id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c173600 | if !handler.isValid() {
panic("Invalid handler: " + methodName)
}
return handler
} | |
c173601 |
gr := &Request{Request: r}
gf(gr).Send(w)
}
} | |
c173602 | c.Request = &Request{Request: req}
} | |
c173603 | == nil {
c.Request.session = c.sessionFinder(c.Request)
}
return c.Request.session
} | |
c173604 | err != nil {
panic(err.Error())
}
return c.RenderTemplate(t, vars)
} | |
c173605 | bytes.NewBuffer(nil)
err := t.Execute(out, vars)
if err != nil {
panic(err.Error())
}
return out.Bytes()
} | |
c173606 | NewRedirectResponse(c.UrlFor(routeName, args...).String())
} | |
c173607 |
return UrlFor(routeName, args...)
} | |
c173608 | nil {
return ""
}
return c.Value
} | |
c173609 | {
panic(ghttp.NewHttpError(err, http.StatusRequestTimeout))
} else {
panic(err)
}
}
}
r.bodyRead = true
}
return r.bodyData
} | |
c173610 | return r.URL.Query().Get(key)
} | |
c173611 | string {
val := r.FormValue(key)
if val == "" {
val = def
}
return val
} | |
c173612 | mux.Vars(r.Request)[key]
} | |
c173613 | := range substrs {
if strings.Contains(s, substr) {
return true
}
}
return false
} | |
c173614 | substr), "")
if lastS != s {
loop = true
break
}
}
}
return s
} | |
c173615 | ss {
newStrings[i] = callback(s)
}
return newStrings
} | |
c173616 |
}
for i, v := range a {
if v != b[i] {
return false
}
}
return true
} | |
c173617 | uniqItems = append(uniqItems, item)
lastitem = item
}
}
return
} | |
c173618 | {
return CookieSigner{signer: hmac.New(sha256.New, key)}
} | |
c173619 | = c.EncodeValue(cookie.Value)
} | |
c173620 | err := c.DecodeValue(cookie.Value)
if err != nil {
return err
}
cookie.Value = data
return nil
} | |
c173621 | != nil {
return "", err
}
if !hmac.Equal(c.mac(value), mac) {
return "", errors.New("Bad signature")
}
return value, nil
} | |
c173622 | fmt.Sprintf("%s.%s",
base64.URLEncoding.EncodeToString(c.mac(value)),
value)
} | |
c173623 | "" {
sh.statter.Counter(1.0, sh.prefix+"."+description+".requests", 1)
sh.statter.Timing(1.0, sh.prefix+"."+description+".responsetime", requestDuration)
}
} | |
c173624 | httputil.NewSingleHostReverseProxy(target),
target: target,
}
return &s, nil
} | |
c173625 |
if len(newkey) > 250 {
newkey = newkey[:250]
}
return newkey
} | |
c173626 |
err := m.Stop(sectionName)
if err == nil {
m.Log(sectionName)
}
return err
} | |
c173627 | {
return m.MonitorReflectedFunc(section, reflect.ValueOf(myfunc), []reflect.Value{})
} | |
c173628 | args []reflect.Value) []reflect.Value {
m.Start(section)
defer m.StopAndLog(section)
return reflectedFunc.Call(args)
} | |
c173629 | strings.Join(v, " "),
r.URL.String(),
r.Method,
time.Now(),
serializedHeaders.String(),
string(r.BodyData()),
debug.Stack(),
)
} | |
c173630 |
return &commonLogHandler{
handler: h,
logger: logger,
template: template.Must(template.New("").Parse(templ)),
}
} | |
c173631 | req)
logData.End = time.Now()
logOutput := bytes.Buffer{}
err := lh.template.Execute(&logOutput, logData)
if err != nil {
panic(err)
}
lh.logger.Println(logOutput.String())
} | |
c173632 | return this.Request.URL.User.Username()
}
return ""
} | |
c173633 | err := r.URL(args...)
if err != nil {
log.Panicln("UrlFor: " + err.Error())
}
return u
} | |
c173634 |
u := UrlFor(name, args...)
u.Host = UrlBase.Host
u.Scheme = UrlBase.Scheme
return u
} | |
c173635 | if err != nil {
panic(err.Error())
}
} | |
c173636 | ""
if fieldValue.Kind() == reflect.String {
jsonStr = fmt.Sprintf(`{"%s": "%s"}`, structField.Name, envVal)
} else {
jsonStr = fmt.Sprintf(`{"%s": %s}`, structField.Name, envVal)
}
err := json.Unmarshal([]byte(jsonStr), v)
result = append(result, MarshalledEnvironmentVar{envKey, envVal, structField.Name, err})
}
}
}
return
} | |
c173637 | if len(matches) > 1 {
r.URL.Path = matches[1]
h.ServeHTTP(w, r)
} else {
http.NotFound(w, r)
}
})
} | |
c173638 | &cacheDecorator{delegate, maxage}
} | |
c173639 | return nil, errors.New(
fmt.Sprintf("type not match: expect map key string or int get: %T", k))
}
v, err = transform(v)
if err != nil {
return nil, err
}
o[sk] = v
}
return o, nil
case []interface{}:
in1 := in.([]interface{})
len1 := len(in1)
o := make([]interface{}, len1)
for i := 0; i < len1; i++ {
o[i], err = transform(in1[i])
if err != nil {
return nil, err
}
}
return o, nil
default:
return in, nil
}
} | |
c173640 | := strings.Join(parts[:end], "/")
eps, err = doDiscover(pre, app, insecure)
if derr := discoverFn(pre, eps, err); derr != nil {
return derr
}
}
return
} | |
c173641 | if len(out.ACIEndpoints) != 0 || len(out.Keys) != 0 || len(out.ACIPushEndpoints) != 0 {
return errEnough
}
return nil
}
err = DiscoverWalk(app, insecure, walker(out, &attempts, testFn))
if err != nil && err != errEnough {
return nil, attempts, err
}
return out, attempts, nil
} | |
c173642 | := make([]string, 0, len(m.fields))
for k := range m.fields {
l = append(l, k)
}
return l
} | |
c173643 |
return ""
}
m := getType2jfm(v.Type())
m.lock.Lock()
defer m.lock.Unlock()
s, ok := m.fields[name]
if !ok {
return ""
}
return s
} | |
c173644 | return Empty.Enumerate(cancel)
}
return dict.root.Enumerate(cancel)
} | |
c173645 | = m.List[:0]
messagePool.Put(m)
}
} | |
c173646 | causer(newError(nil, err, text...))
} | |
c173647 |
return &causerT{
errorT: e,
}
} | |
c173648 | ok := ctx.(Context); ok {
return c
}
return &contextT{ctx: ctx}
} | |
c173649 | &contextT{ctx: newContext(c.ctx, keyvals)}
} | |
c173650 |
list := List(fromContext(c.ctx))
list.writeToBuffer(buf)
f.Write(buf.Bytes())
pool.ReleaseBuffer(buf)
} | |
c173651 |
w := &Writer{
printer: newPrinter(out),
}
return w
} | |
c173652 | := make(map[string]string)
for level, effect := range w.levels {
levels[level] = effect
}
return levels
} | |
c173653 | w.Levels()
levels[level] = effect
w.SetLevels(levels)
} | |
c173654 |
for _, level := range levels {
p[level] = "hide"
}
w.SetLevels(p)
} | |
c173655 | ok := w.suppressMap[level]
return ok
} | |
c173656 |
w.handlers = append(w.handlers, h)
}
} | |
c173657 | = newPrinter(out)
w.mutex.Unlock()
} | |
c173658 | d.Options&DirectoryOptionsRecursive {
err = filepath.SkipDir
}
if d.applyOptions(currentLocation, info) {
select {
case results <- currentLocation:
// Intentionally Left Blank
case <-cancel:
err = errors.New("directory enumeration cancelled")
}
}
return
})
}()
return results
} | |
c173659 | close(done)
return subject.Enumerate(done).All(p)
} | |
c173660 | {
return false
}
}
return true
} | |
c173661 |
defer close(done)
for range iterator.Enumerate(done) {
return true
}
return false
} | |
c173662 | close(done)
for element := range iterator.Enumerate(done) {
if p(element) {
return true
}
}
return false
} | |
c173663 | reflect.Slice || kind == reflect.Array {
return enumerableValue{
Value: val,
}
}
return enumerableSlice(entries)
} | |
c173664 |
err = errNoElements
var isOpen bool
if retval, isOpen = <-subject.Enumerate(done); isOpen {
err = nil
}
close(done)
return
} | |
c173665 | }
wg.Done()
}
go funnel(iter)
for _, item := range others {
go funnel(item)
}
go func() {
wg.Wait()
close(retval)
}()
return retval
} | |
c173666 | Enumerable {
return parallelSelecter{
original: original,
operation: operation,
}
} | |
c173667 | uint(cpus))
return intermediate[0].Merge(intermediate[1:]...)
}
return iter
} | |
c173668 |
val, _ := cache.Pop()
retval <- val
}
close(retval)
}()
return retval
} | |
c173669 |
original: subject,
transform: transform,
}
} | |
c173670 |
go func() {
for item := range iter {
retval <- transform(item)
}
close(retval)
}()
return retval
} | |
c173671 |
original: subject,
toMany: toMany,
}
} | |
c173672 | range lister(parent) {
retval <- child
}
}
close(retval)
}()
return retval
} | |
c173673 | = entry
err = nil
} else {
retval = nil
err = errMultipleElements
break
}
firstPass = false
}
return
} | |
c173674 | interface{}, err error) {
iter = Where(iter, pred)
return Single(iter)
} | |
c173675 |
original: subject,
skipCount: n,
}
} | |
c173676 | defer close(results[addr])
for {
read, ok := <-iter
if !ok {
return
}
results[addr] <- operation(read)
}
}(i)
}
}()
return cast
} | |
c173677 |
original: subject,
n: n,
}
} | |
c173678 | if i >= n {
return
}
i++
results <- entry
}
}()
return results
} | |
c173679 | uint) bool) Enumerable {
return takeWhiler{
original: subject,
criteria: criteria,
}
} | |
c173680 | := range iter {
if !criteria(entry, i) {
return
}
i++
results <- entry
}
}()
return results
} | |
c173681 | <- entry
right <- entry
}
close(left)
close(right)
}()
return left, right
} | |
c173682 | retval = append(retval, entry)
}
return retval
} | |
c173683 |
original: original,
filter: p,
}
} | |
c173684 | go func() {
for item := range iter {
if predicate(item) {
retval <- item
}
}
close(retval)
}()
return retval
} | |
c173685 |
if buf != nil {
buf.Reset()
bufferPool.Put(buf)
}
} | |
c173686 | = NewLinkedList()
for _, entry := range entries {
retval.Push(entry)
}
return retval
} | |
c173687 | defer stack.key.RUnlock()
return stack.underlyer.Enumerate(cancel)
} | |
c173688 | stack.key.RUnlock()
return stack.underlyer == nil || stack.underlyer.IsEmpty()
} | |
c173689 | stack.underlyer = NewLinkedList()
}
stack.underlyer.AddFront(entry)
} | |
c173690 | return nil, false
}
return stack.underlyer.RemoveFront()
} | |
c173691 | stack.key.RUnlock()
return stack.underlyer.PeekFront()
} | |
c173692 |
if stack.underlyer == nil {
return 0
}
return stack.underlyer.Length()
} | |
c173693 | entries {
list.AddBack(entry)
}
return list
} | |
c173694 |
list.length++
if list.first == nil {
list.first = toAppend
list.last = toAppend
return
}
list.last.next = toAppend
list.last = toAppend
} | |
c173695 | select {
case retval <- current.payload:
break
case <-cancel:
return
}
current = current.next
}
}()
return retval
} | |
c173696 | list.key.RUnlock()
node, ok := get(list.first, pos)
if ok {
return node.payload, true
}
return nil, false
} | |
c173697 | list.key.RUnlock()
return list.first == nil
} | |
c173698 | list.key.RUnlock()
return list.length
} | |
c173699 | {
return nil, false
}
return list.last.payload, true
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.