_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q180400 | ReadInt8 | test | func (p *Process) ReadInt8(a Address) int8 {
return int8(p.ReadUint8(a))
} | go | {
"resource": ""
} |
q180401 | ReadInt16 | test | func (p *Process) ReadInt16(a Address) int16 {
return int16(p.ReadUint16(a))
} | go | {
"resource": ""
} |
q180402 | ReadInt32 | test | func (p *Process) ReadInt32(a Address) int32 {
return int32(p.ReadUint32(a))
} | go | {
"resource": ""
} |
q180403 | ReadInt64 | test | func (p *Process) ReadInt64(a Address) int64 {
return int64(p.ReadUint64(a))
} | go | {
"resource": ""
} |
q180404 | ReadUintptr | test | func (p *Process) ReadUintptr(a Address) uint64 {
if p.ptrSize == 4 {
return uint64(p.ReadUint32(a))
}
return p.ReadUint64(a)
} | go | {
"resource": ""
} |
q180405 | ReadPtr | test | func (p *Process) ReadPtr(a Address) Address {
return Address(p.ReadUintptr(a))
} | go | {
"resource": ""
} |
q180406 | ReadCString | test | func (p *Process) ReadCString(a Address) string {
for n := int64(0); ; n++ {
if p.ReadUint8(a.Add(n)) == 0 {
b := make([]byte, n)
p.ReadAt(b, a)
return string(b)
}
}
} | go | {
"resource": ""
} |
q180407 | Source | test | func (m *Mapping) Source() (string, int64) {
if m.f == nil {
return "", 0
}
return m.f.Name(), m.off
} | go | {
"resource": ""
} |
q180408 | findMapping | test | func (p *Process) findMapping(a Address) *Mapping {
t3 := p.pageTable[a>>52]
if t3 == nil {
return nil
}
t2 := t3[a>>42%(1<<10)]
if t2 == nil {
return nil
}
t1 := t2[a>>32%(1<<10)]
if t1 == nil {
return nil
}
t0 := t1[a>>22%(1<<10)]
if t0 == nil {
return nil
}
return t0[a>>12%(1<<10)]
} | go | {
"resource": ""
} |
q180409 | Max | test | func (a Address) Max(b Address) Address {
if a > b {
return a
}
return b
} | go | {
"resource": ""
} |
q180410 | Min | test | func (a Address) Min(b Address) Address {
if a < b {
return a
}
return b
} | go | {
"resource": ""
} |
q180411 | Align | test | func (a Address) Align(x int64) Address {
return (a + Address(x) - 1) & ^(Address(x) - 1)
} | go | {
"resource": ""
} |
q180412 | initialize | test | func (d *ltDom) initialize() {
type workItem struct {
name vName
parentName vName
}
// Initialize objs for mapping from object index back to Object.
i := 0
d.p.ForEachObject(func(x Object) bool {
d.objs[i] = x
i++
return true
})
// Add roots to the work stack, essentially pretending to visit
/... | go | {
"resource": ""
} |
q180413 | calculate | test | func (d *ltDom) calculate() {
// name -> bucket (a name), per Georgiadis.
buckets := make([]vName, d.nVertices)
for i := range buckets {
buckets[i] = vName(i)
}
for i := vNumber(len(d.vertices)) - 1; i > 0; i-- {
w := d.vertices[i]
// Step 3. Implicitly define the immediate dominator of each node.
for v ... | go | {
"resource": ""
} |
q180414 | eval | test | func (d *ltDom) eval(v vName) vName {
if d.ancestor[v] == -1 {
return v
}
d.compress(v)
return d.labels[v]
} | go | {
"resource": ""
} |
q180415 | compress | test | func (d *ltDom) compress(v vName) {
var stackBuf [20]vName
stack := stackBuf[:0]
for d.ancestor[d.ancestor[v]] != -1 {
stack = append(stack, v)
v = d.ancestor[v]
}
for len(stack) != 0 {
v := stack[len(stack)-1]
stack = stack[:len(stack)-1]
if d.semis[d.labels[d.ancestor[v]]] < d.semis[d.labels[v]] {
... | go | {
"resource": ""
} |
q180416 | link | test | func (d *ltDom) link(v, w vName) {
d.ancestor[w] = v
} | go | {
"resource": ""
} |
q180417 | reverse | test | func (d *dominators) reverse() {
// One inbound edge per vertex. Then we need an extra so that you can
// always look at ridx[i+1], and another for working storage while
// populating redge.
cnt := make([]int, len(d.idom)+2)
// Fill cnt[2:] with the number of outbound edges for each vertex.
tmp := cnt[2:]
for _... | go | {
"resource": ""
} |
q180418 | calcSize | test | func (d *dominators) calcSize(p *Process) {
d.size = make([]int64, len(d.idom))
type workItem struct {
v vName
mode dfsMode
}
work := []workItem{{pseudoRoot, down}}
for len(work) > 0 {
item := &work[len(work)-1]
kids := d.redge[d.ridx[item.v]:d.ridx[item.v+1]]
if item.mode == down && len(kids) != 0 ... | go | {
"resource": ""
} |
q180419 | objField | test | func objField(c *gocore.Process, x gocore.Object, off int64) string {
t, r := c.Type(x)
if t == nil {
return fmt.Sprintf("f%d", off)
}
s := ""
if r > 1 {
s = fmt.Sprintf("[%d]", off/t.Size)
off %= t.Size
}
return s + typeFieldName(t, off)
} | go | {
"resource": ""
} |
q180420 | Readable | test | func (p *Process) Readable(a Address) bool {
return p.findMapping(a) != nil
} | go | {
"resource": ""
} |
q180421 | ReadableN | test | func (p *Process) ReadableN(a Address, n int64) bool {
for {
m := p.findMapping(a)
if m == nil || m.perm&Read == 0 {
return false
}
c := m.max.Sub(a)
if n <= c {
return true
}
n -= c
a = a.Add(c)
}
} | go | {
"resource": ""
} |
q180422 | splitMappingsAt | test | func (p *Process) splitMappingsAt(a Address) {
for _, m := range p.memory.mappings {
if a < m.min || a > m.max {
continue
}
if a == m.min || a == m.max {
return
}
// Split this mapping at a.
m2 := new(Mapping)
*m2 = *m
m.max = a
m2.min = a
if m2.f != nil {
m2.off += m.Size()
}
if m2.or... | go | {
"resource": ""
} |
q180423 | DynamicType | test | func (p *Process) DynamicType(t *Type, a core.Address) *Type {
switch t.Kind {
default:
panic("asking for the dynamic type of a non-interface")
case KindEface:
x := p.proc.ReadPtr(a)
if x == 0 {
return nil
}
return p.runtimeType2Type(x)
case KindIface:
x := p.proc.ReadPtr(a)
if x == 0 {
return n... | go | {
"resource": ""
} |
q180424 | Create | test | func (fs *BtrfsFilesystem) Create(bytes uint64) error {
// significantly
idempotent := exec.Command("bash", "-e", "-x", "-c", `
if [ ! -e $IMAGE_PATH ] || [ "$(stat --printf="%s" $IMAGE_PATH)" != "$SIZE_IN_BYTES" ]; then
touch $IMAGE_PATH
truncate -s ${SIZE_IN_BYTES} $IMAGE_PATH
fi
lo="$(losetup -j $IMA... | go | {
"resource": ""
} |
q180425 | Resolve | test | func Resolve(u *url.URL) (*net.IPAddr, error) {
host, _, err := SplitHostPort(u)
if err != nil {
return nil, err
}
addr, err := net.ResolveIPAddr("ip", host)
if err != nil {
return nil, err
}
return addr, nil
} | go | {
"resource": ""
} |
q180426 | Equal | test | func (a *Token) Equal(b *Token) bool {
if a == nil || b == nil {
return false
}
if a.tokenType != b.tokenType {
return false
}
return a.value == b.value
} | go | {
"resource": ""
} |
q180427 | newDefaultClassifier | test | func newDefaultClassifier() tokenClassifier {
t := tokenClassifier{}
t.addRuneClass(spaceRunes, spaceRuneClass)
t.addRuneClass(escapingQuoteRunes, escapingQuoteRuneClass)
t.addRuneClass(nonEscapingQuoteRunes, nonEscapingQuoteRuneClass)
t.addRuneClass(escapeRunes, escapeRuneClass)
t.addRuneClass(commentRunes, comm... | go | {
"resource": ""
} |
q180428 | Next | test | func (l *Lexer) Next() (string, error) {
for {
token, err := (*Tokenizer)(l).Next()
if err != nil {
return "", err
}
switch token.tokenType {
case WordToken:
return token.value, nil
case CommentToken:
// skip comments
default:
return "", fmt.Errorf("Unknown token type: %v", token.tokenType)
... | go | {
"resource": ""
} |
q180429 | NewTokenizer | test | func NewTokenizer(r io.Reader) *Tokenizer {
input := bufio.NewReader(r)
classifier := newDefaultClassifier()
return &Tokenizer{
input: *input,
classifier: classifier}
} | go | {
"resource": ""
} |
q180430 | Split | test | func Split(s string) ([]string, error) {
l := NewLexer(strings.NewReader(s))
subStrings := make([]string, 0)
for {
word, err := l.Next()
if err != nil {
if err == io.EOF {
return subStrings, nil
}
return subStrings, err
}
subStrings = append(subStrings, word)
}
} | go | {
"resource": ""
} |
q180431 | Between | test | func Between(s, left, right string) string {
l := len(left)
startPos := strings.Index(s, left)
if startPos < 0 {
return ""
}
endPos := IndexOf(s, right, startPos+l)
//log.Printf("%s: left %s right %s start %d end %d", s, left, right, startPos+l, endPos)
if endPos < 0 {
return ""
} else if right == "" {
re... | go | {
"resource": ""
} |
q180432 | BetweenF | test | func BetweenF(left, right string) func(string) string {
return func(s string) string {
return Between(s, left, right)
}
} | go | {
"resource": ""
} |
q180433 | Camelize | test | func Camelize(s string) string {
return camelizeRe.ReplaceAllStringFunc(s, func(val string) string {
val = strings.ToUpper(val)
val = camelizeRe2.ReplaceAllString(val, "")
return val
})
} | go | {
"resource": ""
} |
q180434 | Capitalize | test | func Capitalize(s string) string {
return strings.ToUpper(s[0:1]) + strings.ToLower(s[1:])
} | go | {
"resource": ""
} |
q180435 | CharAt | test | func CharAt(s string, index int) string {
l := len(s)
shortcut := index < 0 || index > l-1 || l == 0
if shortcut {
return ""
}
return s[index : index+1]
} | go | {
"resource": ""
} |
q180436 | CharAtF | test | func CharAtF(index int) func(string) string {
return func(s string) string {
return CharAt(s, index)
}
} | go | {
"resource": ""
} |
q180437 | ChompLeft | test | func ChompLeft(s, prefix string) string {
if strings.HasPrefix(s, prefix) {
return s[len(prefix):]
}
return s
} | go | {
"resource": ""
} |
q180438 | ChompLeftF | test | func ChompLeftF(prefix string) func(string) string {
return func(s string) string {
return ChompLeft(s, prefix)
}
} | go | {
"resource": ""
} |
q180439 | ChompRight | test | func ChompRight(s, suffix string) string {
if strings.HasSuffix(s, suffix) {
return s[:len(s)-len(suffix)]
}
return s
} | go | {
"resource": ""
} |
q180440 | ChompRightF | test | func ChompRightF(suffix string) func(string) string {
return func(s string) string {
return ChompRight(s, suffix)
}
} | go | {
"resource": ""
} |
q180441 | ClassifyF | test | func ClassifyF(s string) func(string) string {
return func(s string) string {
return Classify(s)
}
} | go | {
"resource": ""
} |
q180442 | Clean | test | func Clean(s string) string {
s = spacesRe.ReplaceAllString(s, " ")
s = beginEndSpacesRe.ReplaceAllString(s, "")
return s
} | go | {
"resource": ""
} |
q180443 | Dasherize | test | func Dasherize(s string) string {
s = strings.TrimSpace(s)
s = spaceUnderscoreRe.ReplaceAllString(s, "-")
s = capitalsRe.ReplaceAllString(s, "-$1")
s = dashesRe.ReplaceAllString(s, "-")
s = strings.ToLower(s)
return s
} | go | {
"resource": ""
} |
q180444 | EscapeHTML | test | func EscapeHTML(s string) string {
if Verbose {
fmt.Println("Use html.EscapeString instead of EscapeHTML")
}
return html.EscapeString(s)
} | go | {
"resource": ""
} |
q180445 | DecodeHTMLEntities | test | func DecodeHTMLEntities(s string) string {
if Verbose {
fmt.Println("Use html.UnescapeString instead of DecodeHTMLEntities")
}
return html.UnescapeString(s)
} | go | {
"resource": ""
} |
q180446 | EnsurePrefixF | test | func EnsurePrefixF(prefix string) func(string) string {
return func(s string) string {
return EnsurePrefix(s, prefix)
}
} | go | {
"resource": ""
} |
q180447 | EnsureSuffixF | test | func EnsureSuffixF(suffix string) func(string) string {
return func(s string) string {
return EnsureSuffix(s, suffix)
}
} | go | {
"resource": ""
} |
q180448 | Humanize | test | func Humanize(s string) string {
if s == "" {
return s
}
s = Underscore(s)
var humanizeRe = regexp.MustCompile(`_id$`)
s = humanizeRe.ReplaceAllString(s, "")
s = strings.Replace(s, "_", " ", -1)
s = strings.TrimSpace(s)
s = Capitalize(s)
return s
} | go | {
"resource": ""
} |
q180449 | Iif | test | func Iif(condition bool, truthy string, falsey string) string {
if condition {
return truthy
}
return falsey
} | go | {
"resource": ""
} |
q180450 | IndexOf | test | func IndexOf(s string, needle string, start int) int {
l := len(s)
if needle == "" {
if start < 0 {
return 0
} else if start < l {
return start
} else {
return l
}
}
if start < 0 || start > l-1 {
return -1
}
pos := strings.Index(s[start:], needle)
if pos == -1 {
return -1
}
return start + ... | go | {
"resource": ""
} |
q180451 | IsLower | test | func IsLower(s string) bool {
return IsAlpha(s) && s == strings.ToLower(s)
} | go | {
"resource": ""
} |
q180452 | IsUpper | test | func IsUpper(s string) bool {
return IsAlpha(s) && s == strings.ToUpper(s)
} | go | {
"resource": ""
} |
q180453 | Left | test | func Left(s string, n int) string {
if n < 0 {
return Right(s, -n)
}
return Substr(s, 0, n)
} | go | {
"resource": ""
} |
q180454 | LeftF | test | func LeftF(n int) func(string) string {
return func(s string) string {
return Left(s, n)
}
} | go | {
"resource": ""
} |
q180455 | Letters | test | func Letters(s string) []string {
result := []string{}
for _, r := range s {
result = append(result, string(r))
}
return result
} | go | {
"resource": ""
} |
q180456 | Lines | test | func Lines(s string) []string {
s = strings.Replace(s, "\r\n", "\n", -1)
return strings.Split(s, "\n")
} | go | {
"resource": ""
} |
q180457 | Map | test | func Map(arr []string, iterator func(string) string) []string {
r := []string{}
for _, item := range arr {
r = append(r, iterator(item))
}
return r
} | go | {
"resource": ""
} |
q180458 | Match | test | func Match(s, pattern string) bool {
r := regexp.MustCompile(pattern)
return r.MatchString(s)
} | go | {
"resource": ""
} |
q180459 | tasks | test | func tasks(p *do.Project) {
p.Task("default", do.S{"readme"}, nil)
p.Task("install", nil, func(c *do.Context) {
c.Run("go get github.com/robertkrimen/godocdown/godocdown")
})
p.Task("lint", nil, func(c *do.Context) {
c.Run("golint .")
c.Run("gofmt -w -s .")
c.Run("go vet .")
c.Run("go test")
})
p.Tas... | go | {
"resource": ""
} |
q180460 | Pad | test | func Pad(s, c string, n int) string {
L := len(s)
if L >= n {
return s
}
n -= L
left := strings.Repeat(c, int(math.Ceil(float64(n)/2)))
right := strings.Repeat(c, int(math.Floor(float64(n)/2)))
return left + s + right
} | go | {
"resource": ""
} |
q180461 | PadF | test | func PadF(c string, n int) func(string) string {
return func(s string) string {
return Pad(s, c, n)
}
} | go | {
"resource": ""
} |
q180462 | PadLeft | test | func PadLeft(s, c string, n int) string {
L := len(s)
if L > n {
return s
}
return strings.Repeat(c, (n-L)) + s
} | go | {
"resource": ""
} |
q180463 | PadLeftF | test | func PadLeftF(c string, n int) func(string) string {
return func(s string) string {
return PadLeft(s, c, n)
}
} | go | {
"resource": ""
} |
q180464 | PadRightF | test | func PadRightF(c string, n int) func(string) string {
return func(s string) string {
return PadRight(s, c, n)
}
} | go | {
"resource": ""
} |
q180465 | Pipe | test | func Pipe(s string, funcs ...func(string) string) string {
for _, fn := range funcs {
s = fn(s)
}
return s
} | go | {
"resource": ""
} |
q180466 | QuoteItems | test | func QuoteItems(arr []string) []string {
return Map(arr, func(s string) string {
return strconv.Quote(s)
})
} | go | {
"resource": ""
} |
q180467 | ReplaceF | test | func ReplaceF(old, new string, n int) func(string) string {
return func(s string) string {
return strings.Replace(s, old, new, n)
}
} | go | {
"resource": ""
} |
q180468 | ReplacePatternF | test | func ReplacePatternF(pattern, repl string) func(string) string {
return func(s string) string {
return ReplacePattern(s, pattern, repl)
}
} | go | {
"resource": ""
} |
q180469 | Reverse | test | func Reverse(s string) string {
cs := make([]rune, utf8.RuneCountInString(s))
i := len(cs)
for _, c := range s {
i--
cs[i] = c
}
return string(cs)
} | go | {
"resource": ""
} |
q180470 | RightF | test | func RightF(n int) func(string) string {
return func(s string) string {
return Right(s, n)
}
} | go | {
"resource": ""
} |
q180471 | Slice | test | func Slice(s string, start, end int) string {
if end > -1 {
return s[start:end]
}
L := len(s)
if L+end > 0 {
return s[start : L-end]
}
return s[start:]
} | go | {
"resource": ""
} |
q180472 | SliceF | test | func SliceF(start, end int) func(string) string {
return func(s string) string {
return Slice(s, start, end)
}
} | go | {
"resource": ""
} |
q180473 | SliceContains | test | func SliceContains(slice []string, val string) bool {
if slice == nil {
return false
}
for _, it := range slice {
if it == val {
return true
}
}
return false
} | go | {
"resource": ""
} |
q180474 | SliceIndexOf | test | func SliceIndexOf(slice []string, val string) int {
if slice == nil {
return -1
}
for i, it := range slice {
if it == val {
return i
}
}
return -1
} | go | {
"resource": ""
} |
q180475 | Slugify | test | func Slugify(s string) string {
sl := slugifyRe.ReplaceAllString(s, "")
sl = strings.ToLower(sl)
sl = Dasherize(sl)
return sl
} | go | {
"resource": ""
} |
q180476 | StripPunctuation | test | func StripPunctuation(s string) string {
s = stripPuncRe.ReplaceAllString(s, "")
s = nWhitespaceRe.ReplaceAllString(s, " ")
return s
} | go | {
"resource": ""
} |
q180477 | StripTags | test | func StripTags(s string, tags ...string) string {
if len(tags) == 0 {
tags = append(tags, "")
}
for _, tag := range tags {
stripTagsRe := regexp.MustCompile(`(?i)<\/?` + tag + `[^<>]*>`)
s = stripTagsRe.ReplaceAllString(s, "")
}
return s
} | go | {
"resource": ""
} |
q180478 | Substr | test | func Substr(s string, index int, n int) string {
L := len(s)
if index < 0 || index >= L || s == "" {
return ""
}
end := index + n
if end >= L {
end = L
}
if end <= index {
return ""
}
return s[index:end]
} | go | {
"resource": ""
} |
q180479 | SubstrF | test | func SubstrF(index, n int) func(string) string {
return func(s string) string {
return Substr(s, index, n)
}
} | go | {
"resource": ""
} |
q180480 | TemplateWithDelimiters | test | func TemplateWithDelimiters(s string, values map[string]interface{}, opening, closing string) string {
escapeDelimiter := func(delim string) string {
result := templateRe.ReplaceAllString(delim, "\\$1")
return templateRe2.ReplaceAllString(result, "\\$")
}
openingDelim := escapeDelimiter(opening)
closingDelim :... | go | {
"resource": ""
} |
q180481 | ToArgv | test | func ToArgv(s string) []string {
const (
InArg = iota
InArgQuote
OutOfArg
)
currentState := OutOfArg
currentQuoteChar := "\x00" // to distinguish between ' and " quotations
// this allows to use "foo'bar"
currentArg := ""
argv := []string{}
isQuote := func(c string) bool {
return c == `"` || c == `'`
... | go | {
"resource": ""
} |
q180482 | ToBool | test | func ToBool(s string) bool {
s = strings.ToLower(s)
return s == "true" || s == "yes" || s == "on" || s == "1"
} | go | {
"resource": ""
} |
q180483 | ToBoolOr | test | func ToBoolOr(s string, defaultValue bool) bool {
b, err := strconv.ParseBool(s)
if err != nil {
return defaultValue
}
return b
} | go | {
"resource": ""
} |
q180484 | ToIntOr | test | func ToIntOr(s string, defaultValue int) int {
n, err := strconv.Atoi(s)
if err != nil {
return defaultValue
}
return n
} | go | {
"resource": ""
} |
q180485 | ToFloat32Or | test | func ToFloat32Or(s string, defaultValue float32) float32 {
f, err := strconv.ParseFloat(s, 32)
if err != nil {
return defaultValue
}
return float32(f)
} | go | {
"resource": ""
} |
q180486 | ToFloat64Or | test | func ToFloat64Or(s string, defaultValue float64) float64 {
f, err := strconv.ParseFloat(s, 64)
if err != nil {
return defaultValue
}
return f
} | go | {
"resource": ""
} |
q180487 | UnescapeHTML | test | func UnescapeHTML(s string) string {
if Verbose {
fmt.Println("Use html.UnescapeString instead of UnescapeHTML")
}
return html.UnescapeString(s)
} | go | {
"resource": ""
} |
q180488 | WrapHTML | test | func WrapHTML(s string, tag string, attrs map[string]string) string {
escapeHTMLAttributeQuotes := func(v string) string {
v = strings.Replace(v, "<", "<", -1)
v = strings.Replace(v, "&", "&", -1)
v = strings.Replace(v, "\"", """, -1)
return v
}
if tag == "" {
tag = "div"
}
el := "<" + tag
f... | go | {
"resource": ""
} |
q180489 | WrapHTMLF | test | func WrapHTMLF(tag string, attrs map[string]string) func(string) string {
return func(s string) string {
return WrapHTML(s, tag, attrs)
}
} | go | {
"resource": ""
} |
q180490 | ReapChildren | test | func ReapChildren(pids PidCh, errors ErrorCh, done chan struct{}, reapLock *sync.RWMutex) {
c := make(chan os.Signal, 1)
signal.Notify(c, unix.SIGCHLD)
for {
// Block for an incoming signal that a child has exited.
select {
case <-c:
// Got a child signal, drop out and reap.
case <-done:
return
}
... | go | {
"resource": ""
} |
q180491 | SdNotify | test | func SdNotify(state string) error {
name := os.Getenv("NOTIFY_SOCKET")
if name == "" {
return ErrSdNotifyNoSocket
}
conn, err := net.DialUnix("unixgram", nil, &net.UnixAddr{Name: name, Net: "unixgram"})
if err != nil {
return err
}
defer conn.Close()
_, err = conn.Write([]byte(state))
return err
} | go | {
"resource": ""
} |
q180492 | NewAuthenticator | test | func NewAuthenticator(store *coal.Store, policy *Policy) *Authenticator {
// initialize token
coal.Init(policy.Token)
// initialize clients
for _, model := range policy.Clients {
coal.Init(model)
}
return &Authenticator{
store: store,
policy: policy,
}
} | go | {
"resource": ""
} |
q180493 | Endpoint | test | func (a *Authenticator) Endpoint(prefix string) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// create tracer
tracer := fire.NewTracerFromRequest(r, "flame/Authenticator.Endpoint")
tracer.Tag("prefix", prefix)
defer tracer.Finish(true)
// continue any previous aborts... | go | {
"resource": ""
} |
q180494 | Unique | test | func Unique(ids []bson.ObjectId) []bson.ObjectId {
// prepare map
m := make(map[bson.ObjectId]bool)
l := make([]bson.ObjectId, 0, len(ids))
for _, id := range ids {
if _, ok := m[id]; !ok {
m[id] = true
l = append(l, id)
}
}
return l
} | go | {
"resource": ""
} |
q180495 | Contains | test | func Contains(list []bson.ObjectId, id bson.ObjectId) bool {
for _, item := range list {
if item == id {
return true
}
}
return false
} | go | {
"resource": ""
} |
q180496 | Includes | test | func Includes(all, subset []bson.ObjectId) bool {
for _, item := range subset {
if !Contains(all, item) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q180497 | Require | test | func Require(m Model, flags ...string) {
// check all flags
for _, f := range flags {
L(m, f, true)
}
} | go | {
"resource": ""
} |
q180498 | Enqueue | test | func Enqueue(store *coal.SubStore, name string, data Model, delay time.Duration) (*Job, error) {
// set default data
if data == nil {
data = bson.M{}
}
// get time
now := time.Now()
// prepare job
job := coal.Init(&Job{
Name: name,
Status: StatusEnqueued,
Created: now,
Available: now.Add(de... | go | {
"resource": ""
} |
q180499 | A | test | func A(name string, m fire.Matcher, h Handler) *Authorizer {
// panic if matcher or handler is not set
if m == nil || h == nil {
panic("ash: missing matcher or handler")
}
// construct and return authorizer
return &Authorizer{
Matcher: m,
Handler: func(ctx *fire.Context) ([]*Enforcer, error) {
// begin t... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.