_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q33200 | Bits | train | func (b *Bitset) Bits() []bool {
result := make([]bool, b.numBits)
var i int
for i = 0; i < b.numBits; i++ {
result[i] = (b.bits[i/8] & (0x80 >> byte(i%8))) != 0
}
return result
} | go | {
"resource": ""
} |
q33201 | At | train | func (b *Bitset) At(index int) bool {
if index >= b.numBits {
log.Panicf("Index %d out of range", index)
}
return (b.bits[index/8] & (0x80 >> byte(index%8))) != 0
} | go | {
"resource": ""
} |
q33202 | Equals | train | func (b *Bitset) Equals(other *Bitset) bool {
if b.numBits != other.numBits {
return false
}
if !bytes.Equal(b.bits[0:b.numBits/8], other.bits[0:b.numBits/8]) {
return false
}
for i := 8 * (b.numBits / 8); i < b.numBits; i++ {
a := (b.bits[i/8] & (0x80 >> byte(i%8)))
b := (other.bits[i/8] & (0x80 >> byte... | go | {
"resource": ""
} |
q33203 | ByteAt | train | func (b *Bitset) ByteAt(index int) byte {
if index < 0 || index >= b.numBits {
log.Panicf("Index %d out of range", index)
}
var result byte
for i := index; i < index+8 && i < b.numBits; i++ {
result <<= 1
if b.At(i) {
result |= 1
}
}
return result
} | go | {
"resource": ""
} |
q33204 | bitmap | train | func (m *symbol) bitmap() [][]bool {
module := make([][]bool, len(m.module))
for i := range m.module {
module[i] = m.module[i][:]
}
return module
} | go | {
"resource": ""
} |
q33205 | string | train | func (m *symbol) string() string {
var result string
for _, row := range m.module {
for _, value := range row {
switch value {
case true:
result += " "
case false:
// Unicode 'FULL BLOCK' (U+2588).
result += "██"
}
}
result += "\n"
}
return result
} | go | {
"resource": ""
} |
q33206 | penaltyScore | train | func (m *symbol) penaltyScore() int {
return m.penalty1() + m.penalty2() + m.penalty3() + m.penalty4()
} | go | {
"resource": ""
} |
q33207 | penalty4 | train | func (m *symbol) penalty4() int {
numModules := m.symbolSize * m.symbolSize
numDarkModules := 0
for x := 0; x < m.symbolSize; x++ {
for y := 0; y < m.symbolSize; y++ {
if v := m.get(x, y); v {
numDarkModules++
}
}
}
numDarkModuleDeviation := numModules/2 - numDarkModules
if numDarkModuleDeviation ... | go | {
"resource": ""
} |
q33208 | gfPolyAdd | train | func gfPolyAdd(a, b gfPoly) gfPoly {
numATerms := a.numTerms()
numBTerms := b.numTerms()
numTerms := numATerms
if numBTerms > numTerms {
numTerms = numBTerms
}
result := gfPoly{term: make([]gfElement, numTerms)}
for i := 0; i < numTerms; i++ {
switch {
case numATerms > i && numBTerms > i:
result.term... | go | {
"resource": ""
} |
q33209 | equals | train | func (e gfPoly) equals(other gfPoly) bool {
var minecPoly *gfPoly
var maxecPoly *gfPoly
if e.numTerms() > other.numTerms() {
minecPoly = &other
maxecPoly = &e
} else {
minecPoly = &e
maxecPoly = &other
}
numMinTerms := minecPoly.numTerms()
numMaxTerms := maxecPoly.numTerms()
for i := 0; i < numMinTer... | go | {
"resource": ""
} |
q33210 | newDataEncoder | train | func newDataEncoder(t dataEncoderType) *dataEncoder {
d := &dataEncoder{}
switch t {
case dataEncoderType1To9:
d = &dataEncoder{
minVersion: 1,
maxVersion: 9,
numericModeIndicator: bitset.New(b0, b0, b0, b1),
alphanumericModeIndicator: bitset.New(b0, b0, ... | go | {
"resource": ""
} |
q33211 | encode | train | func (d *dataEncoder) encode(data []byte) (*bitset.Bitset, error) {
d.data = data
d.actual = nil
d.optimised = nil
if len(data) == 0 {
return nil, errors.New("no data to encode")
}
// Classify data into unoptimised segments.
d.classifyDataModes()
// Optimise segments.
err := d.optimiseDataModes()
if err ... | go | {
"resource": ""
} |
q33212 | encodeDataRaw | train | func (d *dataEncoder) encodeDataRaw(data []byte, dataMode dataMode, encoded *bitset.Bitset) {
modeIndicator := d.modeIndicator(dataMode)
charCountBits := d.charCountBits(dataMode)
// Append mode indicator.
encoded.Append(modeIndicator)
// Append character count.
encoded.AppendUint32(uint32(len(data)), charCount... | go | {
"resource": ""
} |
q33213 | modeIndicator | train | func (d *dataEncoder) modeIndicator(dataMode dataMode) *bitset.Bitset {
switch dataMode {
case dataModeNumeric:
return d.numericModeIndicator
case dataModeAlphanumeric:
return d.alphanumericModeIndicator
case dataModeByte:
return d.byteModeIndicator
default:
log.Panic("Unknown data mode")
}
return nil
} | go | {
"resource": ""
} |
q33214 | charCountBits | train | func (d *dataEncoder) charCountBits(dataMode dataMode) int {
switch dataMode {
case dataModeNumeric:
return d.numNumericCharCountBits
case dataModeAlphanumeric:
return d.numAlphanumericCharCountBits
case dataModeByte:
return d.numByteCharCountBits
default:
log.Panic("Unknown data mode")
}
return 0
} | go | {
"resource": ""
} |
q33215 | formatInfo | train | func (v qrCodeVersion) formatInfo(maskPattern int) *bitset.Bitset {
formatID := 0
switch v.level {
case Low:
formatID = 0x08 // 0b01000
case Medium:
formatID = 0x00 // 0b00000
case High:
formatID = 0x18 // 0b11000
case Highest:
formatID = 0x10 // 0b10000
default:
log.Panicf("Invalid level %d", v.level... | go | {
"resource": ""
} |
q33216 | versionInfo | train | func (v qrCodeVersion) versionInfo() *bitset.Bitset {
if v.version < 7 {
return nil
}
result := bitset.New()
result.AppendUint32(versionBitSequence[v.version], 18)
return result
} | go | {
"resource": ""
} |
q33217 | numDataBits | train | func (v qrCodeVersion) numDataBits() int {
numDataBits := 0
for _, b := range v.block {
numDataBits += 8 * b.numBlocks * b.numDataCodewords // 8 bits in a byte
}
return numDataBits
} | go | {
"resource": ""
} |
q33218 | chooseQRCodeVersion | train | func chooseQRCodeVersion(level RecoveryLevel, encoder *dataEncoder, numDataBits int) *qrCodeVersion {
var chosenVersion *qrCodeVersion
for _, v := range versions {
if v.level != level {
continue
} else if v.version < encoder.minVersion {
continue
} else if v.version > encoder.maxVersion {
break
}
... | go | {
"resource": ""
} |
q33219 | numBlocks | train | func (v qrCodeVersion) numBlocks() int {
numBlocks := 0
for _, b := range v.block {
numBlocks += b.numBlocks
}
return numBlocks
} | go | {
"resource": ""
} |
q33220 | numBitsToPadToCodeword | train | func (v qrCodeVersion) numBitsToPadToCodeword(numDataBits int) int {
if numDataBits == v.numDataBits() {
return 0
}
return (8 - numDataBits%8) % 8
} | go | {
"resource": ""
} |
q33221 | getQRCodeVersion | train | func getQRCodeVersion(level RecoveryLevel, version int) *qrCodeVersion {
for _, v := range versions {
if v.level == level && v.version == version {
return &v
}
}
return nil
} | go | {
"resource": ""
} |
q33222 | Open | train | func Open(path string) (*DB, error) {
db := &DB{}
// initialize trees and indexes
db.keys = btree.New(btreeDegrees, nil)
db.exps = btree.New(btreeDegrees, &exctx{db})
db.idxs = make(map[string]*index)
// initialize default configuration
db.config = Config{
SyncPolicy: EverySecond,
AutoShrinkPercent... | go | {
"resource": ""
} |
q33223 | match | train | func (idx *index) match(key string) bool {
if idx.pattern == "*" {
return true
}
if idx.opts.CaseInsensitiveKeyMatching {
for i := 0; i < len(key); i++ {
if key[i] >= 'A' && key[i] <= 'Z' {
key = strings.ToLower(key)
break
}
}
}
return match.Match(key, idx.pattern)
} | go | {
"resource": ""
} |
q33224 | clearCopy | train | func (idx *index) clearCopy() *index {
// copy the index meta information
nidx := &index{
name: idx.name,
pattern: idx.pattern,
db: idx.db,
less: idx.less,
rect: idx.rect,
opts: idx.opts,
}
// initialize with empty trees
if nidx.less != nil {
nidx.btr = btree.New(btreeDegrees, nidx)
... | go | {
"resource": ""
} |
q33225 | rebuild | train | func (idx *index) rebuild() {
// initialize trees
if idx.less != nil {
idx.btr = btree.New(btreeDegrees, idx)
}
if idx.rect != nil {
idx.rtr = rtree.New(idx)
}
// iterate through all keys and fill the index
idx.db.keys.Ascend(func(item btree.Item) bool {
dbi := item.(*dbItem)
if !idx.match(dbi.key) {
... | go | {
"resource": ""
} |
q33226 | ReadConfig | train | func (db *DB) ReadConfig(config *Config) error {
db.mu.RLock()
defer db.mu.RUnlock()
if db.closed {
return ErrDatabaseClosed
}
*config = db.config
return nil
} | go | {
"resource": ""
} |
q33227 | SetConfig | train | func (db *DB) SetConfig(config Config) error {
db.mu.Lock()
defer db.mu.Unlock()
if db.closed {
return ErrDatabaseClosed
}
switch config.SyncPolicy {
default:
return ErrInvalidSyncPolicy
case Never, EverySecond, Always:
}
db.config = config
return nil
} | go | {
"resource": ""
} |
q33228 | insertIntoDatabase | train | func (db *DB) insertIntoDatabase(item *dbItem) *dbItem {
var pdbi *dbItem
prev := db.keys.ReplaceOrInsert(item)
if prev != nil {
// A previous item was removed from the keys tree. Let's
// fully delete this item from all indexes.
pdbi = prev.(*dbItem)
if pdbi.opts != nil && pdbi.opts.ex {
// Remove it fro... | go | {
"resource": ""
} |
q33229 | managed | train | func (db *DB) managed(writable bool, fn func(tx *Tx) error) (err error) {
var tx *Tx
tx, err = db.Begin(writable)
if err != nil {
return
}
defer func() {
if err != nil {
// The caller returned an error. We must rollback.
_ = tx.Rollback()
return
}
if writable {
// Everything went well. Lets Com... | go | {
"resource": ""
} |
q33230 | get | train | func (db *DB) get(key string) *dbItem {
item := db.keys.Get(&dbItem{key: key})
if item != nil {
return item.(*dbItem)
}
return nil
} | go | {
"resource": ""
} |
q33231 | DeleteAll | train | func (tx *Tx) DeleteAll() error {
if tx.db == nil {
return ErrTxClosed
} else if !tx.writable {
return ErrTxNotWritable
} else if tx.wc.itercount > 0 {
return ErrTxIterating
}
// check to see if we've already deleted everything
if tx.wc.rbkeys == nil {
// we need to backup the live data in case of a roll... | go | {
"resource": ""
} |
q33232 | lock | train | func (tx *Tx) lock() {
if tx.writable {
tx.db.mu.Lock()
} else {
tx.db.mu.RLock()
}
} | go | {
"resource": ""
} |
q33233 | unlock | train | func (tx *Tx) unlock() {
if tx.writable {
tx.db.mu.Unlock()
} else {
tx.db.mu.RUnlock()
}
} | go | {
"resource": ""
} |
q33234 | writeSetTo | train | func (dbi *dbItem) writeSetTo(buf []byte) []byte {
if dbi.opts != nil && dbi.opts.ex {
ex := dbi.opts.exat.Sub(time.Now()) / time.Second
buf = appendArray(buf, 5)
buf = appendBulkString(buf, "set")
buf = appendBulkString(buf, dbi.key)
buf = appendBulkString(buf, dbi.val)
buf = appendBulkString(buf, "ex")
... | go | {
"resource": ""
} |
q33235 | writeDeleteTo | train | func (dbi *dbItem) writeDeleteTo(buf []byte) []byte {
buf = appendArray(buf, 2)
buf = appendBulkString(buf, "del")
buf = appendBulkString(buf, dbi.key)
return buf
} | go | {
"resource": ""
} |
q33236 | expired | train | func (dbi *dbItem) expired() bool {
return dbi.opts != nil && dbi.opts.ex && time.Now().After(dbi.opts.exat)
} | go | {
"resource": ""
} |
q33237 | expiresAt | train | func (dbi *dbItem) expiresAt() time.Time {
if dbi.opts == nil || !dbi.opts.ex {
return maxTime
}
return dbi.opts.exat
} | go | {
"resource": ""
} |
q33238 | Less | train | func (dbi *dbItem) Less(item btree.Item, ctx interface{}) bool {
dbi2 := item.(*dbItem)
switch ctx := ctx.(type) {
case *exctx:
// The expires b-tree formula
if dbi2.expiresAt().After(dbi.expiresAt()) {
return true
}
if dbi.expiresAt().After(dbi2.expiresAt()) {
return false
}
case *index:
if ctx.l... | go | {
"resource": ""
} |
q33239 | Rect | train | func (dbi *dbItem) Rect(ctx interface{}) (min, max []float64) {
switch ctx := ctx.(type) {
case *index:
return ctx.rect(dbi.val)
}
return nil, nil
} | go | {
"resource": ""
} |
q33240 | GetLess | train | func (tx *Tx) GetLess(index string) (func(a, b string) bool, error) {
if tx.db == nil {
return nil, ErrTxClosed
}
idx, ok := tx.db.idxs[index]
if !ok || idx.less == nil {
return nil, ErrNotFound
}
return idx.less, nil
} | go | {
"resource": ""
} |
q33241 | GetRect | train | func (tx *Tx) GetRect(index string) (func(s string) (min, max []float64),
error) {
if tx.db == nil {
return nil, ErrTxClosed
}
idx, ok := tx.db.idxs[index]
if !ok || idx.rect == nil {
return nil, ErrNotFound
}
return idx.rect, nil
} | go | {
"resource": ""
} |
q33242 | Get | train | func (tx *Tx) Get(key string, ignoreExpired ...bool) (val string, err error) {
if tx.db == nil {
return "", ErrTxClosed
}
var ignore bool
if len(ignoreExpired) != 0 {
ignore = ignoreExpired[0]
}
item := tx.db.get(key)
if item == nil || (item.expired() && !ignore) {
// The item does not exists or has expire... | go | {
"resource": ""
} |
q33243 | TTL | train | func (tx *Tx) TTL(key string) (time.Duration, error) {
if tx.db == nil {
return 0, ErrTxClosed
}
item := tx.db.get(key)
if item == nil {
return 0, ErrNotFound
} else if item.opts == nil || !item.opts.ex {
return -1, nil
}
dur := item.opts.exat.Sub(time.Now())
if dur < 0 {
return 0, ErrNotFound
}
retur... | go | {
"resource": ""
} |
q33244 | scan | train | func (tx *Tx) scan(desc, gt, lt bool, index, start, stop string,
iterator func(key, value string) bool) error {
if tx.db == nil {
return ErrTxClosed
}
// wrap a btree specific iterator around the user-defined iterator.
iter := func(item btree.Item) bool {
dbi := item.(*dbItem)
return iterator(dbi.key, dbi.va... | go | {
"resource": ""
} |
q33245 | AscendKeys | train | func (tx *Tx) AscendKeys(pattern string,
iterator func(key, value string) bool) error {
if pattern == "" {
return nil
}
if pattern[0] == '*' {
if pattern == "*" {
return tx.Ascend("", iterator)
}
return tx.Ascend("", func(key, value string) bool {
if match.Match(key, pattern) {
if !iterator(key, v... | go | {
"resource": ""
} |
q33246 | DescendKeys | train | func (tx *Tx) DescendKeys(pattern string,
iterator func(key, value string) bool) error {
if pattern == "" {
return nil
}
if pattern[0] == '*' {
if pattern == "*" {
return tx.Descend("", iterator)
}
return tx.Descend("", func(key, value string) bool {
if match.Match(key, pattern) {
if !iterator(key... | go | {
"resource": ""
} |
q33247 | Len | train | func (tx *Tx) Len() (int, error) {
if tx.db == nil {
return 0, ErrTxClosed
}
return tx.db.keys.Len(), nil
} | go | {
"resource": ""
} |
q33248 | CreateIndexOptions | train | func (tx *Tx) CreateIndexOptions(name, pattern string,
opts *IndexOptions,
less ...func(a, b string) bool) error {
return tx.createIndex(name, pattern, less, nil, opts)
} | go | {
"resource": ""
} |
q33249 | CreateSpatialIndexOptions | train | func (tx *Tx) CreateSpatialIndexOptions(name, pattern string,
opts *IndexOptions,
rect func(item string) (min, max []float64)) error {
return tx.createIndex(name, pattern, nil, rect, nil)
} | go | {
"resource": ""
} |
q33250 | DropIndex | train | func (tx *Tx) DropIndex(name string) error {
if tx.db == nil {
return ErrTxClosed
} else if !tx.writable {
return ErrTxNotWritable
} else if tx.wc.itercount > 0 {
return ErrTxIterating
}
if name == "" {
// cannot drop the default "keys" index
return ErrInvalidOperation
}
idx, ok := tx.db.idxs[name]
if... | go | {
"resource": ""
} |
q33251 | Indexes | train | func (tx *Tx) Indexes() ([]string, error) {
if tx.db == nil {
return nil, ErrTxClosed
}
names := make([]string, 0, len(tx.db.idxs))
for name := range tx.db.idxs {
names = append(names, name)
}
sort.Strings(names)
return names, nil
} | go | {
"resource": ""
} |
q33252 | IndexInt | train | func IndexInt(a, b string) bool {
ia, _ := strconv.ParseInt(a, 10, 64)
ib, _ := strconv.ParseInt(b, 10, 64)
return ia < ib
} | go | {
"resource": ""
} |
q33253 | IndexJSON | train | func IndexJSON(path string) func(a, b string) bool {
return func(a, b string) bool {
return gjson.Get(a, path).Less(gjson.Get(b, path), false)
}
} | go | {
"resource": ""
} |
q33254 | IndexJSONCaseSensitive | train | func IndexJSONCaseSensitive(path string) func(a, b string) bool {
return func(a, b string) bool {
return gjson.Get(a, path).Less(gjson.Get(b, path), true)
}
} | go | {
"resource": ""
} |
q33255 | Desc | train | func Desc(less func(a, b string) bool) func(a, b string) bool {
return func(a, b string) bool { return less(b, a) }
} | go | {
"resource": ""
} |
q33256 | Eq | train | func Eq(field string, v interface{}) Matcher {
return NewFieldMatcher(field, &cmp{value: v, token: token.EQL})
} | go | {
"resource": ""
} |
q33257 | EqF | train | func EqF(field1, field2 string) Matcher {
return NewField2FieldMatcher(field1, field2, token.EQL)
} | go | {
"resource": ""
} |
q33258 | StrictEq | train | func StrictEq(field string, v interface{}) Matcher {
return NewFieldMatcher(field, &strictEq{value: v})
} | go | {
"resource": ""
} |
q33259 | Gt | train | func Gt(field string, v interface{}) Matcher {
return NewFieldMatcher(field, &cmp{value: v, token: token.GTR})
} | go | {
"resource": ""
} |
q33260 | GtF | train | func GtF(field1, field2 string) Matcher {
return NewField2FieldMatcher(field1, field2, token.GTR)
} | go | {
"resource": ""
} |
q33261 | Gte | train | func Gte(field string, v interface{}) Matcher {
return NewFieldMatcher(field, &cmp{value: v, token: token.GEQ})
} | go | {
"resource": ""
} |
q33262 | GteF | train | func GteF(field1, field2 string) Matcher {
return NewField2FieldMatcher(field1, field2, token.GEQ)
} | go | {
"resource": ""
} |
q33263 | Lt | train | func Lt(field string, v interface{}) Matcher {
return NewFieldMatcher(field, &cmp{value: v, token: token.LSS})
} | go | {
"resource": ""
} |
q33264 | LtF | train | func LtF(field1, field2 string) Matcher {
return NewField2FieldMatcher(field1, field2, token.LSS)
} | go | {
"resource": ""
} |
q33265 | Lte | train | func Lte(field string, v interface{}) Matcher {
return NewFieldMatcher(field, &cmp{value: v, token: token.LEQ})
} | go | {
"resource": ""
} |
q33266 | LteF | train | func LteF(field1, field2 string) Matcher {
return NewField2FieldMatcher(field1, field2, token.LEQ)
} | go | {
"resource": ""
} |
q33267 | In | train | func In(field string, v interface{}) Matcher {
return NewFieldMatcher(field, &in{list: v})
} | go | {
"resource": ""
} |
q33268 | PrefixScan | train | func (n *node) PrefixScan(prefix string) []Node {
if n.tx != nil {
return n.prefixScan(n.tx, prefix)
}
var nodes []Node
n.readTx(func(tx *bolt.Tx) error {
nodes = n.prefixScan(tx, prefix)
return nil
})
return nodes
} | go | {
"resource": ""
} |
q33269 | RangeScan | train | func (n *node) RangeScan(min, max string) []Node {
if n.tx != nil {
return n.rangeScan(n.tx, min, max)
}
var nodes []Node
n.readTx(func(tx *bolt.Tx) error {
nodes = n.rangeScan(tx, min, max)
return nil
})
return nodes
} | go | {
"resource": ""
} |
q33270 | CreateBucketIfNotExists | train | func (n *node) CreateBucketIfNotExists(tx *bolt.Tx, bucket string) (*bolt.Bucket, error) {
var b *bolt.Bucket
var err error
bucketNames := append(n.rootBucket, bucket)
for _, bucketName := range bucketNames {
if b != nil {
if b, err = b.CreateBucketIfNotExists([]byte(bucketName)); err != nil {
return nil... | go | {
"resource": ""
} |
q33271 | GetBucket | train | func (n *node) GetBucket(tx *bolt.Tx, children ...string) *bolt.Bucket {
var b *bolt.Bucket
bucketNames := append(n.rootBucket, children...)
for _, bucketName := range bucketNames {
if b != nil {
if b = b.Bucket([]byte(bucketName)); b == nil {
return nil
}
} else {
if b = tx.Bucket([]byte(bucketNam... | go | {
"resource": ""
} |
q33272 | Begin | train | func (n node) Begin(writable bool) (Node, error) {
var err error
n.tx, err = n.s.Bolt.Begin(writable)
if err != nil {
return nil, err
}
return &n, nil
} | go | {
"resource": ""
} |
q33273 | Rollback | train | func (n *node) Rollback() error {
if n.tx == nil {
return ErrNotInTransaction
}
err := n.tx.Rollback()
if err == bolt.ErrTxClosed {
return ErrNotInTransaction
}
return err
} | go | {
"resource": ""
} |
q33274 | NewFieldMatcher | train | func NewFieldMatcher(field string, fm FieldMatcher) Matcher {
return fieldMatcherDelegate{Field: field, FieldMatcher: fm}
} | go | {
"resource": ""
} |
q33275 | NewField2FieldMatcher | train | func NewField2FieldMatcher(field1, field2 string, tok token.Token) Matcher {
return field2fieldMatcherDelegate{Field1: field1, Field2: field2, Tok: tok}
} | go | {
"resource": ""
} |
q33276 | One | train | func (n *node) One(fieldName string, value interface{}, to interface{}) error {
sink, err := newFirstSink(n, to)
if err != nil {
return err
}
bucketName := sink.bucketName()
if bucketName == "" {
return ErrNoName
}
if fieldName == "" {
return ErrNotFound
}
ref := reflect.Indirect(sink.ref)
cfg, err :... | go | {
"resource": ""
} |
q33277 | AllByIndex | train | func (n *node) AllByIndex(fieldName string, to interface{}, options ...func(*index.Options)) error {
if fieldName == "" {
return n.All(to, options...)
}
ref := reflect.ValueOf(to)
if ref.Kind() != reflect.Ptr || ref.Elem().Kind() != reflect.Slice {
return ErrSlicePtrNeeded
}
typ := reflect.Indirect(ref).Ty... | go | {
"resource": ""
} |
q33278 | All | train | func (n *node) All(to interface{}, options ...func(*index.Options)) error {
opts := index.NewOptions()
for _, fn := range options {
fn(opts)
}
query := newQuery(n, nil).Limit(opts.Limit).Skip(opts.Skip)
if opts.Reverse {
query.Reverse()
}
err := query.Find(to)
if err != nil && err != ErrNotFound {
retur... | go | {
"resource": ""
} |
q33279 | Range | train | func (n *node) Range(fieldName string, min, max, to interface{}, options ...func(*index.Options)) error {
sink, err := newListSink(n, to)
if err != nil {
return err
}
bucketName := sink.bucketName()
if bucketName == "" {
return ErrNoName
}
ref := reflect.Indirect(reflect.New(sink.elemType))
cfg, err := ex... | go | {
"resource": ""
} |
q33280 | Prefix | train | func (n *node) Prefix(fieldName string, prefix string, to interface{}, options ...func(*index.Options)) error {
sink, err := newListSink(n, to)
if err != nil {
return err
}
bucketName := sink.bucketName()
if bucketName == "" {
return ErrNoName
}
ref := reflect.Indirect(reflect.New(sink.elemType))
cfg, err... | go | {
"resource": ""
} |
q33281 | Count | train | func (n *node) Count(data interface{}) (int, error) {
return n.Select().Count(data)
} | go | {
"resource": ""
} |
q33282 | Select | train | func (n *node) Select(matchers ...q.Matcher) Query {
tree := q.And(matchers...)
return newQuery(n, tree)
} | go | {
"resource": ""
} |
q33283 | NewListIndex | train | func NewListIndex(parent *bolt.Bucket, indexName []byte) (*ListIndex, error) {
var err error
b := parent.Bucket(indexName)
if b == nil {
if !parent.Writable() {
return nil, ErrNotFound
}
b, err = parent.CreateBucket(indexName)
if err != nil {
return nil, err
}
}
ids, err := NewUniqueIndex(b, []byt... | go | {
"resource": ""
} |
q33284 | Add | train | func (idx *ListIndex) Add(newValue []byte, targetID []byte) error {
if newValue == nil || len(newValue) == 0 {
return ErrNilParam
}
if targetID == nil || len(targetID) == 0 {
return ErrNilParam
}
key := idx.IDs.Get(targetID)
if key != nil {
err := idx.IndexBucket.Delete(key)
if err != nil {
return err... | go | {
"resource": ""
} |
q33285 | RemoveID | train | func (idx *ListIndex) RemoveID(targetID []byte) error {
value := idx.IDs.Get(targetID)
if value == nil {
return nil
}
err := idx.IndexBucket.Delete(value)
if err != nil {
return err
}
return idx.IDs.Remove(targetID)
} | go | {
"resource": ""
} |
q33286 | Get | train | func (idx *ListIndex) Get(value []byte) []byte {
c := idx.IndexBucket.Cursor()
prefix := generatePrefix(value)
for k, id := c.Seek(prefix); bytes.HasPrefix(k, prefix); k, id = c.Next() {
return id
}
return nil
} | go | {
"resource": ""
} |
q33287 | All | train | func (idx *ListIndex) All(value []byte, opts *Options) ([][]byte, error) {
var list [][]byte
c := idx.IndexBucket.Cursor()
cur := internal.Cursor{C: c, Reverse: opts != nil && opts.Reverse}
prefix := generatePrefix(value)
k, id := c.Seek(prefix)
if cur.Reverse {
var count int
kc := k
idc := id
for ; kc ... | go | {
"resource": ""
} |
q33288 | From | train | func (n node) From(addend ...string) Node {
n.rootBucket = append(n.rootBucket, addend...)
return &n
} | go | {
"resource": ""
} |
q33289 | WithTransaction | train | func (n node) WithTransaction(tx *bolt.Tx) Node {
n.tx = tx
return &n
} | go | {
"resource": ""
} |
q33290 | WithCodec | train | func (n node) WithCodec(codec codec.MarshalUnmarshaler) Node {
n.codec = codec
return &n
} | go | {
"resource": ""
} |
q33291 | WithBatch | train | func (n node) WithBatch(enabled bool) Node {
n.batchMode = enabled
return &n
} | go | {
"resource": ""
} |
q33292 | readWriteTx | train | func (n *node) readWriteTx(fn func(tx *bolt.Tx) error) error {
if n.tx != nil {
return fn(n.tx)
}
if n.batchMode {
return n.s.Bolt.Batch(func(tx *bolt.Tx) error {
return fn(tx)
})
}
return n.s.Bolt.Update(func(tx *bolt.Tx) error {
return fn(tx)
})
} | go | {
"resource": ""
} |
q33293 | readTx | train | func (n *node) readTx(fn func(tx *bolt.Tx) error) error {
if n.tx != nil {
return fn(n.tx)
}
return n.s.Bolt.View(func(tx *bolt.Tx) error {
return fn(tx)
})
} | go | {
"resource": ""
} |
q33294 | NewUniqueIndex | train | func NewUniqueIndex(parent *bolt.Bucket, indexName []byte) (*UniqueIndex, error) {
var err error
b := parent.Bucket(indexName)
if b == nil {
if !parent.Writable() {
return nil, ErrNotFound
}
b, err = parent.CreateBucket(indexName)
if err != nil {
return nil, err
}
}
return &UniqueIndex{
IndexBuc... | go | {
"resource": ""
} |
q33295 | Add | train | func (idx *UniqueIndex) Add(value []byte, targetID []byte) error {
if value == nil || len(value) == 0 {
return ErrNilParam
}
if targetID == nil || len(targetID) == 0 {
return ErrNilParam
}
exists := idx.IndexBucket.Get(value)
if exists != nil {
if bytes.Equal(exists, targetID) {
return nil
}
return ... | go | {
"resource": ""
} |
q33296 | RemoveID | train | func (idx *UniqueIndex) RemoveID(id []byte) error {
c := idx.IndexBucket.Cursor()
for val, ident := c.First(); val != nil; val, ident = c.Next() {
if bytes.Equal(ident, id) {
return idx.Remove(val)
}
}
return nil
} | go | {
"resource": ""
} |
q33297 | Get | train | func (idx *UniqueIndex) Get(value []byte) []byte {
return idx.IndexBucket.Get(value)
} | go | {
"resource": ""
} |
q33298 | All | train | func (idx *UniqueIndex) All(value []byte, opts *Options) ([][]byte, error) {
id := idx.IndexBucket.Get(value)
if id != nil {
return [][]byte{id}, nil
}
return nil, nil
} | go | {
"resource": ""
} |
q33299 | first | train | func (idx *UniqueIndex) first() []byte {
c := idx.IndexBucket.Cursor()
for val, ident := c.First(); val != nil; val, ident = c.Next() {
return ident
}
return nil
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.