_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q34000 | saveAvailableShards | train | func (f *Field) saveAvailableShards() error {
f.mu.Lock()
defer f.mu.Unlock()
return f.unprotectedSaveAvailableShards()
} | go | {
"resource": ""
} |
q34001 | Type | train | func (f *Field) Type() string {
f.mu.RLock()
defer f.mu.RUnlock()
return f.options.Type
} | go | {
"resource": ""
} |
q34002 | SetCacheSize | train | func (f *Field) SetCacheSize(v uint32) error {
f.mu.Lock()
defer f.mu.Unlock()
// Ignore if no change occurred.
if v == 0 || f.options.CacheSize == v {
return nil
}
// Persist meta data to disk on change.
f.options.CacheSize = v
if err := f.saveMeta(); err != nil {
return errors.Wrap(err, "saving")
}
r... | go | {
"resource": ""
} |
q34003 | CacheSize | train | func (f *Field) CacheSize() uint32 {
f.mu.RLock()
v := f.options.CacheSize
f.mu.RUnlock()
return v
} | go | {
"resource": ""
} |
q34004 | Options | train | func (f *Field) Options() FieldOptions {
f.mu.RLock()
defer f.mu.RUnlock()
return f.options
} | go | {
"resource": ""
} |
q34005 | Open | train | func (f *Field) Open() error {
if err := func() error {
// Ensure the field's path exists.
f.logger.Debugf("ensure field path exists: %s", f.path)
if err := os.MkdirAll(f.path, 0777); err != nil {
return errors.Wrap(err, "creating field dir")
}
f.logger.Debugf("load meta file for index/field: %s/%s", f.i... | go | {
"resource": ""
} |
q34006 | openViews | train | func (f *Field) openViews() error {
file, err := os.Open(filepath.Join(f.path, "views"))
if os.IsNotExist(err) {
return nil
} else if err != nil {
return errors.Wrap(err, "opening view directory")
}
defer file.Close()
fis, err := file.Readdir(0)
if err != nil {
return errors.Wrap(err, "reading directory")... | go | {
"resource": ""
} |
q34007 | loadMeta | train | func (f *Field) loadMeta() error {
var pb internal.FieldOptions
// Read data from meta file.
buf, err := ioutil.ReadFile(filepath.Join(f.path, ".meta"))
if os.IsNotExist(err) {
return nil
} else if err != nil {
return errors.Wrap(err, "reading meta")
} else {
if err := proto.Unmarshal(buf, &pb); err != nil... | go | {
"resource": ""
} |
q34008 | saveMeta | train | func (f *Field) saveMeta() error {
// Marshal metadata.
fo := f.options
buf, err := proto.Marshal(fo.encode())
if err != nil {
return errors.Wrap(err, "marshaling")
}
// Write to meta file.
if err := ioutil.WriteFile(filepath.Join(f.path, ".meta"), buf, 0666); err != nil {
return errors.Wrap(err, "writing m... | go | {
"resource": ""
} |
q34009 | applyOptions | train | func (f *Field) applyOptions(opt FieldOptions) error {
switch opt.Type {
case FieldTypeSet, FieldTypeMutex, "":
fldType := opt.Type
if fldType == "" {
fldType = FieldTypeSet
}
f.options.Type = fldType
if opt.CacheType != "" {
f.options.CacheType = opt.CacheType
}
if opt.CacheSize != 0 {
if opt.... | go | {
"resource": ""
} |
q34010 | Close | train | func (f *Field) Close() error {
f.mu.Lock()
defer f.mu.Unlock()
// Close the attribute store.
if f.rowAttrStore != nil {
_ = f.rowAttrStore.Close()
}
// Close all views.
for _, view := range f.viewMap {
if err := view.close(); err != nil {
return err
}
}
f.viewMap = make(map[string]*view)
return n... | go | {
"resource": ""
} |
q34011 | keys | train | func (f *Field) keys() bool {
f.mu.RLock()
defer f.mu.RUnlock()
return f.options.Keys
} | go | {
"resource": ""
} |
q34012 | bsiGroup | train | func (f *Field) bsiGroup(name string) *bsiGroup {
f.mu.RLock()
defer f.mu.RUnlock()
for _, bsig := range f.bsiGroups {
if bsig.Name == name {
return bsig
}
}
return nil
} | go | {
"resource": ""
} |
q34013 | hasBSIGroup | train | func (f *Field) hasBSIGroup(name string) bool {
for _, bsig := range f.bsiGroups {
if bsig.Name == name {
return true
}
}
return false
} | go | {
"resource": ""
} |
q34014 | createBSIGroup | train | func (f *Field) createBSIGroup(bsig *bsiGroup) error {
f.mu.Lock()
defer f.mu.Unlock()
// Append bsiGroup.
if err := f.addBSIGroup(bsig); err != nil {
return err
}
if err := f.saveMeta(); err != nil {
return errors.Wrap(err, "saving")
}
return nil
} | go | {
"resource": ""
} |
q34015 | addBSIGroup | train | func (f *Field) addBSIGroup(bsig *bsiGroup) error {
if err := bsig.validate(); err != nil {
return errors.Wrap(err, "validating bsigroup")
} else if f.hasBSIGroup(bsig.Name) {
return ErrBSIGroupExists
}
// Add bsiGroup to list.
f.bsiGroups = append(f.bsiGroups, bsig)
// Sort bsiGroups by name.
sort.Slice(f... | go | {
"resource": ""
} |
q34016 | TimeQuantum | train | func (f *Field) TimeQuantum() TimeQuantum {
f.mu.Lock()
defer f.mu.Unlock()
return f.options.TimeQuantum
} | go | {
"resource": ""
} |
q34017 | setTimeQuantum | train | func (f *Field) setTimeQuantum(q TimeQuantum) error {
f.mu.Lock()
defer f.mu.Unlock()
// Validate input.
if !q.Valid() {
return ErrInvalidTimeQuantum
}
// Update value on field.
f.options.TimeQuantum = q
// Persist meta data to disk.
if err := f.saveMeta(); err != nil {
return errors.Wrap(err, "saving m... | go | {
"resource": ""
} |
q34018 | RowTime | train | func (f *Field) RowTime(rowID uint64, time time.Time, quantum string) (*Row, error) {
if !TimeQuantum(quantum).Valid() {
return nil, ErrInvalidTimeQuantum
}
viewname := viewsByTime(viewStandard, time, TimeQuantum(quantum[len(quantum)-1:]))[0]
view := f.view(viewname)
if view == nil {
return nil, errors.Errorf(... | go | {
"resource": ""
} |
q34019 | viewPath | train | func (f *Field) viewPath(name string) string {
return filepath.Join(f.path, "views", name)
} | go | {
"resource": ""
} |
q34020 | view | train | func (f *Field) view(name string) *view {
f.mu.RLock()
defer f.mu.RUnlock()
return f.unprotectedView(name)
} | go | {
"resource": ""
} |
q34021 | views | train | func (f *Field) views() []*view {
f.mu.RLock()
defer f.mu.RUnlock()
other := make([]*view, 0, len(f.viewMap))
for _, view := range f.viewMap {
other = append(other, view)
}
return other
} | go | {
"resource": ""
} |
q34022 | createViewIfNotExists | train | func (f *Field) createViewIfNotExists(name string) (*view, error) {
view, created, err := f.createViewIfNotExistsBase(name)
if err != nil {
return nil, err
}
if created {
// Broadcast view creation to the cluster.
err = f.broadcaster.SendSync(
&CreateViewMessage{
Index: f.index,
Field: f.name,
... | go | {
"resource": ""
} |
q34023 | createViewIfNotExistsBase | train | func (f *Field) createViewIfNotExistsBase(name string) (*view, bool, error) {
f.mu.Lock()
defer f.mu.Unlock()
if view := f.viewMap[name]; view != nil {
return view, false, nil
}
view := f.newView(f.viewPath(name), name)
if err := view.open(); err != nil {
return nil, false, errors.Wrap(err, "opening view")
... | go | {
"resource": ""
} |
q34024 | deleteView | train | func (f *Field) deleteView(name string) error {
view := f.viewMap[name]
if view == nil {
return ErrInvalidView
}
// Close data files before deletion.
if err := view.close(); err != nil {
return errors.Wrap(err, "closing view")
}
// Delete view directory.
if err := os.RemoveAll(view.path); err != nil {
r... | go | {
"resource": ""
} |
q34025 | Row | train | func (f *Field) Row(rowID uint64) (*Row, error) {
if f.Type() != FieldTypeSet {
return nil, errors.Errorf("row method unsupported for field type: %s", f.Type())
}
view := f.view(viewStandard)
if view == nil {
return nil, ErrInvalidView
}
return view.row(rowID), nil
} | go | {
"resource": ""
} |
q34026 | SetBit | train | func (f *Field) SetBit(rowID, colID uint64, t *time.Time) (changed bool, err error) {
viewName := viewStandard
if !f.options.NoStandardView {
// Retrieve view. Exit if it doesn't exist.
view, err := f.createViewIfNotExists(viewName)
if err != nil {
return changed, errors.Wrap(err, "creating view")
}
// ... | go | {
"resource": ""
} |
q34027 | ClearBit | train | func (f *Field) ClearBit(rowID, colID uint64) (changed bool, err error) {
viewName := viewStandard
// Retrieve view. Exit if it doesn't exist.
view, present := f.viewMap[viewName]
if !present {
return changed, errors.Wrap(err, "clearing missing view")
}
// Clear non-time bit.
if v, err := view.clearBit(rowI... | go | {
"resource": ""
} |
q34028 | Value | train | func (f *Field) Value(columnID uint64) (value int64, exists bool, err error) {
bsig := f.bsiGroup(f.name)
if bsig == nil {
return 0, false, ErrBSIGroupNotFound
}
// Fetch target view.
view := f.view(viewBSIGroupPrefix + f.name)
if view == nil {
return 0, false, nil
}
v, exists, err := view.value(columnID,... | go | {
"resource": ""
} |
q34029 | SetValue | train | func (f *Field) SetValue(columnID uint64, value int64) (changed bool, err error) {
// Fetch bsiGroup and validate value.
bsig := f.bsiGroup(f.name)
if bsig == nil {
return false, ErrBSIGroupNotFound
} else if value < bsig.Min {
return false, ErrBSIGroupValueTooLow
} else if value > bsig.Max {
return false, E... | go | {
"resource": ""
} |
q34030 | Sum | train | func (f *Field) Sum(filter *Row, name string) (sum, count int64, err error) {
bsig := f.bsiGroup(name)
if bsig == nil {
return 0, 0, ErrBSIGroupNotFound
}
view := f.view(viewBSIGroupPrefix + name)
if view == nil {
return 0, 0, nil
}
vsum, vcount, err := view.sum(filter, bsig.BitDepth())
if err != nil {
... | go | {
"resource": ""
} |
q34031 | Min | train | func (f *Field) Min(filter *Row, name string) (min, count int64, err error) {
bsig := f.bsiGroup(name)
if bsig == nil {
return 0, 0, ErrBSIGroupNotFound
}
view := f.view(viewBSIGroupPrefix + name)
if view == nil {
return 0, 0, nil
}
vmin, vcount, err := view.min(filter, bsig.BitDepth())
if err != nil {
... | go | {
"resource": ""
} |
q34032 | Max | train | func (f *Field) Max(filter *Row, name string) (max, count int64, err error) {
bsig := f.bsiGroup(name)
if bsig == nil {
return 0, 0, ErrBSIGroupNotFound
}
view := f.view(viewBSIGroupPrefix + name)
if view == nil {
return 0, 0, nil
}
vmax, vcount, err := view.max(filter, bsig.BitDepth())
if err != nil {
... | go | {
"resource": ""
} |
q34033 | Range | train | func (f *Field) Range(name string, op pql.Token, predicate int64) (*Row, error) {
// Retrieve and validate bsiGroup.
bsig := f.bsiGroup(name)
if bsig == nil {
return nil, ErrBSIGroupNotFound
} else if predicate < bsig.Min || predicate > bsig.Max {
return nil, nil
}
// Retrieve bsiGroup's view.
view := f.vie... | go | {
"resource": ""
} |
q34034 | Import | train | func (f *Field) Import(rowIDs, columnIDs []uint64, timestamps []*time.Time, opts ...ImportOption) error {
// Set up import options.
options := &ImportOptions{}
for _, opt := range opts {
err := opt(options)
if err != nil {
return errors.Wrap(err, "applying option")
}
}
// Determine quantum if timestamps... | go | {
"resource": ""
} |
q34035 | importValue | train | func (f *Field) importValue(columnIDs []uint64, values []int64, options *ImportOptions) error {
viewName := viewBSIGroupPrefix + f.name
// Get the bsiGroup so we know bitDepth.
bsig := f.bsiGroup(f.name)
if bsig == nil {
return errors.Wrap(ErrBSIGroupNotFound, f.name)
}
// Split import data by fragment.
dataB... | go | {
"resource": ""
} |
q34036 | applyDefaultOptions | train | func applyDefaultOptions(o FieldOptions) FieldOptions {
if o.Type == "" {
return FieldOptions{
Type: DefaultFieldType,
CacheType: DefaultCacheType,
CacheSize: DefaultCacheSize,
}
}
return o
} | go | {
"resource": ""
} |
q34037 | MarshalJSON | train | func (o *FieldOptions) MarshalJSON() ([]byte, error) {
switch o.Type {
case FieldTypeSet:
return json.Marshal(struct {
Type string `json:"type"`
CacheType string `json:"cacheType"`
CacheSize uint32 `json:"cacheSize"`
Keys bool `json:"keys"`
}{
o.Type,
o.CacheType,
o.CacheSize,
... | go | {
"resource": ""
} |
q34038 | BitDepth | train | func (b *bsiGroup) BitDepth() uint {
for i := uint(0); i < 63; i++ {
if b.Max-b.Min < (1 << i) {
return i
}
}
return 63
} | go | {
"resource": ""
} |
q34039 | isValidCacheType | train | func isValidCacheType(v string) bool {
switch v {
case CacheTypeLRU, CacheTypeRanked, CacheTypeNone:
return true
default:
return false
}
} | go | {
"resource": ""
} |
q34040 | Uptime | train | func (s *systemInfo) Uptime() (uptime uint64, err error) {
hostInfo, err := host.Info()
if err != nil {
return 0, err
}
return hostInfo.Uptime, nil
} | go | {
"resource": ""
} |
q34041 | collectPlatformInfo | train | func (s *systemInfo) collectPlatformInfo() error {
var err error
if s.platform == "" {
s.platform, s.family, s.osVersion, err = host.PlatformInformation()
if err != nil {
return err
}
}
if s.cpuModel == "" {
infos, err := cpu.Info()
if err != nil || len(infos) == 0 {
s.cpuModel = "unknown"
// if ... | go | {
"resource": ""
} |
q34042 | Platform | train | func (s *systemInfo) Platform() (string, error) {
err := s.collectPlatformInfo()
if err != nil {
return "", err
}
return s.platform, nil
} | go | {
"resource": ""
} |
q34043 | Family | train | func (s *systemInfo) Family() (string, error) {
err := s.collectPlatformInfo()
if err != nil {
return "", err
}
return s.family, err
} | go | {
"resource": ""
} |
q34044 | OSVersion | train | func (s *systemInfo) OSVersion() (string, error) {
err := s.collectPlatformInfo()
if err != nil {
return "", err
}
return s.osVersion, err
} | go | {
"resource": ""
} |
q34045 | MemFree | train | func (s *systemInfo) MemFree() (uint64, error) {
memInfo, err := mem.VirtualMemory()
if err != nil {
return 0, err
}
return memInfo.Free, err
} | go | {
"resource": ""
} |
q34046 | MemTotal | train | func (s *systemInfo) MemTotal() (uint64, error) {
memInfo, err := mem.VirtualMemory()
if err != nil {
return 0, err
}
return memInfo.Total, err
} | go | {
"resource": ""
} |
q34047 | MemUsed | train | func (s *systemInfo) MemUsed() (uint64, error) {
memInfo, err := mem.VirtualMemory()
if err != nil {
return 0, err
}
return memInfo.Used, err
} | go | {
"resource": ""
} |
q34048 | CPUModel | train | func (s *systemInfo) CPUModel() string {
err := s.collectPlatformInfo()
if err != nil {
return "unknown"
}
return s.cpuModel
} | go | {
"resource": ""
} |
q34049 | CPUMHz | train | func (s *systemInfo) CPUMHz() (int, error) {
err := s.collectPlatformInfo()
if err != nil {
return 0, err
}
return s.cpuMHz, nil
} | go | {
"resource": ""
} |
q34050 | Next | train | func (itr *bufIterator) Next() (rowID, columnID uint64, eof bool) {
if itr.buf.full {
itr.buf.full = false
return itr.buf.rowID, itr.buf.columnID, itr.buf.eof
}
// Read values onto buffer in case of unread.
itr.buf.rowID, itr.buf.columnID, itr.buf.eof = itr.itr.Next()
return itr.buf.rowID, itr.buf.columnID, ... | go | {
"resource": ""
} |
q34051 | Peek | train | func (itr *bufIterator) Peek() (rowID, columnID uint64, eof bool) {
rowID, columnID, eof = itr.Next()
itr.Unread()
return
} | go | {
"resource": ""
} |
q34052 | Unread | train | func (itr *bufIterator) Unread() {
if itr.buf.full {
panic("pilosa.BufIterator: buffer full")
}
itr.buf.full = true
} | go | {
"resource": ""
} |
q34053 | newLimitIterator | train | func newLimitIterator(itr iterator, maxRowID, maxColumnID uint64) *limitIterator { // nolint: unparam
return &limitIterator{
itr: itr,
maxRowID: maxRowID,
maxColumnID: maxColumnID,
}
} | go | {
"resource": ""
} |
q34054 | Seek | train | func (itr *sliceIterator) Seek(bseek, pseek uint64) {
for i := 0; i < itr.n; i++ {
rowID := itr.rowIDs[i]
columnID := itr.columnIDs[i]
if (bseek == rowID && pseek <= columnID) || bseek < rowID {
itr.i = i
return
}
}
// Seek to the end of the slice if all values are less than seek pair.
itr.i = itr.n... | go | {
"resource": ""
} |
q34055 | Marshal | train | func (Serializer) Marshal(m pilosa.Message) ([]byte, error) {
pm := encodeToProto(m)
if pm == nil {
return nil, errors.New("passed invalid pilosa.Message")
}
buf, err := proto.Marshal(pm)
return buf, errors.Wrap(err, "marshalling")
} | go | {
"resource": ""
} |
q34056 | encodeNodes | train | func encodeNodes(a []*pilosa.Node) []*internal.Node {
other := make([]*internal.Node, len(a))
for i := range a {
other[i] = encodeNode(a[i])
}
return other
} | go | {
"resource": ""
} |
q34057 | encodeNode | train | func encodeNode(n *pilosa.Node) *internal.Node {
return &internal.Node{
ID: n.ID,
URI: encodeURI(n.URI),
IsCoordinator: n.IsCoordinator,
State: n.State,
}
} | go | {
"resource": ""
} |
q34058 | decodeRow | train | func decodeRow(pr *internal.Row) *pilosa.Row {
if pr == nil {
return nil
}
r := pilosa.NewRow()
r.Attrs = decodeAttrs(pr.Attrs)
r.Keys = pr.Keys
for _, v := range pr.Columns {
r.SetBit(v)
}
return r
} | go | {
"resource": ""
} |
q34059 | NewRow | train | func NewRow(columns ...uint64) *Row {
r := &Row{}
for _, i := range columns {
r.SetBit(i)
}
return r
} | go | {
"resource": ""
} |
q34060 | IsEmpty | train | func (r *Row) IsEmpty() bool {
if len(r.segments) == 0 {
return true
}
for i := range r.segments {
if r.segments[i].n > 0 {
return false
}
}
return true
} | go | {
"resource": ""
} |
q34061 | Merge | train | func (r *Row) Merge(other *Row) {
var segments []rowSegment
itr := newMergeSegmentIterator(r.segments, other.segments)
for s0, s1 := itr.next(); s0 != nil || s1 != nil; s0, s1 = itr.next() {
// Use the other row's data if segment is missing.
if s0 == nil {
segments = append(segments, *s1)
continue
} els... | go | {
"resource": ""
} |
q34062 | intersectionCount | train | func (r *Row) intersectionCount(other *Row) uint64 {
var n uint64
itr := newMergeSegmentIterator(r.segments, other.segments)
for s0, s1 := itr.next(); s0 != nil || s1 != nil; s0, s1 = itr.next() {
// Ignore non-overlapping segments.
if s0 == nil || s1 == nil {
continue
}
n += s0.IntersectionCount(s1)
}... | go | {
"resource": ""
} |
q34063 | Shift | train | func (r *Row) Shift(n int64) (*Row, error) {
if n < 0 {
return nil, errors.New("cannot shift by negative values")
} else if n == 0 {
return r, nil
}
work := r
var segments []rowSegment
for i := int64(0); i < n; i++ {
segments = segments[:0]
for _, segment := range work.segments {
shifted, err := segme... | go | {
"resource": ""
} |
q34064 | clearBit | train | func (r *Row) clearBit(i uint64) (changed bool) { // nolint: unparam
s := r.segment(i / ShardWidth)
if s == nil {
return false
}
return s.ClearBit(i)
} | go | {
"resource": ""
} |
q34065 | segment | train | func (r *Row) segment(shard uint64) *rowSegment {
if i := sort.Search(len(r.segments), func(i int) bool {
return r.segments[i].shard >= shard
}); i < len(r.segments) && r.segments[i].shard == shard {
return &r.segments[i]
}
return nil
} | go | {
"resource": ""
} |
q34066 | invalidateCount | train | func (r *Row) invalidateCount() {
for i := range r.segments {
r.segments[i].InvalidateCount()
}
} | go | {
"resource": ""
} |
q34067 | Count | train | func (r *Row) Count() uint64 {
var n uint64
for i := range r.segments {
n += r.segments[i].Count()
}
return n
} | go | {
"resource": ""
} |
q34068 | MarshalJSON | train | func (r *Row) MarshalJSON() ([]byte, error) {
var o struct {
Attrs map[string]interface{} `json:"attrs"`
Columns []uint64 `json:"columns"`
Keys []string `json:"keys,omitempty"`
}
o.Columns = r.Columns()
o.Keys = r.Keys
o.Attrs = r.Attrs
if o.Attrs == nil {
o.Attrs = make(... | go | {
"resource": ""
} |
q34069 | Columns | train | func (r *Row) Columns() []uint64 {
a := make([]uint64, 0, r.Count())
for i := range r.segments {
a = append(a, r.segments[i].Columns()...)
}
return a
} | go | {
"resource": ""
} |
q34070 | Merge | train | func (s *rowSegment) Merge(other *rowSegment) {
s.ensureWritable()
itr := other.data.Iterator()
for v, eof := itr.Next(); !eof; v, eof = itr.Next() {
s.SetBit(v)
}
} | go | {
"resource": ""
} |
q34071 | IntersectionCount | train | func (s *rowSegment) IntersectionCount(other *rowSegment) uint64 {
return s.data.IntersectionCount(&other.data)
} | go | {
"resource": ""
} |
q34072 | Intersect | train | func (s *rowSegment) Intersect(other *rowSegment) *rowSegment {
data := s.data.Intersect(&other.data)
return &rowSegment{
data: *data,
shard: s.shard,
n: data.Count(),
}
} | go | {
"resource": ""
} |
q34073 | Union | train | func (s *rowSegment) Union(other *rowSegment) *rowSegment {
data := s.data.Union(&other.data)
return &rowSegment{
data: *data,
shard: s.shard,
n: data.Count(),
}
} | go | {
"resource": ""
} |
q34074 | Difference | train | func (s *rowSegment) Difference(other *rowSegment) *rowSegment {
data := s.data.Difference(&other.data)
return &rowSegment{
data: *data,
shard: s.shard,
n: data.Count(),
}
} | go | {
"resource": ""
} |
q34075 | Xor | train | func (s *rowSegment) Xor(other *rowSegment) *rowSegment {
data := s.data.Xor(&other.data)
return &rowSegment{
data: *data,
shard: s.shard,
n: data.Count(),
}
} | go | {
"resource": ""
} |
q34076 | Shift | train | func (s *rowSegment) Shift() (*rowSegment, error) {
//TODO deal with overflow
data, err := s.data.Shift(1)
if err != nil {
return nil, errors.Wrap(err, "shifting roaring data")
}
return &rowSegment{
data: *data,
shard: s.shard,
n: data.Count(),
}, nil
} | go | {
"resource": ""
} |
q34077 | ClearBit | train | func (s *rowSegment) ClearBit(i uint64) (changed bool) {
s.ensureWritable()
changed, _ = s.data.Remove(i)
if changed {
s.n--
}
return changed
} | go | {
"resource": ""
} |
q34078 | Columns | train | func (s *rowSegment) Columns() []uint64 {
a := make([]uint64, 0, s.Count())
itr := s.data.Iterator()
for v, eof := itr.Next(); !eof; v, eof = itr.Next() {
a = append(a, v)
}
return a
} | go | {
"resource": ""
} |
q34079 | ensureWritable | train | func (s *rowSegment) ensureWritable() {
if s.writable {
return
}
s.data = *s.data.Clone()
s.writable = true
} | go | {
"resource": ""
} |
q34080 | newMergeSegmentIterator | train | func newMergeSegmentIterator(a0, a1 []rowSegment) mergeSegmentIterator {
return mergeSegmentIterator{a0: a0, a1: a1}
} | go | {
"resource": ""
} |
q34081 | next | train | func (itr *mergeSegmentIterator) next() (s0, s1 *rowSegment) {
// Find current segments.
if len(itr.a0) > 0 {
s0 = &itr.a0[0]
}
if len(itr.a1) > 0 {
s1 = &itr.a1[0]
}
// Return if either or both are nil.
if s0 == nil && s1 == nil {
return
} else if s0 == nil {
itr.a1 = itr.a1[1:]
return
} else if s1... | go | {
"resource": ""
} |
q34082 | Encode | train | func (enc *Encoder) Encode(pb proto.Message) error {
buf, err := proto.Marshal(pb)
if err != nil {
return err
}
if _, err := enc.w.Write(buf); err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q34083 | Decode | train | func (dec *Decoder) Decode(pb proto.Message) error {
buf, err := ioutil.ReadAll(dec.r)
if err != nil {
return err
}
return proto.Unmarshal(buf, pb)
} | go | {
"resource": ""
} |
q34084 | MarshalJSON | train | func (t *ButtonsTemplate) MarshalJSON() ([]byte, error) {
return json.Marshal(&struct {
Type TemplateType `json:"type"`
ThumbnailImageURL string `json:"thumbnailImageUrl,omitempty"`
ImageAspectRatio ImageAspectRatioType `json:"imageAspectRatio,omitempty"`
ImageSize ... | go | {
"resource": ""
} |
q34085 | WithImageOptions | train | func (t *ButtonsTemplate) WithImageOptions(imageAspectRatio ImageAspectRatioType, imageSize ImageSizeType, imageBackgroundColor string) *ButtonsTemplate {
t.ImageAspectRatio = imageAspectRatio
t.ImageSize = imageSize
t.ImageBackgroundColor = imageBackgroundColor
return t
} | go | {
"resource": ""
} |
q34086 | MarshalJSON | train | func (t *ConfirmTemplate) MarshalJSON() ([]byte, error) {
return json.Marshal(&struct {
Type TemplateType `json:"type"`
Text string `json:"text"`
Actions []TemplateAction `json:"actions"`
}{
Type: TemplateTypeConfirm,
Text: t.Text,
Actions: t.Actions,
})
} | go | {
"resource": ""
} |
q34087 | MarshalJSON | train | func (t *CarouselTemplate) MarshalJSON() ([]byte, error) {
return json.Marshal(&struct {
Type TemplateType `json:"type"`
Columns []*CarouselColumn `json:"columns"`
ImageAspectRatio ImageAspectRatioType `json:"imageAspectRatio,omitempty"`
ImageSize ImageSizeType `js... | go | {
"resource": ""
} |
q34088 | WithImageOptions | train | func (t *CarouselTemplate) WithImageOptions(imageAspectRatio ImageAspectRatioType, imageSize ImageSizeType) *CarouselTemplate {
t.ImageAspectRatio = imageAspectRatio
t.ImageSize = imageSize
return t
} | go | {
"resource": ""
} |
q34089 | WithImageOptions | train | func (t *CarouselColumn) WithImageOptions(imageBackgroundColor string) *CarouselColumn {
t.ImageBackgroundColor = imageBackgroundColor
return t
} | go | {
"resource": ""
} |
q34090 | MarshalJSON | train | func (t *ImageCarouselTemplate) MarshalJSON() ([]byte, error) {
return json.Marshal(&struct {
Type TemplateType `json:"type"`
Columns []*ImageCarouselColumn `json:"columns"`
}{
Type: TemplateTypeImageCarousel,
Columns: t.Columns,
})
} | go | {
"resource": ""
} |
q34091 | NewButtonsTemplate | train | func NewButtonsTemplate(thumbnailImageURL, title, text string, actions ...TemplateAction) *ButtonsTemplate {
return &ButtonsTemplate{
ThumbnailImageURL: thumbnailImageURL,
Title: title,
Text: text,
Actions: actions,
}
} | go | {
"resource": ""
} |
q34092 | NewCarouselColumn | train | func NewCarouselColumn(thumbnailImageURL, title, text string, actions ...TemplateAction) *CarouselColumn {
return &CarouselColumn{
ThumbnailImageURL: thumbnailImageURL,
Title: title,
Text: text,
Actions: actions,
}
} | go | {
"resource": ""
} |
q34093 | MarshalJSON | train | func (a *URIImagemapAction) MarshalJSON() ([]byte, error) {
return json.Marshal(&struct {
Type ImagemapActionType `json:"type"`
LinkURL string `json:"linkUri"`
Area ImagemapArea `json:"area"`
}{
Type: ImagemapActionTypeURI,
LinkURL: a.LinkURL,
Area: a.Area,
})
} | go | {
"resource": ""
} |
q34094 | MarshalJSON | train | func (a *MessageImagemapAction) MarshalJSON() ([]byte, error) {
return json.Marshal(&struct {
Type ImagemapActionType `json:"type"`
Text string `json:"text"`
Area ImagemapArea `json:"area"`
}{
Type: ImagemapActionTypeMessage,
Text: a.Text,
Area: a.Area,
})
} | go | {
"resource": ""
} |
q34095 | New | train | func New(channelSecret, channelToken string, options ...ClientOption) (*Client, error) {
if channelSecret == "" {
return nil, errors.New("missing channel secret")
}
if channelToken == "" {
return nil, errors.New("missing channel access token")
}
c := &Client{
channelSecret: channelSecret,
channelToken: ch... | go | {
"resource": ""
} |
q34096 | UnmarshalJSON | train | func (c *BoxComponent) UnmarshalJSON(data []byte) error {
type alias BoxComponent
raw := struct {
Contents []rawFlexComponent `json:"contents"`
*alias
}{
alias: (*alias)(c),
}
if err := json.Unmarshal(data, &raw); err != nil {
return err
}
components := make([]FlexComponent, len(raw.Contents))
for i, co... | go | {
"resource": ""
} |
q34097 | UnmarshalJSON | train | func (c *ButtonComponent) UnmarshalJSON(data []byte) error {
type alias ButtonComponent
raw := struct {
Action rawAction `json:"action"`
*alias
}{
alias: (*alias)(c),
}
if err := json.Unmarshal(data, &raw); err != nil {
return err
}
c.Action = raw.Action.Action
return nil
} | go | {
"resource": ""
} |
q34098 | MarshalJSON | train | func (c *BubbleContainer) MarshalJSON() ([]byte, error) {
return json.Marshal(&struct {
Type FlexContainerType `json:"type"`
Direction FlexBubbleDirectionType `json:"direction,omitempty"`
Header *BoxComponent `json:"header,omitempty"`
Hero *ImageComponent `json:"hero,omitem... | go | {
"resource": ""
} |
q34099 | MarshalJSON | train | func (c *CarouselContainer) MarshalJSON() ([]byte, error) {
return json.Marshal(&struct {
Type FlexContainerType `json:"type"`
Contents []*BubbleContainer `json:"contents"`
}{
Type: FlexContainerTypeCarousel,
Contents: c.Contents,
})
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.