_id
stringlengths 2
7
| title
stringlengths 1
118
| partition
stringclasses 3
values | text
stringlengths 52
85.5k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q182500 | Search | test | func (c *Client) Search(term string) ([]RantModel, error) {
url := fmt.Sprintf(SEARCH_PATH, API, term, APP_VERSION)
res, err := http.Get(url)
if err != nil {
return nil, err
}
var data SearchResponse
json.NewDecoder(res.Body).Decode(&data)
if !data.Success && data.Error != "" {
return nil, errors.New(data.Error)
}
return data.Rants, nil
} | go | {
"resource": ""
} |
q182501 | Surprise | test | func (c *Client) Surprise() (RantModel, error) {
url := fmt.Sprintf(SURPRISE_PATH, API, APP_VERSION)
res, err := http.Get(url)
if err != nil {
return RantModel{}, err
}
var data RantResponse
json.NewDecoder(res.Body).Decode(&data)
if !data.Success && data.Error != "" {
return RantModel{}, errors.New(data.Error)
}
return data.Rant, nil
} | go | {
"resource": ""
} |
q182502 | WeeklyRants | test | func (c *Client) WeeklyRants() ([]RantModel, error) {
url := fmt.Sprintf(WEEKLY_PATH, API, APP_VERSION)
res, err := http.Get(url)
if err != nil {
return nil, err
}
var data RantsResponse
json.NewDecoder(res.Body).Decode(&data)
if !data.Success && data.Error != "" {
return nil, errors.New(data.Error)
}
return data.Rants, nil
} | go | {
"resource": ""
} |
q182503 | getUserId | test | func getUserId(username string) (int, error) {
url := fmt.Sprintf(USER_ID_PATH, API, username, APP_VERSION)
res, err := http.Get(url)
if err != nil {
return 0, err
}
var data GetUserIdResponse
json.NewDecoder(res.Body).Decode(&data)
if !data.Success && data.Error != "" {
return 0, errors.New(data.Error)
}
return data.UserId, nil
} | go | {
"resource": ""
} |
q182504 | Shutdown | test | func (rs *ReplValueStore) Shutdown(ctx context.Context) error {
rs.ringLock.Lock()
if rs.ringServerExitChan != nil {
close(rs.ringServerExitChan)
rs.ringServerExitChan = nil
}
rs.storesLock.Lock()
for addr, stc := range rs.stores {
if err := stc.store.Shutdown(ctx); err != nil {
rs.logDebug("replValueStore: error during shutdown of store %s: %s", addr, err)
}
delete(rs.stores, addr)
select {
case <-ctx.Done():
rs.storesLock.Unlock()
return ctx.Err()
default:
}
}
rs.storesLock.Unlock()
rs.ringLock.Unlock()
return nil
} | go | {
"resource": ""
} |
q182505 | FExists | test | func FExists(name string) bool {
if _, err := os.Stat(name); os.IsNotExist(err) {
return false
}
return true
} | go | {
"resource": ""
} |
q182506 | outbound | test | func (m *MessageStream) outbound() {
for {
select {
case <-m.Shutdown:
log.Infof("Closing OpenFlow message stream.")
m.conn.Close()
return
case msg := <-m.Outbound:
// Forward outbound messages to conn
data, _ := msg.MarshalBinary()
if _, err := m.conn.Write(data); err != nil {
log.Warnln("OutboundError:", err)
m.Error <- err
m.Shutdown <- true
}
log.Debugf("Sent(%d): %v", len(data), data)
}
}
} | go | {
"resource": ""
} |
q182507 | parse | test | func (m *MessageStream) parse() {
for {
b := <-m.pool.Full
log.Debugf("Rcvd: %v", b.Bytes())
msg, err := m.parser.Parse(b.Bytes())
// Log all message parsing errors.
if err != nil {
log.Print(err)
}
m.Inbound <- msg
b.Reset()
m.pool.Empty <- b
}
} | go | {
"resource": ""
} |
q182508 | Group | test | func (dom *Domain) Group(name string, members []*Account) *Group {
return &Group{Domain: dom, Name: name, Members: members}
} | go | {
"resource": ""
} |
q182509 | Groups | test | func (dom *Domain) Groups() ([]*Group, error) {
var vl valueList
err := dom.cgp.request(listGroups{Domain: dom.Name}, &vl)
if err != nil {
return []*Group{}, err
}
vals := vl.compact()
grps := make([]*Group, len(vals))
for i, v := range vals {
g, err := dom.GetGroup(v)
if err != nil {
return grps, err
}
grps[i] = g
}
return grps, nil
} | go | {
"resource": ""
} |
q182510 | GetGroup | test | func (dom *Domain) GetGroup(name string) (*Group, error) {
var d dictionary
err := dom.cgp.request(getGroup{Name: fmt.Sprintf("%s@%s", name, dom.Name)}, &d)
if err != nil {
return &Group{}, err
}
memStr := d.toMap()["Members"]
var mems []*Account
dec := xml.NewDecoder(bytes.NewBufferString(memStr))
for {
var a string
err := dec.Decode(&a)
if err == io.EOF {
break
}
if err != nil {
return dom.Group(name, mems), err
}
if a == "" {
continue
}
mems = append(mems, dom.Account(a))
}
return dom.Group(name, mems), nil
} | go | {
"resource": ""
} |
q182511 | Reticence | test | func Reticence(str string, length int) string {
if length > len(str) {
return str
}
var i int
F:
for i = len(str) - 1; i >= 0; i-- {
switch str[i] {
case ' ', ',', '?', ';', ':', '\'', '"', '!':
if i <= length {
break F
}
case '.':
if i-2 >= 0 {
s := str[i-2 : i]
if s == ".." {
i = i - 2
if i <= length {
break F
}
}
}
if i <= length {
break F
}
}
}
if i-1 > 0 {
switch str[i-1] {
case ' ', ',', '?', ';', ':', '\'', '"', '!':
i--
case '.':
if i-2 > 0 && str[i-2:i] == ".." {
i -= 3
}
}
}
if i >= 2 {
if i+3 >= len(str) {
return str
}
return str[:i] + "..."
}
if length >= 2 && length < len(str) {
if length+3 >= len(str) {
return str
}
return str[:length] + "..."
}
return str
} | go | {
"resource": ""
} |
q182512 | CheckPassword | test | func CheckPassword(pass string, min, max int) error {
if len(pass) < min || len(pass) > max {
return e.New(ErrInvalidPassLength)
}
for _, r := range pass {
if !unicode.IsGraphic(r) {
return e.New(ErrInvalidPassChar)
}
}
return nil
} | go | {
"resource": ""
} |
q182513 | CleanUrl | test | func CleanUrl(rawurl string, min, max int) (string, error) {
err := CheckUrl(rawurl, min, max)
if err != nil {
return "", e.Forward(err)
}
u, err := url.Parse(rawurl)
if err != nil {
return "", e.Push(e.New(ErrInvUrl), err)
}
if u.Scheme == "" {
return u.String(), e.New(ErrNoScheme)
}
return u.String(), nil
} | go | {
"resource": ""
} |
q182514 | NewParameter | test | func NewParameter(name string, value reflect.Value) *Parameter {
parameter := Parameter{
Name: name,
Value: value,
}
return ¶meter
} | go | {
"resource": ""
} |
q182515 | MakeParams | test | func MakeParams(fieldCount int) *Params {
return &Params{
make(map[string]*Parameter),
make([]*Parameter, 0, fieldCount),
}
} | go | {
"resource": ""
} |
q182516 | Parse | test | func (p *Params) Parse(pvalue *reflect.Value) error {
vtype := pvalue.Type().Elem()
for idx := 0; idx < vtype.NumField(); idx++ {
field := vtype.Field(idx)
value := pvalue.Elem().Field(idx)
if value.Kind() == reflect.Slice {
value.Set(reflect.MakeSlice(value.Type(), 0, 0))
}
parameter := NewParameter(field.Name, value)
if err := parameter.DiscoverProperties(field.Tag); err != nil {
return err
}
if err := p.Set(parameter.Name, parameter); err != nil {
return err
}
if parameter.Alias != "" {
if err := p.Set(parameter.Alias, parameter); err != nil {
return err
}
}
p.Listing = append(p.Listing, parameter)
}
return nil
} | go | {
"resource": ""
} |
q182517 | Email | test | func (f Forwarder) Email() string {
return fmt.Sprintf("%s@%s", f.Name, f.Domain.Name)
} | go | {
"resource": ""
} |
q182518 | Forwarder | test | func (dom *Domain) Forwarder(name, to string) *Forwarder {
return &Forwarder{Domain: dom, Name: name, To: to}
} | go | {
"resource": ""
} |
q182519 | Forwarders | test | func (dom *Domain) Forwarders() ([]*Forwarder, error) {
var vl valueList
err := dom.cgp.request(listForwarders{Param: dom.Name}, &vl)
if err != nil {
return []*Forwarder{}, err
}
vals := vl.compact()
fs := make([]*Forwarder, len(vals))
for i, v := range vals {
f, err := dom.GetForwarder(v)
if err != nil {
return fs, err
}
fs[i] = f
}
return fs, err
} | go | {
"resource": ""
} |
q182520 | GetForwarder | test | func (dom *Domain) GetForwarder(name string) (*Forwarder, error) {
var f string
err := dom.cgp.request(getForwarder{Param: fmt.Sprintf("%s@%s", name, dom.Name)}, &f)
if err != nil {
return &Forwarder{}, err
}
return &Forwarder{Domain: dom, Name: name, To: f}, nil
} | go | {
"resource": ""
} |
q182521 | New | test | func New(url, user, pass string) *CGP {
return &CGP{url: url, user: user, pass: pass}
} | go | {
"resource": ""
} |
q182522 | EscapeCommaSeparated | test | func EscapeCommaSeparated(in ...string) string {
var out string
for i, str := range in {
escaped := strings.Replace(url.QueryEscape(str), "%2F", "%252F", -1)
escaped = strings.Replace(escaped, "\"", "%22", -1)
escaped = strings.Replace(escaped, " ", "%20", -1)
out += escaped
if i < len(in)-1 {
out += ","
}
}
return out
} | go | {
"resource": ""
} |
q182523 | Alias | test | func (acc *Account) Alias(name string) *Alias {
return &Alias{account: acc, Name: name}
} | go | {
"resource": ""
} |
q182524 | Email | test | func (a Alias) Email() string {
return fmt.Sprintf("%s@%s", a.Name, a.account.Domain.Name)
} | go | {
"resource": ""
} |
q182525 | Aliases | test | func (acc *Account) Aliases() ([]*Alias, error) {
var vl valueList
err := acc.Domain.cgp.request(listAliases{Param: fmt.Sprintf("%s@%s", acc.Name, acc.Domain.Name)}, &vl)
if err != nil {
return []*Alias{}, err
}
vals := vl.compact()
as := make([]*Alias, len(vals))
for i, v := range vals {
as[i] = acc.Alias(v)
}
return as, nil
} | go | {
"resource": ""
} |
q182526 | RealName | test | func (a Account) RealName() (string, error) {
var d dictionary
err := a.Domain.cgp.request(getAccountSettings{Account: a.Email()}, &d)
if err != nil {
return "", err
}
return d.toMap()["RealName"], nil
} | go | {
"resource": ""
} |
q182527 | Email | test | func (a Account) Email() string {
return fmt.Sprintf("%s@%s", a.Name, a.Domain.Name)
} | go | {
"resource": ""
} |
q182528 | Account | test | func (dom *Domain) Account(name string) *Account {
return &Account{Domain: dom, Name: name}
} | go | {
"resource": ""
} |
q182529 | Accounts | test | func (dom *Domain) Accounts() ([]*Account, error) {
var al accountList
err := dom.cgp.request(listAccounts{Domain: dom.Name}, &al)
if err != nil {
return []*Account{}, err
}
keys := al.SubKeys
as := make([]*Account, len(keys))
for i, k := range keys {
as[i] = dom.Account(k.Name)
}
return as, nil
} | go | {
"resource": ""
} |
q182530 | Exists | test | func (dom Domain) Exists() (bool, error) {
var d dictionary
err := dom.cgp.request(getDomainSettings{Domain: dom.Name}, &d)
if _, ok := err.(SOAPNotFoundError); ok {
return false, nil
}
if err != nil {
return false, err
}
return true, nil
} | go | {
"resource": ""
} |
q182531 | Aliases | test | func (dom Domain) Aliases() ([]string, error) {
var vl valueList
err := dom.cgp.request(getDomainAliases{Domain: dom.Name}, &vl)
if err != nil {
return []string{}, err
}
return vl.compact(), nil
} | go | {
"resource": ""
} |
q182532 | Domain | test | func (cgp *CGP) Domain(name string) *Domain {
return &Domain{cgp: cgp, Name: name}
} | go | {
"resource": ""
} |
q182533 | Domains | test | func (cgp *CGP) Domains() ([]*Domain, error) {
var vl valueList
err := cgp.request(listDomains{}, &vl)
if err != nil {
return []*Domain{}, err
}
vals := vl.SubValues
ds := make([]*Domain, len(vals))
for i, d := range vals {
ds[i] = cgp.Domain(d)
}
return ds, nil
} | go | {
"resource": ""
} |
q182534 | New | test | func New(info Info, publicMsg ...interface{}) Err {
return newErr(debug.Stack(), nil, false, info, publicMsg)
} | go | {
"resource": ""
} |
q182535 | Wrap | test | func Wrap(wrapErr error, info Info, publicMsg ...interface{}) Err {
if wrapErr == nil {
return nil
}
if info == nil {
info = Info{}
}
if errsErr, isErr := IsErr(wrapErr); isErr {
if errStructErr, isErrsErr := errsErr.(*err); isErrsErr {
errStructErr.mergeIn(info, publicMsg)
return errStructErr
}
return errsErr
}
return newErr(debug.Stack(), wrapErr, false, info, publicMsg)
} | go | {
"resource": ""
} |
q182536 | mergeIn | test | func (e *err) mergeIn(info Info, publicMsgParts []interface{}) {
for key, val := range info {
for e.info[key] != nil {
key = key + "_duplicate"
}
e.info[key] = val
}
publicMsgPrefix := concatArgs(publicMsgParts...)
if publicMsgPrefix == "" {
// do nothing
} else if e.publicMsg == "" {
e.publicMsg = publicMsgPrefix
} else {
e.publicMsg = publicMsgPrefix + " - " + e.publicMsg
}
} | go | {
"resource": ""
} |
q182537 | wrappedErrStr | test | func (e *err) wrappedErrStr() string {
if e == nil {
return ""
}
if e.wrappedErr == nil {
return ""
}
return e.wrappedErr.Error()
} | go | {
"resource": ""
} |
q182538 | concatArgs | test | func concatArgs(args ...interface{}) string {
res := fmt.Sprintln(args...)
return res[0 : len(res)-1] // Remove newline at the end
} | go | {
"resource": ""
} |
q182539 | MailingList | test | func (dom *Domain) MailingList(name string) *MailingList {
return &MailingList{Domain: dom, Name: name}
} | go | {
"resource": ""
} |
q182540 | Subscriber | test | func (ml *MailingList) Subscriber(email, name string) *Subscriber {
return &Subscriber{MailingList: ml, Email: email, RealName: name}
} | go | {
"resource": ""
} |
q182541 | Subscribers | test | func (ml *MailingList) Subscribers() ([]*Subscriber, error) {
var res readSubscribersResponse
err := ml.Domain.cgp.request(readSubscribers{Name: fmt.Sprintf("%s@%s", ml.Name, ml.Domain.Name)}, &res)
if err != nil {
return []*Subscriber{}, err
}
ds := res.SubValues[1].SubValues
subs := make([]*Subscriber, len(ds))
for i, d := range ds {
m := d.toMap()
subs[i] = ml.Subscriber(m["Sub"], m["RealName"])
}
return subs, nil
} | go | {
"resource": ""
} |
q182542 | MailingLists | test | func (dom *Domain) MailingLists() ([]*MailingList, error) {
var vl valueList
err := dom.cgp.request(listLists{Domain: dom.Name}, &vl)
if err != nil {
return []*MailingList{}, err
}
vals := vl.compact()
mls := make([]*MailingList, len(vals))
for i, v := range vals {
mls[i] = dom.MailingList(v)
}
return mls, nil
} | go | {
"resource": ""
} |
q182543 | NewByteKeyItem | test | func NewByteKeyItem(k []byte) unsafe.Pointer {
itm := byteKeyItem(k)
return unsafe.Pointer(&itm)
} | go | {
"resource": ""
} |
q182544 | CompareBytes | test | func CompareBytes(this, that unsafe.Pointer) int {
thisItem := (*byteKeyItem)(this)
thatItem := (*byteKeyItem)(that)
return bytes.Compare([]byte(*thisItem), []byte(*thatItem))
} | go | {
"resource": ""
} |
q182545 | CompareInt | test | func CompareInt(this, that unsafe.Pointer) int {
thisItem := (*intKeyItem)(this)
thatItem := (*intKeyItem)(that)
return int(*thisItem - *thatItem)
} | go | {
"resource": ""
} |
q182546 | Malloc | test | func Malloc(l int) unsafe.Pointer {
if Debug {
atomic.AddUint64(&stats.allocs, 1)
}
return C.mm_malloc(C.size_t(l))
} | go | {
"resource": ""
} |
q182547 | Free | test | func Free(p unsafe.Pointer) {
if Debug {
atomic.AddUint64(&stats.frees, 1)
}
C.mm_free(p)
} | go | {
"resource": ""
} |
q182548 | Stats | test | func Stats() string {
mu.Lock()
defer mu.Unlock()
buf := C.mm_stats()
s := "==== Stats ====\n"
if Debug {
s += fmt.Sprintf("Mallocs = %d\n"+
"Frees = %d\n", stats.allocs, stats.frees)
}
if buf != nil {
s += C.GoString(buf)
C.free(unsafe.Pointer(buf))
}
return s
} | go | {
"resource": ""
} |
q182549 | FreeOSMemory | test | func FreeOSMemory() error {
errCode := int(C.mm_free2os())
if errCode != 0 {
return fmt.Errorf("status: %d", errCode)
}
return nil
} | go | {
"resource": ""
} |
q182550 | Add | test | func (s *Segment) Add(itm unsafe.Pointer) {
itemLevel := s.builder.store.NewLevel(s.rand.Float32)
x := s.builder.store.newNode(itm, itemLevel)
s.sts.AddInt64(&s.sts.nodeAllocs, 1)
s.sts.AddInt64(&s.sts.levelNodesCount[itemLevel], 1)
s.sts.AddInt64(&s.sts.usedBytes, int64(s.builder.store.Size(x)))
for l := 0; l <= itemLevel; l++ {
if s.tail[l] != nil {
s.tail[l].setNext(l, x, false)
} else {
s.head[l] = x
}
s.tail[l] = x
}
if s.callb != nil {
s.callb(x)
}
} | go | {
"resource": ""
} |
q182551 | NewSegment | test | func (b *Builder) NewSegment() *Segment {
seg := &Segment{tail: make([]*Node, MaxLevel+1),
head: make([]*Node, MaxLevel+1), builder: b,
rand: rand.New(rand.NewSource(int64(rand.Int()))),
}
seg.sts.IsLocal(true)
return seg
} | go | {
"resource": ""
} |
q182552 | Assemble | test | func (b *Builder) Assemble(segments ...*Segment) *Skiplist {
tail := make([]*Node, MaxLevel+1)
head := make([]*Node, MaxLevel+1)
for _, seg := range segments {
for l := 0; l <= MaxLevel; l++ {
if tail[l] != nil && seg.head[l] != nil {
tail[l].setNext(l, seg.head[l], false)
} else if head[l] == nil && seg.head[l] != nil {
head[l] = seg.head[l]
}
if seg.tail[l] != nil {
tail[l] = seg.tail[l]
}
}
}
for l := 0; l <= MaxLevel; l++ {
if head[l] != nil {
b.store.head.setNext(l, head[l], false)
}
if tail[l] != nil {
tail[l].setNext(l, b.store.tail, false)
}
}
for _, seg := range segments {
b.store.Stats.Merge(&seg.sts)
}
return b.store
} | go | {
"resource": ""
} |
q182553 | CompareNodeTable | test | func CompareNodeTable(a, b unsafe.Pointer) int {
return int(uintptr(a)) - int(uintptr(b))
} | go | {
"resource": ""
} |
q182554 | New | test | func New(hfn HashFn, kfn EqualKeyFn) *NodeTable {
nt := &NodeTable{
fastHT: make(map[uint32]uint64),
slowHT: make(map[uint32][]uint64),
hash: hfn,
keyEqual: kfn,
}
buf := dbInstances.MakeBuf()
defer dbInstances.FreeBuf(buf)
dbInstances.Insert(unsafe.Pointer(nt), CompareNodeTable, buf, &dbInstances.Stats)
return nt
} | go | {
"resource": ""
} |
q182555 | Stats | test | func (nt *NodeTable) Stats() string {
return fmt.Sprintf("\nFastHTCount = %d\n"+
"SlowHTCount = %d\n"+
"Conflicts = %d\n"+
"MemoryInUse = %d\n",
nt.fastHTCount, nt.slowHTCount, nt.conflicts, nt.MemoryInUse())
} | go | {
"resource": ""
} |
q182556 | MemoryInUse | test | func (nt *NodeTable) MemoryInUse() int64 {
return int64(approxItemSize * (nt.fastHTCount + nt.slowHTCount))
} | go | {
"resource": ""
} |
q182557 | Get | test | func (nt *NodeTable) Get(key []byte) unsafe.Pointer {
res := nt.find(key)
if res.status&ntFoundMask == ntFoundMask {
if res.status == ntFoundInFast {
return decodePointer(res.fastHTValue)
}
return decodePointer(res.slowHTValues[res.slowHTPos])
}
return nil
} | go | {
"resource": ""
} |
q182558 | Update | test | func (nt *NodeTable) Update(key []byte, nptr unsafe.Pointer) (updated bool, oldPtr unsafe.Pointer) {
res := nt.find(key)
if res.status&ntFoundMask == ntFoundMask {
// Found key, replace old pointer value with new one
updated = true
if res.status == ntFoundInFast {
oldPtr = decodePointer(res.fastHTValue)
nt.fastHT[res.hash] = encodePointer(nptr, res.hasConflict)
} else {
oldPtr = decodePointer(res.slowHTValues[res.slowHTPos])
res.slowHTValues[res.slowHTPos] = encodePointer(nptr, true)
}
} else {
// Insert new key
updated = false
newSlowValue := res.fastHTHasEntry && !res.hasConflict
// Key needs to be inserted into slowHT
if res.hasConflict || newSlowValue {
slowHTValues := nt.slowHT[res.hash]
slowHTValues = append(slowHTValues, encodePointer(nptr, false))
nt.slowHT[res.hash] = slowHTValues
// There is an entry already in the fastHT for same crc32 hash
// We have inserted first entry into the slowHT. Now mark conflict bit.
if newSlowValue {
nt.fastHT[res.hash] = encodePointer(decodePointer(nt.fastHT[res.hash]), true)
nt.conflicts++
}
nt.slowHTCount++
} else {
// Insert new item into fastHT
nt.fastHT[res.hash] = encodePointer(nptr, false)
nt.fastHTCount++
}
}
return
} | go | {
"resource": ""
} |
q182559 | Remove | test | func (nt *NodeTable) Remove(key []byte) (success bool, nptr unsafe.Pointer) {
res := nt.find(key)
if res.status&ntFoundMask == ntFoundMask {
success = true
if res.status == ntFoundInFast {
nptr = decodePointer(res.fastHTValue)
// Key needs to be removed from fastHT. For that we need to move
// an item present in slowHT and overwrite fastHT entry.
if res.hasConflict {
slowHTValues := nt.slowHT[res.hash]
v := slowHTValues[0] // New fastHT candidate
slowHTValues = append([]uint64(nil), slowHTValues[1:]...)
nt.slowHTCount--
var conflict bool
if len(slowHTValues) == 0 {
delete(nt.slowHT, res.hash)
nt.conflicts--
} else {
conflict = true
nt.slowHT[res.hash] = slowHTValues
}
nt.fastHT[res.hash] = encodePointer(decodePointer(v), conflict)
} else {
delete(nt.fastHT, res.hash)
nt.fastHTCount--
}
} else {
nptr = decodePointer(res.slowHTValues[res.slowHTPos])
// Remove key from slowHT
newSlowValue := append([]uint64(nil), res.slowHTValues[:res.slowHTPos]...)
if res.slowHTPos+1 != len(res.slowHTValues) {
newSlowValue = append(newSlowValue, res.slowHTValues[res.slowHTPos+1:]...)
}
nt.slowHTCount--
if len(newSlowValue) == 0 {
delete(nt.slowHT, res.hash)
nt.fastHT[res.hash] = encodePointer(decodePointer(nt.fastHT[res.hash]), false)
nt.conflicts--
} else {
nt.slowHT[res.hash] = newSlowValue
}
}
}
return
} | go | {
"resource": ""
} |
q182560 | Close | test | func (nt *NodeTable) Close() {
nt.fastHTCount = 0
nt.slowHTCount = 0
nt.conflicts = 0
nt.fastHT = make(map[uint32]uint64)
nt.slowHT = make(map[uint32][]uint64)
buf := dbInstances.MakeBuf()
defer dbInstances.FreeBuf(buf)
dbInstances.Delete(unsafe.Pointer(nt), CompareNodeTable, buf, &dbInstances.Stats)
} | go | {
"resource": ""
} |
q182561 | MemoryInUse | test | func MemoryInUse() (sz int64) {
buf := dbInstances.MakeBuf()
defer dbInstances.FreeBuf(buf)
iter := dbInstances.NewIterator(CompareNodeTable, buf)
for iter.SeekFirst(); iter.Valid(); iter.Next() {
db := (*NodeTable)(iter.Get())
sz += db.MemoryInUse()
}
return
} | go | {
"resource": ""
} |
q182562 | debugMarkFree | test | func debugMarkFree(n *Node) {
var block []byte
l := int(nodeTypes[n.level].Size())
sh := (*reflect.SliceHeader)(unsafe.Pointer(&block))
sh.Data = uintptr(unsafe.Pointer(n))
sh.Len = l
sh.Cap = l
copy(block, freeBlockContent)
} | go | {
"resource": ""
} |
q182563 | Seek | test | func (it *Iterator) Seek(bs []byte) {
itm := it.snap.db.newItem(bs, false)
it.iter.Seek(unsafe.Pointer(itm))
it.skipUnwanted()
} | go | {
"resource": ""
} |
q182564 | Next | test | func (it *Iterator) Next() {
it.iter.Next()
it.count++
it.skipUnwanted()
if it.refreshRate > 0 && it.count > it.refreshRate {
it.Refresh()
it.count = 0
}
} | go | {
"resource": ""
} |
q182565 | Refresh | test | func (it *Iterator) Refresh() {
if it.Valid() {
itm := it.snap.db.ptrToItem(it.GetNode().Item())
it.iter.Close()
it.iter = it.snap.db.store.NewIterator(it.snap.db.iterCmp, it.buf)
it.iter.Seek(unsafe.Pointer(itm))
}
} | go | {
"resource": ""
} |
q182566 | Close | test | func (it *Iterator) Close() {
it.snap.Close()
it.snap.db.store.FreeBuf(it.buf)
it.iter.Close()
} | go | {
"resource": ""
} |
q182567 | NewIterator | test | func (m *Nitro) NewIterator(snap *Snapshot) *Iterator {
if !snap.Open() {
return nil
}
buf := snap.db.store.MakeBuf()
return &Iterator{
snap: snap,
iter: m.store.NewIterator(m.iterCmp, buf),
buf: buf,
}
} | go | {
"resource": ""
} |
q182568 | SeekFirst | test | func (mit *MergeIterator) SeekFirst() {
for _, it := range mit.iters {
it.SeekFirst()
if it.Valid() {
n := it.GetNode()
mit.h = append(mit.h, heapItem{iter: it, n: n})
}
}
heap.Init(&mit.h)
mit.Next()
} | go | {
"resource": ""
} |
q182569 | Next | test | func (mit *MergeIterator) Next() {
mit.curr = nil
if mit.h.Len() == 0 {
return
}
o := heap.Pop(&mit.h)
hi := o.(heapItem)
mit.curr = hi.n
hi.iter.Next()
if hi.iter.Valid() {
hi.n = hi.iter.GetNode()
heap.Push(&mit.h, hi)
}
} | go | {
"resource": ""
} |
q182570 | Seek | test | func (mit *MergeIterator) Seek(itm unsafe.Pointer) bool {
var found bool
for _, it := range mit.iters {
if it.Seek(itm) {
found = true
}
if it.Valid() {
n := it.GetNode()
mit.h = append(mit.h, heapItem{iter: it, n: n})
}
}
heap.Init(&mit.h)
mit.Next()
return found
} | go | {
"resource": ""
} |
q182571 | Keys | test | func (l *NodeList) Keys() (keys [][]byte) {
node := l.head
for node != nil {
key := (*Item)(node.Item()).Bytes()
keys = append(keys, key)
node = node.GetLink()
}
return
} | go | {
"resource": ""
} |
q182572 | Remove | test | func (l *NodeList) Remove(key []byte) *skiplist.Node {
var prev *skiplist.Node
node := l.head
for node != nil {
nodeKey := (*Item)(node.Item()).Bytes()
if bytes.Equal(nodeKey, key) {
if prev == nil {
l.head = node.GetLink()
return node
}
prev.SetLink(node.GetLink())
return node
}
prev = node
node = node.GetLink()
}
return nil
} | go | {
"resource": ""
} |
q182573 | Add | test | func (l *NodeList) Add(node *skiplist.Node) {
node.SetLink(l.head)
l.head = node
} | go | {
"resource": ""
} |
q182574 | NewWithConfig | test | func NewWithConfig(cfg Config) *Skiplist {
if runtime.GOARCH != "amd64" {
cfg.UseMemoryMgmt = false
}
s := &Skiplist{
Config: cfg,
barrier: newAccessBarrier(cfg.UseMemoryMgmt, cfg.BarrierDestructor),
}
s.newNode = func(itm unsafe.Pointer, level int) *Node {
return allocNode(itm, level, cfg.Malloc)
}
if cfg.UseMemoryMgmt {
s.freeNode = func(n *Node) {
if Debug {
debugMarkFree(n)
}
cfg.Free(unsafe.Pointer(n))
}
} else {
s.freeNode = func(*Node) {}
}
head := allocNode(minItem, MaxLevel, nil)
tail := allocNode(maxItem, MaxLevel, nil)
for i := 0; i <= MaxLevel; i++ {
head.setNext(i, tail, false)
}
s.head = head
s.tail = tail
return s
} | go | {
"resource": ""
} |
q182575 | FreeNode | test | func (s *Skiplist) FreeNode(n *Node, sts *Stats) {
s.freeNode(n)
sts.AddInt64(&sts.nodeFrees, 1)
} | go | {
"resource": ""
} |
q182576 | MakeBuf | test | func (s *Skiplist) MakeBuf() *ActionBuffer {
return &ActionBuffer{
preds: make([]*Node, MaxLevel+1),
succs: make([]*Node, MaxLevel+1),
}
} | go | {
"resource": ""
} |
q182577 | Size | test | func (s *Skiplist) Size(n *Node) int {
return s.ItemSize(n.Item()) + n.Size()
} | go | {
"resource": ""
} |
q182578 | NewLevel | test | func (s *Skiplist) NewLevel(randFn func() float32) int {
var nextLevel int
for ; randFn() < p; nextLevel++ {
}
if nextLevel > MaxLevel {
nextLevel = MaxLevel
}
level := int(atomic.LoadInt32(&s.level))
if nextLevel > level {
if atomic.CompareAndSwapInt32(&s.level, int32(level), int32(level+1)) {
nextLevel = level + 1
} else {
nextLevel = level
}
}
return nextLevel
} | go | {
"resource": ""
} |
q182579 | Insert | test | func (s *Skiplist) Insert(itm unsafe.Pointer, cmp CompareFn,
buf *ActionBuffer, sts *Stats) (success bool) {
_, success = s.Insert2(itm, cmp, nil, buf, rand.Float32, sts)
return
} | go | {
"resource": ""
} |
q182580 | Insert2 | test | func (s *Skiplist) Insert2(itm unsafe.Pointer, inscmp CompareFn, eqCmp CompareFn,
buf *ActionBuffer, randFn func() float32, sts *Stats) (*Node, bool) {
itemLevel := s.NewLevel(randFn)
return s.Insert3(itm, inscmp, eqCmp, buf, itemLevel, false, sts)
} | go | {
"resource": ""
} |
q182581 | Insert3 | test | func (s *Skiplist) Insert3(itm unsafe.Pointer, insCmp CompareFn, eqCmp CompareFn,
buf *ActionBuffer, itemLevel int, skipFindPath bool, sts *Stats) (*Node, bool) {
token := s.barrier.Acquire()
defer s.barrier.Release(token)
x := s.newNode(itm, itemLevel)
retry:
if skipFindPath {
skipFindPath = false
} else {
if s.findPath(itm, insCmp, buf, sts) != nil ||
eqCmp != nil && compare(eqCmp, itm, buf.preds[0].Item()) == 0 {
s.freeNode(x)
return nil, false
}
}
// Set all next links for the node non-atomically
for i := 0; i <= int(itemLevel); i++ {
x.setNext(i, buf.succs[i], false)
}
// Now node is part of the skiplist
if !buf.preds[0].dcasNext(0, buf.succs[0], x, false, false) {
sts.AddUint64(&sts.insertConflicts, 1)
goto retry
}
// Add to index levels
for i := 1; i <= int(itemLevel); i++ {
fixThisLevel:
for {
nodeNext, deleted := x.getNext(i)
next := buf.succs[i]
// Update the node's next pointer at current level if required.
// This is the only thread which can modify next pointer at this level
// The dcas operation can fail only if another thread marked delete
if deleted || (nodeNext != next && !x.dcasNext(i, nodeNext, next, false, false)) {
goto finished
}
if buf.preds[i].dcasNext(i, next, x, false, false) {
break fixThisLevel
}
s.findPath(itm, insCmp, buf, sts)
}
}
finished:
sts.AddInt64(&sts.nodeAllocs, 1)
sts.AddInt64(&sts.levelNodesCount[itemLevel], 1)
sts.AddInt64(&sts.usedBytes, int64(s.Size(x)))
return x, true
} | go | {
"resource": ""
} |
q182582 | Delete | test | func (s *Skiplist) Delete(itm unsafe.Pointer, cmp CompareFn,
buf *ActionBuffer, sts *Stats) bool {
token := s.barrier.Acquire()
defer s.barrier.Release(token)
found := s.findPath(itm, cmp, buf, sts) != nil
if !found {
return false
}
delNode := buf.succs[0]
return s.deleteNode(delNode, cmp, buf, sts)
} | go | {
"resource": ""
} |
q182583 | DeleteNode | test | func (s *Skiplist) DeleteNode(n *Node, cmp CompareFn,
buf *ActionBuffer, sts *Stats) bool {
token := s.barrier.Acquire()
defer s.barrier.Release(token)
return s.deleteNode(n, cmp, buf, sts)
} | go | {
"resource": ""
} |
q182584 | GetRangeSplitItems | test | func (s *Skiplist) GetRangeSplitItems(nways int) []unsafe.Pointer {
var deleted bool
repeat:
var itms []unsafe.Pointer
var finished bool
l := int(atomic.LoadInt32(&s.level))
for ; l >= 0; l-- {
c := int(atomic.LoadInt64(&s.Stats.levelNodesCount[l]) + 1)
if c >= nways {
perSplit := c / nways
node := s.head
for j := 0; node != s.tail && !finished; j++ {
if j == perSplit {
j = -1
itms = append(itms, node.Item())
finished = len(itms) == nways-1
}
node, deleted = node.getNext(l)
if deleted {
goto repeat
}
}
break
}
}
return itms
} | go | {
"resource": ""
} |
q182585 | Bytes | test | func (itm *Item) Bytes() (bs []byte) {
l := itm.dataLen
dataOffset := uintptr(unsafe.Pointer(itm)) + itemHeaderSize
hdr := (*reflect.SliceHeader)(unsafe.Pointer(&bs))
hdr.Data = dataOffset
hdr.Len = int(l)
hdr.Cap = hdr.Len
return
} | go | {
"resource": ""
} |
q182586 | ItemSize | test | func ItemSize(p unsafe.Pointer) int {
itm := (*Item)(p)
return int(itemHeaderSize + uintptr(itm.dataLen))
} | go | {
"resource": ""
} |
q182587 | KVFromBytes | test | func KVFromBytes(bs []byte) (k, v []byte) {
klen := int(binary.LittleEndian.Uint16(bs[0:2]))
return bs[2 : 2+klen], bs[2+klen:]
} | go | {
"resource": ""
} |
q182588 | CompareKV | test | func CompareKV(a []byte, b []byte) int {
la := int(binary.LittleEndian.Uint16(a[0:2]))
lb := int(binary.LittleEndian.Uint16(b[0:2]))
return bytes.Compare(a[2:2+la], b[2:2+lb])
} | go | {
"resource": ""
} |
q182589 | Emit | test | func (e *EventController) Emit(b EventBody) (int, error) {
// int used to count the number of Handlers fired.
var i int
// We build an event struct to contain the Body and generate a Header.
event := Event{Header: generateHeader(), Body: b}
// Fire a gorountine for each handler.
// By design the is no waiting for any Handlers to complete
// before firing another. Therefore there is also no guarantee
// that any Handler will predictably fire before another one.
//
// Any synchronizing needs to be within the Handler.
for _, h := range e.Handlers {
i++
go h.HandleGomitEvent(event)
}
return i, nil
} | go | {
"resource": ""
} |
q182590 | UnregisterHandler | test | func (e *EventController) UnregisterHandler(n string) error {
e.handlerMutex.Lock()
delete(e.Handlers, n)
e.handlerMutex.Unlock()
return nil
} | go | {
"resource": ""
} |
q182591 | IsHandlerRegistered | test | func (e *EventController) IsHandlerRegistered(n string) bool {
_, x := e.Handlers[n]
return x
} | go | {
"resource": ""
} |
q182592 | CompareNitro | test | func CompareNitro(this unsafe.Pointer, that unsafe.Pointer) int {
thisItem := (*Nitro)(this)
thatItem := (*Nitro)(that)
return int(thisItem.id - thatItem.id)
} | go | {
"resource": ""
} |
q182593 | DefaultConfig | test | func DefaultConfig() Config {
var cfg Config
cfg.SetKeyComparator(defaultKeyCmp)
cfg.fileType = RawdbFile
cfg.useMemoryMgmt = false
cfg.refreshRate = defaultRefreshRate
return cfg
} | go | {
"resource": ""
} |
q182594 | Delete | test | func (w *Writer) Delete(bs []byte) (success bool) {
_, success = w.Delete2(bs)
return
} | go | {
"resource": ""
} |
q182595 | GetNode | test | func (w *Writer) GetNode(bs []byte) *skiplist.Node {
iter := w.store.NewIterator(w.iterCmp, w.buf)
defer iter.Close()
x := w.newItem(bs, false)
x.bornSn = w.getCurrSn()
if found := iter.SeekWithCmp(unsafe.Pointer(x), w.insCmp, w.existCmp); found {
return iter.GetNode()
}
return nil
} | go | {
"resource": ""
} |
q182596 | SetKeyComparator | test | func (cfg *Config) SetKeyComparator(cmp KeyCompare) {
cfg.keyCmp = cmp
cfg.insCmp = newInsertCompare(cmp)
cfg.iterCmp = newIterCompare(cmp)
cfg.existCmp = newExistCompare(cmp)
} | go | {
"resource": ""
} |
q182597 | UseMemoryMgmt | test | func (cfg *Config) UseMemoryMgmt(malloc skiplist.MallocFn, free skiplist.FreeFn) {
if runtime.GOARCH == "amd64" {
cfg.useMemoryMgmt = true
cfg.mallocFun = malloc
cfg.freeFun = free
}
} | go | {
"resource": ""
} |
q182598 | NewWithConfig | test | func NewWithConfig(cfg Config) *Nitro {
m := &Nitro{
snapshots: skiplist.New(),
gcsnapshots: skiplist.New(),
currSn: 1,
Config: cfg,
gcchan: make(chan *skiplist.Node, gcchanBufSize),
id: int(atomic.AddInt64(&dbInstancesCount, 1)),
}
m.freechan = make(chan *skiplist.Node, gcchanBufSize)
m.store = skiplist.NewWithConfig(m.newStoreConfig())
m.initSizeFuns()
buf := dbInstances.MakeBuf()
defer dbInstances.FreeBuf(buf)
dbInstances.Insert(unsafe.Pointer(m), CompareNitro, buf, &dbInstances.Stats)
return m
} | go | {
"resource": ""
} |
q182599 | MemoryInUse | test | func (m *Nitro) MemoryInUse() int64 {
storeStats := m.aggrStoreStats()
return storeStats.Memory + m.snapshots.MemoryInUse() + m.gcsnapshots.MemoryInUse()
} | go | {
"resource": ""
} |