_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q182600 | Close | test | func (m *Nitro) Close() {
// Wait until all snapshot iterators have finished
for s := m.snapshots.GetStats(); int(s.NodeCount) != 0; s = m.snapshots.GetStats() {
time.Sleep(time.Millisecond)
}
m.hasShutdown = true
// Acquire gc chan ownership
// This will make sure that no other goroutine will write to gcchan... | go | {
"resource": ""
} |
q182601 | NewWriter | test | func (m *Nitro) NewWriter() *Writer {
w := m.newWriter()
w.next = m.wlist
m.wlist = w
w.dwrCtx.Init()
m.shutdownWg1.Add(1)
go m.collectionWorker(w)
if m.useMemoryMgmt {
m.shutdownWg2.Add(1)
go m.freeWorker(w)
}
return w
} | go | {
"resource": ""
} |
q182602 | SnapshotSize | test | func SnapshotSize(p unsafe.Pointer) int {
s := (*Snapshot)(p)
return int(unsafe.Sizeof(s.sn) + unsafe.Sizeof(s.refCount) + unsafe.Sizeof(s.db) +
unsafe.Sizeof(s.count) + unsafe.Sizeof(s.gclist))
} | go | {
"resource": ""
} |
q182603 | Encode | test | func (s *Snapshot) Encode(buf []byte, w io.Writer) error {
l := 4
if len(buf) < l {
return errNotEnoughSpace
}
binary.BigEndian.PutUint32(buf[0:4], s.sn)
if _, err := w.Write(buf[0:4]); err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q182604 | Decode | test | func (s *Snapshot) Decode(buf []byte, r io.Reader) error {
if _, err := io.ReadFull(r, buf[0:4]); err != nil {
return err
}
s.sn = binary.BigEndian.Uint32(buf[0:4])
return nil
} | go | {
"resource": ""
} |
q182605 | Open | test | func (s *Snapshot) Open() bool {
if atomic.LoadInt32(&s.refCount) == 0 {
return false
}
atomic.AddInt32(&s.refCount, 1)
return true
} | go | {
"resource": ""
} |
q182606 | CompareSnapshot | test | func CompareSnapshot(this, that unsafe.Pointer) int {
thisItem := (*Snapshot)(this)
thatItem := (*Snapshot)(that)
return int(thisItem.sn) - int(thatItem.sn)
} | go | {
"resource": ""
} |
q182607 | GC | test | func (m *Nitro) GC() {
if atomic.CompareAndSwapInt32(&m.isGCRunning, 0, 1) {
m.collectDead()
atomic.CompareAndSwapInt32(&m.isGCRunning, 1, 0)
}
} | go | {
"resource": ""
} |
q182608 | GetSnapshots | test | func (m *Nitro) GetSnapshots() []*Snapshot {
var snaps []*Snapshot
buf := m.snapshots.MakeBuf()
defer m.snapshots.FreeBuf(buf)
iter := m.snapshots.NewIterator(CompareSnapshot, buf)
iter.SeekFirst()
for ; iter.Valid(); iter.Next() {
snaps = append(snaps, (*Snapshot)(iter.Get()))
}
return snaps
} | go | {
"resource": ""
} |
q182609 | MemoryInUse | test | func MemoryInUse() (sz int64) {
buf := dbInstances.MakeBuf()
defer dbInstances.FreeBuf(buf)
iter := dbInstances.NewIterator(CompareNitro, buf)
for iter.SeekFirst(); iter.Valid(); iter.Next() {
db := (*Nitro)(iter.Get())
sz += db.MemoryInUse()
}
return
} | go | {
"resource": ""
} |
q182610 | CompareBS | test | func CompareBS(this, that unsafe.Pointer) int {
thisItm := (*BarrierSession)(this)
thatItm := (*BarrierSession)(that)
return int(thisItm.seqno) - int(thatItm.seqno)
} | go | {
"resource": ""
} |
q182611 | Acquire | test | func (ab *AccessBarrier) Acquire() *BarrierSession {
if ab.active {
retry:
bs := (*BarrierSession)(atomic.LoadPointer(&ab.session))
liveCount := atomic.AddInt32(bs.liveCount, 1)
if liveCount > barrierFlushOffset {
ab.Release(bs)
goto retry
}
return bs
}
return nil
} | go | {
"resource": ""
} |
q182612 | Release | test | func (ab *AccessBarrier) Release(bs *BarrierSession) {
if ab.active {
liveCount := atomic.AddInt32(bs.liveCount, -1)
if liveCount == barrierFlushOffset {
buf := ab.freeq.MakeBuf()
defer ab.freeq.FreeBuf(buf)
// Accessors which entered a closed barrier session steps down automatically
// But, they may ... | go | {
"resource": ""
} |
q182613 | FlushSession | test | func (ab *AccessBarrier) FlushSession(ref unsafe.Pointer) {
if ab.active {
ab.Lock()
defer ab.Unlock()
bsPtr := atomic.LoadPointer(&ab.session)
newBsPtr := unsafe.Pointer(newBarrierSession())
atomic.CompareAndSwapPointer(&ab.session, bsPtr, newBsPtr)
bs := (*BarrierSession)(bsPtr)
bs.objectRef = ref
a... | go | {
"resource": ""
} |
q182614 | Apply | test | func (report *StatsReport) Apply(s *Stats) {
var totalNextPtrs int
var totalNodes int
report.ReadConflicts += s.readConflicts
report.InsertConflicts += s.insertConflicts
for i, c := range s.levelNodesCount {
report.NodeDistribution[i] += c
nodesAtlevel := report.NodeDistribution[i]
totalNodes += int(nodesA... | go | {
"resource": ""
} |
q182615 | AddInt64 | test | func (s *Stats) AddInt64(src *int64, val int64) {
if s.isLocal {
*src += val
} else {
atomic.AddInt64(src, val)
}
} | go | {
"resource": ""
} |
q182616 | AddUint64 | test | func (s *Stats) AddUint64(src *uint64, val uint64) {
if s.isLocal {
*src += val
} else {
atomic.AddUint64(src, val)
}
} | go | {
"resource": ""
} |
q182617 | Merge | test | func (s *Stats) Merge(sts *Stats) {
atomic.AddUint64(&s.insertConflicts, sts.insertConflicts)
sts.insertConflicts = 0
atomic.AddUint64(&s.readConflicts, sts.readConflicts)
sts.readConflicts = 0
atomic.AddInt64(&s.softDeletes, sts.softDeletes)
sts.softDeletes = 0
atomic.AddInt64(&s.nodeAllocs, sts.nodeAllocs)
st... | go | {
"resource": ""
} |
q182618 | GetStats | test | func (s *Skiplist) GetStats() StatsReport {
var report StatsReport
report.Apply(&s.Stats)
return report
} | go | {
"resource": ""
} |
q182619 | NewIterator | test | func (s *Skiplist) NewIterator(cmp CompareFn,
buf *ActionBuffer) *Iterator {
return &Iterator{
cmp: cmp,
s: s,
buf: buf,
bs: s.barrier.Acquire(),
}
} | go | {
"resource": ""
} |
q182620 | SeekFirst | test | func (it *Iterator) SeekFirst() {
it.prev = it.s.head
it.curr, _ = it.s.head.getNext(0)
it.valid = true
} | go | {
"resource": ""
} |
q182621 | SeekWithCmp | test | func (it *Iterator) SeekWithCmp(itm unsafe.Pointer, cmp CompareFn, eqCmp CompareFn) bool {
var found bool
if found = it.s.findPath(itm, cmp, it.buf, &it.s.Stats) != nil; found {
it.prev = it.buf.preds[0]
it.curr = it.buf.succs[0]
} else {
if found = eqCmp != nil && compare(eqCmp, itm, it.buf.preds[0].Item()) =... | go | {
"resource": ""
} |
q182622 | Seek | test | func (it *Iterator) Seek(itm unsafe.Pointer) bool {
it.valid = true
found := it.s.findPath(itm, it.cmp, it.buf, &it.s.Stats) != nil
it.prev = it.buf.preds[0]
it.curr = it.buf.succs[0]
return found
} | go | {
"resource": ""
} |
q182623 | Valid | test | func (it *Iterator) Valid() bool {
if it.valid && it.curr == it.s.tail {
it.valid = false
}
return it.valid
} | go | {
"resource": ""
} |
q182624 | Delete | test | func (it *Iterator) Delete() {
it.s.softDelete(it.curr, &it.s.Stats)
// It will observe that current item is deleted
// Run delete helper and move to the next possible item
it.Next()
it.deleted = true
} | go | {
"resource": ""
} |
q182625 | Next | test | func (it *Iterator) Next() {
if it.deleted {
it.deleted = false
return
}
retry:
it.valid = true
next, deleted := it.curr.getNext(0)
if deleted {
// Current node is deleted. Unlink current node from the level
// and make next node as current node.
// If it fails, refresh the path buffer and obtain new cu... | go | {
"resource": ""
} |
q182626 | Init | test | func Init() {
s := new(SkuM1SmallBuilder)
s.Client, _ = new(SkuM1Small).GetInnkeeperClient()
skurepo.Register(SkuName, s)
} | go | {
"resource": ""
} |
q182627 | FromURL | test | func FromURL(url string) string {
result := url
for _, replace := range replaces {
result = strings.Replace(result, replace.a, replace.b, -1)
}
return result
} | go | {
"resource": ""
} |
q182628 | ToURL | test | func ToURL(folder string) string {
result := folder
for _, replace := range replaces {
result = strings.Replace(result, replace.b, replace.a, -1)
}
return result
} | go | {
"resource": ""
} |
q182629 | Size | test | func (t *TupleHeader) Size() int {
return VersionOneTupleHeaderSize + int(t.FieldSize)*int(t.FieldCount)
} | go | {
"resource": ""
} |
q182630 | WriteTo | test | func (t *TupleHeader) WriteTo(w io.Writer) (int64, error) {
if len(t.Offsets) != int(t.FieldCount) {
return 0, errors.New("Invalid Header: Field count does not equal number of field offsets")
}
// Encode Header
dst := make([]byte, t.Size())
dst[0] = byte(t.TupleVersion)
binary.LittleEndian.PutUint32(dst[1:], ... | go | {
"resource": ""
} |
q182631 | Static | test | func Static(directory string, staticOpt ...StaticOptions) Handler {
if !path.IsAbs(directory) {
directory = path.Join(Root, directory)
}
dir := http.Dir(directory)
opt := prepareStaticOptions(staticOpt)
return func(res http.ResponseWriter, req *http.Request, log *log.Logger) {
if req.Method != "GET" && req.Me... | go | {
"resource": ""
} |
q182632 | Read | test | func (c *Config) Read() error {
in, err := os.Open(c.filename)
if err != nil {
return err
}
defer in.Close()
scanner := bufio.NewScanner(in)
line := ""
section := ""
for scanner.Scan() {
if scanner.Text() == "" {
continue
}
if line == "" {
sec, ok := checkSection(scanner.Text())
if ok {
sec... | go | {
"resource": ""
} |
q182633 | Del | test | func (c *Config) Del(section string, key string) {
_, ok := c.config[section]
if ok {
delete(c.config[section], key)
if len(c.config[section]) == 0 {
delete(c.config, section)
}
}
} | go | {
"resource": ""
} |
q182634 | WriteTo | test | func (c *Config) WriteTo(filename string) error {
content := ""
for k, v := range c.config {
format := "%v = %v\n"
if k != "" {
content += fmt.Sprintf("[%v]\n", k)
format = "\t" + format
}
for key, value := range v {
content += fmt.Sprintf(format, key, value)
}
}
return ioutil.WriteFile(filename,... | go | {
"resource": ""
} |
q182635 | checkSection | test | func checkSection(line string) (string, bool) {
line = strings.TrimSpace(line)
lineLen := len(line)
if lineLen < 2 {
return "", false
}
if line[0] == '[' && line[lineLen-1] == ']' {
return line[1 : lineLen-1], true
}
return "", false
} | go | {
"resource": ""
} |
q182636 | checkLine | test | func checkLine(line string) (string, string, bool) {
key := ""
value := ""
sp := strings.SplitN(line, "=", 2)
if len(sp) != 2 {
return key, value, false
}
key = strings.TrimSpace(sp[0])
value = strings.TrimSpace(sp[1])
return key, value, true
} | go | {
"resource": ""
} |
q182637 | checkComment | test | func checkComment(line string) bool {
line = strings.TrimSpace(line)
for p := range commentPrefix {
if strings.HasPrefix(line, commentPrefix[p]) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q182638 | NewResponseWrapper | test | func NewResponseWrapper(w http.ResponseWriter) *ResponseWrapper {
return &ResponseWrapper{ResponseRecorder: httptest.NewRecorder(), writer: w}
} | go | {
"resource": ""
} |
q182639 | Hijack | test | func (w *ResponseWrapper) Hijack() (net.Conn, *bufio.ReadWriter, error) {
if hijacker, ok := w.writer.(http.Hijacker); ok {
c, rw, err := hijacker.Hijack()
if err == nil {
w.Hijacked = true
}
return c, rw, err
}
return nil, nil, errors.New("Wrapped ResponseWriter is not a Hijacker")
} | go | {
"resource": ""
} |
q182640 | CloseNotify | test | func (w *ResponseWrapper) CloseNotify() <-chan bool {
if notifier, ok := w.writer.(http.CloseNotifier); ok {
c := notifier.CloseNotify()
return c
}
return make(chan bool)
} | go | {
"resource": ""
} |
q182641 | DateFormat | test | func DateFormat(f string) Option {
return Option{func(o *options) {
o.dateFormat = f
}}
} | go | {
"resource": ""
} |
q182642 | Logger | test | func Logger(next http.Handler) http.HandlerFunc {
stdlogger := log.New(os.Stdout, "", 0)
//errlogger := log.New(os.Stderr, "", 0)
return func(w http.ResponseWriter, r *http.Request) {
// Start timer
start := time.Now()
// Process request
writer := statusWriter{w, 0}
next.ServeHTTP(&writer, r)
// Stop ... | go | {
"resource": ""
} |
q182643 | GetAvailableInventory | test | func GetAvailableInventory(taskCollection integrations.Collection) (inventory map[string]skurepo.SkuBuilder) {
inventory = skurepo.GetRegistry()
onceLoadInventoryPoller.Do(func() {
startTaskPollingForRegisteredSkus(taskCollection)
})
return
} | go | {
"resource": ""
} |
q182644 | Expiration | test | func Expiration(e time.Duration) TokenOpt {
return TokenOpt{func(o *options) {
o.expiration = e
}}
} | go | {
"resource": ""
} |
q182645 | Claimer | test | func Claimer(c func(claims *jwt.StandardClaims) jwt.Claims) TokenOpt {
return TokenOpt{func(o *options) {
o.claimer = c
}}
} | go | {
"resource": ""
} |
q182646 | Issuer | test | func Issuer(issuer string) TokenOpt {
return TokenOpt{func(o *options) {
o.issuer = issuer
}}
} | go | {
"resource": ""
} |
q182647 | User | test | func User(user string) TokenOpt {
return TokenOpt{func(o *options) {
o.user = user
}}
} | go | {
"resource": ""
} |
q182648 | Password | test | func Password(password string) TokenOpt {
return TokenOpt{func(o *options) {
o.password = password
}}
} | go | {
"resource": ""
} |
q182649 | Extractor | test | func Extractor(e request.Extractor) TokenOpt {
return TokenOpt{func(o *options) {
o.extractor = e
}}
} | go | {
"resource": ""
} |
q182650 | TokenGenerator | test | func TokenGenerator(h http.Handler, auth Authenticator, secret []byte, opts ...TokenOpt) http.Handler {
o := options{
logger: handler.NopLogger(),
claimer: func(c *jwt.StandardClaims) jwt.Claims { return c },
expiration: time.Hour * 24 * 15,
user: "user",
password: "password",
}
o.apply(opt... | go | {
"resource": ""
} |
q182651 | Token | test | func Token(r *http.Request) string {
if token, ok := r.Context().Value(TokenKey).(string); ok {
return token
}
return ""
} | go | {
"resource": ""
} |
q182652 | Claims | test | func Claims(r *http.Request) jwt.Claims {
if claims, ok := r.Context().Value(ClaimsKey).(jwt.Claims); ok {
return claims
}
return nil
} | go | {
"resource": ""
} |
q182653 | String | test | func (t Token) String() string {
switch t.Type {
case TokenEOF:
return "EOF"
case TokenError:
return t.Value
}
if len(t.Value) > 10 {
return fmt.Sprintf("%.25q...", t.Value)
}
return fmt.Sprintf("%q", t.Value)
} | go | {
"resource": ""
} |
q182654 | NewLexer | test | func NewLexer(name, input string, h Handler) *Lexer {
return &Lexer{
Name: name,
input: input + "\n",
state: lexText,
handler: h,
}
} | go | {
"resource": ""
} |
q182655 | run | test | func (l *Lexer) run() {
for state := lexText; state != nil; {
state = state(l)
}
} | go | {
"resource": ""
} |
q182656 | emit | test | func (l *Lexer) emit(t TokenType) {
// if the position is the same as the start, do not emit a token
if l.Pos == l.Start {
return
}
tok := Token{t, l.input[l.Start:l.Pos]}
l.handler(tok)
l.Start = l.Pos
} | go | {
"resource": ""
} |
q182657 | skipWhitespace | test | func (l *Lexer) skipWhitespace() {
for unicode.Is(unicode.White_Space, l.next()) {
}
l.backup()
l.ignore()
} | go | {
"resource": ""
} |
q182658 | next | test | func (l *Lexer) next() (r rune) {
if l.Pos >= len(l.input) {
l.Width = 0
return eof
}
r, l.Width = utf8.DecodeRuneInString(l.remaining())
l.advance(l.Width)
return
} | go | {
"resource": ""
} |
q182659 | LineNum | test | func (l *Lexer) LineNum() int {
return strings.Count(l.input[:l.Pos], "\n")
} | go | {
"resource": ""
} |
q182660 | Offset | test | func (l *Lexer) Offset() int {
// find last line break
lineoffset := strings.LastIndex(l.input[:l.Pos], "\n")
if lineoffset != -1 {
// calculate current offset from last line break
return l.Pos - lineoffset
}
// first line
return l.Pos
} | go | {
"resource": ""
} |
q182661 | errorf | test | func (l *Lexer) errorf(format string, args ...interface{}) stateFn {
l.handler(Token{TokenError, fmt.Sprintf(fmt.Sprintf("%s[%d:%d] ", l.Name, l.LineNum(), l.Offset())+format, args...)})
return nil
} | go | {
"resource": ""
} |
q182662 | lexText | test | func lexText(l *Lexer) stateFn {
OUTER:
for {
l.skipWhitespace()
remaining := l.remaining()
if strings.HasPrefix(remaining, comment) { // Start comment
// state function which lexes a comment
return lexComment
} else if strings.HasPrefix(remaining, pkg) { // Start package decl
// state function which... | go | {
"resource": ""
} |
q182663 | lexComment | test | func lexComment(l *Lexer) stateFn {
l.skipWhitespace()
// if strings.HasPrefix(l.remaining(), comment) {
// skip comment //
l.Pos += len(comment)
// find next new line and add location to pos which
// advances the scanner
if index := strings.Index(l.remaining(), "\n"); index > 0 {
l.Pos += index
} else {
... | go | {
"resource": ""
} |
q182664 | New | test | func New(namespace string, name string) (t TupleType) {
hash := syncHash.Hash([]byte(name))
ns_hash := syncHash.Hash([]byte(namespace))
t = TupleType{namespace, name, ns_hash, hash, make([][]Field, 0), make(map[string]int)}
return
} | go | {
"resource": ""
} |
q182665 | AddVersion | test | func (t *TupleType) AddVersion(fields ...Field) {
t.versions = append(t.versions, fields)
for _, field := range fields {
t.fields[field.Name] = len(t.fields)
}
} | go | {
"resource": ""
} |
q182666 | Contains | test | func (t *TupleType) Contains(field string) bool {
_, exists := t.fields[field]
return exists
} | go | {
"resource": ""
} |
q182667 | Offset | test | func (t *TupleType) Offset(field string) (offset int, exists bool) {
offset, exists = t.fields[field]
return
} | go | {
"resource": ""
} |
q182668 | Versions | test | func (t *TupleType) Versions() (vers []Version) {
vers = make([]Version, t.NumVersions())
for i := 0; i < t.NumVersions(); i++ {
vers[i] = Version{uint8(i + 1), t.versions[i]}
}
return
} | go | {
"resource": ""
} |
q182669 | SetPrivateMeta | test | func (s *Task) SetPrivateMeta(name string, value interface{}) {
if s.PrivateMetaData == nil {
s.PrivateMetaData = make(map[string]interface{})
}
s.PrivateMetaData[name] = value
} | go | {
"resource": ""
} |
q182670 | SetPublicMeta | test | func (s *Task) SetPublicMeta(name string, value interface{}) {
if s.MetaData == nil {
s.MetaData = make(map[string]interface{})
}
s.MetaData[name] = value
} | go | {
"resource": ""
} |
q182671 | GetRedactedVersion | test | func (s *Task) GetRedactedVersion() RedactedTask {
s.mutex.RLock()
rt := RedactedTask{
ID: s.ID,
Timestamp: s.Timestamp,
Expires: s.Expires,
Status: s.Status,
Profile: s.Profile,
CallerName: s.CallerName,
MetaData: s.MetaData,
}
s.mutex.RUnlock()
return rt
} | go | {
"resource": ""
} |
q182672 | Equal | test | func (s Task) Equal(b Task) bool {
return (s.ID == b.ID &&
s.Timestamp == b.Timestamp &&
s.Expires == b.Expires &&
s.Status == b.Status &&
s.Profile == b.Profile &&
s.CallerName == b.CallerName)
} | go | {
"resource": ""
} |
q182673 | HTTP | test | func HTTP(h http.Handler, verb Verb, verbs ...Verb) http.Handler {
verbSet := map[Verb]struct{}{verb: struct{}{}}
for _, v := range verbs {
verbSet[v] = struct{}{}
}
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if _, ok := verbSet[Verb(r.Method)]; ok {
h.ServeHTTP(w, r)
} else {
... | go | {
"resource": ""
} |
q182674 | PutUint8 | test | func (b *TupleBuilder) PutUint8(field string, value uint8) (wrote uint64, err error) {
// field type should be a Uint8Field
if err = b.typeCheck(field, Uint8Field); err != nil {
return 0, err
}
// minimum bytes is 2 (type code + value)
if b.available() < 2 {
return 0, xbinary.ErrOutOfRange
}
// write type... | go | {
"resource": ""
} |
q182675 | PutInt8 | test | func (b *TupleBuilder) PutInt8(field string, value int8) (wrote uint64, err error) {
// field type should be
if err = b.typeCheck(field, Int8Field); err != nil {
return 0, err
}
// minimum bytes is 2 (type code + value)
if b.available() < 2 {
return 0, xbinary.ErrOutOfRange
}
// write type code
b.buffer[... | go | {
"resource": ""
} |
q182676 | PutUint16 | test | func (b *TupleBuilder) PutUint16(field string, value uint16) (wrote uint64, err error) {
// field type should be
if err = b.typeCheck(field, Uint16Field); err != nil {
return 0, err
}
if value < math.MaxUint8 {
// minimum bytes is 2 (type code + value)
if b.available() < 2 {
return 0, xbinary.ErrOutOfRa... | go | {
"resource": ""
} |
q182677 | PutInt16 | test | func (b *TupleBuilder) PutInt16(field string, value int16) (wrote uint64, err error) {
// field type should be
if err = b.typeCheck(field, Int16Field); err != nil {
return 0, err
}
if uint16(value) < math.MaxUint8 {
// minimum bytes is 2 (type code + value)
if b.available() < 2 {
return 0, xbinary.ErrOu... | go | {
"resource": ""
} |
q182678 | PutUint32 | test | func (b *TupleBuilder) PutUint32(field string, value uint32) (wrote uint64, err error) {
// field type should be
if err = b.typeCheck(field, Uint32Field); err != nil {
return 0, err
}
if value < math.MaxUint8 {
// minimum bytes is 2 (type code + value)
if b.available() < 2 {
return 0, xbinary.ErrOutOfRa... | go | {
"resource": ""
} |
q182679 | PutInt32 | test | func (b *TupleBuilder) PutInt32(field string, value int32) (wrote uint64, err error) {
// field type should be
if err = b.typeCheck(field, Int32Field); err != nil {
return 0, err
}
unsigned := uint32(value)
if unsigned < math.MaxUint8 {
// minimum bytes is 2 (type code + value)
if b.available() < 2 {
r... | go | {
"resource": ""
} |
q182680 | PutUint64 | test | func (b *TupleBuilder) PutUint64(field string, value uint64) (wrote uint64, err error) {
// field type should be
if err = b.typeCheck(field, Uint64Field); err != nil {
return 0, err
}
if value < math.MaxUint8 {
// minimum bytes is 2 (type code + value)
if b.available() < 2 {
return 0, xbinary.ErrOutOfRa... | go | {
"resource": ""
} |
q182681 | PutInt64 | test | func (b *TupleBuilder) PutInt64(field string, value int64) (wrote uint64, err error) {
// field type should be
if err = b.typeCheck(field, Int64Field); err != nil {
return 0, err
}
unsigned := uint64(value)
if unsigned < math.MaxUint8 {
// minimum bytes is 2 (type code + value)
if b.available() < 2 {
r... | go | {
"resource": ""
} |
q182682 | NewPackageList | test | func NewPackageList() PackageList {
var lock sync.Mutex
return &packageList{make(map[string]Package), lock}
} | go | {
"resource": ""
} |
q182683 | PutFloat32 | test | func (b *TupleBuilder) PutFloat32(field string, value float32) (wrote uint64, err error) {
// field type should be
if err = b.typeCheck(field, Float32Field); err != nil {
return 0, err
}
// write value
// length check performed by xbinary
wrote, err = xbinary.LittleEndian.PutFloat32(b.buffer, b.pos+1, value)
... | go | {
"resource": ""
} |
q182684 | Classic | test | func Classic() *ClassicMartini {
r := NewRouter()
m := New()
m.Use(Logger())
m.Use(Recovery())
m.Use(Static("static"))
m.Use(ContextRender("", RenderOptions{
Extensions: []string{".html", ".tmpl", "tpl"},
}))
m.MapTo(r, (*Routes)(nil))
m.Action(r.Handle)
return &ClassicMartini{m, r}
} | go | {
"resource": ""
} |
q182685 | Languages | test | func Languages(tags []xlang.Tag) Option {
return Option{func(o *options) {
o.languages = tags
}}
} | go | {
"resource": ""
} |
q182686 | Session | test | func Session(s handler.Session) Option {
return Option{func(o *options) {
o.session = s
}}
} | go | {
"resource": ""
} |
q182687 | Data | test | func Data(r *http.Request) ContextValue {
if v, ok := r.Context().Value(ContextKey).(ContextValue); ok {
return v
}
return ContextValue{}
} | go | {
"resource": ""
} |
q182688 | URL | test | func URL(url, prefix string, data ContextValue) string {
if data.Current.IsRoot() {
return url
}
if prefix == "" {
prefix = "/"
} else if prefix[len(prefix)-1] != '/' {
prefix += "/"
}
if url == "" {
url = "/"
}
if url[0] != '/' {
url = "/" + url
}
return prefix + data.Current.String() + url
} | go | {
"resource": ""
} |
q182689 | Size | test | func Size() (w, h int, err error) {
if !IsInit {
err = errors.New("termsize not yet iniitialied")
return
}
return get_size()
} | go | {
"resource": ""
} |
q182690 | GetRequestIDFromTaskResponse | test | func GetRequestIDFromTaskResponse(taskResponse TaskResponse) (requestID string, err error) {
var provisionHostInfoBytes []byte
firstRecordIndex := 0
meta := taskResponse.MetaData
provisionHostInfo := ProvisionHostInfo{}
lo.G.Debug("taskResponse: ", taskResponse)
lo.G.Debug("metadata: ", meta)
if provisionHostIn... | go | {
"resource": ""
} |
q182691 | PutString | test | func (b *TupleBuilder) PutString(field string, value string) (wrote int, err error) {
// field type should be
if err = b.typeCheck(field, StringField); err != nil {
return 0, err
}
size := len(value)
if size < math.MaxUint8 {
if b.available() < size+2 {
return 0, xbinary.ErrOutOfRange
}
// write len... | go | {
"resource": ""
} |
q182692 | LoadDirectory | test | func LoadDirectory(dir string, parser Parser) (err error) {
// Open dir for reading
d, err := os.Open(dir)
if err != nil {
return
}
// Iterate over all the files in the directory.
for {
// Only read 128 files at a time.
if fis, err := d.Readdir(128); err == nil {
... | go | {
"resource": ""
} |
q182693 | LoadFile | test | func LoadFile(filename string, parser Parser) (Package, error) {
file, err := os.Open(filename)
if err != nil {
return Package{}, err
}
defer file.Close()
// read file
bytes, err := ioutil.ReadAll(file)
if err != nil {
return Package{}, err
}
// convert to string an... | go | {
"resource": ""
} |
q182694 | LoadPackage | test | func LoadPackage(parser Parser, name, text string) (Package, error) {
return parser.Parse(name, text)
} | go | {
"resource": ""
} |
q182695 | NewDecoder | test | func NewDecoder(reg Registry, r io.Reader) Decoder {
var buf []byte
return decoder{reg, DefaultMaxSize, bytes.NewBuffer(buf), bufio.NewReader(r)}
} | go | {
"resource": ""
} |
q182696 | NewDecoderSize | test | func NewDecoderSize(reg Registry, maxSize uint64, r io.Reader) Decoder {
var buf []byte
return decoder{reg, maxSize, bytes.NewBuffer(buf), bufio.NewReader(r)}
} | go | {
"resource": ""
} |
q182697 | Panic | test | func Panic(h http.Handler, opts ...Option) http.Handler {
o := options{logger: handler.ErrLogger(), dateFormat: PanicDateFormat}
o.apply(opts)
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer func() {
if rec := recover(); rec != nil {
stack := debug.Stack()
timestamp := time... | go | {
"resource": ""
} |
q182698 | DeployVApp | test | func (s *FakeVCDClient) DeployVApp(templateName, templateHref, vcdHref string) (vapp *vcloudclient.VApp, err error) {
return s.FakeVApp, s.ErrUnDeployFake
} | go | {
"resource": ""
} |
q182699 | UnDeployVApp | test | func (s *FakeVCDClient) UnDeployVApp(vappID string) (task *vcloudclient.TaskElem, err error) {
return &s.FakeVApp.Tasks.Task, s.ErrDeployFake
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.