_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q181600 | StrLenIn | test | func (c *Controller) StrLenIn(fieldName string, p interface{}, l ...int) string {
if p == nil {
p = ""
}
v, ok := p.(string)
if ok == false {
panic((&ValidationError{}).New(fieldName + "格式错误"))
}
length := utf8.RuneCountInString(v)
b := false
for i := 0; i < len(l); i++ {
if l[i] == length {
b = true
... | go | {
"resource": ""
} |
q181601 | StrIn | test | func (c *Controller) StrIn(fieldName string, p interface{}, l ...string) string {
if p == nil {
p = ""
}
v, ok := p.(string)
if ok == false {
panic((&ValidationError{}).New(fieldName + "格式错误"))
}
b := false
for i := 0; i < len(l); i++ {
if l[i] == v {
b = true
}
}
if b == false {
panic((&Validatio... | go | {
"resource": ""
} |
q181602 | GetEmail | test | func (c *Controller) GetEmail(fieldName string, p interface{}) string {
if p == nil {
p = ""
}
v, ok := p.(string)
if ok == false {
panic((&ValidationError{}).New(fieldName + "格式错误"))
}
b := c.Validate.Email(v)
if b == false {
panic((&ValidationError{}).New(fieldName + "格式错误"))
}
return v
} | go | {
"resource": ""
} |
q181603 | MostSpecificType | test | func MostSpecificType(types []string) (string, error) {
if len(types) == 0 {
return "", errors.New("no types supplied")
}
sorted, err := SortTypes(types)
if err != nil {
return "", err
}
return sorted[len(sorted)-1], nil
} | go | {
"resource": ""
} |
q181604 | FullTypeHierarchy | test | func FullTypeHierarchy(highestLevelType string) []string {
var typeHierarchy []string
t := strings.Split(highestLevelType, "/")
typeToCheck := t[len(t)-1]
for {
typeHierarchy = append(typeHierarchy, typeToCheck)
parentType := ParentType(typeToCheck)
if parentType != "" {
typeToCheck = parentType
} else {... | go | {
"resource": ""
} |
q181605 | SortTypes | test | func SortTypes(types []string) ([]string, error) {
ts := &typeSorter{types: make([]string, len(types))}
copy(ts.types, types)
sort.Sort(ts)
if ts.invalid {
return types, ErrNotHierarchy
}
return ts.types, nil
} | go | {
"resource": ""
} |
q181606 | Delete | test | func (rs *redisStore) Delete(key string) error {
delete(rs.Values, key)
err := provider.refresh(rs)
return err
} | go | {
"resource": ""
} |
q181607 | Set | test | func (rp *redisProvider) Set(key string, values map[string]string) (*redisStore, error) {
rs := &redisStore{SID: key, Values: values}
err := provider.refresh(rs)
return rs, err
} | go | {
"resource": ""
} |
q181608 | refresh | test | func (rp *redisProvider) refresh(rs *redisStore) error {
var err error
redisPool.Exec(func(c *redis.Client) {
err = c.HMSet(rs.SID, rs.Values).Err()
if err != nil {
return
}
err = c.Expire(rs.SID, sessExpire).Err()
})
return nil
} | go | {
"resource": ""
} |
q181609 | Get | test | func (rp *redisProvider) Get(sid string) (*redisStore, error) {
var rs = &redisStore{}
var val map[string]string
var err error
redisPool.Exec(func(c *redis.Client) {
val, err = c.HGetAll(sid).Result()
rs.Values = val
})
return rs, err
} | go | {
"resource": ""
} |
q181610 | Destroy | test | func (rp *redisProvider) Destroy(sid string) error {
var err error
redisPool.Exec(func(c *redis.Client) {
err = c.Del(sid).Err()
})
return err
} | go | {
"resource": ""
} |
q181611 | UpExpire | test | func (rp *redisProvider) UpExpire(sid string) error {
var err error
redisPool.Exec(func(c *redis.Client) {
err = c.Expire(sid, sessExpire).Err()
})
return err
} | go | {
"resource": ""
} |
q181612 | Use | test | func (hs *HandlersStack) Use(h RouterHandler) {
hs.Handlers = append(hs.Handlers, h)
} | go | {
"resource": ""
} |
q181613 | ServeHTTP | test | func (hs *HandlersStack) ServeHTTP(w http.ResponseWriter, r *http.Request) {
// Get a context for the request from ctxPool.
c := getContext(w, r)
// Set some "good practice" default headers.
c.ResponseWriter.Header().Set("Cache-Control", "no-cache")
c.ResponseWriter.Header().Set("Content-Type", "application/json"... | go | {
"resource": ""
} |
q181614 | Use | test | func (group *RouterGroup) Use(middleware ...RouterHandler) IRoutes {
group.Handlers = append(group.Handlers, middleware...)
return group.returnObj()
} | go | {
"resource": ""
} |
q181615 | Group | test | func (group *RouterGroup) Group(relativePath string, handlers ...RouterHandler) *RouterGroup {
return &RouterGroup{
Handlers: group.combineHandlers(handlers),
basePath: group.calculateAbsolutePath(relativePath),
engine: group.engine,
}
} | go | {
"resource": ""
} |
q181616 | Run | test | func Run() {
for _, f := range beforeRun {
f()
}
// parse command line params.
if OpenCommandLine {
flag.StringVar(&Address, "address", ":8080", "-address=:8080")
flag.BoolVar(&Production, "production", false, "-production=false")
flag.Parse()
}
log.Warnln(fmt.Sprintf("Serving %s with pid %d. Production... | go | {
"resource": ""
} |
q181617 | create | test | func create() *Engine {
engine := &Engine{
RouterGroup: RouterGroup{
Handlers: nil,
basePath: "/",
root: true,
},
trees: make(methodTrees, 0, 9),
}
engine.RouterGroup.engine = engine
return engine
} | go | {
"resource": ""
} |
q181618 | Redirect | test | func (ctx *Context) Redirect(url string, code int) {
http.Redirect(ctx.ResponseWriter, ctx.Request, url, code)
} | go | {
"resource": ""
} |
q181619 | Ok | test | func (ctx *Context) Ok(data interface{}) {
if ctx.written == true {
log.WithFields(log.Fields{"path": ctx.Request.URL.Path}).Warnln("Context.Success: request has been writed")
return
}
ctx.written = true
var json = jsoniter.ConfigCompatibleWithStandardLibrary
b, _ := json.Marshal(&ResFormat{Ok: true, Data: dat... | go | {
"resource": ""
} |
q181620 | Fail | test | func (ctx *Context) Fail(err error) {
if err == nil {
log.WithFields(log.Fields{"path": ctx.Request.URL.Path}).Warnln("Context.Fail: err is nil")
ctx.ResponseWriter.WriteHeader(http.StatusInternalServerError)
ctx.ResponseWriter.Write(nil)
return
}
if ctx.written == true {
log.WithFields(log.Fields{"path":... | go | {
"resource": ""
} |
q181621 | ResStatus | test | func (ctx *Context) ResStatus(code int) (int, error) {
if ctx.written == true {
return 0, errors.New("Context.ResStatus: request has been writed")
}
ctx.written = true
ctx.ResponseWriter.WriteHeader(code)
return fmt.Fprint(ctx.ResponseWriter, http.StatusText(code))
} | go | {
"resource": ""
} |
q181622 | Next | test | func (ctx *Context) Next() {
// Call the next handler only if there is one and the response hasn't been written.
if !ctx.Written() && ctx.index < len(ctx.handlersStack.Handlers)-1 {
ctx.index++
ctx.handlersStack.Handlers[ctx.index](ctx)
}
} | go | {
"resource": ""
} |
q181623 | GetSession | test | func (ctx *Context) GetSession() IStore {
store := ctx.Data["session"]
if store == nil {
return nil
}
st, ok := store.(IStore)
if ok == false {
return nil
}
return st
} | go | {
"resource": ""
} |
q181624 | GetBodyJSON | test | func (ctx *Context) GetBodyJSON() {
var reqJSON map[string]interface{}
body, _ := ioutil.ReadAll(ctx.Request.Body)
defer ctx.Request.Body.Close()
cType := ctx.Request.Header.Get("Content-Type")
a := strings.Split(cType, ";")
if a[0] == "application/x-www-form-urlencoded" {
reqJSON = make(map[string]interface{})... | go | {
"resource": ""
} |
q181625 | SetSession | test | func (ctx *Context) SetSession(key string, values map[string]string) error {
sid := ctx.genSid(key)
values["Sid"] = sid
timestamp := strconv.FormatInt(time.Now().Unix(), 10)
token := ctx.genSid(key + timestamp)
values["Token"] = token
store, err := provider.Set(sid, values)
if err != nil {
return err
}
cooki... | go | {
"resource": ""
} |
q181626 | FreshSession | test | func (ctx *Context) FreshSession(key string) error {
err := provider.UpExpire(key)
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q181627 | DeleteSession | test | func (ctx *Context) DeleteSession() error {
sid := ctx.Data["Sid"].(string)
ctx.Data["session"] = nil
provider.Destroy(sid)
cookie := httpCookie
cookie.MaxAge = -1
http.SetCookie(ctx.ResponseWriter, &cookie)
return nil
} | go | {
"resource": ""
} |
q181628 | Write | test | func (w contextWriter) Write(p []byte) (int, error) {
w.context.written = true
return w.ResponseWriter.Write(p)
} | go | {
"resource": ""
} |
q181629 | WriteHeader | test | func (w contextWriter) WriteHeader(code int) {
w.context.written = true
w.ResponseWriter.WriteHeader(code)
} | go | {
"resource": ""
} |
q181630 | New | test | func New(pemPath string, options ...func(*Client) error) *Client {
c := Client{
pemPath: pemPath,
RequestTimeout: defaultRequestTimeout,
}
c.PrintDebug = false
for _, option := range options {
err := option(&c)
if err != nil {
return nil
}
}
return &c
} | go | {
"resource": ""
} |
q181631 | setAllowLargeResults | test | func (c *Client) setAllowLargeResults(shouldAllow bool, tempTableName string, flattenResults bool) error {
c.allowLargeResults = shouldAllow
c.tempTableName = tempTableName
c.flattenResults = flattenResults
return nil
} | go | {
"resource": ""
} |
q181632 | connect | test | func (c *Client) connect() (*bigquery.Service, error) {
if c.token != nil {
if !c.token.Valid() && c.service != nil {
return c.service, nil
}
}
// generate auth token and create service object
//authScope := bigquery.BigqueryScope
pemKeyBytes, err := ioutil.ReadFile(c.pemPath)
if err != nil {
panic(err)... | go | {
"resource": ""
} |
q181633 | InsertRow | test | func (c *Client) InsertRow(projectID, datasetID, tableID string, rowData map[string]interface{}) error {
service, err := c.connect()
if err != nil {
return err
}
insertRequest := buildBigQueryInsertRequest([]map[string]interface{}{rowData})
result, err := service.Tabledata.InsertAll(projectID, datasetID, table... | go | {
"resource": ""
} |
q181634 | AsyncQuery | test | func (c *Client) AsyncQuery(pageSize int, dataset, project, queryStr string, dataChan chan Data) {
c.pagedQuery(pageSize, dataset, project, queryStr, dataChan)
} | go | {
"resource": ""
} |
q181635 | Query | test | func (c *Client) Query(dataset, project, queryStr string) ([][]interface{}, []string, error) {
return c.pagedQuery(defaultPageSize, dataset, project, queryStr, nil)
} | go | {
"resource": ""
} |
q181636 | stdPagedQuery | test | func (c *Client) stdPagedQuery(service *bigquery.Service, pageSize int, dataset, project, queryStr string, dataChan chan Data) ([][]interface{}, []string, error) {
c.printDebug("std paged query")
datasetRef := &bigquery.DatasetReference{
DatasetId: dataset,
ProjectId: project,
}
query := &bigquery.QueryRequest... | go | {
"resource": ""
} |
q181637 | largeDataPagedQuery | test | func (c *Client) largeDataPagedQuery(service *bigquery.Service, pageSize int, dataset, project, queryStr string, dataChan chan Data) ([][]interface{}, []string, error) {
c.printDebug("largeDataPagedQuery starting")
ts := time.Now()
// start query
tableRef := bigquery.TableReference{DatasetId: dataset, ProjectId: pr... | go | {
"resource": ""
} |
q181638 | pagedQuery | test | func (c *Client) pagedQuery(pageSize int, dataset, project, queryStr string, dataChan chan Data) ([][]interface{}, []string, error) {
// connect to service
service, err := c.connect()
if err != nil {
if dataChan != nil {
dataChan <- Data{Err: err}
}
return nil, nil, err
}
if c.allowLargeResults && len(c.... | go | {
"resource": ""
} |
q181639 | pageOverJob | test | func (c *Client) pageOverJob(rowCount int, jobRef *bigquery.JobReference, pageToken string, resultChan chan [][]interface{}, headersChan chan []string) error {
service, err := c.connect()
if err != nil {
return err
}
qrc := service.Jobs.GetQueryResults(jobRef.ProjectId, jobRef.JobId)
if len(pageToken) > 0 {
q... | go | {
"resource": ""
} |
q181640 | Count | test | func (c *Client) Count(dataset, project, datasetTable string) int64 {
qstr := fmt.Sprintf("select count(*) from [%s]", datasetTable)
res, err := c.SyncQuery(dataset, project, qstr, 1)
if err == nil {
if len(res) > 0 {
val, _ := strconv.ParseInt(res[0][0].(string), 10, 64)
return val
}
}
return 0
} | go | {
"resource": ""
} |
q181641 | work | test | func work(args ...interface{}) interface{} {
url := args[0].(string)
depth := args[1].(int)
fetcher := args[2].(Fetcher)
if depth <= 0 {
return crawlResult{}
}
body, urls, err := fetcher.Fetch(url)
return crawlResult{body, urls, err}
} | go | {
"resource": ""
} |
q181642 | subworker | test | func (pool *Pool) subworker(job *Job) {
defer func() {
if err := recover(); err != nil {
log.Println("panic while running job:", err)
job.Result = nil
job.Err = fmt.Errorf(err.(string))
}
}()
job.Result = job.F(job.Args...)
} | go | {
"resource": ""
} |
q181643 | worker | test | func (pool *Pool) worker(worker_id uint) {
job_pipe := make(chan *Job)
WORKER_LOOP:
for {
pool.job_wanted_pipe <- job_pipe
job := <-job_pipe
if job == nil {
time.Sleep(pool.interval * time.Millisecond)
} else {
job.Worker_id = worker_id
pool.subworker(job)
pool.done_pipe <- job
}
select {
ca... | go | {
"resource": ""
} |
q181644 | supervisor | test | func (pool *Pool) supervisor() {
SUPERVISOR_LOOP:
for {
select {
// new job
case job := <-pool.add_pipe:
pool.jobs_ready_to_run.PushBack(job)
pool.num_jobs_submitted++
job.added <- true
// send jobs to the workers
case job_pipe := <-pool.job_wanted_pipe:
element := pool.jobs_ready_to_run.Front()
... | go | {
"resource": ""
} |
q181645 | Run | test | func (pool *Pool) Run() {
if pool.workers_started {
panic("trying to start a pool that's already running")
}
for i := uint(0); i < uint(pool.num_workers); i++ {
pool.worker_wg.Add(1)
go pool.worker(i)
}
pool.workers_started = true
// handle the supervisor
if !pool.supervisor_started {
pool.startSuperviso... | go | {
"resource": ""
} |
q181646 | Add | test | func (pool *Pool) Add(f func(...interface{}) interface{}, args ...interface{}) {
job := &Job{f, args, nil, nil, make(chan bool), 0, pool.getNextJobId()}
pool.add_pipe <- job
<-job.added
} | go | {
"resource": ""
} |
q181647 | Wait | test | func (pool *Pool) Wait() {
working_pipe := make(chan bool)
for {
pool.working_wanted_pipe <- working_pipe
if !<-working_pipe {
break
}
time.Sleep(pool.interval * time.Millisecond)
}
} | go | {
"resource": ""
} |
q181648 | Results | test | func (pool *Pool) Results() (res []*Job) {
res = make([]*Job, pool.jobs_completed.Len())
i := 0
for e := pool.jobs_completed.Front(); e != nil; e = e.Next() {
res[i] = e.Value.(*Job)
i++
}
pool.jobs_completed = list.New()
return
} | go | {
"resource": ""
} |
q181649 | WaitForJob | test | func (pool *Pool) WaitForJob() *Job {
result_pipe := make(chan *Job)
var job *Job
var ok bool
for {
pool.result_wanted_pipe <- result_pipe
job, ok = <-result_pipe
if !ok {
// no more results available
return nil
}
if job == (*Job)(nil) {
// no result available right now but there are jobs running... | go | {
"resource": ""
} |
q181650 | Status | test | func (pool *Pool) Status() stats {
stats_pipe := make(chan stats)
if pool.supervisor_started {
pool.stats_wanted_pipe <- stats_pipe
return <-stats_pipe
}
// the supervisor wasn't started so we return a zeroed structure
return stats{}
} | go | {
"resource": ""
} |
q181651 | WrapHTTPHandlerFunc | test | func WrapHTTPHandlerFunc(f http.HandlerFunc) HandlerFunc {
newF := func(ctx *Context) error {
f(ctx.Response, ctx.Request)
return nil
}
return newF
} | go | {
"resource": ""
} |
q181652 | WebSocketHandlerFunc | test | func WebSocketHandlerFunc(f func(ws *websocket.Conn)) HandlerFunc {
h := websocket.Handler(f)
return WrapHTTPHandlerFunc(h.ServeHTTP)
} | go | {
"resource": ""
} |
q181653 | StaticFile | test | func StaticFile(filename string, contentType string) staticFile {
if contentType == "" {
contentType = mime.TypeByExtension(path.Ext(filename))
}
header := make(http.Header)
header.Set("Content-Type", contentType)
return staticFile{filename, header}
} | go | {
"resource": ""
} |
q181654 | PreloadFile | test | func PreloadFile(filename string, contentType string) (preloadFile, error) {
body, err := ioutil.ReadFile(filename)
if err != nil {
return preloadFile{}, err
}
if contentType == "" {
contentType = mime.TypeByExtension(path.Ext(filename))
}
header := make(http.Header)
header.Set("Content-Type", contentType)
... | go | {
"resource": ""
} |
q181655 | InitHtmlTemplates | test | func InitHtmlTemplates(pattern string) (err error) {
htmlTemp.Template, err = html.ParseGlob(pattern)
return
} | go | {
"resource": ""
} |
q181656 | InitTextTemplates | test | func InitTextTemplates(pattern string) (err error) {
textTemp.Template, err = text.ParseGlob(pattern)
return nil
} | go | {
"resource": ""
} |
q181657 | Html | test | func Html(name, contentType, charSet string) template {
if htmlTemp.Template == nil {
panic("Function `InitHtmlTemplates` should be called first.")
}
if contentType == "" {
contentType = ContentTypeHTML
}
if charSet == "" {
charSet = CharSetUTF8
}
header := make(http.Header)
header.Set("Content-Type",
f... | go | {
"resource": ""
} |
q181658 | Text | test | func Text(name, contentType, charSet string) template {
if textTemp.Template == nil {
panic("Function `InitTextTemplates` should be called first.")
}
if contentType == "" {
contentType = ContentTypePlain
}
if charSet == "" {
charSet = CharSetUTF8
}
header := make(http.Header)
header.Set("Content-Type",
... | go | {
"resource": ""
} |
q181659 | InitWatcher | test | func InitWatcher(pattern string, f func(string) error, ef func(error)) (err error) {
if err = f(pattern); err != nil {
return
}
if watcher.Watcher == nil {
watcher.Watcher, err = fsnotify.NewWatcher()
if err != nil {
return
}
watcher.closer = make(chan bool)
}
go func() {
atomic.AddUint32(&watcher.c... | go | {
"resource": ""
} |
q181660 | CloseWatcher | test | func CloseWatcher() error {
for i := uint32(0); i < watcher.count; i++ {
watcher.closer <- true
}
return watcher.Close()
} | go | {
"resource": ""
} |
q181661 | Find | test | func (rs *Routers) Find(path string) (url.Values, HandlerFunc, view.View) {
defer rs.RUnlock()
rs.RLock()
if s, ok := rs.s[path]; ok {
return nil, s.h, s.v
}
for e := rs.l.Front(); e != nil; e = e.Next() {
s := e.Value.(struct {
r router.Router
v view.View
h HandlerFunc
})
if params, ok := s.r.Mat... | go | {
"resource": ""
} |
q181662 | Add | test | func (rs *Routers) Add(r router.Router, h HandlerFunc, v view.View) {
defer rs.Unlock()
rs.Lock()
s := struct {
r router.Router
v view.View
h HandlerFunc
}{r, v, h}
// simple will full-match the path
if sr, ok := r.(*router.Base); ok {
rs.s[sr.Path] = s
return
}
rs.l.PushFront(s)
} | go | {
"resource": ""
} |
q181663 | NewRouters | test | func NewRouters() *Routers {
return &Routers{
s: make(map[string]struct {
r router.Router
v view.View
h HandlerFunc
}),
l: list.New(),
}
} | go | {
"resource": ""
} |
q181664 | NewServerMux | test | func NewServerMux() (mux *ServerMux) {
nf := struct {
View view.View
Handler HandlerFunc
}{view.Simple(view.ContentTypePlain, view.CharSetUTF8), defaultNotFound}
return &ServerMux{NewRouters(), nil, nil, nil, nf}
} | go | {
"resource": ""
} |
q181665 | err | test | func (mux *ServerMux) err(err error) {
if mux.ErrorHandle != nil {
mux.ErrorHandle(err)
}
} | go | {
"resource": ""
} |
q181666 | HandleFunc | test | func (mux *ServerMux) HandleFunc(r router.Router, h HandlerFunc, v view.View) {
mux.routers.Add(r, h, v)
} | go | {
"resource": ""
} |
q181667 | handleError | test | func (mux *ServerMux) handleError(ctx *Context, err error) bool {
if err == nil {
return false
}
if e, ok := err.(Error); ok {
ctx.Response.Status = e.Status
ctx.Response.Data = e
return true
}
if ctx.Response.Status == http.StatusOK {
ctx.Response.Status = http.StatusInternalServerError
}
ctx.Response... | go | {
"resource": ""
} |
q181668 | Redirect | test | func (ctx *Context) Redirect(code int, url string) {
ctx.Response.Status = code
ctx.Response.Data = url
} | go | {
"resource": ""
} |
q181669 | InitPProf | test | func (mux *ServerMux) InitPProf(prefix string) {
if prefix == "" {
prefix = "/debug/pprof"
}
mux.HandleFunc(router.Wildcard(fmt.Sprintf("%s/*", prefix)),
WrapHTTPHandlerFunc(pprofIndex(prefix)), nil)
mux.HandleFunc(router.Simple(fmt.Sprintf("%s/cmdline", prefix)),
WrapHTTPHandlerFunc(http.HandlerFunc(pprof.Cm... | go | {
"resource": ""
} |
q181670 | StartSession | test | func (ctx *Context) StartSession(f session.FactoryFunc) (err error) {
ctx.Session, err = f(ctx.Response, ctx.Request)
return
} | go | {
"resource": ""
} |
q181671 | combinations | test | func combinations(list []int, select_num, buf int) (c chan []int) {
c = make(chan []int, buf)
go func() {
defer close(c)
switch {
case select_num == 0:
c <- []int{}
case select_num == len(list):
c <- list
case len(list) < select_num:
return
default:
for i := 0; i < len(list); i++ {
for sub... | go | {
"resource": ""
} |
q181672 | repeated_combinations | test | func repeated_combinations(list []int, select_num, buf int) (c chan []int) {
c = make(chan []int, buf)
go func() {
defer close(c)
if select_num == 1 {
for v := range list {
c <- []int{v}
}
return
}
for i := 0; i < len(list); i++ {
for sub_comb := range repeated_combinations(list[i:], select_nu... | go | {
"resource": ""
} |
q181673 | permutations | test | func permutations(list []int, select_num, buf int) (c chan []int) {
c = make(chan []int, buf)
go func() {
defer close(c)
switch select_num {
case 1:
for _, v := range list {
c <- []int{v}
}
return
case 0:
return
case len(list):
for i := 0; i < len(list); i++ {
top, sub_list := pop(lis... | go | {
"resource": ""
} |
q181674 | repeated_permutations | test | func repeated_permutations(list []int, select_num, buf int) (c chan []int) {
c = make(chan []int, buf)
go func() {
defer close(c)
switch select_num {
case 1:
for _, v := range list {
c <- []int{v}
}
default:
for i := 0; i < len(list); i++ {
for perm := range repeated_permutations(list, select... | go | {
"resource": ""
} |
q181675 | gformat | test | func gformat(format string, args map[string]interface{}) (string, []interface{}) {
// holder for new format string - capacity as length of provided string
// should be enough not to resize during appending, since expected length
// of new format is smaller then provided one (names are removed)
var new_format = make... | go | {
"resource": ""
} |
q181676 | Errorm | test | func Errorm(format string, args map[string]interface{}) error {
f, a := gformat(format, args)
return fmt.Errorf(f, a...)
} | go | {
"resource": ""
} |
q181677 | Fprintm | test | func Fprintm(w io.Writer, format string, args map[string]interface{}) (n int, err error) {
f, a := gformat(format, args)
return fmt.Fprintf(w, f, a...)
} | go | {
"resource": ""
} |
q181678 | Printm | test | func Printm(format string, args map[string]interface{}) (n int, err error) {
f, a := gformat(format, args)
return fmt.Printf(f, a...)
} | go | {
"resource": ""
} |
q181679 | Sprintm | test | func Sprintm(format string, args map[string]interface{}) string {
f, a := gformat(format, args)
return fmt.Sprintf(f, a...)
} | go | {
"resource": ""
} |
q181680 | Validate | test | func (p *PasswordStrengthRequirements) Validate(password string) (bool, string) {
reqs := MakeRequirements(password)
if p.MaximumTotalLength > 0 && reqs.MaximumTotalLength > p.MaximumTotalLength {
return false, "password is too long"
}
if reqs.MinimumTotalLength < p.MinimumTotalLength {
return false, "password ... | go | {
"resource": ""
} |
q181681 | MakeRequirements | test | func MakeRequirements(password string) PasswordStrengthRequirements {
pwd := []byte(password)
reqs := PasswordStrengthRequirements{}
reqs.MaximumTotalLength = len(password)
reqs.MinimumTotalLength = len(password)
for i := range pwd {
switch {
case unicode.IsDigit(rune(pwd[i])):
reqs.Digits++
case unicode.... | go | {
"resource": ""
} |
q181682 | sanityCheck | test | func (p *PasswordStrengthRequirements) sanityCheck() (bool, string) {
if p.MaximumTotalLength == 0 {
return true, ""
}
if p.MaximumTotalLength < p.MinimumTotalLength {
return false, "maximum total length is less than minimum total length"
}
if p.MaximumTotalLength < p.Digits {
return false, "maximum required... | go | {
"resource": ""
} |
q181683 | password | test | func (g Garbler) password(req PasswordStrengthRequirements) (string, error) {
//Step 1: Figure out settings
letters := 0
mustGarble := 0
switch {
case req.MaximumTotalLength > 0 && req.MaximumTotalLength > 6:
letters = req.MaximumTotalLength - req.Digits - req.Punctuation
case req.MaximumTotalLength > 0 && req.... | go | {
"resource": ""
} |
q181684 | NewPassword | test | func NewPassword(reqs *PasswordStrengthRequirements) (string, error) {
if reqs == nil {
reqs = &Medium
}
if ok, problems := reqs.sanityCheck(); !ok {
return "", errors.New("requirements failed validation: " + problems)
}
e := Garbler{}
return e.password(*reqs)
} | go | {
"resource": ""
} |
q181685 | NewPasswords | test | func NewPasswords(reqs *PasswordStrengthRequirements, n int) ([]string, error) {
var err error
if reqs == nil {
reqs = &Medium
}
if ok, problems := reqs.sanityCheck(); !ok {
return nil, errors.New("requirements failed validation: " + problems)
}
e := Garbler{}
passes := make([]string, n, n)
for i := 0; i < ... | go | {
"resource": ""
} |
q181686 | addNums | test | func (g Garbler) addNums(p string, numDigits int) string {
if numDigits <= 0 {
return p
}
ret := p
remaining := numDigits
for remaining > 10 {
ret += fmt.Sprintf("%d", pow(10, 9)+randInt(pow(10, 10)-pow(10, 9)))
remaining -= 10
}
ret += fmt.Sprintf("%d", pow(10, remaining-1)+randInt(pow(10, remaining)-pow(... | go | {
"resource": ""
} |
q181687 | punctuate | test | func (g Garbler) punctuate(p string, numPunc int) string {
if numPunc <= 0 {
return p
}
ret := p
for i := 0; i < numPunc; i++ {
if i%2 == 0 {
ret += string(Punctuation[randInt(len(Punctuation))])
} else {
ret = string(Punctuation[randInt(len(Punctuation))]) + ret
}
}
return ret
} | go | {
"resource": ""
} |
q181688 | deprecated_init | test | func deprecated_init() {
// if piping from stdin we can just exit
// and use the default Stdin value
stat, _ := os.Stdin.Stat()
if (stat.Mode() & os.ModeCharDevice) == 0 {
return
}
// check for params after the double dash
// in the command string
for i, argv := range os.Args {
if argv == "--" {
arg := ... | go | {
"resource": ""
} |
q181689 | Param | test | func (p ParamSet) Param(name string, value interface{}) {
p.params[name] = value
} | go | {
"resource": ""
} |
q181690 | Parse | test | func (p ParamSet) Parse() error {
raw := map[string]json.RawMessage{}
err := json.NewDecoder(p.reader).Decode(&raw)
if err != nil {
return err
}
for key, val := range p.params {
data, ok := raw[key]
if !ok {
continue
}
err := json.Unmarshal(data, val)
if err != nil {
return fmt.Errorf("Unable to... | go | {
"resource": ""
} |
q181691 | Unmarshal | test | func (p ParamSet) Unmarshal(v interface{}) error {
return json.NewDecoder(p.reader).Decode(v)
} | go | {
"resource": ""
} |
q181692 | GetDefaultHTTPClient | test | func GetDefaultHTTPClient(timeout time.Duration) IHTTPClient {
client := http.Client{
Timeout: timeout,
}
return IHTTPClient(&client)
} | go | {
"resource": ""
} |
q181693 | DeviceInfo | test | func (p Pushy) DeviceInfo(deviceID string) (*DeviceInfo, *Error, error) {
url := fmt.Sprintf("%s/devices/%s?api_key=%s", p.APIEndpoint, deviceID, p.APIToken)
var errResponse *Error
var info *DeviceInfo
err := get(p.httpClient, url, &info, &errResponse)
return info, errResponse, err
} | go | {
"resource": ""
} |
q181694 | DevicePresence | test | func (p *Pushy) DevicePresence(deviceID ...string) (*DevicePresenceResponse, *Error, error) {
url := fmt.Sprintf("%s/devices/presence?api_key=%s", p.APIEndpoint, p.APIToken)
var devicePresenceResponse *DevicePresenceResponse
var pushyErr *Error
err := post(p.httpClient, url, DevicePresenceRequest{Tokens: deviceID},... | go | {
"resource": ""
} |
q181695 | NotificationStatus | test | func (p *Pushy) NotificationStatus(pushID string) (*NotificationStatus, *Error, error) {
url := fmt.Sprintf("%s/pushes/%s?api_key=%s", p.APIEndpoint, pushID, p.APIToken)
var errResponse *Error
var status *NotificationStatus
err := get(p.httpClient, url, &status, &errResponse)
return status, errResponse, err
} | go | {
"resource": ""
} |
q181696 | DeleteNotification | test | func (p *Pushy) DeleteNotification(pushID string) (*SimpleSuccess, *Error, error) {
url := fmt.Sprintf("%s/pushes/%s?api_key=%s", p.APIEndpoint, pushID, p.APIToken)
var success *SimpleSuccess
var pushyErr *Error
err := del(p.httpClient, url, &success, &pushyErr)
return success, pushyErr, err
} | go | {
"resource": ""
} |
q181697 | NotifyDevice | test | func (p *Pushy) NotifyDevice(request SendNotificationRequest) (*NotificationResponse, *Error, error) {
url := fmt.Sprintf("%s/push?api_key=%s", p.APIEndpoint, p.APIToken)
var success *NotificationResponse
var pushyErr *Error
err := post(p.httpClient, url, request, &success, &pushyErr)
return success, pushyErr, err... | go | {
"resource": ""
} |
q181698 | Assert | test | func Assert(t Tester, b bool, message ...interface{}) {
if !b {
pc, file, line, _ := runtime.Caller(1)
caller_func_info := runtime.FuncForPC(pc)
error_string := fmt.Sprintf("\n\rASSERT:\tfunc (%s) 0x%x\n\r\tFile %s:%d",
caller_func_info.Name(),
pc,
file,
line)
if len(message) > 0 {
error_strin... | go | {
"resource": ""
} |
q181699 | CreateFile | test | func CreateFile(filename string, size int64) error {
buf := make([]byte, size)
// Create the file store some data
fp, err := os.Create(filename)
if err != nil {
return err
}
// Write the buffer
_, err = fp.Write(buf)
// Cleanup
fp.Close()
return err
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.