_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q33800 | OptServerMetricInterval | train | func OptServerMetricInterval(dur time.Duration) ServerOption {
return func(s *Server) error {
s.metricInterval = dur
return nil
}
} | go | {
"resource": ""
} |
q33801 | OptServerSystemInfo | train | func OptServerSystemInfo(si SystemInfo) ServerOption {
return func(s *Server) error {
s.systemInfo = si
return nil
}
} | go | {
"resource": ""
} |
q33802 | OptServerGCNotifier | train | func OptServerGCNotifier(gcn GCNotifier) ServerOption {
return func(s *Server) error {
s.gcNotifier = gcn
return nil
}
} | go | {
"resource": ""
} |
q33803 | OptServerInternalClient | train | func OptServerInternalClient(c InternalClient) ServerOption {
return func(s *Server) error {
s.executor = newExecutor(optExecutorInternalQueryClient(c))
s.defaultClient = c
s.cluster.InternalClient = c
return nil
}
} | go | {
"resource": ""
} |
q33804 | OptServerPrimaryTranslateStore | train | func OptServerPrimaryTranslateStore(store TranslateStore) ServerOption {
return func(s *Server) error {
s.logger.Printf("DEPRECATED: OptServerPrimaryTranslateStore")
return nil
}
} | go | {
"resource": ""
} |
q33805 | OptServerPrimaryTranslateStoreFunc | train | func OptServerPrimaryTranslateStoreFunc(tf func(interface{}) TranslateStore) ServerOption {
return func(s *Server) error {
s.holder.NewPrimaryTranslateStore = tf
return nil
}
} | go | {
"resource": ""
} |
q33806 | OptServerStatsClient | train | func OptServerStatsClient(sc stats.StatsClient) ServerOption {
return func(s *Server) error {
s.holder.Stats = sc
return nil
}
} | go | {
"resource": ""
} |
q33807 | OptServerDiagnosticsInterval | train | func OptServerDiagnosticsInterval(dur time.Duration) ServerOption {
return func(s *Server) error {
s.diagnosticInterval = dur
return nil
}
} | go | {
"resource": ""
} |
q33808 | OptServerURI | train | func OptServerURI(uri *URI) ServerOption {
return func(s *Server) error {
s.uri = *uri
return nil
}
} | go | {
"resource": ""
} |
q33809 | OptServerClusterDisabled | train | func OptServerClusterDisabled(disabled bool, hosts []string) ServerOption {
return func(s *Server) error {
s.hosts = hosts
s.clusterDisabled = disabled
return nil
}
} | go | {
"resource": ""
} |
q33810 | OptServerSerializer | train | func OptServerSerializer(ser Serializer) ServerOption {
return func(s *Server) error {
s.serializer = ser
return nil
}
} | go | {
"resource": ""
} |
q33811 | OptServerIsCoordinator | train | func OptServerIsCoordinator(is bool) ServerOption {
return func(s *Server) error {
s.isCoordinator = is
return nil
}
} | go | {
"resource": ""
} |
q33812 | OptServerNodeID | train | func OptServerNodeID(nodeID string) ServerOption {
return func(s *Server) error {
s.nodeID = nodeID
return nil
}
} | go | {
"resource": ""
} |
q33813 | OptServerClusterHasher | train | func OptServerClusterHasher(h Hasher) ServerOption {
return func(s *Server) error {
s.cluster.Hasher = h
return nil
}
} | go | {
"resource": ""
} |
q33814 | OptServerTranslateFileMapSize | train | func OptServerTranslateFileMapSize(mapSize int) ServerOption {
return func(s *Server) error {
s.holder.translateFile = NewTranslateFile(OptTranslateFileMapSize(mapSize))
return nil
}
} | go | {
"resource": ""
} |
q33815 | Open | train | func (s *Server) Open() error {
s.logger.Printf("open server")
// Log startup
err := s.holder.logStartup()
if err != nil {
log.Println(errors.Wrap(err, "logging startup"))
}
// Initialize id-key storage.
if err := s.holder.translateFile.Open(); err != nil {
return errors.Wrap(err, "opening TranslateFile")
... | go | {
"resource": ""
} |
q33816 | Close | train | func (s *Server) Close() error {
// Notify goroutines to stop.
close(s.closing)
s.wg.Wait()
var errh error
var errc error
if s.cluster != nil {
errc = s.cluster.close()
}
if s.holder != nil {
errh = s.holder.Close()
}
// prefer to return holder error over cluster
// error. This order is somewhat arbitra... | go | {
"resource": ""
} |
q33817 | loadNodeID | train | func (s *Server) loadNodeID() string {
if s.nodeID != "" {
return s.nodeID
}
nodeID, err := s.holder.loadNodeID()
if err != nil {
s.logger.Printf("loading NodeID: %v", err)
return s.nodeID
}
return nodeID
} | go | {
"resource": ""
} |
q33818 | SendSync | train | func (s *Server) SendSync(m Message) error {
var eg errgroup.Group
msg, err := s.serializer.Marshal(m)
if err != nil {
return fmt.Errorf("marshaling message: %v", err)
}
msg = append([]byte{getMessageType(m)}, msg...)
for _, node := range s.cluster.Nodes() {
node := node
// Don't forward the message to our... | go | {
"resource": ""
} |
q33819 | SendTo | train | func (s *Server) SendTo(to *Node, m Message) error {
msg, err := s.serializer.Marshal(m)
if err != nil {
return fmt.Errorf("marshaling message: %v", err)
}
msg = append([]byte{getMessageType(m)}, msg...)
return s.defaultClient.SendMessage(context.Background(), &to.URI, msg)
} | go | {
"resource": ""
} |
q33820 | handleRemoteStatus | train | func (s *Server) handleRemoteStatus(pb Message) {
// Ignore NodeStatus messages until the cluster is in a Normal state.
if s.cluster.State() != ClusterStateNormal {
return
}
go func() {
// Make sure the holder has opened.
s.holder.opened.Recv()
err := s.mergeRemoteStatus(pb.(*NodeStatus))
if err != nil ... | go | {
"resource": ""
} |
q33821 | monitorDiagnostics | train | func (s *Server) monitorDiagnostics() {
// Do not send more than once a minute
if s.diagnosticInterval < time.Minute {
s.logger.Printf("diagnostics disabled")
return
}
s.logger.Printf("Pilosa is currently configured to send small diagnostics reports to our team every %v. More information here: https://www.pilos... | go | {
"resource": ""
} |
q33822 | monitorRuntime | train | func (s *Server) monitorRuntime() {
// Disable metrics when poll interval is zero.
if s.metricInterval <= 0 {
return
}
var m runtime.MemStats
ticker := time.NewTicker(s.metricInterval)
defer ticker.Stop()
defer s.gcNotifier.Close()
s.logger.Printf("runtime stats initializing (%s interval)", s.metricInterva... | go | {
"resource": ""
} |
q33823 | countOpenFiles | train | func countOpenFiles() (int, error) {
switch runtime.GOOS {
case "darwin", "linux", "unix", "freebsd":
// -b option avoid kernel blocks
pid := os.Getpid()
out, err := exec.Command("/bin/sh", "-c", fmt.Sprintf("lsof -b -p %v", pid)).Output()
if err != nil {
return 0, fmt.Errorf("calling lsof: %s", err)
}
... | go | {
"resource": ""
} |
q33824 | NewInspectCommand | train | func NewInspectCommand(stdin io.Reader, stdout, stderr io.Writer) *InspectCommand {
return &InspectCommand{
CmdIO: pilosa.NewCmdIO(stdin, stdout, stderr),
}
} | go | {
"resource": ""
} |
q33825 | Run | train | func (cmd *InspectCommand) Run(_ context.Context) error {
// Open file handle.
f, err := os.Open(cmd.Path)
if err != nil {
return errors.Wrap(err, "opening file")
}
defer f.Close()
fi, err := f.Stat()
if err != nil {
return errors.Wrap(err, "statting file")
}
// Memory map the file.
data, err := syscall... | go | {
"resource": ""
} |
q33826 | Options | train | func (i *Index) Options() IndexOptions {
i.mu.RLock()
defer i.mu.RUnlock()
return i.options()
} | go | {
"resource": ""
} |
q33827 | Open | train | func (i *Index) Open() error {
// Ensure the path exists.
i.logger.Debugf("ensure index path exists: %s", i.path)
if err := os.MkdirAll(i.path, 0777); err != nil {
return errors.Wrap(err, "creating directory")
}
// Read meta file.
i.logger.Debugf("load meta file for index: %s", i.name)
if err := i.loadMeta();... | go | {
"resource": ""
} |
q33828 | openFields | train | func (i *Index) openFields() error {
f, err := os.Open(i.path)
if err != nil {
return errors.Wrap(err, "opening directory")
}
defer f.Close()
fis, err := f.Readdir(0)
if err != nil {
return errors.Wrap(err, "reading directory")
}
for _, fi := range fis {
if !fi.IsDir() {
continue
}
i.logger.Debu... | go | {
"resource": ""
} |
q33829 | openExistenceField | train | func (i *Index) openExistenceField() error {
f, err := i.createFieldIfNotExists(existenceFieldName, FieldOptions{CacheType: CacheTypeNone, CacheSize: 0})
if err != nil {
return errors.Wrap(err, "creating existence field")
}
i.existenceFld = f
return nil
} | go | {
"resource": ""
} |
q33830 | loadMeta | train | func (i *Index) loadMeta() error {
var pb internal.IndexMeta
// Read data from meta file.
buf, err := ioutil.ReadFile(filepath.Join(i.path, ".meta"))
if os.IsNotExist(err) {
return nil
} else if err != nil {
return errors.Wrap(err, "reading")
} else {
if err := proto.Unmarshal(buf, &pb); err != nil {
re... | go | {
"resource": ""
} |
q33831 | saveMeta | train | func (i *Index) saveMeta() error {
// Marshal metadata.
buf, err := proto.Marshal(&internal.IndexMeta{
Keys: i.keys,
TrackExistence: i.trackExistence,
})
if err != nil {
return errors.Wrap(err, "marshalling")
}
// Write to meta file.
if err := ioutil.WriteFile(filepath.Join(i.path, ".meta"), buf... | go | {
"resource": ""
} |
q33832 | Close | train | func (i *Index) Close() error {
i.mu.Lock()
defer i.mu.Unlock()
// Close the attribute store.
i.columnAttrs.Close()
// Close all fields.
for _, f := range i.fields {
if err := f.Close(); err != nil {
return errors.Wrap(err, "closing field")
}
}
i.fields = make(map[string]*Field)
return nil
} | go | {
"resource": ""
} |
q33833 | AvailableShards | train | func (i *Index) AvailableShards() *roaring.Bitmap {
if i == nil {
return roaring.NewBitmap()
}
i.mu.RLock()
defer i.mu.RUnlock()
b := roaring.NewBitmap()
for _, f := range i.fields {
b = b.Union(f.AvailableShards())
}
i.Stats.Gauge("maxShard", float64(b.Max()), 1.0)
return b
} | go | {
"resource": ""
} |
q33834 | Field | train | func (i *Index) Field(name string) *Field {
i.mu.RLock()
defer i.mu.RUnlock()
return i.field(name)
} | go | {
"resource": ""
} |
q33835 | Fields | train | func (i *Index) Fields() []*Field {
i.mu.RLock()
defer i.mu.RUnlock()
a := make([]*Field, 0, len(i.fields))
for _, f := range i.fields {
a = append(a, f)
}
sort.Sort(fieldSlice(a))
return a
} | go | {
"resource": ""
} |
q33836 | existenceField | train | func (i *Index) existenceField() *Field {
i.mu.RLock()
defer i.mu.RUnlock()
return i.existenceFld
} | go | {
"resource": ""
} |
q33837 | CreateFieldIfNotExists | train | func (i *Index) CreateFieldIfNotExists(name string, opts ...FieldOption) (*Field, error) {
err := validateName(name)
if err != nil {
return nil, errors.Wrap(err, "validating name")
}
i.mu.Lock()
defer i.mu.Unlock()
// Find field in cache first.
if f := i.fields[name]; f != nil {
return f, nil
}
// Apply... | go | {
"resource": ""
} |
q33838 | DeleteField | train | func (i *Index) DeleteField(name string) error {
i.mu.Lock()
defer i.mu.Unlock()
// Confirm field exists.
f := i.field(name)
if f == nil {
return newNotFoundError(ErrFieldNotFound)
}
// Close field.
if err := f.Close(); err != nil {
return errors.Wrap(err, "closing")
}
// Delete field directory.
if er... | go | {
"resource": ""
} |
q33839 | hasTime | train | func hasTime(a []*time.Time) bool {
for _, t := range a {
if t != nil {
return true
}
}
return false
} | go | {
"resource": ""
} |
q33840 | StartSpanFromContext | train | func StartSpanFromContext(ctx context.Context, operationName string) (Span, context.Context) {
return GlobalTracer.StartSpanFromContext(ctx, operationName)
} | go | {
"resource": ""
} |
q33841 | MarshalInternalMessage | train | func MarshalInternalMessage(m Message, s Serializer) ([]byte, error) {
typ := getMessageType(m)
buf, err := s.Marshal(m)
if err != nil {
return nil, errors.Wrap(err, "marshaling")
}
return append([]byte{typ}, buf...), nil
} | go | {
"resource": ""
} |
q33842 | NewStatsClient | train | func NewStatsClient(host string) (*statsClient, error) {
c, err := statsd.NewBuffered(host, bufferLen)
if err != nil {
return nil, err
}
return &statsClient{
client: c,
logger: logger.NopLogger,
}, nil
} | go | {
"resource": ""
} |
q33843 | Count | train | func (c *statsClient) Count(name string, value int64, rate float64) {
if err := c.client.Count(prefix+name, value, c.tags, rate); err != nil {
c.logger.Printf("statsd.StatsClient.Count error: %s", err)
}
} | go | {
"resource": ""
} |
q33844 | unionStringSlice | train | func unionStringSlice(a, b []string) []string {
// Sort both sets first.
sort.Strings(a)
sort.Strings(b)
// Find size of largest slice.
n := len(a)
if len(b) > n {
n = len(b)
}
// Exit if both sets are empty.
if n == 0 {
return nil
}
// Iterate over both in order and merge.
other := make([]string, 0,... | go | {
"resource": ""
} |
q33845 | Diff | train | func (a attrBlocks) Diff(other []AttrBlock) []uint64 {
var ids []uint64
for {
// Read next block from each list.
var blk0, blk1 *AttrBlock
if len(a) > 0 {
blk0 = &a[0]
}
if len(other) > 0 {
blk1 = &other[0]
}
// Exit if "a" contains no more blocks.
if blk0 == nil {
return ids
}
// Add b... | go | {
"resource": ""
} |
q33846 | cloneAttrs | train | func cloneAttrs(m map[string]interface{}) map[string]interface{} {
other := make(map[string]interface{}, len(m))
for k, v := range m {
other[k] = v
}
return other
} | go | {
"resource": ""
} |
q33847 | EncodeAttrs | train | func EncodeAttrs(attr map[string]interface{}) ([]byte, error) {
return proto.Marshal(&internal.AttrMap{Attrs: encodeAttrs(attr)})
} | go | {
"resource": ""
} |
q33848 | DecodeAttrs | train | func DecodeAttrs(v []byte) (map[string]interface{}, error) {
var pb internal.AttrMap
if err := proto.Unmarshal(v, &pb); err != nil {
return nil, err
}
return decodeAttrs(pb.GetAttrs()), nil
} | go | {
"resource": ""
} |
q33849 | NewURIFromHostPort | train | func NewURIFromHostPort(host string, port uint16) (*URI, error) {
uri := defaultURI()
err := uri.setHost(host)
if err != nil {
return nil, errors.Wrap(err, "setting uri host")
}
uri.SetPort(port)
return uri, nil
} | go | {
"resource": ""
} |
q33850 | setScheme | train | func (u *URI) setScheme(scheme string) error {
m := schemeRegexp.FindStringSubmatch(scheme)
if m == nil {
return errors.New("invalid scheme")
}
u.Scheme = scheme
return nil
} | go | {
"resource": ""
} |
q33851 | setHost | train | func (u *URI) setHost(host string) error {
m := hostRegexp.FindStringSubmatch(host)
if m == nil {
return errors.New("invalid host")
}
u.Host = host
return nil
} | go | {
"resource": ""
} |
q33852 | normalize | train | func (u *URI) normalize() string {
scheme := u.Scheme
index := strings.Index(scheme, "+")
if index >= 0 {
scheme = scheme[:index]
}
return fmt.Sprintf("%s://%s:%d", scheme, u.Host, u.Port)
} | go | {
"resource": ""
} |
q33853 | String | train | func (u URI) String() string {
return fmt.Sprintf("%s://%s:%d", u.Scheme, u.Host, u.Port)
} | go | {
"resource": ""
} |
q33854 | Path | train | func (u *URI) Path(path string) string {
return fmt.Sprintf("%s%s", u.normalize(), path)
} | go | {
"resource": ""
} |
q33855 | Set | train | func (u *URI) Set(value string) error {
uri, err := NewURIFromAddress(value)
if err != nil {
return err
}
*u = *uri
return nil
} | go | {
"resource": ""
} |
q33856 | MarshalJSON | train | func (u *URI) MarshalJSON() ([]byte, error) {
var output struct {
Scheme string `json:"scheme,omitempty"`
Host string `json:"host,omitempty"`
Port uint16 `json:"port,omitempty"`
}
output.Scheme = u.Scheme
output.Host = u.Host
output.Port = u.Port
return json.Marshal(output)
} | go | {
"resource": ""
} |
q33857 | UnmarshalJSON | train | func (u *URI) UnmarshalJSON(b []byte) error {
var input struct {
Scheme string `json:"scheme,omitempty"`
Host string `json:"host,omitempty"`
Port uint16 `json:"port,omitempty"`
}
if err := json.Unmarshal(b, &input); err != nil {
return err
}
u.Scheme = input.Scheme
u.Host = input.Host
u.Port = input.... | go | {
"resource": ""
} |
q33858 | NewCheckCommand | train | func NewCheckCommand(stdin io.Reader, stdout, stderr io.Writer) *CheckCommand {
return &CheckCommand{
CmdIO: pilosa.NewCmdIO(stdin, stdout, stderr),
}
} | go | {
"resource": ""
} |
q33859 | Run | train | func (cmd *CheckCommand) Run(_ context.Context) error {
for _, path := range cmd.Paths {
switch filepath.Ext(path) {
case "":
if err := cmd.checkBitmapFile(path); err != nil {
return errors.Wrap(err, "checking bitmap")
}
case ".cache":
if err := cmd.checkCacheFile(path); err != nil {
return err... | go | {
"resource": ""
} |
q33860 | checkBitmapFile | train | func (cmd *CheckCommand) checkBitmapFile(path string) (err error) {
// Open file handle.
f, err := os.Open(path)
if err != nil {
return errors.Wrap(err, "opening file")
}
defer f.Close()
fi, err := f.Stat()
if err != nil {
return errors.Wrap(err, "statting file")
}
// Memory map the file.
data, err := s... | go | {
"resource": ""
} |
q33861 | checkCacheFile | train | func (cmd *CheckCommand) checkCacheFile(path string) error {
fmt.Fprintf(cmd.Stderr, "%s: ignoring cache file\n", path)
return nil
} | go | {
"resource": ""
} |
q33862 | NewTranslateStore | train | func NewTranslateStore() *translateStore {
return &translateStore{
cols: make(map[string]*translateIndex),
rows: make(map[frameKey]*translateIndex),
}
} | go | {
"resource": ""
} |
q33863 | Reader | train | func (s *translateStore) Reader(ctx context.Context, offset int64) (io.ReadCloser, error) {
return nil, pilosa.ErrReplicationNotSupported
} | go | {
"resource": ""
} |
q33864 | TranslateColumnsToUint64 | train | func (s *translateStore) TranslateColumnsToUint64(index string, values []string) ([]uint64, error) {
ret := make([]uint64, len(values))
// Read value under read lock.
s.mu.RLock()
if idx := s.cols[index]; idx != nil {
var writeRequired bool
for i := range values {
v, ok := idx.lookup[values[i]]
if !ok {
... | go | {
"resource": ""
} |
q33865 | NewExportCommand | train | func NewExportCommand(stdin io.Reader, stdout, stderr io.Writer) *ExportCommand {
return &ExportCommand{
CmdIO: pilosa.NewCmdIO(stdin, stdout, stderr),
}
} | go | {
"resource": ""
} |
q33866 | Run | train | func (cmd *ExportCommand) Run(ctx context.Context) error {
logger := log.New(cmd.Stderr, "", log.LstdFlags)
// Validate arguments.
if cmd.Index == "" {
return pilosa.ErrIndexRequired
} else if cmd.Field == "" {
return pilosa.ErrFieldRequired
}
// Use output file, if specified.
// Otherwise use STDOUT.
var... | go | {
"resource": ""
} |
q33867 | Count | train | func (c *expvarStatsClient) Count(name string, value int64, rate float64) {
c.m.Add(name, value)
} | go | {
"resource": ""
} |
q33868 | Gauge | train | func (c *expvarStatsClient) Gauge(name string, value float64, rate float64) {
var f expvar.Float
f.Set(value)
c.m.Set(name, &f)
} | go | {
"resource": ""
} |
q33869 | Histogram | train | func (c *expvarStatsClient) Histogram(name string, value float64, rate float64) {
c.Gauge(name, value, rate)
} | go | {
"resource": ""
} |
q33870 | Set | train | func (c *expvarStatsClient) Set(name string, value string, rate float64) {
var s expvar.String
s.Set(value)
c.m.Set(name, &s)
} | go | {
"resource": ""
} |
q33871 | WithTags | train | func (a MultiStatsClient) WithTags(tags ...string) StatsClient {
other := make(MultiStatsClient, len(a))
for i := range a {
other[i] = a[i].WithTags(tags...)
}
return other
} | go | {
"resource": ""
} |
q33872 | Count | train | func (a MultiStatsClient) Count(name string, value int64, rate float64) {
for _, c := range a {
c.Count(name, value, rate)
}
} | go | {
"resource": ""
} |
q33873 | Set | train | func (a MultiStatsClient) Set(name string, value string, rate float64) {
for _, c := range a {
c.Set(name, value, rate)
}
} | go | {
"resource": ""
} |
q33874 | Timing | train | func (a MultiStatsClient) Timing(name string, value time.Duration, rate float64) {
for _, c := range a {
c.Timing(name, value, rate)
}
} | go | {
"resource": ""
} |
q33875 | SetLogger | train | func (a MultiStatsClient) SetLogger(logger logger.Logger) {
for _, c := range a {
c.SetLogger(logger)
}
} | go | {
"resource": ""
} |
q33876 | Close | train | func (a MultiStatsClient) Close() error {
for _, c := range a {
err := c.Close()
if err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q33877 | NewCommand | train | func NewCommand(stdin io.Reader, stdout, stderr io.Writer, opts ...CommandOption) *Command {
c := &Command{
Config: NewConfig(),
CmdIO: pilosa.NewCmdIO(stdin, stdout, stderr),
Started: make(chan struct{}),
done: make(chan struct{}),
}
for _, opt := range opts {
err := opt(c)
if err != nil {
pani... | go | {
"resource": ""
} |
q33878 | Start | train | func (m *Command) Start() (err error) {
defer close(m.Started)
// Seed random number generator
rand.Seed(time.Now().UTC().UnixNano())
// SetupServer
err = m.SetupServer()
if err != nil {
return errors.Wrap(err, "setting up server")
}
// SetupNetworking
err = m.setupNetworking()
if err != nil {
return e... | go | {
"resource": ""
} |
q33879 | Wait | train | func (m *Command) Wait() error {
// First SIGKILL causes server to shut down gracefully.
c := make(chan os.Signal, 2)
signal.Notify(c, os.Interrupt, syscall.SIGTERM)
select {
case sig := <-c:
m.logger.Printf("received signal '%s', gracefully shutting down...\n", sig.String())
// Second signal causes a hard sh... | go | {
"resource": ""
} |
q33880 | setupNetworking | train | func (m *Command) setupNetworking() error {
if m.Config.Cluster.Disabled {
return nil
}
gossipPort, err := strconv.Atoi(m.Config.Gossip.Port)
if err != nil {
return errors.Wrap(err, "parsing port")
}
// get the host portion of addr to use for binding
gossipHost := m.listenURI.Host
m.gossipTransport, err =... | go | {
"resource": ""
} |
q33881 | newStatsClient | train | func newStatsClient(name string, host string) (stats.StatsClient, error) {
switch name {
case "expvar":
return stats.NewExpvarStatsClient(), nil
case "statsd":
return statsd.NewStatsClient(host)
case "nop", "none":
return stats.NopStatsClient, nil
default:
return nil, errors.Errorf("'%v' not a valid stats ... | go | {
"resource": ""
} |
q33882 | getListener | train | func getListener(uri pilosa.URI, tlsconf *tls.Config) (ln net.Listener, err error) {
// If bind URI has the https scheme, enable TLS
if uri.Scheme == "https" && tlsconf != nil {
ln, err = tls.Listen("tcp", uri.HostPort(), tlsconf)
if err != nil {
return nil, errors.Wrap(err, "tls.Listener")
}
} else if uri.... | go | {
"resource": ""
} |
q33883 | NewBitmap | train | func NewBitmap(a ...uint64) *Bitmap {
b := &Bitmap{
Containers: newSliceContainers(),
}
// TODO: We have no way to report this. We aren't in a server context
// so we haven't got a logger, nothing is checking for nil returns
// from this...
_, _ = b.AddN(a...)
return b
} | go | {
"resource": ""
} |
q33884 | DirectRemoveN | train | func (b *Bitmap) DirectRemoveN(a ...uint64) (changed int) {
return b.directOpN((*Container).remove, a...)
} | go | {
"resource": ""
} |
q33885 | directOpN | train | func (b *Bitmap) directOpN(op func(c *Container, v uint16) bool, a ...uint64) (changed int) {
hb := uint64(0xFFFFFFFFFFFFFFFF) // impossible sentinel value
var cont *Container
for _, v := range a {
if newhb := highbits(v); newhb != hb {
hb = newhb
cont = b.Containers.GetOrCreate(hb)
}
if op(cont, lowbits... | go | {
"resource": ""
} |
q33886 | Contains | train | func (b *Bitmap) Contains(v uint64) bool {
c := b.Containers.Get(highbits(v))
if c == nil {
return false
}
return c.Contains(lowbits(v))
} | go | {
"resource": ""
} |
q33887 | RemoveN | train | func (b *Bitmap) RemoveN(a ...uint64) (changed int, err error) {
if len(a) == 0 {
return 0, nil
}
changed = b.DirectRemoveN(a...) // modifies a in-place
if b.OpWriter != nil {
op := &op{
typ: opTypeRemoveBatch,
values: a[:changed],
}
if err := b.writeOp(op); err != nil {
b.DirectAddN(op.values... | go | {
"resource": ""
} |
q33888 | Max | train | func (b *Bitmap) Max() uint64 {
if b.Containers.Size() == 0 {
return 0
}
hb, c := b.Containers.Last()
lb := c.max()
return hb<<16 | uint64(lb)
} | go | {
"resource": ""
} |
q33889 | Size | train | func (b *Bitmap) Size() int {
numbytes := 0
citer, _ := b.Containers.Iterator(0)
for citer.Next() {
_, c := citer.Value()
numbytes += c.size()
}
return numbytes
} | go | {
"resource": ""
} |
q33890 | CountRange | train | func (b *Bitmap) CountRange(start, end uint64) (n uint64) {
if b.Containers.Size() == 0 {
return
}
skey := highbits(start)
ekey := highbits(end)
citer, found := b.Containers.Iterator(highbits(start))
// If range is entirely in one container then just count that range.
if found && skey == ekey {
citer.Next(... | go | {
"resource": ""
} |
q33891 | Slice | train | func (b *Bitmap) Slice() []uint64 {
var a []uint64
itr := b.Iterator()
itr.Seek(0)
for v, eof := itr.Next(); !eof; v, eof = itr.Next() {
a = append(a, v)
}
return a
} | go | {
"resource": ""
} |
q33892 | SliceRange | train | func (b *Bitmap) SliceRange(start, end uint64) []uint64 {
var a []uint64
itr := b.Iterator()
itr.Seek(start)
for v, eof := itr.Next(); !eof && v < end; v, eof = itr.Next() {
a = append(a, v)
}
return a
} | go | {
"resource": ""
} |
q33893 | ForEach | train | func (b *Bitmap) ForEach(fn func(uint64)) {
itr := b.Iterator()
itr.Seek(0)
for v, eof := itr.Next(); !eof; v, eof = itr.Next() {
fn(v)
}
} | go | {
"resource": ""
} |
q33894 | ForEachRange | train | func (b *Bitmap) ForEachRange(start, end uint64, fn func(uint64)) {
itr := b.Iterator()
itr.Seek(start)
for v, eof := itr.Next(); !eof && v < end; v, eof = itr.Next() {
fn(v)
}
} | go | {
"resource": ""
} |
q33895 | OffsetRange | train | func (b *Bitmap) OffsetRange(offset, start, end uint64) *Bitmap {
if lowbits(offset) != 0 {
panic("offset must not contain low bits")
}
if lowbits(start) != 0 {
panic("range start must not contain low bits")
}
if lowbits(end) != 0 {
panic("range end must not contain low bits")
}
off := highbits(offset)
h... | go | {
"resource": ""
} |
q33896 | container | train | func (b *Bitmap) container(key uint64) *Container {
return b.Containers.Get(key)
} | go | {
"resource": ""
} |
q33897 | IntersectionCount | train | func (b *Bitmap) IntersectionCount(other *Bitmap) uint64 {
var n uint64
iiter, _ := b.Containers.Iterator(0)
jiter, _ := other.Containers.Iterator(0)
i, j := iiter.Next(), jiter.Next()
ki, ci := iiter.Value()
kj, cj := jiter.Value()
for i && j {
if ki < kj {
i = iiter.Next()
ki, ci = iiter.Value()
} el... | go | {
"resource": ""
} |
q33898 | Intersect | train | func (b *Bitmap) Intersect(other *Bitmap) *Bitmap {
output := NewBitmap()
iiter, _ := b.Containers.Iterator(0)
jiter, _ := other.Containers.Iterator(0)
i, j := iiter.Next(), jiter.Next()
ki, ci := iiter.Value()
kj, cj := jiter.Value()
for i && j {
if ki < kj {
i = iiter.Next()
ki, ci = iiter.Value()
} ... | go | {
"resource": ""
} |
q33899 | Union | train | func (b *Bitmap) Union(others ...*Bitmap) *Bitmap {
if len(others) == 1 {
output := NewBitmap()
b.unionIntoTargetSingle(output, others[0])
return output
}
output := b.Clone()
output.UnionInPlace(others...)
return output
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.