_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
// the pseudo-root, numbering it 0.
d.semis[pseudoRoot] = 0
d.parents[pseudoRoot] = -1
d.vertices[0] = pseudoRoot
var work []workItem
for i := 1; i < 1+d.nRoots; i++ {
work = append(work, workItem{name: vName(i), parentName: 0})
}
n := vNumber(1) // 0 was the pseudo-root.
// Build the spanning tree, assigning vertex numbers to each object
// and initializing semi and parent.
for len(work) != 0 {
item := work[len(work)-1]
work = work[:len(work)-1]
if d.semis[item.name] != -1 {
continue
}
d.semis[item.name] = n
d.parents[item.name] = item.parentName
d.vertices[n] = item.name
n++
visitChild := func(_ int64, child Object, _ int64) bool {
childIdx, _ := d.p.findObjectIndex(d.p.Addr(child))
work = append(work, workItem{name: vName(childIdx + d.nRoots + 1), parentName: item.name})
return true
}
root, object := d.findVertexByName(item.name)
if root != nil {
d.p.ForEachRootPtr(root, visitChild)
} else {
d.p.ForEachPtr(object, visitChild)
}
}
} | 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 := buckets[w]; v != w; v = buckets[v] {
u := d.eval(v)
if d.semis[u] < d.semis[v] {
d.idom[v] = u
} else {
d.idom[v] = w
}
}
// Step 2. Compute the semidominators of all nodes.
root, obj := d.findVertexByName(w)
// This loop never visits the pseudo-root.
if root != nil {
u := d.eval(pseudoRoot)
if d.semis[u] < d.semis[w] {
d.semis[w] = d.semis[u]
}
} else {
d.p.ForEachReversePtr(obj, func(x Object, r *Root, _, _ int64) bool {
var v int
if r != nil {
v = d.p.findRootIndex(r) + 1
} else {
v, _ = d.p.findObjectIndex(d.p.Addr(x))
v += d.nRoots + 1
}
u := d.eval(vName(v))
if d.semis[u] < d.semis[w] {
d.semis[w] = d.semis[u]
}
return true
})
}
d.link(d.parents[w], w)
if d.parents[w] == d.vertices[d.semis[w]] {
d.idom[w] = d.parents[w]
} else {
buckets[w] = buckets[d.vertices[d.semis[w]]]
buckets[d.vertices[d.semis[w]]] = w
}
}
// The final 'Step 3' is now outside the loop.
for v := buckets[pseudoRoot]; v != pseudoRoot; v = buckets[v] {
d.idom[v] = pseudoRoot
}
// Step 4. Explicitly define the immediate dominator of each
// node, in preorder.
for _, w := range d.vertices[1:] {
if d.idom[w] != d.vertices[d.semis[w]] {
d.idom[w] = d.idom[d.idom[w]]
}
}
} | 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]] {
d.labels[v] = d.labels[d.ancestor[v]]
}
d.ancestor[v] = d.ancestor[d.ancestor[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 _, idom := range d.idom {
tmp[idom]++
}
// Make tmp cumulative. After this step, cnt[1:] is what we want for
// ridx, but the next step messes it up.
var n int
for idx, c := range tmp {
n += c
tmp[idx] = n
}
// Store outbound edges in redge, using cnt[1:] as the index to store
// the next edge for each vertex. After we're done, everything's been
// shifted over one, and cnt is ridx.
redge := make([]vName, len(d.idom))
tmp = cnt[1:]
for i, idom := range d.idom {
redge[tmp[idom]] = vName(i)
tmp[idom]++
}
d.redge, d.ridx = redge, cnt[:len(cnt)-1]
} | 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 {
item.mode = up
for _, w := range kids {
if w == 0 {
// bogus self-edge. Ignore.
continue
}
work = append(work, workItem{w, down})
}
continue
}
work = work[:len(work)-1]
root, obj := d.findVertexByName(item.v)
var size int64
switch {
case item.v == pseudoRoot:
break
case root != nil:
size += root.Type.Size
default:
size += p.Size(obj)
}
for _, w := range kids {
size += d.size[w]
}
d.size[item.v] = size
}
} | 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.origF != nil {
m2.origOff += m.Size()
}
p.memory.mappings = append(p.memory.mappings, m2)
return
}
} | 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 nil
}
// Read type out of itab.
x = p.proc.ReadPtr(x.Add(p.proc.PtrSize()))
return p.runtimeType2Type(x)
}
} | 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 $IMAGE_PATH | cut -d':' -f1)"
if [ -z "$lo" ]; then
lo="$(losetup -f --show $IMAGE_PATH)"
fi
if ! file $IMAGE_PATH | grep BTRFS; then
`+fs.mkfsBin+` --nodiscard $IMAGE_PATH
fi
mkdir -p $MOUNT_PATH
if ! mountpoint -q $MOUNT_PATH; then
mount -t btrfs $lo $MOUNT_PATH
fi
`)
idempotent.Env = []string{
"PATH=" + os.Getenv("PATH"),
"MOUNT_PATH=" + fs.mountPath,
"IMAGE_PATH=" + fs.imagePath,
fmt.Sprintf("SIZE_IN_BYTES=%d", bytes),
}
_, err := fs.run(idempotent)
return err
} | 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, commentRuneClass)
return t
} | 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 == "" {
return s[endPos:]
} else {
return s[startPos+l : endPos]
}
} | 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 + pos
} | 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.Task("readme", nil, func(c *do.Context) {
c.Run("godocdown -output README.md")
packageName, _ := util.PackageName("doc.go")
// add godoc link
goa.Pipe(
f.Load("./README.md"),
f.Str(str.ReplaceF("--", "\n[godoc](https://godoc.org/"+packageName+")\n", 1)),
f.Write(),
)
}).Src("**/*.go")
p.Task("test", nil, func(c *do.Context) {
c.Run("go test")
})
} | 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 := escapeDelimiter(closing)
r := regexp.MustCompile(openingDelim + `(.+?)` + closingDelim)
matches := r.FindAllStringSubmatch(s, -1)
for _, submatches := range matches {
match := submatches[0]
key := submatches[1]
//log.Printf("match %s key %s\n", match, key)
if values[key] != nil {
v := fmt.Sprintf("%v", values[key])
s = strings.Replace(s, match, v, -1)
}
}
return s
} | 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 == `'`
}
isEscape := func(c string) bool {
return c == `\`
}
isWhitespace := func(c string) bool {
return c == " " || c == "\t"
}
L := len(s)
for i := 0; i < L; i++ {
c := s[i : i+1]
//fmt.Printf("c %s state %v arg %s argv %v i %d\n", c, currentState, currentArg, args, i)
if isQuote(c) {
switch currentState {
case OutOfArg:
currentArg = ""
fallthrough
case InArg:
currentState = InArgQuote
currentQuoteChar = c
case InArgQuote:
if c == currentQuoteChar {
currentState = InArg
} else {
currentArg += c
}
}
} else if isWhitespace(c) {
switch currentState {
case InArg:
argv = append(argv, currentArg)
currentState = OutOfArg
case InArgQuote:
currentArg += c
case OutOfArg:
// nothing
}
} else if isEscape(c) {
switch currentState {
case OutOfArg:
currentArg = ""
currentState = InArg
fallthrough
case InArg:
fallthrough
case InArgQuote:
if i == L-1 {
if runtime.GOOS == "windows" {
// just add \ to end for windows
currentArg += c
} else {
panic("Escape character at end string")
}
} else {
if runtime.GOOS == "windows" {
peek := s[i+1 : i+2]
if peek != `"` {
currentArg += c
}
} else {
i++
c = s[i : i+1]
currentArg += c
}
}
}
} else {
switch currentState {
case InArg, InArgQuote:
currentArg += c
case OutOfArg:
currentArg = ""
currentArg += c
currentState = InArg
}
}
}
if currentState == InArg {
argv = append(argv, currentArg)
} else if currentState == InArgQuote {
panic("Starting quote has no ending quote.")
}
return argv
} | 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
for name, val := range attrs {
el += " " + name + "=\"" + escapeHTMLAttributeQuotes(val) + "\""
}
el += ">" + s + "</" + tag + ">"
return el
} | 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
}
// Attempt to reap all abandoned child processes after getting
// the reap lock, which makes sure the application isn't doing
// any waiting of its own. Note that we do the full write lock
// here.
func() {
if reapLock != nil {
reapLock.Lock()
defer reapLock.Unlock()
}
POLL:
// Try to reap children until there aren't any more. We
// never block in here so that we are always responsive
// to signals, at the expense of possibly leaving a
// child behind if we get here too quickly. Any
// stragglers should get reaped the next time we see a
// signal, so we won't leak in the long run.
var status unix.WaitStatus
pid, err := unix.Wait4(-1, &status, unix.WNOHANG, nil)
switch err {
case nil:
// Got a child, clean this up and poll again.
if pid > 0 {
if pids != nil {
pids <- pid
}
goto POLL
}
return
case unix.ECHILD:
// No more children, we are done.
return
case unix.EINTR:
// We got interrupted, try again. This likely
// can't happen since we are calling Wait4 in a
// non-blocking fashion, but it's good to be
// complete and handle this case rather than
// fail.
goto POLL
default:
// We got some other error we didn't expect.
// Wait for another SIGCHLD so we don't
// potentially spam in here and chew up CPU.
if errors != nil {
errors <- err
}
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
defer stack.Resume(func(err error) {
// directly write oauth2 errors
if oauth2Error, ok := err.(*oauth2.Error); ok {
_ = oauth2.WriteError(w, oauth2Error)
return
}
// set critical error on last span
tracer.Tag("error", true)
tracer.Log("error", err.Error())
tracer.Log("stack", stack.Trace())
// otherwise report critical errors
if a.Reporter != nil {
a.Reporter(err)
}
// ignore errors caused by writing critical errors
_ = oauth2.WriteError(w, oauth2.ServerError(""))
})
// trim and split path
s := strings.Split(strings.Trim(strings.TrimPrefix(r.URL.Path, prefix), "/"), "/")
if len(s) != 1 || (s[0] != "authorize" && s[0] != "token" && s[0] != "revoke") {
w.WriteHeader(http.StatusNotFound)
return
}
// copy store
store := a.store.Copy()
defer store.Close()
// create
state := &state{
request: r,
writer: w,
store: store,
tracer: tracer,
}
// call endpoints
switch s[0] {
case "authorize":
a.authorizationEndpoint(state)
case "token":
a.tokenEndpoint(state)
case "revoke":
a.revocationEndpoint(state)
}
})
} | 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(delay),
}).(*Job)
// marshall data
raw, err := bson.Marshal(data)
if err != nil {
return nil, err
}
// marshall into job
err = bson.Unmarshal(raw, &job.Data)
if err != nil {
return nil, err
}
// insert job
err = store.C(job).Insert(job)
if err != nil {
return nil, err
}
return job, nil
} | 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 trace
ctx.Tracer.Push(name)
// call handler
enforcers, err := h(ctx)
if err != nil {
return nil, err
}
// finish trace
ctx.Tracer.Pop()
return enforcers, nil
},
}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.