repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens list | docstring stringlengths 6 2.61k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 85 252 | partition stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
siddontang/ledisdb | ledis/t_kv.go | Exists | func (db *DB) Exists(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
var err error
key = db.encodeKVKey(key)
var v []byte
v, err = db.bucket.Get(key)
if v != nil && err == nil {
return 1, nil
}
return 0, err
} | go | func (db *DB) Exists(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
var err error
key = db.encodeKVKey(key)
var v []byte
v, err = db.bucket.Get(key)
if v != nil && err == nil {
return 1, nil
}
return 0, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"Exists",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\... | // Exists check data exists or not. | [
"Exists",
"check",
"data",
"exists",
"or",
"not",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L158-L173 | train |
siddontang/ledisdb | ledis/t_kv.go | Get | func (db *DB) Get(key []byte) ([]byte, error) {
if err := checkKeySize(key); err != nil {
return nil, err
}
key = db.encodeKVKey(key)
return db.bucket.Get(key)
} | go | func (db *DB) Get(key []byte) ([]byte, error) {
if err := checkKeySize(key); err != nil {
return nil, err
}
key = db.encodeKVKey(key)
return db.bucket.Get(key)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"Get",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
... | // Get gets the value. | [
"Get",
"gets",
"the",
"value",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L176-L184 | train |
siddontang/ledisdb | ledis/t_kv.go | GetSlice | func (db *DB) GetSlice(key []byte) (store.Slice, error) {
if err := checkKeySize(key); err != nil {
return nil, err
}
key = db.encodeKVKey(key)
return db.bucket.GetSlice(key)
} | go | func (db *DB) GetSlice(key []byte) (store.Slice, error) {
if err := checkKeySize(key); err != nil {
return nil, err
}
key = db.encodeKVKey(key)
return db.bucket.GetSlice(key)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"GetSlice",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"store",
".",
"Slice",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",... | // GetSlice gets the slice of the data. | [
"GetSlice",
"gets",
"the",
"slice",
"of",
"the",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L187-L195 | train |
siddontang/ledisdb | ledis/t_kv.go | GetSet | func (db *DB) GetSet(key []byte, value []byte) ([]byte, error) {
if err := checkKeySize(key); err != nil {
return nil, err
} else if err := checkValueSize(value); err != nil {
return nil, err
}
key = db.encodeKVKey(key)
t := db.kvBatch
t.Lock()
defer t.Unlock()
oldValue, err := db.bucket.Get(key)
if er... | go | func (db *DB) GetSet(key []byte, value []byte) ([]byte, error) {
if err := checkKeySize(key); err != nil {
return nil, err
} else if err := checkValueSize(value); err != nil {
return nil, err
}
key = db.encodeKVKey(key)
t := db.kvBatch
t.Lock()
defer t.Unlock()
oldValue, err := db.bucket.Get(key)
if er... | [
"func",
"(",
"db",
"*",
"DB",
")",
"GetSet",
"(",
"key",
"[",
"]",
"byte",
",",
"value",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
... | // GetSet gets the value and sets new value. | [
"GetSet",
"gets",
"the",
"value",
"and",
"sets",
"new",
"value",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L198-L222 | train |
siddontang/ledisdb | ledis/t_kv.go | Incr | func (db *DB) Incr(key []byte) (int64, error) {
return db.incr(key, 1)
} | go | func (db *DB) Incr(key []byte) (int64, error) {
return db.incr(key, 1)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"Incr",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"return",
"db",
".",
"incr",
"(",
"key",
",",
"1",
")",
"\n",
"}"
] | // Incr increases the data. | [
"Incr",
"increases",
"the",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L225-L227 | train |
siddontang/ledisdb | ledis/t_kv.go | IncrBy | func (db *DB) IncrBy(key []byte, increment int64) (int64, error) {
return db.incr(key, increment)
} | go | func (db *DB) IncrBy(key []byte, increment int64) (int64, error) {
return db.incr(key, increment)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"IncrBy",
"(",
"key",
"[",
"]",
"byte",
",",
"increment",
"int64",
")",
"(",
"int64",
",",
"error",
")",
"{",
"return",
"db",
".",
"incr",
"(",
"key",
",",
"increment",
")",
"\n",
"}"
] | // IncrBy increases the data by increment. | [
"IncrBy",
"increases",
"the",
"data",
"by",
"increment",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L230-L232 | train |
siddontang/ledisdb | ledis/t_kv.go | MGet | func (db *DB) MGet(keys ...[]byte) ([][]byte, error) {
values := make([][]byte, len(keys))
it := db.bucket.NewIterator()
defer it.Close()
for i := range keys {
if err := checkKeySize(keys[i]); err != nil {
return nil, err
}
values[i] = it.Find(db.encodeKVKey(keys[i]))
}
return values, nil
} | go | func (db *DB) MGet(keys ...[]byte) ([][]byte, error) {
values := make([][]byte, len(keys))
it := db.bucket.NewIterator()
defer it.Close()
for i := range keys {
if err := checkKeySize(keys[i]); err != nil {
return nil, err
}
values[i] = it.Find(db.encodeKVKey(keys[i]))
}
return values, nil
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"MGet",
"(",
"keys",
"...",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"values",
":=",
"make",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"len",
"(",
"keys",
")",
")",
"\n... | // MGet gets multi data. | [
"MGet",
"gets",
"multi",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L235-L250 | train |
siddontang/ledisdb | ledis/t_kv.go | MSet | func (db *DB) MSet(args ...KVPair) error {
if len(args) == 0 {
return nil
}
t := db.kvBatch
var err error
var key []byte
var value []byte
t.Lock()
defer t.Unlock()
for i := 0; i < len(args); i++ {
if err := checkKeySize(args[i].Key); err != nil {
return err
} else if err := checkValueSize(args[i].... | go | func (db *DB) MSet(args ...KVPair) error {
if len(args) == 0 {
return nil
}
t := db.kvBatch
var err error
var key []byte
var value []byte
t.Lock()
defer t.Unlock()
for i := 0; i < len(args); i++ {
if err := checkKeySize(args[i].Key); err != nil {
return err
} else if err := checkValueSize(args[i].... | [
"func",
"(",
"db",
"*",
"DB",
")",
"MSet",
"(",
"args",
"...",
"KVPair",
")",
"error",
"{",
"if",
"len",
"(",
"args",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"t",
":=",
"db",
".",
"kvBatch",
"\n\n",
"var",
"err",
"error",
"\n",... | // MSet sets multi data. | [
"MSet",
"sets",
"multi",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L253-L284 | train |
siddontang/ledisdb | ledis/t_kv.go | Set | func (db *DB) Set(key []byte, value []byte) error {
if err := checkKeySize(key); err != nil {
return err
} else if err := checkValueSize(value); err != nil {
return err
}
var err error
key = db.encodeKVKey(key)
t := db.kvBatch
t.Lock()
defer t.Unlock()
t.Put(key, value)
err = t.Commit()
return err
... | go | func (db *DB) Set(key []byte, value []byte) error {
if err := checkKeySize(key); err != nil {
return err
} else if err := checkValueSize(value); err != nil {
return err
}
var err error
key = db.encodeKVKey(key)
t := db.kvBatch
t.Lock()
defer t.Unlock()
t.Put(key, value)
err = t.Commit()
return err
... | [
"func",
"(",
"db",
"*",
"DB",
")",
"Set",
"(",
"key",
"[",
"]",
"byte",
",",
"value",
"[",
"]",
"byte",
")",
"error",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"else",
"... | // Set sets the data. | [
"Set",
"sets",
"the",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L287-L307 | train |
siddontang/ledisdb | ledis/t_kv.go | SetNX | func (db *DB) SetNX(key []byte, value []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
} else if err := checkValueSize(value); err != nil {
return 0, err
}
var err error
key = db.encodeKVKey(key)
var n int64 = 1
t := db.kvBatch
t.Lock()
defer t.Unlock()
if v, err := db... | go | func (db *DB) SetNX(key []byte, value []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
} else if err := checkValueSize(value); err != nil {
return 0, err
}
var err error
key = db.encodeKVKey(key)
var n int64 = 1
t := db.kvBatch
t.Lock()
defer t.Unlock()
if v, err := db... | [
"func",
"(",
"db",
"*",
"DB",
")",
"SetNX",
"(",
"key",
"[",
"]",
"byte",
",",
"value",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"... | // SetNX sets the data if not existed. | [
"SetNX",
"sets",
"the",
"data",
"if",
"not",
"existed",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L310-L338 | train |
siddontang/ledisdb | ledis/t_kv.go | SetEX | func (db *DB) SetEX(key []byte, duration int64, value []byte) error {
if err := checkKeySize(key); err != nil {
return err
} else if err := checkValueSize(value); err != nil {
return err
} else if duration <= 0 {
return errExpireValue
}
ek := db.encodeKVKey(key)
t := db.kvBatch
t.Lock()
defer t.Unlock(... | go | func (db *DB) SetEX(key []byte, duration int64, value []byte) error {
if err := checkKeySize(key); err != nil {
return err
} else if err := checkValueSize(value); err != nil {
return err
} else if duration <= 0 {
return errExpireValue
}
ek := db.encodeKVKey(key)
t := db.kvBatch
t.Lock()
defer t.Unlock(... | [
"func",
"(",
"db",
"*",
"DB",
")",
"SetEX",
"(",
"key",
"[",
"]",
"byte",
",",
"duration",
"int64",
",",
"value",
"[",
"]",
"byte",
")",
"error",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"... | // SetEX sets the data with a TTL. | [
"SetEX",
"sets",
"the",
"data",
"with",
"a",
"TTL",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L341-L361 | train |
siddontang/ledisdb | ledis/t_kv.go | Expire | func (db *DB) Expire(key []byte, duration int64) (int64, error) {
if duration <= 0 {
return 0, errExpireValue
}
return db.setExpireAt(key, time.Now().Unix()+duration)
} | go | func (db *DB) Expire(key []byte, duration int64) (int64, error) {
if duration <= 0 {
return 0, errExpireValue
}
return db.setExpireAt(key, time.Now().Unix()+duration)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"Expire",
"(",
"key",
"[",
"]",
"byte",
",",
"duration",
"int64",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"duration",
"<=",
"0",
"{",
"return",
"0",
",",
"errExpireValue",
"\n",
"}",
"\n\n",
"return",
"... | // Expire expires the data. | [
"Expire",
"expires",
"the",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L371-L377 | train |
siddontang/ledisdb | ledis/t_kv.go | ExpireAt | func (db *DB) ExpireAt(key []byte, when int64) (int64, error) {
if when <= time.Now().Unix() {
return 0, errExpireValue
}
return db.setExpireAt(key, when)
} | go | func (db *DB) ExpireAt(key []byte, when int64) (int64, error) {
if when <= time.Now().Unix() {
return 0, errExpireValue
}
return db.setExpireAt(key, when)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ExpireAt",
"(",
"key",
"[",
"]",
"byte",
",",
"when",
"int64",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"when",
"<=",
"time",
".",
"Now",
"(",
")",
".",
"Unix",
"(",
")",
"{",
"return",
"0",
",",
... | // ExpireAt expires the data at when. | [
"ExpireAt",
"expires",
"the",
"data",
"at",
"when",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L380-L386 | train |
siddontang/ledisdb | ledis/t_kv.go | TTL | func (db *DB) TTL(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return -1, err
}
return db.ttl(KVType, key)
} | go | func (db *DB) TTL(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return -1, err
}
return db.ttl(KVType, key)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"TTL",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"-",
"1",
",",
"err",
"\n",
"}",
... | // TTL returns the TTL of the data. | [
"TTL",
"returns",
"the",
"TTL",
"of",
"the",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L389-L395 | train |
siddontang/ledisdb | ledis/t_kv.go | Persist | func (db *DB) Persist(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.kvBatch
t.Lock()
defer t.Unlock()
n, err := db.rmExpire(t, KVType, key)
if err != nil {
return 0, err
}
err = t.Commit()
return n, err
} | go | func (db *DB) Persist(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.kvBatch
t.Lock()
defer t.Unlock()
n, err := db.rmExpire(t, KVType, key)
if err != nil {
return 0, err
}
err = t.Commit()
return n, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"Persist",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n... | // Persist removes the TTL of the data. | [
"Persist",
"removes",
"the",
"TTL",
"of",
"the",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L398-L413 | train |
siddontang/ledisdb | ledis/t_kv.go | SetRange | func (db *DB) SetRange(key []byte, offset int, value []byte) (int64, error) {
if len(value) == 0 {
return 0, nil
}
if err := checkKeySize(key); err != nil {
return 0, err
} else if len(value)+offset > MaxValueSize {
return 0, errValueSize
}
key = db.encodeKVKey(key)
t := db.kvBatch
t.Lock()
defer t.U... | go | func (db *DB) SetRange(key []byte, offset int, value []byte) (int64, error) {
if len(value) == 0 {
return 0, nil
}
if err := checkKeySize(key); err != nil {
return 0, err
} else if len(value)+offset > MaxValueSize {
return 0, errValueSize
}
key = db.encodeKVKey(key)
t := db.kvBatch
t.Lock()
defer t.U... | [
"func",
"(",
"db",
"*",
"DB",
")",
"SetRange",
"(",
"key",
"[",
"]",
"byte",
",",
"offset",
"int",
",",
"value",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"len",
"(",
"value",
")",
"==",
"0",
"{",
"return",
"0",
",",
... | // SetRange sets the data with new value from offset. | [
"SetRange",
"sets",
"the",
"data",
"with",
"new",
"value",
"from",
"offset",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L416-L453 | train |
siddontang/ledisdb | ledis/t_kv.go | GetRange | func (db *DB) GetRange(key []byte, start int, end int) ([]byte, error) {
if err := checkKeySize(key); err != nil {
return nil, err
}
key = db.encodeKVKey(key)
value, err := db.bucket.Get(key)
if err != nil {
return nil, err
}
valLen := len(value)
start, end = getRange(start, end, valLen)
if start > end... | go | func (db *DB) GetRange(key []byte, start int, end int) ([]byte, error) {
if err := checkKeySize(key); err != nil {
return nil, err
}
key = db.encodeKVKey(key)
value, err := db.bucket.Get(key)
if err != nil {
return nil, err
}
valLen := len(value)
start, end = getRange(start, end, valLen)
if start > end... | [
"func",
"(",
"db",
"*",
"DB",
")",
"GetRange",
"(",
"key",
"[",
"]",
"byte",
",",
"start",
"int",
",",
"end",
"int",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"ni... | // GetRange gets the range of the data. | [
"GetRange",
"gets",
"the",
"range",
"of",
"the",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L479-L499 | train |
siddontang/ledisdb | ledis/t_kv.go | StrLen | func (db *DB) StrLen(key []byte) (int64, error) {
s, err := db.GetSlice(key)
if err != nil {
return 0, err
}
n := s.Size()
s.Free()
return int64(n), nil
} | go | func (db *DB) StrLen(key []byte) (int64, error) {
s, err := db.GetSlice(key)
if err != nil {
return 0, err
}
n := s.Size()
s.Free()
return int64(n), nil
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"StrLen",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"s",
",",
"err",
":=",
"db",
".",
"GetSlice",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"e... | // StrLen returns the length of the data. | [
"StrLen",
"returns",
"the",
"length",
"of",
"the",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L502-L511 | train |
siddontang/ledisdb | ledis/t_kv.go | Append | func (db *DB) Append(key []byte, value []byte) (int64, error) {
if len(value) == 0 {
return 0, nil
}
if err := checkKeySize(key); err != nil {
return 0, err
}
key = db.encodeKVKey(key)
t := db.kvBatch
t.Lock()
defer t.Unlock()
oldValue, err := db.bucket.Get(key)
if err != nil {
return 0, err
}
if... | go | func (db *DB) Append(key []byte, value []byte) (int64, error) {
if len(value) == 0 {
return 0, nil
}
if err := checkKeySize(key); err != nil {
return 0, err
}
key = db.encodeKVKey(key)
t := db.kvBatch
t.Lock()
defer t.Unlock()
oldValue, err := db.bucket.Get(key)
if err != nil {
return 0, err
}
if... | [
"func",
"(",
"db",
"*",
"DB",
")",
"Append",
"(",
"key",
"[",
"]",
"byte",
",",
"value",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"len",
"(",
"value",
")",
"==",
"0",
"{",
"return",
"0",
",",
"nil",
"\n",
"}",
"\n\... | // Append appends the value to the data. | [
"Append",
"appends",
"the",
"value",
"to",
"the",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L514-L547 | train |
siddontang/ledisdb | ledis/t_kv.go | BitOP | func (db *DB) BitOP(op string, destKey []byte, srcKeys ...[]byte) (int64, error) {
if err := checkKeySize(destKey); err != nil {
return 0, err
}
op = strings.ToLower(op)
if len(srcKeys) == 0 {
return 0, nil
} else if op == BitNot && len(srcKeys) > 1 {
return 0, fmt.Errorf("BITOP NOT has only one srckey")
}... | go | func (db *DB) BitOP(op string, destKey []byte, srcKeys ...[]byte) (int64, error) {
if err := checkKeySize(destKey); err != nil {
return 0, err
}
op = strings.ToLower(op)
if len(srcKeys) == 0 {
return 0, nil
} else if op == BitNot && len(srcKeys) > 1 {
return 0, fmt.Errorf("BITOP NOT has only one srckey")
}... | [
"func",
"(",
"db",
"*",
"DB",
")",
"BitOP",
"(",
"op",
"string",
",",
"destKey",
"[",
"]",
"byte",
",",
"srcKeys",
"...",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"destKey",
")",
";",
... | // BitOP does the bit operations in data. | [
"BitOP",
"does",
"the",
"bit",
"operations",
"in",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L550-L631 | train |
siddontang/ledisdb | ledis/t_kv.go | BitCount | func (db *DB) BitCount(key []byte, start int, end int) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
key = db.encodeKVKey(key)
value, err := db.bucket.Get(key)
if err != nil {
return 0, err
}
start, end = getRange(start, end, len(value))
value = value[start : end+1]
var n in... | go | func (db *DB) BitCount(key []byte, start int, end int) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
key = db.encodeKVKey(key)
value, err := db.bucket.Get(key)
if err != nil {
return 0, err
}
start, end = getRange(start, end, len(value))
value = value[start : end+1]
var n in... | [
"func",
"(",
"db",
"*",
"DB",
")",
"BitCount",
"(",
"key",
"[",
"]",
"byte",
",",
"start",
"int",
",",
"end",
"int",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
... | // BitCount returns the bit count of data. | [
"BitCount",
"returns",
"the",
"bit",
"count",
"of",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L653-L679 | train |
siddontang/ledisdb | ledis/t_kv.go | BitPos | func (db *DB) BitPos(key []byte, on int, start int, end int) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
if (on & ^1) != 0 {
return 0, fmt.Errorf("bit must be 0 or 1, not %d", on)
}
var skipValue uint8
if on == 0 {
skipValue = 0xFF
}
key = db.encodeKVKey(key)
value, err ... | go | func (db *DB) BitPos(key []byte, on int, start int, end int) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
if (on & ^1) != 0 {
return 0, fmt.Errorf("bit must be 0 or 1, not %d", on)
}
var skipValue uint8
if on == 0 {
skipValue = 0xFF
}
key = db.encodeKVKey(key)
value, err ... | [
"func",
"(",
"db",
"*",
"DB",
")",
"BitPos",
"(",
"key",
"[",
"]",
"byte",
",",
"on",
"int",
",",
"start",
"int",
",",
"end",
"int",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!... | // BitPos returns the pos of the data. | [
"BitPos",
"returns",
"the",
"pos",
"of",
"the",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L682-L718 | train |
siddontang/ledisdb | ledis/t_kv.go | SetBit | func (db *DB) SetBit(key []byte, offset int, on int) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
if (on & ^1) != 0 {
return 0, fmt.Errorf("bit must be 0 or 1, not %d", on)
}
t := db.kvBatch
t.Lock()
defer t.Unlock()
key = db.encodeKVKey(key)
value, err := db.bucket.Get(ke... | go | func (db *DB) SetBit(key []byte, offset int, on int) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
if (on & ^1) != 0 {
return 0, fmt.Errorf("bit must be 0 or 1, not %d", on)
}
t := db.kvBatch
t.Lock()
defer t.Unlock()
key = db.encodeKVKey(key)
value, err := db.bucket.Get(ke... | [
"func",
"(",
"db",
"*",
"DB",
")",
"SetBit",
"(",
"key",
"[",
"]",
"byte",
",",
"offset",
"int",
",",
"on",
"int",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"r... | // SetBit sets the bit to the data. | [
"SetBit",
"sets",
"the",
"bit",
"to",
"the",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L721-L766 | train |
siddontang/ledisdb | ledis/t_kv.go | GetBit | func (db *DB) GetBit(key []byte, offset int) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
key = db.encodeKVKey(key)
value, err := db.bucket.Get(key)
if err != nil {
return 0, err
}
byteOffset := uint32(offset) >> 3
bit := 7 - uint8(uint32(offset)&0x7)
if byteOffset >= uint... | go | func (db *DB) GetBit(key []byte, offset int) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
key = db.encodeKVKey(key)
value, err := db.bucket.Get(key)
if err != nil {
return 0, err
}
byteOffset := uint32(offset) >> 3
bit := 7 - uint8(uint32(offset)&0x7)
if byteOffset >= uint... | [
"func",
"(",
"db",
"*",
"DB",
")",
"GetBit",
"(",
"key",
"[",
"]",
"byte",
",",
"offset",
"int",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
... | // GetBit gets the bit of data at offset. | [
"GetBit",
"gets",
"the",
"bit",
"of",
"data",
"at",
"offset",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_kv.go#L769-L794 | train |
siddontang/ledisdb | ledis/replication.go | WaitReplication | func (l *Ledis) WaitReplication() error {
if !l.ReplicationUsed() {
return ErrRplNotSupport
}
for i := 0; i < 100; i++ {
l.noticeReplication()
select {
case <-l.rDoneCh:
case <-l.quit:
return nil
}
time.Sleep(100 * time.Millisecond)
b, err := l.r.CommitIDBehind()
if err != nil {
return er... | go | func (l *Ledis) WaitReplication() error {
if !l.ReplicationUsed() {
return ErrRplNotSupport
}
for i := 0; i < 100; i++ {
l.noticeReplication()
select {
case <-l.rDoneCh:
case <-l.quit:
return nil
}
time.Sleep(100 * time.Millisecond)
b, err := l.r.CommitIDBehind()
if err != nil {
return er... | [
"func",
"(",
"l",
"*",
"Ledis",
")",
"WaitReplication",
"(",
")",
"error",
"{",
"if",
"!",
"l",
".",
"ReplicationUsed",
"(",
")",
"{",
"return",
"ErrRplNotSupport",
"\n\n",
"}",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"100",
";",
"i",
"++",
... | // WaitReplication waits replication done | [
"WaitReplication",
"waits",
"replication",
"done"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/replication.go#L95-L120 | train |
siddontang/ledisdb | ledis/replication.go | StoreLogsFromReader | func (l *Ledis) StoreLogsFromReader(rb io.Reader) error {
if !l.ReplicationUsed() {
return ErrRplNotSupport
} else if !l.cfg.Readonly {
return ErrRplInRDWR
}
log := &rpl.Log{}
for {
if err := log.Decode(rb); err != nil {
if err == io.EOF {
break
} else {
return err
}
}
if err := l.r.S... | go | func (l *Ledis) StoreLogsFromReader(rb io.Reader) error {
if !l.ReplicationUsed() {
return ErrRplNotSupport
} else if !l.cfg.Readonly {
return ErrRplInRDWR
}
log := &rpl.Log{}
for {
if err := log.Decode(rb); err != nil {
if err == io.EOF {
break
} else {
return err
}
}
if err := l.r.S... | [
"func",
"(",
"l",
"*",
"Ledis",
")",
"StoreLogsFromReader",
"(",
"rb",
"io",
".",
"Reader",
")",
"error",
"{",
"if",
"!",
"l",
".",
"ReplicationUsed",
"(",
")",
"{",
"return",
"ErrRplNotSupport",
"\n",
"}",
"else",
"if",
"!",
"l",
".",
"cfg",
".",
... | // StoreLogsFromReader stores logs from the Reader | [
"StoreLogsFromReader",
"stores",
"logs",
"from",
"the",
"Reader"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/replication.go#L123-L150 | train |
siddontang/ledisdb | ledis/replication.go | StoreLogsFromData | func (l *Ledis) StoreLogsFromData(data []byte) error {
rb := bytes.NewReader(data)
return l.StoreLogsFromReader(rb)
} | go | func (l *Ledis) StoreLogsFromData(data []byte) error {
rb := bytes.NewReader(data)
return l.StoreLogsFromReader(rb)
} | [
"func",
"(",
"l",
"*",
"Ledis",
")",
"StoreLogsFromData",
"(",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"rb",
":=",
"bytes",
".",
"NewReader",
"(",
"data",
")",
"\n\n",
"return",
"l",
".",
"StoreLogsFromReader",
"(",
"rb",
")",
"\n",
"}"
] | // StoreLogsFromData stores logs from data. | [
"StoreLogsFromData",
"stores",
"logs",
"from",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/replication.go#L157-L161 | train |
siddontang/ledisdb | ledis/replication.go | ReadLogsTo | func (l *Ledis) ReadLogsTo(startLogID uint64, w io.Writer) (n int, nextLogID uint64, err error) {
if !l.ReplicationUsed() {
// no replication log
nextLogID = 0
err = ErrRplNotSupport
return
}
var firtID, lastID uint64
firtID, err = l.r.FirstLogID()
if err != nil {
return
}
if startLogID < firtID {
... | go | func (l *Ledis) ReadLogsTo(startLogID uint64, w io.Writer) (n int, nextLogID uint64, err error) {
if !l.ReplicationUsed() {
// no replication log
nextLogID = 0
err = ErrRplNotSupport
return
}
var firtID, lastID uint64
firtID, err = l.r.FirstLogID()
if err != nil {
return
}
if startLogID < firtID {
... | [
"func",
"(",
"l",
"*",
"Ledis",
")",
"ReadLogsTo",
"(",
"startLogID",
"uint64",
",",
"w",
"io",
".",
"Writer",
")",
"(",
"n",
"int",
",",
"nextLogID",
"uint64",
",",
"err",
"error",
")",
"{",
"if",
"!",
"l",
".",
"ReplicationUsed",
"(",
")",
"{",
... | // ReadLogsTo reads logs and write to the Writer. | [
"ReadLogsTo",
"reads",
"logs",
"and",
"write",
"to",
"the",
"Writer",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/replication.go#L164-L211 | train |
siddontang/ledisdb | ledis/replication.go | ReadLogsToTimeout | func (l *Ledis) ReadLogsToTimeout(startLogID uint64, w io.Writer, timeout int, quitCh chan struct{}) (n int, nextLogID uint64, err error) {
n, nextLogID, err = l.ReadLogsTo(startLogID, w)
if err != nil {
return
} else if n != 0 {
return
}
//no events read
select {
case <-l.r.WaitLog():
case <-time.After(tim... | go | func (l *Ledis) ReadLogsToTimeout(startLogID uint64, w io.Writer, timeout int, quitCh chan struct{}) (n int, nextLogID uint64, err error) {
n, nextLogID, err = l.ReadLogsTo(startLogID, w)
if err != nil {
return
} else if n != 0 {
return
}
//no events read
select {
case <-l.r.WaitLog():
case <-time.After(tim... | [
"func",
"(",
"l",
"*",
"Ledis",
")",
"ReadLogsToTimeout",
"(",
"startLogID",
"uint64",
",",
"w",
"io",
".",
"Writer",
",",
"timeout",
"int",
",",
"quitCh",
"chan",
"struct",
"{",
"}",
")",
"(",
"n",
"int",
",",
"nextLogID",
"uint64",
",",
"err",
"err... | // ReadLogsToTimeout tries to read events, if no events read,
// tres to wait the new event singal until timeout seconds | [
"ReadLogsToTimeout",
"tries",
"to",
"read",
"events",
"if",
"no",
"events",
"read",
"tres",
"to",
"wait",
"the",
"new",
"event",
"singal",
"until",
"timeout",
"seconds"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/replication.go#L215-L230 | train |
siddontang/ledisdb | ledis/replication.go | AddNewLogEventHandler | func (l *Ledis) AddNewLogEventHandler(h NewLogEventHandler) error {
if !l.ReplicationUsed() {
return ErrRplNotSupport
}
l.rhs = append(l.rhs, h)
return nil
} | go | func (l *Ledis) AddNewLogEventHandler(h NewLogEventHandler) error {
if !l.ReplicationUsed() {
return ErrRplNotSupport
}
l.rhs = append(l.rhs, h)
return nil
} | [
"func",
"(",
"l",
"*",
"Ledis",
")",
"AddNewLogEventHandler",
"(",
"h",
"NewLogEventHandler",
")",
"error",
"{",
"if",
"!",
"l",
".",
"ReplicationUsed",
"(",
")",
"{",
"return",
"ErrRplNotSupport",
"\n",
"}",
"\n\n",
"l",
".",
"rhs",
"=",
"append",
"(",
... | // AddNewLogEventHandler adds the handler for the new log event | [
"AddNewLogEventHandler",
"adds",
"the",
"handler",
"for",
"the",
"new",
"log",
"event"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/replication.go#L242-L250 | train |
siddontang/ledisdb | ledis/replication.go | ReplicationStat | func (l *Ledis) ReplicationStat() (*rpl.Stat, error) {
if !l.ReplicationUsed() {
return nil, ErrRplNotSupport
}
return l.r.Stat()
} | go | func (l *Ledis) ReplicationStat() (*rpl.Stat, error) {
if !l.ReplicationUsed() {
return nil, ErrRplNotSupport
}
return l.r.Stat()
} | [
"func",
"(",
"l",
"*",
"Ledis",
")",
"ReplicationStat",
"(",
")",
"(",
"*",
"rpl",
".",
"Stat",
",",
"error",
")",
"{",
"if",
"!",
"l",
".",
"ReplicationUsed",
"(",
")",
"{",
"return",
"nil",
",",
"ErrRplNotSupport",
"\n",
"}",
"\n\n",
"return",
"l... | // ReplicationStat returns the statistics of repliaciton. | [
"ReplicationStat",
"returns",
"the",
"statistics",
"of",
"repliaciton",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/replication.go#L253-L259 | train |
siddontang/ledisdb | ledis/t_zset.go | ZAdd | func (db *DB) ZAdd(key []byte, args ...ScorePair) (int64, error) {
if len(args) == 0 {
return 0, nil
}
t := db.zsetBatch
t.Lock()
defer t.Unlock()
var num int64
for i := 0; i < len(args); i++ {
score := args[i].Score
member := args[i].Member
if err := checkZSetKMSize(key, member); err != nil {
retu... | go | func (db *DB) ZAdd(key []byte, args ...ScorePair) (int64, error) {
if len(args) == 0 {
return 0, nil
}
t := db.zsetBatch
t.Lock()
defer t.Unlock()
var num int64
for i := 0; i < len(args); i++ {
score := args[i].Score
member := args[i].Member
if err := checkZSetKMSize(key, member); err != nil {
retu... | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZAdd",
"(",
"key",
"[",
"]",
"byte",
",",
"args",
"...",
"ScorePair",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"len",
"(",
"args",
")",
"==",
"0",
"{",
"return",
"0",
",",
"nil",
"\n",
"}",
"\n\n",
... | // ZAdd add the members. | [
"ZAdd",
"add",
"the",
"members",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L317-L349 | train |
siddontang/ledisdb | ledis/t_zset.go | ZCard | func (db *DB) ZCard(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
sk := db.zEncodeSizeKey(key)
return Int64(db.bucket.Get(sk))
} | go | func (db *DB) ZCard(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
sk := db.zEncodeSizeKey(key)
return Int64(db.bucket.Get(sk))
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZCard",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n... | // ZCard gets the size of the zset. | [
"ZCard",
"gets",
"the",
"size",
"of",
"the",
"zset",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L371-L378 | train |
siddontang/ledisdb | ledis/t_zset.go | ZScore | func (db *DB) ZScore(key []byte, member []byte) (int64, error) {
if err := checkZSetKMSize(key, member); err != nil {
return InvalidScore, err
}
score := InvalidScore
k := db.zEncodeSetKey(key, member)
if v, err := db.bucket.Get(k); err != nil {
return InvalidScore, err
} else if v == nil {
return Invalid... | go | func (db *DB) ZScore(key []byte, member []byte) (int64, error) {
if err := checkZSetKMSize(key, member); err != nil {
return InvalidScore, err
}
score := InvalidScore
k := db.zEncodeSetKey(key, member)
if v, err := db.bucket.Get(k); err != nil {
return InvalidScore, err
} else if v == nil {
return Invalid... | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZScore",
"(",
"key",
"[",
"]",
"byte",
",",
"member",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkZSetKMSize",
"(",
"key",
",",
"member",
")",
";",
"err",
"!=",
"nil"... | // ZScore gets the score of member. | [
"ZScore",
"gets",
"the",
"score",
"of",
"member",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L381-L400 | train |
siddontang/ledisdb | ledis/t_zset.go | ZRem | func (db *DB) ZRem(key []byte, members ...[]byte) (int64, error) {
if len(members) == 0 {
return 0, nil
}
t := db.zsetBatch
t.Lock()
defer t.Unlock()
var num int64
for i := 0; i < len(members); i++ {
if err := checkZSetKMSize(key, members[i]); err != nil {
return 0, err
}
if n, err := db.zDelItem(t... | go | func (db *DB) ZRem(key []byte, members ...[]byte) (int64, error) {
if len(members) == 0 {
return 0, nil
}
t := db.zsetBatch
t.Lock()
defer t.Unlock()
var num int64
for i := 0; i < len(members); i++ {
if err := checkZSetKMSize(key, members[i]); err != nil {
return 0, err
}
if n, err := db.zDelItem(t... | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZRem",
"(",
"key",
"[",
"]",
"byte",
",",
"members",
"...",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"len",
"(",
"members",
")",
"==",
"0",
"{",
"return",
"0",
",",
"nil",
"\n",
... | // ZRem removes members | [
"ZRem",
"removes",
"members"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L403-L431 | train |
siddontang/ledisdb | ledis/t_zset.go | ZIncrBy | func (db *DB) ZIncrBy(key []byte, delta int64, member []byte) (int64, error) {
if err := checkZSetKMSize(key, member); err != nil {
return InvalidScore, err
}
t := db.zsetBatch
t.Lock()
defer t.Unlock()
ek := db.zEncodeSetKey(key, member)
var oldScore int64
v, err := db.bucket.Get(ek)
if err != nil {
re... | go | func (db *DB) ZIncrBy(key []byte, delta int64, member []byte) (int64, error) {
if err := checkZSetKMSize(key, member); err != nil {
return InvalidScore, err
}
t := db.zsetBatch
t.Lock()
defer t.Unlock()
ek := db.zEncodeSetKey(key, member)
var oldScore int64
v, err := db.bucket.Get(ek)
if err != nil {
re... | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZIncrBy",
"(",
"key",
"[",
"]",
"byte",
",",
"delta",
"int64",
",",
"member",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkZSetKMSize",
"(",
"key",
",",
"member",
")",
... | // ZIncrBy increases the score of member with delta. | [
"ZIncrBy",
"increases",
"the",
"score",
"of",
"member",
"with",
"delta",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L434-L474 | train |
siddontang/ledisdb | ledis/t_zset.go | ZClear | func (db *DB) ZClear(key []byte) (int64, error) {
t := db.zsetBatch
t.Lock()
defer t.Unlock()
rmCnt, err := db.zRemRange(t, key, MinScore, MaxScore, 0, -1)
if err == nil {
err = t.Commit()
}
return rmCnt, err
} | go | func (db *DB) ZClear(key []byte) (int64, error) {
t := db.zsetBatch
t.Lock()
defer t.Unlock()
rmCnt, err := db.zRemRange(t, key, MinScore, MaxScore, 0, -1)
if err == nil {
err = t.Commit()
}
return rmCnt, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZClear",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"t",
":=",
"db",
".",
"zsetBatch",
"\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
... | // ZClear clears the zset. | [
"ZClear",
"clears",
"the",
"zset",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L672-L683 | train |
siddontang/ledisdb | ledis/t_zset.go | ZMclear | func (db *DB) ZMclear(keys ...[]byte) (int64, error) {
t := db.zsetBatch
t.Lock()
defer t.Unlock()
for _, key := range keys {
if _, err := db.zRemRange(t, key, MinScore, MaxScore, 0, -1); err != nil {
return 0, err
}
}
err := t.Commit()
return int64(len(keys)), err
} | go | func (db *DB) ZMclear(keys ...[]byte) (int64, error) {
t := db.zsetBatch
t.Lock()
defer t.Unlock()
for _, key := range keys {
if _, err := db.zRemRange(t, key, MinScore, MaxScore, 0, -1); err != nil {
return 0, err
}
}
err := t.Commit()
return int64(len(keys)), err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZMclear",
"(",
"keys",
"...",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"t",
":=",
"db",
".",
"zsetBatch",
"\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
... | // ZMclear clears multi zsets. | [
"ZMclear",
"clears",
"multi",
"zsets",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L686-L700 | train |
siddontang/ledisdb | ledis/t_zset.go | ZRange | func (db *DB) ZRange(key []byte, start int, stop int) ([]ScorePair, error) {
return db.ZRangeGeneric(key, start, stop, false)
} | go | func (db *DB) ZRange(key []byte, start int, stop int) ([]ScorePair, error) {
return db.ZRangeGeneric(key, start, stop, false)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZRange",
"(",
"key",
"[",
"]",
"byte",
",",
"start",
"int",
",",
"stop",
"int",
")",
"(",
"[",
"]",
"ScorePair",
",",
"error",
")",
"{",
"return",
"db",
".",
"ZRangeGeneric",
"(",
"key",
",",
"start",
",",
"s... | // ZRange gets the members from start to stop. | [
"ZRange",
"gets",
"the",
"members",
"from",
"start",
"to",
"stop",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L703-L705 | train |
siddontang/ledisdb | ledis/t_zset.go | ZRangeByScore | func (db *DB) ZRangeByScore(key []byte, min int64, max int64,
offset int, count int) ([]ScorePair, error) {
return db.ZRangeByScoreGeneric(key, min, max, offset, count, false)
} | go | func (db *DB) ZRangeByScore(key []byte, min int64, max int64,
offset int, count int) ([]ScorePair, error) {
return db.ZRangeByScoreGeneric(key, min, max, offset, count, false)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZRangeByScore",
"(",
"key",
"[",
"]",
"byte",
",",
"min",
"int64",
",",
"max",
"int64",
",",
"offset",
"int",
",",
"count",
"int",
")",
"(",
"[",
"]",
"ScorePair",
",",
"error",
")",
"{",
"return",
"db",
".",
... | // ZRangeByScore gets the data with score in min and max.
// min and max must be inclusive
// if no limit, set offset = 0 and count = -1 | [
"ZRangeByScore",
"gets",
"the",
"data",
"with",
"score",
"in",
"min",
"and",
"max",
".",
"min",
"and",
"max",
"must",
"be",
"inclusive",
"if",
"no",
"limit",
"set",
"offset",
"=",
"0",
"and",
"count",
"=",
"-",
"1"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L710-L713 | train |
siddontang/ledisdb | ledis/t_zset.go | ZRank | func (db *DB) ZRank(key []byte, member []byte) (int64, error) {
return db.zrank(key, member, false)
} | go | func (db *DB) ZRank(key []byte, member []byte) (int64, error) {
return db.zrank(key, member, false)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZRank",
"(",
"key",
"[",
"]",
"byte",
",",
"member",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"return",
"db",
".",
"zrank",
"(",
"key",
",",
"member",
",",
"false",
")",
"\n",
"}"
] | // ZRank gets the rank of member. | [
"ZRank",
"gets",
"the",
"rank",
"of",
"member",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L716-L718 | train |
siddontang/ledisdb | ledis/t_zset.go | ZRemRangeByRank | func (db *DB) ZRemRangeByRank(key []byte, start int, stop int) (int64, error) {
offset, count, err := db.zParseLimit(key, start, stop)
if err != nil {
return 0, err
}
var rmCnt int64
t := db.zsetBatch
t.Lock()
defer t.Unlock()
rmCnt, err = db.zRemRange(t, key, MinScore, MaxScore, offset, count)
if err == ... | go | func (db *DB) ZRemRangeByRank(key []byte, start int, stop int) (int64, error) {
offset, count, err := db.zParseLimit(key, start, stop)
if err != nil {
return 0, err
}
var rmCnt int64
t := db.zsetBatch
t.Lock()
defer t.Unlock()
rmCnt, err = db.zRemRange(t, key, MinScore, MaxScore, offset, count)
if err == ... | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZRemRangeByRank",
"(",
"key",
"[",
"]",
"byte",
",",
"start",
"int",
",",
"stop",
"int",
")",
"(",
"int64",
",",
"error",
")",
"{",
"offset",
",",
"count",
",",
"err",
":=",
"db",
".",
"zParseLimit",
"(",
"key"... | // ZRemRangeByRank removes the member at range from start to stop. | [
"ZRemRangeByRank",
"removes",
"the",
"member",
"at",
"range",
"from",
"start",
"to",
"stop",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L721-L739 | train |
siddontang/ledisdb | ledis/t_zset.go | ZRevRange | func (db *DB) ZRevRange(key []byte, start int, stop int) ([]ScorePair, error) {
return db.ZRangeGeneric(key, start, stop, true)
} | go | func (db *DB) ZRevRange(key []byte, start int, stop int) ([]ScorePair, error) {
return db.ZRangeGeneric(key, start, stop, true)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZRevRange",
"(",
"key",
"[",
"]",
"byte",
",",
"start",
"int",
",",
"stop",
"int",
")",
"(",
"[",
"]",
"ScorePair",
",",
"error",
")",
"{",
"return",
"db",
".",
"ZRangeGeneric",
"(",
"key",
",",
"start",
",",
... | // ZRevRange gets the data reversed. | [
"ZRevRange",
"gets",
"the",
"data",
"reversed",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L756-L758 | train |
siddontang/ledisdb | ledis/t_zset.go | ZRevRank | func (db *DB) ZRevRank(key []byte, member []byte) (int64, error) {
return db.zrank(key, member, true)
} | go | func (db *DB) ZRevRank(key []byte, member []byte) (int64, error) {
return db.zrank(key, member, true)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZRevRank",
"(",
"key",
"[",
"]",
"byte",
",",
"member",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"return",
"db",
".",
"zrank",
"(",
"key",
",",
"member",
",",
"true",
")",
"\n",
"}"
] | // ZRevRank gets the rank of member reversed. | [
"ZRevRank",
"gets",
"the",
"rank",
"of",
"member",
"reversed",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L761-L763 | train |
siddontang/ledisdb | ledis/t_zset.go | ZRangeGeneric | func (db *DB) ZRangeGeneric(key []byte, start int, stop int, reverse bool) ([]ScorePair, error) {
offset, count, err := db.zParseLimit(key, start, stop)
if err != nil {
return nil, err
}
return db.zRange(key, MinScore, MaxScore, offset, count, reverse)
} | go | func (db *DB) ZRangeGeneric(key []byte, start int, stop int, reverse bool) ([]ScorePair, error) {
offset, count, err := db.zParseLimit(key, start, stop)
if err != nil {
return nil, err
}
return db.zRange(key, MinScore, MaxScore, offset, count, reverse)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZRangeGeneric",
"(",
"key",
"[",
"]",
"byte",
",",
"start",
"int",
",",
"stop",
"int",
",",
"reverse",
"bool",
")",
"(",
"[",
"]",
"ScorePair",
",",
"error",
")",
"{",
"offset",
",",
"count",
",",
"err",
":=",
... | // ZRangeGeneric is a generic function for scan zset. | [
"ZRangeGeneric",
"is",
"a",
"generic",
"function",
"for",
"scan",
"zset",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L773-L780 | train |
siddontang/ledisdb | ledis/t_zset.go | ZRangeByScoreGeneric | func (db *DB) ZRangeByScoreGeneric(key []byte, min int64, max int64,
offset int, count int, reverse bool) ([]ScorePair, error) {
return db.zRange(key, min, max, offset, count, reverse)
} | go | func (db *DB) ZRangeByScoreGeneric(key []byte, min int64, max int64,
offset int, count int, reverse bool) ([]ScorePair, error) {
return db.zRange(key, min, max, offset, count, reverse)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZRangeByScoreGeneric",
"(",
"key",
"[",
"]",
"byte",
",",
"min",
"int64",
",",
"max",
"int64",
",",
"offset",
"int",
",",
"count",
"int",
",",
"reverse",
"bool",
")",
"(",
"[",
"]",
"ScorePair",
",",
"error",
")"... | // ZRangeByScoreGeneric is a generic function to scan zset with score.
// min and max must be inclusive
// if no limit, set offset = 0 and count = -1 | [
"ZRangeByScoreGeneric",
"is",
"a",
"generic",
"function",
"to",
"scan",
"zset",
"with",
"score",
".",
"min",
"and",
"max",
"must",
"be",
"inclusive",
"if",
"no",
"limit",
"set",
"offset",
"=",
"0",
"and",
"count",
"=",
"-",
"1"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L785-L789 | train |
siddontang/ledisdb | ledis/t_zset.go | ZExpire | func (db *DB) ZExpire(key []byte, duration int64) (int64, error) {
if duration <= 0 {
return 0, errExpireValue
}
return db.zExpireAt(key, time.Now().Unix()+duration)
} | go | func (db *DB) ZExpire(key []byte, duration int64) (int64, error) {
if duration <= 0 {
return 0, errExpireValue
}
return db.zExpireAt(key, time.Now().Unix()+duration)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZExpire",
"(",
"key",
"[",
"]",
"byte",
",",
"duration",
"int64",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"duration",
"<=",
"0",
"{",
"return",
"0",
",",
"errExpireValue",
"\n",
"}",
"\n\n",
"return",
... | // ZExpire expires the zset. | [
"ZExpire",
"expires",
"the",
"zset",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L799-L805 | train |
siddontang/ledisdb | ledis/t_zset.go | ZExpireAt | func (db *DB) ZExpireAt(key []byte, when int64) (int64, error) {
if when <= time.Now().Unix() {
return 0, errExpireValue
}
return db.zExpireAt(key, when)
} | go | func (db *DB) ZExpireAt(key []byte, when int64) (int64, error) {
if when <= time.Now().Unix() {
return 0, errExpireValue
}
return db.zExpireAt(key, when)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZExpireAt",
"(",
"key",
"[",
"]",
"byte",
",",
"when",
"int64",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"when",
"<=",
"time",
".",
"Now",
"(",
")",
".",
"Unix",
"(",
")",
"{",
"return",
"0",
",",
... | // ZExpireAt expires the zset at when. | [
"ZExpireAt",
"expires",
"the",
"zset",
"at",
"when",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L808-L814 | train |
siddontang/ledisdb | ledis/t_zset.go | ZTTL | func (db *DB) ZTTL(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return -1, err
}
return db.ttl(ZSetType, key)
} | go | func (db *DB) ZTTL(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return -1, err
}
return db.ttl(ZSetType, key)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZTTL",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"-",
"1",
",",
"err",
"\n",
"}",
... | // ZTTL gets the TTL of zset. | [
"ZTTL",
"gets",
"the",
"TTL",
"of",
"zset",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L817-L823 | train |
siddontang/ledisdb | ledis/t_zset.go | ZPersist | func (db *DB) ZPersist(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.zsetBatch
t.Lock()
defer t.Unlock()
n, err := db.rmExpire(t, ZSetType, key)
if err != nil {
return 0, err
}
err = t.Commit()
return n, err
} | go | func (db *DB) ZPersist(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.zsetBatch
t.Lock()
defer t.Unlock()
n, err := db.rmExpire(t, ZSetType, key)
if err != nil {
return 0, err
}
err = t.Commit()
return n, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZPersist",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\... | // ZPersist removes the TTL of zset. | [
"ZPersist",
"removes",
"the",
"TTL",
"of",
"zset",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L826-L842 | train |
siddontang/ledisdb | ledis/t_zset.go | ZUnionStore | func (db *DB) ZUnionStore(destKey []byte, srcKeys [][]byte, weights []int64, aggregate byte) (int64, error) {
var destMap = map[string]int64{}
aggregateFunc := getAggregateFunc(aggregate)
if aggregateFunc == nil {
return 0, errInvalidAggregate
}
if len(srcKeys) < 1 {
return 0, errInvalidSrcKeyNum
}
if weigh... | go | func (db *DB) ZUnionStore(destKey []byte, srcKeys [][]byte, weights []int64, aggregate byte) (int64, error) {
var destMap = map[string]int64{}
aggregateFunc := getAggregateFunc(aggregate)
if aggregateFunc == nil {
return 0, errInvalidAggregate
}
if len(srcKeys) < 1 {
return 0, errInvalidSrcKeyNum
}
if weigh... | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZUnionStore",
"(",
"destKey",
"[",
"]",
"byte",
",",
"srcKeys",
"[",
"]",
"[",
"]",
"byte",
",",
"weights",
"[",
"]",
"int64",
",",
"aggregate",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"var",
"destMa... | // ZUnionStore unions the zsets and stores to dest zset. | [
"ZUnionStore",
"unions",
"the",
"zsets",
"and",
"stores",
"to",
"dest",
"zset",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L869-L928 | train |
siddontang/ledisdb | ledis/t_zset.go | ZRangeByLex | func (db *DB) ZRangeByLex(key []byte, min []byte, max []byte, rangeType uint8, offset int, count int) ([][]byte, error) {
if min == nil {
min = db.zEncodeStartSetKey(key)
} else {
min = db.zEncodeSetKey(key, min)
}
if max == nil {
max = db.zEncodeStopSetKey(key)
} else {
max = db.zEncodeSetKey(key, max)
}... | go | func (db *DB) ZRangeByLex(key []byte, min []byte, max []byte, rangeType uint8, offset int, count int) ([][]byte, error) {
if min == nil {
min = db.zEncodeStartSetKey(key)
} else {
min = db.zEncodeSetKey(key, min)
}
if max == nil {
max = db.zEncodeStopSetKey(key)
} else {
max = db.zEncodeSetKey(key, max)
}... | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZRangeByLex",
"(",
"key",
"[",
"]",
"byte",
",",
"min",
"[",
"]",
"byte",
",",
"max",
"[",
"]",
"byte",
",",
"rangeType",
"uint8",
",",
"offset",
"int",
",",
"count",
"int",
")",
"(",
"[",
"]",
"[",
"]",
"b... | // ZRangeByLex scans the zset lexicographically | [
"ZRangeByLex",
"scans",
"the",
"zset",
"lexicographically"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L1000-L1023 | train |
siddontang/ledisdb | ledis/t_zset.go | ZLexCount | func (db *DB) ZLexCount(key []byte, min []byte, max []byte, rangeType uint8) (int64, error) {
if min == nil {
min = db.zEncodeStartSetKey(key)
} else {
min = db.zEncodeSetKey(key, min)
}
if max == nil {
max = db.zEncodeStopSetKey(key)
} else {
max = db.zEncodeSetKey(key, max)
}
it := db.bucket.RangeIter... | go | func (db *DB) ZLexCount(key []byte, min []byte, max []byte, rangeType uint8) (int64, error) {
if min == nil {
min = db.zEncodeStartSetKey(key)
} else {
min = db.zEncodeSetKey(key, min)
}
if max == nil {
max = db.zEncodeStopSetKey(key)
} else {
max = db.zEncodeSetKey(key, max)
}
it := db.bucket.RangeIter... | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZLexCount",
"(",
"key",
"[",
"]",
"byte",
",",
"min",
"[",
"]",
"byte",
",",
"max",
"[",
"]",
"byte",
",",
"rangeType",
"uint8",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"min",
"==",
"nil",
"{",
"mi... | // ZLexCount gets the count of zset lexicographically. | [
"ZLexCount",
"gets",
"the",
"count",
"of",
"zset",
"lexicographically",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L1059-L1080 | train |
siddontang/ledisdb | ledis/t_zset.go | ZKeyExists | func (db *DB) ZKeyExists(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
sk := db.zEncodeSizeKey(key)
v, err := db.bucket.Get(sk)
if v != nil && err == nil {
return 1, nil
}
return 0, err
} | go | func (db *DB) ZKeyExists(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
sk := db.zEncodeSizeKey(key)
v, err := db.bucket.Get(sk)
if v != nil && err == nil {
return 1, nil
}
return 0, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZKeyExists",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
... | // ZKeyExists checks zset existed or not. | [
"ZKeyExists",
"checks",
"zset",
"existed",
"or",
"not",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_zset.go#L1083-L1093 | train |
siddontang/ledisdb | server/client_resp.go | handleXSelectCmd | func (c *respClient) handleXSelectCmd() error {
if len(c.args) <= 2 {
// invalid command format
return fmt.Errorf("invalid format for XSELECT, must XSELECT db THEN your command")
}
if hack.String(upperSlice(c.args[1])) != "THEN" {
// invalid command format, just resturn here
return fmt.Errorf("invalid forma... | go | func (c *respClient) handleXSelectCmd() error {
if len(c.args) <= 2 {
// invalid command format
return fmt.Errorf("invalid format for XSELECT, must XSELECT db THEN your command")
}
if hack.String(upperSlice(c.args[1])) != "THEN" {
// invalid command format, just resturn here
return fmt.Errorf("invalid forma... | [
"func",
"(",
"c",
"*",
"respClient",
")",
"handleXSelectCmd",
"(",
")",
"error",
"{",
"if",
"len",
"(",
"c",
".",
"args",
")",
"<=",
"2",
"{",
"// invalid command format",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",... | // XSELECT db THEN command | [
"XSELECT",
"db",
"THEN",
"command"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/server/client_resp.go#L191-L218 | train |
siddontang/ledisdb | ledis/scan.go | buildDataScanKeyRange | func (db *DB) buildDataScanKeyRange(storeDataType byte, key []byte, cursor []byte, reverse bool) (minKey []byte, maxKey []byte, err error) {
if !reverse {
if minKey, err = db.encodeDataScanMinKey(storeDataType, key, cursor); err != nil {
return
}
if maxKey, err = db.encodeDataScanMaxKey(storeDataType, key, ni... | go | func (db *DB) buildDataScanKeyRange(storeDataType byte, key []byte, cursor []byte, reverse bool) (minKey []byte, maxKey []byte, err error) {
if !reverse {
if minKey, err = db.encodeDataScanMinKey(storeDataType, key, cursor); err != nil {
return
}
if maxKey, err = db.encodeDataScanMaxKey(storeDataType, key, ni... | [
"func",
"(",
"db",
"*",
"DB",
")",
"buildDataScanKeyRange",
"(",
"storeDataType",
"byte",
",",
"key",
"[",
"]",
"byte",
",",
"cursor",
"[",
"]",
"byte",
",",
"reverse",
"bool",
")",
"(",
"minKey",
"[",
"]",
"byte",
",",
"maxKey",
"[",
"]",
"byte",
... | // for specail data scan | [
"for",
"specail",
"data",
"scan"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/scan.go#L202-L219 | train |
siddontang/ledisdb | ledis/scan.go | HScan | func (db *DB) HScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([]FVPair, error) {
return db.hScanGeneric(key, cursor, count, inclusive, match, false)
} | go | func (db *DB) HScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([]FVPair, error) {
return db.hScanGeneric(key, cursor, count, inclusive, match, false)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"HScan",
"(",
"key",
"[",
"]",
"byte",
",",
"cursor",
"[",
"]",
"byte",
",",
"count",
"int",
",",
"inclusive",
"bool",
",",
"match",
"string",
")",
"(",
"[",
"]",
"FVPair",
",",
"error",
")",
"{",
"return",
"d... | // HScan scans data for hash. | [
"HScan",
"scans",
"data",
"for",
"hash",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/scan.go#L304-L306 | train |
siddontang/ledisdb | ledis/scan.go | HRevScan | func (db *DB) HRevScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([]FVPair, error) {
return db.hScanGeneric(key, cursor, count, inclusive, match, true)
} | go | func (db *DB) HRevScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([]FVPair, error) {
return db.hScanGeneric(key, cursor, count, inclusive, match, true)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"HRevScan",
"(",
"key",
"[",
"]",
"byte",
",",
"cursor",
"[",
"]",
"byte",
",",
"count",
"int",
",",
"inclusive",
"bool",
",",
"match",
"string",
")",
"(",
"[",
"]",
"FVPair",
",",
"error",
")",
"{",
"return",
... | // HRevScan reversed scans data for hash. | [
"HRevScan",
"reversed",
"scans",
"data",
"for",
"hash",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/scan.go#L309-L311 | train |
siddontang/ledisdb | ledis/scan.go | SScan | func (db *DB) SScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([][]byte, error) {
return db.sScanGeneric(key, cursor, count, inclusive, match, false)
} | go | func (db *DB) SScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([][]byte, error) {
return db.sScanGeneric(key, cursor, count, inclusive, match, false)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SScan",
"(",
"key",
"[",
"]",
"byte",
",",
"cursor",
"[",
"]",
"byte",
",",
"count",
"int",
",",
"inclusive",
"bool",
",",
"match",
"string",
")",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"r... | // SScan scans data for set. | [
"SScan",
"scans",
"data",
"for",
"set",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/scan.go#L347-L349 | train |
siddontang/ledisdb | ledis/scan.go | SRevScan | func (db *DB) SRevScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([][]byte, error) {
return db.sScanGeneric(key, cursor, count, inclusive, match, true)
} | go | func (db *DB) SRevScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([][]byte, error) {
return db.sScanGeneric(key, cursor, count, inclusive, match, true)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"SRevScan",
"(",
"key",
"[",
"]",
"byte",
",",
"cursor",
"[",
"]",
"byte",
",",
"count",
"int",
",",
"inclusive",
"bool",
",",
"match",
"string",
")",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"error",
")",
"{",
... | // SRevScan scans data reversed for set. | [
"SRevScan",
"scans",
"data",
"reversed",
"for",
"set",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/scan.go#L352-L354 | train |
siddontang/ledisdb | ledis/scan.go | ZScan | func (db *DB) ZScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([]ScorePair, error) {
return db.zScanGeneric(key, cursor, count, inclusive, match, false)
} | go | func (db *DB) ZScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([]ScorePair, error) {
return db.zScanGeneric(key, cursor, count, inclusive, match, false)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZScan",
"(",
"key",
"[",
"]",
"byte",
",",
"cursor",
"[",
"]",
"byte",
",",
"count",
"int",
",",
"inclusive",
"bool",
",",
"match",
"string",
")",
"(",
"[",
"]",
"ScorePair",
",",
"error",
")",
"{",
"return",
... | // ZScan scans data for zset. | [
"ZScan",
"scans",
"data",
"for",
"zset",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/scan.go#L395-L397 | train |
siddontang/ledisdb | ledis/scan.go | ZRevScan | func (db *DB) ZRevScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([]ScorePair, error) {
return db.zScanGeneric(key, cursor, count, inclusive, match, true)
} | go | func (db *DB) ZRevScan(key []byte, cursor []byte, count int, inclusive bool, match string) ([]ScorePair, error) {
return db.zScanGeneric(key, cursor, count, inclusive, match, true)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"ZRevScan",
"(",
"key",
"[",
"]",
"byte",
",",
"cursor",
"[",
"]",
"byte",
",",
"count",
"int",
",",
"inclusive",
"bool",
",",
"match",
"string",
")",
"(",
"[",
"]",
"ScorePair",
",",
"error",
")",
"{",
"return"... | // ZRevScan scans data reversed for zset. | [
"ZRevScan",
"scans",
"data",
"reversed",
"for",
"zset",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/scan.go#L400-L402 | train |
siddontang/ledisdb | store/writebatch.go | BatchData | func (wb *WriteBatch) BatchData() *BatchData {
data := wb.wb.Data()
if wb.data == nil {
wb.data = new(BatchData)
}
wb.data.Load(data)
return wb.data
} | go | func (wb *WriteBatch) BatchData() *BatchData {
data := wb.wb.Data()
if wb.data == nil {
wb.data = new(BatchData)
}
wb.data.Load(data)
return wb.data
} | [
"func",
"(",
"wb",
"*",
"WriteBatch",
")",
"BatchData",
"(",
")",
"*",
"BatchData",
"{",
"data",
":=",
"wb",
".",
"wb",
".",
"Data",
"(",
")",
"\n",
"if",
"wb",
".",
"data",
"==",
"nil",
"{",
"wb",
".",
"data",
"=",
"new",
"(",
"BatchData",
")"... | // the data will be undefined after commit or rollback | [
"the",
"data",
"will",
"be",
"undefined",
"after",
"commit",
"or",
"rollback"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/store/writebatch.go#L63-L71 | train |
siddontang/ledisdb | ledis/util.go | Uint64 | func Uint64(v []byte, err error) (uint64, error) {
if err != nil {
return 0, err
} else if v == nil || len(v) == 0 {
return 0, nil
} else if len(v) != 8 {
return 0, errIntNumber
}
return binary.LittleEndian.Uint64(v), nil
} | go | func Uint64(v []byte, err error) (uint64, error) {
if err != nil {
return 0, err
} else if v == nil || len(v) == 0 {
return 0, nil
} else if len(v) != 8 {
return 0, errIntNumber
}
return binary.LittleEndian.Uint64(v), nil
} | [
"func",
"Uint64",
"(",
"v",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"(",
"uint64",
",",
"error",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"else",
"if",
"v",
"==",
"nil",
"||",
"len",
"(",
"v",
")",
... | // Uint64 gets unsigned 64 integer. | [
"Uint64",
"gets",
"unsigned",
"64",
"integer",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/util.go#L32-L42 | train |
siddontang/ledisdb | ledis/util.go | PutInt64 | func PutInt64(v int64) []byte {
b := make([]byte, 8)
binary.LittleEndian.PutUint64(b, uint64(v))
return b
} | go | func PutInt64(v int64) []byte {
b := make([]byte, 8)
binary.LittleEndian.PutUint64(b, uint64(v))
return b
} | [
"func",
"PutInt64",
"(",
"v",
"int64",
")",
"[",
"]",
"byte",
"{",
"b",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"8",
")",
"\n",
"binary",
".",
"LittleEndian",
".",
"PutUint64",
"(",
"b",
",",
"uint64",
"(",
"v",
")",
")",
"\n",
"return",
"b",... | // PutInt64 puts the 64 integer. | [
"PutInt64",
"puts",
"the",
"64",
"integer",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/util.go#L45-L49 | train |
siddontang/ledisdb | ledis/util.go | StrInt64 | func StrInt64(v []byte, err error) (int64, error) {
if err != nil {
return 0, err
} else if v == nil {
return 0, nil
} else {
return strconv.ParseInt(hack.String(v), 10, 64)
}
} | go | func StrInt64(v []byte, err error) (int64, error) {
if err != nil {
return 0, err
} else if v == nil {
return 0, nil
} else {
return strconv.ParseInt(hack.String(v), 10, 64)
}
} | [
"func",
"StrInt64",
"(",
"v",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"else",
"if",
"v",
"==",
"nil",
"{",
"return",
"0",
",",
"nil... | // StrInt64 gets the 64 integer with string format. | [
"StrInt64",
"gets",
"the",
"64",
"integer",
"with",
"string",
"format",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/util.go#L52-L60 | train |
siddontang/ledisdb | ledis/util.go | StrUint64 | func StrUint64(v []byte, err error) (uint64, error) {
if err != nil {
return 0, err
} else if v == nil {
return 0, nil
} else {
return strconv.ParseUint(hack.String(v), 10, 64)
}
} | go | func StrUint64(v []byte, err error) (uint64, error) {
if err != nil {
return 0, err
} else if v == nil {
return 0, nil
} else {
return strconv.ParseUint(hack.String(v), 10, 64)
}
} | [
"func",
"StrUint64",
"(",
"v",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"(",
"uint64",
",",
"error",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"else",
"if",
"v",
"==",
"nil",
"{",
"return",
"0",
",",
"n... | // StrUint64 gets the unsigned 64 integer with string format. | [
"StrUint64",
"gets",
"the",
"unsigned",
"64",
"integer",
"with",
"string",
"format",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/util.go#L63-L71 | train |
siddontang/ledisdb | ledis/util.go | StrInt32 | func StrInt32(v []byte, err error) (int32, error) {
if err != nil {
return 0, err
} else if v == nil {
return 0, nil
} else {
res, err := strconv.ParseInt(hack.String(v), 10, 32)
return int32(res), err
}
} | go | func StrInt32(v []byte, err error) (int32, error) {
if err != nil {
return 0, err
} else if v == nil {
return 0, nil
} else {
res, err := strconv.ParseInt(hack.String(v), 10, 32)
return int32(res), err
}
} | [
"func",
"StrInt32",
"(",
"v",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"(",
"int32",
",",
"error",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"else",
"if",
"v",
"==",
"nil",
"{",
"return",
"0",
",",
"nil... | // StrInt32 gets the 32 integer with string format. | [
"StrInt32",
"gets",
"the",
"32",
"integer",
"with",
"string",
"format",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/util.go#L74-L83 | train |
siddontang/ledisdb | ledis/util.go | StrInt8 | func StrInt8(v []byte, err error) (int8, error) {
if err != nil {
return 0, err
} else if v == nil {
return 0, nil
} else {
res, err := strconv.ParseInt(hack.String(v), 10, 8)
return int8(res), err
}
} | go | func StrInt8(v []byte, err error) (int8, error) {
if err != nil {
return 0, err
} else if v == nil {
return 0, nil
} else {
res, err := strconv.ParseInt(hack.String(v), 10, 8)
return int8(res), err
}
} | [
"func",
"StrInt8",
"(",
"v",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"(",
"int8",
",",
"error",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"else",
"if",
"v",
"==",
"nil",
"{",
"return",
"0",
",",
"nil",... | // StrInt8 ets the 8 integer with string format. | [
"StrInt8",
"ets",
"the",
"8",
"integer",
"with",
"string",
"format",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/util.go#L86-L95 | train |
siddontang/ledisdb | ledis/sort.go | XLSort | func (db *DB) XLSort(key []byte, offset int, size int, alpha bool, desc bool, sortBy []byte, sortGet [][]byte) ([][]byte, error) {
values, err := db.LRange(key, 0, -1)
if err != nil {
return nil, err
}
return db.xsort(values, offset, size, alpha, desc, sortBy, sortGet)
} | go | func (db *DB) XLSort(key []byte, offset int, size int, alpha bool, desc bool, sortBy []byte, sortGet [][]byte) ([][]byte, error) {
values, err := db.LRange(key, 0, -1)
if err != nil {
return nil, err
}
return db.xsort(values, offset, size, alpha, desc, sortBy, sortGet)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"XLSort",
"(",
"key",
"[",
"]",
"byte",
",",
"offset",
"int",
",",
"size",
"int",
",",
"alpha",
"bool",
",",
"desc",
"bool",
",",
"sortBy",
"[",
"]",
"byte",
",",
"sortGet",
"[",
"]",
"[",
"]",
"byte",
")",
... | // XLSort sorts list. | [
"XLSort",
"sorts",
"list",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/sort.go#L207-L215 | train |
siddontang/ledisdb | ledis/sort.go | XZSort | func (db *DB) XZSort(key []byte, offset int, size int, alpha bool, desc bool, sortBy []byte, sortGet [][]byte) ([][]byte, error) {
values, err := db.ZRangeByLex(key, nil, nil, store.RangeClose, 0, -1)
if err != nil {
return nil, err
}
return db.xsort(values, offset, size, alpha, desc, sortBy, sortGet)
} | go | func (db *DB) XZSort(key []byte, offset int, size int, alpha bool, desc bool, sortBy []byte, sortGet [][]byte) ([][]byte, error) {
values, err := db.ZRangeByLex(key, nil, nil, store.RangeClose, 0, -1)
if err != nil {
return nil, err
}
return db.xsort(values, offset, size, alpha, desc, sortBy, sortGet)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"XZSort",
"(",
"key",
"[",
"]",
"byte",
",",
"offset",
"int",
",",
"size",
"int",
",",
"alpha",
"bool",
",",
"desc",
"bool",
",",
"sortBy",
"[",
"]",
"byte",
",",
"sortGet",
"[",
"]",
"[",
"]",
"byte",
")",
... | // XZSort sorts zset. | [
"XZSort",
"sorts",
"zset",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/sort.go#L228-L235 | train |
siddontang/ledisdb | ledis/t_hash.go | HLen | func (db *DB) HLen(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
return Int64(db.bucket.Get(db.hEncodeSizeKey(key)))
} | go | func (db *DB) HLen(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
return Int64(db.bucket.Get(db.hEncodeSizeKey(key)))
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"HLen",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n"... | // HLen returns the lengh of hash. | [
"HLen",
"returns",
"the",
"lengh",
"of",
"hash",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L188-L194 | train |
siddontang/ledisdb | ledis/t_hash.go | HSet | func (db *DB) HSet(key []byte, field []byte, value []byte) (int64, error) {
if err := checkHashKFSize(key, field); err != nil {
return 0, err
} else if err := checkValueSize(value); err != nil {
return 0, err
}
t := db.hashBatch
t.Lock()
defer t.Unlock()
n, err := db.hSetItem(key, field, value)
if err != ... | go | func (db *DB) HSet(key []byte, field []byte, value []byte) (int64, error) {
if err := checkHashKFSize(key, field); err != nil {
return 0, err
} else if err := checkValueSize(value); err != nil {
return 0, err
}
t := db.hashBatch
t.Lock()
defer t.Unlock()
n, err := db.hSetItem(key, field, value)
if err != ... | [
"func",
"(",
"db",
"*",
"DB",
")",
"HSet",
"(",
"key",
"[",
"]",
"byte",
",",
"field",
"[",
"]",
"byte",
",",
"value",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkHashKFSize",
"(",
"key",
",",
"field",
... | // HSet sets the field with value of key. | [
"HSet",
"sets",
"the",
"field",
"with",
"value",
"of",
"key",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L197-L215 | train |
siddontang/ledisdb | ledis/t_hash.go | HGet | func (db *DB) HGet(key []byte, field []byte) ([]byte, error) {
if err := checkHashKFSize(key, field); err != nil {
return nil, err
}
return db.bucket.Get(db.hEncodeHashKey(key, field))
} | go | func (db *DB) HGet(key []byte, field []byte) ([]byte, error) {
if err := checkHashKFSize(key, field); err != nil {
return nil, err
}
return db.bucket.Get(db.hEncodeHashKey(key, field))
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"HGet",
"(",
"key",
"[",
"]",
"byte",
",",
"field",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkHashKFSize",
"(",
"key",
",",
"field",
")",
";",
"err",
"!="... | // HGet gets the value of the field. | [
"HGet",
"gets",
"the",
"value",
"of",
"the",
"field",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L218-L224 | train |
siddontang/ledisdb | ledis/t_hash.go | HMset | func (db *DB) HMset(key []byte, args ...FVPair) error {
t := db.hashBatch
t.Lock()
defer t.Unlock()
var err error
var ek []byte
var num int64
for i := 0; i < len(args); i++ {
if err := checkHashKFSize(key, args[i].Field); err != nil {
return err
} else if err := checkValueSize(args[i].Value); err != nil ... | go | func (db *DB) HMset(key []byte, args ...FVPair) error {
t := db.hashBatch
t.Lock()
defer t.Unlock()
var err error
var ek []byte
var num int64
for i := 0; i < len(args); i++ {
if err := checkHashKFSize(key, args[i].Field); err != nil {
return err
} else if err := checkValueSize(args[i].Value); err != nil ... | [
"func",
"(",
"db",
"*",
"DB",
")",
"HMset",
"(",
"key",
"[",
"]",
"byte",
",",
"args",
"...",
"FVPair",
")",
"error",
"{",
"t",
":=",
"db",
".",
"hashBatch",
"\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n... | // HMset sets multi field-values. | [
"HMset",
"sets",
"multi",
"field",
"-",
"values",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L227-L260 | train |
siddontang/ledisdb | ledis/t_hash.go | HMget | func (db *DB) HMget(key []byte, args ...[]byte) ([][]byte, error) {
var ek []byte
it := db.bucket.NewIterator()
defer it.Close()
r := make([][]byte, len(args))
for i := 0; i < len(args); i++ {
if err := checkHashKFSize(key, args[i]); err != nil {
return nil, err
}
ek = db.hEncodeHashKey(key, args[i])
... | go | func (db *DB) HMget(key []byte, args ...[]byte) ([][]byte, error) {
var ek []byte
it := db.bucket.NewIterator()
defer it.Close()
r := make([][]byte, len(args))
for i := 0; i < len(args); i++ {
if err := checkHashKFSize(key, args[i]); err != nil {
return nil, err
}
ek = db.hEncodeHashKey(key, args[i])
... | [
"func",
"(",
"db",
"*",
"DB",
")",
"HMget",
"(",
"key",
"[",
"]",
"byte",
",",
"args",
"...",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"ek",
"[",
"]",
"byte",
"\n\n",
"it",
":=",
"db",
".",
"b... | // HMget gets multi values of fields | [
"HMget",
"gets",
"multi",
"values",
"of",
"fields"
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L263-L281 | train |
siddontang/ledisdb | ledis/t_hash.go | HDel | func (db *DB) HDel(key []byte, args ...[]byte) (int64, error) {
t := db.hashBatch
var ek []byte
var v []byte
var err error
t.Lock()
defer t.Unlock()
it := db.bucket.NewIterator()
defer it.Close()
var num int64
for i := 0; i < len(args); i++ {
if err := checkHashKFSize(key, args[i]); err != nil {
retu... | go | func (db *DB) HDel(key []byte, args ...[]byte) (int64, error) {
t := db.hashBatch
var ek []byte
var v []byte
var err error
t.Lock()
defer t.Unlock()
it := db.bucket.NewIterator()
defer it.Close()
var num int64
for i := 0; i < len(args); i++ {
if err := checkHashKFSize(key, args[i]); err != nil {
retu... | [
"func",
"(",
"db",
"*",
"DB",
")",
"HDel",
"(",
"key",
"[",
"]",
"byte",
",",
"args",
"...",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"t",
":=",
"db",
".",
"hashBatch",
"\n\n",
"var",
"ek",
"[",
"]",
"byte",
"\n",
"var",
... | // HDel deletes the fields. | [
"HDel",
"deletes",
"the",
"fields",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L284-L321 | train |
siddontang/ledisdb | ledis/t_hash.go | HIncrBy | func (db *DB) HIncrBy(key []byte, field []byte, delta int64) (int64, error) {
if err := checkHashKFSize(key, field); err != nil {
return 0, err
}
t := db.hashBatch
var ek []byte
var err error
t.Lock()
defer t.Unlock()
ek = db.hEncodeHashKey(key, field)
var n int64
if n, err = StrInt64(db.bucket.Get(ek))... | go | func (db *DB) HIncrBy(key []byte, field []byte, delta int64) (int64, error) {
if err := checkHashKFSize(key, field); err != nil {
return 0, err
}
t := db.hashBatch
var ek []byte
var err error
t.Lock()
defer t.Unlock()
ek = db.hEncodeHashKey(key, field)
var n int64
if n, err = StrInt64(db.bucket.Get(ek))... | [
"func",
"(",
"db",
"*",
"DB",
")",
"HIncrBy",
"(",
"key",
"[",
"]",
"byte",
",",
"field",
"[",
"]",
"byte",
",",
"delta",
"int64",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkHashKFSize",
"(",
"key",
",",
"field",
")",
"... | // HIncrBy increases the value of field by delta. | [
"HIncrBy",
"increases",
"the",
"value",
"of",
"field",
"by",
"delta",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L346-L375 | train |
siddontang/ledisdb | ledis/t_hash.go | HGetAll | func (db *DB) HGetAll(key []byte) ([]FVPair, error) {
if err := checkKeySize(key); err != nil {
return nil, err
}
start := db.hEncodeStartKey(key)
stop := db.hEncodeStopKey(key)
v := make([]FVPair, 0, 16)
it := db.bucket.RangeLimitIterator(start, stop, store.RangeROpen, 0, -1)
defer it.Close()
for ; it.Va... | go | func (db *DB) HGetAll(key []byte) ([]FVPair, error) {
if err := checkKeySize(key); err != nil {
return nil, err
}
start := db.hEncodeStartKey(key)
stop := db.hEncodeStopKey(key)
v := make([]FVPair, 0, 16)
it := db.bucket.RangeLimitIterator(start, stop, store.RangeROpen, 0, -1)
defer it.Close()
for ; it.Va... | [
"func",
"(",
"db",
"*",
"DB",
")",
"HGetAll",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"FVPair",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"... | // HGetAll returns all field-values. | [
"HGetAll",
"returns",
"all",
"field",
"-",
"values",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L378-L401 | train |
siddontang/ledisdb | ledis/t_hash.go | HClear | func (db *DB) HClear(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.hashBatch
t.Lock()
defer t.Unlock()
num := db.hDelete(t, key)
db.rmExpire(t, HashType, key)
err := t.Commit()
return num, err
} | go | func (db *DB) HClear(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.hashBatch
t.Lock()
defer t.Unlock()
num := db.hDelete(t, key)
db.rmExpire(t, HashType, key)
err := t.Commit()
return num, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"HClear",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\... | // HClear clears the data. | [
"HClear",
"clears",
"the",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L455-L469 | train |
siddontang/ledisdb | ledis/t_hash.go | HMclear | func (db *DB) HMclear(keys ...[]byte) (int64, error) {
t := db.hashBatch
t.Lock()
defer t.Unlock()
for _, key := range keys {
if err := checkKeySize(key); err != nil {
return 0, err
}
db.hDelete(t, key)
db.rmExpire(t, HashType, key)
}
err := t.Commit()
return int64(len(keys)), err
} | go | func (db *DB) HMclear(keys ...[]byte) (int64, error) {
t := db.hashBatch
t.Lock()
defer t.Unlock()
for _, key := range keys {
if err := checkKeySize(key); err != nil {
return 0, err
}
db.hDelete(t, key)
db.rmExpire(t, HashType, key)
}
err := t.Commit()
return int64(len(keys)), err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"HMclear",
"(",
"keys",
"...",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"t",
":=",
"db",
".",
"hashBatch",
"\n",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
... | // HMclear cleans multi data. | [
"HMclear",
"cleans",
"multi",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L472-L488 | train |
siddontang/ledisdb | ledis/t_hash.go | HExpire | func (db *DB) HExpire(key []byte, duration int64) (int64, error) {
if duration <= 0 {
return 0, errExpireValue
}
return db.hExpireAt(key, time.Now().Unix()+duration)
} | go | func (db *DB) HExpire(key []byte, duration int64) (int64, error) {
if duration <= 0 {
return 0, errExpireValue
}
return db.hExpireAt(key, time.Now().Unix()+duration)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"HExpire",
"(",
"key",
"[",
"]",
"byte",
",",
"duration",
"int64",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"duration",
"<=",
"0",
"{",
"return",
"0",
",",
"errExpireValue",
"\n",
"}",
"\n\n",
"return",
... | // HExpire expires the data with duration. | [
"HExpire",
"expires",
"the",
"data",
"with",
"duration",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L500-L506 | train |
siddontang/ledisdb | ledis/t_hash.go | HExpireAt | func (db *DB) HExpireAt(key []byte, when int64) (int64, error) {
if when <= time.Now().Unix() {
return 0, errExpireValue
}
return db.hExpireAt(key, when)
} | go | func (db *DB) HExpireAt(key []byte, when int64) (int64, error) {
if when <= time.Now().Unix() {
return 0, errExpireValue
}
return db.hExpireAt(key, when)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"HExpireAt",
"(",
"key",
"[",
"]",
"byte",
",",
"when",
"int64",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"when",
"<=",
"time",
".",
"Now",
"(",
")",
".",
"Unix",
"(",
")",
"{",
"return",
"0",
",",
... | // HExpireAt expires the data at time when. | [
"HExpireAt",
"expires",
"the",
"data",
"at",
"time",
"when",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L509-L515 | train |
siddontang/ledisdb | ledis/t_hash.go | HTTL | func (db *DB) HTTL(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return -1, err
}
return db.ttl(HashType, key)
} | go | func (db *DB) HTTL(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return -1, err
}
return db.ttl(HashType, key)
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"HTTL",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"-",
"1",
",",
"err",
"\n",
"}",
... | // HTTL gets the TTL of data. | [
"HTTL",
"gets",
"the",
"TTL",
"of",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L518-L524 | train |
siddontang/ledisdb | ledis/t_hash.go | HPersist | func (db *DB) HPersist(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.hashBatch
t.Lock()
defer t.Unlock()
n, err := db.rmExpire(t, HashType, key)
if err != nil {
return 0, err
}
err = t.Commit()
return n, err
} | go | func (db *DB) HPersist(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
t := db.hashBatch
t.Lock()
defer t.Unlock()
n, err := db.rmExpire(t, HashType, key)
if err != nil {
return 0, err
}
err = t.Commit()
return n, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"HPersist",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\... | // HPersist removes the TTL of data. | [
"HPersist",
"removes",
"the",
"TTL",
"of",
"data",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L527-L543 | train |
siddontang/ledisdb | ledis/t_hash.go | HKeyExists | func (db *DB) HKeyExists(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
sk := db.hEncodeSizeKey(key)
v, err := db.bucket.Get(sk)
if v != nil && err == nil {
return 1, nil
}
return 0, err
} | go | func (db *DB) HKeyExists(key []byte) (int64, error) {
if err := checkKeySize(key); err != nil {
return 0, err
}
sk := db.hEncodeSizeKey(key)
v, err := db.bucket.Get(sk)
if v != nil && err == nil {
return 1, nil
}
return 0, err
} | [
"func",
"(",
"db",
"*",
"DB",
")",
"HKeyExists",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"int64",
",",
"error",
")",
"{",
"if",
"err",
":=",
"checkKeySize",
"(",
"key",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
... | // HKeyExists checks whether data exists or not. | [
"HKeyExists",
"checks",
"whether",
"data",
"exists",
"or",
"not",
"."
] | 8ceb77e66a9234dc460f28234390a5896a96a584 | https://github.com/siddontang/ledisdb/blob/8ceb77e66a9234dc460f28234390a5896a96a584/ledis/t_hash.go#L546-L556 | train |
maxence-charriere/app | dom.go | Contains | func (e *domEngine) Contains(c Compo) bool {
e.mutex.RLock()
defer e.mutex.RUnlock()
_, ok := e.compos[c]
return ok
} | go | func (e *domEngine) Contains(c Compo) bool {
e.mutex.RLock()
defer e.mutex.RUnlock()
_, ok := e.compos[c]
return ok
} | [
"func",
"(",
"e",
"*",
"domEngine",
")",
"Contains",
"(",
"c",
"Compo",
")",
"bool",
"{",
"e",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"e",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n\n",
"_",
",",
"ok",
":=",
"e",
".",
"compos",
... | // Contains reports whether the given component is in the dom. | [
"Contains",
"reports",
"whether",
"the",
"given",
"component",
"is",
"in",
"the",
"dom",
"."
] | a4bd499377b93214614b805d3c2c74e0fea2379d | https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/dom.go#L60-L66 | train |
maxence-charriere/app | dom.go | CompoByID | func (e *domEngine) CompoByID(id string) (Compo, error) {
e.mutex.RLock()
defer e.mutex.RUnlock()
c, ok := e.compoIDs[id]
if !ok {
return nil, ErrCompoNotMounted
}
return c.Compo, nil
} | go | func (e *domEngine) CompoByID(id string) (Compo, error) {
e.mutex.RLock()
defer e.mutex.RUnlock()
c, ok := e.compoIDs[id]
if !ok {
return nil, ErrCompoNotMounted
}
return c.Compo, nil
} | [
"func",
"(",
"e",
"*",
"domEngine",
")",
"CompoByID",
"(",
"id",
"string",
")",
"(",
"Compo",
",",
"error",
")",
"{",
"e",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"e",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n\n",
"c",
",",
"ok",... | // CompoByID returns the component with the given identifier. | [
"CompoByID",
"returns",
"the",
"component",
"with",
"the",
"given",
"identifier",
"."
] | a4bd499377b93214614b805d3c2c74e0fea2379d | https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/dom.go#L69-L79 | train |
maxence-charriere/app | dom.go | New | func (e *domEngine) New(c Compo) error {
e.once.Do(e.init)
e.mutex.Lock()
defer e.mutex.Unlock()
e.close()
if err := e.render(c); err != nil {
return err
}
ic := e.compos[c]
e.rootID = ic.ID
e.changes = append(e.changes, change{
Action: setRoot,
NodeID: ic.ID,
})
return e.sync()
} | go | func (e *domEngine) New(c Compo) error {
e.once.Do(e.init)
e.mutex.Lock()
defer e.mutex.Unlock()
e.close()
if err := e.render(c); err != nil {
return err
}
ic := e.compos[c]
e.rootID = ic.ID
e.changes = append(e.changes, change{
Action: setRoot,
NodeID: ic.ID,
})
return e.sync()
} | [
"func",
"(",
"e",
"*",
"domEngine",
")",
"New",
"(",
"c",
"Compo",
")",
"error",
"{",
"e",
".",
"once",
".",
"Do",
"(",
"e",
".",
"init",
")",
"\n",
"e",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"e",
".",
"mutex",
".",
"Unlock",
... | // New renders the given component and set it as the dom root. | [
"New",
"renders",
"the",
"given",
"component",
"and",
"set",
"it",
"as",
"the",
"dom",
"root",
"."
] | a4bd499377b93214614b805d3c2c74e0fea2379d | https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/dom.go#L82-L102 | train |
maxence-charriere/app | dom.go | Close | func (e *domEngine) Close() {
e.once.Do(e.init)
e.mutex.Lock()
defer e.mutex.Unlock()
e.close()
} | go | func (e *domEngine) Close() {
e.once.Do(e.init)
e.mutex.Lock()
defer e.mutex.Unlock()
e.close()
} | [
"func",
"(",
"e",
"*",
"domEngine",
")",
"Close",
"(",
")",
"{",
"e",
".",
"once",
".",
"Do",
"(",
"e",
".",
"init",
")",
"\n",
"e",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"e",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"e",
... | // Close deletes the components and nodes from the dom. | [
"Close",
"deletes",
"the",
"components",
"and",
"nodes",
"from",
"the",
"dom",
"."
] | a4bd499377b93214614b805d3c2c74e0fea2379d | https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/dom.go#L105-L111 | train |
maxence-charriere/app | internal/http/cache.go | CacheHandler | func CacheHandler(h http.Handler, webDir string) http.Handler {
return &cacheHandler{
Handler: h,
webDir: webDir,
}
} | go | func CacheHandler(h http.Handler, webDir string) http.Handler {
return &cacheHandler{
Handler: h,
webDir: webDir,
}
} | [
"func",
"CacheHandler",
"(",
"h",
"http",
".",
"Handler",
",",
"webDir",
"string",
")",
"http",
".",
"Handler",
"{",
"return",
"&",
"cacheHandler",
"{",
"Handler",
":",
"h",
",",
"webDir",
":",
"webDir",
",",
"}",
"\n",
"}"
] | // CacheHandler returns a decorated version of the given cache that injects
// cache related headers. | [
"CacheHandler",
"returns",
"a",
"decorated",
"version",
"of",
"the",
"given",
"cache",
"that",
"injects",
"cache",
"related",
"headers",
"."
] | a4bd499377b93214614b805d3c2c74e0fea2379d | https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/internal/http/cache.go#L15-L20 | train |
maxence-charriere/app | internal/http/cache.go | GenerateEtag | func GenerateEtag() string {
t := time.Now().UTC().String()
return fmt.Sprintf(`%x`, sha1.Sum([]byte(t)))
} | go | func GenerateEtag() string {
t := time.Now().UTC().String()
return fmt.Sprintf(`%x`, sha1.Sum([]byte(t)))
} | [
"func",
"GenerateEtag",
"(",
")",
"string",
"{",
"t",
":=",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"String",
"(",
")",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"`%x`",
",",
"sha1",
".",
"Sum",
"(",
"[",
"]",
"byte",
"(",
... | // GenerateEtag generates an etag. | [
"GenerateEtag",
"generates",
"an",
"etag",
"."
] | a4bd499377b93214614b805d3c2c74e0fea2379d | https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/internal/http/cache.go#L63-L66 | train |
maxence-charriere/app | internal/http/cache.go | GetEtag | func GetEtag(webDir string) string {
filename := filepath.Join(webDir, ".etag")
etag, err := ioutil.ReadFile(filename)
if err != nil {
return ""
}
return string(etag)
} | go | func GetEtag(webDir string) string {
filename := filepath.Join(webDir, ".etag")
etag, err := ioutil.ReadFile(filename)
if err != nil {
return ""
}
return string(etag)
} | [
"func",
"GetEtag",
"(",
"webDir",
"string",
")",
"string",
"{",
"filename",
":=",
"filepath",
".",
"Join",
"(",
"webDir",
",",
"\"",
"\"",
")",
"\n\n",
"etag",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"filename",
")",
"\n",
"if",
"err",
"!="... | // GetEtag returns the etag for the given web directory. | [
"GetEtag",
"returns",
"the",
"etag",
"for",
"the",
"given",
"web",
"directory",
"."
] | a4bd499377b93214614b805d3c2c74e0fea2379d | https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/internal/http/cache.go#L69-L77 | train |
maxence-charriere/app | attr.go | jsToGoHandler | func jsToGoHandler(name, value string) (string, string) {
if !strings.HasPrefix(name, "on") {
return name, value
}
if strings.HasPrefix(value, "js:") {
return name, strings.TrimPrefix(value, "js:")
}
return name, fmt.Sprintf("callCompoHandler(this, event, '%s')", value)
} | go | func jsToGoHandler(name, value string) (string, string) {
if !strings.HasPrefix(name, "on") {
return name, value
}
if strings.HasPrefix(value, "js:") {
return name, strings.TrimPrefix(value, "js:")
}
return name, fmt.Sprintf("callCompoHandler(this, event, '%s')", value)
} | [
"func",
"jsToGoHandler",
"(",
"name",
",",
"value",
"string",
")",
"(",
"string",
",",
"string",
")",
"{",
"if",
"!",
"strings",
".",
"HasPrefix",
"(",
"name",
",",
"\"",
"\"",
")",
"{",
"return",
"name",
",",
"value",
"\n",
"}",
"\n\n",
"if",
"str... | // jsToGoHandler convert a javascript handler to a go component handler. | [
"jsToGoHandler",
"convert",
"a",
"javascript",
"handler",
"to",
"a",
"go",
"component",
"handler",
"."
] | a4bd499377b93214614b805d3c2c74e0fea2379d | https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/attr.go#L12-L22 | train |
maxence-charriere/app | app.go | Import | func Import(c ...Compo) {
for _, compo := range c {
if _, err := components.register(compo); err != nil {
Panicf("import component failed: %s", err)
}
}
} | go | func Import(c ...Compo) {
for _, compo := range c {
if _, err := components.register(compo); err != nil {
Panicf("import component failed: %s", err)
}
}
} | [
"func",
"Import",
"(",
"c",
"...",
"Compo",
")",
"{",
"for",
"_",
",",
"compo",
":=",
"range",
"c",
"{",
"if",
"_",
",",
"err",
":=",
"components",
".",
"register",
"(",
"compo",
")",
";",
"err",
"!=",
"nil",
"{",
"Panicf",
"(",
"\"",
"\"",
","... | // Import imports the given components into the app.
// Components must be imported in order the be used by the app package.
// This allows components to be created dynamically when they are found into
// markup. | [
"Import",
"imports",
"the",
"given",
"components",
"into",
"the",
"app",
".",
"Components",
"must",
"be",
"imported",
"in",
"order",
"the",
"be",
"used",
"by",
"the",
"app",
"package",
".",
"This",
"allows",
"components",
"to",
"be",
"created",
"dynamically"... | a4bd499377b93214614b805d3c2c74e0fea2379d | https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/app.go#L77-L83 | train |
maxence-charriere/app | app.go | Log | func Log(a ...interface{}) {
format := ""
for range a {
format += "%v "
}
format = format[:len(format)-1]
Logger(format, a...)
} | go | func Log(a ...interface{}) {
format := ""
for range a {
format += "%v "
}
format = format[:len(format)-1]
Logger(format, a...)
} | [
"func",
"Log",
"(",
"a",
"...",
"interface",
"{",
"}",
")",
"{",
"format",
":=",
"\"",
"\"",
"\n\n",
"for",
"range",
"a",
"{",
"format",
"+=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"format",
"=",
"format",
"[",
":",
"len",
"(",
"format",
")",
"-",
"1"... | // Log formats using the default formats for its operands and logs the resulting
// string.
// Spaces are always added between operands and a newline is appended. | [
"Log",
"formats",
"using",
"the",
"default",
"formats",
"for",
"its",
"operands",
"and",
"logs",
"the",
"resulting",
"string",
".",
"Spaces",
"are",
"always",
"added",
"between",
"operands",
"and",
"a",
"newline",
"is",
"appended",
"."
] | a4bd499377b93214614b805d3c2c74e0fea2379d | https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/app.go#L88-L97 | train |
maxence-charriere/app | app.go | Render | func Render(c Compo) {
WhenDebug(func() {
Logf("rendering %T")
})
if err := render(c); err != nil {
Log(err)
}
} | go | func Render(c Compo) {
WhenDebug(func() {
Logf("rendering %T")
})
if err := render(c); err != nil {
Log(err)
}
} | [
"func",
"Render",
"(",
"c",
"Compo",
")",
"{",
"WhenDebug",
"(",
"func",
"(",
")",
"{",
"Logf",
"(",
"\"",
"\"",
")",
"\n",
"}",
")",
"\n\n",
"if",
"err",
":=",
"render",
"(",
"c",
")",
";",
"err",
"!=",
"nil",
"{",
"Log",
"(",
"err",
")",
... | // Render renders the given component.
// It should be called whenever a component is modified.
//
// It panics if called before Run. | [
"Render",
"renders",
"the",
"given",
"component",
".",
"It",
"should",
"be",
"called",
"whenever",
"a",
"component",
"is",
"modified",
".",
"It",
"panics",
"if",
"called",
"before",
"Run",
"."
] | a4bd499377b93214614b805d3c2c74e0fea2379d | https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/app.go#L167-L175 | train |
maxence-charriere/app | mapping.go | Map | func (m *mapping) Map(c Compo) (f func(), err error) {
if m.pipeline, err = pipeline(m.FieldOrMethod); err != nil {
return nil, err
}
return m.mapTo(reflect.ValueOf(c))
} | go | func (m *mapping) Map(c Compo) (f func(), err error) {
if m.pipeline, err = pipeline(m.FieldOrMethod); err != nil {
return nil, err
}
return m.mapTo(reflect.ValueOf(c))
} | [
"func",
"(",
"m",
"*",
"mapping",
")",
"Map",
"(",
"c",
"Compo",
")",
"(",
"f",
"func",
"(",
")",
",",
"err",
"error",
")",
"{",
"if",
"m",
".",
"pipeline",
",",
"err",
"=",
"pipeline",
"(",
"m",
".",
"FieldOrMethod",
")",
";",
"err",
"!=",
"... | // Map performs the mapping to the given component. | [
"Map",
"performs",
"the",
"mapping",
"to",
"the",
"given",
"component",
"."
] | a4bd499377b93214614b805d3c2c74e0fea2379d | https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/mapping.go#L91-L97 | train |
maxence-charriere/app | demo/cmd/demo-wasm/hello.go | OnMenuClick | func (h *Hello) OnMenuClick() {
app.NewContextMenu(
app.MenuItem{
Label: "Reload",
Keys: "cmdorctrl+r",
OnClick: app.Reload},
app.MenuItem{Separator: true},
app.MenuItem{
Label: "Go to repository",
OnClick: func() {
app.Navigate("https://github.com/maxence-charriere/app")
}},
app.Men... | go | func (h *Hello) OnMenuClick() {
app.NewContextMenu(
app.MenuItem{
Label: "Reload",
Keys: "cmdorctrl+r",
OnClick: app.Reload},
app.MenuItem{Separator: true},
app.MenuItem{
Label: "Go to repository",
OnClick: func() {
app.Navigate("https://github.com/maxence-charriere/app")
}},
app.Men... | [
"func",
"(",
"h",
"*",
"Hello",
")",
"OnMenuClick",
"(",
")",
"{",
"app",
".",
"NewContextMenu",
"(",
"app",
".",
"MenuItem",
"{",
"Label",
":",
"\"",
"\"",
",",
"Keys",
":",
"\"",
"\"",
",",
"OnClick",
":",
"app",
".",
"Reload",
"}",
",",
"app",... | // OnMenuClick creates a context menu when the menu button is clicked. | [
"OnMenuClick",
"creates",
"a",
"context",
"menu",
"when",
"the",
"menu",
"button",
"is",
"clicked",
"."
] | a4bd499377b93214614b805d3c2c74e0fea2379d | https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/demo/cmd/demo-wasm/hello.go#L37-L55 | train |
maxence-charriere/app | internal/http/file.go | FileHandler | func FileHandler(webDir string) http.Handler {
return http.FileServer(http.Dir(webDir))
} | go | func FileHandler(webDir string) http.Handler {
return http.FileServer(http.Dir(webDir))
} | [
"func",
"FileHandler",
"(",
"webDir",
"string",
")",
"http",
".",
"Handler",
"{",
"return",
"http",
".",
"FileServer",
"(",
"http",
".",
"Dir",
"(",
"webDir",
")",
")",
"\n",
"}"
] | // FileHandler returns a handler that serves files located in the web directory. | [
"FileHandler",
"returns",
"a",
"handler",
"that",
"serves",
"files",
"located",
"in",
"the",
"web",
"directory",
"."
] | a4bd499377b93214614b805d3c2c74e0fea2379d | https://github.com/maxence-charriere/app/blob/a4bd499377b93214614b805d3c2c74e0fea2379d/internal/http/file.go#L6-L8 | train |
Subsets and Splits
SQL Console for semeru/code-text-go
Retrieves a limited set of code samples with their languages, with a specific case adjustment for 'Go' language.