_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q174500 | RemoveLogger | validation | func RemoveLogger(name string) {
lock.Lock()
delete(loggers, name)
if name == "default" {
defaultLogger = nil
}
lock.Unlock()
} | go | {
"resource": ""
} |
q174501 | WaitForAllUnprocessedRecords | validation | func WaitForAllUnprocessedRecords() {
lock.Lock()
var wg sync.WaitGroup
for _, logger := range loggers {
wg.Add(1)
go func(logger *Logger) {
logger.WaitForUnprocessedRecords()
wg.Done()
}(logger)
}
wg.Wait()
lock.Unlock()
} | go | {
"resource": ""
} |
q174502 | run | validation | func (logger *Logger) run() {
defer func() {
logger.WaitForUnprocessedRecords()
logger.closeHandlers()
}()
recordLoop:
for {
select {
case record := <-logger.recordChannel:
record.process(logger)
case state := <-logger.stateChannel:
switch state {
case stopped:
break recordLoop
case paused:... | go | {
"resource": ""
} |
q174503 | WaitForUnprocessedRecords | validation | func (logger *Logger) WaitForUnprocessedRecords() {
runtime.Gosched()
var (
diff uint64
diffPrev uint64
i uint8
)
for {
diff = atomic.LoadUint64(&logger.countIn) - atomic.LoadUint64(&logger.countOut)
if diff == diffPrev {
i++
}
if i >= 100 {
return
}
if diff > 0 {
diffPrev = di... | go | {
"resource": ""
} |
q174504 | SetBufferLength | validation | func (logger *Logger) SetBufferLength(length int) {
logger.lock.Lock()
if length == 0 {
logger.buffer = nil
} else if length != logger.buffer.Len() {
logger.buffer = ring.New(length)
}
logger.lock.Unlock()
} | go | {
"resource": ""
} |
q174505 | AddHandler | validation | func (logger *Logger) AddHandler(handler Handler) {
logger.lock.Lock()
logger.Handlers = append(logger.Handlers, handler)
logger.flushBuffer()
logger.lock.Unlock()
} | go | {
"resource": ""
} |
q174506 | ClearHandlers | validation | func (logger *Logger) ClearHandlers() {
logger.lock.Lock()
logger.closeHandlers()
logger.Handlers = make([]Handler, 0)
logger.flushBuffer()
logger.lock.Unlock()
} | go | {
"resource": ""
} |
q174507 | SetLevel | validation | func (logger *Logger) SetLevel(level Level) {
logger.lock.Lock()
logger.Level = level
logger.flushBuffer()
logger.lock.Unlock()
} | go | {
"resource": ""
} |
q174508 | log | validation | func (logger *Logger) log(level Level, format string, a ...interface{}) {
var message string
if format == "" {
message = fmt.Sprint(a...)
} else {
message = fmt.Sprintf(format, a...)
}
atomic.AddUint64(&logger.countIn, 1)
logger.recordChannel <- &Record{
Level: level,
Message: message,
Time: time.... | go | {
"resource": ""
} |
q174509 | Logf | validation | func (logger *Logger) Logf(level Level, format string, a ...interface{}) {
logger.log(level, format, a...)
} | go | {
"resource": ""
} |
q174510 | Log | validation | func (logger *Logger) Log(level Level, a ...interface{}) {
logger.log(level, "", a...)
} | go | {
"resource": ""
} |
q174511 | Emergencyf | validation | func (logger *Logger) Emergencyf(format string, a ...interface{}) {
logger.log(EMERGENCY, format, a...)
} | go | {
"resource": ""
} |
q174512 | Alertf | validation | func (logger *Logger) Alertf(format string, a ...interface{}) {
logger.log(ALERT, format, a...)
} | go | {
"resource": ""
} |
q174513 | Criticalf | validation | func (logger *Logger) Criticalf(format string, a ...interface{}) {
logger.log(CRITICAL, format, a...)
} | go | {
"resource": ""
} |
q174514 | Errorf | validation | func (logger *Logger) Errorf(format string, a ...interface{}) {
logger.log(ERROR, format, a...)
} | go | {
"resource": ""
} |
q174515 | Warningf | validation | func (logger *Logger) Warningf(format string, a ...interface{}) {
logger.log(WARNING, format, a...)
} | go | {
"resource": ""
} |
q174516 | Noticef | validation | func (logger *Logger) Noticef(format string, a ...interface{}) {
logger.log(NOTICE, format, a...)
} | go | {
"resource": ""
} |
q174517 | Infof | validation | func (logger *Logger) Infof(format string, a ...interface{}) {
logger.log(INFO, format, a...)
} | go | {
"resource": ""
} |
q174518 | Debugf | validation | func (logger *Logger) Debugf(format string, a ...interface{}) {
logger.log(DEBUG, format, a...)
} | go | {
"resource": ""
} |
q174519 | SetHandler | validation | func (e *Entry) SetHandler(h *Route) error {
if e.handler != nil {
return errors.New("Duplicate Route registration")
}
e.handler = h
return nil
} | go | {
"resource": ""
} |
q174520 | SetMethodHandler | validation | func (e *Entry) SetMethodHandler(method string, h *Route) error {
if e.GetHandler(method) != nil {
return errors.New("Duplicate Route registration")
}
e.handlers[method] = h
return nil
} | go | {
"resource": ""
} |
q174521 | GetHandler | validation | func (e *Entry) GetHandler(method string) *Route {
handler := e.handlers[method]
if handler == nil {
handler = e.handler
}
return handler
} | go | {
"resource": ""
} |
q174522 | getChildEntry | validation | func (e *Entry) getChildEntry(pat string) *Entry {
for _, entry := range e.entries {
if pat == entry.Pattern() {
return entry
}
}
return nil
} | go | {
"resource": ""
} |
q174523 | MergePatterns | validation | func (e *Entry) MergePatterns(patterns []string) *Entry {
pat, size := PeekNextPattern(patterns)
if child := e.getChildEntry(pat); child != nil {
if len(patterns) == size {
return child
}
return child.MergePatterns(patterns[size:])
}
return e.addPatterns(patterns)
} | go | {
"resource": ""
} |
q174524 | AddEntry | validation | func (e *Entry) AddEntry(child *Entry) {
length := len(e.entries)
if length == 0 {
e.entries = append(e.entries, child)
return
}
index := sort.Search(length, func(i int) bool {
return child.weight > e.entries[i].weight
})
if index == length {
e.entries = append(e.entries, child)
return
}
e.entries ... | go | {
"resource": ""
} |
q174525 | addPatterns | validation | func (e *Entry) addPatterns(patterns []string) *Entry {
var currentNode *Entry = e
for len(patterns) > 0 {
var entry *Entry
pat, size := PeekNextPattern(patterns)
// suffix entry
if size == 2 {
matcher, name := parseMatcher(patterns[0])
suffixMatcher := &SuffixMatcher{patterns[1], matcher}
entry = ... | go | {
"resource": ""
} |
q174526 | execPrefix | validation | func (e *Entry) execPrefix(method, urlStr string) (*Route, []string) {
if !strings.HasPrefix(urlStr, e.pattern) {
return nil, nil
}
if len(urlStr) == len(e.pattern) {
return e.GetHandler(method), nil
}
return e.traverse(method, urlStr[len(e.pattern):])
} | go | {
"resource": ""
} |
q174527 | traverse | validation | func (e *Entry) traverse(method, urlStr string) (*Route, []string) {
for _, entry := range e.entries {
if h, params := entry.exec(method, urlStr); h != nil {
return h, params
}
}
return nil, nil
} | go | {
"resource": ""
} |
q174528 | getExecMatch | validation | func (e *Entry) getExecMatch(name string, matcher Matcher) ExecFunc {
return func(method, urlStr string) (*Route, []string) {
offset, matchStr := matcher.Match(urlStr)
if offset == -1 {
return nil, nil
}
// finish parsing
if len(urlStr) == offset {
if h := e.GetHandler(method); h != nil {
return h... | go | {
"resource": ""
} |
q174529 | MergeRoutes | validation | func MergeRoutes(r ...Routable) Routes {
routes := make(Routes, 0)
for _, v := range r {
routes = append(routes, v.Routes()...)
}
return routes
} | go | {
"resource": ""
} |
q174530 | Debugln | validation | func (l *logger) Debugln(vals ...interface{}) {
l.mut.Lock()
defer l.mut.Unlock()
s := fmt.Sprintln(vals...)
l.logger.Output(2, "DEBUG: "+s)
l.callHandlers(LevelDebug, s)
} | go | {
"resource": ""
} |
q174531 | Debugf | validation | func (l *logger) Debugf(format string, vals ...interface{}) {
l.mut.Lock()
defer l.mut.Unlock()
s := fmt.Sprintf(format, vals...)
l.logger.Output(2, "DEBUG: "+s)
l.callHandlers(LevelDebug, s)
} | go | {
"resource": ""
} |
q174532 | Verbosef | validation | func (l *logger) Verbosef(format string, vals ...interface{}) {
l.mut.Lock()
defer l.mut.Unlock()
s := fmt.Sprintf(format, vals...)
l.logger.Output(2, "VERBOSE: "+s)
l.callHandlers(LevelVerbose, s)
} | go | {
"resource": ""
} |
q174533 | Infoln | validation | func (l *logger) Infoln(vals ...interface{}) {
l.mut.Lock()
defer l.mut.Unlock()
s := fmt.Sprintln(vals...)
l.logger.Output(2, "INFO: "+s)
l.callHandlers(LevelInfo, s)
} | go | {
"resource": ""
} |
q174534 | Infof | validation | func (l *logger) Infof(format string, vals ...interface{}) {
l.mut.Lock()
defer l.mut.Unlock()
s := fmt.Sprintf(format, vals...)
l.logger.Output(2, "INFO: "+s)
l.callHandlers(LevelInfo, s)
} | go | {
"resource": ""
} |
q174535 | Okln | validation | func (l *logger) Okln(vals ...interface{}) {
l.mut.Lock()
defer l.mut.Unlock()
s := fmt.Sprintln(vals...)
l.logger.Output(2, "OK: "+s)
l.callHandlers(LevelOK, s)
} | go | {
"resource": ""
} |
q174536 | Okf | validation | func (l *logger) Okf(format string, vals ...interface{}) {
l.mut.Lock()
defer l.mut.Unlock()
s := fmt.Sprintf(format, vals...)
l.logger.Output(2, "OK: "+s)
l.callHandlers(LevelOK, s)
} | go | {
"resource": ""
} |
q174537 | Fatalln | validation | func (l *logger) Fatalln(vals ...interface{}) {
l.mut.Lock()
defer l.mut.Unlock()
s := fmt.Sprintln(vals...)
l.logger.Output(2, "FATAL: "+s)
l.callHandlers(LevelFatal, s)
os.Exit(1)
} | go | {
"resource": ""
} |
q174538 | Fatalf | validation | func (l *logger) Fatalf(format string, vals ...interface{}) {
l.mut.Lock()
defer l.mut.Unlock()
s := fmt.Sprintf(format, vals...)
l.logger.Output(2, "FATAL: "+s)
l.callHandlers(LevelFatal, s)
os.Exit(1)
} | go | {
"resource": ""
} |
q174539 | ShouldDebug | validation | func (l *logger) ShouldDebug(facility string) bool {
l.mut.Lock()
res := l.debug[facility]
l.mut.Unlock()
return res
} | go | {
"resource": ""
} |
q174540 | SetDebug | validation | func (l *logger) SetDebug(facility string, enabled bool) {
l.mut.Lock()
l.debug[facility] = enabled
l.mut.Unlock()
} | go | {
"resource": ""
} |
q174541 | Facilities | validation | func (l *logger) Facilities() (enabled, disabled []string) {
l.mut.Lock()
for facility, isEnabled := range l.debug {
if isEnabled {
enabled = append(enabled, facility)
} else {
disabled = append(disabled, facility)
}
}
l.mut.Unlock()
return
} | go | {
"resource": ""
} |
q174542 | NewFacility | validation | func (l *logger) NewFacility(facility string) Logger {
l.mut.Lock()
if l.debug == nil {
l.debug = make(map[string]bool)
}
l.debug[facility] = false
l.mut.Unlock()
return &facilityLogger{
logger: l,
facility: facility,
}
} | go | {
"resource": ""
} |
q174543 | removeNonDigits | validation | func (f *formatifier) removeNonDigits() {
rp := regexp.MustCompile(`\D`)
f.theString = rp.ReplaceAllString(f.theString, "")
} | go | {
"resource": ""
} |
q174544 | removeNonWordChars | validation | func (f *formatifier) removeNonWordChars() {
if len(f.theString) > 0 {
rp := regexp.MustCompile(`\W|\s|_`)
f.theString = rp.ReplaceAllString(f.theString, "")
}
} | go | {
"resource": ""
} |
q174545 | urlEncodeSpaces | validation | func (f *formatifier) urlEncodeSpaces() {
rp := regexp.MustCompile(`\s`)
f.theString = rp.ReplaceAllString(f.theString, "%20")
} | go | {
"resource": ""
} |
q174546 | randomSelect | validation | func randomSelect(a []int) int {
var tmpIndex int
length := len(a)
randBytes := make([]byte, length)
if _, err := rand.Read(randBytes); err == nil {
tmpIndex = int(randBytes[0]) % length
}
return a[tmpIndex]
} | go | {
"resource": ""
} |
q174547 | NewStdFormatter | validation | func NewStdFormatter(delim, tmpl string, entry Entry, values map[string]interface{}, timeformat string) (Formatter, error) {
if delim == "" {
return nil, e.New("invalid delimitator")
}
if tmpl == "" {
return nil, e.New("invalid template")
}
if entry == nil {
return nil, e.New("invalid entry")
}
if values =... | go | {
"resource": ""
} |
q174548 | Get | validation | func (s Chain) Get(handler http.Handler) http.Handler {
for i := len(s) - 1; i >= 0; i-- {
handler = s[i](handler)
}
return handler
} | go | {
"resource": ""
} |
q174549 | parseMatcher | validation | func parseMatcher(pat string) (matcher Matcher, name string) {
if !isMatchPattern(pat) {
panic("pattern \"" + pat + "\" is not a matcher pattern")
}
s := pat[1 : len(pat)-1]
ss := strings.Split(s, ":")
var matchType string
if len(ss) == 1 {
name = ss[0]
} else {
matchType = ss[0]
name = ss[1]
}
if mat... | go | {
"resource": ""
} |
q174550 | isMatchPattern | validation | func isMatchPattern(s string) bool {
return len(s) > 2 && s[0] == '<' && s[len(s)-1] == '>'
} | go | {
"resource": ""
} |
q174551 | routeSplitFunc | validation | func routeSplitFunc(data []byte, atEOF bool) (int, []byte, error) {
if atEOF || data == nil {
return 0, nil, io.EOF
}
r, _ := utf8.DecodeRune(data)
// matcher
if r == '<' {
i := bytes.IndexRune(data, '>')
if i == -1 {
return 0, nil, NoClosingBracket
}
return (i + 1), data[:(i + 1)], nil
}
// one ... | go | {
"resource": ""
} |
q174552 | SplitPath | validation | func SplitPath(pat string) (routes []string, err error) {
scanner := bufio.NewScanner(strings.NewReader(pat))
scanner.Split(routeSplitFunc)
for scanner.Scan() {
routes = append(routes, scanner.Text())
}
err = scanner.Err()
return
} | go | {
"resource": ""
} |
q174553 | isNextSuffixPattern | validation | func isNextSuffixPattern(p []string) bool {
if len(p) >= 2 && isMatchPattern(p[0]) && !isMatchPattern(p[1]) {
matcher, _ := parseMatcher(p[0])
if _, ok := matcher.(*FixedLengthMatcher); ok {
return false
}
r, _ := utf8.DecodeRuneInString(p[1])
return matcher.MatchRune(r)
}
return false
} | go | {
"resource": ""
} |
q174554 | PeekNextPattern | validation | func PeekNextPattern(p []string) (pat string, size int) {
if isNextSuffixPattern(p) {
pat, size = (p[0] + p[1]), 2
} else {
pat, size = p[0], 1
}
return
} | go | {
"resource": ""
} |
q174555 | NewPlayer | validation | func NewPlayer(nick string, profile Profile) (*Player, error) {
p := new(Player)
newUUID, err := uuid.V4()
if err != nil {
// FIXME: Handle error
}
p.UUID = newUUID
p.Nick = nick
p.Profile = profile
err = storage.Store(p)
if err != nil {
return nil, errors.New(err.Error() + " - Could not write player to st... | go | {
"resource": ""
} |
q174556 | Push | validation | func (r *Reader) Push(reader io.Reader) {
r.readers = append(r.readers, reader)
} | go | {
"resource": ""
} |
q174557 | NewCatering | validation | func NewCatering(tournament uuid.UUID, ci Info) (*Catering, error) {
c := new(Catering)
c.UUID, _ = uuid.V4()
c.Tournament = tournament
if err := mergo.MergeWithOverwrite(&c.Info, ci); err != nil {
return nil, errors.New(err.Error() + " - Could not set initial catering info")
}
if err := storage.Store(c); err !... | go | {
"resource": ""
} |
q174558 | GroupByMonths | validation | func (t Tournaments) GroupByMonths(season int) map[time.Month]Tournaments {
byMonth := make(map[time.Month]Tournaments)
for _, entry := range t {
y, m := entry.Info.Scheduled.Year(), entry.Info.Scheduled.Month()
if y == season {
byMonth[m] = append(byMonth[m], entry)
}
}
return byMonth
} | go | {
"resource": ""
} |
q174559 | validateTournamentInfo | validation | func validateTournamentInfo(info Info) error {
if info.Scheduled.IsZero() {
return errors.New("Tournament needs scheduled date")
}
if info.Stake == 0 {
return errors.New("Tournament needs a stake")
}
if info.Season == 0 {
return errors.New("Tournament needs a season")
}
return nil
} | go | {
"resource": ""
} |
q174560 | NewTournament | validation | func NewTournament(tdata Info) (*Tournament, error) {
if err := validateTournamentInfo(tdata); err != nil {
return nil, errors.New(err.Error() + " - Could not create tournament")
}
t := new(Tournament)
t.UUID, _ = uuid.V4()
if err := mergo.MergeWithOverwrite(&t.Info, tdata); err != nil {
return nil, errors.Ne... | go | {
"resource": ""
} |
q174561 | IndexOf | validation | func (s StringSlice) IndexOf(str string) int {
for i, v := range s {
if str == v {
return i
}
}
return -1
} | go | {
"resource": ""
} |
q174562 | IndexOfIgnoreCase | validation | func (s StringSlice) IndexOfIgnoreCase(str string) int {
str = strings.ToLower(str)
for i, v := range s {
if str == strings.ToLower(v) {
return i
}
}
return -1
} | go | {
"resource": ""
} |
q174563 | NewCache | validation | func NewCache(d time.Duration) *Cache {
return &Cache{
values: make(map[string]*cacheItem),
lifetime: d,
}
} | go | {
"resource": ""
} |
q174564 | Count | validation | func (s *Cache) Count() int {
if s.removeExpired() == raiqub.WriteLocked {
defer s.Unlock()
} else {
defer s.RUnlock()
}
return len(s.values)
} | go | {
"resource": ""
} |
q174565 | Flush | validation | func (s *Cache) Flush() {
s.Lock()
defer s.Unlock()
s.values = make(map[string]*cacheItem)
} | go | {
"resource": ""
} |
q174566 | removeExpired | validation | func (s *Cache) removeExpired() raiqub.LockStatus {
writeLocked := false
s.RLock()
for i := range s.values {
if s.values[i].IsExpired() {
if !writeLocked {
s.RUnlock()
s.Lock()
writeLocked = true
}
delete(s.values, i)
}
}
if writeLocked {
return raiqub.WriteLocked
} else {
return rai... | go | {
"resource": ""
} |
q174567 | NewImage | validation | func NewImage(d *Docker, name string) *Image {
return &Image{
docker: d,
name: name,
}
} | go | {
"resource": ""
} |
q174568 | Exists | validation | func (s *Image) Exists() bool {
out, err := s.docker.Run("images", "--no-trunc")
if err != nil {
return false
}
return strings.Contains(out, s.name)
} | go | {
"resource": ""
} |
q174569 | Pull | validation | func (s *Image) Pull() error {
_, err := s.docker.Run("pull", s.name)
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q174570 | Run | validation | func (s *Image) Run(cfg *RunConfig) (*Container, error) {
args := make([]string, 0, len(cfg.Options)+len(cfg.Args)+1)
args = append(args, cfg.Options...)
args = append(args, s.name)
args = append(args, cfg.Args...)
out, err := s.docker.Run("run", args...)
if err != nil {
return nil, err
}
container := &Cont... | go | {
"resource": ""
} |
q174571 | Setup | validation | func (s *Image) Setup() error {
if !s.docker.HasBin() {
return DockerBinNotFound(s.docker.binCmd)
}
if !s.Exists() {
if err := s.Pull(); err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q174572 | NewLocation | validation | func NewLocation(host uuid.UUID, lp Profile) (*Location, error) {
l := new(Location)
l.UUID, _ = uuid.V4()
l.Active = true
l.Host = host
if err := mergo.MergeWithOverwrite(&l.Profile, lp); err != nil {
return nil, errors.New(err.Error() + " - Could not set initial location profile")
}
if err := storage.Store(l... | go | {
"resource": ""
} |
q174573 | PortAt | validation | func (s NetworkSettings) PortAt(index int) (string, *HostPublish) {
counter := 0
for k, v := range s.Ports {
if counter != index {
counter++
continue
}
return k, v
}
return "", nil
} | go | {
"resource": ""
} |
q174574 | SplitPort | validation | func (s NetworkSettings) SplitPort(index int) (uint16, string) {
ptProt, _ := s.PortAt(index)
vect := strings.Split(ptProt, "/")
port, _ := strconv.ParseUint(vect[0], 10, 16)
return uint16(port), vect[1]
} | go | {
"resource": ""
} |
q174575 | Priority | validation | func (s SyslogFacility) Priority() syslog.Priority {
return syslogPriorities[strings.ToLower(s.String())]
} | go | {
"resource": ""
} |
q174576 | OK | validation | func (s SyslogFacility) OK() (ok bool) {
_, ok = syslogPriorities[strings.ToLower(s.String())]
return
} | go | {
"resource": ""
} |
q174577 | Format | validation | func (formatter *JSONFormatter) Format(record *Record) string {
data, _ := json.Marshal(record)
return string(data)
} | go | {
"resource": ""
} |
q174578 | Open | validation | func Open(path string, mode os.FileMode, options *bolt.Options) (DB, error) {
db, err := bolt.Open(path, mode, options)
return DB{db}, errorsp.WithStacks(err)
} | go | {
"resource": ""
} |
q174579 | Begin | validation | func (db DB) Begin(writable bool) (Tx, error) {
tx, err := db.DB.Begin(writable)
return Tx{tx}, errorsp.WithStacks(err)
} | go | {
"resource": ""
} |
q174580 | View | validation | func (db DB) View(f func(Tx) error) error {
return errorsp.WithStacks(db.DB.View(func(tx *bolt.Tx) error {
return errorsp.WithStacks(f(Tx{tx}))
}))
} | go | {
"resource": ""
} |
q174581 | CopyFile | validation | func (tx Tx) CopyFile(path string, mode os.FileMode) error {
return errorsp.WithStacks(tx.Tx.CopyFile(path, mode))
} | go | {
"resource": ""
} |
q174582 | CreateBucketIfNotExists | validation | func (tx Tx) CreateBucketIfNotExists(folders [][]byte) (Bucket, error) {
b, err := tx.Tx.CreateBucketIfNotExists(folders[0])
if err != nil {
return Bucket{}, nil
}
if len(folders) == 1 {
return Bucket{b}, nil
}
return Bucket{b}.CreateBucketIfNotExists(folders[1:])
} | go | {
"resource": ""
} |
q174583 | Delete | validation | func (tx Tx) Delete(k [][]byte) error {
if len(k) == 1 {
return errorsp.WithStacks(tx.Tx.DeleteBucket(k[0]))
}
return tx.Bucket(k[:len(k)-1], func(b Bucket) error {
return errorsp.WithStacks(b.Bucket.Delete(k[len(k)-1]))
})
} | go | {
"resource": ""
} |
q174584 | ForEach | validation | func (tx Tx) ForEach(folders [][]byte, f func(Bucket, bytesp.Slice, bytesp.Slice) error) error {
return tx.Bucket(folders, func(b Bucket) error {
return errorsp.WithStacks(b.Bucket.ForEach(func(k, v []byte) error {
return errorsp.WithStacks(f(b, bytesp.Slice(k), bytesp.Slice(v)))
}))
})
} | go | {
"resource": ""
} |
q174585 | ForEachGob | validation | func (tx Tx) ForEachGob(folders [][]byte, f func(Bucket, bytesp.Slice, interface{}) error) error {
return tx.ForEach(folders, func(b Bucket, k, bs bytesp.Slice) error {
var v interface{}
if err := gob.NewDecoder(&bs).Decode(&v); err != nil {
return errorsp.WithStacksAndMessage(err, "decoding %d bytes value for ... | go | {
"resource": ""
} |
q174586 | Put | validation | func (tx Tx) Put(k [][]byte, v []byte) error {
b, err := tx.CreateBucketIfNotExists(k[:len(k)-1])
if err != nil {
return err
}
return errorsp.WithStacks(b.Bucket.Put(k[len(k)-1], v))
} | go | {
"resource": ""
} |
q174587 | Value | validation | func (tx Tx) Value(k [][]byte, f func(v bytesp.Slice) error) error {
return tx.Bucket(k[:len(k)-1], func(b Bucket) error {
v := b.Bucket.Get(k[len(k)-1])
if v == nil {
return nil
}
return errorsp.WithStacks(f(bytesp.Slice(v)))
})
} | go | {
"resource": ""
} |
q174588 | Update | validation | func (tx Tx) Update(k [][]byte, f func(bytesp.Slice) (bytesp.Slice, error)) error {
b, err := tx.CreateBucketIfNotExists(k[:len(k)-1])
if err != nil {
return err
}
v, err := f(b.Bucket.Get(k[len(k)-1]))
if err != nil {
return errorsp.WithStacks(err)
}
if v == nil {
return errorsp.WithStacks(b.Bucket.Delete... | go | {
"resource": ""
} |
q174589 | OpenBucket | validation | func (b Bucket) OpenBucket(folders [][]byte, f func(Bucket) error) error {
bb := b.Bucket
for _, fld := range folders {
bb = bb.Bucket(fld)
if bb == nil {
return nil
}
}
return errorsp.WithStacks(f(Bucket{bb}))
} | go | {
"resource": ""
} |
q174590 | CreateBucketIfNotExists | validation | func (b Bucket) CreateBucketIfNotExists(folders [][]byte) (Bucket, error) {
bb := b.Bucket
for _, fld := range folders {
var err error
if bb, err = bb.CreateBucketIfNotExists(fld); err != nil {
return Bucket{}, errorsp.WithStacks(err)
}
}
return Bucket{bb}, nil
} | go | {
"resource": ""
} |
q174591 | Delete | validation | func (b Bucket) Delete(k [][]byte) error {
return b.OpenBucket(k[:len(k)-1], func(b Bucket) error {
return errorsp.WithStacks(b.Bucket.Delete(k[len(k)-1]))
})
} | go | {
"resource": ""
} |
q174592 | GobValue | validation | func (b Bucket) GobValue(k [][]byte, f func(interface{}) error) error {
return b.Value(k, func(bs bytesp.Slice) error {
var v interface{}
if err := gob.NewDecoder(&bs).Decode(&v); err != nil {
return errorsp.WithStacksAndMessage(err, "decoding %d bytes buffer failed", len(bs))
}
return f(v)
})
} | go | {
"resource": ""
} |
q174593 | NextSequence | validation | func (b Bucket) NextSequence() (uint64, error) {
s, err := b.Bucket.NextSequence()
return s, errorsp.WithStacks(err)
} | go | {
"resource": ""
} |
q174594 | Put | validation | func (b Bucket) Put(k [][]byte, v []byte) error {
bb, err := b.CreateBucketIfNotExists(k[:len(k)-1])
if err != nil {
return errorsp.WithStacksAndMessage(err, "CreateBucketIfNotExists %q failed", string(bytes.Join(k[:len(k)-1], []byte(" "))))
}
return errorsp.WithStacks(bb.Bucket.Put(k[len(k)-1], v))
} | go | {
"resource": ""
} |
q174595 | PutGob | validation | func (b Bucket) PutGob(k [][]byte, v interface{}) error {
var bs bytesp.Slice
if err := gob.NewEncoder(&bs).Encode(&v); err != nil {
return errorsp.WithStacksAndMessage(err, "encoding %+v failed", v)
}
return b.Put(k, bs)
} | go | {
"resource": ""
} |
q174596 | Drop | validation | func (m *MongoDb) Drop() error {
err := m.db.DropDatabase()
if err != nil {
return e.New(err)
}
m.db = m.session.DB(m.dbname)
m.c = m.db.C(m.collection)
return nil
} | go | {
"resource": ""
} |
q174597 | HandleError | validation | func (handler *NullHandler) HandleError(err error) error {
os.Stderr.WriteString(fmt.Sprintf("%s %s\n", time.Now(), err.Error()))
return nil
} | go | {
"resource": ""
} |
q174598 | Handle | validation | func (handler *WriteHandler) Handle(record *Record) error {
_, err := handler.Writer.Write([]byte(handler.Formatter.Format(record) + "\n"))
return err
} | go | {
"resource": ""
} |
q174599 | Handle | validation | func (handler *MemoryHandler) Handle(record *Record) error {
handler.lock.Lock()
handler.Messages = append(handler.Messages, handler.Formatter.Format(record))
handler.lock.Unlock()
return nil
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.