id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c182600 | free up all nodes
iter := m.store.NewIterator(m.iterCmp, buf)
defer iter.Close()
var lastNode *skiplist.Node
iter.SeekFirst()
if iter.Valid() {
lastNode = iter.GetNode()
iter.Next()
}
for lastNode != nil {
m.freeItem((*Item)(lastNode.Item()))
m.store.FreeNode(lastNode, &m.store.Stats)
lastNode = nil
if iter.Valid() {
lastNode = iter.GetNode()
iter.Next()
}
}
}
} | |
c182601 |
m.shutdownWg1.Add(1)
go m.collectionWorker(w)
if m.useMemoryMgmt {
m.shutdownWg2.Add(1)
go m.freeWorker(w)
}
return w
} | |
c182602 | + unsafe.Sizeof(s.refCount) + unsafe.Sizeof(s.db) +
unsafe.Sizeof(s.count) + unsafe.Sizeof(s.gclist))
} | |
c182603 |
}
binary.BigEndian.PutUint32(buf[0:4], s.sn)
if _, err := w.Write(buf[0:4]); err != nil {
return err
}
return nil
} | |
c182604 |
}
s.sn = binary.BigEndian.Uint32(buf[0:4])
return nil
} | |
c182605 |
atomic.AddInt32(&s.refCount, 1)
return true
} | |
c182606 | (*Snapshot)(that)
return int(thisItem.sn) - int(thatItem.sn)
} | |
c182607 | 0, 1) {
m.collectDead()
atomic.CompareAndSwapInt32(&m.isGCRunning, 1, 0)
}
} | |
c182608 | ; iter.Valid(); iter.Next() {
snaps = append(snaps, (*Snapshot)(iter.Get()))
}
return snaps
} | |
c182609 | iter.Valid(); iter.Next() {
db := (*Nitro)(iter.Get())
sz += db.MemoryInUse()
}
return
} | |
c182610 |
thatItm := (*BarrierSession)(that)
return int(thisItm.seqno) - int(thatItm.seqno)
} | |
c182611 | liveCount > barrierFlushOffset {
ab.Release(bs)
goto retry
}
return bs
}
return nil
} | |
c182612 | steps down automatically
// But, they may try to close an already closed session.
if atomic.AddInt32(&bs.closed, 1) == 1 {
ab.freeq.Insert(unsafe.Pointer(bs), CompareBS, buf, &ab.freeq.Stats)
if atomic.CompareAndSwapInt32(&ab.isDestructorRunning, 0, 1) {
ab.doCleanup()
atomic.CompareAndSwapInt32(&ab.isDestructorRunning, 1, 0)
}
}
}
}
} | |
c182613 | (*BarrierSession)(bsPtr)
bs.objectRef = ref
ab.activeSeqno++
bs.seqno = ab.activeSeqno
atomic.AddInt32(bs.liveCount, barrierFlushOffset+1)
ab.Release(bs)
}
} | |
c182614 | int(nodesAtlevel)
}
report.SoftDeletes += s.softDeletes
report.NodeCount = totalNodes
report.NextPointersPerNode = float64(totalNextPtrs) / float64(totalNodes)
report.NodeAllocs += s.nodeAllocs
report.NodeFrees += s.nodeFrees
report.Memory += s.usedBytes
} | |
c182615 |
} else {
atomic.AddInt64(src, val)
}
} | |
c182616 | val
} else {
atomic.AddUint64(src, val)
}
} | |
c182617 |
atomic.AddInt64(&s.usedBytes, sts.usedBytes)
sts.usedBytes = 0
for i, val := range sts.levelNodesCount {
if val != 0 {
atomic.AddInt64(&s.levelNodesCount[i], val)
sts.levelNodesCount[i] = 0
}
}
} | |
c182618 |
report.Apply(&s.Stats)
return report
} | |
c182619 | cmp,
s: s,
buf: buf,
bs: s.barrier.Acquire(),
}
} | |
c182620 | = it.s.head.getNext(0)
it.valid = true
} | |
c182621 |
if found = eqCmp != nil && compare(eqCmp, itm, it.buf.preds[0].Item()) == 0; found {
it.prev = nil
it.curr = it.buf.preds[0]
}
}
return found
} | |
c182622 | it.cmp, it.buf, &it.s.Stats) != nil
it.prev = it.buf.preds[0]
it.curr = it.buf.succs[0]
return found
} | |
c182623 | && it.curr == it.s.tail {
it.valid = false
}
return it.valid
} | |
c182624 | helper and move to the next possible item
it.Next()
it.deleted = true
} | |
c182625 | it.s.findPath(it.curr.Item(), it.cmp, it.buf, &it.s.Stats) != nil
last := it.curr
it.prev = it.buf.preds[0]
it.curr = it.buf.succs[0]
if found && last == it.curr {
goto retry
}
}
} else {
it.prev = it.curr
it.curr = next
}
} | |
c182626 | new(SkuM1Small).GetInnkeeperClient()
skurepo.Register(SkuName, s)
} | |
c182627 | range replaces {
result = strings.Replace(result, replace.a, replace.b, -1)
}
return result
} | |
c182628 | := range replaces {
result = strings.Replace(result, replace.b, replace.a, -1)
}
return result
} | |
c182629 | int(t.FieldSize)*int(t.FieldCount)
} | |
c182630 | size enum
dst[0] |= 128
// Write field offsets
for _, offset := range t.Offsets {
binary.LittleEndian.PutUint32(dst[pos:], uint32(offset))
pos += 4
}
case 8:
// Set size enum
dst[0] |= 192
// Write field offsets
for _, offset := range t.Offsets {
binary.LittleEndian.PutUint64(dst[pos:], offset)
pos += 8
}
default:
return pos, errors.New("Invalid Header: Field size must be 1,2,4 or 8 bytes")
}
n, err := w.Write(dst)
return int64(n), err
} | |
c182631 | to serve index file
if fi.IsDir() {
// redirect if missing trailing slash
if !strings.HasSuffix(req.URL.Path, "/") {
http.Redirect(res, req, req.URL.Path+"/", http.StatusFound)
return
}
file = path.Join(file, opt.IndexFile)
f, err = dir.Open(file)
if err != nil {
return
}
defer f.Close()
fi, err = f.Stat()
if err != nil || fi.IsDir() {
return
}
}
if !opt.SkipLogging {
log.Println("[Static] Serving " + file)
}
// Add an Expires header to the static content
if opt.Expires != nil {
res.Header().Set("Expires", opt.Expires())
}
http.ServeContent(res, req, file, fi.ModTime(), f)
}
} | |
c182632 | continue
}
line += scanner.Text()
if strings.HasSuffix(line, "\\") {
line = line[:len(line)-1]
continue
}
key, value, ok := checkLine(line)
if !ok {
return errors.New("WRONG: " + line)
}
c.Set(section, key, value)
line = ""
}
return nil
} | |
c182633 | if len(c.config[section]) == 0 {
delete(c.config, section)
}
}
} | |
c182634 | value := range v {
content += fmt.Sprintf(format, key, value)
}
}
return ioutil.WriteFile(filename, []byte(content), 0644)
} | |
c182635 | && line[lineLen-1] == ']' {
return line[1 : lineLen-1], true
}
return "", false
} | |
c182636 | = strings.TrimSpace(sp[0])
value = strings.TrimSpace(sp[1])
return key, value, true
} | |
c182637 | := range commentPrefix {
if strings.HasPrefix(line, commentPrefix[p]) {
return true
}
}
return false
} | |
c182638 | {
return &ResponseWrapper{ResponseRecorder: httptest.NewRecorder(), writer: w}
} | |
c182639 | w.Hijacked = true
}
return c, rw, err
}
return nil, nil, errors.New("Wrapped ResponseWriter is not a Hijacker")
} | |
c182640 | w.writer.(http.CloseNotifier); ok {
c := notifier.CloseNotify()
return c
}
return make(chan bool)
} | |
c182641 | Option{func(o *options) {
o.dateFormat = f
}}
} | |
c182642 | := colorForStatus(statusCode)
methodColor := colorForMethod(method)
stdlogger.Printf("[HTTP] %v |%s %3d %s| %12v | %s |%s %s %-7s %s\n",
end.Format("2006/01/02 - 15:04:05"),
statusColor, statusCode, reset,
latency,
clientIP,
methodColor, reset, method,
r.URL.Path,
)
}
} | |
c182643 | {
inventory = skurepo.GetRegistry()
onceLoadInventoryPoller.Do(func() {
startTaskPollingForRegisteredSkus(taskCollection)
})
return
} | |
c182644 | *options) {
o.expiration = e
}}
} | |
c182645 | TokenOpt{func(o *options) {
o.claimer = c
}}
} | |
c182646 | TokenOpt{func(o *options) {
o.issuer = issuer
}}
} | |
c182647 | TokenOpt{func(o *options) {
o.user = user
}}
} | |
c182648 | *options) {
o.password = password
}}
} | |
c182649 | *options) {
o.extractor = e
}}
} | |
c182650 |
ExpiresAt: expiration.Unix(),
Issuer: o.issuer,
}))
if token, err := t.SignedString(secret); err == nil {
if h == nil {
w.Header().Add("Authorization", "Bearer "+token)
w.Write([]byte(token))
return
}
r = r.WithContext(context.WithValue(r.Context(), TokenKey, token))
h.ServeHTTP(w, r)
} else {
o.logger.Print("Error authenticating user:", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
})
} | |
c182651 | r.Context().Value(TokenKey).(string); ok {
return token
}
return ""
} | |
c182652 | := r.Context().Value(ClaimsKey).(jwt.Claims); ok {
return claims
}
return nil
} | |
c182653 | return t.Value
}
if len(t.Value) > 10 {
return fmt.Sprintf("%.25q...", t.Value)
}
return fmt.Sprintf("%q", t.Value)
} | |
c182654 |
Name: name,
input: input + "\n",
state: lexText,
handler: h,
}
} | |
c182655 | nil; {
state = state(l)
}
} | |
c182656 | := Token{t, l.input[l.Start:l.Pos]}
l.handler(tok)
l.Start = l.Pos
} | |
c182657 | l.next()) {
}
l.backup()
l.ignore()
} | |
c182658 | r, l.Width = utf8.DecodeRuneInString(l.remaining())
l.advance(l.Width)
return
} | |
c182659 | strings.Count(l.input[:l.Pos], "\n")
} | |
c182660 |
if lineoffset != -1 {
// calculate current offset from last line break
return l.Pos - lineoffset
}
// first line
return l.Pos
} | |
c182661 | l.Name, l.LineNum(), l.Offset())+format, args...)})
return nil
} | |
c182662 | field
// state function which lexes a field
l.Pos += len(optional)
l.emit(TokenOptional)
l.skipWhitespace()
return lexType
} else if strings.HasPrefix(remaining, openScope) { // Open scope
l.Pos += len(openScope)
l.emit(TokenOpenCurlyBracket)
} else if strings.HasPrefix(remaining, closeScope) { // Close scope
l.Pos += len(closeScope)
l.emit(TokenCloseCurlyBracket)
} else {
switch r := l.next(); {
case r == eof: // reached EOF?
l.emit(TokenEOF)
break OUTER
default:
l.errorf("unknown token: %#v", string(r))
}
}
}
// Stops the run loop
return nil
} | |
c182663 | advances the scanner
if index := strings.Index(l.remaining(), "\n"); index > 0 {
l.Pos += index
} else {
l.Pos += len(l.remaining())
// l.emit(TokenComment)
// break
}
// emit the comment string
l.emit(TokenComment)
l.skipWhitespace()
// }
// continue on scanner
return lexText
} | |
c182664 | = TupleType{namespace, name, ns_hash, hash, make([][]Field, 0), make(map[string]int)}
return
} | |
c182665 | fields)
for _, field := range fields {
t.fields[field.Name] = len(t.fields)
}
} | |
c182666 | exists := t.fields[field]
return exists
} | |
c182667 |
offset, exists = t.fields[field]
return
} | |
c182668 | {
vers[i] = Version{uint8(i + 1), t.versions[i]}
}
return
} | |
c182669 | == nil {
s.PrivateMetaData = make(map[string]interface{})
}
s.PrivateMetaData[name] = value
} | |
c182670 | s.MetaData == nil {
s.MetaData = make(map[string]interface{})
}
s.MetaData[name] = value
} | |
c182671 | Profile: s.Profile,
CallerName: s.CallerName,
MetaData: s.MetaData,
}
s.mutex.RUnlock()
return rt
} | |
c182672 | s.Status == b.Status &&
s.Profile == b.Profile &&
s.CallerName == b.CallerName)
} | |
c182673 | verbSet[Verb(r.Method)]; ok {
h.ServeHTTP(w, r)
} else {
w.WriteHeader(http.StatusBadRequest)
}
})
} | |
c182674 |
}
// write type code
b.buffer[b.pos] = byte(UnsignedInt8Code.OpCode)
// write value
b.buffer[b.pos+1] = byte(value)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 2
return 2, nil
} | |
c182675 |
}
// write type code
b.buffer[b.pos] = byte(Int8Code.OpCode)
// write value
b.buffer[b.pos+1] = byte(value)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 2
return 2, nil
} | |
c182676 |
return 2, nil
}
// write value
// length check performed by xbinary
wrote, err = xbinary.LittleEndian.PutUint16(b.buffer, b.pos+1, value)
if err != nil {
return 0, err
}
// write type code
b.buffer[b.pos] = byte(UnsignedShort16Code.OpCode)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 3
// wrote 3 bytes
return 3, nil
} | |
c182677 | byte(Short8Code.OpCode)
// write value
b.buffer[b.pos+1] = byte(value)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 2
return 2, nil
}
// write value
// length check performed by xbinary
wrote, err = xbinary.LittleEndian.PutInt16(b.buffer, b.pos+1, value)
if err != nil {
return 0, err
}
// write type code
b.buffer[b.pos] = byte(Short16Code.OpCode)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 3
// wrote 3 bytes
return 3, nil
} | |
c182678 | field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 3
// wrote 3 bytes
return 3, nil
}
// write value
// length check performed by xbinary
wrote, err = xbinary.LittleEndian.PutUint32(b.buffer, b.pos+1, value)
if err != nil {
return 0, err
}
// write type code
b.buffer[b.pos] = byte(UnsignedInt32Code.OpCode)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 5
// wrote 5 bytes
return 5, nil
} | |
c182679 | = byte(Int16Code.OpCode)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 3
// wrote 3 bytes
return 3, nil
}
// write value
// length check performed by xbinary
wrote, err = xbinary.LittleEndian.PutInt32(b.buffer, b.pos+1, value)
if err != nil {
return 0, err
}
// write type code
b.buffer[b.pos] = byte(Int32Code.OpCode)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 5
// wrote 5 bytes
return 5, nil
} | |
c182680 |
// write value
// length check performed by xbinary
wrote, err = xbinary.LittleEndian.PutUint32(b.buffer, b.pos+1, uint32(value))
if err != nil {
return 0, err
}
// write type code
b.buffer[b.pos] = byte(UnsignedLong32Code.OpCode)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 5
// wrote 5 bytes
return 5, nil
}
// write value
// length check performed by xbinary
wrote, err = xbinary.LittleEndian.PutUint64(b.buffer, b.pos+1, value)
if err != nil {
return 0, err
}
// write type code
b.buffer[b.pos] = byte(UnsignedLong64Code.OpCode)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 9
// wrote 9 bytes
return 9, nil
} | |
c182681 | {
// write value
// length check performed by xbinary
wrote, err = xbinary.LittleEndian.PutInt32(b.buffer, b.pos+1, int32(value))
if err != nil {
return 0, err
}
// write type code
b.buffer[b.pos] = byte(Long32Code.OpCode)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 5
// wrote 5 bytes
return 5, nil
}
// write value
// length check performed by xbinary
wrote, err = xbinary.LittleEndian.PutInt64(b.buffer, b.pos+1, value)
if err != nil {
return 0, err
}
// write type code
b.buffer[b.pos] = byte(Long64Code.OpCode)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 9
// wrote 9 bytes
return 9, nil
} | |
c182682 | return &packageList{make(map[string]Package), lock}
} | |
c182683 | nil {
return 0, err
}
// write type code
b.buffer[b.pos] = byte(FloatCode.OpCode)
// set field offset
b.offsets[field] = b.pos
// incr pos
b.pos += 5
return 5, nil
} | |
c182684 |
m.Use(ContextRender("", RenderOptions{
Extensions: []string{".html", ".tmpl", "tpl"},
}))
m.MapTo(r, (*Routes)(nil))
m.Action(r.Handle)
return &ClassicMartini{m, r}
} | |
c182685 |
return Option{func(o *options) {
o.languages = tags
}}
} | |
c182686 | *options) {
o.session = s
}}
} | |
c182687 | ok {
return v
}
return ContextValue{}
} | |
c182688 |
if url == "" {
url = "/"
}
if url[0] != '/' {
url = "/" + url
}
return prefix + data.Current.String() + url
} | |
c182689 | iniitialied")
return
}
return get_size()
} | |
c182690 | nil {
if err = json.Unmarshal(provisionHostInfoBytes, &provisionHostInfo); err == nil {
if len(provisionHostInfo.Data) > firstRecordIndex {
requestID = provisionHostInfo.Data[firstRecordIndex].RequestID
} else {
lo.G.Error("no request id found in: ", provisionHostInfo)
}
} else {
lo.G.Error("error unmarshalling: ", err, meta)
lo.G.Error("metadata: ", meta)
}
} else {
lo.G.Error("error marshalling: ", err)
}
return
} | |
c182691 | // write value
xbinary.LittleEndian.PutString(b.buffer, b.pos+5, value)
// write type code
b.buffer[b.pos] = byte(String32Code.OpCode)
wrote += 5 + size
} else {
if b.available() < size+9 {
return 0, xbinary.ErrOutOfRange
}
// write length
xbinary.LittleEndian.PutUint64(b.buffer, b.pos+1, uint64(size))
// write value
xbinary.LittleEndian.PutString(b.buffer, b.pos+9, value)
// write type code
b.buffer[b.pos] = byte(String64Code.OpCode)
wrote += 9 + size
}
b.offsets[field] = b.pos
b.pos += wrote
return
} | |
c182692 | // return error if there is one
if err := LoadDirectory(fi.Name(), parser); err != nil {
return err
}
case false:
// All schema files should end with .nt
if !strings.HasSuffix(fi.Name(), ".ent") {
break
}
// Read the file
if _, err := LoadFile(filepath.Join(dir, fi.Name()), parser); err != nil {
return err
}
}
}
} else if err == io.EOF {
// If there are no more files in the directory, break.
break
} else {
// If there is any other error, return it.
return err
}
}
// If you have reached this far, you are done.
return nil
} | |
c182693 | return Package{}, err
}
// convert to string and load
return parser.Parse(file.Name(), string(bytes))
} | |
c182694 | string) (Package, error) {
return parser.Parse(name, text)
} | |
c182695 | DefaultMaxSize, bytes.NewBuffer(buf), bufio.NewReader(r)}
} | |
c182696 | {
var buf []byte
return decoder{reg, maxSize, bytes.NewBuffer(buf), bufio.NewReader(r)}
} | |
c182697 | nil {
stack := debug.Stack()
timestamp := time.Now().Format(o.dateFormat)
message := fmt.Sprintf("%s - %s\n%s\n", timestamp, rec, stack)
o.logger.Print(message)
w.WriteHeader(http.StatusInternalServerError)
if !o.showStack {
message = "Internal Server Error"
}
w.Write([]byte(message))
}
}()
h.ServeHTTP(w, r)
})
} | |
c182698 | err error) {
return s.FakeVApp, s.ErrUnDeployFake
} | |
c182699 |
return &s.FakeVApp.Tasks.Task, s.ErrDeployFake
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.