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
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
urfave/cli | command.go | HasName | func (c Command) HasName(name string) bool {
for _, n := range c.Names() {
if n == name {
return true
}
}
return false
} | go | func (c Command) HasName(name string) bool {
for _, n := range c.Names() {
if n == name {
return true
}
}
return false
} | [
"func",
"(",
"c",
"Command",
")",
"HasName",
"(",
"name",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"n",
":=",
"range",
"c",
".",
"Names",
"(",
")",
"{",
"if",
"n",
"==",
"name",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // HasName returns true if Command.Name or Command.ShortName matches given name | [
"HasName",
"returns",
"true",
"if",
"Command",
".",
"Name",
"or",
"Command",
".",
"ShortName",
"matches",
"given",
"name"
] | 693af58b4d51b8fcc7f9d89576da170765980581 | https://github.com/urfave/cli/blob/693af58b4d51b8fcc7f9d89576da170765980581/command.go#L309-L316 | train |
urfave/cli | flag.go | ApplyWithError | func (f GenericFlag) ApplyWithError(set *flag.FlagSet) error {
val := f.Value
if fileEnvVal, ok := flagFromFileEnv(f.FilePath, f.EnvVar); ok {
if err := val.Set(fileEnvVal); err != nil {
return fmt.Errorf("could not parse %s as value for flag %s: %s", fileEnvVal, f.Name, err)
}
}
eachName(f.Name, func(name string) {
set.Var(f.Value, name, f.Usage)
})
return nil
} | go | func (f GenericFlag) ApplyWithError(set *flag.FlagSet) error {
val := f.Value
if fileEnvVal, ok := flagFromFileEnv(f.FilePath, f.EnvVar); ok {
if err := val.Set(fileEnvVal); err != nil {
return fmt.Errorf("could not parse %s as value for flag %s: %s", fileEnvVal, f.Name, err)
}
}
eachName(f.Name, func(name string) {
set.Var(f.Value, name, f.Usage)
})
return nil
} | [
"func",
"(",
"f",
"GenericFlag",
")",
"ApplyWithError",
"(",
"set",
"*",
"flag",
".",
"FlagSet",
")",
"error",
"{",
"val",
":=",
"f",
".",
"Value",
"\n",
"if",
"fileEnvVal",
",",
"ok",
":=",
"flagFromFileEnv",
"(",
"f",
".",
"FilePath",
",",
"f",
".",
"EnvVar",
")",
";",
"ok",
"{",
"if",
"err",
":=",
"val",
".",
"Set",
"(",
"fileEnvVal",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"fileEnvVal",
",",
"f",
".",
"Name",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"eachName",
"(",
"f",
".",
"Name",
",",
"func",
"(",
"name",
"string",
")",
"{",
"set",
".",
"Var",
"(",
"f",
".",
"Value",
",",
"name",
",",
"f",
".",
"Usage",
")",
"\n",
"}",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // ApplyWithError takes the flagset and calls Set on the generic flag with the value
// provided by the user for parsing by the flag | [
"ApplyWithError",
"takes",
"the",
"flagset",
"and",
"calls",
"Set",
"on",
"the",
"generic",
"flag",
"with",
"the",
"value",
"provided",
"by",
"the",
"user",
"for",
"parsing",
"by",
"the",
"flag"
] | 693af58b4d51b8fcc7f9d89576da170765980581 | https://github.com/urfave/cli/blob/693af58b4d51b8fcc7f9d89576da170765980581/flag.go#L126-L139 | train |
urfave/cli | flag.go | Set | func (f *StringSlice) Set(value string) error {
*f = append(*f, value)
return nil
} | go | func (f *StringSlice) Set(value string) error {
*f = append(*f, value)
return nil
} | [
"func",
"(",
"f",
"*",
"StringSlice",
")",
"Set",
"(",
"value",
"string",
")",
"error",
"{",
"*",
"f",
"=",
"append",
"(",
"*",
"f",
",",
"value",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // Set appends the string value to the list of values | [
"Set",
"appends",
"the",
"string",
"value",
"to",
"the",
"list",
"of",
"values"
] | 693af58b4d51b8fcc7f9d89576da170765980581 | https://github.com/urfave/cli/blob/693af58b4d51b8fcc7f9d89576da170765980581/flag.go#L145-L148 | train |
urfave/cli | flag.go | unquoteUsage | func unquoteUsage(usage string) (string, string) {
for i := 0; i < len(usage); i++ {
if usage[i] == '`' {
for j := i + 1; j < len(usage); j++ {
if usage[j] == '`' {
name := usage[i+1 : j]
usage = usage[:i] + name + usage[j+1:]
return name, usage
}
}
break
}
}
return "", usage
} | go | func unquoteUsage(usage string) (string, string) {
for i := 0; i < len(usage); i++ {
if usage[i] == '`' {
for j := i + 1; j < len(usage); j++ {
if usage[j] == '`' {
name := usage[i+1 : j]
usage = usage[:i] + name + usage[j+1:]
return name, usage
}
}
break
}
}
return "", usage
} | [
"func",
"unquoteUsage",
"(",
"usage",
"string",
")",
"(",
"string",
",",
"string",
")",
"{",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"usage",
")",
";",
"i",
"++",
"{",
"if",
"usage",
"[",
"i",
"]",
"==",
"'`'",
"{",
"for",
"j",
":=",
"i",
"+",
"1",
";",
"j",
"<",
"len",
"(",
"usage",
")",
";",
"j",
"++",
"{",
"if",
"usage",
"[",
"j",
"]",
"==",
"'`'",
"{",
"name",
":=",
"usage",
"[",
"i",
"+",
"1",
":",
"j",
"]",
"\n",
"usage",
"=",
"usage",
"[",
":",
"i",
"]",
"+",
"name",
"+",
"usage",
"[",
"j",
"+",
"1",
":",
"]",
"\n",
"return",
"name",
",",
"usage",
"\n",
"}",
"\n",
"}",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
",",
"usage",
"\n",
"}"
] | // Returns the placeholder, if any, and the unquoted usage string. | [
"Returns",
"the",
"placeholder",
"if",
"any",
"and",
"the",
"unquoted",
"usage",
"string",
"."
] | 693af58b4d51b8fcc7f9d89576da170765980581 | https://github.com/urfave/cli/blob/693af58b4d51b8fcc7f9d89576da170765980581/flag.go#L596-L610 | train |
syndtr/goleveldb | leveldb/session_util.go | newTemp | func (s *session) newTemp() storage.FileDesc {
num := atomic.AddInt64(&s.stTempFileNum, 1) - 1
return storage.FileDesc{Type: storage.TypeTemp, Num: num}
} | go | func (s *session) newTemp() storage.FileDesc {
num := atomic.AddInt64(&s.stTempFileNum, 1) - 1
return storage.FileDesc{Type: storage.TypeTemp, Num: num}
} | [
"func",
"(",
"s",
"*",
"session",
")",
"newTemp",
"(",
")",
"storage",
".",
"FileDesc",
"{",
"num",
":=",
"atomic",
".",
"AddInt64",
"(",
"&",
"s",
".",
"stTempFileNum",
",",
"1",
")",
"-",
"1",
"\n",
"return",
"storage",
".",
"FileDesc",
"{",
"Type",
":",
"storage",
".",
"TypeTemp",
",",
"Num",
":",
"num",
"}",
"\n",
"}"
] | // File utils. | [
"File",
"utils",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/session_util.go#L38-L41 | train |
syndtr/goleveldb | leveldb/session_util.go | setNextFileNum | func (s *session) setNextFileNum(num int64) {
atomic.StoreInt64(&s.stNextFileNum, num)
} | go | func (s *session) setNextFileNum(num int64) {
atomic.StoreInt64(&s.stNextFileNum, num)
} | [
"func",
"(",
"s",
"*",
"session",
")",
"setNextFileNum",
"(",
"num",
"int64",
")",
"{",
"atomic",
".",
"StoreInt64",
"(",
"&",
"s",
".",
"stNextFileNum",
",",
"num",
")",
"\n",
"}"
] | // Set current unused file number to num. | [
"Set",
"current",
"unused",
"file",
"number",
"to",
"num",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/session_util.go#L303-L305 | train |
syndtr/goleveldb | leveldb/session_util.go | markFileNum | func (s *session) markFileNum(num int64) {
nextFileNum := num + 1
for {
old, x := s.stNextFileNum, nextFileNum
if old > x {
x = old
}
if atomic.CompareAndSwapInt64(&s.stNextFileNum, old, x) {
break
}
}
} | go | func (s *session) markFileNum(num int64) {
nextFileNum := num + 1
for {
old, x := s.stNextFileNum, nextFileNum
if old > x {
x = old
}
if atomic.CompareAndSwapInt64(&s.stNextFileNum, old, x) {
break
}
}
} | [
"func",
"(",
"s",
"*",
"session",
")",
"markFileNum",
"(",
"num",
"int64",
")",
"{",
"nextFileNum",
":=",
"num",
"+",
"1",
"\n",
"for",
"{",
"old",
",",
"x",
":=",
"s",
".",
"stNextFileNum",
",",
"nextFileNum",
"\n",
"if",
"old",
">",
"x",
"{",
"x",
"=",
"old",
"\n",
"}",
"\n",
"if",
"atomic",
".",
"CompareAndSwapInt64",
"(",
"&",
"s",
".",
"stNextFileNum",
",",
"old",
",",
"x",
")",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Mark file number as used. | [
"Mark",
"file",
"number",
"as",
"used",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/session_util.go#L308-L319 | train |
syndtr/goleveldb | leveldb/session_util.go | reuseFileNum | func (s *session) reuseFileNum(num int64) {
for {
old, x := s.stNextFileNum, num
if old != x+1 {
x = old
}
if atomic.CompareAndSwapInt64(&s.stNextFileNum, old, x) {
break
}
}
} | go | func (s *session) reuseFileNum(num int64) {
for {
old, x := s.stNextFileNum, num
if old != x+1 {
x = old
}
if atomic.CompareAndSwapInt64(&s.stNextFileNum, old, x) {
break
}
}
} | [
"func",
"(",
"s",
"*",
"session",
")",
"reuseFileNum",
"(",
"num",
"int64",
")",
"{",
"for",
"{",
"old",
",",
"x",
":=",
"s",
".",
"stNextFileNum",
",",
"num",
"\n",
"if",
"old",
"!=",
"x",
"+",
"1",
"{",
"x",
"=",
"old",
"\n",
"}",
"\n",
"if",
"atomic",
".",
"CompareAndSwapInt64",
"(",
"&",
"s",
".",
"stNextFileNum",
",",
"old",
",",
"x",
")",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Reuse given file number. | [
"Reuse",
"given",
"file",
"number",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/session_util.go#L327-L337 | train |
syndtr/goleveldb | leveldb/session_util.go | setCompPtr | func (s *session) setCompPtr(level int, ik internalKey) {
if level >= len(s.stCompPtrs) {
newCompPtrs := make([]internalKey, level+1)
copy(newCompPtrs, s.stCompPtrs)
s.stCompPtrs = newCompPtrs
}
s.stCompPtrs[level] = append(internalKey{}, ik...)
} | go | func (s *session) setCompPtr(level int, ik internalKey) {
if level >= len(s.stCompPtrs) {
newCompPtrs := make([]internalKey, level+1)
copy(newCompPtrs, s.stCompPtrs)
s.stCompPtrs = newCompPtrs
}
s.stCompPtrs[level] = append(internalKey{}, ik...)
} | [
"func",
"(",
"s",
"*",
"session",
")",
"setCompPtr",
"(",
"level",
"int",
",",
"ik",
"internalKey",
")",
"{",
"if",
"level",
">=",
"len",
"(",
"s",
".",
"stCompPtrs",
")",
"{",
"newCompPtrs",
":=",
"make",
"(",
"[",
"]",
"internalKey",
",",
"level",
"+",
"1",
")",
"\n",
"copy",
"(",
"newCompPtrs",
",",
"s",
".",
"stCompPtrs",
")",
"\n",
"s",
".",
"stCompPtrs",
"=",
"newCompPtrs",
"\n",
"}",
"\n",
"s",
".",
"stCompPtrs",
"[",
"level",
"]",
"=",
"append",
"(",
"internalKey",
"{",
"}",
",",
"ik",
"...",
")",
"\n",
"}"
] | // Set compaction ptr at given level; need external synchronization. | [
"Set",
"compaction",
"ptr",
"at",
"given",
"level",
";",
"need",
"external",
"synchronization",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/session_util.go#L340-L347 | train |
syndtr/goleveldb | leveldb/session_util.go | getCompPtr | func (s *session) getCompPtr(level int) internalKey {
if level >= len(s.stCompPtrs) {
return nil
}
return s.stCompPtrs[level]
} | go | func (s *session) getCompPtr(level int) internalKey {
if level >= len(s.stCompPtrs) {
return nil
}
return s.stCompPtrs[level]
} | [
"func",
"(",
"s",
"*",
"session",
")",
"getCompPtr",
"(",
"level",
"int",
")",
"internalKey",
"{",
"if",
"level",
">=",
"len",
"(",
"s",
".",
"stCompPtrs",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"s",
".",
"stCompPtrs",
"[",
"level",
"]",
"\n",
"}"
] | // Get compaction ptr at given level; need external synchronization. | [
"Get",
"compaction",
"ptr",
"at",
"given",
"level",
";",
"need",
"external",
"synchronization",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/session_util.go#L350-L355 | train |
syndtr/goleveldb | leveldb/session_util.go | fillRecord | func (s *session) fillRecord(r *sessionRecord, snapshot bool) {
r.setNextFileNum(s.nextFileNum())
if snapshot {
if !r.has(recJournalNum) {
r.setJournalNum(s.stJournalNum)
}
if !r.has(recSeqNum) {
r.setSeqNum(s.stSeqNum)
}
for level, ik := range s.stCompPtrs {
if ik != nil {
r.addCompPtr(level, ik)
}
}
r.setComparer(s.icmp.uName())
}
} | go | func (s *session) fillRecord(r *sessionRecord, snapshot bool) {
r.setNextFileNum(s.nextFileNum())
if snapshot {
if !r.has(recJournalNum) {
r.setJournalNum(s.stJournalNum)
}
if !r.has(recSeqNum) {
r.setSeqNum(s.stSeqNum)
}
for level, ik := range s.stCompPtrs {
if ik != nil {
r.addCompPtr(level, ik)
}
}
r.setComparer(s.icmp.uName())
}
} | [
"func",
"(",
"s",
"*",
"session",
")",
"fillRecord",
"(",
"r",
"*",
"sessionRecord",
",",
"snapshot",
"bool",
")",
"{",
"r",
".",
"setNextFileNum",
"(",
"s",
".",
"nextFileNum",
"(",
")",
")",
"\n\n",
"if",
"snapshot",
"{",
"if",
"!",
"r",
".",
"has",
"(",
"recJournalNum",
")",
"{",
"r",
".",
"setJournalNum",
"(",
"s",
".",
"stJournalNum",
")",
"\n",
"}",
"\n\n",
"if",
"!",
"r",
".",
"has",
"(",
"recSeqNum",
")",
"{",
"r",
".",
"setSeqNum",
"(",
"s",
".",
"stSeqNum",
")",
"\n",
"}",
"\n\n",
"for",
"level",
",",
"ik",
":=",
"range",
"s",
".",
"stCompPtrs",
"{",
"if",
"ik",
"!=",
"nil",
"{",
"r",
".",
"addCompPtr",
"(",
"level",
",",
"ik",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"r",
".",
"setComparer",
"(",
"s",
".",
"icmp",
".",
"uName",
"(",
")",
")",
"\n",
"}",
"\n",
"}"
] | // Manifest related utils.
// Fill given session record obj with current states; need external
// synchronization. | [
"Manifest",
"related",
"utils",
".",
"Fill",
"given",
"session",
"record",
"obj",
"with",
"current",
"states",
";",
"need",
"external",
"synchronization",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/session_util.go#L361-L381 | train |
syndtr/goleveldb | leveldb/session_util.go | recordCommited | func (s *session) recordCommited(rec *sessionRecord) {
if rec.has(recJournalNum) {
s.stJournalNum = rec.journalNum
}
if rec.has(recPrevJournalNum) {
s.stPrevJournalNum = rec.prevJournalNum
}
if rec.has(recSeqNum) {
s.stSeqNum = rec.seqNum
}
for _, r := range rec.compPtrs {
s.setCompPtr(r.level, internalKey(r.ikey))
}
} | go | func (s *session) recordCommited(rec *sessionRecord) {
if rec.has(recJournalNum) {
s.stJournalNum = rec.journalNum
}
if rec.has(recPrevJournalNum) {
s.stPrevJournalNum = rec.prevJournalNum
}
if rec.has(recSeqNum) {
s.stSeqNum = rec.seqNum
}
for _, r := range rec.compPtrs {
s.setCompPtr(r.level, internalKey(r.ikey))
}
} | [
"func",
"(",
"s",
"*",
"session",
")",
"recordCommited",
"(",
"rec",
"*",
"sessionRecord",
")",
"{",
"if",
"rec",
".",
"has",
"(",
"recJournalNum",
")",
"{",
"s",
".",
"stJournalNum",
"=",
"rec",
".",
"journalNum",
"\n",
"}",
"\n\n",
"if",
"rec",
".",
"has",
"(",
"recPrevJournalNum",
")",
"{",
"s",
".",
"stPrevJournalNum",
"=",
"rec",
".",
"prevJournalNum",
"\n",
"}",
"\n\n",
"if",
"rec",
".",
"has",
"(",
"recSeqNum",
")",
"{",
"s",
".",
"stSeqNum",
"=",
"rec",
".",
"seqNum",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"r",
":=",
"range",
"rec",
".",
"compPtrs",
"{",
"s",
".",
"setCompPtr",
"(",
"r",
".",
"level",
",",
"internalKey",
"(",
"r",
".",
"ikey",
")",
")",
"\n",
"}",
"\n",
"}"
] | // Mark if record has been committed, this will update session state;
// need external synchronization. | [
"Mark",
"if",
"record",
"has",
"been",
"committed",
"this",
"will",
"update",
"session",
"state",
";",
"need",
"external",
"synchronization",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/session_util.go#L385-L401 | train |
syndtr/goleveldb | leveldb/session_util.go | flushManifest | func (s *session) flushManifest(rec *sessionRecord) (err error) {
s.fillRecord(rec, false)
w, err := s.manifest.Next()
if err != nil {
return
}
err = rec.encode(w)
if err != nil {
return
}
err = s.manifest.Flush()
if err != nil {
return
}
if !s.o.GetNoSync() {
err = s.manifestWriter.Sync()
if err != nil {
return
}
}
s.recordCommited(rec)
return
} | go | func (s *session) flushManifest(rec *sessionRecord) (err error) {
s.fillRecord(rec, false)
w, err := s.manifest.Next()
if err != nil {
return
}
err = rec.encode(w)
if err != nil {
return
}
err = s.manifest.Flush()
if err != nil {
return
}
if !s.o.GetNoSync() {
err = s.manifestWriter.Sync()
if err != nil {
return
}
}
s.recordCommited(rec)
return
} | [
"func",
"(",
"s",
"*",
"session",
")",
"flushManifest",
"(",
"rec",
"*",
"sessionRecord",
")",
"(",
"err",
"error",
")",
"{",
"s",
".",
"fillRecord",
"(",
"rec",
",",
"false",
")",
"\n",
"w",
",",
"err",
":=",
"s",
".",
"manifest",
".",
"Next",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"err",
"=",
"rec",
".",
"encode",
"(",
"w",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"err",
"=",
"s",
".",
"manifest",
".",
"Flush",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"if",
"!",
"s",
".",
"o",
".",
"GetNoSync",
"(",
")",
"{",
"err",
"=",
"s",
".",
"manifestWriter",
".",
"Sync",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"s",
".",
"recordCommited",
"(",
"rec",
")",
"\n",
"return",
"\n",
"}"
] | // Flush record to disk. | [
"Flush",
"record",
"to",
"disk",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/session_util.go#L461-L483 | train |
syndtr/goleveldb | leveldb/storage/file_storage.go | OpenFile | func OpenFile(path string, readOnly bool) (Storage, error) {
if fi, err := os.Stat(path); err == nil {
if !fi.IsDir() {
return nil, fmt.Errorf("leveldb/storage: open %s: not a directory", path)
}
} else if os.IsNotExist(err) && !readOnly {
if err := os.MkdirAll(path, 0755); err != nil {
return nil, err
}
} else {
return nil, err
}
flock, err := newFileLock(filepath.Join(path, "LOCK"), readOnly)
if err != nil {
return nil, err
}
defer func() {
if err != nil {
flock.release()
}
}()
var (
logw *os.File
logSize int64
)
if !readOnly {
logw, err = os.OpenFile(filepath.Join(path, "LOG"), os.O_WRONLY|os.O_CREATE, 0644)
if err != nil {
return nil, err
}
logSize, err = logw.Seek(0, os.SEEK_END)
if err != nil {
logw.Close()
return nil, err
}
}
fs := &fileStorage{
path: path,
readOnly: readOnly,
flock: flock,
logw: logw,
logSize: logSize,
}
runtime.SetFinalizer(fs, (*fileStorage).Close)
return fs, nil
} | go | func OpenFile(path string, readOnly bool) (Storage, error) {
if fi, err := os.Stat(path); err == nil {
if !fi.IsDir() {
return nil, fmt.Errorf("leveldb/storage: open %s: not a directory", path)
}
} else if os.IsNotExist(err) && !readOnly {
if err := os.MkdirAll(path, 0755); err != nil {
return nil, err
}
} else {
return nil, err
}
flock, err := newFileLock(filepath.Join(path, "LOCK"), readOnly)
if err != nil {
return nil, err
}
defer func() {
if err != nil {
flock.release()
}
}()
var (
logw *os.File
logSize int64
)
if !readOnly {
logw, err = os.OpenFile(filepath.Join(path, "LOG"), os.O_WRONLY|os.O_CREATE, 0644)
if err != nil {
return nil, err
}
logSize, err = logw.Seek(0, os.SEEK_END)
if err != nil {
logw.Close()
return nil, err
}
}
fs := &fileStorage{
path: path,
readOnly: readOnly,
flock: flock,
logw: logw,
logSize: logSize,
}
runtime.SetFinalizer(fs, (*fileStorage).Close)
return fs, nil
} | [
"func",
"OpenFile",
"(",
"path",
"string",
",",
"readOnly",
"bool",
")",
"(",
"Storage",
",",
"error",
")",
"{",
"if",
"fi",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"path",
")",
";",
"err",
"==",
"nil",
"{",
"if",
"!",
"fi",
".",
"IsDir",
"(",
")",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"path",
")",
"\n",
"}",
"\n",
"}",
"else",
"if",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"&&",
"!",
"readOnly",
"{",
"if",
"err",
":=",
"os",
".",
"MkdirAll",
"(",
"path",
",",
"0755",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"flock",
",",
"err",
":=",
"newFileLock",
"(",
"filepath",
".",
"Join",
"(",
"path",
",",
"\"",
"\"",
")",
",",
"readOnly",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"defer",
"func",
"(",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"flock",
".",
"release",
"(",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"var",
"(",
"logw",
"*",
"os",
".",
"File",
"\n",
"logSize",
"int64",
"\n",
")",
"\n",
"if",
"!",
"readOnly",
"{",
"logw",
",",
"err",
"=",
"os",
".",
"OpenFile",
"(",
"filepath",
".",
"Join",
"(",
"path",
",",
"\"",
"\"",
")",
",",
"os",
".",
"O_WRONLY",
"|",
"os",
".",
"O_CREATE",
",",
"0644",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"logSize",
",",
"err",
"=",
"logw",
".",
"Seek",
"(",
"0",
",",
"os",
".",
"SEEK_END",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logw",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"fs",
":=",
"&",
"fileStorage",
"{",
"path",
":",
"path",
",",
"readOnly",
":",
"readOnly",
",",
"flock",
":",
"flock",
",",
"logw",
":",
"logw",
",",
"logSize",
":",
"logSize",
",",
"}",
"\n",
"runtime",
".",
"SetFinalizer",
"(",
"fs",
",",
"(",
"*",
"fileStorage",
")",
".",
"Close",
")",
"\n",
"return",
"fs",
",",
"nil",
"\n",
"}"
] | // OpenFile returns a new filesystem-backed storage implementation with the given
// path. This also acquire a file lock, so any subsequent attempt to open the
// same path will fail.
//
// The storage must be closed after use, by calling Close method. | [
"OpenFile",
"returns",
"a",
"new",
"filesystem",
"-",
"backed",
"storage",
"implementation",
"with",
"the",
"given",
"path",
".",
"This",
"also",
"acquire",
"a",
"file",
"lock",
"so",
"any",
"subsequent",
"attempt",
"to",
"open",
"the",
"same",
"path",
"will",
"fail",
".",
"The",
"storage",
"must",
"be",
"closed",
"after",
"use",
"by",
"calling",
"Close",
"method",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/storage/file_storage.go#L94-L143 | train |
syndtr/goleveldb | leveldb/db_snapshot.go | acquireSnapshot | func (db *DB) acquireSnapshot() *snapshotElement {
db.snapsMu.Lock()
defer db.snapsMu.Unlock()
seq := db.getSeq()
if e := db.snapsList.Back(); e != nil {
se := e.Value.(*snapshotElement)
if se.seq == seq {
se.ref++
return se
} else if seq < se.seq {
panic("leveldb: sequence number is not increasing")
}
}
se := &snapshotElement{seq: seq, ref: 1}
se.e = db.snapsList.PushBack(se)
return se
} | go | func (db *DB) acquireSnapshot() *snapshotElement {
db.snapsMu.Lock()
defer db.snapsMu.Unlock()
seq := db.getSeq()
if e := db.snapsList.Back(); e != nil {
se := e.Value.(*snapshotElement)
if se.seq == seq {
se.ref++
return se
} else if seq < se.seq {
panic("leveldb: sequence number is not increasing")
}
}
se := &snapshotElement{seq: seq, ref: 1}
se.e = db.snapsList.PushBack(se)
return se
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"acquireSnapshot",
"(",
")",
"*",
"snapshotElement",
"{",
"db",
".",
"snapsMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"db",
".",
"snapsMu",
".",
"Unlock",
"(",
")",
"\n\n",
"seq",
":=",
"db",
".",
"getSeq",
"(",
")",
"\n\n",
"if",
"e",
":=",
"db",
".",
"snapsList",
".",
"Back",
"(",
")",
";",
"e",
"!=",
"nil",
"{",
"se",
":=",
"e",
".",
"Value",
".",
"(",
"*",
"snapshotElement",
")",
"\n",
"if",
"se",
".",
"seq",
"==",
"seq",
"{",
"se",
".",
"ref",
"++",
"\n",
"return",
"se",
"\n",
"}",
"else",
"if",
"seq",
"<",
"se",
".",
"seq",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"se",
":=",
"&",
"snapshotElement",
"{",
"seq",
":",
"seq",
",",
"ref",
":",
"1",
"}",
"\n",
"se",
".",
"e",
"=",
"db",
".",
"snapsList",
".",
"PushBack",
"(",
"se",
")",
"\n",
"return",
"se",
"\n",
"}"
] | // Acquires a snapshot, based on latest sequence. | [
"Acquires",
"a",
"snapshot",
"based",
"on",
"latest",
"sequence",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/db_snapshot.go#L28-L46 | train |
syndtr/goleveldb | leveldb/db_snapshot.go | releaseSnapshot | func (db *DB) releaseSnapshot(se *snapshotElement) {
db.snapsMu.Lock()
defer db.snapsMu.Unlock()
se.ref--
if se.ref == 0 {
db.snapsList.Remove(se.e)
se.e = nil
} else if se.ref < 0 {
panic("leveldb: Snapshot: negative element reference")
}
} | go | func (db *DB) releaseSnapshot(se *snapshotElement) {
db.snapsMu.Lock()
defer db.snapsMu.Unlock()
se.ref--
if se.ref == 0 {
db.snapsList.Remove(se.e)
se.e = nil
} else if se.ref < 0 {
panic("leveldb: Snapshot: negative element reference")
}
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"releaseSnapshot",
"(",
"se",
"*",
"snapshotElement",
")",
"{",
"db",
".",
"snapsMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"db",
".",
"snapsMu",
".",
"Unlock",
"(",
")",
"\n\n",
"se",
".",
"ref",
"--",
"\n",
"if",
"se",
".",
"ref",
"==",
"0",
"{",
"db",
".",
"snapsList",
".",
"Remove",
"(",
"se",
".",
"e",
")",
"\n",
"se",
".",
"e",
"=",
"nil",
"\n",
"}",
"else",
"if",
"se",
".",
"ref",
"<",
"0",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}"
] | // Releases given snapshot element. | [
"Releases",
"given",
"snapshot",
"element",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/db_snapshot.go#L49-L60 | train |
syndtr/goleveldb | leveldb/db_snapshot.go | minSeq | func (db *DB) minSeq() uint64 {
db.snapsMu.Lock()
defer db.snapsMu.Unlock()
if e := db.snapsList.Front(); e != nil {
return e.Value.(*snapshotElement).seq
}
return db.getSeq()
} | go | func (db *DB) minSeq() uint64 {
db.snapsMu.Lock()
defer db.snapsMu.Unlock()
if e := db.snapsList.Front(); e != nil {
return e.Value.(*snapshotElement).seq
}
return db.getSeq()
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"minSeq",
"(",
")",
"uint64",
"{",
"db",
".",
"snapsMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"db",
".",
"snapsMu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"e",
":=",
"db",
".",
"snapsList",
".",
"Front",
"(",
")",
";",
"e",
"!=",
"nil",
"{",
"return",
"e",
".",
"Value",
".",
"(",
"*",
"snapshotElement",
")",
".",
"seq",
"\n",
"}",
"\n\n",
"return",
"db",
".",
"getSeq",
"(",
")",
"\n",
"}"
] | // Gets minimum sequence that not being snapshotted. | [
"Gets",
"minimum",
"sequence",
"that",
"not",
"being",
"snapshotted",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/db_snapshot.go#L63-L72 | train |
syndtr/goleveldb | leveldb/db_snapshot.go | newSnapshot | func (db *DB) newSnapshot() *Snapshot {
snap := &Snapshot{
db: db,
elem: db.acquireSnapshot(),
}
atomic.AddInt32(&db.aliveSnaps, 1)
runtime.SetFinalizer(snap, (*Snapshot).Release)
return snap
} | go | func (db *DB) newSnapshot() *Snapshot {
snap := &Snapshot{
db: db,
elem: db.acquireSnapshot(),
}
atomic.AddInt32(&db.aliveSnaps, 1)
runtime.SetFinalizer(snap, (*Snapshot).Release)
return snap
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"newSnapshot",
"(",
")",
"*",
"Snapshot",
"{",
"snap",
":=",
"&",
"Snapshot",
"{",
"db",
":",
"db",
",",
"elem",
":",
"db",
".",
"acquireSnapshot",
"(",
")",
",",
"}",
"\n",
"atomic",
".",
"AddInt32",
"(",
"&",
"db",
".",
"aliveSnaps",
",",
"1",
")",
"\n",
"runtime",
".",
"SetFinalizer",
"(",
"snap",
",",
"(",
"*",
"Snapshot",
")",
".",
"Release",
")",
"\n",
"return",
"snap",
"\n",
"}"
] | // Creates new snapshot object. | [
"Creates",
"new",
"snapshot",
"object",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/db_snapshot.go#L83-L91 | train |
syndtr/goleveldb | leveldb/db_snapshot.go | Get | func (snap *Snapshot) Get(key []byte, ro *opt.ReadOptions) (value []byte, err error) {
err = snap.db.ok()
if err != nil {
return
}
snap.mu.RLock()
defer snap.mu.RUnlock()
if snap.released {
err = ErrSnapshotReleased
return
}
return snap.db.get(nil, nil, key, snap.elem.seq, ro)
} | go | func (snap *Snapshot) Get(key []byte, ro *opt.ReadOptions) (value []byte, err error) {
err = snap.db.ok()
if err != nil {
return
}
snap.mu.RLock()
defer snap.mu.RUnlock()
if snap.released {
err = ErrSnapshotReleased
return
}
return snap.db.get(nil, nil, key, snap.elem.seq, ro)
} | [
"func",
"(",
"snap",
"*",
"Snapshot",
")",
"Get",
"(",
"key",
"[",
"]",
"byte",
",",
"ro",
"*",
"opt",
".",
"ReadOptions",
")",
"(",
"value",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"err",
"=",
"snap",
".",
"db",
".",
"ok",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"snap",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"snap",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"snap",
".",
"released",
"{",
"err",
"=",
"ErrSnapshotReleased",
"\n",
"return",
"\n",
"}",
"\n",
"return",
"snap",
".",
"db",
".",
"get",
"(",
"nil",
",",
"nil",
",",
"key",
",",
"snap",
".",
"elem",
".",
"seq",
",",
"ro",
")",
"\n",
"}"
] | // Get gets the value for the given key. It returns ErrNotFound if
// the DB does not contains the key.
//
// The caller should not modify the contents of the returned slice, but
// it is safe to modify the contents of the argument after Get returns. | [
"Get",
"gets",
"the",
"value",
"for",
"the",
"given",
"key",
".",
"It",
"returns",
"ErrNotFound",
"if",
"the",
"DB",
"does",
"not",
"contains",
"the",
"key",
".",
"The",
"caller",
"should",
"not",
"modify",
"the",
"contents",
"of",
"the",
"returned",
"slice",
"but",
"it",
"is",
"safe",
"to",
"modify",
"the",
"contents",
"of",
"the",
"argument",
"after",
"Get",
"returns",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/db_snapshot.go#L102-L114 | train |
syndtr/goleveldb | leveldb/db_snapshot.go | Has | func (snap *Snapshot) Has(key []byte, ro *opt.ReadOptions) (ret bool, err error) {
err = snap.db.ok()
if err != nil {
return
}
snap.mu.RLock()
defer snap.mu.RUnlock()
if snap.released {
err = ErrSnapshotReleased
return
}
return snap.db.has(nil, nil, key, snap.elem.seq, ro)
} | go | func (snap *Snapshot) Has(key []byte, ro *opt.ReadOptions) (ret bool, err error) {
err = snap.db.ok()
if err != nil {
return
}
snap.mu.RLock()
defer snap.mu.RUnlock()
if snap.released {
err = ErrSnapshotReleased
return
}
return snap.db.has(nil, nil, key, snap.elem.seq, ro)
} | [
"func",
"(",
"snap",
"*",
"Snapshot",
")",
"Has",
"(",
"key",
"[",
"]",
"byte",
",",
"ro",
"*",
"opt",
".",
"ReadOptions",
")",
"(",
"ret",
"bool",
",",
"err",
"error",
")",
"{",
"err",
"=",
"snap",
".",
"db",
".",
"ok",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"snap",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"snap",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"snap",
".",
"released",
"{",
"err",
"=",
"ErrSnapshotReleased",
"\n",
"return",
"\n",
"}",
"\n",
"return",
"snap",
".",
"db",
".",
"has",
"(",
"nil",
",",
"nil",
",",
"key",
",",
"snap",
".",
"elem",
".",
"seq",
",",
"ro",
")",
"\n",
"}"
] | // Has returns true if the DB does contains the given key.
//
// It is safe to modify the contents of the argument after Get returns. | [
"Has",
"returns",
"true",
"if",
"the",
"DB",
"does",
"contains",
"the",
"given",
"key",
".",
"It",
"is",
"safe",
"to",
"modify",
"the",
"contents",
"of",
"the",
"argument",
"after",
"Get",
"returns",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/db_snapshot.go#L119-L131 | train |
syndtr/goleveldb | leveldb/db_snapshot.go | Release | func (snap *Snapshot) Release() {
snap.mu.Lock()
defer snap.mu.Unlock()
if !snap.released {
// Clear the finalizer.
runtime.SetFinalizer(snap, nil)
snap.released = true
snap.db.releaseSnapshot(snap.elem)
atomic.AddInt32(&snap.db.aliveSnaps, -1)
snap.db = nil
snap.elem = nil
}
} | go | func (snap *Snapshot) Release() {
snap.mu.Lock()
defer snap.mu.Unlock()
if !snap.released {
// Clear the finalizer.
runtime.SetFinalizer(snap, nil)
snap.released = true
snap.db.releaseSnapshot(snap.elem)
atomic.AddInt32(&snap.db.aliveSnaps, -1)
snap.db = nil
snap.elem = nil
}
} | [
"func",
"(",
"snap",
"*",
"Snapshot",
")",
"Release",
"(",
")",
"{",
"snap",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"snap",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"!",
"snap",
".",
"released",
"{",
"// Clear the finalizer.",
"runtime",
".",
"SetFinalizer",
"(",
"snap",
",",
"nil",
")",
"\n\n",
"snap",
".",
"released",
"=",
"true",
"\n",
"snap",
".",
"db",
".",
"releaseSnapshot",
"(",
"snap",
".",
"elem",
")",
"\n",
"atomic",
".",
"AddInt32",
"(",
"&",
"snap",
".",
"db",
".",
"aliveSnaps",
",",
"-",
"1",
")",
"\n",
"snap",
".",
"db",
"=",
"nil",
"\n",
"snap",
".",
"elem",
"=",
"nil",
"\n",
"}",
"\n",
"}"
] | // Release releases the snapshot. This will not release any returned
// iterators, the iterators would still be valid until released or the
// underlying DB is closed.
//
// Other methods should not be called after the snapshot has been released. | [
"Release",
"releases",
"the",
"snapshot",
".",
"This",
"will",
"not",
"release",
"any",
"returned",
"iterators",
"the",
"iterators",
"would",
"still",
"be",
"valid",
"until",
"released",
"or",
"the",
"underlying",
"DB",
"is",
"closed",
".",
"Other",
"methods",
"should",
"not",
"be",
"called",
"after",
"the",
"snapshot",
"has",
"been",
"released",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/db_snapshot.go#L173-L187 | train |
syndtr/goleveldb | leveldb/db_compaction.go | resumeWrite | func (db *DB) resumeWrite() bool {
v := db.s.version()
defer v.release()
if v.tLen(0) < db.s.o.GetWriteL0PauseTrigger() {
return true
}
return false
} | go | func (db *DB) resumeWrite() bool {
v := db.s.version()
defer v.release()
if v.tLen(0) < db.s.o.GetWriteL0PauseTrigger() {
return true
}
return false
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"resumeWrite",
"(",
")",
"bool",
"{",
"v",
":=",
"db",
".",
"s",
".",
"version",
"(",
")",
"\n",
"defer",
"v",
".",
"release",
"(",
")",
"\n",
"if",
"v",
".",
"tLen",
"(",
"0",
")",
"<",
"db",
".",
"s",
".",
"o",
".",
"GetWriteL0PauseTrigger",
"(",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // resumeWrite returns an indicator whether we should resume write operation if enough level0 files are compacted. | [
"resumeWrite",
"returns",
"an",
"indicator",
"whether",
"we",
"should",
"resume",
"write",
"operation",
"if",
"enough",
"level0",
"files",
"are",
"compacted",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/db_compaction.go#L644-L651 | train |
syndtr/goleveldb | leveldb/db_compaction.go | compTriggerRange | func (db *DB) compTriggerRange(compC chan<- cCmd, level int, min, max []byte) (err error) {
ch := make(chan error)
defer close(ch)
// Send cmd.
select {
case compC <- cRange{level, min, max, ch}:
case err := <-db.compErrC:
return err
case <-db.closeC:
return ErrClosed
}
// Wait cmd.
select {
case err = <-ch:
case err = <-db.compErrC:
case <-db.closeC:
return ErrClosed
}
return err
} | go | func (db *DB) compTriggerRange(compC chan<- cCmd, level int, min, max []byte) (err error) {
ch := make(chan error)
defer close(ch)
// Send cmd.
select {
case compC <- cRange{level, min, max, ch}:
case err := <-db.compErrC:
return err
case <-db.closeC:
return ErrClosed
}
// Wait cmd.
select {
case err = <-ch:
case err = <-db.compErrC:
case <-db.closeC:
return ErrClosed
}
return err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"compTriggerRange",
"(",
"compC",
"chan",
"<-",
"cCmd",
",",
"level",
"int",
",",
"min",
",",
"max",
"[",
"]",
"byte",
")",
"(",
"err",
"error",
")",
"{",
"ch",
":=",
"make",
"(",
"chan",
"error",
")",
"\n",
"defer",
"close",
"(",
"ch",
")",
"\n",
"// Send cmd.",
"select",
"{",
"case",
"compC",
"<-",
"cRange",
"{",
"level",
",",
"min",
",",
"max",
",",
"ch",
"}",
":",
"case",
"err",
":=",
"<-",
"db",
".",
"compErrC",
":",
"return",
"err",
"\n",
"case",
"<-",
"db",
".",
"closeC",
":",
"return",
"ErrClosed",
"\n",
"}",
"\n",
"// Wait cmd.",
"select",
"{",
"case",
"err",
"=",
"<-",
"ch",
":",
"case",
"err",
"=",
"<-",
"db",
".",
"compErrC",
":",
"case",
"<-",
"db",
".",
"closeC",
":",
"return",
"ErrClosed",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | // Send range compaction request. | [
"Send",
"range",
"compaction",
"request",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/db_compaction.go#L725-L744 | train |
syndtr/goleveldb | leveldb/util/crc32.go | Update | func (c CRC) Update(b []byte) CRC {
return CRC(crc32.Update(uint32(c), table, b))
} | go | func (c CRC) Update(b []byte) CRC {
return CRC(crc32.Update(uint32(c), table, b))
} | [
"func",
"(",
"c",
"CRC",
")",
"Update",
"(",
"b",
"[",
"]",
"byte",
")",
"CRC",
"{",
"return",
"CRC",
"(",
"crc32",
".",
"Update",
"(",
"uint32",
"(",
"c",
")",
",",
"table",
",",
"b",
")",
")",
"\n",
"}"
] | // Update updates the crc with the given bytes. | [
"Update",
"updates",
"the",
"crc",
"with",
"the",
"given",
"bytes",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/util/crc32.go#L23-L25 | train |
syndtr/goleveldb | leveldb/util/buffer_pool.go | Put | func (p *BufferPool) Put(b []byte) {
if p == nil {
return
}
p.mu.RLock()
defer p.mu.RUnlock()
if p.closed {
return
}
atomic.AddUint32(&p.put, 1)
pool := p.pool[p.poolNum(cap(b))]
select {
case pool <- b:
default:
}
} | go | func (p *BufferPool) Put(b []byte) {
if p == nil {
return
}
p.mu.RLock()
defer p.mu.RUnlock()
if p.closed {
return
}
atomic.AddUint32(&p.put, 1)
pool := p.pool[p.poolNum(cap(b))]
select {
case pool <- b:
default:
}
} | [
"func",
"(",
"p",
"*",
"BufferPool",
")",
"Put",
"(",
"b",
"[",
"]",
"byte",
")",
"{",
"if",
"p",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"p",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"p",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n\n",
"if",
"p",
".",
"closed",
"{",
"return",
"\n",
"}",
"\n\n",
"atomic",
".",
"AddUint32",
"(",
"&",
"p",
".",
"put",
",",
"1",
")",
"\n\n",
"pool",
":=",
"p",
".",
"pool",
"[",
"p",
".",
"poolNum",
"(",
"cap",
"(",
"b",
")",
")",
"]",
"\n",
"select",
"{",
"case",
"pool",
"<-",
"b",
":",
"default",
":",
"}",
"\n\n",
"}"
] | // Put adds given buffer to the pool. | [
"Put",
"adds",
"given",
"buffer",
"to",
"the",
"pool",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/util/buffer_pool.go#L158-L178 | train |
syndtr/goleveldb | leveldb/util/buffer_pool.go | NewBufferPool | func NewBufferPool(baseline int) *BufferPool {
if baseline <= 0 {
panic("baseline can't be <= 0")
}
p := &BufferPool{
baseline0: baseline,
baseline: [...]int{baseline / 4, baseline / 2, baseline * 2, baseline * 4},
closeC: make(chan struct{}, 1),
}
for i, cap := range []int{2, 2, 4, 4, 2, 1} {
p.pool[i] = make(chan []byte, cap)
}
go p.drain()
return p
} | go | func NewBufferPool(baseline int) *BufferPool {
if baseline <= 0 {
panic("baseline can't be <= 0")
}
p := &BufferPool{
baseline0: baseline,
baseline: [...]int{baseline / 4, baseline / 2, baseline * 2, baseline * 4},
closeC: make(chan struct{}, 1),
}
for i, cap := range []int{2, 2, 4, 4, 2, 1} {
p.pool[i] = make(chan []byte, cap)
}
go p.drain()
return p
} | [
"func",
"NewBufferPool",
"(",
"baseline",
"int",
")",
"*",
"BufferPool",
"{",
"if",
"baseline",
"<=",
"0",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"p",
":=",
"&",
"BufferPool",
"{",
"baseline0",
":",
"baseline",
",",
"baseline",
":",
"[",
"...",
"]",
"int",
"{",
"baseline",
"/",
"4",
",",
"baseline",
"/",
"2",
",",
"baseline",
"*",
"2",
",",
"baseline",
"*",
"4",
"}",
",",
"closeC",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
",",
"1",
")",
",",
"}",
"\n",
"for",
"i",
",",
"cap",
":=",
"range",
"[",
"]",
"int",
"{",
"2",
",",
"2",
",",
"4",
",",
"4",
",",
"2",
",",
"1",
"}",
"{",
"p",
".",
"pool",
"[",
"i",
"]",
"=",
"make",
"(",
"chan",
"[",
"]",
"byte",
",",
"cap",
")",
"\n",
"}",
"\n",
"go",
"p",
".",
"drain",
"(",
")",
"\n",
"return",
"p",
"\n",
"}"
] | // NewBufferPool creates a new initialized 'buffer pool'. | [
"NewBufferPool",
"creates",
"a",
"new",
"initialized",
"buffer",
"pool",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/util/buffer_pool.go#L225-L239 | train |
syndtr/goleveldb | leveldb/table.go | after | func (t *tFile) after(icmp *iComparer, ukey []byte) bool {
return ukey != nil && icmp.uCompare(ukey, t.imax.ukey()) > 0
} | go | func (t *tFile) after(icmp *iComparer, ukey []byte) bool {
return ukey != nil && icmp.uCompare(ukey, t.imax.ukey()) > 0
} | [
"func",
"(",
"t",
"*",
"tFile",
")",
"after",
"(",
"icmp",
"*",
"iComparer",
",",
"ukey",
"[",
"]",
"byte",
")",
"bool",
"{",
"return",
"ukey",
"!=",
"nil",
"&&",
"icmp",
".",
"uCompare",
"(",
"ukey",
",",
"t",
".",
"imax",
".",
"ukey",
"(",
")",
")",
">",
"0",
"\n",
"}"
] | // Returns true if given key is after largest key of this table. | [
"Returns",
"true",
"if",
"given",
"key",
"is",
"after",
"largest",
"key",
"of",
"this",
"table",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/table.go#L32-L34 | train |
syndtr/goleveldb | leveldb/table.go | before | func (t *tFile) before(icmp *iComparer, ukey []byte) bool {
return ukey != nil && icmp.uCompare(ukey, t.imin.ukey()) < 0
} | go | func (t *tFile) before(icmp *iComparer, ukey []byte) bool {
return ukey != nil && icmp.uCompare(ukey, t.imin.ukey()) < 0
} | [
"func",
"(",
"t",
"*",
"tFile",
")",
"before",
"(",
"icmp",
"*",
"iComparer",
",",
"ukey",
"[",
"]",
"byte",
")",
"bool",
"{",
"return",
"ukey",
"!=",
"nil",
"&&",
"icmp",
".",
"uCompare",
"(",
"ukey",
",",
"t",
".",
"imin",
".",
"ukey",
"(",
")",
")",
"<",
"0",
"\n",
"}"
] | // Returns true if given key is before smallest key of this table. | [
"Returns",
"true",
"if",
"given",
"key",
"is",
"before",
"smallest",
"key",
"of",
"this",
"table",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/table.go#L37-L39 | train |
syndtr/goleveldb | leveldb/table.go | overlaps | func (t *tFile) overlaps(icmp *iComparer, umin, umax []byte) bool {
return !t.after(icmp, umin) && !t.before(icmp, umax)
} | go | func (t *tFile) overlaps(icmp *iComparer, umin, umax []byte) bool {
return !t.after(icmp, umin) && !t.before(icmp, umax)
} | [
"func",
"(",
"t",
"*",
"tFile",
")",
"overlaps",
"(",
"icmp",
"*",
"iComparer",
",",
"umin",
",",
"umax",
"[",
"]",
"byte",
")",
"bool",
"{",
"return",
"!",
"t",
".",
"after",
"(",
"icmp",
",",
"umin",
")",
"&&",
"!",
"t",
".",
"before",
"(",
"icmp",
",",
"umax",
")",
"\n",
"}"
] | // Returns true if given key range overlaps with this table key range. | [
"Returns",
"true",
"if",
"given",
"key",
"range",
"overlaps",
"with",
"this",
"table",
"key",
"range",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/table.go#L42-L44 | train |
syndtr/goleveldb | leveldb/table.go | newTableFile | func newTableFile(fd storage.FileDesc, size int64, imin, imax internalKey) *tFile {
f := &tFile{
fd: fd,
size: size,
imin: imin,
imax: imax,
}
// We arrange to automatically compact this file after
// a certain number of seeks. Let's assume:
// (1) One seek costs 10ms
// (2) Writing or reading 1MB costs 10ms (100MB/s)
// (3) A compaction of 1MB does 25MB of IO:
// 1MB read from this level
// 10-12MB read from next level (boundaries may be misaligned)
// 10-12MB written to next level
// This implies that 25 seeks cost the same as the compaction
// of 1MB of data. I.e., one seek costs approximately the
// same as the compaction of 40KB of data. We are a little
// conservative and allow approximately one seek for every 16KB
// of data before triggering a compaction.
f.seekLeft = int32(size / 16384)
if f.seekLeft < 100 {
f.seekLeft = 100
}
return f
} | go | func newTableFile(fd storage.FileDesc, size int64, imin, imax internalKey) *tFile {
f := &tFile{
fd: fd,
size: size,
imin: imin,
imax: imax,
}
// We arrange to automatically compact this file after
// a certain number of seeks. Let's assume:
// (1) One seek costs 10ms
// (2) Writing or reading 1MB costs 10ms (100MB/s)
// (3) A compaction of 1MB does 25MB of IO:
// 1MB read from this level
// 10-12MB read from next level (boundaries may be misaligned)
// 10-12MB written to next level
// This implies that 25 seeks cost the same as the compaction
// of 1MB of data. I.e., one seek costs approximately the
// same as the compaction of 40KB of data. We are a little
// conservative and allow approximately one seek for every 16KB
// of data before triggering a compaction.
f.seekLeft = int32(size / 16384)
if f.seekLeft < 100 {
f.seekLeft = 100
}
return f
} | [
"func",
"newTableFile",
"(",
"fd",
"storage",
".",
"FileDesc",
",",
"size",
"int64",
",",
"imin",
",",
"imax",
"internalKey",
")",
"*",
"tFile",
"{",
"f",
":=",
"&",
"tFile",
"{",
"fd",
":",
"fd",
",",
"size",
":",
"size",
",",
"imin",
":",
"imin",
",",
"imax",
":",
"imax",
",",
"}",
"\n\n",
"// We arrange to automatically compact this file after",
"// a certain number of seeks. Let's assume:",
"// (1) One seek costs 10ms",
"// (2) Writing or reading 1MB costs 10ms (100MB/s)",
"// (3) A compaction of 1MB does 25MB of IO:",
"// 1MB read from this level",
"// 10-12MB read from next level (boundaries may be misaligned)",
"// 10-12MB written to next level",
"// This implies that 25 seeks cost the same as the compaction",
"// of 1MB of data. I.e., one seek costs approximately the",
"// same as the compaction of 40KB of data. We are a little",
"// conservative and allow approximately one seek for every 16KB",
"// of data before triggering a compaction.",
"f",
".",
"seekLeft",
"=",
"int32",
"(",
"size",
"/",
"16384",
")",
"\n",
"if",
"f",
".",
"seekLeft",
"<",
"100",
"{",
"f",
".",
"seekLeft",
"=",
"100",
"\n",
"}",
"\n\n",
"return",
"f",
"\n",
"}"
] | // Creates new tFile. | [
"Creates",
"new",
"tFile",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/table.go#L52-L79 | train |
syndtr/goleveldb | leveldb/table.go | lessByKey | func (tf tFiles) lessByKey(icmp *iComparer, i, j int) bool {
a, b := tf[i], tf[j]
n := icmp.Compare(a.imin, b.imin)
if n == 0 {
return a.fd.Num < b.fd.Num
}
return n < 0
} | go | func (tf tFiles) lessByKey(icmp *iComparer, i, j int) bool {
a, b := tf[i], tf[j]
n := icmp.Compare(a.imin, b.imin)
if n == 0 {
return a.fd.Num < b.fd.Num
}
return n < 0
} | [
"func",
"(",
"tf",
"tFiles",
")",
"lessByKey",
"(",
"icmp",
"*",
"iComparer",
",",
"i",
",",
"j",
"int",
")",
"bool",
"{",
"a",
",",
"b",
":=",
"tf",
"[",
"i",
"]",
",",
"tf",
"[",
"j",
"]",
"\n",
"n",
":=",
"icmp",
".",
"Compare",
"(",
"a",
".",
"imin",
",",
"b",
".",
"imin",
")",
"\n",
"if",
"n",
"==",
"0",
"{",
"return",
"a",
".",
"fd",
".",
"Num",
"<",
"b",
".",
"fd",
".",
"Num",
"\n",
"}",
"\n",
"return",
"n",
"<",
"0",
"\n",
"}"
] | // Returns true if i smallest key is less than j.
// This used for sort by key in ascending order. | [
"Returns",
"true",
"if",
"i",
"smallest",
"key",
"is",
"less",
"than",
"j",
".",
"This",
"used",
"for",
"sort",
"by",
"key",
"in",
"ascending",
"order",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/table.go#L105-L112 | train |
syndtr/goleveldb | leveldb/table.go | lessByNum | func (tf tFiles) lessByNum(i, j int) bool {
return tf[i].fd.Num > tf[j].fd.Num
} | go | func (tf tFiles) lessByNum(i, j int) bool {
return tf[i].fd.Num > tf[j].fd.Num
} | [
"func",
"(",
"tf",
"tFiles",
")",
"lessByNum",
"(",
"i",
",",
"j",
"int",
")",
"bool",
"{",
"return",
"tf",
"[",
"i",
"]",
".",
"fd",
".",
"Num",
">",
"tf",
"[",
"j",
"]",
".",
"fd",
".",
"Num",
"\n",
"}"
] | // Returns true if i file number is greater than j.
// This used for sort by file number in descending order. | [
"Returns",
"true",
"if",
"i",
"file",
"number",
"is",
"greater",
"than",
"j",
".",
"This",
"used",
"for",
"sort",
"by",
"file",
"number",
"in",
"descending",
"order",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/table.go#L116-L118 | train |
syndtr/goleveldb | leveldb/table.go | sortByKey | func (tf tFiles) sortByKey(icmp *iComparer) {
sort.Sort(&tFilesSortByKey{tFiles: tf, icmp: icmp})
} | go | func (tf tFiles) sortByKey(icmp *iComparer) {
sort.Sort(&tFilesSortByKey{tFiles: tf, icmp: icmp})
} | [
"func",
"(",
"tf",
"tFiles",
")",
"sortByKey",
"(",
"icmp",
"*",
"iComparer",
")",
"{",
"sort",
".",
"Sort",
"(",
"&",
"tFilesSortByKey",
"{",
"tFiles",
":",
"tf",
",",
"icmp",
":",
"icmp",
"}",
")",
"\n",
"}"
] | // Sorts tables by key in ascending order. | [
"Sorts",
"tables",
"by",
"key",
"in",
"ascending",
"order",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/table.go#L121-L123 | train |
syndtr/goleveldb | leveldb/table.go | size | func (tf tFiles) size() (sum int64) {
for _, t := range tf {
sum += t.size
}
return sum
} | go | func (tf tFiles) size() (sum int64) {
for _, t := range tf {
sum += t.size
}
return sum
} | [
"func",
"(",
"tf",
"tFiles",
")",
"size",
"(",
")",
"(",
"sum",
"int64",
")",
"{",
"for",
"_",
",",
"t",
":=",
"range",
"tf",
"{",
"sum",
"+=",
"t",
".",
"size",
"\n",
"}",
"\n",
"return",
"sum",
"\n",
"}"
] | // Returns sum of all tables size. | [
"Returns",
"sum",
"of",
"all",
"tables",
"size",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/table.go#L131-L136 | train |
syndtr/goleveldb | leveldb/table.go | searchMin | func (tf tFiles) searchMin(icmp *iComparer, ikey internalKey) int {
return sort.Search(len(tf), func(i int) bool {
return icmp.Compare(tf[i].imin, ikey) >= 0
})
} | go | func (tf tFiles) searchMin(icmp *iComparer, ikey internalKey) int {
return sort.Search(len(tf), func(i int) bool {
return icmp.Compare(tf[i].imin, ikey) >= 0
})
} | [
"func",
"(",
"tf",
"tFiles",
")",
"searchMin",
"(",
"icmp",
"*",
"iComparer",
",",
"ikey",
"internalKey",
")",
"int",
"{",
"return",
"sort",
".",
"Search",
"(",
"len",
"(",
"tf",
")",
",",
"func",
"(",
"i",
"int",
")",
"bool",
"{",
"return",
"icmp",
".",
"Compare",
"(",
"tf",
"[",
"i",
"]",
".",
"imin",
",",
"ikey",
")",
">=",
"0",
"\n",
"}",
")",
"\n",
"}"
] | // Searches smallest index of tables whose its smallest
// key is after or equal with given key. | [
"Searches",
"smallest",
"index",
"of",
"tables",
"whose",
"its",
"smallest",
"key",
"is",
"after",
"or",
"equal",
"with",
"given",
"key",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/table.go#L140-L144 | train |
syndtr/goleveldb | leveldb/table.go | searchMax | func (tf tFiles) searchMax(icmp *iComparer, ikey internalKey) int {
return sort.Search(len(tf), func(i int) bool {
return icmp.Compare(tf[i].imax, ikey) >= 0
})
} | go | func (tf tFiles) searchMax(icmp *iComparer, ikey internalKey) int {
return sort.Search(len(tf), func(i int) bool {
return icmp.Compare(tf[i].imax, ikey) >= 0
})
} | [
"func",
"(",
"tf",
"tFiles",
")",
"searchMax",
"(",
"icmp",
"*",
"iComparer",
",",
"ikey",
"internalKey",
")",
"int",
"{",
"return",
"sort",
".",
"Search",
"(",
"len",
"(",
"tf",
")",
",",
"func",
"(",
"i",
"int",
")",
"bool",
"{",
"return",
"icmp",
".",
"Compare",
"(",
"tf",
"[",
"i",
"]",
".",
"imax",
",",
"ikey",
")",
">=",
"0",
"\n",
"}",
")",
"\n",
"}"
] | // Searches smallest index of tables whose its largest
// key is after or equal with given key. | [
"Searches",
"smallest",
"index",
"of",
"tables",
"whose",
"its",
"largest",
"key",
"is",
"after",
"or",
"equal",
"with",
"given",
"key",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/table.go#L148-L152 | train |
syndtr/goleveldb | leveldb/table.go | searchNumLess | func (tf tFiles) searchNumLess(num int64) int {
return sort.Search(len(tf), func(i int) bool {
return tf[i].fd.Num < num
})
} | go | func (tf tFiles) searchNumLess(num int64) int {
return sort.Search(len(tf), func(i int) bool {
return tf[i].fd.Num < num
})
} | [
"func",
"(",
"tf",
"tFiles",
")",
"searchNumLess",
"(",
"num",
"int64",
")",
"int",
"{",
"return",
"sort",
".",
"Search",
"(",
"len",
"(",
"tf",
")",
",",
"func",
"(",
"i",
"int",
")",
"bool",
"{",
"return",
"tf",
"[",
"i",
"]",
".",
"fd",
".",
"Num",
"<",
"num",
"\n",
"}",
")",
"\n",
"}"
] | // Searches smallest index of tables whose its file number
// is smaller than the given number. | [
"Searches",
"smallest",
"index",
"of",
"tables",
"whose",
"its",
"file",
"number",
"is",
"smaller",
"than",
"the",
"given",
"number",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/table.go#L156-L160 | train |
syndtr/goleveldb | leveldb/table.go | searchMinUkey | func (tf tFiles) searchMinUkey(icmp *iComparer, umin []byte) int {
return sort.Search(len(tf), func(i int) bool {
return icmp.ucmp.Compare(tf[i].imin.ukey(), umin) > 0
})
} | go | func (tf tFiles) searchMinUkey(icmp *iComparer, umin []byte) int {
return sort.Search(len(tf), func(i int) bool {
return icmp.ucmp.Compare(tf[i].imin.ukey(), umin) > 0
})
} | [
"func",
"(",
"tf",
"tFiles",
")",
"searchMinUkey",
"(",
"icmp",
"*",
"iComparer",
",",
"umin",
"[",
"]",
"byte",
")",
"int",
"{",
"return",
"sort",
".",
"Search",
"(",
"len",
"(",
"tf",
")",
",",
"func",
"(",
"i",
"int",
")",
"bool",
"{",
"return",
"icmp",
".",
"ucmp",
".",
"Compare",
"(",
"tf",
"[",
"i",
"]",
".",
"imin",
".",
"ukey",
"(",
")",
",",
"umin",
")",
">",
"0",
"\n",
"}",
")",
"\n",
"}"
] | // Searches smallest index of tables whose its smallest
// key is after the given key. | [
"Searches",
"smallest",
"index",
"of",
"tables",
"whose",
"its",
"smallest",
"key",
"is",
"after",
"the",
"given",
"key",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/table.go#L164-L168 | train |
syndtr/goleveldb | leveldb/table.go | searchMaxUkey | func (tf tFiles) searchMaxUkey(icmp *iComparer, umax []byte) int {
return sort.Search(len(tf), func(i int) bool {
return icmp.ucmp.Compare(tf[i].imax.ukey(), umax) > 0
})
} | go | func (tf tFiles) searchMaxUkey(icmp *iComparer, umax []byte) int {
return sort.Search(len(tf), func(i int) bool {
return icmp.ucmp.Compare(tf[i].imax.ukey(), umax) > 0
})
} | [
"func",
"(",
"tf",
"tFiles",
")",
"searchMaxUkey",
"(",
"icmp",
"*",
"iComparer",
",",
"umax",
"[",
"]",
"byte",
")",
"int",
"{",
"return",
"sort",
".",
"Search",
"(",
"len",
"(",
"tf",
")",
",",
"func",
"(",
"i",
"int",
")",
"bool",
"{",
"return",
"icmp",
".",
"ucmp",
".",
"Compare",
"(",
"tf",
"[",
"i",
"]",
".",
"imax",
".",
"ukey",
"(",
")",
",",
"umax",
")",
">",
"0",
"\n",
"}",
")",
"\n",
"}"
] | // Searches smallest index of tables whose its largest
// key is after the given key. | [
"Searches",
"smallest",
"index",
"of",
"tables",
"whose",
"its",
"largest",
"key",
"is",
"after",
"the",
"given",
"key",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/table.go#L172-L176 | train |
syndtr/goleveldb | leveldb/table.go | overlaps | func (tf tFiles) overlaps(icmp *iComparer, umin, umax []byte, unsorted bool) bool {
if unsorted {
// Check against all files.
for _, t := range tf {
if t.overlaps(icmp, umin, umax) {
return true
}
}
return false
}
i := 0
if len(umin) > 0 {
// Find the earliest possible internal key for min.
i = tf.searchMax(icmp, makeInternalKey(nil, umin, keyMaxSeq, keyTypeSeek))
}
if i >= len(tf) {
// Beginning of range is after all files, so no overlap.
return false
}
return !tf[i].before(icmp, umax)
} | go | func (tf tFiles) overlaps(icmp *iComparer, umin, umax []byte, unsorted bool) bool {
if unsorted {
// Check against all files.
for _, t := range tf {
if t.overlaps(icmp, umin, umax) {
return true
}
}
return false
}
i := 0
if len(umin) > 0 {
// Find the earliest possible internal key for min.
i = tf.searchMax(icmp, makeInternalKey(nil, umin, keyMaxSeq, keyTypeSeek))
}
if i >= len(tf) {
// Beginning of range is after all files, so no overlap.
return false
}
return !tf[i].before(icmp, umax)
} | [
"func",
"(",
"tf",
"tFiles",
")",
"overlaps",
"(",
"icmp",
"*",
"iComparer",
",",
"umin",
",",
"umax",
"[",
"]",
"byte",
",",
"unsorted",
"bool",
")",
"bool",
"{",
"if",
"unsorted",
"{",
"// Check against all files.",
"for",
"_",
",",
"t",
":=",
"range",
"tf",
"{",
"if",
"t",
".",
"overlaps",
"(",
"icmp",
",",
"umin",
",",
"umax",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}",
"\n\n",
"i",
":=",
"0",
"\n",
"if",
"len",
"(",
"umin",
")",
">",
"0",
"{",
"// Find the earliest possible internal key for min.",
"i",
"=",
"tf",
".",
"searchMax",
"(",
"icmp",
",",
"makeInternalKey",
"(",
"nil",
",",
"umin",
",",
"keyMaxSeq",
",",
"keyTypeSeek",
")",
")",
"\n",
"}",
"\n",
"if",
"i",
">=",
"len",
"(",
"tf",
")",
"{",
"// Beginning of range is after all files, so no overlap.",
"return",
"false",
"\n",
"}",
"\n",
"return",
"!",
"tf",
"[",
"i",
"]",
".",
"before",
"(",
"icmp",
",",
"umax",
")",
"\n",
"}"
] | // Returns true if given key range overlaps with one or more
// tables key range. If unsorted is true then binary search will not be used. | [
"Returns",
"true",
"if",
"given",
"key",
"range",
"overlaps",
"with",
"one",
"or",
"more",
"tables",
"key",
"range",
".",
"If",
"unsorted",
"is",
"true",
"then",
"binary",
"search",
"will",
"not",
"be",
"used",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/table.go#L180-L201 | train |
syndtr/goleveldb | leveldb/table.go | getRange | func (tf tFiles) getRange(icmp *iComparer) (imin, imax internalKey) {
for i, t := range tf {
if i == 0 {
imin, imax = t.imin, t.imax
continue
}
if icmp.Compare(t.imin, imin) < 0 {
imin = t.imin
}
if icmp.Compare(t.imax, imax) > 0 {
imax = t.imax
}
}
return
} | go | func (tf tFiles) getRange(icmp *iComparer) (imin, imax internalKey) {
for i, t := range tf {
if i == 0 {
imin, imax = t.imin, t.imax
continue
}
if icmp.Compare(t.imin, imin) < 0 {
imin = t.imin
}
if icmp.Compare(t.imax, imax) > 0 {
imax = t.imax
}
}
return
} | [
"func",
"(",
"tf",
"tFiles",
")",
"getRange",
"(",
"icmp",
"*",
"iComparer",
")",
"(",
"imin",
",",
"imax",
"internalKey",
")",
"{",
"for",
"i",
",",
"t",
":=",
"range",
"tf",
"{",
"if",
"i",
"==",
"0",
"{",
"imin",
",",
"imax",
"=",
"t",
".",
"imin",
",",
"t",
".",
"imax",
"\n",
"continue",
"\n",
"}",
"\n",
"if",
"icmp",
".",
"Compare",
"(",
"t",
".",
"imin",
",",
"imin",
")",
"<",
"0",
"{",
"imin",
"=",
"t",
".",
"imin",
"\n",
"}",
"\n",
"if",
"icmp",
".",
"Compare",
"(",
"t",
".",
"imax",
",",
"imax",
")",
">",
"0",
"{",
"imax",
"=",
"t",
".",
"imax",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // Returns tables key range. | [
"Returns",
"tables",
"key",
"range",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/table.go#L279-L294 | train |
syndtr/goleveldb | leveldb/table.go | newIndexIterator | func (tf tFiles) newIndexIterator(tops *tOps, icmp *iComparer, slice *util.Range, ro *opt.ReadOptions) iterator.IteratorIndexer {
if slice != nil {
var start, limit int
if slice.Start != nil {
start = tf.searchMax(icmp, internalKey(slice.Start))
}
if slice.Limit != nil {
limit = tf.searchMin(icmp, internalKey(slice.Limit))
} else {
limit = tf.Len()
}
tf = tf[start:limit]
}
return iterator.NewArrayIndexer(&tFilesArrayIndexer{
tFiles: tf,
tops: tops,
icmp: icmp,
slice: slice,
ro: ro,
})
} | go | func (tf tFiles) newIndexIterator(tops *tOps, icmp *iComparer, slice *util.Range, ro *opt.ReadOptions) iterator.IteratorIndexer {
if slice != nil {
var start, limit int
if slice.Start != nil {
start = tf.searchMax(icmp, internalKey(slice.Start))
}
if slice.Limit != nil {
limit = tf.searchMin(icmp, internalKey(slice.Limit))
} else {
limit = tf.Len()
}
tf = tf[start:limit]
}
return iterator.NewArrayIndexer(&tFilesArrayIndexer{
tFiles: tf,
tops: tops,
icmp: icmp,
slice: slice,
ro: ro,
})
} | [
"func",
"(",
"tf",
"tFiles",
")",
"newIndexIterator",
"(",
"tops",
"*",
"tOps",
",",
"icmp",
"*",
"iComparer",
",",
"slice",
"*",
"util",
".",
"Range",
",",
"ro",
"*",
"opt",
".",
"ReadOptions",
")",
"iterator",
".",
"IteratorIndexer",
"{",
"if",
"slice",
"!=",
"nil",
"{",
"var",
"start",
",",
"limit",
"int",
"\n",
"if",
"slice",
".",
"Start",
"!=",
"nil",
"{",
"start",
"=",
"tf",
".",
"searchMax",
"(",
"icmp",
",",
"internalKey",
"(",
"slice",
".",
"Start",
")",
")",
"\n",
"}",
"\n",
"if",
"slice",
".",
"Limit",
"!=",
"nil",
"{",
"limit",
"=",
"tf",
".",
"searchMin",
"(",
"icmp",
",",
"internalKey",
"(",
"slice",
".",
"Limit",
")",
")",
"\n",
"}",
"else",
"{",
"limit",
"=",
"tf",
".",
"Len",
"(",
")",
"\n",
"}",
"\n",
"tf",
"=",
"tf",
"[",
"start",
":",
"limit",
"]",
"\n",
"}",
"\n",
"return",
"iterator",
".",
"NewArrayIndexer",
"(",
"&",
"tFilesArrayIndexer",
"{",
"tFiles",
":",
"tf",
",",
"tops",
":",
"tops",
",",
"icmp",
":",
"icmp",
",",
"slice",
":",
"slice",
",",
"ro",
":",
"ro",
",",
"}",
")",
"\n",
"}"
] | // Creates iterator index from tables. | [
"Creates",
"iterator",
"index",
"from",
"tables",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/table.go#L297-L317 | train |
syndtr/goleveldb | leveldb/table.go | createFrom | func (t *tOps) createFrom(src iterator.Iterator) (f *tFile, n int, err error) {
w, err := t.create()
if err != nil {
return
}
defer func() {
if err != nil {
w.drop()
}
}()
for src.Next() {
err = w.append(src.Key(), src.Value())
if err != nil {
return
}
}
err = src.Error()
if err != nil {
return
}
n = w.tw.EntriesLen()
f, err = w.finish()
return
} | go | func (t *tOps) createFrom(src iterator.Iterator) (f *tFile, n int, err error) {
w, err := t.create()
if err != nil {
return
}
defer func() {
if err != nil {
w.drop()
}
}()
for src.Next() {
err = w.append(src.Key(), src.Value())
if err != nil {
return
}
}
err = src.Error()
if err != nil {
return
}
n = w.tw.EntriesLen()
f, err = w.finish()
return
} | [
"func",
"(",
"t",
"*",
"tOps",
")",
"createFrom",
"(",
"src",
"iterator",
".",
"Iterator",
")",
"(",
"f",
"*",
"tFile",
",",
"n",
"int",
",",
"err",
"error",
")",
"{",
"w",
",",
"err",
":=",
"t",
".",
"create",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"defer",
"func",
"(",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"w",
".",
"drop",
"(",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"for",
"src",
".",
"Next",
"(",
")",
"{",
"err",
"=",
"w",
".",
"append",
"(",
"src",
".",
"Key",
"(",
")",
",",
"src",
".",
"Value",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"err",
"=",
"src",
".",
"Error",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"n",
"=",
"w",
".",
"tw",
".",
"EntriesLen",
"(",
")",
"\n",
"f",
",",
"err",
"=",
"w",
".",
"finish",
"(",
")",
"\n",
"return",
"\n",
"}"
] | // Builds table from src iterator. | [
"Builds",
"table",
"from",
"src",
"iterator",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/table.go#L384-L410 | train |
syndtr/goleveldb | leveldb/table.go | open | func (t *tOps) open(f *tFile) (ch *cache.Handle, err error) {
ch = t.cache.Get(0, uint64(f.fd.Num), func() (size int, value cache.Value) {
var r storage.Reader
r, err = t.s.stor.Open(f.fd)
if err != nil {
return 0, nil
}
var bcache *cache.NamespaceGetter
if t.bcache != nil {
bcache = &cache.NamespaceGetter{Cache: t.bcache, NS: uint64(f.fd.Num)}
}
var tr *table.Reader
tr, err = table.NewReader(r, f.size, f.fd, bcache, t.bpool, t.s.o.Options)
if err != nil {
r.Close()
return 0, nil
}
return 1, tr
})
if ch == nil && err == nil {
err = ErrClosed
}
return
} | go | func (t *tOps) open(f *tFile) (ch *cache.Handle, err error) {
ch = t.cache.Get(0, uint64(f.fd.Num), func() (size int, value cache.Value) {
var r storage.Reader
r, err = t.s.stor.Open(f.fd)
if err != nil {
return 0, nil
}
var bcache *cache.NamespaceGetter
if t.bcache != nil {
bcache = &cache.NamespaceGetter{Cache: t.bcache, NS: uint64(f.fd.Num)}
}
var tr *table.Reader
tr, err = table.NewReader(r, f.size, f.fd, bcache, t.bpool, t.s.o.Options)
if err != nil {
r.Close()
return 0, nil
}
return 1, tr
})
if ch == nil && err == nil {
err = ErrClosed
}
return
} | [
"func",
"(",
"t",
"*",
"tOps",
")",
"open",
"(",
"f",
"*",
"tFile",
")",
"(",
"ch",
"*",
"cache",
".",
"Handle",
",",
"err",
"error",
")",
"{",
"ch",
"=",
"t",
".",
"cache",
".",
"Get",
"(",
"0",
",",
"uint64",
"(",
"f",
".",
"fd",
".",
"Num",
")",
",",
"func",
"(",
")",
"(",
"size",
"int",
",",
"value",
"cache",
".",
"Value",
")",
"{",
"var",
"r",
"storage",
".",
"Reader",
"\n",
"r",
",",
"err",
"=",
"t",
".",
"s",
".",
"stor",
".",
"Open",
"(",
"f",
".",
"fd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"nil",
"\n",
"}",
"\n\n",
"var",
"bcache",
"*",
"cache",
".",
"NamespaceGetter",
"\n",
"if",
"t",
".",
"bcache",
"!=",
"nil",
"{",
"bcache",
"=",
"&",
"cache",
".",
"NamespaceGetter",
"{",
"Cache",
":",
"t",
".",
"bcache",
",",
"NS",
":",
"uint64",
"(",
"f",
".",
"fd",
".",
"Num",
")",
"}",
"\n",
"}",
"\n\n",
"var",
"tr",
"*",
"table",
".",
"Reader",
"\n",
"tr",
",",
"err",
"=",
"table",
".",
"NewReader",
"(",
"r",
",",
"f",
".",
"size",
",",
"f",
".",
"fd",
",",
"bcache",
",",
"t",
".",
"bpool",
",",
"t",
".",
"s",
".",
"o",
".",
"Options",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"r",
".",
"Close",
"(",
")",
"\n",
"return",
"0",
",",
"nil",
"\n",
"}",
"\n",
"return",
"1",
",",
"tr",
"\n\n",
"}",
")",
"\n",
"if",
"ch",
"==",
"nil",
"&&",
"err",
"==",
"nil",
"{",
"err",
"=",
"ErrClosed",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // Opens table. It returns a cache handle, which should
// be released after use. | [
"Opens",
"table",
".",
"It",
"returns",
"a",
"cache",
"handle",
"which",
"should",
"be",
"released",
"after",
"use",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/table.go#L414-L440 | train |
syndtr/goleveldb | leveldb/table.go | findKey | func (t *tOps) findKey(f *tFile, key []byte, ro *opt.ReadOptions) (rkey []byte, err error) {
ch, err := t.open(f)
if err != nil {
return nil, err
}
defer ch.Release()
return ch.Value().(*table.Reader).FindKey(key, true, ro)
} | go | func (t *tOps) findKey(f *tFile, key []byte, ro *opt.ReadOptions) (rkey []byte, err error) {
ch, err := t.open(f)
if err != nil {
return nil, err
}
defer ch.Release()
return ch.Value().(*table.Reader).FindKey(key, true, ro)
} | [
"func",
"(",
"t",
"*",
"tOps",
")",
"findKey",
"(",
"f",
"*",
"tFile",
",",
"key",
"[",
"]",
"byte",
",",
"ro",
"*",
"opt",
".",
"ReadOptions",
")",
"(",
"rkey",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"ch",
",",
"err",
":=",
"t",
".",
"open",
"(",
"f",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"ch",
".",
"Release",
"(",
")",
"\n",
"return",
"ch",
".",
"Value",
"(",
")",
".",
"(",
"*",
"table",
".",
"Reader",
")",
".",
"FindKey",
"(",
"key",
",",
"true",
",",
"ro",
")",
"\n",
"}"
] | // Finds key that is greater than or equal to the given key. | [
"Finds",
"key",
"that",
"is",
"greater",
"than",
"or",
"equal",
"to",
"the",
"given",
"key",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/table.go#L454-L461 | train |
syndtr/goleveldb | leveldb/table.go | offsetOf | func (t *tOps) offsetOf(f *tFile, key []byte) (offset int64, err error) {
ch, err := t.open(f)
if err != nil {
return
}
defer ch.Release()
return ch.Value().(*table.Reader).OffsetOf(key)
} | go | func (t *tOps) offsetOf(f *tFile, key []byte) (offset int64, err error) {
ch, err := t.open(f)
if err != nil {
return
}
defer ch.Release()
return ch.Value().(*table.Reader).OffsetOf(key)
} | [
"func",
"(",
"t",
"*",
"tOps",
")",
"offsetOf",
"(",
"f",
"*",
"tFile",
",",
"key",
"[",
"]",
"byte",
")",
"(",
"offset",
"int64",
",",
"err",
"error",
")",
"{",
"ch",
",",
"err",
":=",
"t",
".",
"open",
"(",
"f",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"defer",
"ch",
".",
"Release",
"(",
")",
"\n",
"return",
"ch",
".",
"Value",
"(",
")",
".",
"(",
"*",
"table",
".",
"Reader",
")",
".",
"OffsetOf",
"(",
"key",
")",
"\n",
"}"
] | // Returns approximate offset of the given key. | [
"Returns",
"approximate",
"offset",
"of",
"the",
"given",
"key",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/table.go#L464-L471 | train |
syndtr/goleveldb | leveldb/table.go | newIterator | func (t *tOps) newIterator(f *tFile, slice *util.Range, ro *opt.ReadOptions) iterator.Iterator {
ch, err := t.open(f)
if err != nil {
return iterator.NewEmptyIterator(err)
}
iter := ch.Value().(*table.Reader).NewIterator(slice, ro)
iter.SetReleaser(ch)
return iter
} | go | func (t *tOps) newIterator(f *tFile, slice *util.Range, ro *opt.ReadOptions) iterator.Iterator {
ch, err := t.open(f)
if err != nil {
return iterator.NewEmptyIterator(err)
}
iter := ch.Value().(*table.Reader).NewIterator(slice, ro)
iter.SetReleaser(ch)
return iter
} | [
"func",
"(",
"t",
"*",
"tOps",
")",
"newIterator",
"(",
"f",
"*",
"tFile",
",",
"slice",
"*",
"util",
".",
"Range",
",",
"ro",
"*",
"opt",
".",
"ReadOptions",
")",
"iterator",
".",
"Iterator",
"{",
"ch",
",",
"err",
":=",
"t",
".",
"open",
"(",
"f",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"iterator",
".",
"NewEmptyIterator",
"(",
"err",
")",
"\n",
"}",
"\n",
"iter",
":=",
"ch",
".",
"Value",
"(",
")",
".",
"(",
"*",
"table",
".",
"Reader",
")",
".",
"NewIterator",
"(",
"slice",
",",
"ro",
")",
"\n",
"iter",
".",
"SetReleaser",
"(",
"ch",
")",
"\n",
"return",
"iter",
"\n",
"}"
] | // Creates an iterator from the given table. | [
"Creates",
"an",
"iterator",
"from",
"the",
"given",
"table",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/table.go#L474-L482 | train |
syndtr/goleveldb | leveldb/table.go | close | func (t *tOps) close() {
t.bpool.Close()
t.cache.Close()
if t.bcache != nil {
t.bcache.CloseWeak()
}
} | go | func (t *tOps) close() {
t.bpool.Close()
t.cache.Close()
if t.bcache != nil {
t.bcache.CloseWeak()
}
} | [
"func",
"(",
"t",
"*",
"tOps",
")",
"close",
"(",
")",
"{",
"t",
".",
"bpool",
".",
"Close",
"(",
")",
"\n",
"t",
".",
"cache",
".",
"Close",
"(",
")",
"\n",
"if",
"t",
".",
"bcache",
"!=",
"nil",
"{",
"t",
".",
"bcache",
".",
"CloseWeak",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // Closes the table ops instance. It will close all tables,
// regadless still used or not. | [
"Closes",
"the",
"table",
"ops",
"instance",
".",
"It",
"will",
"close",
"all",
"tables",
"regadless",
"still",
"used",
"or",
"not",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/table.go#L501-L507 | train |
syndtr/goleveldb | leveldb/table.go | close | func (w *tWriter) close() {
if w.w != nil {
w.w.Close()
w.w = nil
}
} | go | func (w *tWriter) close() {
if w.w != nil {
w.w.Close()
w.w = nil
}
} | [
"func",
"(",
"w",
"*",
"tWriter",
")",
"close",
"(",
")",
"{",
"if",
"w",
".",
"w",
"!=",
"nil",
"{",
"w",
".",
"w",
".",
"Close",
"(",
")",
"\n",
"w",
".",
"w",
"=",
"nil",
"\n",
"}",
"\n",
"}"
] | // Closes the storage.Writer. | [
"Closes",
"the",
"storage",
".",
"Writer",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/table.go#L566-L571 | train |
syndtr/goleveldb | leveldb/table.go | finish | func (w *tWriter) finish() (f *tFile, err error) {
defer w.close()
err = w.tw.Close()
if err != nil {
return
}
if !w.t.noSync {
err = w.w.Sync()
if err != nil {
return
}
}
f = newTableFile(w.fd, int64(w.tw.BytesLen()), internalKey(w.first), internalKey(w.last))
return
} | go | func (w *tWriter) finish() (f *tFile, err error) {
defer w.close()
err = w.tw.Close()
if err != nil {
return
}
if !w.t.noSync {
err = w.w.Sync()
if err != nil {
return
}
}
f = newTableFile(w.fd, int64(w.tw.BytesLen()), internalKey(w.first), internalKey(w.last))
return
} | [
"func",
"(",
"w",
"*",
"tWriter",
")",
"finish",
"(",
")",
"(",
"f",
"*",
"tFile",
",",
"err",
"error",
")",
"{",
"defer",
"w",
".",
"close",
"(",
")",
"\n",
"err",
"=",
"w",
".",
"tw",
".",
"Close",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"if",
"!",
"w",
".",
"t",
".",
"noSync",
"{",
"err",
"=",
"w",
".",
"w",
".",
"Sync",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"f",
"=",
"newTableFile",
"(",
"w",
".",
"fd",
",",
"int64",
"(",
"w",
".",
"tw",
".",
"BytesLen",
"(",
")",
")",
",",
"internalKey",
"(",
"w",
".",
"first",
")",
",",
"internalKey",
"(",
"w",
".",
"last",
")",
")",
"\n",
"return",
"\n",
"}"
] | // Finalizes the table and returns table file. | [
"Finalizes",
"the",
"table",
"and",
"returns",
"table",
"file",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/table.go#L574-L588 | train |
syndtr/goleveldb | leveldb/table.go | drop | func (w *tWriter) drop() {
w.close()
w.t.s.stor.Remove(w.fd)
w.t.s.reuseFileNum(w.fd.Num)
w.tw = nil
w.first = nil
w.last = nil
} | go | func (w *tWriter) drop() {
w.close()
w.t.s.stor.Remove(w.fd)
w.t.s.reuseFileNum(w.fd.Num)
w.tw = nil
w.first = nil
w.last = nil
} | [
"func",
"(",
"w",
"*",
"tWriter",
")",
"drop",
"(",
")",
"{",
"w",
".",
"close",
"(",
")",
"\n",
"w",
".",
"t",
".",
"s",
".",
"stor",
".",
"Remove",
"(",
"w",
".",
"fd",
")",
"\n",
"w",
".",
"t",
".",
"s",
".",
"reuseFileNum",
"(",
"w",
".",
"fd",
".",
"Num",
")",
"\n",
"w",
".",
"tw",
"=",
"nil",
"\n",
"w",
".",
"first",
"=",
"nil",
"\n",
"w",
".",
"last",
"=",
"nil",
"\n",
"}"
] | // Drops the table. | [
"Drops",
"the",
"table",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/table.go#L591-L598 | train |
syndtr/goleveldb | leveldb/storage/storage.go | FileDescOk | func FileDescOk(fd FileDesc) bool {
switch fd.Type {
case TypeManifest:
case TypeJournal:
case TypeTable:
case TypeTemp:
default:
return false
}
return fd.Num >= 0
} | go | func FileDescOk(fd FileDesc) bool {
switch fd.Type {
case TypeManifest:
case TypeJournal:
case TypeTable:
case TypeTemp:
default:
return false
}
return fd.Num >= 0
} | [
"func",
"FileDescOk",
"(",
"fd",
"FileDesc",
")",
"bool",
"{",
"switch",
"fd",
".",
"Type",
"{",
"case",
"TypeManifest",
":",
"case",
"TypeJournal",
":",
"case",
"TypeTable",
":",
"case",
"TypeTemp",
":",
"default",
":",
"return",
"false",
"\n",
"}",
"\n",
"return",
"fd",
".",
"Num",
">=",
"0",
"\n",
"}"
] | // FileDescOk returns true if fd is a valid 'file descriptor'. | [
"FileDescOk",
"returns",
"true",
"if",
"fd",
"is",
"a",
"valid",
"file",
"descriptor",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/storage/storage.go#L126-L136 | train |
syndtr/goleveldb | leveldb/util/buffer.go | Alloc | func (b *Buffer) Alloc(n int) []byte {
if n < 0 {
panic("leveldb/util.Buffer.Alloc: negative count")
}
m := b.grow(n)
return b.buf[m:]
} | go | func (b *Buffer) Alloc(n int) []byte {
if n < 0 {
panic("leveldb/util.Buffer.Alloc: negative count")
}
m := b.grow(n)
return b.buf[m:]
} | [
"func",
"(",
"b",
"*",
"Buffer",
")",
"Alloc",
"(",
"n",
"int",
")",
"[",
"]",
"byte",
"{",
"if",
"n",
"<",
"0",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"m",
":=",
"b",
".",
"grow",
"(",
"n",
")",
"\n",
"return",
"b",
".",
"buf",
"[",
"m",
":",
"]",
"\n",
"}"
] | // Alloc allocs n bytes of slice from the buffer, growing the buffer as
// needed. If n is negative, Alloc will panic.
// If the buffer can't grow it will panic with bytes.ErrTooLarge. | [
"Alloc",
"allocs",
"n",
"bytes",
"of",
"slice",
"from",
"the",
"buffer",
"growing",
"the",
"buffer",
"as",
"needed",
".",
"If",
"n",
"is",
"negative",
"Alloc",
"will",
"panic",
".",
"If",
"the",
"buffer",
"can",
"t",
"grow",
"it",
"will",
"panic",
"with",
"bytes",
".",
"ErrTooLarge",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/util/buffer.go#L95-L101 | train |
syndtr/goleveldb | leveldb/util/buffer.go | Write | func (b *Buffer) Write(p []byte) (n int, err error) {
m := b.grow(len(p))
return copy(b.buf[m:], p), nil
} | go | func (b *Buffer) Write(p []byte) (n int, err error) {
m := b.grow(len(p))
return copy(b.buf[m:], p), nil
} | [
"func",
"(",
"b",
"*",
"Buffer",
")",
"Write",
"(",
"p",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"m",
":=",
"b",
".",
"grow",
"(",
"len",
"(",
"p",
")",
")",
"\n",
"return",
"copy",
"(",
"b",
".",
"buf",
"[",
"m",
":",
"]",
",",
"p",
")",
",",
"nil",
"\n",
"}"
] | // Write appends the contents of p to the buffer, growing the buffer as
// needed. The return value n is the length of p; err is always nil. If the
// buffer becomes too large, Write will panic with bytes.ErrTooLarge. | [
"Write",
"appends",
"the",
"contents",
"of",
"p",
"to",
"the",
"buffer",
"growing",
"the",
"buffer",
"as",
"needed",
".",
"The",
"return",
"value",
"n",
"is",
"the",
"length",
"of",
"p",
";",
"err",
"is",
"always",
"nil",
".",
"If",
"the",
"buffer",
"becomes",
"too",
"large",
"Write",
"will",
"panic",
"with",
"bytes",
".",
"ErrTooLarge",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/util/buffer.go#L119-L122 | train |
syndtr/goleveldb | leveldb/util/buffer.go | WriteByte | func (b *Buffer) WriteByte(c byte) error {
m := b.grow(1)
b.buf[m] = c
return nil
} | go | func (b *Buffer) WriteByte(c byte) error {
m := b.grow(1)
b.buf[m] = c
return nil
} | [
"func",
"(",
"b",
"*",
"Buffer",
")",
"WriteByte",
"(",
"c",
"byte",
")",
"error",
"{",
"m",
":=",
"b",
".",
"grow",
"(",
"1",
")",
"\n",
"b",
".",
"buf",
"[",
"m",
"]",
"=",
"c",
"\n",
"return",
"nil",
"\n",
"}"
] | // WriteByte appends the byte c to the buffer, growing the buffer as needed.
// The returned error is always nil, but is included to match bufio.Writer's
// WriteByte. If the buffer becomes too large, WriteByte will panic with
// bytes.ErrTooLarge. | [
"WriteByte",
"appends",
"the",
"byte",
"c",
"to",
"the",
"buffer",
"growing",
"the",
"buffer",
"as",
"needed",
".",
"The",
"returned",
"error",
"is",
"always",
"nil",
"but",
"is",
"included",
"to",
"match",
"bufio",
".",
"Writer",
"s",
"WriteByte",
".",
"If",
"the",
"buffer",
"becomes",
"too",
"large",
"WriteByte",
"will",
"panic",
"with",
"bytes",
".",
"ErrTooLarge",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/util/buffer.go#L208-L212 | train |
syndtr/goleveldb | leveldb/db_state.go | addSeq | func (db *DB) addSeq(delta uint64) {
atomic.AddUint64(&db.seq, delta)
} | go | func (db *DB) addSeq(delta uint64) {
atomic.AddUint64(&db.seq, delta)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"addSeq",
"(",
"delta",
"uint64",
")",
"{",
"atomic",
".",
"AddUint64",
"(",
"&",
"db",
".",
"seq",
",",
"delta",
")",
"\n",
"}"
] | // Atomically adds delta to seq. | [
"Atomically",
"adds",
"delta",
"to",
"seq",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/db_state.go#L57-L59 | train |
syndtr/goleveldb | leveldb/db_state.go | newMem | func (db *DB) newMem(n int) (mem *memDB, err error) {
fd := storage.FileDesc{Type: storage.TypeJournal, Num: db.s.allocFileNum()}
w, err := db.s.stor.Create(fd)
if err != nil {
db.s.reuseFileNum(fd.Num)
return
}
db.memMu.Lock()
defer db.memMu.Unlock()
if db.frozenMem != nil {
return nil, errHasFrozenMem
}
if db.journal == nil {
db.journal = journal.NewWriter(w)
} else {
db.journal.Reset(w)
db.journalWriter.Close()
db.frozenJournalFd = db.journalFd
}
db.journalWriter = w
db.journalFd = fd
db.frozenMem = db.mem
mem = db.mpoolGet(n)
mem.incref() // for self
mem.incref() // for caller
db.mem = mem
// The seq only incremented by the writer. And whoever called newMem
// should hold write lock, so no need additional synchronization here.
db.frozenSeq = db.seq
return
} | go | func (db *DB) newMem(n int) (mem *memDB, err error) {
fd := storage.FileDesc{Type: storage.TypeJournal, Num: db.s.allocFileNum()}
w, err := db.s.stor.Create(fd)
if err != nil {
db.s.reuseFileNum(fd.Num)
return
}
db.memMu.Lock()
defer db.memMu.Unlock()
if db.frozenMem != nil {
return nil, errHasFrozenMem
}
if db.journal == nil {
db.journal = journal.NewWriter(w)
} else {
db.journal.Reset(w)
db.journalWriter.Close()
db.frozenJournalFd = db.journalFd
}
db.journalWriter = w
db.journalFd = fd
db.frozenMem = db.mem
mem = db.mpoolGet(n)
mem.incref() // for self
mem.incref() // for caller
db.mem = mem
// The seq only incremented by the writer. And whoever called newMem
// should hold write lock, so no need additional synchronization here.
db.frozenSeq = db.seq
return
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"newMem",
"(",
"n",
"int",
")",
"(",
"mem",
"*",
"memDB",
",",
"err",
"error",
")",
"{",
"fd",
":=",
"storage",
".",
"FileDesc",
"{",
"Type",
":",
"storage",
".",
"TypeJournal",
",",
"Num",
":",
"db",
".",
"s",
".",
"allocFileNum",
"(",
")",
"}",
"\n",
"w",
",",
"err",
":=",
"db",
".",
"s",
".",
"stor",
".",
"Create",
"(",
"fd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"db",
".",
"s",
".",
"reuseFileNum",
"(",
"fd",
".",
"Num",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"db",
".",
"memMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"db",
".",
"memMu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"db",
".",
"frozenMem",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errHasFrozenMem",
"\n",
"}",
"\n\n",
"if",
"db",
".",
"journal",
"==",
"nil",
"{",
"db",
".",
"journal",
"=",
"journal",
".",
"NewWriter",
"(",
"w",
")",
"\n",
"}",
"else",
"{",
"db",
".",
"journal",
".",
"Reset",
"(",
"w",
")",
"\n",
"db",
".",
"journalWriter",
".",
"Close",
"(",
")",
"\n",
"db",
".",
"frozenJournalFd",
"=",
"db",
".",
"journalFd",
"\n",
"}",
"\n",
"db",
".",
"journalWriter",
"=",
"w",
"\n",
"db",
".",
"journalFd",
"=",
"fd",
"\n",
"db",
".",
"frozenMem",
"=",
"db",
".",
"mem",
"\n",
"mem",
"=",
"db",
".",
"mpoolGet",
"(",
"n",
")",
"\n",
"mem",
".",
"incref",
"(",
")",
"// for self",
"\n",
"mem",
".",
"incref",
"(",
")",
"// for caller",
"\n",
"db",
".",
"mem",
"=",
"mem",
"\n",
"// The seq only incremented by the writer. And whoever called newMem",
"// should hold write lock, so no need additional synchronization here.",
"db",
".",
"frozenSeq",
"=",
"db",
".",
"seq",
"\n",
"return",
"\n",
"}"
] | // Create new memdb and froze the old one; need external synchronization.
// newMem only called synchronously by the writer. | [
"Create",
"new",
"memdb",
"and",
"froze",
"the",
"old",
"one",
";",
"need",
"external",
"synchronization",
".",
"newMem",
"only",
"called",
"synchronously",
"by",
"the",
"writer",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/db_state.go#L122-L155 | train |
syndtr/goleveldb | leveldb/db_state.go | getMems | func (db *DB) getMems() (e, f *memDB) {
db.memMu.RLock()
defer db.memMu.RUnlock()
if db.mem != nil {
db.mem.incref()
} else if !db.isClosed() {
panic("nil effective mem")
}
if db.frozenMem != nil {
db.frozenMem.incref()
}
return db.mem, db.frozenMem
} | go | func (db *DB) getMems() (e, f *memDB) {
db.memMu.RLock()
defer db.memMu.RUnlock()
if db.mem != nil {
db.mem.incref()
} else if !db.isClosed() {
panic("nil effective mem")
}
if db.frozenMem != nil {
db.frozenMem.incref()
}
return db.mem, db.frozenMem
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"getMems",
"(",
")",
"(",
"e",
",",
"f",
"*",
"memDB",
")",
"{",
"db",
".",
"memMu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"db",
".",
"memMu",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"db",
".",
"mem",
"!=",
"nil",
"{",
"db",
".",
"mem",
".",
"incref",
"(",
")",
"\n",
"}",
"else",
"if",
"!",
"db",
".",
"isClosed",
"(",
")",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"db",
".",
"frozenMem",
"!=",
"nil",
"{",
"db",
".",
"frozenMem",
".",
"incref",
"(",
")",
"\n",
"}",
"\n",
"return",
"db",
".",
"mem",
",",
"db",
".",
"frozenMem",
"\n",
"}"
] | // Get all memdbs. | [
"Get",
"all",
"memdbs",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/db_state.go#L158-L170 | train |
syndtr/goleveldb | leveldb/db_state.go | getEffectiveMem | func (db *DB) getEffectiveMem() *memDB {
db.memMu.RLock()
defer db.memMu.RUnlock()
if db.mem != nil {
db.mem.incref()
} else if !db.isClosed() {
panic("nil effective mem")
}
return db.mem
} | go | func (db *DB) getEffectiveMem() *memDB {
db.memMu.RLock()
defer db.memMu.RUnlock()
if db.mem != nil {
db.mem.incref()
} else if !db.isClosed() {
panic("nil effective mem")
}
return db.mem
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"getEffectiveMem",
"(",
")",
"*",
"memDB",
"{",
"db",
".",
"memMu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"db",
".",
"memMu",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"db",
".",
"mem",
"!=",
"nil",
"{",
"db",
".",
"mem",
".",
"incref",
"(",
")",
"\n",
"}",
"else",
"if",
"!",
"db",
".",
"isClosed",
"(",
")",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"db",
".",
"mem",
"\n",
"}"
] | // Get effective memdb. | [
"Get",
"effective",
"memdb",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/db_state.go#L173-L182 | train |
syndtr/goleveldb | leveldb/db_state.go | hasFrozenMem | func (db *DB) hasFrozenMem() bool {
db.memMu.RLock()
defer db.memMu.RUnlock()
return db.frozenMem != nil
} | go | func (db *DB) hasFrozenMem() bool {
db.memMu.RLock()
defer db.memMu.RUnlock()
return db.frozenMem != nil
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"hasFrozenMem",
"(",
")",
"bool",
"{",
"db",
".",
"memMu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"db",
".",
"memMu",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"db",
".",
"frozenMem",
"!=",
"nil",
"\n",
"}"
] | // Check whether we has frozen memdb. | [
"Check",
"whether",
"we",
"has",
"frozen",
"memdb",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/db_state.go#L185-L189 | train |
syndtr/goleveldb | leveldb/db_state.go | getFrozenMem | func (db *DB) getFrozenMem() *memDB {
db.memMu.RLock()
defer db.memMu.RUnlock()
if db.frozenMem != nil {
db.frozenMem.incref()
}
return db.frozenMem
} | go | func (db *DB) getFrozenMem() *memDB {
db.memMu.RLock()
defer db.memMu.RUnlock()
if db.frozenMem != nil {
db.frozenMem.incref()
}
return db.frozenMem
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"getFrozenMem",
"(",
")",
"*",
"memDB",
"{",
"db",
".",
"memMu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"db",
".",
"memMu",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"db",
".",
"frozenMem",
"!=",
"nil",
"{",
"db",
".",
"frozenMem",
".",
"incref",
"(",
")",
"\n",
"}",
"\n",
"return",
"db",
".",
"frozenMem",
"\n",
"}"
] | // Get frozen memdb. | [
"Get",
"frozen",
"memdb",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/db_state.go#L192-L199 | train |
syndtr/goleveldb | leveldb/db_state.go | dropFrozenMem | func (db *DB) dropFrozenMem() {
db.memMu.Lock()
if err := db.s.stor.Remove(db.frozenJournalFd); err != nil {
db.logf("journal@remove removing @%d %q", db.frozenJournalFd.Num, err)
} else {
db.logf("journal@remove removed @%d", db.frozenJournalFd.Num)
}
db.frozenJournalFd = storage.FileDesc{}
db.frozenMem.decref()
db.frozenMem = nil
db.memMu.Unlock()
} | go | func (db *DB) dropFrozenMem() {
db.memMu.Lock()
if err := db.s.stor.Remove(db.frozenJournalFd); err != nil {
db.logf("journal@remove removing @%d %q", db.frozenJournalFd.Num, err)
} else {
db.logf("journal@remove removed @%d", db.frozenJournalFd.Num)
}
db.frozenJournalFd = storage.FileDesc{}
db.frozenMem.decref()
db.frozenMem = nil
db.memMu.Unlock()
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"dropFrozenMem",
"(",
")",
"{",
"db",
".",
"memMu",
".",
"Lock",
"(",
")",
"\n",
"if",
"err",
":=",
"db",
".",
"s",
".",
"stor",
".",
"Remove",
"(",
"db",
".",
"frozenJournalFd",
")",
";",
"err",
"!=",
"nil",
"{",
"db",
".",
"logf",
"(",
"\"",
"\"",
",",
"db",
".",
"frozenJournalFd",
".",
"Num",
",",
"err",
")",
"\n",
"}",
"else",
"{",
"db",
".",
"logf",
"(",
"\"",
"\"",
",",
"db",
".",
"frozenJournalFd",
".",
"Num",
")",
"\n",
"}",
"\n",
"db",
".",
"frozenJournalFd",
"=",
"storage",
".",
"FileDesc",
"{",
"}",
"\n",
"db",
".",
"frozenMem",
".",
"decref",
"(",
")",
"\n",
"db",
".",
"frozenMem",
"=",
"nil",
"\n",
"db",
".",
"memMu",
".",
"Unlock",
"(",
")",
"\n",
"}"
] | // Drop frozen memdb; assume that frozen memdb isn't nil. | [
"Drop",
"frozen",
"memdb",
";",
"assume",
"that",
"frozen",
"memdb",
"isn",
"t",
"nil",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/db_state.go#L202-L213 | train |
syndtr/goleveldb | leveldb/util/range.go | BytesPrefix | func BytesPrefix(prefix []byte) *Range {
var limit []byte
for i := len(prefix) - 1; i >= 0; i-- {
c := prefix[i]
if c < 0xff {
limit = make([]byte, i+1)
copy(limit, prefix)
limit[i] = c + 1
break
}
}
return &Range{prefix, limit}
} | go | func BytesPrefix(prefix []byte) *Range {
var limit []byte
for i := len(prefix) - 1; i >= 0; i-- {
c := prefix[i]
if c < 0xff {
limit = make([]byte, i+1)
copy(limit, prefix)
limit[i] = c + 1
break
}
}
return &Range{prefix, limit}
} | [
"func",
"BytesPrefix",
"(",
"prefix",
"[",
"]",
"byte",
")",
"*",
"Range",
"{",
"var",
"limit",
"[",
"]",
"byte",
"\n",
"for",
"i",
":=",
"len",
"(",
"prefix",
")",
"-",
"1",
";",
"i",
">=",
"0",
";",
"i",
"--",
"{",
"c",
":=",
"prefix",
"[",
"i",
"]",
"\n",
"if",
"c",
"<",
"0xff",
"{",
"limit",
"=",
"make",
"(",
"[",
"]",
"byte",
",",
"i",
"+",
"1",
")",
"\n",
"copy",
"(",
"limit",
",",
"prefix",
")",
"\n",
"limit",
"[",
"i",
"]",
"=",
"c",
"+",
"1",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"&",
"Range",
"{",
"prefix",
",",
"limit",
"}",
"\n",
"}"
] | // BytesPrefix returns key range that satisfy the given prefix.
// This only applicable for the standard 'bytes comparer'. | [
"BytesPrefix",
"returns",
"key",
"range",
"that",
"satisfy",
"the",
"given",
"prefix",
".",
"This",
"only",
"applicable",
"for",
"the",
"standard",
"bytes",
"comparer",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/util/range.go#L20-L32 | train |
syndtr/goleveldb | leveldb/db_transaction.go | Put | func (tr *Transaction) Put(key, value []byte, wo *opt.WriteOptions) error {
tr.lk.Lock()
defer tr.lk.Unlock()
if tr.closed {
return errTransactionDone
}
return tr.put(keyTypeVal, key, value)
} | go | func (tr *Transaction) Put(key, value []byte, wo *opt.WriteOptions) error {
tr.lk.Lock()
defer tr.lk.Unlock()
if tr.closed {
return errTransactionDone
}
return tr.put(keyTypeVal, key, value)
} | [
"func",
"(",
"tr",
"*",
"Transaction",
")",
"Put",
"(",
"key",
",",
"value",
"[",
"]",
"byte",
",",
"wo",
"*",
"opt",
".",
"WriteOptions",
")",
"error",
"{",
"tr",
".",
"lk",
".",
"Lock",
"(",
")",
"\n",
"defer",
"tr",
".",
"lk",
".",
"Unlock",
"(",
")",
"\n",
"if",
"tr",
".",
"closed",
"{",
"return",
"errTransactionDone",
"\n",
"}",
"\n",
"return",
"tr",
".",
"put",
"(",
"keyTypeVal",
",",
"key",
",",
"value",
")",
"\n",
"}"
] | // Put sets the value for the given key. It overwrites any previous value
// for that key; a DB is not a multi-map.
// Please note that the transaction is not compacted until committed, so if you
// writes 10 same keys, then those 10 same keys are in the transaction.
//
// It is safe to modify the contents of the arguments after Put returns. | [
"Put",
"sets",
"the",
"value",
"for",
"the",
"given",
"key",
".",
"It",
"overwrites",
"any",
"previous",
"value",
"for",
"that",
"key",
";",
"a",
"DB",
"is",
"not",
"a",
"multi",
"-",
"map",
".",
"Please",
"note",
"that",
"the",
"transaction",
"is",
"not",
"compacted",
"until",
"committed",
"so",
"if",
"you",
"writes",
"10",
"same",
"keys",
"then",
"those",
"10",
"same",
"keys",
"are",
"in",
"the",
"transaction",
".",
"It",
"is",
"safe",
"to",
"modify",
"the",
"contents",
"of",
"the",
"arguments",
"after",
"Put",
"returns",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/db_transaction.go#L135-L142 | train |
syndtr/goleveldb | leveldb/db_transaction.go | Delete | func (tr *Transaction) Delete(key []byte, wo *opt.WriteOptions) error {
tr.lk.Lock()
defer tr.lk.Unlock()
if tr.closed {
return errTransactionDone
}
return tr.put(keyTypeDel, key, nil)
} | go | func (tr *Transaction) Delete(key []byte, wo *opt.WriteOptions) error {
tr.lk.Lock()
defer tr.lk.Unlock()
if tr.closed {
return errTransactionDone
}
return tr.put(keyTypeDel, key, nil)
} | [
"func",
"(",
"tr",
"*",
"Transaction",
")",
"Delete",
"(",
"key",
"[",
"]",
"byte",
",",
"wo",
"*",
"opt",
".",
"WriteOptions",
")",
"error",
"{",
"tr",
".",
"lk",
".",
"Lock",
"(",
")",
"\n",
"defer",
"tr",
".",
"lk",
".",
"Unlock",
"(",
")",
"\n",
"if",
"tr",
".",
"closed",
"{",
"return",
"errTransactionDone",
"\n",
"}",
"\n",
"return",
"tr",
".",
"put",
"(",
"keyTypeDel",
",",
"key",
",",
"nil",
")",
"\n",
"}"
] | // Delete deletes the value for the given key.
// Please note that the transaction is not compacted until committed, so if you
// writes 10 same keys, then those 10 same keys are in the transaction.
//
// It is safe to modify the contents of the arguments after Delete returns. | [
"Delete",
"deletes",
"the",
"value",
"for",
"the",
"given",
"key",
".",
"Please",
"note",
"that",
"the",
"transaction",
"is",
"not",
"compacted",
"until",
"committed",
"so",
"if",
"you",
"writes",
"10",
"same",
"keys",
"then",
"those",
"10",
"same",
"keys",
"are",
"in",
"the",
"transaction",
".",
"It",
"is",
"safe",
"to",
"modify",
"the",
"contents",
"of",
"the",
"arguments",
"after",
"Delete",
"returns",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/db_transaction.go#L149-L156 | train |
syndtr/goleveldb | leveldb/db_transaction.go | Write | func (tr *Transaction) Write(b *Batch, wo *opt.WriteOptions) error {
if b == nil || b.Len() == 0 {
return nil
}
tr.lk.Lock()
defer tr.lk.Unlock()
if tr.closed {
return errTransactionDone
}
return b.replayInternal(func(i int, kt keyType, k, v []byte) error {
return tr.put(kt, k, v)
})
} | go | func (tr *Transaction) Write(b *Batch, wo *opt.WriteOptions) error {
if b == nil || b.Len() == 0 {
return nil
}
tr.lk.Lock()
defer tr.lk.Unlock()
if tr.closed {
return errTransactionDone
}
return b.replayInternal(func(i int, kt keyType, k, v []byte) error {
return tr.put(kt, k, v)
})
} | [
"func",
"(",
"tr",
"*",
"Transaction",
")",
"Write",
"(",
"b",
"*",
"Batch",
",",
"wo",
"*",
"opt",
".",
"WriteOptions",
")",
"error",
"{",
"if",
"b",
"==",
"nil",
"||",
"b",
".",
"Len",
"(",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"tr",
".",
"lk",
".",
"Lock",
"(",
")",
"\n",
"defer",
"tr",
".",
"lk",
".",
"Unlock",
"(",
")",
"\n",
"if",
"tr",
".",
"closed",
"{",
"return",
"errTransactionDone",
"\n",
"}",
"\n",
"return",
"b",
".",
"replayInternal",
"(",
"func",
"(",
"i",
"int",
",",
"kt",
"keyType",
",",
"k",
",",
"v",
"[",
"]",
"byte",
")",
"error",
"{",
"return",
"tr",
".",
"put",
"(",
"kt",
",",
"k",
",",
"v",
")",
"\n",
"}",
")",
"\n",
"}"
] | // Write apply the given batch to the transaction. The batch will be applied
// sequentially.
// Please note that the transaction is not compacted until committed, so if you
// writes 10 same keys, then those 10 same keys are in the transaction.
//
// It is safe to modify the contents of the arguments after Write returns. | [
"Write",
"apply",
"the",
"given",
"batch",
"to",
"the",
"transaction",
".",
"The",
"batch",
"will",
"be",
"applied",
"sequentially",
".",
"Please",
"note",
"that",
"the",
"transaction",
"is",
"not",
"compacted",
"until",
"committed",
"so",
"if",
"you",
"writes",
"10",
"same",
"keys",
"then",
"those",
"10",
"same",
"keys",
"are",
"in",
"the",
"transaction",
".",
"It",
"is",
"safe",
"to",
"modify",
"the",
"contents",
"of",
"the",
"arguments",
"after",
"Write",
"returns",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/db_transaction.go#L164-L177 | train |
syndtr/goleveldb | leveldb/db_transaction.go | Discard | func (tr *Transaction) Discard() {
tr.lk.Lock()
if !tr.closed {
tr.discard()
tr.setDone()
}
tr.lk.Unlock()
} | go | func (tr *Transaction) Discard() {
tr.lk.Lock()
if !tr.closed {
tr.discard()
tr.setDone()
}
tr.lk.Unlock()
} | [
"func",
"(",
"tr",
"*",
"Transaction",
")",
"Discard",
"(",
")",
"{",
"tr",
".",
"lk",
".",
"Lock",
"(",
")",
"\n",
"if",
"!",
"tr",
".",
"closed",
"{",
"tr",
".",
"discard",
"(",
")",
"\n",
"tr",
".",
"setDone",
"(",
")",
"\n",
"}",
"\n",
"tr",
".",
"lk",
".",
"Unlock",
"(",
")",
"\n",
"}"
] | // Discard discards the transaction.
//
// Other methods should not be called after transaction has been discarded. | [
"Discard",
"discards",
"the",
"transaction",
".",
"Other",
"methods",
"should",
"not",
"be",
"called",
"after",
"transaction",
"has",
"been",
"discarded",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/db_transaction.go#L264-L271 | train |
syndtr/goleveldb | leveldb/db_transaction.go | OpenTransaction | func (db *DB) OpenTransaction() (*Transaction, error) {
if err := db.ok(); err != nil {
return nil, err
}
// The write happen synchronously.
select {
case db.writeLockC <- struct{}{}:
case err := <-db.compPerErrC:
return nil, err
case <-db.closeC:
return nil, ErrClosed
}
if db.tr != nil {
panic("leveldb: has open transaction")
}
// Flush current memdb.
if db.mem != nil && db.mem.Len() != 0 {
if _, err := db.rotateMem(0, true); err != nil {
return nil, err
}
}
// Wait compaction when certain threshold reached.
if err := db.waitCompaction(); err != nil {
return nil, err
}
tr := &Transaction{
db: db,
seq: db.seq,
mem: db.mpoolGet(0),
}
tr.mem.incref()
db.tr = tr
return tr, nil
} | go | func (db *DB) OpenTransaction() (*Transaction, error) {
if err := db.ok(); err != nil {
return nil, err
}
// The write happen synchronously.
select {
case db.writeLockC <- struct{}{}:
case err := <-db.compPerErrC:
return nil, err
case <-db.closeC:
return nil, ErrClosed
}
if db.tr != nil {
panic("leveldb: has open transaction")
}
// Flush current memdb.
if db.mem != nil && db.mem.Len() != 0 {
if _, err := db.rotateMem(0, true); err != nil {
return nil, err
}
}
// Wait compaction when certain threshold reached.
if err := db.waitCompaction(); err != nil {
return nil, err
}
tr := &Transaction{
db: db,
seq: db.seq,
mem: db.mpoolGet(0),
}
tr.mem.incref()
db.tr = tr
return tr, nil
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"OpenTransaction",
"(",
")",
"(",
"*",
"Transaction",
",",
"error",
")",
"{",
"if",
"err",
":=",
"db",
".",
"ok",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// The write happen synchronously.",
"select",
"{",
"case",
"db",
".",
"writeLockC",
"<-",
"struct",
"{",
"}",
"{",
"}",
":",
"case",
"err",
":=",
"<-",
"db",
".",
"compPerErrC",
":",
"return",
"nil",
",",
"err",
"\n",
"case",
"<-",
"db",
".",
"closeC",
":",
"return",
"nil",
",",
"ErrClosed",
"\n",
"}",
"\n\n",
"if",
"db",
".",
"tr",
"!=",
"nil",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Flush current memdb.",
"if",
"db",
".",
"mem",
"!=",
"nil",
"&&",
"db",
".",
"mem",
".",
"Len",
"(",
")",
"!=",
"0",
"{",
"if",
"_",
",",
"err",
":=",
"db",
".",
"rotateMem",
"(",
"0",
",",
"true",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Wait compaction when certain threshold reached.",
"if",
"err",
":=",
"db",
".",
"waitCompaction",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"tr",
":=",
"&",
"Transaction",
"{",
"db",
":",
"db",
",",
"seq",
":",
"db",
".",
"seq",
",",
"mem",
":",
"db",
".",
"mpoolGet",
"(",
"0",
")",
",",
"}",
"\n",
"tr",
".",
"mem",
".",
"incref",
"(",
")",
"\n",
"db",
".",
"tr",
"=",
"tr",
"\n",
"return",
"tr",
",",
"nil",
"\n",
"}"
] | // OpenTransaction opens an atomic DB transaction. Only one transaction can be
// opened at a time. Subsequent call to Write and OpenTransaction will be blocked
// until in-flight transaction is committed or discarded.
// The returned transaction handle is safe for concurrent use.
//
// Transaction is expensive and can overwhelm compaction, especially if
// transaction size is small. Use with caution.
//
// The transaction must be closed once done, either by committing or discarding
// the transaction.
// Closing the DB will discard open transaction. | [
"OpenTransaction",
"opens",
"an",
"atomic",
"DB",
"transaction",
".",
"Only",
"one",
"transaction",
"can",
"be",
"opened",
"at",
"a",
"time",
".",
"Subsequent",
"call",
"to",
"Write",
"and",
"OpenTransaction",
"will",
"be",
"blocked",
"until",
"in",
"-",
"flight",
"transaction",
"is",
"committed",
"or",
"discarded",
".",
"The",
"returned",
"transaction",
"handle",
"is",
"safe",
"for",
"concurrent",
"use",
".",
"Transaction",
"is",
"expensive",
"and",
"can",
"overwhelm",
"compaction",
"especially",
"if",
"transaction",
"size",
"is",
"small",
".",
"Use",
"with",
"caution",
".",
"The",
"transaction",
"must",
"be",
"closed",
"once",
"done",
"either",
"by",
"committing",
"or",
"discarding",
"the",
"transaction",
".",
"Closing",
"the",
"DB",
"will",
"discard",
"open",
"transaction",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/db_transaction.go#L291-L329 | train |
syndtr/goleveldb | leveldb/table/reader.go | Get | func (r *Reader) Get(key []byte, ro *opt.ReadOptions) (value []byte, err error) {
r.mu.RLock()
defer r.mu.RUnlock()
if r.err != nil {
err = r.err
return
}
rkey, value, err := r.find(key, false, ro, false)
if err == nil && r.cmp.Compare(rkey, key) != 0 {
value = nil
err = ErrNotFound
}
return
} | go | func (r *Reader) Get(key []byte, ro *opt.ReadOptions) (value []byte, err error) {
r.mu.RLock()
defer r.mu.RUnlock()
if r.err != nil {
err = r.err
return
}
rkey, value, err := r.find(key, false, ro, false)
if err == nil && r.cmp.Compare(rkey, key) != 0 {
value = nil
err = ErrNotFound
}
return
} | [
"func",
"(",
"r",
"*",
"Reader",
")",
"Get",
"(",
"key",
"[",
"]",
"byte",
",",
"ro",
"*",
"opt",
".",
"ReadOptions",
")",
"(",
"value",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"r",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"r",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n\n",
"if",
"r",
".",
"err",
"!=",
"nil",
"{",
"err",
"=",
"r",
".",
"err",
"\n",
"return",
"\n",
"}",
"\n\n",
"rkey",
",",
"value",
",",
"err",
":=",
"r",
".",
"find",
"(",
"key",
",",
"false",
",",
"ro",
",",
"false",
")",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"r",
".",
"cmp",
".",
"Compare",
"(",
"rkey",
",",
"key",
")",
"!=",
"0",
"{",
"value",
"=",
"nil",
"\n",
"err",
"=",
"ErrNotFound",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // Get gets the value for the given key. It returns errors.ErrNotFound
// if the table does not contain the key.
//
// The caller may modify the contents of the returned slice as it is its
// own copy.
// It is safe to modify the contents of the argument after Find returns. | [
"Get",
"gets",
"the",
"value",
"for",
"the",
"given",
"key",
".",
"It",
"returns",
"errors",
".",
"ErrNotFound",
"if",
"the",
"table",
"does",
"not",
"contain",
"the",
"key",
".",
"The",
"caller",
"may",
"modify",
"the",
"contents",
"of",
"the",
"returned",
"slice",
"as",
"it",
"is",
"its",
"own",
"copy",
".",
"It",
"is",
"safe",
"to",
"modify",
"the",
"contents",
"of",
"the",
"argument",
"after",
"Find",
"returns",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/table/reader.go#L945-L960 | train |
syndtr/goleveldb | leveldb/table/reader.go | OffsetOf | func (r *Reader) OffsetOf(key []byte) (offset int64, err error) {
r.mu.RLock()
defer r.mu.RUnlock()
if r.err != nil {
err = r.err
return
}
indexBlock, rel, err := r.readBlockCached(r.indexBH, true, true)
if err != nil {
return
}
defer rel.Release()
index := r.newBlockIter(indexBlock, nil, nil, true)
defer index.Release()
if index.Seek(key) {
dataBH, n := decodeBlockHandle(index.Value())
if n == 0 {
r.err = r.newErrCorruptedBH(r.indexBH, "bad data block handle")
return
}
offset = int64(dataBH.offset)
return
}
err = index.Error()
if err == nil {
offset = r.dataEnd
}
return
} | go | func (r *Reader) OffsetOf(key []byte) (offset int64, err error) {
r.mu.RLock()
defer r.mu.RUnlock()
if r.err != nil {
err = r.err
return
}
indexBlock, rel, err := r.readBlockCached(r.indexBH, true, true)
if err != nil {
return
}
defer rel.Release()
index := r.newBlockIter(indexBlock, nil, nil, true)
defer index.Release()
if index.Seek(key) {
dataBH, n := decodeBlockHandle(index.Value())
if n == 0 {
r.err = r.newErrCorruptedBH(r.indexBH, "bad data block handle")
return
}
offset = int64(dataBH.offset)
return
}
err = index.Error()
if err == nil {
offset = r.dataEnd
}
return
} | [
"func",
"(",
"r",
"*",
"Reader",
")",
"OffsetOf",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"offset",
"int64",
",",
"err",
"error",
")",
"{",
"r",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"r",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n\n",
"if",
"r",
".",
"err",
"!=",
"nil",
"{",
"err",
"=",
"r",
".",
"err",
"\n",
"return",
"\n",
"}",
"\n\n",
"indexBlock",
",",
"rel",
",",
"err",
":=",
"r",
".",
"readBlockCached",
"(",
"r",
".",
"indexBH",
",",
"true",
",",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"defer",
"rel",
".",
"Release",
"(",
")",
"\n\n",
"index",
":=",
"r",
".",
"newBlockIter",
"(",
"indexBlock",
",",
"nil",
",",
"nil",
",",
"true",
")",
"\n",
"defer",
"index",
".",
"Release",
"(",
")",
"\n",
"if",
"index",
".",
"Seek",
"(",
"key",
")",
"{",
"dataBH",
",",
"n",
":=",
"decodeBlockHandle",
"(",
"index",
".",
"Value",
"(",
")",
")",
"\n",
"if",
"n",
"==",
"0",
"{",
"r",
".",
"err",
"=",
"r",
".",
"newErrCorruptedBH",
"(",
"r",
".",
"indexBH",
",",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"offset",
"=",
"int64",
"(",
"dataBH",
".",
"offset",
")",
"\n",
"return",
"\n",
"}",
"\n",
"err",
"=",
"index",
".",
"Error",
"(",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"offset",
"=",
"r",
".",
"dataEnd",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // OffsetOf returns approximate offset for the given key.
//
// It is safe to modify the contents of the argument after Get returns. | [
"OffsetOf",
"returns",
"approximate",
"offset",
"for",
"the",
"given",
"key",
".",
"It",
"is",
"safe",
"to",
"modify",
"the",
"contents",
"of",
"the",
"argument",
"after",
"Get",
"returns",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/table/reader.go#L965-L996 | train |
syndtr/goleveldb | leveldb/table/reader.go | Release | func (r *Reader) Release() {
r.mu.Lock()
defer r.mu.Unlock()
if closer, ok := r.reader.(io.Closer); ok {
closer.Close()
}
if r.indexBlock != nil {
r.indexBlock.Release()
r.indexBlock = nil
}
if r.filterBlock != nil {
r.filterBlock.Release()
r.filterBlock = nil
}
r.reader = nil
r.cache = nil
r.bpool = nil
r.err = ErrReaderReleased
} | go | func (r *Reader) Release() {
r.mu.Lock()
defer r.mu.Unlock()
if closer, ok := r.reader.(io.Closer); ok {
closer.Close()
}
if r.indexBlock != nil {
r.indexBlock.Release()
r.indexBlock = nil
}
if r.filterBlock != nil {
r.filterBlock.Release()
r.filterBlock = nil
}
r.reader = nil
r.cache = nil
r.bpool = nil
r.err = ErrReaderReleased
} | [
"func",
"(",
"r",
"*",
"Reader",
")",
"Release",
"(",
")",
"{",
"r",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"closer",
",",
"ok",
":=",
"r",
".",
"reader",
".",
"(",
"io",
".",
"Closer",
")",
";",
"ok",
"{",
"closer",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"if",
"r",
".",
"indexBlock",
"!=",
"nil",
"{",
"r",
".",
"indexBlock",
".",
"Release",
"(",
")",
"\n",
"r",
".",
"indexBlock",
"=",
"nil",
"\n",
"}",
"\n",
"if",
"r",
".",
"filterBlock",
"!=",
"nil",
"{",
"r",
".",
"filterBlock",
".",
"Release",
"(",
")",
"\n",
"r",
".",
"filterBlock",
"=",
"nil",
"\n",
"}",
"\n",
"r",
".",
"reader",
"=",
"nil",
"\n",
"r",
".",
"cache",
"=",
"nil",
"\n",
"r",
".",
"bpool",
"=",
"nil",
"\n",
"r",
".",
"err",
"=",
"ErrReaderReleased",
"\n",
"}"
] | // Release implements util.Releaser.
// It also close the file if it is an io.Closer. | [
"Release",
"implements",
"util",
".",
"Releaser",
".",
"It",
"also",
"close",
"the",
"file",
"if",
"it",
"is",
"an",
"io",
".",
"Closer",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/table/reader.go#L1000-L1019 | train |
syndtr/goleveldb | leveldb/session_compaction.go | pickCompaction | func (s *session) pickCompaction() *compaction {
v := s.version()
var sourceLevel int
var t0 tFiles
if v.cScore >= 1 {
sourceLevel = v.cLevel
cptr := s.getCompPtr(sourceLevel)
tables := v.levels[sourceLevel]
for _, t := range tables {
if cptr == nil || s.icmp.Compare(t.imax, cptr) > 0 {
t0 = append(t0, t)
break
}
}
if len(t0) == 0 {
t0 = append(t0, tables[0])
}
} else {
if p := atomic.LoadPointer(&v.cSeek); p != nil {
ts := (*tSet)(p)
sourceLevel = ts.level
t0 = append(t0, ts.table)
} else {
v.release()
return nil
}
}
return newCompaction(s, v, sourceLevel, t0)
} | go | func (s *session) pickCompaction() *compaction {
v := s.version()
var sourceLevel int
var t0 tFiles
if v.cScore >= 1 {
sourceLevel = v.cLevel
cptr := s.getCompPtr(sourceLevel)
tables := v.levels[sourceLevel]
for _, t := range tables {
if cptr == nil || s.icmp.Compare(t.imax, cptr) > 0 {
t0 = append(t0, t)
break
}
}
if len(t0) == 0 {
t0 = append(t0, tables[0])
}
} else {
if p := atomic.LoadPointer(&v.cSeek); p != nil {
ts := (*tSet)(p)
sourceLevel = ts.level
t0 = append(t0, ts.table)
} else {
v.release()
return nil
}
}
return newCompaction(s, v, sourceLevel, t0)
} | [
"func",
"(",
"s",
"*",
"session",
")",
"pickCompaction",
"(",
")",
"*",
"compaction",
"{",
"v",
":=",
"s",
".",
"version",
"(",
")",
"\n\n",
"var",
"sourceLevel",
"int",
"\n",
"var",
"t0",
"tFiles",
"\n",
"if",
"v",
".",
"cScore",
">=",
"1",
"{",
"sourceLevel",
"=",
"v",
".",
"cLevel",
"\n",
"cptr",
":=",
"s",
".",
"getCompPtr",
"(",
"sourceLevel",
")",
"\n",
"tables",
":=",
"v",
".",
"levels",
"[",
"sourceLevel",
"]",
"\n",
"for",
"_",
",",
"t",
":=",
"range",
"tables",
"{",
"if",
"cptr",
"==",
"nil",
"||",
"s",
".",
"icmp",
".",
"Compare",
"(",
"t",
".",
"imax",
",",
"cptr",
")",
">",
"0",
"{",
"t0",
"=",
"append",
"(",
"t0",
",",
"t",
")",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"t0",
")",
"==",
"0",
"{",
"t0",
"=",
"append",
"(",
"t0",
",",
"tables",
"[",
"0",
"]",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"if",
"p",
":=",
"atomic",
".",
"LoadPointer",
"(",
"&",
"v",
".",
"cSeek",
")",
";",
"p",
"!=",
"nil",
"{",
"ts",
":=",
"(",
"*",
"tSet",
")",
"(",
"p",
")",
"\n",
"sourceLevel",
"=",
"ts",
".",
"level",
"\n",
"t0",
"=",
"append",
"(",
"t0",
",",
"ts",
".",
"table",
")",
"\n",
"}",
"else",
"{",
"v",
".",
"release",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"newCompaction",
"(",
"s",
",",
"v",
",",
"sourceLevel",
",",
"t0",
")",
"\n",
"}"
] | // Pick a compaction based on current state; need external synchronization. | [
"Pick",
"a",
"compaction",
"based",
"on",
"current",
"state",
";",
"need",
"external",
"synchronization",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/session_compaction.go#L48-L78 | train |
syndtr/goleveldb | leveldb/session_compaction.go | getCompactionRange | func (s *session) getCompactionRange(sourceLevel int, umin, umax []byte, noLimit bool) *compaction {
v := s.version()
if sourceLevel >= len(v.levels) {
v.release()
return nil
}
t0 := v.levels[sourceLevel].getOverlaps(nil, s.icmp, umin, umax, sourceLevel == 0)
if len(t0) == 0 {
v.release()
return nil
}
// Avoid compacting too much in one shot in case the range is large.
// But we cannot do this for level-0 since level-0 files can overlap
// and we must not pick one file and drop another older file if the
// two files overlap.
if !noLimit && sourceLevel > 0 {
limit := int64(v.s.o.GetCompactionSourceLimit(sourceLevel))
total := int64(0)
for i, t := range t0 {
total += t.size
if total >= limit {
s.logf("table@compaction limiting F·%d -> F·%d", len(t0), i+1)
t0 = t0[:i+1]
break
}
}
}
return newCompaction(s, v, sourceLevel, t0)
} | go | func (s *session) getCompactionRange(sourceLevel int, umin, umax []byte, noLimit bool) *compaction {
v := s.version()
if sourceLevel >= len(v.levels) {
v.release()
return nil
}
t0 := v.levels[sourceLevel].getOverlaps(nil, s.icmp, umin, umax, sourceLevel == 0)
if len(t0) == 0 {
v.release()
return nil
}
// Avoid compacting too much in one shot in case the range is large.
// But we cannot do this for level-0 since level-0 files can overlap
// and we must not pick one file and drop another older file if the
// two files overlap.
if !noLimit && sourceLevel > 0 {
limit := int64(v.s.o.GetCompactionSourceLimit(sourceLevel))
total := int64(0)
for i, t := range t0 {
total += t.size
if total >= limit {
s.logf("table@compaction limiting F·%d -> F·%d", len(t0), i+1)
t0 = t0[:i+1]
break
}
}
}
return newCompaction(s, v, sourceLevel, t0)
} | [
"func",
"(",
"s",
"*",
"session",
")",
"getCompactionRange",
"(",
"sourceLevel",
"int",
",",
"umin",
",",
"umax",
"[",
"]",
"byte",
",",
"noLimit",
"bool",
")",
"*",
"compaction",
"{",
"v",
":=",
"s",
".",
"version",
"(",
")",
"\n\n",
"if",
"sourceLevel",
">=",
"len",
"(",
"v",
".",
"levels",
")",
"{",
"v",
".",
"release",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"t0",
":=",
"v",
".",
"levels",
"[",
"sourceLevel",
"]",
".",
"getOverlaps",
"(",
"nil",
",",
"s",
".",
"icmp",
",",
"umin",
",",
"umax",
",",
"sourceLevel",
"==",
"0",
")",
"\n",
"if",
"len",
"(",
"t0",
")",
"==",
"0",
"{",
"v",
".",
"release",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"// Avoid compacting too much in one shot in case the range is large.",
"// But we cannot do this for level-0 since level-0 files can overlap",
"// and we must not pick one file and drop another older file if the",
"// two files overlap.",
"if",
"!",
"noLimit",
"&&",
"sourceLevel",
">",
"0",
"{",
"limit",
":=",
"int64",
"(",
"v",
".",
"s",
".",
"o",
".",
"GetCompactionSourceLimit",
"(",
"sourceLevel",
")",
")",
"\n",
"total",
":=",
"int64",
"(",
"0",
")",
"\n",
"for",
"i",
",",
"t",
":=",
"range",
"t0",
"{",
"total",
"+=",
"t",
".",
"size",
"\n",
"if",
"total",
">=",
"limit",
"{",
"s",
".",
"logf",
"(",
"\"",
" ",
"l",
"n(t",
"0",
"),",
" ",
"i",
"1",
")",
"",
"",
"\n",
"t0",
"=",
"t0",
"[",
":",
"i",
"+",
"1",
"]",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"newCompaction",
"(",
"s",
",",
"v",
",",
"sourceLevel",
",",
"t0",
")",
"\n",
"}"
] | // Create compaction from given level and range; need external synchronization. | [
"Create",
"compaction",
"from",
"given",
"level",
"and",
"range",
";",
"need",
"external",
"synchronization",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/session_compaction.go#L81-L113 | train |
syndtr/goleveldb | leveldb/session_compaction.go | trivial | func (c *compaction) trivial() bool {
return len(c.levels[0]) == 1 && len(c.levels[1]) == 0 && c.gp.size() <= c.maxGPOverlaps
} | go | func (c *compaction) trivial() bool {
return len(c.levels[0]) == 1 && len(c.levels[1]) == 0 && c.gp.size() <= c.maxGPOverlaps
} | [
"func",
"(",
"c",
"*",
"compaction",
")",
"trivial",
"(",
")",
"bool",
"{",
"return",
"len",
"(",
"c",
".",
"levels",
"[",
"0",
"]",
")",
"==",
"1",
"&&",
"len",
"(",
"c",
".",
"levels",
"[",
"1",
"]",
")",
"==",
"0",
"&&",
"c",
".",
"gp",
".",
"size",
"(",
")",
"<=",
"c",
".",
"maxGPOverlaps",
"\n",
"}"
] | // Check whether compaction is trivial. | [
"Check",
"whether",
"compaction",
"is",
"trivial",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/session_compaction.go#L226-L228 | train |
syndtr/goleveldb | leveldb/session_compaction.go | newIterator | func (c *compaction) newIterator() iterator.Iterator {
// Creates iterator slice.
icap := len(c.levels)
if c.sourceLevel == 0 {
// Special case for level-0.
icap = len(c.levels[0]) + 1
}
its := make([]iterator.Iterator, 0, icap)
// Options.
ro := &opt.ReadOptions{
DontFillCache: true,
Strict: opt.StrictOverride,
}
strict := c.s.o.GetStrict(opt.StrictCompaction)
if strict {
ro.Strict |= opt.StrictReader
}
for i, tables := range c.levels {
if len(tables) == 0 {
continue
}
// Level-0 is not sorted and may overlaps each other.
if c.sourceLevel+i == 0 {
for _, t := range tables {
its = append(its, c.s.tops.newIterator(t, nil, ro))
}
} else {
it := iterator.NewIndexedIterator(tables.newIndexIterator(c.s.tops, c.s.icmp, nil, ro), strict)
its = append(its, it)
}
}
return iterator.NewMergedIterator(its, c.s.icmp, strict)
} | go | func (c *compaction) newIterator() iterator.Iterator {
// Creates iterator slice.
icap := len(c.levels)
if c.sourceLevel == 0 {
// Special case for level-0.
icap = len(c.levels[0]) + 1
}
its := make([]iterator.Iterator, 0, icap)
// Options.
ro := &opt.ReadOptions{
DontFillCache: true,
Strict: opt.StrictOverride,
}
strict := c.s.o.GetStrict(opt.StrictCompaction)
if strict {
ro.Strict |= opt.StrictReader
}
for i, tables := range c.levels {
if len(tables) == 0 {
continue
}
// Level-0 is not sorted and may overlaps each other.
if c.sourceLevel+i == 0 {
for _, t := range tables {
its = append(its, c.s.tops.newIterator(t, nil, ro))
}
} else {
it := iterator.NewIndexedIterator(tables.newIndexIterator(c.s.tops, c.s.icmp, nil, ro), strict)
its = append(its, it)
}
}
return iterator.NewMergedIterator(its, c.s.icmp, strict)
} | [
"func",
"(",
"c",
"*",
"compaction",
")",
"newIterator",
"(",
")",
"iterator",
".",
"Iterator",
"{",
"// Creates iterator slice.",
"icap",
":=",
"len",
"(",
"c",
".",
"levels",
")",
"\n",
"if",
"c",
".",
"sourceLevel",
"==",
"0",
"{",
"// Special case for level-0.",
"icap",
"=",
"len",
"(",
"c",
".",
"levels",
"[",
"0",
"]",
")",
"+",
"1",
"\n",
"}",
"\n",
"its",
":=",
"make",
"(",
"[",
"]",
"iterator",
".",
"Iterator",
",",
"0",
",",
"icap",
")",
"\n\n",
"// Options.",
"ro",
":=",
"&",
"opt",
".",
"ReadOptions",
"{",
"DontFillCache",
":",
"true",
",",
"Strict",
":",
"opt",
".",
"StrictOverride",
",",
"}",
"\n",
"strict",
":=",
"c",
".",
"s",
".",
"o",
".",
"GetStrict",
"(",
"opt",
".",
"StrictCompaction",
")",
"\n",
"if",
"strict",
"{",
"ro",
".",
"Strict",
"|=",
"opt",
".",
"StrictReader",
"\n",
"}",
"\n\n",
"for",
"i",
",",
"tables",
":=",
"range",
"c",
".",
"levels",
"{",
"if",
"len",
"(",
"tables",
")",
"==",
"0",
"{",
"continue",
"\n",
"}",
"\n\n",
"// Level-0 is not sorted and may overlaps each other.",
"if",
"c",
".",
"sourceLevel",
"+",
"i",
"==",
"0",
"{",
"for",
"_",
",",
"t",
":=",
"range",
"tables",
"{",
"its",
"=",
"append",
"(",
"its",
",",
"c",
".",
"s",
".",
"tops",
".",
"newIterator",
"(",
"t",
",",
"nil",
",",
"ro",
")",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"it",
":=",
"iterator",
".",
"NewIndexedIterator",
"(",
"tables",
".",
"newIndexIterator",
"(",
"c",
".",
"s",
".",
"tops",
",",
"c",
".",
"s",
".",
"icmp",
",",
"nil",
",",
"ro",
")",
",",
"strict",
")",
"\n",
"its",
"=",
"append",
"(",
"its",
",",
"it",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"iterator",
".",
"NewMergedIterator",
"(",
"its",
",",
"c",
".",
"s",
".",
"icmp",
",",
"strict",
")",
"\n",
"}"
] | // Creates an iterator. | [
"Creates",
"an",
"iterator",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/session_compaction.go#L270-L306 | train |
syndtr/goleveldb | leveldb/table/writer.go | BlocksLen | func (w *Writer) BlocksLen() int {
n := w.indexBlock.nEntries
if w.pendingBH.length > 0 {
// Includes the pending block.
n++
}
return n
} | go | func (w *Writer) BlocksLen() int {
n := w.indexBlock.nEntries
if w.pendingBH.length > 0 {
// Includes the pending block.
n++
}
return n
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"BlocksLen",
"(",
")",
"int",
"{",
"n",
":=",
"w",
".",
"indexBlock",
".",
"nEntries",
"\n",
"if",
"w",
".",
"pendingBH",
".",
"length",
">",
"0",
"{",
"// Includes the pending block.",
"n",
"++",
"\n",
"}",
"\n",
"return",
"n",
"\n",
"}"
] | // BlocksLen returns number of blocks written so far. | [
"BlocksLen",
"returns",
"number",
"of",
"blocks",
"written",
"so",
"far",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/table/writer.go#L264-L271 | train |
syndtr/goleveldb | leveldb/table/writer.go | Close | func (w *Writer) Close() error {
if w.err != nil {
return w.err
}
// Write the last data block. Or empty data block if there
// aren't any data blocks at all.
if w.dataBlock.nEntries > 0 || w.nEntries == 0 {
if err := w.finishBlock(); err != nil {
w.err = err
return w.err
}
}
w.flushPendingBH(nil)
// Write the filter block.
var filterBH blockHandle
w.filterBlock.finish()
if buf := &w.filterBlock.buf; buf.Len() > 0 {
filterBH, w.err = w.writeBlock(buf, opt.NoCompression)
if w.err != nil {
return w.err
}
}
// Write the metaindex block.
if filterBH.length > 0 {
key := []byte("filter." + w.filter.Name())
n := encodeBlockHandle(w.scratch[:20], filterBH)
w.dataBlock.append(key, w.scratch[:n])
}
w.dataBlock.finish()
metaindexBH, err := w.writeBlock(&w.dataBlock.buf, w.compression)
if err != nil {
w.err = err
return w.err
}
// Write the index block.
w.indexBlock.finish()
indexBH, err := w.writeBlock(&w.indexBlock.buf, w.compression)
if err != nil {
w.err = err
return w.err
}
// Write the table footer.
footer := w.scratch[:footerLen]
for i := range footer {
footer[i] = 0
}
n := encodeBlockHandle(footer, metaindexBH)
encodeBlockHandle(footer[n:], indexBH)
copy(footer[footerLen-len(magic):], magic)
if _, err := w.writer.Write(footer); err != nil {
w.err = err
return w.err
}
w.offset += footerLen
w.err = errors.New("leveldb/table: writer is closed")
return nil
} | go | func (w *Writer) Close() error {
if w.err != nil {
return w.err
}
// Write the last data block. Or empty data block if there
// aren't any data blocks at all.
if w.dataBlock.nEntries > 0 || w.nEntries == 0 {
if err := w.finishBlock(); err != nil {
w.err = err
return w.err
}
}
w.flushPendingBH(nil)
// Write the filter block.
var filterBH blockHandle
w.filterBlock.finish()
if buf := &w.filterBlock.buf; buf.Len() > 0 {
filterBH, w.err = w.writeBlock(buf, opt.NoCompression)
if w.err != nil {
return w.err
}
}
// Write the metaindex block.
if filterBH.length > 0 {
key := []byte("filter." + w.filter.Name())
n := encodeBlockHandle(w.scratch[:20], filterBH)
w.dataBlock.append(key, w.scratch[:n])
}
w.dataBlock.finish()
metaindexBH, err := w.writeBlock(&w.dataBlock.buf, w.compression)
if err != nil {
w.err = err
return w.err
}
// Write the index block.
w.indexBlock.finish()
indexBH, err := w.writeBlock(&w.indexBlock.buf, w.compression)
if err != nil {
w.err = err
return w.err
}
// Write the table footer.
footer := w.scratch[:footerLen]
for i := range footer {
footer[i] = 0
}
n := encodeBlockHandle(footer, metaindexBH)
encodeBlockHandle(footer[n:], indexBH)
copy(footer[footerLen-len(magic):], magic)
if _, err := w.writer.Write(footer); err != nil {
w.err = err
return w.err
}
w.offset += footerLen
w.err = errors.New("leveldb/table: writer is closed")
return nil
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"w",
".",
"err",
"!=",
"nil",
"{",
"return",
"w",
".",
"err",
"\n",
"}",
"\n\n",
"// Write the last data block. Or empty data block if there",
"// aren't any data blocks at all.",
"if",
"w",
".",
"dataBlock",
".",
"nEntries",
">",
"0",
"||",
"w",
".",
"nEntries",
"==",
"0",
"{",
"if",
"err",
":=",
"w",
".",
"finishBlock",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"w",
".",
"err",
"=",
"err",
"\n",
"return",
"w",
".",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"w",
".",
"flushPendingBH",
"(",
"nil",
")",
"\n\n",
"// Write the filter block.",
"var",
"filterBH",
"blockHandle",
"\n",
"w",
".",
"filterBlock",
".",
"finish",
"(",
")",
"\n",
"if",
"buf",
":=",
"&",
"w",
".",
"filterBlock",
".",
"buf",
";",
"buf",
".",
"Len",
"(",
")",
">",
"0",
"{",
"filterBH",
",",
"w",
".",
"err",
"=",
"w",
".",
"writeBlock",
"(",
"buf",
",",
"opt",
".",
"NoCompression",
")",
"\n",
"if",
"w",
".",
"err",
"!=",
"nil",
"{",
"return",
"w",
".",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Write the metaindex block.",
"if",
"filterBH",
".",
"length",
">",
"0",
"{",
"key",
":=",
"[",
"]",
"byte",
"(",
"\"",
"\"",
"+",
"w",
".",
"filter",
".",
"Name",
"(",
")",
")",
"\n",
"n",
":=",
"encodeBlockHandle",
"(",
"w",
".",
"scratch",
"[",
":",
"20",
"]",
",",
"filterBH",
")",
"\n",
"w",
".",
"dataBlock",
".",
"append",
"(",
"key",
",",
"w",
".",
"scratch",
"[",
":",
"n",
"]",
")",
"\n",
"}",
"\n",
"w",
".",
"dataBlock",
".",
"finish",
"(",
")",
"\n",
"metaindexBH",
",",
"err",
":=",
"w",
".",
"writeBlock",
"(",
"&",
"w",
".",
"dataBlock",
".",
"buf",
",",
"w",
".",
"compression",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"w",
".",
"err",
"=",
"err",
"\n",
"return",
"w",
".",
"err",
"\n",
"}",
"\n\n",
"// Write the index block.",
"w",
".",
"indexBlock",
".",
"finish",
"(",
")",
"\n",
"indexBH",
",",
"err",
":=",
"w",
".",
"writeBlock",
"(",
"&",
"w",
".",
"indexBlock",
".",
"buf",
",",
"w",
".",
"compression",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"w",
".",
"err",
"=",
"err",
"\n",
"return",
"w",
".",
"err",
"\n",
"}",
"\n\n",
"// Write the table footer.",
"footer",
":=",
"w",
".",
"scratch",
"[",
":",
"footerLen",
"]",
"\n",
"for",
"i",
":=",
"range",
"footer",
"{",
"footer",
"[",
"i",
"]",
"=",
"0",
"\n",
"}",
"\n",
"n",
":=",
"encodeBlockHandle",
"(",
"footer",
",",
"metaindexBH",
")",
"\n",
"encodeBlockHandle",
"(",
"footer",
"[",
"n",
":",
"]",
",",
"indexBH",
")",
"\n",
"copy",
"(",
"footer",
"[",
"footerLen",
"-",
"len",
"(",
"magic",
")",
":",
"]",
",",
"magic",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"w",
".",
"writer",
".",
"Write",
"(",
"footer",
")",
";",
"err",
"!=",
"nil",
"{",
"w",
".",
"err",
"=",
"err",
"\n",
"return",
"w",
".",
"err",
"\n",
"}",
"\n",
"w",
".",
"offset",
"+=",
"footerLen",
"\n\n",
"w",
".",
"err",
"=",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // Close will finalize the table. Calling Append is not possible
// after Close, but calling BlocksLen, EntriesLen and BytesLen
// is still possible. | [
"Close",
"will",
"finalize",
"the",
"table",
".",
"Calling",
"Append",
"is",
"not",
"possible",
"after",
"Close",
"but",
"calling",
"BlocksLen",
"EntriesLen",
"and",
"BytesLen",
"is",
"still",
"possible",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/table/writer.go#L286-L348 | train |
syndtr/goleveldb | leveldb/table/writer.go | NewWriter | func NewWriter(f io.Writer, o *opt.Options) *Writer {
w := &Writer{
writer: f,
cmp: o.GetComparer(),
filter: o.GetFilter(),
compression: o.GetCompression(),
blockSize: o.GetBlockSize(),
comparerScratch: make([]byte, 0),
}
// data block
w.dataBlock.restartInterval = o.GetBlockRestartInterval()
// The first 20-bytes are used for encoding block handle.
w.dataBlock.scratch = w.scratch[20:]
// index block
w.indexBlock.restartInterval = 1
w.indexBlock.scratch = w.scratch[20:]
// filter block
if w.filter != nil {
w.filterBlock.generator = w.filter.NewGenerator()
w.filterBlock.flush(0)
}
return w
} | go | func NewWriter(f io.Writer, o *opt.Options) *Writer {
w := &Writer{
writer: f,
cmp: o.GetComparer(),
filter: o.GetFilter(),
compression: o.GetCompression(),
blockSize: o.GetBlockSize(),
comparerScratch: make([]byte, 0),
}
// data block
w.dataBlock.restartInterval = o.GetBlockRestartInterval()
// The first 20-bytes are used for encoding block handle.
w.dataBlock.scratch = w.scratch[20:]
// index block
w.indexBlock.restartInterval = 1
w.indexBlock.scratch = w.scratch[20:]
// filter block
if w.filter != nil {
w.filterBlock.generator = w.filter.NewGenerator()
w.filterBlock.flush(0)
}
return w
} | [
"func",
"NewWriter",
"(",
"f",
"io",
".",
"Writer",
",",
"o",
"*",
"opt",
".",
"Options",
")",
"*",
"Writer",
"{",
"w",
":=",
"&",
"Writer",
"{",
"writer",
":",
"f",
",",
"cmp",
":",
"o",
".",
"GetComparer",
"(",
")",
",",
"filter",
":",
"o",
".",
"GetFilter",
"(",
")",
",",
"compression",
":",
"o",
".",
"GetCompression",
"(",
")",
",",
"blockSize",
":",
"o",
".",
"GetBlockSize",
"(",
")",
",",
"comparerScratch",
":",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
")",
",",
"}",
"\n",
"// data block",
"w",
".",
"dataBlock",
".",
"restartInterval",
"=",
"o",
".",
"GetBlockRestartInterval",
"(",
")",
"\n",
"// The first 20-bytes are used for encoding block handle.",
"w",
".",
"dataBlock",
".",
"scratch",
"=",
"w",
".",
"scratch",
"[",
"20",
":",
"]",
"\n",
"// index block",
"w",
".",
"indexBlock",
".",
"restartInterval",
"=",
"1",
"\n",
"w",
".",
"indexBlock",
".",
"scratch",
"=",
"w",
".",
"scratch",
"[",
"20",
":",
"]",
"\n",
"// filter block",
"if",
"w",
".",
"filter",
"!=",
"nil",
"{",
"w",
".",
"filterBlock",
".",
"generator",
"=",
"w",
".",
"filter",
".",
"NewGenerator",
"(",
")",
"\n",
"w",
".",
"filterBlock",
".",
"flush",
"(",
"0",
")",
"\n",
"}",
"\n",
"return",
"w",
"\n",
"}"
] | // NewWriter creates a new initialized table writer for the file.
//
// Table writer is not safe for concurrent use. | [
"NewWriter",
"creates",
"a",
"new",
"initialized",
"table",
"writer",
"for",
"the",
"file",
".",
"Table",
"writer",
"is",
"not",
"safe",
"for",
"concurrent",
"use",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/table/writer.go#L353-L375 | train |
syndtr/goleveldb | leveldb/memdb/memdb.go | findGE | func (p *DB) findGE(key []byte, prev bool) (int, bool) {
node := 0
h := p.maxHeight - 1
for {
next := p.nodeData[node+nNext+h]
cmp := 1
if next != 0 {
o := p.nodeData[next]
cmp = p.cmp.Compare(p.kvData[o:o+p.nodeData[next+nKey]], key)
}
if cmp < 0 {
// Keep searching in this list
node = next
} else {
if prev {
p.prevNode[h] = node
} else if cmp == 0 {
return next, true
}
if h == 0 {
return next, cmp == 0
}
h--
}
}
} | go | func (p *DB) findGE(key []byte, prev bool) (int, bool) {
node := 0
h := p.maxHeight - 1
for {
next := p.nodeData[node+nNext+h]
cmp := 1
if next != 0 {
o := p.nodeData[next]
cmp = p.cmp.Compare(p.kvData[o:o+p.nodeData[next+nKey]], key)
}
if cmp < 0 {
// Keep searching in this list
node = next
} else {
if prev {
p.prevNode[h] = node
} else if cmp == 0 {
return next, true
}
if h == 0 {
return next, cmp == 0
}
h--
}
}
} | [
"func",
"(",
"p",
"*",
"DB",
")",
"findGE",
"(",
"key",
"[",
"]",
"byte",
",",
"prev",
"bool",
")",
"(",
"int",
",",
"bool",
")",
"{",
"node",
":=",
"0",
"\n",
"h",
":=",
"p",
".",
"maxHeight",
"-",
"1",
"\n",
"for",
"{",
"next",
":=",
"p",
".",
"nodeData",
"[",
"node",
"+",
"nNext",
"+",
"h",
"]",
"\n",
"cmp",
":=",
"1",
"\n",
"if",
"next",
"!=",
"0",
"{",
"o",
":=",
"p",
".",
"nodeData",
"[",
"next",
"]",
"\n",
"cmp",
"=",
"p",
".",
"cmp",
".",
"Compare",
"(",
"p",
".",
"kvData",
"[",
"o",
":",
"o",
"+",
"p",
".",
"nodeData",
"[",
"next",
"+",
"nKey",
"]",
"]",
",",
"key",
")",
"\n",
"}",
"\n",
"if",
"cmp",
"<",
"0",
"{",
"// Keep searching in this list",
"node",
"=",
"next",
"\n",
"}",
"else",
"{",
"if",
"prev",
"{",
"p",
".",
"prevNode",
"[",
"h",
"]",
"=",
"node",
"\n",
"}",
"else",
"if",
"cmp",
"==",
"0",
"{",
"return",
"next",
",",
"true",
"\n",
"}",
"\n",
"if",
"h",
"==",
"0",
"{",
"return",
"next",
",",
"cmp",
"==",
"0",
"\n",
"}",
"\n",
"h",
"--",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Must hold RW-lock if prev == true, as it use shared prevNode slice. | [
"Must",
"hold",
"RW",
"-",
"lock",
"if",
"prev",
"==",
"true",
"as",
"it",
"use",
"shared",
"prevNode",
"slice",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/memdb/memdb.go#L211-L236 | train |
syndtr/goleveldb | leveldb/memdb/memdb.go | Put | func (p *DB) Put(key []byte, value []byte) error {
p.mu.Lock()
defer p.mu.Unlock()
if node, exact := p.findGE(key, true); exact {
kvOffset := len(p.kvData)
p.kvData = append(p.kvData, key...)
p.kvData = append(p.kvData, value...)
p.nodeData[node] = kvOffset
m := p.nodeData[node+nVal]
p.nodeData[node+nVal] = len(value)
p.kvSize += len(value) - m
return nil
}
h := p.randHeight()
if h > p.maxHeight {
for i := p.maxHeight; i < h; i++ {
p.prevNode[i] = 0
}
p.maxHeight = h
}
kvOffset := len(p.kvData)
p.kvData = append(p.kvData, key...)
p.kvData = append(p.kvData, value...)
// Node
node := len(p.nodeData)
p.nodeData = append(p.nodeData, kvOffset, len(key), len(value), h)
for i, n := range p.prevNode[:h] {
m := n + nNext + i
p.nodeData = append(p.nodeData, p.nodeData[m])
p.nodeData[m] = node
}
p.kvSize += len(key) + len(value)
p.n++
return nil
} | go | func (p *DB) Put(key []byte, value []byte) error {
p.mu.Lock()
defer p.mu.Unlock()
if node, exact := p.findGE(key, true); exact {
kvOffset := len(p.kvData)
p.kvData = append(p.kvData, key...)
p.kvData = append(p.kvData, value...)
p.nodeData[node] = kvOffset
m := p.nodeData[node+nVal]
p.nodeData[node+nVal] = len(value)
p.kvSize += len(value) - m
return nil
}
h := p.randHeight()
if h > p.maxHeight {
for i := p.maxHeight; i < h; i++ {
p.prevNode[i] = 0
}
p.maxHeight = h
}
kvOffset := len(p.kvData)
p.kvData = append(p.kvData, key...)
p.kvData = append(p.kvData, value...)
// Node
node := len(p.nodeData)
p.nodeData = append(p.nodeData, kvOffset, len(key), len(value), h)
for i, n := range p.prevNode[:h] {
m := n + nNext + i
p.nodeData = append(p.nodeData, p.nodeData[m])
p.nodeData[m] = node
}
p.kvSize += len(key) + len(value)
p.n++
return nil
} | [
"func",
"(",
"p",
"*",
"DB",
")",
"Put",
"(",
"key",
"[",
"]",
"byte",
",",
"value",
"[",
"]",
"byte",
")",
"error",
"{",
"p",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"p",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"node",
",",
"exact",
":=",
"p",
".",
"findGE",
"(",
"key",
",",
"true",
")",
";",
"exact",
"{",
"kvOffset",
":=",
"len",
"(",
"p",
".",
"kvData",
")",
"\n",
"p",
".",
"kvData",
"=",
"append",
"(",
"p",
".",
"kvData",
",",
"key",
"...",
")",
"\n",
"p",
".",
"kvData",
"=",
"append",
"(",
"p",
".",
"kvData",
",",
"value",
"...",
")",
"\n",
"p",
".",
"nodeData",
"[",
"node",
"]",
"=",
"kvOffset",
"\n",
"m",
":=",
"p",
".",
"nodeData",
"[",
"node",
"+",
"nVal",
"]",
"\n",
"p",
".",
"nodeData",
"[",
"node",
"+",
"nVal",
"]",
"=",
"len",
"(",
"value",
")",
"\n",
"p",
".",
"kvSize",
"+=",
"len",
"(",
"value",
")",
"-",
"m",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"h",
":=",
"p",
".",
"randHeight",
"(",
")",
"\n",
"if",
"h",
">",
"p",
".",
"maxHeight",
"{",
"for",
"i",
":=",
"p",
".",
"maxHeight",
";",
"i",
"<",
"h",
";",
"i",
"++",
"{",
"p",
".",
"prevNode",
"[",
"i",
"]",
"=",
"0",
"\n",
"}",
"\n",
"p",
".",
"maxHeight",
"=",
"h",
"\n",
"}",
"\n\n",
"kvOffset",
":=",
"len",
"(",
"p",
".",
"kvData",
")",
"\n",
"p",
".",
"kvData",
"=",
"append",
"(",
"p",
".",
"kvData",
",",
"key",
"...",
")",
"\n",
"p",
".",
"kvData",
"=",
"append",
"(",
"p",
".",
"kvData",
",",
"value",
"...",
")",
"\n",
"// Node",
"node",
":=",
"len",
"(",
"p",
".",
"nodeData",
")",
"\n",
"p",
".",
"nodeData",
"=",
"append",
"(",
"p",
".",
"nodeData",
",",
"kvOffset",
",",
"len",
"(",
"key",
")",
",",
"len",
"(",
"value",
")",
",",
"h",
")",
"\n",
"for",
"i",
",",
"n",
":=",
"range",
"p",
".",
"prevNode",
"[",
":",
"h",
"]",
"{",
"m",
":=",
"n",
"+",
"nNext",
"+",
"i",
"\n",
"p",
".",
"nodeData",
"=",
"append",
"(",
"p",
".",
"nodeData",
",",
"p",
".",
"nodeData",
"[",
"m",
"]",
")",
"\n",
"p",
".",
"nodeData",
"[",
"m",
"]",
"=",
"node",
"\n",
"}",
"\n\n",
"p",
".",
"kvSize",
"+=",
"len",
"(",
"key",
")",
"+",
"len",
"(",
"value",
")",
"\n",
"p",
".",
"n",
"++",
"\n",
"return",
"nil",
"\n",
"}"
] | // Put sets the value for the given key. It overwrites any previous value
// for that key; a DB is not a multi-map.
//
// It is safe to modify the contents of the arguments after Put returns. | [
"Put",
"sets",
"the",
"value",
"for",
"the",
"given",
"key",
".",
"It",
"overwrites",
"any",
"previous",
"value",
"for",
"that",
"key",
";",
"a",
"DB",
"is",
"not",
"a",
"multi",
"-",
"map",
".",
"It",
"is",
"safe",
"to",
"modify",
"the",
"contents",
"of",
"the",
"arguments",
"after",
"Put",
"returns",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/memdb/memdb.go#L277-L315 | train |
syndtr/goleveldb | leveldb/memdb/memdb.go | Contains | func (p *DB) Contains(key []byte) bool {
p.mu.RLock()
_, exact := p.findGE(key, false)
p.mu.RUnlock()
return exact
} | go | func (p *DB) Contains(key []byte) bool {
p.mu.RLock()
_, exact := p.findGE(key, false)
p.mu.RUnlock()
return exact
} | [
"func",
"(",
"p",
"*",
"DB",
")",
"Contains",
"(",
"key",
"[",
"]",
"byte",
")",
"bool",
"{",
"p",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"_",
",",
"exact",
":=",
"p",
".",
"findGE",
"(",
"key",
",",
"false",
")",
"\n",
"p",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"exact",
"\n",
"}"
] | // Contains returns true if the given key are in the DB.
//
// It is safe to modify the contents of the arguments after Contains returns. | [
"Contains",
"returns",
"true",
"if",
"the",
"given",
"key",
"are",
"in",
"the",
"DB",
".",
"It",
"is",
"safe",
"to",
"modify",
"the",
"contents",
"of",
"the",
"arguments",
"after",
"Contains",
"returns",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/memdb/memdb.go#L344-L349 | train |
syndtr/goleveldb | leveldb/memdb/memdb.go | Get | func (p *DB) Get(key []byte) (value []byte, err error) {
p.mu.RLock()
if node, exact := p.findGE(key, false); exact {
o := p.nodeData[node] + p.nodeData[node+nKey]
value = p.kvData[o : o+p.nodeData[node+nVal]]
} else {
err = ErrNotFound
}
p.mu.RUnlock()
return
} | go | func (p *DB) Get(key []byte) (value []byte, err error) {
p.mu.RLock()
if node, exact := p.findGE(key, false); exact {
o := p.nodeData[node] + p.nodeData[node+nKey]
value = p.kvData[o : o+p.nodeData[node+nVal]]
} else {
err = ErrNotFound
}
p.mu.RUnlock()
return
} | [
"func",
"(",
"p",
"*",
"DB",
")",
"Get",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"value",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"p",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"if",
"node",
",",
"exact",
":=",
"p",
".",
"findGE",
"(",
"key",
",",
"false",
")",
";",
"exact",
"{",
"o",
":=",
"p",
".",
"nodeData",
"[",
"node",
"]",
"+",
"p",
".",
"nodeData",
"[",
"node",
"+",
"nKey",
"]",
"\n",
"value",
"=",
"p",
".",
"kvData",
"[",
"o",
":",
"o",
"+",
"p",
".",
"nodeData",
"[",
"node",
"+",
"nVal",
"]",
"]",
"\n",
"}",
"else",
"{",
"err",
"=",
"ErrNotFound",
"\n",
"}",
"\n",
"p",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"\n",
"}"
] | // Get gets the value for the given key. It returns error.ErrNotFound if the
// DB does not contain the key.
//
// The caller should not modify the contents of the returned slice, but
// it is safe to modify the contents of the argument after Get returns. | [
"Get",
"gets",
"the",
"value",
"for",
"the",
"given",
"key",
".",
"It",
"returns",
"error",
".",
"ErrNotFound",
"if",
"the",
"DB",
"does",
"not",
"contain",
"the",
"key",
".",
"The",
"caller",
"should",
"not",
"modify",
"the",
"contents",
"of",
"the",
"returned",
"slice",
"but",
"it",
"is",
"safe",
"to",
"modify",
"the",
"contents",
"of",
"the",
"argument",
"after",
"Get",
"returns",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/memdb/memdb.go#L356-L366 | train |
syndtr/goleveldb | leveldb/memdb/memdb.go | Len | func (p *DB) Len() int {
p.mu.RLock()
defer p.mu.RUnlock()
return p.n
} | go | func (p *DB) Len() int {
p.mu.RLock()
defer p.mu.RUnlock()
return p.n
} | [
"func",
"(",
"p",
"*",
"DB",
")",
"Len",
"(",
")",
"int",
"{",
"p",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"p",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"p",
".",
"n",
"\n",
"}"
] | // Len returns the number of entries in the DB. | [
"Len",
"returns",
"the",
"number",
"of",
"entries",
"in",
"the",
"DB",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/memdb/memdb.go#L435-L439 | train |
syndtr/goleveldb | leveldb/memdb/memdb.go | Reset | func (p *DB) Reset() {
p.mu.Lock()
p.rnd = rand.New(rand.NewSource(0xdeadbeef))
p.maxHeight = 1
p.n = 0
p.kvSize = 0
p.kvData = p.kvData[:0]
p.nodeData = p.nodeData[:nNext+tMaxHeight]
p.nodeData[nKV] = 0
p.nodeData[nKey] = 0
p.nodeData[nVal] = 0
p.nodeData[nHeight] = tMaxHeight
for n := 0; n < tMaxHeight; n++ {
p.nodeData[nNext+n] = 0
p.prevNode[n] = 0
}
p.mu.Unlock()
} | go | func (p *DB) Reset() {
p.mu.Lock()
p.rnd = rand.New(rand.NewSource(0xdeadbeef))
p.maxHeight = 1
p.n = 0
p.kvSize = 0
p.kvData = p.kvData[:0]
p.nodeData = p.nodeData[:nNext+tMaxHeight]
p.nodeData[nKV] = 0
p.nodeData[nKey] = 0
p.nodeData[nVal] = 0
p.nodeData[nHeight] = tMaxHeight
for n := 0; n < tMaxHeight; n++ {
p.nodeData[nNext+n] = 0
p.prevNode[n] = 0
}
p.mu.Unlock()
} | [
"func",
"(",
"p",
"*",
"DB",
")",
"Reset",
"(",
")",
"{",
"p",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"p",
".",
"rnd",
"=",
"rand",
".",
"New",
"(",
"rand",
".",
"NewSource",
"(",
"0xdeadbeef",
")",
")",
"\n",
"p",
".",
"maxHeight",
"=",
"1",
"\n",
"p",
".",
"n",
"=",
"0",
"\n",
"p",
".",
"kvSize",
"=",
"0",
"\n",
"p",
".",
"kvData",
"=",
"p",
".",
"kvData",
"[",
":",
"0",
"]",
"\n",
"p",
".",
"nodeData",
"=",
"p",
".",
"nodeData",
"[",
":",
"nNext",
"+",
"tMaxHeight",
"]",
"\n",
"p",
".",
"nodeData",
"[",
"nKV",
"]",
"=",
"0",
"\n",
"p",
".",
"nodeData",
"[",
"nKey",
"]",
"=",
"0",
"\n",
"p",
".",
"nodeData",
"[",
"nVal",
"]",
"=",
"0",
"\n",
"p",
".",
"nodeData",
"[",
"nHeight",
"]",
"=",
"tMaxHeight",
"\n",
"for",
"n",
":=",
"0",
";",
"n",
"<",
"tMaxHeight",
";",
"n",
"++",
"{",
"p",
".",
"nodeData",
"[",
"nNext",
"+",
"n",
"]",
"=",
"0",
"\n",
"p",
".",
"prevNode",
"[",
"n",
"]",
"=",
"0",
"\n",
"}",
"\n",
"p",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"}"
] | // Reset resets the DB to initial empty state. Allows reuse the buffer. | [
"Reset",
"resets",
"the",
"DB",
"to",
"initial",
"empty",
"state",
".",
"Allows",
"reuse",
"the",
"buffer",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/memdb/memdb.go#L442-L459 | train |
syndtr/goleveldb | leveldb/iterator/array_iter.go | NewArrayIterator | func NewArrayIterator(array Array) Iterator {
return &arrayIterator{
basicArrayIterator: basicArrayIterator{array: array, pos: -1},
array: array,
pos: -1,
}
} | go | func NewArrayIterator(array Array) Iterator {
return &arrayIterator{
basicArrayIterator: basicArrayIterator{array: array, pos: -1},
array: array,
pos: -1,
}
} | [
"func",
"NewArrayIterator",
"(",
"array",
"Array",
")",
"Iterator",
"{",
"return",
"&",
"arrayIterator",
"{",
"basicArrayIterator",
":",
"basicArrayIterator",
"{",
"array",
":",
"array",
",",
"pos",
":",
"-",
"1",
"}",
",",
"array",
":",
"array",
",",
"pos",
":",
"-",
"1",
",",
"}",
"\n",
"}"
] | // NewArrayIterator returns an iterator from the given array. | [
"NewArrayIterator",
"returns",
"an",
"iterator",
"from",
"the",
"given",
"array",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/iterator/array_iter.go#L170-L176 | train |
syndtr/goleveldb | leveldb/iterator/array_iter.go | NewArrayIndexer | func NewArrayIndexer(array ArrayIndexer) IteratorIndexer {
return &arrayIteratorIndexer{
basicArrayIterator: basicArrayIterator{array: array, pos: -1},
array: array,
}
} | go | func NewArrayIndexer(array ArrayIndexer) IteratorIndexer {
return &arrayIteratorIndexer{
basicArrayIterator: basicArrayIterator{array: array, pos: -1},
array: array,
}
} | [
"func",
"NewArrayIndexer",
"(",
"array",
"ArrayIndexer",
")",
"IteratorIndexer",
"{",
"return",
"&",
"arrayIteratorIndexer",
"{",
"basicArrayIterator",
":",
"basicArrayIterator",
"{",
"array",
":",
"array",
",",
"pos",
":",
"-",
"1",
"}",
",",
"array",
":",
"array",
",",
"}",
"\n",
"}"
] | // NewArrayIndexer returns an index iterator from the given array. | [
"NewArrayIndexer",
"returns",
"an",
"index",
"iterator",
"from",
"the",
"given",
"array",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/iterator/array_iter.go#L179-L184 | train |
syndtr/goleveldb | leveldb/cache/lru.go | NewLRU | func NewLRU(capacity int) Cacher {
r := &lru{capacity: capacity}
r.reset()
return r
} | go | func NewLRU(capacity int) Cacher {
r := &lru{capacity: capacity}
r.reset()
return r
} | [
"func",
"NewLRU",
"(",
"capacity",
"int",
")",
"Cacher",
"{",
"r",
":=",
"&",
"lru",
"{",
"capacity",
":",
"capacity",
"}",
"\n",
"r",
".",
"reset",
"(",
")",
"\n",
"return",
"r",
"\n",
"}"
] | // NewLRU create a new LRU-cache. | [
"NewLRU",
"create",
"a",
"new",
"LRU",
"-",
"cache",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/cache/lru.go#L191-L195 | train |
syndtr/goleveldb | leveldb/journal/journal.go | NewReader | func NewReader(r io.Reader, dropper Dropper, strict, checksum bool) *Reader {
return &Reader{
r: r,
dropper: dropper,
strict: strict,
checksum: checksum,
last: true,
}
} | go | func NewReader(r io.Reader, dropper Dropper, strict, checksum bool) *Reader {
return &Reader{
r: r,
dropper: dropper,
strict: strict,
checksum: checksum,
last: true,
}
} | [
"func",
"NewReader",
"(",
"r",
"io",
".",
"Reader",
",",
"dropper",
"Dropper",
",",
"strict",
",",
"checksum",
"bool",
")",
"*",
"Reader",
"{",
"return",
"&",
"Reader",
"{",
"r",
":",
"r",
",",
"dropper",
":",
"dropper",
",",
"strict",
":",
"strict",
",",
"checksum",
":",
"checksum",
",",
"last",
":",
"true",
",",
"}",
"\n",
"}"
] | // NewReader returns a new reader. The dropper may be nil, and if
// strict is true then corrupted or invalid chunk will halt the journal
// reader entirely. | [
"NewReader",
"returns",
"a",
"new",
"reader",
".",
"The",
"dropper",
"may",
"be",
"nil",
"and",
"if",
"strict",
"is",
"true",
"then",
"corrupted",
"or",
"invalid",
"chunk",
"will",
"halt",
"the",
"journal",
"reader",
"entirely",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/journal/journal.go#L152-L160 | train |
syndtr/goleveldb | leveldb/journal/journal.go | Reset | func (r *Reader) Reset(reader io.Reader, dropper Dropper, strict, checksum bool) error {
r.seq++
err := r.err
r.r = reader
r.dropper = dropper
r.strict = strict
r.checksum = checksum
r.i = 0
r.j = 0
r.n = 0
r.last = true
r.err = nil
return err
} | go | func (r *Reader) Reset(reader io.Reader, dropper Dropper, strict, checksum bool) error {
r.seq++
err := r.err
r.r = reader
r.dropper = dropper
r.strict = strict
r.checksum = checksum
r.i = 0
r.j = 0
r.n = 0
r.last = true
r.err = nil
return err
} | [
"func",
"(",
"r",
"*",
"Reader",
")",
"Reset",
"(",
"reader",
"io",
".",
"Reader",
",",
"dropper",
"Dropper",
",",
"strict",
",",
"checksum",
"bool",
")",
"error",
"{",
"r",
".",
"seq",
"++",
"\n",
"err",
":=",
"r",
".",
"err",
"\n",
"r",
".",
"r",
"=",
"reader",
"\n",
"r",
".",
"dropper",
"=",
"dropper",
"\n",
"r",
".",
"strict",
"=",
"strict",
"\n",
"r",
".",
"checksum",
"=",
"checksum",
"\n",
"r",
".",
"i",
"=",
"0",
"\n",
"r",
".",
"j",
"=",
"0",
"\n",
"r",
".",
"n",
"=",
"0",
"\n",
"r",
".",
"last",
"=",
"true",
"\n",
"r",
".",
"err",
"=",
"nil",
"\n",
"return",
"err",
"\n",
"}"
] | // Reset resets the journal reader, allows reuse of the journal reader. Reset returns
// last accumulated error. | [
"Reset",
"resets",
"the",
"journal",
"reader",
"allows",
"reuse",
"of",
"the",
"journal",
"reader",
".",
"Reset",
"returns",
"last",
"accumulated",
"error",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/journal/journal.go#L266-L279 | train |
syndtr/goleveldb | leveldb/journal/journal.go | fillHeader | func (w *Writer) fillHeader(last bool) {
if w.i+headerSize > w.j || w.j > blockSize {
panic("leveldb/journal: bad writer state")
}
if last {
if w.first {
w.buf[w.i+6] = fullChunkType
} else {
w.buf[w.i+6] = lastChunkType
}
} else {
if w.first {
w.buf[w.i+6] = firstChunkType
} else {
w.buf[w.i+6] = middleChunkType
}
}
binary.LittleEndian.PutUint32(w.buf[w.i+0:w.i+4], util.NewCRC(w.buf[w.i+6:w.j]).Value())
binary.LittleEndian.PutUint16(w.buf[w.i+4:w.i+6], uint16(w.j-w.i-headerSize))
} | go | func (w *Writer) fillHeader(last bool) {
if w.i+headerSize > w.j || w.j > blockSize {
panic("leveldb/journal: bad writer state")
}
if last {
if w.first {
w.buf[w.i+6] = fullChunkType
} else {
w.buf[w.i+6] = lastChunkType
}
} else {
if w.first {
w.buf[w.i+6] = firstChunkType
} else {
w.buf[w.i+6] = middleChunkType
}
}
binary.LittleEndian.PutUint32(w.buf[w.i+0:w.i+4], util.NewCRC(w.buf[w.i+6:w.j]).Value())
binary.LittleEndian.PutUint16(w.buf[w.i+4:w.i+6], uint16(w.j-w.i-headerSize))
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"fillHeader",
"(",
"last",
"bool",
")",
"{",
"if",
"w",
".",
"i",
"+",
"headerSize",
">",
"w",
".",
"j",
"||",
"w",
".",
"j",
">",
"blockSize",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"last",
"{",
"if",
"w",
".",
"first",
"{",
"w",
".",
"buf",
"[",
"w",
".",
"i",
"+",
"6",
"]",
"=",
"fullChunkType",
"\n",
"}",
"else",
"{",
"w",
".",
"buf",
"[",
"w",
".",
"i",
"+",
"6",
"]",
"=",
"lastChunkType",
"\n",
"}",
"\n",
"}",
"else",
"{",
"if",
"w",
".",
"first",
"{",
"w",
".",
"buf",
"[",
"w",
".",
"i",
"+",
"6",
"]",
"=",
"firstChunkType",
"\n",
"}",
"else",
"{",
"w",
".",
"buf",
"[",
"w",
".",
"i",
"+",
"6",
"]",
"=",
"middleChunkType",
"\n",
"}",
"\n",
"}",
"\n",
"binary",
".",
"LittleEndian",
".",
"PutUint32",
"(",
"w",
".",
"buf",
"[",
"w",
".",
"i",
"+",
"0",
":",
"w",
".",
"i",
"+",
"4",
"]",
",",
"util",
".",
"NewCRC",
"(",
"w",
".",
"buf",
"[",
"w",
".",
"i",
"+",
"6",
":",
"w",
".",
"j",
"]",
")",
".",
"Value",
"(",
")",
")",
"\n",
"binary",
".",
"LittleEndian",
".",
"PutUint16",
"(",
"w",
".",
"buf",
"[",
"w",
".",
"i",
"+",
"4",
":",
"w",
".",
"i",
"+",
"6",
"]",
",",
"uint16",
"(",
"w",
".",
"j",
"-",
"w",
".",
"i",
"-",
"headerSize",
")",
")",
"\n",
"}"
] | // fillHeader fills in the header for the pending chunk. | [
"fillHeader",
"fills",
"in",
"the",
"header",
"for",
"the",
"pending",
"chunk",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/journal/journal.go#L377-L396 | train |
syndtr/goleveldb | leveldb/journal/journal.go | writeBlock | func (w *Writer) writeBlock() {
_, w.err = w.w.Write(w.buf[w.written:])
w.i = 0
w.j = headerSize
w.written = 0
} | go | func (w *Writer) writeBlock() {
_, w.err = w.w.Write(w.buf[w.written:])
w.i = 0
w.j = headerSize
w.written = 0
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"writeBlock",
"(",
")",
"{",
"_",
",",
"w",
".",
"err",
"=",
"w",
".",
"w",
".",
"Write",
"(",
"w",
".",
"buf",
"[",
"w",
".",
"written",
":",
"]",
")",
"\n",
"w",
".",
"i",
"=",
"0",
"\n",
"w",
".",
"j",
"=",
"headerSize",
"\n",
"w",
".",
"written",
"=",
"0",
"\n",
"}"
] | // writeBlock writes the buffered block to the underlying writer, and reserves
// space for the next chunk's header. | [
"writeBlock",
"writes",
"the",
"buffered",
"block",
"to",
"the",
"underlying",
"writer",
"and",
"reserves",
"space",
"for",
"the",
"next",
"chunk",
"s",
"header",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/journal/journal.go#L400-L405 | train |
syndtr/goleveldb | leveldb/journal/journal.go | writePending | func (w *Writer) writePending() {
if w.err != nil {
return
}
if w.pending {
w.fillHeader(true)
w.pending = false
}
_, w.err = w.w.Write(w.buf[w.written:w.j])
w.written = w.j
} | go | func (w *Writer) writePending() {
if w.err != nil {
return
}
if w.pending {
w.fillHeader(true)
w.pending = false
}
_, w.err = w.w.Write(w.buf[w.written:w.j])
w.written = w.j
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"writePending",
"(",
")",
"{",
"if",
"w",
".",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"if",
"w",
".",
"pending",
"{",
"w",
".",
"fillHeader",
"(",
"true",
")",
"\n",
"w",
".",
"pending",
"=",
"false",
"\n",
"}",
"\n",
"_",
",",
"w",
".",
"err",
"=",
"w",
".",
"w",
".",
"Write",
"(",
"w",
".",
"buf",
"[",
"w",
".",
"written",
":",
"w",
".",
"j",
"]",
")",
"\n",
"w",
".",
"written",
"=",
"w",
".",
"j",
"\n",
"}"
] | // writePending finishes the current journal and writes the buffer to the
// underlying writer. | [
"writePending",
"finishes",
"the",
"current",
"journal",
"and",
"writes",
"the",
"buffer",
"to",
"the",
"underlying",
"writer",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/journal/journal.go#L409-L419 | train |
syndtr/goleveldb | leveldb/journal/journal.go | Close | func (w *Writer) Close() error {
w.seq++
w.writePending()
if w.err != nil {
return w.err
}
w.err = errors.New("leveldb/journal: closed Writer")
return nil
} | go | func (w *Writer) Close() error {
w.seq++
w.writePending()
if w.err != nil {
return w.err
}
w.err = errors.New("leveldb/journal: closed Writer")
return nil
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"Close",
"(",
")",
"error",
"{",
"w",
".",
"seq",
"++",
"\n",
"w",
".",
"writePending",
"(",
")",
"\n",
"if",
"w",
".",
"err",
"!=",
"nil",
"{",
"return",
"w",
".",
"err",
"\n",
"}",
"\n",
"w",
".",
"err",
"=",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // Close finishes the current journal and closes the writer. | [
"Close",
"finishes",
"the",
"current",
"journal",
"and",
"closes",
"the",
"writer",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/journal/journal.go#L422-L430 | train |
syndtr/goleveldb | leveldb/journal/journal.go | Reset | func (w *Writer) Reset(writer io.Writer) (err error) {
w.seq++
if w.err == nil {
w.writePending()
err = w.err
}
w.w = writer
w.f, _ = writer.(flusher)
w.i = 0
w.j = 0
w.written = 0
w.first = false
w.pending = false
w.err = nil
return
} | go | func (w *Writer) Reset(writer io.Writer) (err error) {
w.seq++
if w.err == nil {
w.writePending()
err = w.err
}
w.w = writer
w.f, _ = writer.(flusher)
w.i = 0
w.j = 0
w.written = 0
w.first = false
w.pending = false
w.err = nil
return
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"Reset",
"(",
"writer",
"io",
".",
"Writer",
")",
"(",
"err",
"error",
")",
"{",
"w",
".",
"seq",
"++",
"\n",
"if",
"w",
".",
"err",
"==",
"nil",
"{",
"w",
".",
"writePending",
"(",
")",
"\n",
"err",
"=",
"w",
".",
"err",
"\n",
"}",
"\n",
"w",
".",
"w",
"=",
"writer",
"\n",
"w",
".",
"f",
",",
"_",
"=",
"writer",
".",
"(",
"flusher",
")",
"\n",
"w",
".",
"i",
"=",
"0",
"\n",
"w",
".",
"j",
"=",
"0",
"\n",
"w",
".",
"written",
"=",
"0",
"\n",
"w",
".",
"first",
"=",
"false",
"\n",
"w",
".",
"pending",
"=",
"false",
"\n",
"w",
".",
"err",
"=",
"nil",
"\n",
"return",
"\n",
"}"
] | // Reset resets the journal writer, allows reuse of the journal writer. Reset
// will also closes the journal writer if not already. | [
"Reset",
"resets",
"the",
"journal",
"writer",
"allows",
"reuse",
"of",
"the",
"journal",
"writer",
".",
"Reset",
"will",
"also",
"closes",
"the",
"journal",
"writer",
"if",
"not",
"already",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/journal/journal.go#L449-L464 | train |
syndtr/goleveldb | leveldb/version.go | newVersion | func newVersion(s *session) *version {
id := atomic.AddInt64(&s.ntVersionId, 1)
nv := &version{s: s, id: id - 1}
return nv
} | go | func newVersion(s *session) *version {
id := atomic.AddInt64(&s.ntVersionId, 1)
nv := &version{s: s, id: id - 1}
return nv
} | [
"func",
"newVersion",
"(",
"s",
"*",
"session",
")",
"*",
"version",
"{",
"id",
":=",
"atomic",
".",
"AddInt64",
"(",
"&",
"s",
".",
"ntVersionId",
",",
"1",
")",
"\n",
"nv",
":=",
"&",
"version",
"{",
"s",
":",
"s",
",",
"id",
":",
"id",
"-",
"1",
"}",
"\n",
"return",
"nv",
"\n",
"}"
] | // newVersion creates a new version with an unique monotonous increasing id. | [
"newVersion",
"creates",
"a",
"new",
"version",
"with",
"an",
"unique",
"monotonous",
"increasing",
"id",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/version.go#L45-L49 | train |
syndtr/goleveldb | leveldb/version.go | spawn | func (v *version) spawn(r *sessionRecord, trivial bool) *version {
staging := v.newStaging()
staging.commit(r)
return staging.finish(trivial)
} | go | func (v *version) spawn(r *sessionRecord, trivial bool) *version {
staging := v.newStaging()
staging.commit(r)
return staging.finish(trivial)
} | [
"func",
"(",
"v",
"*",
"version",
")",
"spawn",
"(",
"r",
"*",
"sessionRecord",
",",
"trivial",
"bool",
")",
"*",
"version",
"{",
"staging",
":=",
"v",
".",
"newStaging",
"(",
")",
"\n",
"staging",
".",
"commit",
"(",
"r",
")",
"\n",
"return",
"staging",
".",
"finish",
"(",
"trivial",
")",
"\n",
"}"
] | // Spawn a new version based on this version. | [
"Spawn",
"a",
"new",
"version",
"based",
"on",
"this",
"version",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/version.go#L279-L283 | train |
syndtr/goleveldb | leveldb/cache/cache.go | NewCache | func NewCache(cacher Cacher) *Cache {
h := &mNode{
buckets: make([]unsafe.Pointer, mInitialSize),
mask: mInitialSize - 1,
growThreshold: int32(mInitialSize * mOverflowThreshold),
shrinkThreshold: 0,
}
for i := range h.buckets {
h.buckets[i] = unsafe.Pointer(&mBucket{})
}
r := &Cache{
mHead: unsafe.Pointer(h),
cacher: cacher,
}
return r
} | go | func NewCache(cacher Cacher) *Cache {
h := &mNode{
buckets: make([]unsafe.Pointer, mInitialSize),
mask: mInitialSize - 1,
growThreshold: int32(mInitialSize * mOverflowThreshold),
shrinkThreshold: 0,
}
for i := range h.buckets {
h.buckets[i] = unsafe.Pointer(&mBucket{})
}
r := &Cache{
mHead: unsafe.Pointer(h),
cacher: cacher,
}
return r
} | [
"func",
"NewCache",
"(",
"cacher",
"Cacher",
")",
"*",
"Cache",
"{",
"h",
":=",
"&",
"mNode",
"{",
"buckets",
":",
"make",
"(",
"[",
"]",
"unsafe",
".",
"Pointer",
",",
"mInitialSize",
")",
",",
"mask",
":",
"mInitialSize",
"-",
"1",
",",
"growThreshold",
":",
"int32",
"(",
"mInitialSize",
"*",
"mOverflowThreshold",
")",
",",
"shrinkThreshold",
":",
"0",
",",
"}",
"\n",
"for",
"i",
":=",
"range",
"h",
".",
"buckets",
"{",
"h",
".",
"buckets",
"[",
"i",
"]",
"=",
"unsafe",
".",
"Pointer",
"(",
"&",
"mBucket",
"{",
"}",
")",
"\n",
"}",
"\n",
"r",
":=",
"&",
"Cache",
"{",
"mHead",
":",
"unsafe",
".",
"Pointer",
"(",
"h",
")",
",",
"cacher",
":",
"cacher",
",",
"}",
"\n",
"return",
"r",
"\n",
"}"
] | // NewCache creates a new 'cache map'. The cacher is optional and
// may be nil. | [
"NewCache",
"creates",
"a",
"new",
"cache",
"map",
".",
"The",
"cacher",
"is",
"optional",
"and",
"may",
"be",
"nil",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/cache/cache.go#L299-L314 | train |
syndtr/goleveldb | leveldb/cache/cache.go | Capacity | func (r *Cache) Capacity() int {
if r.cacher == nil {
return 0
}
return r.cacher.Capacity()
} | go | func (r *Cache) Capacity() int {
if r.cacher == nil {
return 0
}
return r.cacher.Capacity()
} | [
"func",
"(",
"r",
"*",
"Cache",
")",
"Capacity",
"(",
")",
"int",
"{",
"if",
"r",
".",
"cacher",
"==",
"nil",
"{",
"return",
"0",
"\n",
"}",
"\n",
"return",
"r",
".",
"cacher",
".",
"Capacity",
"(",
")",
"\n",
"}"
] | // Capacity returns cache capacity. | [
"Capacity",
"returns",
"cache",
"capacity",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/cache/cache.go#L347-L352 | train |
syndtr/goleveldb | leveldb/cache/cache.go | SetCapacity | func (r *Cache) SetCapacity(capacity int) {
if r.cacher != nil {
r.cacher.SetCapacity(capacity)
}
} | go | func (r *Cache) SetCapacity(capacity int) {
if r.cacher != nil {
r.cacher.SetCapacity(capacity)
}
} | [
"func",
"(",
"r",
"*",
"Cache",
")",
"SetCapacity",
"(",
"capacity",
"int",
")",
"{",
"if",
"r",
".",
"cacher",
"!=",
"nil",
"{",
"r",
".",
"cacher",
".",
"SetCapacity",
"(",
"capacity",
")",
"\n",
"}",
"\n",
"}"
] | // SetCapacity sets cache capacity. | [
"SetCapacity",
"sets",
"cache",
"capacity",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/cache/cache.go#L355-L359 | train |
syndtr/goleveldb | leveldb/cache/cache.go | Get | func (r *Cache) Get(ns, key uint64, setFunc func() (size int, value Value)) *Handle {
r.mu.RLock()
defer r.mu.RUnlock()
if r.closed {
return nil
}
hash := murmur32(ns, key, 0xf00)
for {
h, b := r.getBucket(hash)
done, _, n := b.get(r, h, hash, ns, key, setFunc == nil)
if done {
if n != nil {
n.mu.Lock()
if n.value == nil {
if setFunc == nil {
n.mu.Unlock()
n.unref()
return nil
}
n.size, n.value = setFunc()
if n.value == nil {
n.size = 0
n.mu.Unlock()
n.unref()
return nil
}
atomic.AddInt32(&r.size, int32(n.size))
}
n.mu.Unlock()
if r.cacher != nil {
r.cacher.Promote(n)
}
return &Handle{unsafe.Pointer(n)}
}
break
}
}
return nil
} | go | func (r *Cache) Get(ns, key uint64, setFunc func() (size int, value Value)) *Handle {
r.mu.RLock()
defer r.mu.RUnlock()
if r.closed {
return nil
}
hash := murmur32(ns, key, 0xf00)
for {
h, b := r.getBucket(hash)
done, _, n := b.get(r, h, hash, ns, key, setFunc == nil)
if done {
if n != nil {
n.mu.Lock()
if n.value == nil {
if setFunc == nil {
n.mu.Unlock()
n.unref()
return nil
}
n.size, n.value = setFunc()
if n.value == nil {
n.size = 0
n.mu.Unlock()
n.unref()
return nil
}
atomic.AddInt32(&r.size, int32(n.size))
}
n.mu.Unlock()
if r.cacher != nil {
r.cacher.Promote(n)
}
return &Handle{unsafe.Pointer(n)}
}
break
}
}
return nil
} | [
"func",
"(",
"r",
"*",
"Cache",
")",
"Get",
"(",
"ns",
",",
"key",
"uint64",
",",
"setFunc",
"func",
"(",
")",
"(",
"size",
"int",
",",
"value",
"Value",
")",
")",
"*",
"Handle",
"{",
"r",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"r",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"r",
".",
"closed",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"hash",
":=",
"murmur32",
"(",
"ns",
",",
"key",
",",
"0xf00",
")",
"\n",
"for",
"{",
"h",
",",
"b",
":=",
"r",
".",
"getBucket",
"(",
"hash",
")",
"\n",
"done",
",",
"_",
",",
"n",
":=",
"b",
".",
"get",
"(",
"r",
",",
"h",
",",
"hash",
",",
"ns",
",",
"key",
",",
"setFunc",
"==",
"nil",
")",
"\n",
"if",
"done",
"{",
"if",
"n",
"!=",
"nil",
"{",
"n",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"if",
"n",
".",
"value",
"==",
"nil",
"{",
"if",
"setFunc",
"==",
"nil",
"{",
"n",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"n",
".",
"unref",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"n",
".",
"size",
",",
"n",
".",
"value",
"=",
"setFunc",
"(",
")",
"\n",
"if",
"n",
".",
"value",
"==",
"nil",
"{",
"n",
".",
"size",
"=",
"0",
"\n",
"n",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"n",
".",
"unref",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"atomic",
".",
"AddInt32",
"(",
"&",
"r",
".",
"size",
",",
"int32",
"(",
"n",
".",
"size",
")",
")",
"\n",
"}",
"\n",
"n",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"r",
".",
"cacher",
"!=",
"nil",
"{",
"r",
".",
"cacher",
".",
"Promote",
"(",
"n",
")",
"\n",
"}",
"\n",
"return",
"&",
"Handle",
"{",
"unsafe",
".",
"Pointer",
"(",
"n",
")",
"}",
"\n",
"}",
"\n\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Get gets 'cache node' with the given namespace and key.
// If cache node is not found and setFunc is not nil, Get will atomically creates
// the 'cache node' by calling setFunc. Otherwise Get will returns nil.
//
// The returned 'cache handle' should be released after use by calling Release
// method. | [
"Get",
"gets",
"cache",
"node",
"with",
"the",
"given",
"namespace",
"and",
"key",
".",
"If",
"cache",
"node",
"is",
"not",
"found",
"and",
"setFunc",
"is",
"not",
"nil",
"Get",
"will",
"atomically",
"creates",
"the",
"cache",
"node",
"by",
"calling",
"setFunc",
".",
"Otherwise",
"Get",
"will",
"returns",
"nil",
".",
"The",
"returned",
"cache",
"handle",
"should",
"be",
"released",
"after",
"use",
"by",
"calling",
"Release",
"method",
"."
] | c3a204f8e96543bb0cc090385c001078f184fc46 | https://github.com/syndtr/goleveldb/blob/c3a204f8e96543bb0cc090385c001078f184fc46/leveldb/cache/cache.go#L367-L408 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.