id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1 value | code stringlengths 52 85.5k | code_tokens list | docstring stringlengths 6 2.61k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
14,900 | goware/emailx | emailx.go | Validate | func Validate(email string) error {
if len(email) < 6 || len(email) > 254 {
return ErrInvalidFormat
}
at := strings.LastIndex(email, "@")
if at <= 0 || at > len(email)-3 {
return ErrInvalidFormat
}
user := email[:at]
host := email[at+1:]
if len(user) > 64 {
return ErrInvalidFormat
}
if userDotRegexp.MatchString(user) || !userRegexp.MatchString(user) || !hostRegexp.MatchString(host) {
return ErrInvalidFormat
}
switch host {
case "localhost", "example.com":
return nil
}
if _, err := net.LookupMX(host); err != nil {
if _, err := net.LookupIP(host); err != nil {
// Only fail if both MX and A records are missing - any of the
// two is enough for an email to be deliverable
return ErrUnresolvableHost
}
}
return nil
} | go | func Validate(email string) error {
if len(email) < 6 || len(email) > 254 {
return ErrInvalidFormat
}
at := strings.LastIndex(email, "@")
if at <= 0 || at > len(email)-3 {
return ErrInvalidFormat
}
user := email[:at]
host := email[at+1:]
if len(user) > 64 {
return ErrInvalidFormat
}
if userDotRegexp.MatchString(user) || !userRegexp.MatchString(user) || !hostRegexp.MatchString(host) {
return ErrInvalidFormat
}
switch host {
case "localhost", "example.com":
return nil
}
if _, err := net.LookupMX(host); err != nil {
if _, err := net.LookupIP(host); err != nil {
// Only fail if both MX and A records are missing - any of the
// two is enough for an email to be deliverable
return ErrUnresolvableHost
}
}
return nil
} | [
"func",
"Validate",
"(",
"email",
"string",
")",
"error",
"{",
"if",
"len",
"(",
"email",
")",
"<",
"6",
"||",
"len",
"(",
"email",
")",
">",
"254",
"{",
"return",
"ErrInvalidFormat",
"\n",
"}",
"\n\n",
"at",
":=",
"strings",
".",
"LastIndex",
"(",
... | // Validate checks format of a given email and resolves its host name. | [
"Validate",
"checks",
"format",
"of",
"a",
"given",
"email",
"and",
"resolves",
"its",
"host",
"name",
"."
] | 80a00e4677ff2f102e17b78107f255253e2032e5 | https://github.com/goware/emailx/blob/80a00e4677ff2f102e17b78107f255253e2032e5/emailx.go#L24-L58 |
14,901 | goware/emailx | emailx.go | ValidateFast | func ValidateFast(email string) error {
if len(email) < 6 || len(email) > 254 {
return ErrInvalidFormat
}
at := strings.LastIndex(email, "@")
if at <= 0 || at > len(email)-3 {
return ErrInvalidFormat
}
user := email[:at]
host := email[at+1:]
if len(user) > 64 {
return ErrInvalidFormat
}
if userDotRegexp.MatchString(user) || !userRegexp.MatchString(user) || !hostRegexp.MatchString(host) {
return ErrInvalidFormat
}
return nil
} | go | func ValidateFast(email string) error {
if len(email) < 6 || len(email) > 254 {
return ErrInvalidFormat
}
at := strings.LastIndex(email, "@")
if at <= 0 || at > len(email)-3 {
return ErrInvalidFormat
}
user := email[:at]
host := email[at+1:]
if len(user) > 64 {
return ErrInvalidFormat
}
if userDotRegexp.MatchString(user) || !userRegexp.MatchString(user) || !hostRegexp.MatchString(host) {
return ErrInvalidFormat
}
return nil
} | [
"func",
"ValidateFast",
"(",
"email",
"string",
")",
"error",
"{",
"if",
"len",
"(",
"email",
")",
"<",
"6",
"||",
"len",
"(",
"email",
")",
">",
"254",
"{",
"return",
"ErrInvalidFormat",
"\n",
"}",
"\n\n",
"at",
":=",
"strings",
".",
"LastIndex",
"(... | // ValidateFast checks format of a given email. | [
"ValidateFast",
"checks",
"format",
"of",
"a",
"given",
"email",
"."
] | 80a00e4677ff2f102e17b78107f255253e2032e5 | https://github.com/goware/emailx/blob/80a00e4677ff2f102e17b78107f255253e2032e5/emailx.go#L61-L82 |
14,902 | goware/emailx | emailx.go | Normalize | func Normalize(email string) string {
// Trim whitespaces.
email = strings.TrimSpace(email)
// Trim extra dot in hostname.
email = strings.TrimRight(email, ".")
// Lowercase.
email = strings.ToLower(email)
return email
} | go | func Normalize(email string) string {
// Trim whitespaces.
email = strings.TrimSpace(email)
// Trim extra dot in hostname.
email = strings.TrimRight(email, ".")
// Lowercase.
email = strings.ToLower(email)
return email
} | [
"func",
"Normalize",
"(",
"email",
"string",
")",
"string",
"{",
"// Trim whitespaces.",
"email",
"=",
"strings",
".",
"TrimSpace",
"(",
"email",
")",
"\n\n",
"// Trim extra dot in hostname.",
"email",
"=",
"strings",
".",
"TrimRight",
"(",
"email",
",",
"\"",
... | // Normalize normalizes email address. | [
"Normalize",
"normalizes",
"email",
"address",
"."
] | 80a00e4677ff2f102e17b78107f255253e2032e5 | https://github.com/goware/emailx/blob/80a00e4677ff2f102e17b78107f255253e2032e5/emailx.go#L85-L96 |
14,903 | wader/gormstore | gormstore.go | New | func New(db *gorm.DB, keyPairs ...[]byte) *Store {
return NewOptions(db, Options{}, keyPairs...)
} | go | func New(db *gorm.DB, keyPairs ...[]byte) *Store {
return NewOptions(db, Options{}, keyPairs...)
} | [
"func",
"New",
"(",
"db",
"*",
"gorm",
".",
"DB",
",",
"keyPairs",
"...",
"[",
"]",
"byte",
")",
"*",
"Store",
"{",
"return",
"NewOptions",
"(",
"db",
",",
"Options",
"{",
"}",
",",
"keyPairs",
"...",
")",
"\n",
"}"
] | // New creates a new gormstore session | [
"New",
"creates",
"a",
"new",
"gormstore",
"session"
] | acb787ba37557045dc3da46414b50233d49df8bf | https://github.com/wader/gormstore/blob/acb787ba37557045dc3da46414b50233d49df8bf/gormstore.go#L84-L86 |
14,904 | wader/gormstore | gormstore.go | NewOptions | func NewOptions(db *gorm.DB, opts Options, keyPairs ...[]byte) *Store {
st := &Store{
db: db,
opts: opts,
Codecs: securecookie.CodecsFromPairs(keyPairs...),
SessionOpts: &sessions.Options{
Path: defaultPath,
MaxAge: defaultMaxAge,
},
}
if st.opts.TableName == "" {
st.opts.TableName = defaultTableName
}
if !st.opts.SkipCreateTable {
st.db.AutoMigrate(&gormSession{tableName: st.opts.TableName})
}
return st
} | go | func NewOptions(db *gorm.DB, opts Options, keyPairs ...[]byte) *Store {
st := &Store{
db: db,
opts: opts,
Codecs: securecookie.CodecsFromPairs(keyPairs...),
SessionOpts: &sessions.Options{
Path: defaultPath,
MaxAge: defaultMaxAge,
},
}
if st.opts.TableName == "" {
st.opts.TableName = defaultTableName
}
if !st.opts.SkipCreateTable {
st.db.AutoMigrate(&gormSession{tableName: st.opts.TableName})
}
return st
} | [
"func",
"NewOptions",
"(",
"db",
"*",
"gorm",
".",
"DB",
",",
"opts",
"Options",
",",
"keyPairs",
"...",
"[",
"]",
"byte",
")",
"*",
"Store",
"{",
"st",
":=",
"&",
"Store",
"{",
"db",
":",
"db",
",",
"opts",
":",
"opts",
",",
"Codecs",
":",
"se... | // NewOptions creates a new gormstore session with options | [
"NewOptions",
"creates",
"a",
"new",
"gormstore",
"session",
"with",
"options"
] | acb787ba37557045dc3da46414b50233d49df8bf | https://github.com/wader/gormstore/blob/acb787ba37557045dc3da46414b50233d49df8bf/gormstore.go#L89-L108 |
14,905 | wader/gormstore | gormstore.go | Get | func (st *Store) Get(r *http.Request, name string) (*sessions.Session, error) {
return sessions.GetRegistry(r).Get(st, name)
} | go | func (st *Store) Get(r *http.Request, name string) (*sessions.Session, error) {
return sessions.GetRegistry(r).Get(st, name)
} | [
"func",
"(",
"st",
"*",
"Store",
")",
"Get",
"(",
"r",
"*",
"http",
".",
"Request",
",",
"name",
"string",
")",
"(",
"*",
"sessions",
".",
"Session",
",",
"error",
")",
"{",
"return",
"sessions",
".",
"GetRegistry",
"(",
"r",
")",
".",
"Get",
"("... | // Get returns a session for the given name after adding it to the registry. | [
"Get",
"returns",
"a",
"session",
"for",
"the",
"given",
"name",
"after",
"adding",
"it",
"to",
"the",
"registry",
"."
] | acb787ba37557045dc3da46414b50233d49df8bf | https://github.com/wader/gormstore/blob/acb787ba37557045dc3da46414b50233d49df8bf/gormstore.go#L111-L113 |
14,906 | wader/gormstore | gormstore.go | PeriodicCleanup | func (st *Store) PeriodicCleanup(interval time.Duration, quit <-chan struct{}) {
t := time.NewTicker(interval)
defer t.Stop()
for {
select {
case <-t.C:
st.Cleanup()
case <-quit:
return
}
}
} | go | func (st *Store) PeriodicCleanup(interval time.Duration, quit <-chan struct{}) {
t := time.NewTicker(interval)
defer t.Stop()
for {
select {
case <-t.C:
st.Cleanup()
case <-quit:
return
}
}
} | [
"func",
"(",
"st",
"*",
"Store",
")",
"PeriodicCleanup",
"(",
"interval",
"time",
".",
"Duration",
",",
"quit",
"<-",
"chan",
"struct",
"{",
"}",
")",
"{",
"t",
":=",
"time",
".",
"NewTicker",
"(",
"interval",
")",
"\n",
"defer",
"t",
".",
"Stop",
... | // PeriodicCleanup runs Cleanup every interval. Close quit channel to stop. | [
"PeriodicCleanup",
"runs",
"Cleanup",
"every",
"interval",
".",
"Close",
"quit",
"channel",
"to",
"stop",
"."
] | acb787ba37557045dc3da46414b50233d49df8bf | https://github.com/wader/gormstore/blob/acb787ba37557045dc3da46414b50233d49df8bf/gormstore.go#L229-L240 |
14,907 | azer/crud | fields.go | SetDefaultPK | func SetDefaultPK(fields []*Field) {
if HasPK(fields) {
return
}
for i, f := range fields {
if !f.SQL.IsPrimaryKey && f.SQL.Name == "id" && f.SQL.Type == "int" {
fields[i].SQL.IsAutoIncrementing = true
fields[i].SQL.AutoIncrement = 1
fields[i].SQL.IsRequired = true
fields[i].SQL.IsPrimaryKey = true
return
}
}
} | go | func SetDefaultPK(fields []*Field) {
if HasPK(fields) {
return
}
for i, f := range fields {
if !f.SQL.IsPrimaryKey && f.SQL.Name == "id" && f.SQL.Type == "int" {
fields[i].SQL.IsAutoIncrementing = true
fields[i].SQL.AutoIncrement = 1
fields[i].SQL.IsRequired = true
fields[i].SQL.IsPrimaryKey = true
return
}
}
} | [
"func",
"SetDefaultPK",
"(",
"fields",
"[",
"]",
"*",
"Field",
")",
"{",
"if",
"HasPK",
"(",
"fields",
")",
"{",
"return",
"\n",
"}",
"\n\n",
"for",
"i",
",",
"f",
":=",
"range",
"fields",
"{",
"if",
"!",
"f",
".",
"SQL",
".",
"IsPrimaryKey",
"&&... | // If no PK is specified, then set `id` to be PK. | [
"If",
"no",
"PK",
"is",
"specified",
"then",
"set",
"id",
"to",
"be",
"PK",
"."
] | 41b8d890fefaaf6fa14bda0548ee6096a0a164f3 | https://github.com/azer/crud/blob/41b8d890fefaaf6fa14bda0548ee6096a0a164f3/fields.go#L55-L69 |
14,908 | ansel1/merry | print.go | Location | func Location(e error) (file string, line int) {
s := Stack(e)
if len(s) > 0 {
fnc, _ := runtime.CallersFrames(s[:1]).Next()
return fnc.File, fnc.Line
}
return "", 0
} | go | func Location(e error) (file string, line int) {
s := Stack(e)
if len(s) > 0 {
fnc, _ := runtime.CallersFrames(s[:1]).Next()
return fnc.File, fnc.Line
}
return "", 0
} | [
"func",
"Location",
"(",
"e",
"error",
")",
"(",
"file",
"string",
",",
"line",
"int",
")",
"{",
"s",
":=",
"Stack",
"(",
"e",
")",
"\n",
"if",
"len",
"(",
"s",
")",
">",
"0",
"{",
"fnc",
",",
"_",
":=",
"runtime",
".",
"CallersFrames",
"(",
... | // Location returns zero values if e has no stacktrace | [
"Location",
"returns",
"zero",
"values",
"if",
"e",
"has",
"no",
"stacktrace"
] | 4db5a8dcd6e777f88c88819528382e5b1490a1ba | https://github.com/ansel1/merry/blob/4db5a8dcd6e777f88c88819528382e5b1490a1ba/print.go#L61-L68 |
14,909 | ansel1/merry | print.go | SourceLine | func SourceLine(e error) string {
file, line := Location(e)
if line != 0 {
return fmt.Sprintf("%s:%d", file, line)
}
return ""
} | go | func SourceLine(e error) string {
file, line := Location(e)
if line != 0 {
return fmt.Sprintf("%s:%d", file, line)
}
return ""
} | [
"func",
"SourceLine",
"(",
"e",
"error",
")",
"string",
"{",
"file",
",",
"line",
":=",
"Location",
"(",
"e",
")",
"\n",
"if",
"line",
"!=",
"0",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"file",
",",
"line",
")",
"\n",
"}",
"... | // SourceLine returns the string representation of
// Location's result or an empty string if there's
// no stracktrace. | [
"SourceLine",
"returns",
"the",
"string",
"representation",
"of",
"Location",
"s",
"result",
"or",
"an",
"empty",
"string",
"if",
"there",
"s",
"no",
"stracktrace",
"."
] | 4db5a8dcd6e777f88c88819528382e5b1490a1ba | https://github.com/ansel1/merry/blob/4db5a8dcd6e777f88c88819528382e5b1490a1ba/print.go#L73-L79 |
14,910 | ansel1/merry | print.go | Stacktrace | func Stacktrace(e error) string {
s := Stack(e)
if len(s) > 0 {
buf := bytes.Buffer{}
frames := runtime.CallersFrames(s)
for {
frame, more := frames.Next()
buf.WriteString(frame.Function)
buf.WriteString(fmt.Sprintf("\n\t%s:%d\n", frame.File, frame.Line))
if !more {
break
}
}
return buf.String()
}
return ""
} | go | func Stacktrace(e error) string {
s := Stack(e)
if len(s) > 0 {
buf := bytes.Buffer{}
frames := runtime.CallersFrames(s)
for {
frame, more := frames.Next()
buf.WriteString(frame.Function)
buf.WriteString(fmt.Sprintf("\n\t%s:%d\n", frame.File, frame.Line))
if !more {
break
}
}
return buf.String()
}
return ""
} | [
"func",
"Stacktrace",
"(",
"e",
"error",
")",
"string",
"{",
"s",
":=",
"Stack",
"(",
"e",
")",
"\n",
"if",
"len",
"(",
"s",
")",
">",
"0",
"{",
"buf",
":=",
"bytes",
".",
"Buffer",
"{",
"}",
"\n",
"frames",
":=",
"runtime",
".",
"CallersFrames",... | // Stacktrace returns the error's stacktrace as a string formatted
// the same way as golangs runtime package.
// If e has no stacktrace, returns an empty string. | [
"Stacktrace",
"returns",
"the",
"error",
"s",
"stacktrace",
"as",
"a",
"string",
"formatted",
"the",
"same",
"way",
"as",
"golangs",
"runtime",
"package",
".",
"If",
"e",
"has",
"no",
"stacktrace",
"returns",
"an",
"empty",
"string",
"."
] | 4db5a8dcd6e777f88c88819528382e5b1490a1ba | https://github.com/ansel1/merry/blob/4db5a8dcd6e777f88c88819528382e5b1490a1ba/print.go#L84-L101 |
14,911 | ansel1/merry | errors.go | WithValue | func WithValue(e error, key, value interface{}) Error {
if e == nil {
return nil
}
return WrapSkipping(e, 1).WithValue(key, value)
} | go | func WithValue(e error, key, value interface{}) Error {
if e == nil {
return nil
}
return WrapSkipping(e, 1).WithValue(key, value)
} | [
"func",
"WithValue",
"(",
"e",
"error",
",",
"key",
",",
"value",
"interface",
"{",
"}",
")",
"Error",
"{",
"if",
"e",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"WrapSkipping",
"(",
"e",
",",
"1",
")",
".",
"WithValue",
"(",
"... | // WithValue adds a context an error. If the key was already set on e,
// the new value will take precedence.
// If e is nil, returns nil. | [
"WithValue",
"adds",
"a",
"context",
"an",
"error",
".",
"If",
"the",
"key",
"was",
"already",
"set",
"on",
"e",
"the",
"new",
"value",
"will",
"take",
"precedence",
".",
"If",
"e",
"is",
"nil",
"returns",
"nil",
"."
] | 4db5a8dcd6e777f88c88819528382e5b1490a1ba | https://github.com/ansel1/merry/blob/4db5a8dcd6e777f88c88819528382e5b1490a1ba/errors.go#L144-L149 |
14,912 | ansel1/merry | errors.go | Value | func Value(e error, key interface{}) interface{} {
for {
switch m := e.(type) {
case nil:
return nil
case *merryErr:
if m.key == key {
return m.value
}
e = m.err
default:
return nil
}
}
} | go | func Value(e error, key interface{}) interface{} {
for {
switch m := e.(type) {
case nil:
return nil
case *merryErr:
if m.key == key {
return m.value
}
e = m.err
default:
return nil
}
}
} | [
"func",
"Value",
"(",
"e",
"error",
",",
"key",
"interface",
"{",
"}",
")",
"interface",
"{",
"}",
"{",
"for",
"{",
"switch",
"m",
":=",
"e",
".",
"(",
"type",
")",
"{",
"case",
"nil",
":",
"return",
"nil",
"\n",
"case",
"*",
"merryErr",
":",
"... | // Value returns the value for key, or nil if not set.
// If e is nil, returns nil. | [
"Value",
"returns",
"the",
"value",
"for",
"key",
"or",
"nil",
"if",
"not",
"set",
".",
"If",
"e",
"is",
"nil",
"returns",
"nil",
"."
] | 4db5a8dcd6e777f88c88819528382e5b1490a1ba | https://github.com/ansel1/merry/blob/4db5a8dcd6e777f88c88819528382e5b1490a1ba/errors.go#L153-L167 |
14,913 | ansel1/merry | errors.go | Values | func Values(e error) map[interface{}]interface{} {
if e == nil {
return nil
}
var values map[interface{}]interface{}
for {
w, ok := e.(*merryErr)
if !ok {
return values
}
if values == nil {
values = make(map[interface{}]interface{}, 1)
}
if _, ok := values[w.key]; !ok {
values[w.key] = w.value
}
e = w.err
}
} | go | func Values(e error) map[interface{}]interface{} {
if e == nil {
return nil
}
var values map[interface{}]interface{}
for {
w, ok := e.(*merryErr)
if !ok {
return values
}
if values == nil {
values = make(map[interface{}]interface{}, 1)
}
if _, ok := values[w.key]; !ok {
values[w.key] = w.value
}
e = w.err
}
} | [
"func",
"Values",
"(",
"e",
"error",
")",
"map",
"[",
"interface",
"{",
"}",
"]",
"interface",
"{",
"}",
"{",
"if",
"e",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"var",
"values",
"map",
"[",
"interface",
"{",
"}",
"]",
"interface",
"{"... | // Values returns a map of all values attached to the error
// If a key has been attached multiple times, the map will
// contain the last value mapped
// If e is nil, returns nil. | [
"Values",
"returns",
"a",
"map",
"of",
"all",
"values",
"attached",
"to",
"the",
"error",
"If",
"a",
"key",
"has",
"been",
"attached",
"multiple",
"times",
"the",
"map",
"will",
"contain",
"the",
"last",
"value",
"mapped",
"If",
"e",
"is",
"nil",
"return... | 4db5a8dcd6e777f88c88819528382e5b1490a1ba | https://github.com/ansel1/merry/blob/4db5a8dcd6e777f88c88819528382e5b1490a1ba/errors.go#L173-L191 |
14,914 | ansel1/merry | errors.go | Stack | func Stack(e error) []uintptr {
stack, _ := Value(e, stack).([]uintptr)
return stack
} | go | func Stack(e error) []uintptr {
stack, _ := Value(e, stack).([]uintptr)
return stack
} | [
"func",
"Stack",
"(",
"e",
"error",
")",
"[",
"]",
"uintptr",
"{",
"stack",
",",
"_",
":=",
"Value",
"(",
"e",
",",
"stack",
")",
".",
"(",
"[",
"]",
"uintptr",
")",
"\n",
"return",
"stack",
"\n",
"}"
] | // Stack returns the stack attached to an error, or nil if one is not attached
// If e is nil, returns nil. | [
"Stack",
"returns",
"the",
"stack",
"attached",
"to",
"an",
"error",
"or",
"nil",
"if",
"one",
"is",
"not",
"attached",
"If",
"e",
"is",
"nil",
"returns",
"nil",
"."
] | 4db5a8dcd6e777f88c88819528382e5b1490a1ba | https://github.com/ansel1/merry/blob/4db5a8dcd6e777f88c88819528382e5b1490a1ba/errors.go#L216-L219 |
14,915 | ansel1/merry | errors.go | WithHTTPCode | func WithHTTPCode(e error, code int) Error {
if e == nil {
return nil
}
return WrapSkipping(e, 1).WithHTTPCode(code)
} | go | func WithHTTPCode(e error, code int) Error {
if e == nil {
return nil
}
return WrapSkipping(e, 1).WithHTTPCode(code)
} | [
"func",
"WithHTTPCode",
"(",
"e",
"error",
",",
"code",
"int",
")",
"Error",
"{",
"if",
"e",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"WrapSkipping",
"(",
"e",
",",
"1",
")",
".",
"WithHTTPCode",
"(",
"code",
")",
"\n",
"}"
] | // WithHTTPCode returns an error with an http code attached.
// If e is nil, returns nil. | [
"WithHTTPCode",
"returns",
"an",
"error",
"with",
"an",
"http",
"code",
"attached",
".",
"If",
"e",
"is",
"nil",
"returns",
"nil",
"."
] | 4db5a8dcd6e777f88c88819528382e5b1490a1ba | https://github.com/ansel1/merry/blob/4db5a8dcd6e777f88c88819528382e5b1490a1ba/errors.go#L223-L228 |
14,916 | ansel1/merry | errors.go | HTTPCode | func HTTPCode(e error) int {
if e == nil {
return 200
}
code, _ := Value(e, httpCode).(int)
if code == 0 {
return 500
}
return code
} | go | func HTTPCode(e error) int {
if e == nil {
return 200
}
code, _ := Value(e, httpCode).(int)
if code == 0 {
return 500
}
return code
} | [
"func",
"HTTPCode",
"(",
"e",
"error",
")",
"int",
"{",
"if",
"e",
"==",
"nil",
"{",
"return",
"200",
"\n",
"}",
"\n",
"code",
",",
"_",
":=",
"Value",
"(",
"e",
",",
"httpCode",
")",
".",
"(",
"int",
")",
"\n",
"if",
"code",
"==",
"0",
"{",
... | // HTTPCode converts an error to an http status code. All errors
// map to 500, unless the error has an http code attached.
// If e is nil, returns 200. | [
"HTTPCode",
"converts",
"an",
"error",
"to",
"an",
"http",
"status",
"code",
".",
"All",
"errors",
"map",
"to",
"500",
"unless",
"the",
"error",
"has",
"an",
"http",
"code",
"attached",
".",
"If",
"e",
"is",
"nil",
"returns",
"200",
"."
] | 4db5a8dcd6e777f88c88819528382e5b1490a1ba | https://github.com/ansel1/merry/blob/4db5a8dcd6e777f88c88819528382e5b1490a1ba/errors.go#L233-L242 |
14,917 | ansel1/merry | errors.go | UserMessage | func UserMessage(e error) string {
if e == nil {
return ""
}
msg, _ := Value(e, userMessage).(string)
return msg
} | go | func UserMessage(e error) string {
if e == nil {
return ""
}
msg, _ := Value(e, userMessage).(string)
return msg
} | [
"func",
"UserMessage",
"(",
"e",
"error",
")",
"string",
"{",
"if",
"e",
"==",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"msg",
",",
"_",
":=",
"Value",
"(",
"e",
",",
"userMessage",
")",
".",
"(",
"string",
")",
"\n",
"return",
"msg",
... | // UserMessage returns the end-user safe message. Returns empty if not set.
// If e is nil, returns "". | [
"UserMessage",
"returns",
"the",
"end",
"-",
"user",
"safe",
"message",
".",
"Returns",
"empty",
"if",
"not",
"set",
".",
"If",
"e",
"is",
"nil",
"returns",
"."
] | 4db5a8dcd6e777f88c88819528382e5b1490a1ba | https://github.com/ansel1/merry/blob/4db5a8dcd6e777f88c88819528382e5b1490a1ba/errors.go#L246-L252 |
14,918 | ansel1/merry | errors.go | Cause | func Cause(e error) error {
if e == nil {
return nil
}
c, _ := Value(e, cause).(error)
return c
} | go | func Cause(e error) error {
if e == nil {
return nil
}
c, _ := Value(e, cause).(error)
return c
} | [
"func",
"Cause",
"(",
"e",
"error",
")",
"error",
"{",
"if",
"e",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"c",
",",
"_",
":=",
"Value",
"(",
"e",
",",
"cause",
")",
".",
"(",
"error",
")",
"\n",
"return",
"c",
"\n",
"}"
] | // Cause returns the cause of the argument. If e is nil, or has no cause,
// nil is returned. | [
"Cause",
"returns",
"the",
"cause",
"of",
"the",
"argument",
".",
"If",
"e",
"is",
"nil",
"or",
"has",
"no",
"cause",
"nil",
"is",
"returned",
"."
] | 4db5a8dcd6e777f88c88819528382e5b1490a1ba | https://github.com/ansel1/merry/blob/4db5a8dcd6e777f88c88819528382e5b1490a1ba/errors.go#L277-L283 |
14,919 | ansel1/merry | errors.go | WithCause | func WithCause(e error, cause error) Error {
if e == nil {
return nil
}
return WrapSkipping(e, 1).WithCause(cause)
} | go | func WithCause(e error, cause error) Error {
if e == nil {
return nil
}
return WrapSkipping(e, 1).WithCause(cause)
} | [
"func",
"WithCause",
"(",
"e",
"error",
",",
"cause",
"error",
")",
"Error",
"{",
"if",
"e",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"WrapSkipping",
"(",
"e",
",",
"1",
")",
".",
"WithCause",
"(",
"cause",
")",
"\n",
"}"
] | // WithCause returns an error based on the first argument, with the cause
// set to the second argument. If e is nil, returns nil. | [
"WithCause",
"returns",
"an",
"error",
"based",
"on",
"the",
"first",
"argument",
"with",
"the",
"cause",
"set",
"to",
"the",
"second",
"argument",
".",
"If",
"e",
"is",
"nil",
"returns",
"nil",
"."
] | 4db5a8dcd6e777f88c88819528382e5b1490a1ba | https://github.com/ansel1/merry/blob/4db5a8dcd6e777f88c88819528382e5b1490a1ba/errors.go#L304-L309 |
14,920 | ansel1/merry | errors.go | WithUserMessage | func WithUserMessage(e error, msg string) Error {
if e == nil {
return nil
}
return WrapSkipping(e, 1).WithUserMessage(msg)
} | go | func WithUserMessage(e error, msg string) Error {
if e == nil {
return nil
}
return WrapSkipping(e, 1).WithUserMessage(msg)
} | [
"func",
"WithUserMessage",
"(",
"e",
"error",
",",
"msg",
"string",
")",
"Error",
"{",
"if",
"e",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"WrapSkipping",
"(",
"e",
",",
"1",
")",
".",
"WithUserMessage",
"(",
"msg",
")",
"\n",
... | // WithUserMessage adds a message which is suitable for end users to see.
// If e is nil, returns nil. | [
"WithUserMessage",
"adds",
"a",
"message",
"which",
"is",
"suitable",
"for",
"end",
"users",
"to",
"see",
".",
"If",
"e",
"is",
"nil",
"returns",
"nil",
"."
] | 4db5a8dcd6e777f88c88819528382e5b1490a1ba | https://github.com/ansel1/merry/blob/4db5a8dcd6e777f88c88819528382e5b1490a1ba/errors.go#L332-L337 |
14,921 | ansel1/merry | errors.go | Unwrap | func Unwrap(e error) error {
if e == nil {
return nil
}
for {
w, ok := e.(*merryErr)
if !ok {
return e
}
e = w.err
}
} | go | func Unwrap(e error) error {
if e == nil {
return nil
}
for {
w, ok := e.(*merryErr)
if !ok {
return e
}
e = w.err
}
} | [
"func",
"Unwrap",
"(",
"e",
"error",
")",
"error",
"{",
"if",
"e",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"for",
"{",
"w",
",",
"ok",
":=",
"e",
".",
"(",
"*",
"merryErr",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"e",
"\n",
"... | // Unwrap returns the innermost underlying error.
// Only useful in advanced cases, like if you need to
// cast the underlying error to some type to get
// additional information from it.
// If e == nil, return nil. | [
"Unwrap",
"returns",
"the",
"innermost",
"underlying",
"error",
".",
"Only",
"useful",
"in",
"advanced",
"cases",
"like",
"if",
"you",
"need",
"to",
"cast",
"the",
"underlying",
"error",
"to",
"some",
"type",
"to",
"get",
"additional",
"information",
"from",
... | 4db5a8dcd6e777f88c88819528382e5b1490a1ba | https://github.com/ansel1/merry/blob/4db5a8dcd6e777f88c88819528382e5b1490a1ba/errors.go#L446-L457 |
14,922 | ansel1/merry | errors.go | Error | func (e *merryErr) Error() string {
if verbose {
return Details(e)
}
m := Message(e)
if m == "" {
m = UserMessage(e)
}
// add cause
if c := Cause(e); c != nil {
if ce := c.Error(); ce != "" {
m += ": " + ce
}
}
return m
} | go | func (e *merryErr) Error() string {
if verbose {
return Details(e)
}
m := Message(e)
if m == "" {
m = UserMessage(e)
}
// add cause
if c := Cause(e); c != nil {
if ce := c.Error(); ce != "" {
m += ": " + ce
}
}
return m
} | [
"func",
"(",
"e",
"*",
"merryErr",
")",
"Error",
"(",
")",
"string",
"{",
"if",
"verbose",
"{",
"return",
"Details",
"(",
"e",
")",
"\n",
"}",
"\n",
"m",
":=",
"Message",
"(",
"e",
")",
"\n",
"if",
"m",
"==",
"\"",
"\"",
"{",
"m",
"=",
"UserM... | // Error implements golang's error interface
// returns the message value if set, otherwise
// delegates to inner error | [
"Error",
"implements",
"golang",
"s",
"error",
"interface",
"returns",
"the",
"message",
"value",
"if",
"set",
"otherwise",
"delegates",
"to",
"inner",
"error"
] | 4db5a8dcd6e777f88c88819528382e5b1490a1ba | https://github.com/ansel1/merry/blob/4db5a8dcd6e777f88c88819528382e5b1490a1ba/errors.go#L505-L520 |
14,923 | ansel1/merry | errors.go | WithValue | func (e *merryErr) WithValue(key, value interface{}) Error {
if e == nil {
return nil
}
return &merryErr{
err: e,
key: key,
value: value,
}
} | go | func (e *merryErr) WithValue(key, value interface{}) Error {
if e == nil {
return nil
}
return &merryErr{
err: e,
key: key,
value: value,
}
} | [
"func",
"(",
"e",
"*",
"merryErr",
")",
"WithValue",
"(",
"key",
",",
"value",
"interface",
"{",
"}",
")",
"Error",
"{",
"if",
"e",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"&",
"merryErr",
"{",
"err",
":",
"e",
",",
"key",
... | // return a new error with additional context | [
"return",
"a",
"new",
"error",
"with",
"additional",
"context"
] | 4db5a8dcd6e777f88c88819528382e5b1490a1ba | https://github.com/ansel1/merry/blob/4db5a8dcd6e777f88c88819528382e5b1490a1ba/errors.go#L523-L532 |
14,924 | ansel1/merry | errors.go | WithStackSkipping | func (e *merryErr) WithStackSkipping(skip int) Error {
if e == nil {
return nil
}
return &merryErr{
err: e,
key: stack,
value: captureStack(skip + 1),
}
} | go | func (e *merryErr) WithStackSkipping(skip int) Error {
if e == nil {
return nil
}
return &merryErr{
err: e,
key: stack,
value: captureStack(skip + 1),
}
} | [
"func",
"(",
"e",
"*",
"merryErr",
")",
"WithStackSkipping",
"(",
"skip",
"int",
")",
"Error",
"{",
"if",
"e",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"&",
"merryErr",
"{",
"err",
":",
"e",
",",
"key",
":",
"stack",
",",
"va... | // return a new error with a new stack capture | [
"return",
"a",
"new",
"error",
"with",
"a",
"new",
"stack",
"capture"
] | 4db5a8dcd6e777f88c88819528382e5b1490a1ba | https://github.com/ansel1/merry/blob/4db5a8dcd6e777f88c88819528382e5b1490a1ba/errors.go#L543-L552 |
14,925 | ansel1/merry | errors.go | WithHTTPCode | func (e *merryErr) WithHTTPCode(code int) Error {
if e == nil {
return nil
}
return e.WithValue(httpCode, code)
} | go | func (e *merryErr) WithHTTPCode(code int) Error {
if e == nil {
return nil
}
return e.WithValue(httpCode, code)
} | [
"func",
"(",
"e",
"*",
"merryErr",
")",
"WithHTTPCode",
"(",
"code",
"int",
")",
"Error",
"{",
"if",
"e",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"e",
".",
"WithValue",
"(",
"httpCode",
",",
"code",
")",
"\n",
"}"
] | // return a new error with an http status code attached | [
"return",
"a",
"new",
"error",
"with",
"an",
"http",
"status",
"code",
"attached"
] | 4db5a8dcd6e777f88c88819528382e5b1490a1ba | https://github.com/ansel1/merry/blob/4db5a8dcd6e777f88c88819528382e5b1490a1ba/errors.go#L555-L560 |
14,926 | ansel1/merry | errors.go | WithMessage | func (e *merryErr) WithMessage(msg string) Error {
if e == nil {
return nil
}
return e.WithValue(message, msg)
} | go | func (e *merryErr) WithMessage(msg string) Error {
if e == nil {
return nil
}
return e.WithValue(message, msg)
} | [
"func",
"(",
"e",
"*",
"merryErr",
")",
"WithMessage",
"(",
"msg",
"string",
")",
"Error",
"{",
"if",
"e",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"e",
".",
"WithValue",
"(",
"message",
",",
"msg",
")",
"\n",
"}"
] | // return a new error with a new message | [
"return",
"a",
"new",
"error",
"with",
"a",
"new",
"message"
] | 4db5a8dcd6e777f88c88819528382e5b1490a1ba | https://github.com/ansel1/merry/blob/4db5a8dcd6e777f88c88819528382e5b1490a1ba/errors.go#L563-L568 |
14,927 | ansel1/merry | errors.go | WithMessagef | func (e *merryErr) WithMessagef(format string, a ...interface{}) Error {
if e == nil {
return nil
}
return e.WithMessage(fmt.Sprintf(format, a...))
} | go | func (e *merryErr) WithMessagef(format string, a ...interface{}) Error {
if e == nil {
return nil
}
return e.WithMessage(fmt.Sprintf(format, a...))
} | [
"func",
"(",
"e",
"*",
"merryErr",
")",
"WithMessagef",
"(",
"format",
"string",
",",
"a",
"...",
"interface",
"{",
"}",
")",
"Error",
"{",
"if",
"e",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"e",
".",
"WithMessage",
"(",
"fmt"... | // return a new error with a new formatted message | [
"return",
"a",
"new",
"error",
"with",
"a",
"new",
"formatted",
"message"
] | 4db5a8dcd6e777f88c88819528382e5b1490a1ba | https://github.com/ansel1/merry/blob/4db5a8dcd6e777f88c88819528382e5b1490a1ba/errors.go#L571-L576 |
14,928 | ansel1/merry | errors.go | WithCause | func (e *merryErr) WithCause(err error) Error {
if e == nil || err == nil {
return e
}
return e.WithValue(cause, err)
} | go | func (e *merryErr) WithCause(err error) Error {
if e == nil || err == nil {
return e
}
return e.WithValue(cause, err)
} | [
"func",
"(",
"e",
"*",
"merryErr",
")",
"WithCause",
"(",
"err",
"error",
")",
"Error",
"{",
"if",
"e",
"==",
"nil",
"||",
"err",
"==",
"nil",
"{",
"return",
"e",
"\n",
"}",
"\n",
"return",
"e",
".",
"WithValue",
"(",
"cause",
",",
"err",
")",
... | // WithCause returns an error based on the receiver, with the cause
// set to the argument. | [
"WithCause",
"returns",
"an",
"error",
"based",
"on",
"the",
"receiver",
"with",
"the",
"cause",
"set",
"to",
"the",
"argument",
"."
] | 4db5a8dcd6e777f88c88819528382e5b1490a1ba | https://github.com/ansel1/merry/blob/4db5a8dcd6e777f88c88819528382e5b1490a1ba/errors.go#L628-L633 |
14,929 | containerd/fifo | raw.go | SyscallConn | func (f *fifo) SyscallConn() (syscall.RawConn, error) {
// deterministic check for closed
select {
case <-f.closed:
return nil, errors.New("fifo closed")
default:
}
select {
case <-f.closed:
return nil, errors.New("fifo closed")
case <-f.opened:
return f.file.SyscallConn()
default:
}
// Not opened and not closed, this means open is non-blocking AND it's not open yet
// Use rawConn to deal with non-blocking open.
rc := &rawConn{f: f, ready: make(chan struct{})}
go func() {
select {
case <-f.closed:
return
case <-f.opened:
rc.raw, rc.err = f.file.SyscallConn()
close(rc.ready)
}
}()
return rc, nil
} | go | func (f *fifo) SyscallConn() (syscall.RawConn, error) {
// deterministic check for closed
select {
case <-f.closed:
return nil, errors.New("fifo closed")
default:
}
select {
case <-f.closed:
return nil, errors.New("fifo closed")
case <-f.opened:
return f.file.SyscallConn()
default:
}
// Not opened and not closed, this means open is non-blocking AND it's not open yet
// Use rawConn to deal with non-blocking open.
rc := &rawConn{f: f, ready: make(chan struct{})}
go func() {
select {
case <-f.closed:
return
case <-f.opened:
rc.raw, rc.err = f.file.SyscallConn()
close(rc.ready)
}
}()
return rc, nil
} | [
"func",
"(",
"f",
"*",
"fifo",
")",
"SyscallConn",
"(",
")",
"(",
"syscall",
".",
"RawConn",
",",
"error",
")",
"{",
"// deterministic check for closed",
"select",
"{",
"case",
"<-",
"f",
".",
"closed",
":",
"return",
"nil",
",",
"errors",
".",
"New",
... | // SyscallConn provides raw access to the fifo's underlying filedescrptor.
// See syscall.Conn for guarentees provided by this interface. | [
"SyscallConn",
"provides",
"raw",
"access",
"to",
"the",
"fifo",
"s",
"underlying",
"filedescrptor",
".",
"See",
"syscall",
".",
"Conn",
"for",
"guarentees",
"provided",
"by",
"this",
"interface",
"."
] | a9fb20d87448d386e6d50b1f2e1fa70dcf0de43c | https://github.com/containerd/fifo/blob/a9fb20d87448d386e6d50b1f2e1fa70dcf0de43c/raw.go#L29-L59 |
14,930 | biogo/hts | sam/program.go | NewProgram | func NewProgram(uid, name, command, prev, v string) *Program {
return &Program{
id: -1,
uid: uid,
previous: prev,
name: name,
command: command,
version: v,
}
} | go | func NewProgram(uid, name, command, prev, v string) *Program {
return &Program{
id: -1,
uid: uid,
previous: prev,
name: name,
command: command,
version: v,
}
} | [
"func",
"NewProgram",
"(",
"uid",
",",
"name",
",",
"command",
",",
"prev",
",",
"v",
"string",
")",
"*",
"Program",
"{",
"return",
"&",
"Program",
"{",
"id",
":",
"-",
"1",
",",
"uid",
":",
"uid",
",",
"previous",
":",
"prev",
",",
"name",
":",
... | // NewProgram returns a Program with the given unique ID, name, command,
// previous program ID in the pipeline and version. | [
"NewProgram",
"returns",
"a",
"Program",
"with",
"the",
"given",
"unique",
"ID",
"name",
"command",
"previous",
"program",
"ID",
"in",
"the",
"pipeline",
"and",
"version",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/sam/program.go#L27-L36 |
14,931 | biogo/hts | sam/program.go | SetUID | func (r *Program) SetUID(uid string) error {
if r.owner != nil {
id, exists := r.owner.seenProgs[uid]
if exists {
if id != r.id {
return errors.New("sam: uid exists")
}
return nil
}
delete(r.owner.seenProgs, r.uid)
r.owner.seenProgs[uid] = r.id
}
r.uid = uid
return nil
} | go | func (r *Program) SetUID(uid string) error {
if r.owner != nil {
id, exists := r.owner.seenProgs[uid]
if exists {
if id != r.id {
return errors.New("sam: uid exists")
}
return nil
}
delete(r.owner.seenProgs, r.uid)
r.owner.seenProgs[uid] = r.id
}
r.uid = uid
return nil
} | [
"func",
"(",
"r",
"*",
"Program",
")",
"SetUID",
"(",
"uid",
"string",
")",
"error",
"{",
"if",
"r",
".",
"owner",
"!=",
"nil",
"{",
"id",
",",
"exists",
":=",
"r",
".",
"owner",
".",
"seenProgs",
"[",
"uid",
"]",
"\n",
"if",
"exists",
"{",
"if... | // SetUID sets the unique program ID to uid. | [
"SetUID",
"sets",
"the",
"unique",
"program",
"ID",
"to",
"uid",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/sam/program.go#L55-L69 |
14,932 | biogo/hts | sam/program.go | Clone | func (p *Program) Clone() *Program {
if p == nil {
return nil
}
cp := *p
if len(cp.otherTags) != 0 {
cp.otherTags = make([]tagPair, len(cp.otherTags))
}
copy(cp.otherTags, p.otherTags)
cp.id = -1
cp.owner = nil
return &cp
} | go | func (p *Program) Clone() *Program {
if p == nil {
return nil
}
cp := *p
if len(cp.otherTags) != 0 {
cp.otherTags = make([]tagPair, len(cp.otherTags))
}
copy(cp.otherTags, p.otherTags)
cp.id = -1
cp.owner = nil
return &cp
} | [
"func",
"(",
"p",
"*",
"Program",
")",
"Clone",
"(",
")",
"*",
"Program",
"{",
"if",
"p",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"cp",
":=",
"*",
"p",
"\n",
"if",
"len",
"(",
"cp",
".",
"otherTags",
")",
"!=",
"0",
"{",
"cp",
"... | // Clone returns a deep copy of the Program. | [
"Clone",
"returns",
"a",
"deep",
"copy",
"of",
"the",
"Program",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/sam/program.go#L104-L116 |
14,933 | biogo/hts | sam/program.go | Tags | func (p *Program) Tags(fn func(t Tag, value string)) {
if fn == nil {
return
}
fn(idTag, p.UID())
if p.name != "" {
fn(programNameTag, p.name)
}
if p.command != "" {
fn(commandLineTag, p.command)
}
if p.previous != "" {
fn(previousProgTag, p.previous)
}
if p.version != "" {
fn(versionTag, p.version)
}
for _, tp := range p.otherTags {
fn(tp.tag, tp.value)
}
} | go | func (p *Program) Tags(fn func(t Tag, value string)) {
if fn == nil {
return
}
fn(idTag, p.UID())
if p.name != "" {
fn(programNameTag, p.name)
}
if p.command != "" {
fn(commandLineTag, p.command)
}
if p.previous != "" {
fn(previousProgTag, p.previous)
}
if p.version != "" {
fn(versionTag, p.version)
}
for _, tp := range p.otherTags {
fn(tp.tag, tp.value)
}
} | [
"func",
"(",
"p",
"*",
"Program",
")",
"Tags",
"(",
"fn",
"func",
"(",
"t",
"Tag",
",",
"value",
"string",
")",
")",
"{",
"if",
"fn",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"fn",
"(",
"idTag",
",",
"p",
".",
"UID",
"(",
")",
")",
"\n"... | // Tags applies the function fn to each of the tag-value pairs of the Program.
// The function fn must not add or delete tags held by the receiver during
// iteration. | [
"Tags",
"applies",
"the",
"function",
"fn",
"to",
"each",
"of",
"the",
"tag",
"-",
"value",
"pairs",
"of",
"the",
"Program",
".",
"The",
"function",
"fn",
"must",
"not",
"add",
"or",
"delete",
"tags",
"held",
"by",
"the",
"receiver",
"during",
"iteration... | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/sam/program.go#L121-L141 |
14,934 | biogo/hts | sam/program.go | Get | func (p *Program) Get(t Tag) string {
switch t {
case idTag:
return p.UID()
case programNameTag:
return p.Name()
case commandLineTag:
return p.Command()
case previousProgTag:
return p.Previous()
case versionTag:
return p.Version()
}
for _, tp := range p.otherTags {
if t == tp.tag {
return tp.value
}
}
return ""
} | go | func (p *Program) Get(t Tag) string {
switch t {
case idTag:
return p.UID()
case programNameTag:
return p.Name()
case commandLineTag:
return p.Command()
case previousProgTag:
return p.Previous()
case versionTag:
return p.Version()
}
for _, tp := range p.otherTags {
if t == tp.tag {
return tp.value
}
}
return ""
} | [
"func",
"(",
"p",
"*",
"Program",
")",
"Get",
"(",
"t",
"Tag",
")",
"string",
"{",
"switch",
"t",
"{",
"case",
"idTag",
":",
"return",
"p",
".",
"UID",
"(",
")",
"\n",
"case",
"programNameTag",
":",
"return",
"p",
".",
"Name",
"(",
")",
"\n",
"... | // Get returns the string representation of the value associated with the
// given program line tag. If the tag is not present the empty string is returned. | [
"Get",
"returns",
"the",
"string",
"representation",
"of",
"the",
"value",
"associated",
"with",
"the",
"given",
"program",
"line",
"tag",
".",
"If",
"the",
"tag",
"is",
"not",
"present",
"the",
"empty",
"string",
"is",
"returned",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/sam/program.go#L145-L164 |
14,935 | biogo/hts | sam/program.go | Set | func (p *Program) Set(t Tag, value string) error {
switch t {
case idTag:
if value == "" {
return errDupProgram
}
case programNameTag:
p.name = value
case commandLineTag:
p.command = value
case previousProgTag:
p.previous = value
case versionTag:
p.version = value
default:
if value == "" {
for i, tp := range p.otherTags {
if t == tp.tag {
copy(p.otherTags[i:], p.otherTags[i+1:])
p.otherTags = p.otherTags[:len(p.otherTags)-1]
return nil
}
}
} else {
for i, tp := range p.otherTags {
if t == tp.tag {
p.otherTags[i].value = value
return nil
}
}
p.otherTags = append(p.otherTags, tagPair{tag: t, value: value})
}
}
return nil
} | go | func (p *Program) Set(t Tag, value string) error {
switch t {
case idTag:
if value == "" {
return errDupProgram
}
case programNameTag:
p.name = value
case commandLineTag:
p.command = value
case previousProgTag:
p.previous = value
case versionTag:
p.version = value
default:
if value == "" {
for i, tp := range p.otherTags {
if t == tp.tag {
copy(p.otherTags[i:], p.otherTags[i+1:])
p.otherTags = p.otherTags[:len(p.otherTags)-1]
return nil
}
}
} else {
for i, tp := range p.otherTags {
if t == tp.tag {
p.otherTags[i].value = value
return nil
}
}
p.otherTags = append(p.otherTags, tagPair{tag: t, value: value})
}
}
return nil
} | [
"func",
"(",
"p",
"*",
"Program",
")",
"Set",
"(",
"t",
"Tag",
",",
"value",
"string",
")",
"error",
"{",
"switch",
"t",
"{",
"case",
"idTag",
":",
"if",
"value",
"==",
"\"",
"\"",
"{",
"return",
"errDupProgram",
"\n",
"}",
"\n",
"case",
"programNa... | // Set sets the value associated with the given program line tag to the specified
// value. If value is the empty string and the tag may be absent, it is deleted. | [
"Set",
"sets",
"the",
"value",
"associated",
"with",
"the",
"given",
"program",
"line",
"tag",
"to",
"the",
"specified",
"value",
".",
"If",
"value",
"is",
"the",
"empty",
"string",
"and",
"the",
"tag",
"may",
"be",
"absent",
"it",
"is",
"deleted",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/sam/program.go#L168-L202 |
14,936 | biogo/hts | sam/program.go | String | func (p *Program) String() string {
var buf bytes.Buffer
fmt.Fprintf(&buf, "@PG\tID:%s", p.uid)
if p.name != "" {
fmt.Fprintf(&buf, "\tPN:%s", p.name)
}
if p.command != "" {
fmt.Fprintf(&buf, "\tCL:%s", p.command)
}
if p.previous != "" {
fmt.Fprintf(&buf, "\tPP:%s", p.previous)
}
if p.version != "" {
fmt.Fprintf(&buf, "\tVN:%s", p.version)
}
for _, tp := range p.otherTags {
fmt.Fprintf(&buf, "\t%s:%s", tp.tag, tp.value)
}
return buf.String()
} | go | func (p *Program) String() string {
var buf bytes.Buffer
fmt.Fprintf(&buf, "@PG\tID:%s", p.uid)
if p.name != "" {
fmt.Fprintf(&buf, "\tPN:%s", p.name)
}
if p.command != "" {
fmt.Fprintf(&buf, "\tCL:%s", p.command)
}
if p.previous != "" {
fmt.Fprintf(&buf, "\tPP:%s", p.previous)
}
if p.version != "" {
fmt.Fprintf(&buf, "\tVN:%s", p.version)
}
for _, tp := range p.otherTags {
fmt.Fprintf(&buf, "\t%s:%s", tp.tag, tp.value)
}
return buf.String()
} | [
"func",
"(",
"p",
"*",
"Program",
")",
"String",
"(",
")",
"string",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"fmt",
".",
"Fprintf",
"(",
"&",
"buf",
",",
"\"",
"\\t",
"\"",
",",
"p",
".",
"uid",
")",
"\n",
"if",
"p",
".",
"name",
"!=... | // String returns a string representation of the program according to the
// SAM specification section 1.3, | [
"String",
"returns",
"a",
"string",
"representation",
"of",
"the",
"program",
"according",
"to",
"the",
"SAM",
"specification",
"section",
"1",
".",
"3"
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/sam/program.go#L206-L225 |
14,937 | biogo/hts | sam/cigar.go | IsValid | func (c Cigar) IsValid(length int) bool {
var pos int
for i, co := range c {
ct := co.Type()
if ct == CigarHardClipped && i != 0 && i != len(c)-1 {
return false
}
if ct == CigarSoftClipped && i != 0 && i != len(c)-1 {
if c[i-1].Type() != CigarHardClipped && c[i+1].Type() != CigarHardClipped {
return false
}
}
con := ct.Consumes()
if pos < 0 && con.Query != 0 {
return false
}
length -= co.Len() * con.Query
pos += co.Len() * con.Reference
}
return length == 0
} | go | func (c Cigar) IsValid(length int) bool {
var pos int
for i, co := range c {
ct := co.Type()
if ct == CigarHardClipped && i != 0 && i != len(c)-1 {
return false
}
if ct == CigarSoftClipped && i != 0 && i != len(c)-1 {
if c[i-1].Type() != CigarHardClipped && c[i+1].Type() != CigarHardClipped {
return false
}
}
con := ct.Consumes()
if pos < 0 && con.Query != 0 {
return false
}
length -= co.Len() * con.Query
pos += co.Len() * con.Reference
}
return length == 0
} | [
"func",
"(",
"c",
"Cigar",
")",
"IsValid",
"(",
"length",
"int",
")",
"bool",
"{",
"var",
"pos",
"int",
"\n",
"for",
"i",
",",
"co",
":=",
"range",
"c",
"{",
"ct",
":=",
"co",
".",
"Type",
"(",
")",
"\n",
"if",
"ct",
"==",
"CigarHardClipped",
"... | // IsValid returns whether the CIGAR string is valid for a record of the given
// sequence length. Validity is defined by the sum of query consuming operations
// matching the given length, clipping operations only being present at the ends
// of alignments, and that CigarBack operations only result in query-consuming
// positions at or right of the start of the alignment. | [
"IsValid",
"returns",
"whether",
"the",
"CIGAR",
"string",
"is",
"valid",
"for",
"a",
"record",
"of",
"the",
"given",
"sequence",
"length",
".",
"Validity",
"is",
"defined",
"by",
"the",
"sum",
"of",
"query",
"consuming",
"operations",
"matching",
"the",
"gi... | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/sam/cigar.go#L20-L40 |
14,938 | biogo/hts | sam/cigar.go | String | func (c Cigar) String() string {
if len(c) == 0 {
return "*"
}
var b bytes.Buffer
for _, co := range c {
fmt.Fprint(&b, co)
}
return b.String()
} | go | func (c Cigar) String() string {
if len(c) == 0 {
return "*"
}
var b bytes.Buffer
for _, co := range c {
fmt.Fprint(&b, co)
}
return b.String()
} | [
"func",
"(",
"c",
"Cigar",
")",
"String",
"(",
")",
"string",
"{",
"if",
"len",
"(",
"c",
")",
"==",
"0",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"var",
"b",
"bytes",
".",
"Buffer",
"\n",
"for",
"_",
",",
"co",
":=",
"range",
"c",
"{",
... | // String returns the CIGAR string for c. | [
"String",
"returns",
"the",
"CIGAR",
"string",
"for",
"c",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/sam/cigar.go#L43-L52 |
14,939 | biogo/hts | sam/cigar.go | Lengths | func (c Cigar) Lengths() (ref, read int) {
var con Consume
for _, co := range c {
con = co.Type().Consumes()
if co.Type() != CigarBack {
ref += co.Len() * con.Reference
}
read += co.Len() * con.Query
}
return ref, read
} | go | func (c Cigar) Lengths() (ref, read int) {
var con Consume
for _, co := range c {
con = co.Type().Consumes()
if co.Type() != CigarBack {
ref += co.Len() * con.Reference
}
read += co.Len() * con.Query
}
return ref, read
} | [
"func",
"(",
"c",
"Cigar",
")",
"Lengths",
"(",
")",
"(",
"ref",
",",
"read",
"int",
")",
"{",
"var",
"con",
"Consume",
"\n",
"for",
"_",
",",
"co",
":=",
"range",
"c",
"{",
"con",
"=",
"co",
".",
"Type",
"(",
")",
".",
"Consumes",
"(",
")",
... | // Lengths returns the number of reference and read bases described by the Cigar. | [
"Lengths",
"returns",
"the",
"number",
"of",
"reference",
"and",
"read",
"bases",
"described",
"by",
"the",
"Cigar",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/sam/cigar.go#L55-L65 |
14,940 | biogo/hts | sam/cigar.go | NewCigarOp | func NewCigarOp(t CigarOpType, n int) CigarOp {
if uint64(n) > 1<<28-1 {
panic("sam: illegal CIGAR op length")
}
return CigarOp(t) | (CigarOp(n) << 4)
} | go | func NewCigarOp(t CigarOpType, n int) CigarOp {
if uint64(n) > 1<<28-1 {
panic("sam: illegal CIGAR op length")
}
return CigarOp(t) | (CigarOp(n) << 4)
} | [
"func",
"NewCigarOp",
"(",
"t",
"CigarOpType",
",",
"n",
"int",
")",
"CigarOp",
"{",
"if",
"uint64",
"(",
"n",
")",
">",
"1",
"<<",
"28",
"-",
"1",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"CigarOp",
"(",
"t",
")",
"|",
... | // NewCigarOp returns a CIGAR operation of the specified type with length n.
// Due to a limitation of the BAM format, CIGAR operation lengths are limited
// to 2^28-1, and NewCigarOp will panic if n is above this or negative. | [
"NewCigarOp",
"returns",
"a",
"CIGAR",
"operation",
"of",
"the",
"specified",
"type",
"with",
"length",
"n",
".",
"Due",
"to",
"a",
"limitation",
"of",
"the",
"BAM",
"format",
"CIGAR",
"operation",
"lengths",
"are",
"limited",
"to",
"2^28",
"-",
"1",
"and"... | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/sam/cigar.go#L74-L79 |
14,941 | biogo/hts | sam/cigar.go | String | func (ct CigarOpType) String() string {
if ct < 0 || ct > lastCigar {
ct = lastCigar
}
return cigarOps[ct]
} | go | func (ct CigarOpType) String() string {
if ct < 0 || ct > lastCigar {
ct = lastCigar
}
return cigarOps[ct]
} | [
"func",
"(",
"ct",
"CigarOpType",
")",
"String",
"(",
")",
"string",
"{",
"if",
"ct",
"<",
"0",
"||",
"ct",
">",
"lastCigar",
"{",
"ct",
"=",
"lastCigar",
"\n",
"}",
"\n",
"return",
"cigarOps",
"[",
"ct",
"]",
"\n",
"}"
] | // String returns the string representation of a CigarOpType. | [
"String",
"returns",
"the",
"string",
"representation",
"of",
"a",
"CigarOpType",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/sam/cigar.go#L128-L133 |
14,942 | biogo/hts | sam/cigar.go | atoi | func atoi(b []byte) (int, error) {
if len(b) > len(powers) {
return 0, fmt.Errorf("sam: integer overflow: %q", b)
}
var n int64
k := len(b) - 1
for i, v := range b {
n += int64(v-'0') * powers[k-i]
if int64(int(n)) != n {
return 0, fmt.Errorf("sam: integer overflow: %q at %d", b, i)
}
}
return int(n), nil
} | go | func atoi(b []byte) (int, error) {
if len(b) > len(powers) {
return 0, fmt.Errorf("sam: integer overflow: %q", b)
}
var n int64
k := len(b) - 1
for i, v := range b {
n += int64(v-'0') * powers[k-i]
if int64(int(n)) != n {
return 0, fmt.Errorf("sam: integer overflow: %q at %d", b, i)
}
}
return int(n), nil
} | [
"func",
"atoi",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"if",
"len",
"(",
"b",
")",
">",
"len",
"(",
"powers",
")",
"{",
"return",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"b",
")",
"\n",
"}",
"\n... | // atoi returns the integer interpretation of b which must be an ASCII decimal number representation. | [
"atoi",
"returns",
"the",
"integer",
"interpretation",
"of",
"b",
"which",
"must",
"be",
"an",
"ASCII",
"decimal",
"number",
"representation",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/sam/cigar.go#L207-L220 |
14,943 | biogo/hts | sam/cigar.go | ParseCigar | func ParseCigar(b []byte) (Cigar, error) {
if len(b) == 1 && b[0] == '*' {
return nil, nil
}
var (
c Cigar
op CigarOpType
n int
err error
)
for i := 0; i < len(b); i++ {
for j := i; j < len(b); j++ {
if b[j] < '0' || '9' < b[j] {
n, err = atoi(b[i:j])
if err != nil {
return nil, err
}
op = cigarOpTypeLookup[b[j]]
i = j
break
}
}
if op == lastCigar {
return nil, fmt.Errorf("sam: failed to parse cigar string %q: unknown operation %q", b, op)
}
for {
c = append(c, NewCigarOp(op, minInt(n, 1<<28-1)))
n -= 1<<28 - 1
if n <= 0 {
break
}
}
}
return c, nil
} | go | func ParseCigar(b []byte) (Cigar, error) {
if len(b) == 1 && b[0] == '*' {
return nil, nil
}
var (
c Cigar
op CigarOpType
n int
err error
)
for i := 0; i < len(b); i++ {
for j := i; j < len(b); j++ {
if b[j] < '0' || '9' < b[j] {
n, err = atoi(b[i:j])
if err != nil {
return nil, err
}
op = cigarOpTypeLookup[b[j]]
i = j
break
}
}
if op == lastCigar {
return nil, fmt.Errorf("sam: failed to parse cigar string %q: unknown operation %q", b, op)
}
for {
c = append(c, NewCigarOp(op, minInt(n, 1<<28-1)))
n -= 1<<28 - 1
if n <= 0 {
break
}
}
}
return c, nil
} | [
"func",
"ParseCigar",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"Cigar",
",",
"error",
")",
"{",
"if",
"len",
"(",
"b",
")",
"==",
"1",
"&&",
"b",
"[",
"0",
"]",
"==",
"'*'",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"var",
"(",
"c",
... | // ParseCigar returns a Cigar parsed from the provided byte slice.
// ParseCigar will break CIGAR operations longer than 2^28-1 into
// multiple operations summing to the same length. | [
"ParseCigar",
"returns",
"a",
"Cigar",
"parsed",
"from",
"the",
"provided",
"byte",
"slice",
".",
"ParseCigar",
"will",
"break",
"CIGAR",
"operations",
"longer",
"than",
"2^28",
"-",
"1",
"into",
"multiple",
"operations",
"summing",
"to",
"the",
"same",
"lengt... | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/sam/cigar.go#L225-L260 |
14,944 | biogo/hts | bam/index.go | ReadIndex | func ReadIndex(r io.Reader) (*Index, error) {
var (
idx Index
magic [4]byte
err error
)
err = binary.Read(r, binary.LittleEndian, &magic)
if err != nil {
return nil, err
}
if magic != baiMagic {
return nil, errors.New("bam: magic number mismatch")
}
var n int32
err = binary.Read(r, binary.LittleEndian, &n)
if err != nil {
return nil, err
}
if n == 0 {
return nil, nil
}
idx.idx, err = internal.ReadIndex(r, n, "bam")
if err != nil {
return nil, err
}
return &idx, nil
} | go | func ReadIndex(r io.Reader) (*Index, error) {
var (
idx Index
magic [4]byte
err error
)
err = binary.Read(r, binary.LittleEndian, &magic)
if err != nil {
return nil, err
}
if magic != baiMagic {
return nil, errors.New("bam: magic number mismatch")
}
var n int32
err = binary.Read(r, binary.LittleEndian, &n)
if err != nil {
return nil, err
}
if n == 0 {
return nil, nil
}
idx.idx, err = internal.ReadIndex(r, n, "bam")
if err != nil {
return nil, err
}
return &idx, nil
} | [
"func",
"ReadIndex",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"*",
"Index",
",",
"error",
")",
"{",
"var",
"(",
"idx",
"Index",
"\n",
"magic",
"[",
"4",
"]",
"byte",
"\n",
"err",
"error",
"\n",
")",
"\n",
"err",
"=",
"binary",
".",
"Read",
"(",... | // ReadIndex reads the BAI Index from the given io.Reader. | [
"ReadIndex",
"reads",
"the",
"BAI",
"Index",
"from",
"the",
"given",
"io",
".",
"Reader",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bam/index.go#L86-L113 |
14,945 | biogo/hts | bam/reader.go | NewReader | func NewReader(r io.Reader, rd int) (*Reader, error) {
bg, err := bgzf.NewReader(r, rd)
if err != nil {
return nil, err
}
h, _ := sam.NewHeader(nil, nil)
br := &Reader{
r: bg,
h: h,
references: int32(len(h.Refs())),
}
err = br.h.DecodeBinary(br.r)
if err != nil {
return nil, err
}
br.lastChunk.End = br.r.LastChunk().End
return br, nil
} | go | func NewReader(r io.Reader, rd int) (*Reader, error) {
bg, err := bgzf.NewReader(r, rd)
if err != nil {
return nil, err
}
h, _ := sam.NewHeader(nil, nil)
br := &Reader{
r: bg,
h: h,
references: int32(len(h.Refs())),
}
err = br.h.DecodeBinary(br.r)
if err != nil {
return nil, err
}
br.lastChunk.End = br.r.LastChunk().End
return br, nil
} | [
"func",
"NewReader",
"(",
"r",
"io",
".",
"Reader",
",",
"rd",
"int",
")",
"(",
"*",
"Reader",
",",
"error",
")",
"{",
"bg",
",",
"err",
":=",
"bgzf",
".",
"NewReader",
"(",
"r",
",",
"rd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
... | // NewReader returns a new Reader using the given io.Reader
// and setting the read concurrency to rd. If rd is zero
// concurrency is set to GOMAXPROCS. The returned Reader
// should be closed after use to avoid leaking resources. | [
"NewReader",
"returns",
"a",
"new",
"Reader",
"using",
"the",
"given",
"io",
".",
"Reader",
"and",
"setting",
"the",
"read",
"concurrency",
"to",
"rd",
".",
"If",
"rd",
"is",
"zero",
"concurrency",
"is",
"set",
"to",
"GOMAXPROCS",
".",
"The",
"returned",
... | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bam/reader.go#L44-L62 |
14,946 | biogo/hts | bam/reader.go | Seek | func (br *Reader) Seek(off bgzf.Offset) error {
return br.r.Seek(off)
} | go | func (br *Reader) Seek(off bgzf.Offset) error {
return br.r.Seek(off)
} | [
"func",
"(",
"br",
"*",
"Reader",
")",
"Seek",
"(",
"off",
"bgzf",
".",
"Offset",
")",
"error",
"{",
"return",
"br",
".",
"r",
".",
"Seek",
"(",
"off",
")",
"\n",
"}"
] | // Seek performs a seek to the specified bgzf.Offset. | [
"Seek",
"performs",
"a",
"seek",
"to",
"the",
"specified",
"bgzf",
".",
"Offset",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bam/reader.go#L199-L201 |
14,947 | biogo/hts | bam/reader.go | SetChunk | func (br *Reader) SetChunk(c *bgzf.Chunk) error {
if c != nil {
err := br.r.Seek(c.Begin)
if err != nil {
return err
}
}
br.c = c
return nil
} | go | func (br *Reader) SetChunk(c *bgzf.Chunk) error {
if c != nil {
err := br.r.Seek(c.Begin)
if err != nil {
return err
}
}
br.c = c
return nil
} | [
"func",
"(",
"br",
"*",
"Reader",
")",
"SetChunk",
"(",
"c",
"*",
"bgzf",
".",
"Chunk",
")",
"error",
"{",
"if",
"c",
"!=",
"nil",
"{",
"err",
":=",
"br",
".",
"r",
".",
"Seek",
"(",
"c",
".",
"Begin",
")",
"\n",
"if",
"err",
"!=",
"nil",
"... | // SetChunk sets a limited range of the underlying BGZF file to read, after
// seeking to the start of the given chunk. It may be used to iterate over
// a defined genomic interval. | [
"SetChunk",
"sets",
"a",
"limited",
"range",
"of",
"the",
"underlying",
"BGZF",
"file",
"to",
"read",
"after",
"seeking",
"to",
"the",
"start",
"of",
"the",
"given",
"chunk",
".",
"It",
"may",
"be",
"used",
"to",
"iterate",
"over",
"a",
"defined",
"genom... | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bam/reader.go#L206-L215 |
14,948 | biogo/hts | bam/reader.go | Error | func (i *Iterator) Error() error {
if i.err == io.EOF {
return nil
}
return i.err
} | go | func (i *Iterator) Error() error {
if i.err == io.EOF {
return nil
}
return i.err
} | [
"func",
"(",
"i",
"*",
"Iterator",
")",
"Error",
"(",
")",
"error",
"{",
"if",
"i",
".",
"err",
"==",
"io",
".",
"EOF",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"i",
".",
"err",
"\n",
"}"
] | // Error returns the first non-EOF error that was encountered by the Iterator. | [
"Error",
"returns",
"the",
"first",
"non",
"-",
"EOF",
"error",
"that",
"was",
"encountered",
"by",
"the",
"Iterator",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bam/reader.go#L287-L292 |
14,949 | biogo/hts | bam/reader.go | Close | func (i *Iterator) Close() error {
i.r.SetChunk(nil)
return i.Error()
} | go | func (i *Iterator) Close() error {
i.r.SetChunk(nil)
return i.Error()
} | [
"func",
"(",
"i",
"*",
"Iterator",
")",
"Close",
"(",
")",
"error",
"{",
"i",
".",
"r",
".",
"SetChunk",
"(",
"nil",
")",
"\n",
"return",
"i",
".",
"Error",
"(",
")",
"\n",
"}"
] | // Close releases the underlying Reader. | [
"Close",
"releases",
"the",
"underlying",
"Reader",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bam/reader.go#L298-L301 |
14,950 | biogo/hts | bam/reader.go | parseAux | func parseAux(aux []byte) ([]sam.Aux, error) {
if len(aux) == 0 {
return nil, nil
}
aa := make([]sam.Aux, 0, 4)
for i := 0; i+2 < len(aux); {
t := aux[i+2]
switch j := jumps[t]; {
case j > 0:
j += 3
aa = append(aa, sam.Aux(aux[i:i+j:i+j]))
i += j
case j < 0:
switch t {
case 'Z', 'H':
j := bytes.IndexByte(aux[i:], 0)
if j == -1 {
return nil, errors.New("bam: invalid zero terminated data: no zero")
}
aa = append(aa, sam.Aux(aux[i:i+j:i+j]))
i += j + 1
case 'B':
length := binary.LittleEndian.Uint32(aux[i+4 : i+8])
j = int(length)*jumps[aux[i+3]] + int(unsafe.Sizeof(length)) + 4
if j < 0 || i+j < 0 || i+j > len(aux) {
return nil, fmt.Errorf("bam: invalid array length for aux data: %d", length)
}
aa = append(aa, sam.Aux(aux[i:i+j:i+j]))
i += j
}
default:
return nil, fmt.Errorf("bam: unrecognised optional field type: %q", t)
}
}
return aa, nil
} | go | func parseAux(aux []byte) ([]sam.Aux, error) {
if len(aux) == 0 {
return nil, nil
}
aa := make([]sam.Aux, 0, 4)
for i := 0; i+2 < len(aux); {
t := aux[i+2]
switch j := jumps[t]; {
case j > 0:
j += 3
aa = append(aa, sam.Aux(aux[i:i+j:i+j]))
i += j
case j < 0:
switch t {
case 'Z', 'H':
j := bytes.IndexByte(aux[i:], 0)
if j == -1 {
return nil, errors.New("bam: invalid zero terminated data: no zero")
}
aa = append(aa, sam.Aux(aux[i:i+j:i+j]))
i += j + 1
case 'B':
length := binary.LittleEndian.Uint32(aux[i+4 : i+8])
j = int(length)*jumps[aux[i+3]] + int(unsafe.Sizeof(length)) + 4
if j < 0 || i+j < 0 || i+j > len(aux) {
return nil, fmt.Errorf("bam: invalid array length for aux data: %d", length)
}
aa = append(aa, sam.Aux(aux[i:i+j:i+j]))
i += j
}
default:
return nil, fmt.Errorf("bam: unrecognised optional field type: %q", t)
}
}
return aa, nil
} | [
"func",
"parseAux",
"(",
"aux",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"sam",
".",
"Aux",
",",
"error",
")",
"{",
"if",
"len",
"(",
"aux",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"aa",
":=",
"make",
"(",
"[",
"]",
... | // parseAux examines the data of a SAM record's OPT fields,
// returning a slice of sam.Aux that are backed by the original data. | [
"parseAux",
"examines",
"the",
"data",
"of",
"a",
"SAM",
"record",
"s",
"OPT",
"fields",
"returning",
"a",
"slice",
"of",
"sam",
".",
"Aux",
"that",
"are",
"backed",
"by",
"the",
"original",
"data",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bam/reader.go#L325-L360 |
14,951 | biogo/hts | bam/reader.go | newBuffer | func newBuffer(br *Reader) (*buffer, error) {
n, err := io.ReadFull(br.r, br.buf[:4])
// br.r.Chunk() is only valid after the call the Read(), so this
// must come after the first read in the record.
tx := br.r.Begin()
defer func() {
br.lastChunk = tx.End()
}()
if err != nil {
return nil, err
}
if n != 4 {
return nil, errors.New("bam: invalid record: short block size")
}
b := &buffer{data: br.buf[:4]}
size := int(b.readInt32())
if size == 0 {
return nil, io.EOF
}
if size < 0 {
return nil, errors.New("bam: invalid record: invalid block size")
}
b.off, b.data = 0, make([]byte, size)
n, err = io.ReadFull(br.r, b.data)
if err != nil {
return nil, err
}
if n != size {
return nil, errors.New("bam: truncated record")
}
return b, nil
} | go | func newBuffer(br *Reader) (*buffer, error) {
n, err := io.ReadFull(br.r, br.buf[:4])
// br.r.Chunk() is only valid after the call the Read(), so this
// must come after the first read in the record.
tx := br.r.Begin()
defer func() {
br.lastChunk = tx.End()
}()
if err != nil {
return nil, err
}
if n != 4 {
return nil, errors.New("bam: invalid record: short block size")
}
b := &buffer{data: br.buf[:4]}
size := int(b.readInt32())
if size == 0 {
return nil, io.EOF
}
if size < 0 {
return nil, errors.New("bam: invalid record: invalid block size")
}
b.off, b.data = 0, make([]byte, size)
n, err = io.ReadFull(br.r, b.data)
if err != nil {
return nil, err
}
if n != size {
return nil, errors.New("bam: truncated record")
}
return b, nil
} | [
"func",
"newBuffer",
"(",
"br",
"*",
"Reader",
")",
"(",
"*",
"buffer",
",",
"error",
")",
"{",
"n",
",",
"err",
":=",
"io",
".",
"ReadFull",
"(",
"br",
".",
"r",
",",
"br",
".",
"buf",
"[",
":",
"4",
"]",
")",
"\n",
"// br.r.Chunk() is only vali... | // newBuffer returns a new buffer reading from the Reader's underlying bgzf.Reader and
// updates the Reader's lastChunk field. | [
"newBuffer",
"returns",
"a",
"new",
"buffer",
"reading",
"from",
"the",
"Reader",
"s",
"underlying",
"bgzf",
".",
"Reader",
"and",
"updates",
"the",
"Reader",
"s",
"lastChunk",
"field",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bam/reader.go#L444-L475 |
14,952 | biogo/hts | bam/reader.go | buildAux | func buildAux(aa []sam.Aux) (aux []byte) {
for _, a := range aa {
// TODO: validate each 'a'
aux = append(aux, []byte(a)...)
switch a.Type() {
case 'Z', 'H':
aux = append(aux, 0)
}
}
return
} | go | func buildAux(aa []sam.Aux) (aux []byte) {
for _, a := range aa {
// TODO: validate each 'a'
aux = append(aux, []byte(a)...)
switch a.Type() {
case 'Z', 'H':
aux = append(aux, 0)
}
}
return
} | [
"func",
"buildAux",
"(",
"aa",
"[",
"]",
"sam",
".",
"Aux",
")",
"(",
"aux",
"[",
"]",
"byte",
")",
"{",
"for",
"_",
",",
"a",
":=",
"range",
"aa",
"{",
"// TODO: validate each 'a'",
"aux",
"=",
"append",
"(",
"aux",
",",
"[",
"]",
"byte",
"(",
... | // buildAux constructs a single byte slice that represents a slice of sam.Aux. | [
"buildAux",
"constructs",
"a",
"single",
"byte",
"slice",
"that",
"represents",
"a",
"slice",
"of",
"sam",
".",
"Aux",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bam/reader.go#L478-L488 |
14,953 | biogo/hts | cram/cram.go | HasEOF | func HasEOF(r io.ReaderAt) (bool, error) {
type sizer interface {
Size() int64
}
type stater interface {
Stat() (os.FileInfo, error)
}
type lenSeeker interface {
io.Seeker
Len() int
}
var size int64
switch r := r.(type) {
case sizer:
size = r.Size()
case stater:
fi, err := r.Stat()
if err != nil {
return false, err
}
size = fi.Size()
case lenSeeker:
var err error
size, err = r.Seek(0, 1)
if err != nil {
return false, err
}
size += int64(r.Len())
default:
return false, ErrNoEnd
}
b := make([]byte, len(cramEOFmarker))
_, err := r.ReadAt(b, size-int64(len(cramEOFmarker)))
if err != nil {
return false, err
}
return bytes.Equal(b, cramEOFmarker), nil
} | go | func HasEOF(r io.ReaderAt) (bool, error) {
type sizer interface {
Size() int64
}
type stater interface {
Stat() (os.FileInfo, error)
}
type lenSeeker interface {
io.Seeker
Len() int
}
var size int64
switch r := r.(type) {
case sizer:
size = r.Size()
case stater:
fi, err := r.Stat()
if err != nil {
return false, err
}
size = fi.Size()
case lenSeeker:
var err error
size, err = r.Seek(0, 1)
if err != nil {
return false, err
}
size += int64(r.Len())
default:
return false, ErrNoEnd
}
b := make([]byte, len(cramEOFmarker))
_, err := r.ReadAt(b, size-int64(len(cramEOFmarker)))
if err != nil {
return false, err
}
return bytes.Equal(b, cramEOFmarker), nil
} | [
"func",
"HasEOF",
"(",
"r",
"io",
".",
"ReaderAt",
")",
"(",
"bool",
",",
"error",
")",
"{",
"type",
"sizer",
"interface",
"{",
"Size",
"(",
")",
"int64",
"\n",
"}",
"\n",
"type",
"stater",
"interface",
"{",
"Stat",
"(",
")",
"(",
"os",
".",
"Fil... | // HasEOF checks for the presence of a CRAM magic EOF block.
// The magic block is defined in the CRAM specification. A magic block
// is written by a Writer on calling Close. The ReaderAt must provide
// some method for determining valid ReadAt offsets. | [
"HasEOF",
"checks",
"for",
"the",
"presence",
"of",
"a",
"CRAM",
"magic",
"EOF",
"block",
".",
"The",
"magic",
"block",
"is",
"defined",
"in",
"the",
"CRAM",
"specification",
".",
"A",
"magic",
"block",
"is",
"written",
"by",
"a",
"Writer",
"on",
"callin... | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/cram/cram.go#L52-L90 |
14,954 | biogo/hts | cram/cram.go | Next | func (r *Reader) Next() bool {
if r.err != nil {
return false
}
if r.c != nil {
io.Copy(ioutil.Discard, r.c.blockData)
}
var c Container
r.err = c.readFrom(r.r)
r.c = &c
return r.err == nil
} | go | func (r *Reader) Next() bool {
if r.err != nil {
return false
}
if r.c != nil {
io.Copy(ioutil.Discard, r.c.blockData)
}
var c Container
r.err = c.readFrom(r.r)
r.c = &c
return r.err == nil
} | [
"func",
"(",
"r",
"*",
"Reader",
")",
"Next",
"(",
")",
"bool",
"{",
"if",
"r",
".",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"r",
".",
"c",
"!=",
"nil",
"{",
"io",
".",
"Copy",
"(",
"ioutil",
".",
"Discard",
",",
... | // Next advances the Reader to the next CRAM container. It returns false
// when the stream ends, either by reaching the end of the stream or
// encountering an error. | [
"Next",
"advances",
"the",
"Reader",
"to",
"the",
"next",
"CRAM",
"container",
".",
"It",
"returns",
"false",
"when",
"the",
"stream",
"ends",
"either",
"by",
"reaching",
"the",
"end",
"of",
"the",
"stream",
"or",
"encountering",
"an",
"error",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/cram/cram.go#L115-L126 |
14,955 | biogo/hts | cram/cram.go | readFrom | func (d *definition) readFrom(r io.Reader) error {
err := binary.Read(r, binary.LittleEndian, d)
if err != nil {
return err
}
magic := reflect.TypeOf(*d).Field(0).Tag.Get("is")
if !bytes.Equal(d.Magic[:], []byte(magic)) {
return fmt.Errorf("cram: not a cram file: magic bytes %q", d.Magic)
}
return nil
} | go | func (d *definition) readFrom(r io.Reader) error {
err := binary.Read(r, binary.LittleEndian, d)
if err != nil {
return err
}
magic := reflect.TypeOf(*d).Field(0).Tag.Get("is")
if !bytes.Equal(d.Magic[:], []byte(magic)) {
return fmt.Errorf("cram: not a cram file: magic bytes %q", d.Magic)
}
return nil
} | [
"func",
"(",
"d",
"*",
"definition",
")",
"readFrom",
"(",
"r",
"io",
".",
"Reader",
")",
"error",
"{",
"err",
":=",
"binary",
".",
"Read",
"(",
"r",
",",
"binary",
".",
"LittleEndian",
",",
"d",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return"... | // readFrom populates a definition from the given io.Reader. If the magic
// number of the file is not "CRAM" readFrom returns an error. | [
"readFrom",
"populates",
"a",
"definition",
"from",
"the",
"given",
"io",
".",
"Reader",
".",
"If",
"the",
"magic",
"number",
"of",
"the",
"file",
"is",
"not",
"CRAM",
"readFrom",
"returns",
"an",
"error",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/cram/cram.go#L153-L163 |
14,956 | biogo/hts | cram/cram.go | readFrom | func (c *Container) readFrom(r io.Reader) error {
crc := crc32.NewIEEE()
er := errorReader{r: io.TeeReader(r, crc)}
var buf [4]byte
io.ReadFull(&er, buf[:])
c.blockLen = int32(binary.LittleEndian.Uint32(buf[:]))
c.refID = er.itf8()
c.start = er.itf8()
c.span = er.itf8()
c.nRec = er.itf8()
c.recCount = er.ltf8()
c.bases = er.ltf8()
c.blocks = er.itf8()
c.landmarks = er.itf8slice()
sum := crc.Sum32()
_, err := io.ReadFull(&er, buf[:])
if err != nil {
return err
}
c.crc32 = binary.LittleEndian.Uint32(buf[:])
if c.crc32 != sum {
return fmt.Errorf("cram: container crc32 mismatch got:0x%08x want:0x%08x", sum, c.crc32)
}
if er.err != nil {
return er.err
}
// The spec says T[] is {itf8, element...}.
// This is not true for byte[] according to
// the EOF block.
c.blockData = &io.LimitedReader{R: r, N: int64(c.blockLen)}
return nil
} | go | func (c *Container) readFrom(r io.Reader) error {
crc := crc32.NewIEEE()
er := errorReader{r: io.TeeReader(r, crc)}
var buf [4]byte
io.ReadFull(&er, buf[:])
c.blockLen = int32(binary.LittleEndian.Uint32(buf[:]))
c.refID = er.itf8()
c.start = er.itf8()
c.span = er.itf8()
c.nRec = er.itf8()
c.recCount = er.ltf8()
c.bases = er.ltf8()
c.blocks = er.itf8()
c.landmarks = er.itf8slice()
sum := crc.Sum32()
_, err := io.ReadFull(&er, buf[:])
if err != nil {
return err
}
c.crc32 = binary.LittleEndian.Uint32(buf[:])
if c.crc32 != sum {
return fmt.Errorf("cram: container crc32 mismatch got:0x%08x want:0x%08x", sum, c.crc32)
}
if er.err != nil {
return er.err
}
// The spec says T[] is {itf8, element...}.
// This is not true for byte[] according to
// the EOF block.
c.blockData = &io.LimitedReader{R: r, N: int64(c.blockLen)}
return nil
} | [
"func",
"(",
"c",
"*",
"Container",
")",
"readFrom",
"(",
"r",
"io",
".",
"Reader",
")",
"error",
"{",
"crc",
":=",
"crc32",
".",
"NewIEEE",
"(",
")",
"\n",
"er",
":=",
"errorReader",
"{",
"r",
":",
"io",
".",
"TeeReader",
"(",
"r",
",",
"crc",
... | // readFrom populates a Container from the given io.Reader checking that the
// CRC32 for the container header is correct. | [
"readFrom",
"populates",
"a",
"Container",
"from",
"the",
"given",
"io",
".",
"Reader",
"checking",
"that",
"the",
"CRC32",
"for",
"the",
"container",
"header",
"is",
"correct",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/cram/cram.go#L187-L218 |
14,957 | biogo/hts | cram/cram.go | Next | func (c *Container) Next() bool {
if c.err != nil {
return false
}
var b Block
c.err = b.readFrom(c.blockData)
if c.err == nil {
c.block = &b
return true
}
return false
} | go | func (c *Container) Next() bool {
if c.err != nil {
return false
}
var b Block
c.err = b.readFrom(c.blockData)
if c.err == nil {
c.block = &b
return true
}
return false
} | [
"func",
"(",
"c",
"*",
"Container",
")",
"Next",
"(",
")",
"bool",
"{",
"if",
"c",
".",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"var",
"b",
"Block",
"\n",
"c",
".",
"err",
"=",
"b",
".",
"readFrom",
"(",
"c",
".",
"blockD... | // Next advances the Container to the next CRAM block. It returns false
// when the data ends, either by reaching the end of the container or
// encountering an error. | [
"Next",
"advances",
"the",
"Container",
"to",
"the",
"next",
"CRAM",
"block",
".",
"It",
"returns",
"false",
"when",
"the",
"data",
"ends",
"either",
"by",
"reaching",
"the",
"end",
"of",
"the",
"container",
"or",
"encountering",
"an",
"error",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/cram/cram.go#L223-L234 |
14,958 | biogo/hts | cram/cram.go | readFrom | func (b *Block) readFrom(r io.Reader) error {
crc := crc32.NewIEEE()
er := errorReader{r: io.TeeReader(r, crc)}
var buf [4]byte
io.ReadFull(&er, buf[:2])
b.method = buf[0]
b.typ = buf[1]
b.contentID = er.itf8()
b.compressedSize = er.itf8()
b.rawSize = er.itf8()
if b.method == rawMethod && b.compressedSize != b.rawSize {
return fmt.Errorf("cram: compressed (%d) != raw (%d) size for raw method", b.compressedSize, b.rawSize)
}
// The spec says T[] is {itf8, element...}.
// This is not true for byte[] according to
// the EOF block.
b.blockData = make([]byte, b.compressedSize)
_, err := io.ReadFull(&er, b.blockData)
if err != nil {
return err
}
sum := crc.Sum32()
_, err = io.ReadFull(&er, buf[:])
if err != nil {
return err
}
b.crc32 = binary.LittleEndian.Uint32(buf[:])
if b.crc32 != sum {
return fmt.Errorf("cram: block crc32 mismatch got:0x%08x want:0x%08x", sum, b.crc32)
}
return nil
} | go | func (b *Block) readFrom(r io.Reader) error {
crc := crc32.NewIEEE()
er := errorReader{r: io.TeeReader(r, crc)}
var buf [4]byte
io.ReadFull(&er, buf[:2])
b.method = buf[0]
b.typ = buf[1]
b.contentID = er.itf8()
b.compressedSize = er.itf8()
b.rawSize = er.itf8()
if b.method == rawMethod && b.compressedSize != b.rawSize {
return fmt.Errorf("cram: compressed (%d) != raw (%d) size for raw method", b.compressedSize, b.rawSize)
}
// The spec says T[] is {itf8, element...}.
// This is not true for byte[] according to
// the EOF block.
b.blockData = make([]byte, b.compressedSize)
_, err := io.ReadFull(&er, b.blockData)
if err != nil {
return err
}
sum := crc.Sum32()
_, err = io.ReadFull(&er, buf[:])
if err != nil {
return err
}
b.crc32 = binary.LittleEndian.Uint32(buf[:])
if b.crc32 != sum {
return fmt.Errorf("cram: block crc32 mismatch got:0x%08x want:0x%08x", sum, b.crc32)
}
return nil
} | [
"func",
"(",
"b",
"*",
"Block",
")",
"readFrom",
"(",
"r",
"io",
".",
"Reader",
")",
"error",
"{",
"crc",
":=",
"crc32",
".",
"NewIEEE",
"(",
")",
"\n",
"er",
":=",
"errorReader",
"{",
"r",
":",
"io",
".",
"TeeReader",
"(",
"r",
",",
"crc",
")"... | // readFrom fills a Block from the given io.Reader checking that the
// CRC32 for the block is correct. | [
"readFrom",
"fills",
"a",
"Block",
"from",
"the",
"given",
"io",
".",
"Reader",
"checking",
"that",
"the",
"CRC32",
"for",
"the",
"block",
"is",
"correct",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/cram/cram.go#L282-L313 |
14,959 | biogo/hts | cram/cram.go | Value | func (b *Block) Value() (interface{}, error) {
switch b.typ {
case fileHeader:
var h sam.Header
blockData, err := b.expandBlockdata()
if err != nil {
return nil, err
}
end := binary.LittleEndian.Uint32(blockData[:4])
err = h.UnmarshalText(blockData[4 : 4+end])
if err != nil {
return nil, err
}
return &h, nil
case mappedSliceHeader:
var s Slice
s.readFrom(bytes.NewReader(b.blockData))
return &s, nil
default:
// Experimental.
switch b.method {
case gzipMethod, bzip2Method, lzmaMethod:
var err error
b.blockData, err = b.expandBlockdata()
if err != nil {
return nil, err
}
b.method |= 0x80
default:
// Do nothing.
}
return b, nil
}
} | go | func (b *Block) Value() (interface{}, error) {
switch b.typ {
case fileHeader:
var h sam.Header
blockData, err := b.expandBlockdata()
if err != nil {
return nil, err
}
end := binary.LittleEndian.Uint32(blockData[:4])
err = h.UnmarshalText(blockData[4 : 4+end])
if err != nil {
return nil, err
}
return &h, nil
case mappedSliceHeader:
var s Slice
s.readFrom(bytes.NewReader(b.blockData))
return &s, nil
default:
// Experimental.
switch b.method {
case gzipMethod, bzip2Method, lzmaMethod:
var err error
b.blockData, err = b.expandBlockdata()
if err != nil {
return nil, err
}
b.method |= 0x80
default:
// Do nothing.
}
return b, nil
}
} | [
"func",
"(",
"b",
"*",
"Block",
")",
"Value",
"(",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"switch",
"b",
".",
"typ",
"{",
"case",
"fileHeader",
":",
"var",
"h",
"sam",
".",
"Header",
"\n",
"blockData",
",",
"err",
":=",
"b",
"... | // Value returns the value of the Block.
//
// Note that rANS decompression is not implemented. | [
"Value",
"returns",
"the",
"value",
"of",
"the",
"Block",
".",
"Note",
"that",
"rANS",
"decompression",
"is",
"not",
"implemented",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/cram/cram.go#L318-L351 |
14,960 | biogo/hts | cram/cram.go | expandBlockdata | func (b *Block) expandBlockdata() ([]byte, error) {
switch b.method {
default:
panic(fmt.Sprintf("cram: unknown method: %v", b.method))
case rawMethod:
return b.blockData, nil
case gzipMethod:
gz, err := gzip.NewReader(bytes.NewReader(b.blockData))
if err != nil {
return nil, err
}
return ioutil.ReadAll(gz)
case bzip2Method:
return ioutil.ReadAll(bzip2.NewReader(bytes.NewReader(b.blockData)))
case lzmaMethod:
lz, err := lzma.NewReader(bytes.NewReader(b.blockData))
if err != nil {
return nil, err
}
return ioutil.ReadAll(lz)
case ransMethod:
// Unimplemented.
// BUG(kortschak): The rANS method is not implemented.
// Data blocks compressed with rANS will be returned
// compressed and an "unimplemented" error will be
// returned.
return b.blockData, errors.New("unimplemented")
}
} | go | func (b *Block) expandBlockdata() ([]byte, error) {
switch b.method {
default:
panic(fmt.Sprintf("cram: unknown method: %v", b.method))
case rawMethod:
return b.blockData, nil
case gzipMethod:
gz, err := gzip.NewReader(bytes.NewReader(b.blockData))
if err != nil {
return nil, err
}
return ioutil.ReadAll(gz)
case bzip2Method:
return ioutil.ReadAll(bzip2.NewReader(bytes.NewReader(b.blockData)))
case lzmaMethod:
lz, err := lzma.NewReader(bytes.NewReader(b.blockData))
if err != nil {
return nil, err
}
return ioutil.ReadAll(lz)
case ransMethod:
// Unimplemented.
// BUG(kortschak): The rANS method is not implemented.
// Data blocks compressed with rANS will be returned
// compressed and an "unimplemented" error will be
// returned.
return b.blockData, errors.New("unimplemented")
}
} | [
"func",
"(",
"b",
"*",
"Block",
")",
"expandBlockdata",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"switch",
"b",
".",
"method",
"{",
"default",
":",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"b",
".",
"method",
"... | // expandBlockdata decompresses the block's compressed data. | [
"expandBlockdata",
"decompresses",
"the",
"block",
"s",
"compressed",
"data",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/cram/cram.go#L354-L382 |
14,961 | biogo/hts | cram/cram.go | readFrom | func (s *Slice) readFrom(r io.Reader) error {
er := errorReader{r: r}
s.refID = er.itf8()
s.start = er.itf8()
s.span = er.itf8()
s.nRec = er.itf8()
s.recCount = er.ltf8()
s.blocks = er.itf8()
s.blockIDs = er.itf8slice()
s.embeddedRefID = er.itf8()
_, err := io.ReadFull(&er, s.md5sum[:])
if err != nil {
return err
}
s.tags, err = ioutil.ReadAll(&er)
return err
} | go | func (s *Slice) readFrom(r io.Reader) error {
er := errorReader{r: r}
s.refID = er.itf8()
s.start = er.itf8()
s.span = er.itf8()
s.nRec = er.itf8()
s.recCount = er.ltf8()
s.blocks = er.itf8()
s.blockIDs = er.itf8slice()
s.embeddedRefID = er.itf8()
_, err := io.ReadFull(&er, s.md5sum[:])
if err != nil {
return err
}
s.tags, err = ioutil.ReadAll(&er)
return err
} | [
"func",
"(",
"s",
"*",
"Slice",
")",
"readFrom",
"(",
"r",
"io",
".",
"Reader",
")",
"error",
"{",
"er",
":=",
"errorReader",
"{",
"r",
":",
"r",
"}",
"\n",
"s",
".",
"refID",
"=",
"er",
".",
"itf8",
"(",
")",
"\n",
"s",
".",
"start",
"=",
... | // readFrom populates a Slice from the given io.Reader. | [
"readFrom",
"populates",
"a",
"Slice",
"from",
"the",
"given",
"io",
".",
"Reader",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/cram/cram.go#L401-L417 |
14,962 | biogo/hts | cram/cram.go | itf8 | func (r *errorReader) itf8() int32 {
var buf [5]byte
_, r.err = io.ReadFull(r, buf[:1])
if r.err != nil {
return 0
}
i, n, ok := itf8.Decode(buf[:1])
if ok {
return i
}
_, r.err = io.ReadFull(r, buf[1:n])
if r.err != nil {
return 0
}
i, _, ok = itf8.Decode(buf[:n])
if !ok {
r.err = fmt.Errorf("cram: failed to decode itf-8 stream %#v", buf[:n])
}
return i
} | go | func (r *errorReader) itf8() int32 {
var buf [5]byte
_, r.err = io.ReadFull(r, buf[:1])
if r.err != nil {
return 0
}
i, n, ok := itf8.Decode(buf[:1])
if ok {
return i
}
_, r.err = io.ReadFull(r, buf[1:n])
if r.err != nil {
return 0
}
i, _, ok = itf8.Decode(buf[:n])
if !ok {
r.err = fmt.Errorf("cram: failed to decode itf-8 stream %#v", buf[:n])
}
return i
} | [
"func",
"(",
"r",
"*",
"errorReader",
")",
"itf8",
"(",
")",
"int32",
"{",
"var",
"buf",
"[",
"5",
"]",
"byte",
"\n",
"_",
",",
"r",
".",
"err",
"=",
"io",
".",
"ReadFull",
"(",
"r",
",",
"buf",
"[",
":",
"1",
"]",
")",
"\n",
"if",
"r",
"... | // itf8 returns the ITF-8 encoded number at the current reader position. | [
"itf8",
"returns",
"the",
"ITF",
"-",
"8",
"encoded",
"number",
"at",
"the",
"current",
"reader",
"position",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/cram/cram.go#L436-L455 |
14,963 | biogo/hts | cram/cram.go | ltf8 | func (r *errorReader) ltf8() int64 {
var buf [9]byte
_, r.err = io.ReadFull(r, buf[:1])
if r.err != nil {
return 0
}
i, n, ok := ltf8.Decode(buf[:1])
if ok {
return i
}
_, r.err = io.ReadFull(r, buf[1:n])
if r.err != nil {
return 0
}
i, _, ok = ltf8.Decode(buf[:n])
if !ok {
r.err = fmt.Errorf("cram: failed to decode ltf-8 stream %#v", buf[:n])
}
return i
} | go | func (r *errorReader) ltf8() int64 {
var buf [9]byte
_, r.err = io.ReadFull(r, buf[:1])
if r.err != nil {
return 0
}
i, n, ok := ltf8.Decode(buf[:1])
if ok {
return i
}
_, r.err = io.ReadFull(r, buf[1:n])
if r.err != nil {
return 0
}
i, _, ok = ltf8.Decode(buf[:n])
if !ok {
r.err = fmt.Errorf("cram: failed to decode ltf-8 stream %#v", buf[:n])
}
return i
} | [
"func",
"(",
"r",
"*",
"errorReader",
")",
"ltf8",
"(",
")",
"int64",
"{",
"var",
"buf",
"[",
"9",
"]",
"byte",
"\n",
"_",
",",
"r",
".",
"err",
"=",
"io",
".",
"ReadFull",
"(",
"r",
",",
"buf",
"[",
":",
"1",
"]",
")",
"\n",
"if",
"r",
"... | // itf8 returns the LTF-8 encoded number at the current reader position. | [
"itf8",
"returns",
"the",
"LTF",
"-",
"8",
"encoded",
"number",
"at",
"the",
"current",
"reader",
"position",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/cram/cram.go#L478-L497 |
14,964 | biogo/hts | tabix/tabix.go | ReadFrom | func ReadFrom(r io.Reader) (*Index, error) {
var (
idx Index
magic [4]byte
err error
)
err = binary.Read(r, binary.LittleEndian, &magic)
if err != nil {
return nil, err
}
if magic != tbiMagic {
return nil, errors.New("tabix: magic number mismatch")
}
var n int32
err = binary.Read(r, binary.LittleEndian, &n)
if err != nil {
return nil, err
}
if n == 0 {
return nil, nil
}
err = readTabixHeader(r, &idx)
if err != nil {
return nil, err
}
if len(idx.refNames) != int(n) {
return nil, fmt.Errorf("tabix: name count mismatch: %d != %d", len(idx.refNames), n)
}
idx.nameMap = make(map[string]int)
for i, n := range idx.refNames {
idx.nameMap[n] = i
}
idx.idx, err = internal.ReadIndex(r, n, "tabix")
if err != nil {
return nil, err
}
return &idx, nil
} | go | func ReadFrom(r io.Reader) (*Index, error) {
var (
idx Index
magic [4]byte
err error
)
err = binary.Read(r, binary.LittleEndian, &magic)
if err != nil {
return nil, err
}
if magic != tbiMagic {
return nil, errors.New("tabix: magic number mismatch")
}
var n int32
err = binary.Read(r, binary.LittleEndian, &n)
if err != nil {
return nil, err
}
if n == 0 {
return nil, nil
}
err = readTabixHeader(r, &idx)
if err != nil {
return nil, err
}
if len(idx.refNames) != int(n) {
return nil, fmt.Errorf("tabix: name count mismatch: %d != %d", len(idx.refNames), n)
}
idx.nameMap = make(map[string]int)
for i, n := range idx.refNames {
idx.nameMap[n] = i
}
idx.idx, err = internal.ReadIndex(r, n, "tabix")
if err != nil {
return nil, err
}
return &idx, nil
} | [
"func",
"ReadFrom",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"*",
"Index",
",",
"error",
")",
"{",
"var",
"(",
"idx",
"Index",
"\n",
"magic",
"[",
"4",
"]",
"byte",
"\n",
"err",
"error",
"\n",
")",
"\n",
"err",
"=",
"binary",
".",
"Read",
"(",
... | // ReadFrom reads the tabix index from the given io.Reader. Note that
// the tabix specification states that the index is stored as BGZF, but
// ReadFrom does not perform decompression. | [
"ReadFrom",
"reads",
"the",
"tabix",
"index",
"from",
"the",
"given",
"io",
".",
"Reader",
".",
"Note",
"that",
"the",
"tabix",
"specification",
"states",
"that",
"the",
"index",
"is",
"stored",
"as",
"BGZF",
"but",
"ReadFrom",
"does",
"not",
"perform",
"d... | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/tabix/tabix.go#L130-L170 |
14,965 | biogo/hts | tabix/tabix.go | WriteTo | func WriteTo(w io.Writer, idx *Index) error {
err := binary.Write(w, binary.LittleEndian, tbiMagic)
if err != nil {
return err
}
err = binary.Write(w, binary.LittleEndian, int32(len(idx.idx.Refs)))
if err != nil {
return err
}
err = writeTabixHeader(w, idx)
if err != nil {
return err
}
return internal.WriteIndex(w, &idx.idx, "tabix")
} | go | func WriteTo(w io.Writer, idx *Index) error {
err := binary.Write(w, binary.LittleEndian, tbiMagic)
if err != nil {
return err
}
err = binary.Write(w, binary.LittleEndian, int32(len(idx.idx.Refs)))
if err != nil {
return err
}
err = writeTabixHeader(w, idx)
if err != nil {
return err
}
return internal.WriteIndex(w, &idx.idx, "tabix")
} | [
"func",
"WriteTo",
"(",
"w",
"io",
".",
"Writer",
",",
"idx",
"*",
"Index",
")",
"error",
"{",
"err",
":=",
"binary",
".",
"Write",
"(",
"w",
",",
"binary",
".",
"LittleEndian",
",",
"tbiMagic",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
... | // WriteTo writes the index to the given io.Writer. Note that
// the tabix specification states that the index is stored as BGZF, but
// WriteTo does not perform compression. | [
"WriteTo",
"writes",
"the",
"index",
"to",
"the",
"given",
"io",
".",
"Writer",
".",
"Note",
"that",
"the",
"tabix",
"specification",
"states",
"that",
"the",
"index",
"is",
"stored",
"as",
"BGZF",
"but",
"WriteTo",
"does",
"not",
"perform",
"compression",
... | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/tabix/tabix.go#L226-L242 |
14,966 | biogo/hts | csi/csi_write.go | WriteTo | func WriteTo(w io.Writer, idx *Index) error {
idx.sort()
err := binary.Write(w, binary.LittleEndian, csiMagic)
if err != nil {
return err
}
_, err = w.Write([]byte{idx.Version})
if err != nil {
return err
}
err = binary.Write(w, binary.LittleEndian, int32(idx.minShift))
if err != nil {
return err
}
err = binary.Write(w, binary.LittleEndian, int32(idx.depth))
if err != nil {
return err
}
err = binary.Write(w, binary.LittleEndian, int32(len(idx.Auxilliary)))
if err != nil {
return err
}
_, err = w.Write(idx.Auxilliary)
if err != nil {
return err
}
binLimit := uint32(((1 << ((idx.depth + 1) * nextBinShift)) - 1) / 7)
err = writeIndices(w, idx.Version, idx.refs, binLimit)
if err != nil {
return err
}
if idx.unmapped != nil {
err = binary.Write(w, binary.LittleEndian, idx.unmapped)
}
return err
} | go | func WriteTo(w io.Writer, idx *Index) error {
idx.sort()
err := binary.Write(w, binary.LittleEndian, csiMagic)
if err != nil {
return err
}
_, err = w.Write([]byte{idx.Version})
if err != nil {
return err
}
err = binary.Write(w, binary.LittleEndian, int32(idx.minShift))
if err != nil {
return err
}
err = binary.Write(w, binary.LittleEndian, int32(idx.depth))
if err != nil {
return err
}
err = binary.Write(w, binary.LittleEndian, int32(len(idx.Auxilliary)))
if err != nil {
return err
}
_, err = w.Write(idx.Auxilliary)
if err != nil {
return err
}
binLimit := uint32(((1 << ((idx.depth + 1) * nextBinShift)) - 1) / 7)
err = writeIndices(w, idx.Version, idx.refs, binLimit)
if err != nil {
return err
}
if idx.unmapped != nil {
err = binary.Write(w, binary.LittleEndian, idx.unmapped)
}
return err
} | [
"func",
"WriteTo",
"(",
"w",
"io",
".",
"Writer",
",",
"idx",
"*",
"Index",
")",
"error",
"{",
"idx",
".",
"sort",
"(",
")",
"\n",
"err",
":=",
"binary",
".",
"Write",
"(",
"w",
",",
"binary",
".",
"LittleEndian",
",",
"csiMagic",
")",
"\n",
"if"... | // WriteTo writes the CSI index to the given io.Writer. Note that
// the csi specification states that the index is stored as BGZF, but
// WriteTo does not perform compression. | [
"WriteTo",
"writes",
"the",
"CSI",
"index",
"to",
"the",
"given",
"io",
".",
"Writer",
".",
"Note",
"that",
"the",
"csi",
"specification",
"states",
"that",
"the",
"index",
"is",
"stored",
"as",
"BGZF",
"but",
"WriteTo",
"does",
"not",
"perform",
"compress... | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/csi/csi_write.go#L19-L54 |
14,967 | biogo/hts | bgzf/index/strategy.go | CompressorStrategy | func CompressorStrategy(near int64) MergeStrategy {
return func(chunks []bgzf.Chunk) []bgzf.Chunk {
if len(chunks) == 0 {
return nil
}
for c := 1; c < len(chunks); c++ {
leftChunk := chunks[c-1]
rightChunk := &chunks[c]
if leftChunk.End.File+near >= rightChunk.Begin.File {
rightChunk.Begin = leftChunk.Begin
if vOffset(leftChunk.End) > vOffset(rightChunk.End) {
rightChunk.End = leftChunk.End
}
chunks = append(chunks[:c-1], chunks[c:]...)
c--
}
}
return chunks
}
} | go | func CompressorStrategy(near int64) MergeStrategy {
return func(chunks []bgzf.Chunk) []bgzf.Chunk {
if len(chunks) == 0 {
return nil
}
for c := 1; c < len(chunks); c++ {
leftChunk := chunks[c-1]
rightChunk := &chunks[c]
if leftChunk.End.File+near >= rightChunk.Begin.File {
rightChunk.Begin = leftChunk.Begin
if vOffset(leftChunk.End) > vOffset(rightChunk.End) {
rightChunk.End = leftChunk.End
}
chunks = append(chunks[:c-1], chunks[c:]...)
c--
}
}
return chunks
}
} | [
"func",
"CompressorStrategy",
"(",
"near",
"int64",
")",
"MergeStrategy",
"{",
"return",
"func",
"(",
"chunks",
"[",
"]",
"bgzf",
".",
"Chunk",
")",
"[",
"]",
"bgzf",
".",
"Chunk",
"{",
"if",
"len",
"(",
"chunks",
")",
"==",
"0",
"{",
"return",
"nil"... | // CompressorStrategy returns a MergeStrategy that will merge bgzf.Chunks
// that have a distance between BGZF block starts less than or equal
// to near. | [
"CompressorStrategy",
"returns",
"a",
"MergeStrategy",
"that",
"will",
"merge",
"bgzf",
".",
"Chunks",
"that",
"have",
"a",
"distance",
"between",
"BGZF",
"block",
"starts",
"less",
"than",
"or",
"equal",
"to",
"near",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bgzf/index/strategy.go#L28-L47 |
14,968 | biogo/hts | bam/writer.go | NewWriter | func NewWriter(w io.Writer, h *sam.Header, wc int) (*Writer, error) {
return NewWriterLevel(w, h, gzip.DefaultCompression, wc)
} | go | func NewWriter(w io.Writer, h *sam.Header, wc int) (*Writer, error) {
return NewWriterLevel(w, h, gzip.DefaultCompression, wc)
} | [
"func",
"NewWriter",
"(",
"w",
"io",
".",
"Writer",
",",
"h",
"*",
"sam",
".",
"Header",
",",
"wc",
"int",
")",
"(",
"*",
"Writer",
",",
"error",
")",
"{",
"return",
"NewWriterLevel",
"(",
"w",
",",
"h",
",",
"gzip",
".",
"DefaultCompression",
",",... | // NewWriter returns a new Writer using the given SAM header. Write
// concurrency is set to wc. | [
"NewWriter",
"returns",
"a",
"new",
"Writer",
"using",
"the",
"given",
"SAM",
"header",
".",
"Write",
"concurrency",
"is",
"set",
"to",
"wc",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bam/writer.go#L28-L30 |
14,969 | biogo/hts | bam/writer.go | Write | func (bw *Writer) Write(r *sam.Record) error {
if len(r.Name) == 0 || len(r.Name) > 254 {
return errors.New("bam: name absent or too long")
}
if r.Qual != nil && len(r.Qual) != r.Seq.Length {
return errors.New("bam: sequence/quality length mismatch")
}
tags := buildAux(r.AuxFields)
recLen := bamFixedRemainder +
len(r.Name) + 1 + // Null terminated.
len(r.Cigar)<<2 + // CigarOps are 4 bytes.
len(r.Seq.Seq) +
len(r.Qual) +
len(tags)
bw.buf.Reset()
bin := binaryWriter{w: &bw.buf}
// Write record header data.
bin.writeInt32(int32(recLen))
bin.writeInt32(int32(r.Ref.ID()))
bin.writeInt32(int32(r.Pos))
bin.writeUint8(byte(len(r.Name) + 1))
bin.writeUint8(r.MapQ)
bin.writeUint16(uint16(r.Bin())) //r.bin
bin.writeUint16(uint16(len(r.Cigar)))
bin.writeUint16(uint16(r.Flags))
bin.writeInt32(int32(r.Seq.Length))
bin.writeInt32(int32(r.MateRef.ID()))
bin.writeInt32(int32(r.MatePos))
bin.writeInt32(int32(r.TempLen))
// Write variable length data.
bw.buf.WriteString(r.Name)
bw.buf.WriteByte(0)
writeCigarOps(&bin, r.Cigar)
bw.buf.Write(doublets(r.Seq.Seq).Bytes())
if r.Qual != nil {
bw.buf.Write(r.Qual)
} else {
for i := 0; i < r.Seq.Length; i++ {
bw.buf.WriteByte(0xff)
}
}
bw.buf.Write(tags)
_, err := bw.bg.Write(bw.buf.Bytes())
return err
} | go | func (bw *Writer) Write(r *sam.Record) error {
if len(r.Name) == 0 || len(r.Name) > 254 {
return errors.New("bam: name absent or too long")
}
if r.Qual != nil && len(r.Qual) != r.Seq.Length {
return errors.New("bam: sequence/quality length mismatch")
}
tags := buildAux(r.AuxFields)
recLen := bamFixedRemainder +
len(r.Name) + 1 + // Null terminated.
len(r.Cigar)<<2 + // CigarOps are 4 bytes.
len(r.Seq.Seq) +
len(r.Qual) +
len(tags)
bw.buf.Reset()
bin := binaryWriter{w: &bw.buf}
// Write record header data.
bin.writeInt32(int32(recLen))
bin.writeInt32(int32(r.Ref.ID()))
bin.writeInt32(int32(r.Pos))
bin.writeUint8(byte(len(r.Name) + 1))
bin.writeUint8(r.MapQ)
bin.writeUint16(uint16(r.Bin())) //r.bin
bin.writeUint16(uint16(len(r.Cigar)))
bin.writeUint16(uint16(r.Flags))
bin.writeInt32(int32(r.Seq.Length))
bin.writeInt32(int32(r.MateRef.ID()))
bin.writeInt32(int32(r.MatePos))
bin.writeInt32(int32(r.TempLen))
// Write variable length data.
bw.buf.WriteString(r.Name)
bw.buf.WriteByte(0)
writeCigarOps(&bin, r.Cigar)
bw.buf.Write(doublets(r.Seq.Seq).Bytes())
if r.Qual != nil {
bw.buf.Write(r.Qual)
} else {
for i := 0; i < r.Seq.Length; i++ {
bw.buf.WriteByte(0xff)
}
}
bw.buf.Write(tags)
_, err := bw.bg.Write(bw.buf.Bytes())
return err
} | [
"func",
"(",
"bw",
"*",
"Writer",
")",
"Write",
"(",
"r",
"*",
"sam",
".",
"Record",
")",
"error",
"{",
"if",
"len",
"(",
"r",
".",
"Name",
")",
"==",
"0",
"||",
"len",
"(",
"r",
".",
"Name",
")",
">",
"254",
"{",
"return",
"errors",
".",
"... | // Write writes r to the BAM stream. | [
"Write",
"writes",
"r",
"to",
"the",
"BAM",
"stream",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bam/writer.go#L76-L123 |
14,970 | biogo/hts | csi/csi.go | MinimumShiftFor | func MinimumShiftFor(max int64, depth uint32) (uint32, bool) {
for shift := uint32(0); shift < 32; shift++ {
if validIndexPos(int(max), shift, depth) {
return shift, true
}
}
return 0, false
} | go | func MinimumShiftFor(max int64, depth uint32) (uint32, bool) {
for shift := uint32(0); shift < 32; shift++ {
if validIndexPos(int(max), shift, depth) {
return shift, true
}
}
return 0, false
} | [
"func",
"MinimumShiftFor",
"(",
"max",
"int64",
",",
"depth",
"uint32",
")",
"(",
"uint32",
",",
"bool",
")",
"{",
"for",
"shift",
":=",
"uint32",
"(",
"0",
")",
";",
"shift",
"<",
"32",
";",
"shift",
"++",
"{",
"if",
"validIndexPos",
"(",
"int",
"... | // MinimumShiftFor returns the lowest minimum shift value that can be used to index
// the given maximum position with the given index depth. | [
"MinimumShiftFor",
"returns",
"the",
"lowest",
"minimum",
"shift",
"value",
"that",
"can",
"be",
"used",
"to",
"index",
"the",
"given",
"maximum",
"position",
"with",
"the",
"given",
"index",
"depth",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/csi/csi.go#L30-L37 |
14,971 | biogo/hts | csi/csi.go | MinimumDepthFor | func MinimumDepthFor(max int64, shift uint32) (uint32, bool) {
for depth := uint32(0); depth < 32; depth++ {
if validIndexPos(int(max), shift, depth) {
return depth, true
}
}
return 0, false
} | go | func MinimumDepthFor(max int64, shift uint32) (uint32, bool) {
for depth := uint32(0); depth < 32; depth++ {
if validIndexPos(int(max), shift, depth) {
return depth, true
}
}
return 0, false
} | [
"func",
"MinimumDepthFor",
"(",
"max",
"int64",
",",
"shift",
"uint32",
")",
"(",
"uint32",
",",
"bool",
")",
"{",
"for",
"depth",
":=",
"uint32",
"(",
"0",
")",
";",
"depth",
"<",
"32",
";",
"depth",
"++",
"{",
"if",
"validIndexPos",
"(",
"int",
"... | // MinimumDepthFor returns the lowest depth value that can be used to index
// the given maximum position with the given index minimum shift. | [
"MinimumDepthFor",
"returns",
"the",
"lowest",
"depth",
"value",
"that",
"can",
"be",
"used",
"to",
"index",
"the",
"given",
"maximum",
"position",
"with",
"the",
"given",
"index",
"minimum",
"shift",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/csi/csi.go#L41-L48 |
14,972 | biogo/hts | csi/csi.go | New | func New(minShift, depth int) *Index {
if minShift == 0 {
minShift = DefaultShift
}
if depth == 0 {
depth = DefaultDepth
}
return &Index{Version: 0x2, minShift: uint32(minShift), depth: uint32(depth)}
} | go | func New(minShift, depth int) *Index {
if minShift == 0 {
minShift = DefaultShift
}
if depth == 0 {
depth = DefaultDepth
}
return &Index{Version: 0x2, minShift: uint32(minShift), depth: uint32(depth)}
} | [
"func",
"New",
"(",
"minShift",
",",
"depth",
"int",
")",
"*",
"Index",
"{",
"if",
"minShift",
"==",
"0",
"{",
"minShift",
"=",
"DefaultShift",
"\n",
"}",
"\n",
"if",
"depth",
"==",
"0",
"{",
"depth",
"=",
"DefaultDepth",
"\n",
"}",
"\n",
"return",
... | // New returns a CSI index with the given minimum shift and depth.
// The returned index defaults to CSI version 2. | [
"New",
"returns",
"a",
"CSI",
"index",
"with",
"the",
"given",
"minimum",
"shift",
"and",
"depth",
".",
"The",
"returned",
"index",
"defaults",
"to",
"CSI",
"version",
"2",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/csi/csi.go#L56-L64 |
14,973 | biogo/hts | csi/csi_read.go | ReadFrom | func ReadFrom(r io.Reader) (*Index, error) {
var (
idx Index
magic [3]byte
err error
)
err = binary.Read(r, binary.LittleEndian, &magic)
if err != nil {
return nil, err
}
if magic != csiMagic {
return nil, errors.New("csi: magic number mismatch")
}
version := []byte{0}
_, err = io.ReadFull(r, version)
if err != nil {
return nil, err
}
idx.Version = version[0]
if idx.Version != 0x1 && idx.Version != 0x2 {
return nil, fmt.Errorf("csi: unknown version: %d", version[0])
}
err = binary.Read(r, binary.LittleEndian, &idx.minShift)
if err != nil {
return nil, err
}
if int32(idx.minShift) < 0 {
return nil, errors.New("csi: invalid minimum shift value")
}
err = binary.Read(r, binary.LittleEndian, &idx.depth)
if err != nil {
return nil, err
}
if int32(idx.depth) < 0 {
return nil, errors.New("csi: invalid index depth value")
}
var n int32
err = binary.Read(r, binary.LittleEndian, &n)
if err != nil {
return nil, err
}
if n > 0 {
idx.Auxilliary = make([]byte, n)
_, err = io.ReadFull(r, idx.Auxilliary)
if err != nil {
return nil, err
}
}
binLimit := uint32(((1 << ((idx.depth + 1) * nextBinShift)) - 1) / 7)
idx.refs, err = readIndices(r, idx.Version, binLimit)
if err != nil {
return nil, err
}
var nUnmapped uint64
err = binary.Read(r, binary.LittleEndian, &nUnmapped)
if err == nil {
idx.unmapped = &nUnmapped
} else if err != io.EOF {
return nil, err
}
idx.isSorted = true
return &idx, nil
} | go | func ReadFrom(r io.Reader) (*Index, error) {
var (
idx Index
magic [3]byte
err error
)
err = binary.Read(r, binary.LittleEndian, &magic)
if err != nil {
return nil, err
}
if magic != csiMagic {
return nil, errors.New("csi: magic number mismatch")
}
version := []byte{0}
_, err = io.ReadFull(r, version)
if err != nil {
return nil, err
}
idx.Version = version[0]
if idx.Version != 0x1 && idx.Version != 0x2 {
return nil, fmt.Errorf("csi: unknown version: %d", version[0])
}
err = binary.Read(r, binary.LittleEndian, &idx.minShift)
if err != nil {
return nil, err
}
if int32(idx.minShift) < 0 {
return nil, errors.New("csi: invalid minimum shift value")
}
err = binary.Read(r, binary.LittleEndian, &idx.depth)
if err != nil {
return nil, err
}
if int32(idx.depth) < 0 {
return nil, errors.New("csi: invalid index depth value")
}
var n int32
err = binary.Read(r, binary.LittleEndian, &n)
if err != nil {
return nil, err
}
if n > 0 {
idx.Auxilliary = make([]byte, n)
_, err = io.ReadFull(r, idx.Auxilliary)
if err != nil {
return nil, err
}
}
binLimit := uint32(((1 << ((idx.depth + 1) * nextBinShift)) - 1) / 7)
idx.refs, err = readIndices(r, idx.Version, binLimit)
if err != nil {
return nil, err
}
var nUnmapped uint64
err = binary.Read(r, binary.LittleEndian, &nUnmapped)
if err == nil {
idx.unmapped = &nUnmapped
} else if err != io.EOF {
return nil, err
}
idx.isSorted = true
return &idx, nil
} | [
"func",
"ReadFrom",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"*",
"Index",
",",
"error",
")",
"{",
"var",
"(",
"idx",
"Index",
"\n",
"magic",
"[",
"3",
"]",
"byte",
"\n",
"err",
"error",
"\n",
")",
"\n",
"err",
"=",
"binary",
".",
"Read",
"(",
... | // ReadFrom reads the CSI index from the given io.Reader. Note that
// the csi specification states that the index is stored as BGZF, but
// ReadFrom does not perform decompression. | [
"ReadFrom",
"reads",
"the",
"CSI",
"index",
"from",
"the",
"given",
"io",
".",
"Reader",
".",
"Note",
"that",
"the",
"csi",
"specification",
"states",
"that",
"the",
"index",
"is",
"stored",
"as",
"BGZF",
"but",
"ReadFrom",
"does",
"not",
"perform",
"decom... | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/csi/csi_read.go#L21-L83 |
14,974 | biogo/hts | sam/sam.go | NewReader | func NewReader(r io.Reader) (*Reader, error) {
h, _ := NewHeader(nil, nil)
sr := &Reader{
r: bufio.NewReader(r),
h: h,
}
var b []byte
p, err := sr.r.Peek(1)
if err != nil {
return nil, err
}
if p[0] != '@' {
sr.seenRefs = make(map[string]*Reference)
return sr, nil
}
for {
l, err := sr.r.ReadBytes('\n')
if err != nil {
return nil, io.ErrUnexpectedEOF
}
b = append(b, l...)
p, err := sr.r.Peek(1)
if err == io.EOF {
break
}
if err != nil {
return nil, err
}
if p[0] != '@' {
break
}
}
err = sr.h.UnmarshalText(b)
if err != nil {
return nil, err
}
return sr, nil
} | go | func NewReader(r io.Reader) (*Reader, error) {
h, _ := NewHeader(nil, nil)
sr := &Reader{
r: bufio.NewReader(r),
h: h,
}
var b []byte
p, err := sr.r.Peek(1)
if err != nil {
return nil, err
}
if p[0] != '@' {
sr.seenRefs = make(map[string]*Reference)
return sr, nil
}
for {
l, err := sr.r.ReadBytes('\n')
if err != nil {
return nil, io.ErrUnexpectedEOF
}
b = append(b, l...)
p, err := sr.r.Peek(1)
if err == io.EOF {
break
}
if err != nil {
return nil, err
}
if p[0] != '@' {
break
}
}
err = sr.h.UnmarshalText(b)
if err != nil {
return nil, err
}
return sr, nil
} | [
"func",
"NewReader",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"*",
"Reader",
",",
"error",
")",
"{",
"h",
",",
"_",
":=",
"NewHeader",
"(",
"nil",
",",
"nil",
")",
"\n",
"sr",
":=",
"&",
"Reader",
"{",
"r",
":",
"bufio",
".",
"NewReader",
"(",
... | // NewReader returns a new Reader, reading from the given io.Reader. | [
"NewReader",
"returns",
"a",
"new",
"Reader",
"reading",
"from",
"the",
"given",
"io",
".",
"Reader",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/sam/sam.go#L26-L67 |
14,975 | biogo/hts | sam/sam.go | Read | func (r *Reader) Read() (*Record, error) {
b, err := r.r.ReadBytes('\n')
if err != nil {
return nil, err
}
b = b[:len(b)-1]
if b[len(b)-1] == '\r' {
b = b[:len(b)-1]
}
var rec Record
// Handle cases where a header was present.
if r.seenRefs == nil {
err = rec.UnmarshalSAM(r.h, b)
if err != nil {
return nil, err
}
return &rec, nil
}
// Handle cases where no SAM header is present.
err = rec.UnmarshalSAM(nil, b)
if err != nil {
return nil, err
}
if ref, ok := r.seenRefs[rec.Ref.Name()]; ok {
rec.Ref = ref
} else if rec.Ref != nil {
err = r.h.AddReference(rec.Ref)
if err != nil {
return nil, err
}
r.seenRefs[rec.Ref.Name()] = rec.Ref
} else {
r.seenRefs["*"] = nil
}
if ref, ok := r.seenRefs[rec.MateRef.Name()]; ok {
rec.MateRef = ref
} else if rec.MateRef != nil {
err = r.h.AddReference(rec.MateRef)
if err != nil {
return nil, err
}
r.seenRefs[rec.MateRef.Name()] = rec.MateRef
} else {
r.seenRefs["*"] = nil
}
return &rec, nil
} | go | func (r *Reader) Read() (*Record, error) {
b, err := r.r.ReadBytes('\n')
if err != nil {
return nil, err
}
b = b[:len(b)-1]
if b[len(b)-1] == '\r' {
b = b[:len(b)-1]
}
var rec Record
// Handle cases where a header was present.
if r.seenRefs == nil {
err = rec.UnmarshalSAM(r.h, b)
if err != nil {
return nil, err
}
return &rec, nil
}
// Handle cases where no SAM header is present.
err = rec.UnmarshalSAM(nil, b)
if err != nil {
return nil, err
}
if ref, ok := r.seenRefs[rec.Ref.Name()]; ok {
rec.Ref = ref
} else if rec.Ref != nil {
err = r.h.AddReference(rec.Ref)
if err != nil {
return nil, err
}
r.seenRefs[rec.Ref.Name()] = rec.Ref
} else {
r.seenRefs["*"] = nil
}
if ref, ok := r.seenRefs[rec.MateRef.Name()]; ok {
rec.MateRef = ref
} else if rec.MateRef != nil {
err = r.h.AddReference(rec.MateRef)
if err != nil {
return nil, err
}
r.seenRefs[rec.MateRef.Name()] = rec.MateRef
} else {
r.seenRefs["*"] = nil
}
return &rec, nil
} | [
"func",
"(",
"r",
"*",
"Reader",
")",
"Read",
"(",
")",
"(",
"*",
"Record",
",",
"error",
")",
"{",
"b",
",",
"err",
":=",
"r",
".",
"r",
".",
"ReadBytes",
"(",
"'\\n'",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
... | // Read returns the next sam.Record in the SAM stream. | [
"Read",
"returns",
"the",
"next",
"sam",
".",
"Record",
"in",
"the",
"SAM",
"stream",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/sam/sam.go#L75-L125 |
14,976 | biogo/hts | sam/sam.go | NewWriter | func NewWriter(w io.Writer, h *Header, flags int) (*Writer, error) {
if flags < FlagDecimal || flags > FlagString {
return nil, errors.New("bam: flag format option out of range")
}
sw := &Writer{w: w, flags: flags}
text, _ := h.MarshalText()
_, err := w.Write(text)
if err != nil {
return nil, err
}
return sw, nil
} | go | func NewWriter(w io.Writer, h *Header, flags int) (*Writer, error) {
if flags < FlagDecimal || flags > FlagString {
return nil, errors.New("bam: flag format option out of range")
}
sw := &Writer{w: w, flags: flags}
text, _ := h.MarshalText()
_, err := w.Write(text)
if err != nil {
return nil, err
}
return sw, nil
} | [
"func",
"NewWriter",
"(",
"w",
"io",
".",
"Writer",
",",
"h",
"*",
"Header",
",",
"flags",
"int",
")",
"(",
"*",
"Writer",
",",
"error",
")",
"{",
"if",
"flags",
"<",
"FlagDecimal",
"||",
"flags",
">",
"FlagString",
"{",
"return",
"nil",
",",
"erro... | // NewWriter returns a Writer to the given io.Writer using h for the SAM
// header. The format of flags for SAM lines can be FlagDecimal, FlagHex
// or FlagString. | [
"NewWriter",
"returns",
"a",
"Writer",
"to",
"the",
"given",
"io",
".",
"Writer",
"using",
"h",
"for",
"the",
"SAM",
"header",
".",
"The",
"format",
"of",
"flags",
"for",
"SAM",
"lines",
"can",
"be",
"FlagDecimal",
"FlagHex",
"or",
"FlagString",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/sam/sam.go#L186-L197 |
14,977 | biogo/hts | sam/sam.go | Write | func (w *Writer) Write(r *Record) error {
b, err := r.MarshalSAM(w.flags)
if err != nil {
return err
}
b = append(b, '\n')
_, err = w.w.Write(b)
return err
} | go | func (w *Writer) Write(r *Record) error {
b, err := r.MarshalSAM(w.flags)
if err != nil {
return err
}
b = append(b, '\n')
_, err = w.w.Write(b)
return err
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"Write",
"(",
"r",
"*",
"Record",
")",
"error",
"{",
"b",
",",
"err",
":=",
"r",
".",
"MarshalSAM",
"(",
"w",
".",
"flags",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"b",... | // Write writes r to the SAM stream. | [
"Write",
"writes",
"r",
"to",
"the",
"SAM",
"stream",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/sam/sam.go#L200-L208 |
14,978 | biogo/hts | bam/merger.go | Read | func (m *Merger) Read() (rec *sam.Record, err error) {
if len(m.readers) == 0 {
return nil, io.EOF
}
if m.less == nil {
return m.cat()
}
return m.nextBySortOrder()
} | go | func (m *Merger) Read() (rec *sam.Record, err error) {
if len(m.readers) == 0 {
return nil, io.EOF
}
if m.less == nil {
return m.cat()
}
return m.nextBySortOrder()
} | [
"func",
"(",
"m",
"*",
"Merger",
")",
"Read",
"(",
")",
"(",
"rec",
"*",
"sam",
".",
"Record",
",",
"err",
"error",
")",
"{",
"if",
"len",
"(",
"m",
".",
"readers",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"io",
".",
"EOF",
"\n",
"}",
"\n... | // Read returns the next sam.Record in the BAM stream.
//
// The Read behaviour will depend on the underlying Readers. | [
"Read",
"returns",
"the",
"next",
"sam",
".",
"Record",
"in",
"the",
"BAM",
"stream",
".",
"The",
"Read",
"behaviour",
"will",
"depend",
"on",
"the",
"underlying",
"Readers",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bam/merger.go#L115-L123 |
14,979 | biogo/hts | bgzf/reader.go | newCountReader | func newCountReader(r io.Reader) *countReader {
switch r := r.(type) {
case *countReader:
panic("bgzf: illegal use of internal type")
case flate.Reader:
return &countReader{fr: r}
default:
return &countReader{fr: bufio.NewReader(r)}
}
} | go | func newCountReader(r io.Reader) *countReader {
switch r := r.(type) {
case *countReader:
panic("bgzf: illegal use of internal type")
case flate.Reader:
return &countReader{fr: r}
default:
return &countReader{fr: bufio.NewReader(r)}
}
} | [
"func",
"newCountReader",
"(",
"r",
"io",
".",
"Reader",
")",
"*",
"countReader",
"{",
"switch",
"r",
":=",
"r",
".",
"(",
"type",
")",
"{",
"case",
"*",
"countReader",
":",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"case",
"flate",
".",
"Reader",
":",
... | // newCountReader returns a new countReader. | [
"newCountReader",
"returns",
"a",
"new",
"countReader",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bgzf/reader.go#L27-L36 |
14,980 | biogo/hts | bgzf/reader.go | Read | func (r *countReader) Read(p []byte) (int, error) {
n, err := r.fr.Read(p)
r.off += int64(n)
return n, err
} | go | func (r *countReader) Read(p []byte) (int, error) {
n, err := r.fr.Read(p)
r.off += int64(n)
return n, err
} | [
"func",
"(",
"r",
"*",
"countReader",
")",
"Read",
"(",
"p",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"n",
",",
"err",
":=",
"r",
".",
"fr",
".",
"Read",
"(",
"p",
")",
"\n",
"r",
".",
"off",
"+=",
"int64",
"(",
"n",
")"... | // Read is required to satisfy flate.Reader. | [
"Read",
"is",
"required",
"to",
"satisfy",
"flate",
".",
"Reader",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bgzf/reader.go#L39-L43 |
14,981 | biogo/hts | bgzf/reader.go | ReadByte | func (r *countReader) ReadByte() (byte, error) {
b, err := r.fr.ReadByte()
if err == nil {
r.off++
}
return b, err
} | go | func (r *countReader) ReadByte() (byte, error) {
b, err := r.fr.ReadByte()
if err == nil {
r.off++
}
return b, err
} | [
"func",
"(",
"r",
"*",
"countReader",
")",
"ReadByte",
"(",
")",
"(",
"byte",
",",
"error",
")",
"{",
"b",
",",
"err",
":=",
"r",
".",
"fr",
".",
"ReadByte",
"(",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"r",
".",
"off",
"++",
"\n",
"}",
"... | // ReadByte is required to satisfy flate.Reader. | [
"ReadByte",
"is",
"required",
"to",
"satisfy",
"flate",
".",
"Reader",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bgzf/reader.go#L46-L52 |
14,982 | biogo/hts | bgzf/reader.go | seek | func (r *countReader) seek(rs io.ReadSeeker, off int64) error {
_, err := rs.Seek(off, 0)
if err != nil {
return err
}
type reseter interface {
Reset(io.Reader)
}
switch cr := r.fr.(type) {
case reseter:
cr.Reset(rs)
default:
r.fr = newCountReader(rs)
}
r.off = off
return nil
} | go | func (r *countReader) seek(rs io.ReadSeeker, off int64) error {
_, err := rs.Seek(off, 0)
if err != nil {
return err
}
type reseter interface {
Reset(io.Reader)
}
switch cr := r.fr.(type) {
case reseter:
cr.Reset(rs)
default:
r.fr = newCountReader(rs)
}
r.off = off
return nil
} | [
"func",
"(",
"r",
"*",
"countReader",
")",
"seek",
"(",
"rs",
"io",
".",
"ReadSeeker",
",",
"off",
"int64",
")",
"error",
"{",
"_",
",",
"err",
":=",
"rs",
".",
"Seek",
"(",
"off",
",",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
... | // seek moves the countReader to the specified offset using rs as the
// underlying reader. | [
"seek",
"moves",
"the",
"countReader",
"to",
"the",
"specified",
"offset",
"using",
"rs",
"as",
"the",
"underlying",
"reader",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bgzf/reader.go#L59-L77 |
14,983 | biogo/hts | bgzf/reader.go | Read | func (r *buffer) Read(b []byte) (int, error) {
if r.off >= r.size {
return 0, io.EOF
}
if n := r.size - r.off; len(b) > n {
b = b[:n]
}
n := copy(b, r.data[r.off:])
r.off += n
return n, nil
} | go | func (r *buffer) Read(b []byte) (int, error) {
if r.off >= r.size {
return 0, io.EOF
}
if n := r.size - r.off; len(b) > n {
b = b[:n]
}
n := copy(b, r.data[r.off:])
r.off += n
return n, nil
} | [
"func",
"(",
"r",
"*",
"buffer",
")",
"Read",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"if",
"r",
".",
"off",
">=",
"r",
".",
"size",
"{",
"return",
"0",
",",
"io",
".",
"EOF",
"\n",
"}",
"\n",
"if",
"n",
":=",... | // Read provides the flate.Decompressor Read method. | [
"Read",
"provides",
"the",
"flate",
".",
"Decompressor",
"Read",
"method",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bgzf/reader.go#L88-L98 |
14,984 | biogo/hts | bgzf/reader.go | ReadByte | func (r *buffer) ReadByte() (byte, error) {
if r.off == r.size {
return 0, io.EOF
}
b := r.data[r.off]
r.off++
return b, nil
} | go | func (r *buffer) ReadByte() (byte, error) {
if r.off == r.size {
return 0, io.EOF
}
b := r.data[r.off]
r.off++
return b, nil
} | [
"func",
"(",
"r",
"*",
"buffer",
")",
"ReadByte",
"(",
")",
"(",
"byte",
",",
"error",
")",
"{",
"if",
"r",
".",
"off",
"==",
"r",
".",
"size",
"{",
"return",
"0",
",",
"io",
".",
"EOF",
"\n",
"}",
"\n",
"b",
":=",
"r",
".",
"data",
"[",
... | // ReadByte provides the flate.Decompressor ReadByte method. | [
"ReadByte",
"provides",
"the",
"flate",
".",
"Decompressor",
"ReadByte",
"method",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bgzf/reader.go#L101-L108 |
14,985 | biogo/hts | bgzf/reader.go | readLimited | func (r *buffer) readLimited(n int, src *countReader) error {
if r.hasData() {
panic("bgzf: read into non-empty buffer")
}
r.off = 0
var err error
r.size, err = io.ReadFull(src, r.data[:n])
return err
} | go | func (r *buffer) readLimited(n int, src *countReader) error {
if r.hasData() {
panic("bgzf: read into non-empty buffer")
}
r.off = 0
var err error
r.size, err = io.ReadFull(src, r.data[:n])
return err
} | [
"func",
"(",
"r",
"*",
"buffer",
")",
"readLimited",
"(",
"n",
"int",
",",
"src",
"*",
"countReader",
")",
"error",
"{",
"if",
"r",
".",
"hasData",
"(",
")",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"r",
".",
"off",
"=",
"0",
"\n"... | // readLimited reads n bytes into the buffer from the given source. | [
"readLimited",
"reads",
"n",
"bytes",
"into",
"the",
"buffer",
"from",
"the",
"given",
"source",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bgzf/reader.go#L117-L125 |
14,986 | biogo/hts | bgzf/reader.go | Read | func (d *decompressor) Read(b []byte) (int, error) {
if d.buf.hasData() {
return d.buf.Read(b)
}
return d.cr.Read(b)
} | go | func (d *decompressor) Read(b []byte) (int, error) {
if d.buf.hasData() {
return d.buf.Read(b)
}
return d.cr.Read(b)
} | [
"func",
"(",
"d",
"*",
"decompressor",
")",
"Read",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"if",
"d",
".",
"buf",
".",
"hasData",
"(",
")",
"{",
"return",
"d",
".",
"buf",
".",
"Read",
"(",
"b",
")",
"\n",
"}",... | // Read provides the Read method for the decompressor's gzip.Reader. | [
"Read",
"provides",
"the",
"Read",
"method",
"for",
"the",
"decompressor",
"s",
"gzip",
".",
"Reader",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bgzf/reader.go#L153-L158 |
14,987 | biogo/hts | bgzf/reader.go | ReadByte | func (d *decompressor) ReadByte() (byte, error) {
if d.buf.hasData() {
return d.buf.ReadByte()
}
return d.cr.ReadByte()
} | go | func (d *decompressor) ReadByte() (byte, error) {
if d.buf.hasData() {
return d.buf.ReadByte()
}
return d.cr.ReadByte()
} | [
"func",
"(",
"d",
"*",
"decompressor",
")",
"ReadByte",
"(",
")",
"(",
"byte",
",",
"error",
")",
"{",
"if",
"d",
".",
"buf",
".",
"hasData",
"(",
")",
"{",
"return",
"d",
".",
"buf",
".",
"ReadByte",
"(",
")",
"\n",
"}",
"\n",
"return",
"d",
... | // ReadByte provides the ReadByte method for the decompressor's gzip.Reader. | [
"ReadByte",
"provides",
"the",
"ReadByte",
"method",
"for",
"the",
"decompressor",
"s",
"gzip",
".",
"Reader",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bgzf/reader.go#L161-L166 |
14,988 | biogo/hts | bgzf/reader.go | lazyBlock | func (d *decompressor) lazyBlock() {
if d.blk == nil {
if w, ok := d.owner.cache.(Wrapper); ok {
d.blk = w.Wrap(&block{owner: d.owner})
} else {
d.blk = &block{owner: d.owner}
}
return
}
if !d.blk.ownedBy(d.owner) {
d.blk.setOwner(d.owner)
}
} | go | func (d *decompressor) lazyBlock() {
if d.blk == nil {
if w, ok := d.owner.cache.(Wrapper); ok {
d.blk = w.Wrap(&block{owner: d.owner})
} else {
d.blk = &block{owner: d.owner}
}
return
}
if !d.blk.ownedBy(d.owner) {
d.blk.setOwner(d.owner)
}
} | [
"func",
"(",
"d",
"*",
"decompressor",
")",
"lazyBlock",
"(",
")",
"{",
"if",
"d",
".",
"blk",
"==",
"nil",
"{",
"if",
"w",
",",
"ok",
":=",
"d",
".",
"owner",
".",
"cache",
".",
"(",
"Wrapper",
")",
";",
"ok",
"{",
"d",
".",
"blk",
"=",
"w... | // lazyBlock conditionally creates a ready to use Block. | [
"lazyBlock",
"conditionally",
"creates",
"a",
"ready",
"to",
"use",
"Block",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bgzf/reader.go#L169-L181 |
14,989 | biogo/hts | bgzf/reader.go | acquireHead | func (d *decompressor) acquireHead() {
d.wg.Add(1)
d.cr = <-d.owner.head
} | go | func (d *decompressor) acquireHead() {
d.wg.Add(1)
d.cr = <-d.owner.head
} | [
"func",
"(",
"d",
"*",
"decompressor",
")",
"acquireHead",
"(",
")",
"{",
"d",
".",
"wg",
".",
"Add",
"(",
"1",
")",
"\n",
"d",
".",
"cr",
"=",
"<-",
"d",
".",
"owner",
".",
"head",
"\n",
"}"
] | // acquireHead gains the read head from the decompressor's owner. | [
"acquireHead",
"gains",
"the",
"read",
"head",
"from",
"the",
"decompressor",
"s",
"owner",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bgzf/reader.go#L184-L187 |
14,990 | biogo/hts | bgzf/reader.go | releaseHead | func (d *decompressor) releaseHead() {
d.owner.head <- d.cr
d.cr = nil // Defensively zero the reader.
} | go | func (d *decompressor) releaseHead() {
d.owner.head <- d.cr
d.cr = nil // Defensively zero the reader.
} | [
"func",
"(",
"d",
"*",
"decompressor",
")",
"releaseHead",
"(",
")",
"{",
"d",
".",
"owner",
".",
"head",
"<-",
"d",
".",
"cr",
"\n",
"d",
".",
"cr",
"=",
"nil",
"// Defensively zero the reader.",
"\n",
"}"
] | // releaseHead releases the read head back to the decompressor's owner. | [
"releaseHead",
"releases",
"the",
"read",
"head",
"back",
"to",
"the",
"decompressor",
"s",
"owner",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bgzf/reader.go#L190-L193 |
14,991 | biogo/hts | bgzf/reader.go | wait | func (d *decompressor) wait() (Block, error) {
d.wg.Wait()
blk := d.blk
d.blk = nil
return blk, d.err
} | go | func (d *decompressor) wait() (Block, error) {
d.wg.Wait()
blk := d.blk
d.blk = nil
return blk, d.err
} | [
"func",
"(",
"d",
"*",
"decompressor",
")",
"wait",
"(",
")",
"(",
"Block",
",",
"error",
")",
"{",
"d",
".",
"wg",
".",
"Wait",
"(",
")",
"\n",
"blk",
":=",
"d",
".",
"blk",
"\n",
"d",
".",
"blk",
"=",
"nil",
"\n",
"return",
"blk",
",",
"d... | // wait waits for the current member to be decompressed or fail, and returns
// the resulting error state. | [
"wait",
"waits",
"for",
"the",
"current",
"member",
"to",
"be",
"decompressed",
"or",
"fail",
"and",
"returns",
"the",
"resulting",
"error",
"state",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bgzf/reader.go#L197-L202 |
14,992 | biogo/hts | bgzf/reader.go | nextBlockAt | func (d *decompressor) nextBlockAt(off int64, rs io.ReadSeeker) *decompressor {
d.err = nil
for {
exists, next := d.owner.cacheHasBlockFor(off)
if !exists {
break
}
off = next
}
d.lazyBlock()
d.acquireHead()
defer d.releaseHead()
if d.cr.offset() != off {
if rs == nil {
// It should not be possible for the expected next block base
// to be out of register with the count reader unless Seek
// has been called, so we know the base reader must be an
// io.ReadSeeker.
var ok bool
rs, ok = d.owner.r.(io.ReadSeeker)
if !ok {
panic("bgzf: unexpected offset without seek")
}
}
d.err = d.cr.seek(rs, off)
if d.err != nil {
d.wg.Done()
return d
}
}
d.blk.setBase(d.cr.offset())
d.err = d.readMember()
if d.err != nil {
d.wg.Done()
return d
}
d.blk.setHeader(d.gz.Header)
d.gz.Header = gzip.Header{} // Prevent retention of header field in next use.
// Decompress data into the decompressor's Block.
go func() {
d.err = d.blk.readFrom(&d.gz)
d.wg.Done()
}()
return d
} | go | func (d *decompressor) nextBlockAt(off int64, rs io.ReadSeeker) *decompressor {
d.err = nil
for {
exists, next := d.owner.cacheHasBlockFor(off)
if !exists {
break
}
off = next
}
d.lazyBlock()
d.acquireHead()
defer d.releaseHead()
if d.cr.offset() != off {
if rs == nil {
// It should not be possible for the expected next block base
// to be out of register with the count reader unless Seek
// has been called, so we know the base reader must be an
// io.ReadSeeker.
var ok bool
rs, ok = d.owner.r.(io.ReadSeeker)
if !ok {
panic("bgzf: unexpected offset without seek")
}
}
d.err = d.cr.seek(rs, off)
if d.err != nil {
d.wg.Done()
return d
}
}
d.blk.setBase(d.cr.offset())
d.err = d.readMember()
if d.err != nil {
d.wg.Done()
return d
}
d.blk.setHeader(d.gz.Header)
d.gz.Header = gzip.Header{} // Prevent retention of header field in next use.
// Decompress data into the decompressor's Block.
go func() {
d.err = d.blk.readFrom(&d.gz)
d.wg.Done()
}()
return d
} | [
"func",
"(",
"d",
"*",
"decompressor",
")",
"nextBlockAt",
"(",
"off",
"int64",
",",
"rs",
"io",
".",
"ReadSeeker",
")",
"*",
"decompressor",
"{",
"d",
".",
"err",
"=",
"nil",
"\n",
"for",
"{",
"exists",
",",
"next",
":=",
"d",
".",
"owner",
".",
... | // nextBlockAt makes the decompressor ready for reading decompressed data
// from its Block. It checks if there is a cached Block for the nextBase,
// otherwise it seeks to the correct location if decompressor is not
// correctly positioned, and then reads the compressed data and fills
// the decompressed Block.
// After nextBlockAt returns without error, the decompressor's Block
// holds a valid gzip.Header and base offset. | [
"nextBlockAt",
"makes",
"the",
"decompressor",
"ready",
"for",
"reading",
"decompressed",
"data",
"from",
"its",
"Block",
".",
"It",
"checks",
"if",
"there",
"is",
"a",
"cached",
"Block",
"for",
"the",
"nextBase",
"otherwise",
"it",
"seeks",
"to",
"the",
"co... | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bgzf/reader.go#L214-L264 |
14,993 | biogo/hts | bgzf/reader.go | expectedMemberSize | func expectedMemberSize(h gzip.Header) int {
i := bytes.Index(h.Extra, bgzfExtraPrefix)
if i < 0 || i+5 >= len(h.Extra) {
return -1
}
return (int(h.Extra[i+4]) | int(h.Extra[i+5])<<8) + 1
} | go | func expectedMemberSize(h gzip.Header) int {
i := bytes.Index(h.Extra, bgzfExtraPrefix)
if i < 0 || i+5 >= len(h.Extra) {
return -1
}
return (int(h.Extra[i+4]) | int(h.Extra[i+5])<<8) + 1
} | [
"func",
"expectedMemberSize",
"(",
"h",
"gzip",
".",
"Header",
")",
"int",
"{",
"i",
":=",
"bytes",
".",
"Index",
"(",
"h",
".",
"Extra",
",",
"bgzfExtraPrefix",
")",
"\n",
"if",
"i",
"<",
"0",
"||",
"i",
"+",
"5",
">=",
"len",
"(",
"h",
".",
"... | // expectedMemberSize returns the size of the BGZF conformant gzip member.
// It returns -1 if no BGZF block size field is found. | [
"expectedMemberSize",
"returns",
"the",
"size",
"of",
"the",
"BGZF",
"conformant",
"gzip",
"member",
".",
"It",
"returns",
"-",
"1",
"if",
"no",
"BGZF",
"block",
"size",
"field",
"is",
"found",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bgzf/reader.go#L268-L274 |
14,994 | biogo/hts | bgzf/reader.go | readMember | func (d *decompressor) readMember() error {
// Set the decompressor to Read from the underlying flate.Reader
// and mark the starting offset from which the underlying reader
// was used.
d.buf.reset()
mark := d.cr.offset()
err := d.gz.Reset(d)
if err != nil {
d.blockSize = -1
return err
}
d.blockSize = expectedMemberSize(d.gz.Header)
if d.blockSize < 0 {
return ErrNoBlockSize
}
skipped := int(d.cr.offset() - mark)
need := d.blockSize - skipped
if need == 0 {
return io.EOF
} else if need < 0 {
return ErrCorrupt
}
// Read compressed data into the decompressor buffer until the
// underlying flate.Reader is positioned at the end of the gzip
// member in which the readMember call was made.
return d.buf.readLimited(need, d.cr)
} | go | func (d *decompressor) readMember() error {
// Set the decompressor to Read from the underlying flate.Reader
// and mark the starting offset from which the underlying reader
// was used.
d.buf.reset()
mark := d.cr.offset()
err := d.gz.Reset(d)
if err != nil {
d.blockSize = -1
return err
}
d.blockSize = expectedMemberSize(d.gz.Header)
if d.blockSize < 0 {
return ErrNoBlockSize
}
skipped := int(d.cr.offset() - mark)
need := d.blockSize - skipped
if need == 0 {
return io.EOF
} else if need < 0 {
return ErrCorrupt
}
// Read compressed data into the decompressor buffer until the
// underlying flate.Reader is positioned at the end of the gzip
// member in which the readMember call was made.
return d.buf.readLimited(need, d.cr)
} | [
"func",
"(",
"d",
"*",
"decompressor",
")",
"readMember",
"(",
")",
"error",
"{",
"// Set the decompressor to Read from the underlying flate.Reader",
"// and mark the starting offset from which the underlying reader",
"// was used.",
"d",
".",
"buf",
".",
"reset",
"(",
")",
... | // readMember buffers the gzip member starting the current decompressor offset. | [
"readMember",
"buffers",
"the",
"gzip",
"member",
"starting",
"the",
"current",
"decompressor",
"offset",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bgzf/reader.go#L277-L306 |
14,995 | biogo/hts | bgzf/reader.go | NewReader | func NewReader(r io.Reader, rd int) (*Reader, error) {
if rd == 0 {
rd = runtime.GOMAXPROCS(0)
}
bg := &Reader{
r: r,
head: make(chan *countReader, 1),
}
bg.head <- newCountReader(r)
// Make work loop control structures.
if rd > 1 {
bg.waiting = make(chan *decompressor, rd)
bg.working = make(chan *decompressor, rd)
bg.control = make(chan int64, 1)
bg.done = make(chan struct{})
for ; rd > 1; rd-- {
bg.waiting <- &decompressor{owner: bg}
}
}
// Read the first block now so we can fail before
// the first Read call if there is a problem.
bg.dec = &decompressor{owner: bg}
blk, err := bg.dec.nextBlockAt(0, nil).wait()
if err != nil {
return nil, err
}
bg.current = blk
bg.Header = bg.current.header()
// Set up work loop if rd was > 1.
if bg.control != nil {
bg.waiting <- bg.dec
bg.dec = nil
next := blk.NextBase()
go func() {
defer func() {
bg.mu.Lock()
bg.cache = nil
bg.mu.Unlock()
close(bg.done)
}()
for dec := range bg.waiting {
var open bool
if next < 0 {
next, open = <-bg.control
if !open {
return
}
} else {
select {
case next, open = <-bg.control:
if !open {
return
}
default:
}
}
dec.nextBlockAt(next, nil)
next = dec.blk.NextBase()
bg.working <- dec
}
}()
}
return bg, nil
} | go | func NewReader(r io.Reader, rd int) (*Reader, error) {
if rd == 0 {
rd = runtime.GOMAXPROCS(0)
}
bg := &Reader{
r: r,
head: make(chan *countReader, 1),
}
bg.head <- newCountReader(r)
// Make work loop control structures.
if rd > 1 {
bg.waiting = make(chan *decompressor, rd)
bg.working = make(chan *decompressor, rd)
bg.control = make(chan int64, 1)
bg.done = make(chan struct{})
for ; rd > 1; rd-- {
bg.waiting <- &decompressor{owner: bg}
}
}
// Read the first block now so we can fail before
// the first Read call if there is a problem.
bg.dec = &decompressor{owner: bg}
blk, err := bg.dec.nextBlockAt(0, nil).wait()
if err != nil {
return nil, err
}
bg.current = blk
bg.Header = bg.current.header()
// Set up work loop if rd was > 1.
if bg.control != nil {
bg.waiting <- bg.dec
bg.dec = nil
next := blk.NextBase()
go func() {
defer func() {
bg.mu.Lock()
bg.cache = nil
bg.mu.Unlock()
close(bg.done)
}()
for dec := range bg.waiting {
var open bool
if next < 0 {
next, open = <-bg.control
if !open {
return
}
} else {
select {
case next, open = <-bg.control:
if !open {
return
}
default:
}
}
dec.nextBlockAt(next, nil)
next = dec.blk.NextBase()
bg.working <- dec
}
}()
}
return bg, nil
} | [
"func",
"NewReader",
"(",
"r",
"io",
".",
"Reader",
",",
"rd",
"int",
")",
"(",
"*",
"Reader",
",",
"error",
")",
"{",
"if",
"rd",
"==",
"0",
"{",
"rd",
"=",
"runtime",
".",
"GOMAXPROCS",
"(",
"0",
")",
"\n",
"}",
"\n",
"bg",
":=",
"&",
"Read... | // NewReader returns a new BGZF reader.
//
// The number of concurrent read decompressors is specified by rd.
// If rd is 0, GOMAXPROCS concurrent will be created. The returned
// Reader should be closed after use to avoid leaking resources. | [
"NewReader",
"returns",
"a",
"new",
"BGZF",
"reader",
".",
"The",
"number",
"of",
"concurrent",
"read",
"decompressors",
"is",
"specified",
"by",
"rd",
".",
"If",
"rd",
"is",
"0",
"GOMAXPROCS",
"concurrent",
"will",
"be",
"created",
".",
"The",
"returned",
... | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bgzf/reader.go#L368-L436 |
14,996 | biogo/hts | bgzf/reader.go | Seek | func (bg *Reader) Seek(off Offset) error {
rs, ok := bg.r.(io.ReadSeeker)
if !ok {
return ErrNotASeeker
}
if off.File != bg.current.Base() || !bg.current.hasData() {
ok := bg.cacheSwap(off.File)
if !ok {
var dec *decompressor
if bg.dec != nil {
dec = bg.dec
} else {
select {
case dec = <-bg.waiting:
case dec = <-bg.working:
blk, err := dec.wait()
if err == nil {
bg.keep(blk)
}
}
}
bg.current, bg.err = dec.
using(bg.current).
nextBlockAt(off.File, rs).
wait()
if bg.dec == nil {
select {
case <-bg.control:
default:
}
bg.control <- bg.current.NextBase()
bg.waiting <- dec
}
bg.Header = bg.current.header()
if bg.err != nil {
return bg.err
}
}
}
bg.err = bg.current.seek(int64(off.Block))
if bg.err == nil {
bg.lastChunk = Chunk{Begin: off, End: off}
}
return bg.err
} | go | func (bg *Reader) Seek(off Offset) error {
rs, ok := bg.r.(io.ReadSeeker)
if !ok {
return ErrNotASeeker
}
if off.File != bg.current.Base() || !bg.current.hasData() {
ok := bg.cacheSwap(off.File)
if !ok {
var dec *decompressor
if bg.dec != nil {
dec = bg.dec
} else {
select {
case dec = <-bg.waiting:
case dec = <-bg.working:
blk, err := dec.wait()
if err == nil {
bg.keep(blk)
}
}
}
bg.current, bg.err = dec.
using(bg.current).
nextBlockAt(off.File, rs).
wait()
if bg.dec == nil {
select {
case <-bg.control:
default:
}
bg.control <- bg.current.NextBase()
bg.waiting <- dec
}
bg.Header = bg.current.header()
if bg.err != nil {
return bg.err
}
}
}
bg.err = bg.current.seek(int64(off.Block))
if bg.err == nil {
bg.lastChunk = Chunk{Begin: off, End: off}
}
return bg.err
} | [
"func",
"(",
"bg",
"*",
"Reader",
")",
"Seek",
"(",
"off",
"Offset",
")",
"error",
"{",
"rs",
",",
"ok",
":=",
"bg",
".",
"r",
".",
"(",
"io",
".",
"ReadSeeker",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"ErrNotASeeker",
"\n",
"}",
"\n\n",
"if... | // Seek performs a seek operation to the given virtual offset. | [
"Seek",
"performs",
"a",
"seek",
"operation",
"to",
"the",
"given",
"virtual",
"offset",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bgzf/reader.go#L446-L493 |
14,997 | biogo/hts | bgzf/reader.go | Close | func (bg *Reader) Close() error {
if bg.control != nil {
close(bg.control)
close(bg.waiting)
<-bg.done
}
if bg.err == io.EOF {
return nil
}
return bg.err
} | go | func (bg *Reader) Close() error {
if bg.control != nil {
close(bg.control)
close(bg.waiting)
<-bg.done
}
if bg.err == io.EOF {
return nil
}
return bg.err
} | [
"func",
"(",
"bg",
"*",
"Reader",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"bg",
".",
"control",
"!=",
"nil",
"{",
"close",
"(",
"bg",
".",
"control",
")",
"\n",
"close",
"(",
"bg",
".",
"waiting",
")",
"\n",
"<-",
"bg",
".",
"done",
"\n",
... | // Close closes the reader and releases resources. | [
"Close",
"closes",
"the",
"reader",
"and",
"releases",
"resources",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bgzf/reader.go#L505-L515 |
14,998 | biogo/hts | bgzf/reader.go | nextBlock | func (bg *Reader) nextBlock() error {
base := bg.current.NextBase()
ok := bg.cacheSwap(base)
if ok {
bg.Header = bg.current.header()
return nil
}
var err error
if bg.dec != nil {
bg.dec.using(bg.current).nextBlockAt(base, nil)
bg.current, err = bg.dec.wait()
} else {
var ok bool
for i := 0; i < cap(bg.working); i++ {
dec := <-bg.working
bg.current, err = dec.wait()
bg.waiting <- dec
if bg.current.Base() == base {
ok = true
break
}
if err == nil {
bg.keep(bg.current)
bg.current = nil
}
}
if !ok {
panic("bgzf: unexpected block")
}
}
if err != nil {
return err
}
// Only set header if there was no error.
h := bg.current.header()
if bg.current.isMagicBlock() {
// TODO(kortschak): Do this more carefully. It may be that
// someone actually has extra data in this field that we are
// clobbering.
bg.Header.Extra = h.Extra
} else {
bg.Header = h
}
return nil
} | go | func (bg *Reader) nextBlock() error {
base := bg.current.NextBase()
ok := bg.cacheSwap(base)
if ok {
bg.Header = bg.current.header()
return nil
}
var err error
if bg.dec != nil {
bg.dec.using(bg.current).nextBlockAt(base, nil)
bg.current, err = bg.dec.wait()
} else {
var ok bool
for i := 0; i < cap(bg.working); i++ {
dec := <-bg.working
bg.current, err = dec.wait()
bg.waiting <- dec
if bg.current.Base() == base {
ok = true
break
}
if err == nil {
bg.keep(bg.current)
bg.current = nil
}
}
if !ok {
panic("bgzf: unexpected block")
}
}
if err != nil {
return err
}
// Only set header if there was no error.
h := bg.current.header()
if bg.current.isMagicBlock() {
// TODO(kortschak): Do this more carefully. It may be that
// someone actually has extra data in this field that we are
// clobbering.
bg.Header.Extra = h.Extra
} else {
bg.Header = h
}
return nil
} | [
"func",
"(",
"bg",
"*",
"Reader",
")",
"nextBlock",
"(",
")",
"error",
"{",
"base",
":=",
"bg",
".",
"current",
".",
"NextBase",
"(",
")",
"\n",
"ok",
":=",
"bg",
".",
"cacheSwap",
"(",
"base",
")",
"\n",
"if",
"ok",
"{",
"bg",
".",
"Header",
"... | // nextBlock swaps the current decompressed block for the next
// in the stream. If the block is available from the cache
// no additional work is done, otherwise a decompressor is
// used or waited on. | [
"nextBlock",
"swaps",
"the",
"current",
"decompressed",
"block",
"for",
"the",
"next",
"in",
"the",
"stream",
".",
"If",
"the",
"block",
"is",
"available",
"from",
"the",
"cache",
"no",
"additional",
"work",
"is",
"done",
"otherwise",
"a",
"decompressor",
"i... | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bgzf/reader.go#L567-L614 |
14,999 | biogo/hts | bgzf/reader.go | cacheSwap | func (bg *Reader) cacheSwap(base int64) bool {
bg.mu.RLock()
defer bg.mu.RUnlock()
if bg.cache == nil {
return false
}
blk, err := bg.cachedBlockFor(base)
if err != nil {
return false
}
if blk != nil {
// TODO(kortschak): Under some conditions, e.g. FIFO
// cache we will be discarding a non-nil evicted Block.
// Consider retaining these in a sync.Pool.
bg.cachePut(bg.current)
bg.current = blk
return true
}
var retained bool
bg.current, retained = bg.cachePut(bg.current)
if retained {
bg.current = nil
}
return false
} | go | func (bg *Reader) cacheSwap(base int64) bool {
bg.mu.RLock()
defer bg.mu.RUnlock()
if bg.cache == nil {
return false
}
blk, err := bg.cachedBlockFor(base)
if err != nil {
return false
}
if blk != nil {
// TODO(kortschak): Under some conditions, e.g. FIFO
// cache we will be discarding a non-nil evicted Block.
// Consider retaining these in a sync.Pool.
bg.cachePut(bg.current)
bg.current = blk
return true
}
var retained bool
bg.current, retained = bg.cachePut(bg.current)
if retained {
bg.current = nil
}
return false
} | [
"func",
"(",
"bg",
"*",
"Reader",
")",
"cacheSwap",
"(",
"base",
"int64",
")",
"bool",
"{",
"bg",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"bg",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"bg",
".",
"cache",
"==",
"nil",
"{",
"... | // cacheSwap attempts to swap the current Block for a cached Block
// for the given base offset. It returns true if successful. | [
"cacheSwap",
"attempts",
"to",
"swap",
"the",
"current",
"Block",
"for",
"a",
"cached",
"Block",
"for",
"the",
"given",
"base",
"offset",
".",
"It",
"returns",
"true",
"if",
"successful",
"."
] | aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64 | https://github.com/biogo/hts/blob/aafaa03b4ed961cf75d5f7ace0d70cf9fa921f64/bgzf/reader.go#L618-L643 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.