_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q8800 | Debugf | train | func (l *CompositeLogger) Debugf(format string, v ...interface{}) {
for _, log := range l.loggers {
log.Debugf(format, v...)
}
} | go | {
"resource": ""
} |
q8801 | Debug | train | func (l *CompositeLogger) Debug(v ...interface{}) {
for _, log := range l.loggers {
log.Debug(v...)
}
} | go | {
"resource": ""
} |
q8802 | Info | train | func (l *CompositeLogger) Info(v ...interface{}) {
for _, log := range l.loggers {
log.Info(v...)
}
} | go | {
"resource": ""
} |
q8803 | Warn | train | func (l *CompositeLogger) Warn(v ...interface{}) {
for _, log := range l.loggers {
log.Warn(v...)
}
} | go | {
"resource": ""
} |
q8804 | Error | train | func (l *CompositeLogger) Error(v ...interface{}) {
for _, log := range l.loggers {
log.Error(v...)
}
} | go | {
"resource": ""
} |
q8805 | NewLogger | train | func NewLogger(out io.Writer) Logger {
l := log.New(out, "[tango] ", log.Ldefault())
l.SetOutputLevel(log.Ldebug)
return l
} | go | {
"resource": ""
} |
q8806 | Logging | train | func Logging() HandlerFunc {
return func(ctx *Context) {
start := time.Now()
p := ctx.Req().URL.Path
if len(ctx.Req().URL.RawQuery) > 0 {
p = p + "?" + ctx.Req().URL.RawQuery
}
ctx.Debug("Started", ctx.Req().Method, p, "for", ctx.IP())
if action := ctx.Action(); action != nil {
if l, ok := action.(LogInterface); ok {
l.SetLogger(ctx.Logger)
}
}
ctx.Next()
if !ctx.Written() {
if ctx.Result == nil {
ctx.Result = NotFound()
}
ctx.HandleError()
}
statusCode := ctx.Status()
if statusCode >= 200 && statusCode < 400 {
ctx.Info(ctx.Req().Method, statusCode, time.Since(start), p)
} else {
ctx.Error(ctx.Req().Method, statusCode, time.Since(start), p, ctx.Result)
}
}
} | go | {
"resource": ""
} |
q8807 | Values | train | func (f *Queries) Values() url.Values {
return (*http.Request)(f).URL.Query()
} | go | {
"resource": ""
} |
q8808 | Query | train | func (ctx *Context) Query(key string, defaults ...string) string {
return (*Queries)(ctx.req).MustString(key, defaults...)
} | go | {
"resource": ""
} |
q8809 | QueryStrings | train | func (ctx *Context) QueryStrings(key string, defaults ...[]string) []string {
return (*Queries)(ctx.req).MustStrings(key, defaults...)
} | go | {
"resource": ""
} |
q8810 | QueryEscape | train | func (ctx *Context) QueryEscape(key string, defaults ...string) string {
return (*Queries)(ctx.req).MustEscape(key, defaults...)
} | go | {
"resource": ""
} |
q8811 | QueryInt | train | func (ctx *Context) QueryInt(key string, defaults ...int) int {
return (*Queries)(ctx.req).MustInt(key, defaults...)
} | go | {
"resource": ""
} |
q8812 | QueryInt32 | train | func (ctx *Context) QueryInt32(key string, defaults ...int32) int32 {
return (*Queries)(ctx.req).MustInt32(key, defaults...)
} | go | {
"resource": ""
} |
q8813 | QueryInt64 | train | func (ctx *Context) QueryInt64(key string, defaults ...int64) int64 {
return (*Queries)(ctx.req).MustInt64(key, defaults...)
} | go | {
"resource": ""
} |
q8814 | QueryUint | train | func (ctx *Context) QueryUint(key string, defaults ...uint) uint {
return (*Queries)(ctx.req).MustUint(key, defaults...)
} | go | {
"resource": ""
} |
q8815 | QueryUint32 | train | func (ctx *Context) QueryUint32(key string, defaults ...uint32) uint32 {
return (*Queries)(ctx.req).MustUint32(key, defaults...)
} | go | {
"resource": ""
} |
q8816 | QueryUint64 | train | func (ctx *Context) QueryUint64(key string, defaults ...uint64) uint64 {
return (*Queries)(ctx.req).MustUint64(key, defaults...)
} | go | {
"resource": ""
} |
q8817 | QueryFloat32 | train | func (ctx *Context) QueryFloat32(key string, defaults ...float32) float32 {
return (*Queries)(ctx.req).MustFloat32(key, defaults...)
} | go | {
"resource": ""
} |
q8818 | Get | train | func (t *Tango) Get(url string, c interface{}, middlewares ...Handler) {
t.Route([]string{"GET", "HEAD:Get"}, url, c, middlewares...)
} | go | {
"resource": ""
} |
q8819 | Any | train | func (t *Tango) Any(url string, c interface{}, middlewares ...Handler) {
t.Route(SupportMethods, url, c, middlewares...)
t.Route([]string{"HEAD:Get"}, url, c, middlewares...)
} | go | {
"resource": ""
} |
q8820 | Use | train | func (t *Tango) Use(handlers ...Handler) {
t.handlers = append(t.handlers, handlers...)
} | go | {
"resource": ""
} |
q8821 | getAddress | train | func getAddress(args ...interface{}) string {
var host string
var port int
if len(args) == 1 {
switch arg := args[0].(type) {
case string:
addrs := strings.Split(args[0].(string), ":")
if len(addrs) == 1 {
host = addrs[0]
} else if len(addrs) >= 2 {
host = addrs[0]
_port, _ := strconv.ParseInt(addrs[1], 10, 0)
port = int(_port)
}
case int:
port = arg
}
} else if len(args) >= 2 {
if arg, ok := args[0].(string); ok {
host = arg
}
if arg, ok := args[1].(int); ok {
port = arg
}
}
if envHost := os.Getenv("HOST"); len(envHost) != 0 {
host = envHost
} else if len(host) == 0 {
host = "0.0.0.0"
}
if envPort, _ := strconv.ParseInt(os.Getenv("PORT"), 10, 32); envPort != 0 {
port = int(envPort)
} else if port == 0 {
port = 8000
}
addr := host + ":" + strconv.FormatInt(int64(port), 10)
return addr
} | go | {
"resource": ""
} |
q8822 | RunTLS | train | func (t *Tango) RunTLS(certFile, keyFile string, args ...interface{}) {
addr := getAddress(args...)
t.logger.Info("Listening on https://" + addr)
t.Server.Addr = addr
t.Server.Handler = t
err := t.ListenAndServeTLS(certFile, keyFile)
if err != nil {
t.logger.Error(err)
}
} | go | {
"resource": ""
} |
q8823 | WrapBefore | train | func WrapBefore(handler http.Handler) HandlerFunc {
return func(ctx *Context) {
handler.ServeHTTP(ctx.ResponseWriter, ctx.Req())
ctx.Next()
}
} | go | {
"resource": ""
} |
q8824 | UseHandler | train | func (t *Tango) UseHandler(handler http.Handler) {
t.Use(WrapBefore(handler))
} | go | {
"resource": ""
} |
q8825 | NewWithLog | train | func NewWithLog(logger Logger, handlers ...Handler) *Tango {
tan := &Tango{
Router: newRouter(),
logger: logger,
handlers: make([]Handler, 0),
ErrHandler: Errors(),
}
tan.ctxPool.New = func() interface{} {
return &Context{
tan: tan,
Logger: tan.logger,
}
}
tan.respPool.New = func() interface{} {
return &responseWriter{}
}
tan.Use(handlers...)
return tan
} | go | {
"resource": ""
} |
q8826 | Classic | train | func Classic(l ...Logger) *Tango {
var logger Logger
if len(l) == 0 {
logger = NewLogger(os.Stdout)
} else {
logger = l[0]
}
return NewWithLog(
logger,
ClassicHandlers...,
)
} | go | {
"resource": ""
} |
q8827 | File | train | func File(path string) func(ctx *Context) {
return func(ctx *Context) {
ctx.ServeFile(path)
}
} | go | {
"resource": ""
} |
q8828 | Dir | train | func Dir(dir string) func(ctx *Context) {
return func(ctx *Context) {
params := ctx.Params()
if len(*params) <= 0 {
ctx.Result = NotFound()
ctx.HandleError()
return
}
ctx.ServeFile(filepath.Join(dir, (*params)[0].Value))
}
} | go | {
"resource": ""
} |
q8829 | Strings | train | func (f *Forms) Strings(key string) ([]string, error) {
(*http.Request)(f).ParseMultipartForm(32 << 20)
if v, ok := (*http.Request)(f).Form[key]; ok {
return v, nil
}
return nil, errors.New("not exist")
} | go | {
"resource": ""
} |
q8830 | Form | train | func (ctx *Context) Form(key string, defaults ...string) string {
return (*Forms)(ctx.req).MustString(key, defaults...)
} | go | {
"resource": ""
} |
q8831 | FormStrings | train | func (ctx *Context) FormStrings(key string, defaults ...[]string) []string {
return (*Forms)(ctx.req).MustStrings(key, defaults...)
} | go | {
"resource": ""
} |
q8832 | FormEscape | train | func (ctx *Context) FormEscape(key string, defaults ...string) string {
return (*Forms)(ctx.req).MustEscape(key, defaults...)
} | go | {
"resource": ""
} |
q8833 | FormInt | train | func (ctx *Context) FormInt(key string, defaults ...int) int {
return (*Forms)(ctx.req).MustInt(key, defaults...)
} | go | {
"resource": ""
} |
q8834 | FormInt32 | train | func (ctx *Context) FormInt32(key string, defaults ...int32) int32 {
return (*Forms)(ctx.req).MustInt32(key, defaults...)
} | go | {
"resource": ""
} |
q8835 | FormInt64 | train | func (ctx *Context) FormInt64(key string, defaults ...int64) int64 {
return (*Forms)(ctx.req).MustInt64(key, defaults...)
} | go | {
"resource": ""
} |
q8836 | FormUint | train | func (ctx *Context) FormUint(key string, defaults ...uint) uint {
return (*Forms)(ctx.req).MustUint(key, defaults...)
} | go | {
"resource": ""
} |
q8837 | FormUint32 | train | func (ctx *Context) FormUint32(key string, defaults ...uint32) uint32 {
return (*Forms)(ctx.req).MustUint32(key, defaults...)
} | go | {
"resource": ""
} |
q8838 | FormUint64 | train | func (ctx *Context) FormUint64(key string, defaults ...uint64) uint64 {
return (*Forms)(ctx.req).MustUint64(key, defaults...)
} | go | {
"resource": ""
} |
q8839 | FormFloat32 | train | func (ctx *Context) FormFloat32(key string, defaults ...float32) float32 {
return (*Forms)(ctx.req).MustFloat32(key, defaults...)
} | go | {
"resource": ""
} |
q8840 | SecureCookies | train | func (ctx *Context) SecureCookies(secret string) Cookies {
return &secureCookies{
(*cookies)(ctx),
secret,
}
} | go | {
"resource": ""
} |
q8841 | IP | train | func (ctx *Context) IP() string {
proxy := []string{}
if ips := ctx.Req().Header.Get("X-Forwarded-For"); ips != "" {
proxy = strings.Split(ips, ",")
}
if len(proxy) > 0 && proxy[0] != "" {
return proxy[0]
}
ip := strings.Split(ctx.Req().RemoteAddr, ":")
if len(ip) > 0 {
if ip[0] != "[" {
return ip[0]
}
}
return "127.0.0.1"
} | go | {
"resource": ""
} |
q8842 | WriteString | train | func (ctx *Context) WriteString(content string) (int, error) {
return io.WriteString(ctx.ResponseWriter, content)
} | go | {
"resource": ""
} |
q8843 | ServeFile | train | func (ctx *Context) ServeFile(path string) error {
dir, file := filepath.Split(path)
return ctx.ServeContent(file, http.Dir(dir))
} | go | {
"resource": ""
} |
q8844 | ServeContent | train | func (ctx *Context) ServeContent(path string, fileSystem http.FileSystem) error {
f, err := fileSystem.Open(path)
if err != nil {
msg, code := toHTTPError(err)
http.Error(ctx, msg, code)
return nil
}
defer f.Close()
d, err := f.Stat()
if err != nil {
msg, code := toHTTPError(err)
http.Error(ctx, msg, code)
return nil
}
if d.IsDir() {
http.Error(ctx, http.StatusText(http.StatusForbidden), http.StatusForbidden)
return nil
}
http.ServeContent(ctx, ctx.Req(), d.Name(), d.ModTime(), f)
return nil
} | go | {
"resource": ""
} |
q8845 | ServeXML | train | func (ctx *Context) ServeXML(obj interface{}) error {
encoder := xml.NewEncoder(ctx)
ctx.Header().Set("Content-Type", "application/xml; charset=UTF-8")
err := encoder.Encode(obj)
if err != nil {
ctx.Header().Del("Content-Type")
}
return err
} | go | {
"resource": ""
} |
q8846 | ServeJSON | train | func (ctx *Context) ServeJSON(obj interface{}) error {
encoder := json.NewEncoder(ctx)
ctx.Header().Set("Content-Type", "application/json; charset=UTF-8")
err := encoder.Encode(obj)
if err != nil {
ctx.Header().Del("Content-Type")
}
return err
} | go | {
"resource": ""
} |
q8847 | Body | train | func (ctx *Context) Body() ([]byte, error) {
if ctx.req.Body == nil {
return []byte{}, nil
}
body, err := ioutil.ReadAll(ctx.req.Body)
if err != nil {
return nil, err
}
ctx.req.Body.Close()
ctx.req.Body = ioutil.NopCloser(bytes.NewBuffer(body))
return body, nil
} | go | {
"resource": ""
} |
q8848 | DecodeJSON | train | func (ctx *Context) DecodeJSON(obj interface{}) error {
body, err := ctx.Body()
if err != nil {
return err
}
return json.Unmarshal(body, obj)
} | go | {
"resource": ""
} |
q8849 | DecodeXML | train | func (ctx *Context) DecodeXML(obj interface{}) error {
body, err := ctx.Body()
if err != nil {
return err
}
return xml.Unmarshal(body, obj)
} | go | {
"resource": ""
} |
q8850 | Download | train | func (ctx *Context) Download(fpath string) error {
f, err := os.Open(fpath)
if err != nil {
return err
}
defer f.Close()
fName := filepath.Base(fpath)
ctx.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=\"%v\"", fName))
_, err = io.Copy(ctx, f)
return err
} | go | {
"resource": ""
} |
q8851 | SaveToFile | train | func (ctx *Context) SaveToFile(formName, savePath string) error {
file, _, err := ctx.Req().FormFile(formName)
if err != nil {
return err
}
defer file.Close()
f, err := os.OpenFile(savePath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
if err != nil {
return err
}
defer f.Close()
_, err = io.Copy(f, file)
return err
} | go | {
"resource": ""
} |
q8852 | Redirect | train | func (ctx *Context) Redirect(url string, status ...int) {
s := http.StatusFound
if len(status) > 0 {
s = status[0]
}
http.Redirect(ctx.ResponseWriter, ctx.Req(), url, s)
} | go | {
"resource": ""
} |
q8853 | Unauthorized | train | func (ctx *Context) Unauthorized() {
ctx.Abort(http.StatusUnauthorized, http.StatusText(http.StatusUnauthorized))
} | go | {
"resource": ""
} |
q8854 | NotFound | train | func (ctx *Context) NotFound(message ...string) {
if len(message) == 0 {
ctx.Abort(http.StatusNotFound, http.StatusText(http.StatusNotFound))
return
}
ctx.Abort(http.StatusNotFound, message[0])
} | go | {
"resource": ""
} |
q8855 | Contexts | train | func Contexts() HandlerFunc {
return func(ctx *Context) {
if action := ctx.Action(); action != nil {
if a, ok := action.(Contexter); ok {
a.SetContext(ctx)
}
}
ctx.Next()
}
} | go | {
"resource": ""
} |
q8856 | Abort | train | func Abort(code int, content ...string) AbortError {
if len(content) >= 1 {
return &abortError{code, content[0]}
}
return &abortError{code, http.StatusText(code)}
} | go | {
"resource": ""
} |
q8857 | Errors | train | func Errors() HandlerFunc {
return func(ctx *Context) {
switch res := ctx.Result.(type) {
case AbortError:
ctx.WriteHeader(res.Code())
ctx.WriteString(res.Error())
case error:
ctx.WriteHeader(http.StatusInternalServerError)
ctx.WriteString(res.Error())
default:
ctx.WriteHeader(http.StatusInternalServerError)
ctx.WriteString(http.StatusText(http.StatusInternalServerError))
}
}
} | go | {
"resource": ""
} |
q8858 | IsFilterExt | train | func (s *StaticOptions) IsFilterExt(rPath string) bool {
rext := path.Ext(rPath)
for _, ext := range s.FilterExts {
if rext == ext {
return true
}
}
return false
} | go | {
"resource": ""
} |
q8859 | NewRoute | train | func NewRoute(v interface{}, t reflect.Type,
method reflect.Value, tp RouteType, handlers []Handler) *Route {
var pool *pool
if tp == StructRoute || tp == StructPtrRoute {
pool = newPool(PoolSize, t)
}
return &Route{
raw: v,
routeType: tp,
method: method,
pool: pool,
handlers: handlers,
}
} | go | {
"resource": ""
} |
q8860 | IsStruct | train | func (r *Route) IsStruct() bool {
return r.routeType == StructRoute || r.routeType == StructPtrRoute
} | go | {
"resource": ""
} |
q8861 | Less | train | func (e edges) Less(i, j int) bool {
if e[i].tp == snode {
if e[j].tp == snode {
return len(e[i].content) > len(e[j].content)
}
return true
}
if e[j].tp == snode {
return false
}
return i < j
} | go | {
"resource": ""
} |
q8862 | newRouter | train | func newRouter() (r *router) {
r = &router{
trees: make(map[string]*node),
}
for _, m := range SupportMethods {
r.trees[m] = &node{
edges: edges{},
}
}
return
} | go | {
"resource": ""
} |
q8863 | Match | train | func (r *router) Match(url, method string) (*Route, Params) {
cn, ok := r.trees[method]
if !ok {
return nil, nil
}
var params = make(Params, 0, strings.Count(url, "/"))
for _, n := range cn.edges {
e, newParams := r.matchNode(n, url, params)
if e != nil {
return e.handle, newParams
}
}
return nil, nil
} | go | {
"resource": ""
} |
q8864 | validNodes | train | func validNodes(nodes []*node) bool {
if len(nodes) == 0 {
return false
}
var lastTp = nodes[0]
for _, node := range nodes[1:] {
if lastTp.tp != snode && node.tp != snode {
return false
}
lastTp = node
}
return true
} | go | {
"resource": ""
} |
q8865 | addnodes | train | func (r *router) addnodes(method string, nodes []*node) {
cn := r.trees[method]
var p = cn
for i := 0; i < len(nodes); i++ {
p = r.addnode(p, nodes, i)
}
} | go | {
"resource": ""
} |
q8866 | Route | train | func (r *router) Route(ms interface{}, url string, c interface{}, handlers ...Handler) {
vc := reflect.ValueOf(c)
if vc.Kind() == reflect.Func {
switch ms.(type) {
case string:
s := strings.Split(ms.(string), ":")
r.addFunc([]string{s[0]}, url, c, handlers)
case []string:
var newSlice []string
for _, m := range ms.([]string) {
s := strings.Split(m, ":")
newSlice = append(newSlice, s[0])
}
r.addFunc(newSlice, url, c, handlers)
default:
panic("unknow methods format")
}
} else if vc.Kind() == reflect.Ptr && vc.Elem().Kind() == reflect.Struct {
if handler, ok := vc.Interface().(http.Handler); ok {
r.Route(ms, url, handler.ServeHTTP, handlers...)
return
}
var methods = make(map[string]string)
switch ms.(type) {
case string:
s := strings.Split(ms.(string), ":")
if len(s) == 1 {
methods[s[0]] = strings.Title(strings.ToLower(s[0]))
} else if len(s) == 2 {
methods[s[0]] = strings.TrimSpace(s[1])
} else {
panic("unknow methods format")
}
case []string:
for _, m := range ms.([]string) {
s := strings.Split(m, ":")
if len(s) == 1 {
methods[s[0]] = strings.Title(strings.ToLower(s[0]))
} else if len(s) == 2 {
methods[s[0]] = strings.TrimSpace(s[1])
} else {
panic("unknow format")
}
}
case map[string]string:
methods = ms.(map[string]string)
default:
panic("unsupported methods")
}
r.addStruct(methods, url, c, handlers)
} else {
panic("not support route type")
}
} | go | {
"resource": ""
} |
q8867 | Compresses | train | func Compresses(exts []string) HandlerFunc {
extsmap := make(map[string]bool)
for _, ext := range exts {
extsmap[strings.ToLower(ext)] = true
}
return func(ctx *Context) {
ae := ctx.Req().Header.Get("Accept-Encoding")
if ae == "" {
ctx.Next()
return
}
if len(extsmap) > 0 {
ext := strings.ToLower(path.Ext(ctx.Req().URL.Path))
if _, ok := extsmap[ext]; ok {
compress(ctx, "auto")
return
}
}
if action := ctx.Action(); action != nil {
if c, ok := action.(Compresser); ok {
compress(ctx, c.CompressType())
return
}
}
// if blank, then no compress
ctx.Next()
}
} | go | {
"resource": ""
} |
q8868 | Recovery | train | func Recovery(debug bool) HandlerFunc {
return func(ctx *Context) {
defer func() {
if e := recover(); e != nil {
var buf bytes.Buffer
fmt.Fprintf(&buf, "Handler crashed with error: %v", e)
for i := 1; ; i++ {
_, file, line, ok := runtime.Caller(i)
if !ok {
break
} else {
fmt.Fprintf(&buf, "\n")
}
fmt.Fprintf(&buf, "%v:%v", file, line)
}
var content = buf.String()
ctx.Logger.Error(content)
if !ctx.Written() {
if !debug {
ctx.Result = InternalServerError(http.StatusText(http.StatusInternalServerError))
} else {
ctx.Result = InternalServerError(content)
}
}
}
}()
ctx.Next()
}
} | go | {
"resource": ""
} |
q8869 | Get | train | func (p *Params) Get(key string) string {
if len(key) == 0 {
return ""
}
if key[0] != ':' && key[0] != '*' {
key = ":" + key
}
for _, v := range *p {
if v.Name == key {
return v.Value
}
}
return ""
} | go | {
"resource": ""
} |
q8870 | Strings | train | func (p *Params) Strings(key string) ([]string, error) {
if len(key) == 0 {
return nil, errors.New("not exist")
}
if key[0] != ':' && key[0] != '*' {
key = ":" + key
}
var s = make([]string, 0)
for _, v := range *p {
if v.Name == key {
s = append(s, v.Value)
}
}
if len(s) > 0 {
return s, nil
}
return nil, errors.New("not exist")
} | go | {
"resource": ""
} |
q8871 | MustString | train | func (p *Params) MustString(key string, defaults ...string) string {
if len(key) == 0 {
return ""
}
if key[0] != ':' && key[0] != '*' {
key = ":" + key
}
for _, v := range *p {
if v.Name == key {
return v.Value
}
}
if len(defaults) > 0 {
return defaults[0]
}
return ""
} | go | {
"resource": ""
} |
q8872 | MustStrings | train | func (p *Params) MustStrings(key string, defaults ...[]string) []string {
if len(key) == 0 {
return []string{}
}
if key[0] != ':' && key[0] != '*' {
key = ":" + key
}
var s = make([]string, 0)
for _, v := range *p {
if v.Name == key {
s = append(s, v.Value)
}
}
if len(s) > 0 {
return s
}
if len(defaults) > 0 {
return defaults[0]
}
return []string{}
} | go | {
"resource": ""
} |
q8873 | Param | train | func (ctx *Context) Param(key string, defaults ...string) string {
return ctx.Params().MustString(key, defaults...)
} | go | {
"resource": ""
} |
q8874 | ParamStrings | train | func (ctx *Context) ParamStrings(key string, defaults ...[]string) []string {
return ctx.Params().MustStrings(key, defaults...)
} | go | {
"resource": ""
} |
q8875 | ParamEscape | train | func (ctx *Context) ParamEscape(key string, defaults ...string) string {
return ctx.Params().MustEscape(key, defaults...)
} | go | {
"resource": ""
} |
q8876 | ParamInt | train | func (ctx *Context) ParamInt(key string, defaults ...int) int {
return ctx.Params().MustInt(key, defaults...)
} | go | {
"resource": ""
} |
q8877 | ParamInt32 | train | func (ctx *Context) ParamInt32(key string, defaults ...int32) int32 {
return ctx.Params().MustInt32(key, defaults...)
} | go | {
"resource": ""
} |
q8878 | ParamInt64 | train | func (ctx *Context) ParamInt64(key string, defaults ...int64) int64 {
return ctx.Params().MustInt64(key, defaults...)
} | go | {
"resource": ""
} |
q8879 | ParamUint | train | func (ctx *Context) ParamUint(key string, defaults ...uint) uint {
return ctx.Params().MustUint(key, defaults...)
} | go | {
"resource": ""
} |
q8880 | ParamUint32 | train | func (ctx *Context) ParamUint32(key string, defaults ...uint32) uint32 {
return ctx.Params().MustUint32(key, defaults...)
} | go | {
"resource": ""
} |
q8881 | ParamUint64 | train | func (ctx *Context) ParamUint64(key string, defaults ...uint64) uint64 {
return ctx.Params().MustUint64(key, defaults...)
} | go | {
"resource": ""
} |
q8882 | ParamFloat32 | train | func (ctx *Context) ParamFloat32(key string, defaults ...float32) float32 {
return ctx.Params().MustFloat32(key, defaults...)
} | go | {
"resource": ""
} |
q8883 | ParamFloat64 | train | func (ctx *Context) ParamFloat64(key string, defaults ...float64) float64 {
return ctx.Params().MustFloat64(key, defaults...)
} | go | {
"resource": ""
} |
q8884 | ParamBool | train | func (ctx *Context) ParamBool(key string, defaults ...bool) bool {
return ctx.Params().MustBool(key, defaults...)
} | go | {
"resource": ""
} |
q8885 | Param | train | func Param() HandlerFunc {
return func(ctx *Context) {
if action := ctx.Action(); action != nil {
if p, ok := action.(Paramer); ok {
p.SetParams(*ctx.Params())
}
}
ctx.Next()
}
} | go | {
"resource": ""
} |
q8886 | Use | train | func (g *Group) Use(handlers ...Handler) {
g.handlers = append(g.handlers, handlers...)
} | go | {
"resource": ""
} |
q8887 | Get | train | func (g *Group) Get(url string, c interface{}, middlewares ...Handler) {
g.Route([]string{"GET", "HEAD:Get"}, url, c, middlewares...)
} | go | {
"resource": ""
} |
q8888 | Any | train | func (g *Group) Any(url string, c interface{}, middlewares ...Handler) {
g.Route(SupportMethods, url, c, middlewares...)
g.Route([]string{"HEAD:Get"}, url, c, middlewares...)
} | go | {
"resource": ""
} |
q8889 | Route | train | func (g *Group) Route(methods interface{}, url string, c interface{}, middlewares ...Handler) {
g.routers = append(g.routers, groupRouter{methods, url, c, middlewares})
} | go | {
"resource": ""
} |
q8890 | Group | train | func (g *Group) Group(p string, o interface{}) {
gr := getGroup(o)
for _, gchild := range gr.routers {
g.Route(gchild.methods, joinRoute(p, gchild.url), gchild.c, append(gr.handlers, gchild.handlers...)...)
}
} | go | {
"resource": ""
} |
q8891 | Group | train | func (t *Tango) Group(p string, o interface{}) {
t.addGroup(p, getGroup(o))
} | go | {
"resource": ""
} |
q8892 | MigrateTo | train | func (g *Gormigrate) MigrateTo(migrationID string) error {
if err := g.checkIDExist(migrationID); err != nil {
return err
}
return g.migrate(migrationID)
} | go | {
"resource": ""
} |
q8893 | hasMigrations | train | func (g *Gormigrate) hasMigrations() bool {
return g.initSchema != nil || len(g.migrations) > 0
} | go | {
"resource": ""
} |
q8894 | checkReservedID | train | func (g *Gormigrate) checkReservedID() error {
for _, m := range g.migrations {
if m.ID == initSchemaMigrationID {
return &ReservedIDError{ID: m.ID}
}
}
return nil
} | go | {
"resource": ""
} |
q8895 | RollbackTo | train | func (g *Gormigrate) RollbackTo(migrationID string) error {
if len(g.migrations) == 0 {
return ErrNoMigrationDefined
}
if err := g.checkIDExist(migrationID); err != nil {
return err
}
g.begin()
defer g.rollback()
for i := len(g.migrations) - 1; i >= 0; i-- {
migration := g.migrations[i]
if migration.ID == migrationID {
break
}
migrationRan, err := g.migrationRan(migration)
if err != nil {
return err
}
if migrationRan {
if err := g.rollbackMigration(migration); err != nil {
return err
}
}
}
return g.commit()
} | go | {
"resource": ""
} |
q8896 | canInitializeSchema | train | func (g *Gormigrate) canInitializeSchema() (bool, error) {
migrationRan, err := g.migrationRan(&Migration{ID: initSchemaMigrationID})
if err != nil {
return false, err
}
if migrationRan {
return false, nil
}
// If the ID doesn't exist, we also want the list of migrations to be empty
var count int
err = g.tx.
Table(g.options.TableName).
Count(&count).
Error
return count == 0, err
} | go | {
"resource": ""
} |
q8897 | One | train | func (mock *MyInterfaceMock) One() bool {
if mock.OneFunc == nil {
panic("MyInterfaceMock.OneFunc: method is nil but MyInterface.One was just called")
}
callInfo := struct {
}{}
lockMyInterfaceMockOne.Lock()
mock.calls.One = append(mock.calls.One, callInfo)
lockMyInterfaceMockOne.Unlock()
return mock.OneFunc()
} | go | {
"resource": ""
} |
q8898 | Three | train | func (mock *MyInterfaceMock) Three() string {
if mock.ThreeFunc == nil {
panic("MyInterfaceMock.ThreeFunc: method is nil but MyInterface.Three was just called")
}
callInfo := struct {
}{}
lockMyInterfaceMockThree.Lock()
mock.calls.Three = append(mock.calls.Three, callInfo)
lockMyInterfaceMockThree.Unlock()
return mock.ThreeFunc()
} | go | {
"resource": ""
} |
q8899 | Two | train | func (mock *MyInterfaceMock) Two() int {
if mock.TwoFunc == nil {
panic("MyInterfaceMock.TwoFunc: method is nil but MyInterface.Two was just called")
}
callInfo := struct {
}{}
lockMyInterfaceMockTwo.Lock()
mock.calls.Two = append(mock.calls.Two, callInfo)
lockMyInterfaceMockTwo.Unlock()
return mock.TwoFunc()
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.