_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q181300 | Setup | test | func (s *Storage) Setup() error {
query := fmt.Sprintf(`
CREATE SCHEMA IF NOT EXISTS %s;
CREATE TABLE IF NOT EXISTS %s.%s (
access_token BYTEA PRIMARY KEY,
refresh_token BYTEA,
subject_id TEXT NOT NULL,
subject_client TEXT,
bag bytea NOT NULL,
expire_at TIMESTAMPTZ NOT NULL DEFAULT (NOW() + '%d s... | go | {
"resource": ""
} |
q181301 | TearDown | test | func (s *Storage) TearDown() error {
_, err := s.db.Exec(`DROP SCHEMA IF EXISTS ` + s.schema + ` CASCADE`)
return err
} | go | {
"resource": ""
} |
q181302 | initJaeger | test | func initJaeger(service, node, agentAddress string, log *zap.Logger) (opentracing.Tracer, io.Closer, error) {
cfg := &config.Configuration{
Sampler: &config.SamplerConfig{
Type: "const",
Param: 1,
},
Tags: []opentracing.Tag{{
Key: constant.Subsystem + ".listen",
Value: node,
}},
Reporter: &con... | go | {
"resource": ""
} |
q181303 | Usage | test | func Usage() {
fmt.Fprintf(errorWriter, "Japanese Morphological Analyzer -- github.com/ikawaha/kagome.ipadic\n")
fmt.Fprintf(errorWriter, "usage: %s <command>\n", path.Base(os.Args[0]))
} | go | {
"resource": ""
} |
q181304 | Build | test | func Build(keywords []string) (DoubleArray, error) {
s := len(keywords)
if s == 0 {
return DoubleArray{}, nil
}
ids := make([]int, s, s)
for i := range ids {
ids[i] = i + 1
}
return BuildWithIDs(keywords, ids)
} | go | {
"resource": ""
} |
q181305 | Read | test | func Read(r io.Reader) (DoubleArray, error) {
var sz int64
if e := binary.Read(r, binary.LittleEndian, &sz); e != nil {
return DoubleArray{}, e
}
//fmt.Println("read data len:", sz)
d := make(DoubleArray, sz, sz)
for i := range d {
if e := binary.Read(r, binary.LittleEndian, &d[i].Base); e != nil {
return ... | go | {
"resource": ""
} |
q181306 | Get | test | func (c *Cluster) Get(k int32) (*Node, bool) {
if len(c.nodes) == 0 {
return nil, false
}
if len(c.nodes)-1 < int(k) {
return nil, false
}
return c.nodes[k], true
} | go | {
"resource": ""
} |
q181307 | ExternalNodes | test | func (c *Cluster) ExternalNodes() (res []*Node) {
for _, n := range c.nodes {
if n.Addr != c.listen {
res = append(res, n)
}
}
return
} | go | {
"resource": ""
} |
q181308 | GetOther | test | func (c *Cluster) GetOther(accessToken string) (*Node, bool) {
if c == nil {
return nil, false
}
if c.Len() == 1 {
return nil, false
}
if node, ok := c.Get(jump.HashString(accessToken, c.Len())); ok {
if node.Addr != c.listen {
if node.Client != nil {
return node, true
}
}
}
return nil, false
... | go | {
"resource": ""
} |
q181309 | GoString | test | func (c *Cluster) GoString() string {
buf, _ := json.Marshal(map[string]interface{}{
"listen": c.listen,
"nodes": c.nodes,
"buckets": strconv.FormatInt(int64(c.buckets), 10),
})
return string(buf)
} | go | {
"resource": ""
} |
q181310 | Scan | test | func (b *Bag) Scan(src interface{}) (err error) {
switch t := src.(type) {
case []byte:
err = gob.NewDecoder(bytes.NewReader(t)).Decode(b)
default:
return errors.New("unsupported data source type")
}
return
} | go | {
"resource": ""
} |
q181311 | Value | test | func (b Bag) Value() (driver.Value, error) {
buf := bytes.NewBuffer(nil)
err := gob.NewEncoder(buf).Encode(b)
if err != nil {
return nil, err
}
return buf.Bytes(), nil
} | go | {
"resource": ""
} |
q181312 | Has | test | func (b *Bag) Has(key string) bool {
_, ok := (*b)[key]
return ok
} | go | {
"resource": ""
} |
q181313 | WriteTo | test | func (idx IndexTable) WriteTo(w io.Writer) (n int64, err error) {
n, err = idx.Da.WriteTo(w)
var b bytes.Buffer
enc := gob.NewEncoder(&b)
if err = enc.Encode(idx.Dup); err != nil {
return
}
x, err := b.WriteTo(w)
if err != nil {
return
}
n += x
return
} | go | {
"resource": ""
} |
q181314 | ReadIndexTable | test | func ReadIndexTable(r io.Reader) (IndexTable, error) {
idx := IndexTable{}
d, err := da.Read(r)
if err != nil {
return idx, fmt.Errorf("read index error, %v", err)
}
idx.Da = d
dec := gob.NewDecoder(r)
if e := dec.Decode(&idx.Dup); e != nil {
return idx, fmt.Errorf("read index dup table error, %v", e)
}
... | go | {
"resource": ""
} |
q181315 | New | test | func New(admin *admin.Admin) *ActionBar {
bar := &ActionBar{Admin: admin}
ctr := &controller{ActionBar: bar}
admin.GetRouter().Get("/action_bar/switch_mode", ctr.SwitchMode)
admin.GetRouter().Get("/action_bar/inline_edit", ctr.InlineEdit)
return bar
} | go | {
"resource": ""
} |
q181316 | RegisterAction | test | func (bar *ActionBar) RegisterAction(action ActionInterface) {
bar.GlobalActions = append(bar.GlobalActions, action)
bar.actions = bar.GlobalActions
} | go | {
"resource": ""
} |
q181317 | Actions | test | func (bar *ActionBar) Actions(actions ...ActionInterface) *ActionBar {
newBar := &ActionBar{Admin: bar.Admin, actions: bar.GlobalActions}
newBar.actions = append(newBar.actions, actions...)
return newBar
} | go | {
"resource": ""
} |
q181318 | Render | test | func (bar *ActionBar) Render(w http.ResponseWriter, r *http.Request) template.HTML {
var (
actions, inlineActions []ActionInterface
context = bar.Admin.NewContext(w, r)
)
for _, action := range bar.actions {
if action.InlineAction() {
inlineActions = append(inlineActions, action)
} else {
... | go | {
"resource": ""
} |
q181319 | FuncMap | test | func (bar *ActionBar) FuncMap(w http.ResponseWriter, r *http.Request) template.FuncMap {
funcMap := template.FuncMap{}
funcMap["render_edit_button"] = func(value interface{}, resources ...*admin.Resource) template.HTML {
return bar.RenderEditButtonWithResource(w, r, value, resources...)
}
return funcMap
} | go | {
"resource": ""
} |
q181320 | EditMode | test | func (bar *ActionBar) EditMode(w http.ResponseWriter, r *http.Request) bool {
return isEditMode(bar.Admin.NewContext(w, r))
} | go | {
"resource": ""
} |
q181321 | SwitchMode | test | func (controller) SwitchMode(context *admin.Context) {
utils.SetCookie(http.Cookie{Name: "qor-action-bar", Value: context.Request.URL.Query().Get("checked")}, context.Context)
referrer := context.Request.Referer()
if referrer == "" {
referrer = "/"
}
http.Redirect(context.Writer, context.Request, referrer, htt... | go | {
"resource": ""
} |
q181322 | InlineEdit | test | func (controller) InlineEdit(context *admin.Context) {
context.Writer.Write([]byte(context.Render("action_bar/inline_edit")))
} | go | {
"resource": ""
} |
q181323 | Error | test | func (e *Error) Error() string {
return fmt.Sprintf("%s:%d: %s", e.Filename, e.LineNum, e.Msg)
} | go | {
"resource": ""
} |
q181324 | ParseFile | test | func ParseFile(filename string) ([]*Machine, Macros, error) {
// TODO(fhs): Check if file is readable by anyone besides the user if there is password in it.
fd, err := os.Open(filename)
if err != nil {
return nil, nil, err
}
defer fd.Close()
return parse(fd, &filePos{filename, 1})
} | go | {
"resource": ""
} |
q181325 | FindMachine | test | func FindMachine(filename, name string) (*Machine, error) {
mach, _, err := ParseFile(filename)
if err != nil {
return nil, err
}
var def *Machine
for _, m := range mach {
if m.Name == name {
return m, nil
}
if m.Name == "" {
def = m
}
}
if def == nil {
return nil, errors.New("no machine found"... | go | {
"resource": ""
} |
q181326 | New | test | func New(initialisms map[string]bool) (*Kace, error) {
ci := initialisms
if ci == nil {
ci = map[string]bool{}
}
ci = sanitizeCI(ci)
t, err := ktrie.NewKTrie(ci)
if err != nil {
return nil, fmt.Errorf("kace: cannot create trie: %s", err)
}
k := &Kace{
t: t,
}
return k, nil
} | go | {
"resource": ""
} |
q181327 | Camel | test | func (k *Kace) Camel(s string) string {
return camelCase(k.t, s, false)
} | go | {
"resource": ""
} |
q181328 | Pascal | test | func (k *Kace) Pascal(s string) string {
return camelCase(k.t, s, true)
} | go | {
"resource": ""
} |
q181329 | Snake | test | func (k *Kace) Snake(s string) string {
return delimitedCase(s, snakeDelim, false)
} | go | {
"resource": ""
} |
q181330 | SnakeUpper | test | func (k *Kace) SnakeUpper(s string) string {
return delimitedCase(s, snakeDelim, true)
} | go | {
"resource": ""
} |
q181331 | Kebab | test | func (k *Kace) Kebab(s string) string {
return delimitedCase(s, kebabDelim, false)
} | go | {
"resource": ""
} |
q181332 | KebabUpper | test | func (k *Kace) KebabUpper(s string) string {
return delimitedCase(s, kebabDelim, true)
} | go | {
"resource": ""
} |
q181333 | isPathSafe | test | func isPathSafe(s string) error {
u, err := url.Parse(s)
if err != nil {
return err
}
e, err := url.PathUnescape(u.Path)
if err != nil {
return err
}
if strings.Contains(e, "..") {
return fmt.Errorf(errorMessage)
}
if !whitelistPattern.MatchString(e) {
return fmt.Errorf(errorMessage)
}
return nil... | go | {
"resource": ""
} |
q181334 | Start | test | func (t *WriterTracer) Start(r *http.Request) {
t.StartTime = time.Now().UTC()
t.Request.URL = r.URL.String()
t.Request.Method = r.Method
} | go | {
"resource": ""
} |
q181335 | ParseAuthHeaders | test | func ParseAuthHeaders(r *http.Request) (*AuthCreds, error) {
// according to the doc below oauth 2.0 bearer access token can
// come with query parameter
// http://self-issued.info/docs/draft-ietf-oauth-v2-bearer.html#query-param
// we are going to support this
if r.URL.Query().Get(AccessTokenQueryParam) != "" {
... | go | {
"resource": ""
} |
q181336 | Tracer | test | func Tracer(newTracer NewTracer) ClientParam {
return func(c *Client) error {
c.newTracer = newTracer
return nil
}
} | go | {
"resource": ""
} |
q181337 | HTTPClient | test | func HTTPClient(h *http.Client) ClientParam {
return func(c *Client) error {
c.client = h
return nil
}
} | go | {
"resource": ""
} |
q181338 | BasicAuth | test | func BasicAuth(username, password string) ClientParam {
return func(c *Client) error {
c.auth = &basicAuth{username: username, password: password}
return nil
}
} | go | {
"resource": ""
} |
q181339 | BearerAuth | test | func BearerAuth(token string) ClientParam {
return func(c *Client) error {
c.auth = &bearerAuth{token: token}
return nil
}
} | go | {
"resource": ""
} |
q181340 | CookieJar | test | func CookieJar(jar http.CookieJar) ClientParam {
return func(c *Client) error {
c.jar = jar
return nil
}
} | go | {
"resource": ""
} |
q181341 | SanitizerEnabled | test | func SanitizerEnabled(sanitizerEnabled bool) ClientParam {
return func(c *Client) error {
c.sanitizerEnabled = sanitizerEnabled
return nil
}
} | go | {
"resource": ""
} |
q181342 | OpenFile | test | func (c *Client) OpenFile(ctx context.Context, endpoint string, params url.Values) (ReadSeekCloser, error) {
// If the sanitizer is enabled, make sure the requested path is safe.
if c.sanitizerEnabled {
err := isPathSafe(endpoint)
if err != nil {
return nil, err
}
}
u, err := url.Parse(endpoint)
if err !... | go | {
"resource": ""
} |
q181343 | RoundTrip | test | func (c *Client) RoundTrip(fn RoundTripFn) (*Response, error) {
re, err := fn()
if err != nil {
return nil, err
}
defer re.Body.Close()
buf := &bytes.Buffer{}
_, err = io.Copy(buf, re.Body)
if err != nil {
return nil, err
}
return &Response{
code: re.StatusCode,
headers: re.Header,
body: buf,
... | go | {
"resource": ""
} |
q181344 | SetAuthHeader | test | func (c *Client) SetAuthHeader(h http.Header) {
if c.auth != nil {
h.Set("Authorization", c.auth.String())
}
} | go | {
"resource": ""
} |
q181345 | FileName | test | func (r *FileResponse) FileName() string {
value := r.headers.Get("Content-Disposition")
if len(value) == 0 {
return ""
}
_, params, err := mime.ParseMediaType(value)
if err != nil {
return ""
}
return params["filename"]
} | go | {
"resource": ""
} |
q181346 | newBuffersFromFiles | test | func newBuffersFromFiles(files []File) []fileBuffer {
buffers := make([]fileBuffer, 0, len(files))
for _, file := range files {
buffers = append(buffers, newFileBuffer(file))
}
return buffers
} | go | {
"resource": ""
} |
q181347 | newFileBuffer | test | func newFileBuffer(file File) fileBuffer {
buf := &bytes.Buffer{}
return fileBuffer{
Reader: io.TeeReader(file.Reader, buf),
File: file,
cache: buf,
}
} | go | {
"resource": ""
} |
q181348 | rewind | test | func (r *fileBuffer) rewind() {
r.Reader = io.MultiReader(r.cache, r.File.Reader)
} | go | {
"resource": ""
} |
q181349 | ConvertResponse | test | func ConvertResponse(re *Response, err error) (*Response, error) {
if err != nil {
if uerr, ok := err.(*url.Error); ok && uerr != nil && uerr.Err != nil {
return nil, trace.Wrap(uerr.Err)
}
return nil, trace.Wrap(err)
}
return re, trace.ReadError(re.Code(), re.Bytes())
} | go | {
"resource": ""
} |
q181350 | Set | test | func (o *BoolOption) Set(s string) error {
err := convertString(s, &o.Value)
if err != nil {
return err
}
o.Source = "override"
o.Defined = true
return nil
} | go | {
"resource": ""
} |
q181351 | WriteAnswer | test | func (o *BoolOption) WriteAnswer(name string, value interface{}) error {
if v, ok := value.(bool); ok {
o.Value = v
o.Defined = true
o.Source = "prompt"
return nil
}
return fmt.Errorf("Got %T expected %T type: %v", value, o.Value, value)
} | go | {
"resource": ""
} |
q181352 | String | test | func (o BoolOption) String() string {
if StringifyValue {
return fmt.Sprintf("%v", o.Value)
}
return fmt.Sprintf("{Source:%s Defined:%t Value:%v}", o.Source, o.Defined, o.Value)
} | go | {
"resource": ""
} |
q181353 | TriggerIncidentKey | test | func TriggerIncidentKey(description string, key string) (incidentKey string, err error) {
return trigger(description, key, map[string]interface{}{})
} | go | {
"resource": ""
} |
q181354 | TriggerWithDetails | test | func TriggerWithDetails(description string, details map[string]interface{}) (incidentKey string, err error) {
return trigger(description, "", details)
} | go | {
"resource": ""
} |
q181355 | TriggerIncidentKeyWithDetails | test | func TriggerIncidentKeyWithDetails(description string, key string, details map[string]interface{}) (incidentKey string, err error) {
return trigger(description, key, details)
} | go | {
"resource": ""
} |
q181356 | Merge | test | func Merge(dst, src interface{}) {
m := NewMerger()
m.mergeStructs(reflect.ValueOf(dst), reflect.ValueOf(src))
} | go | {
"resource": ""
} |
q181357 | setSource | test | func (m *Merger) setSource(v reflect.Value) {
if v.Kind() == reflect.Ptr {
v = v.Elem()
}
switch v.Kind() {
case reflect.Map:
for _, key := range v.MapKeys() {
keyval := v.MapIndex(key)
if keyval.Kind() == reflect.Struct && keyval.FieldByName("Source").IsValid() {
// map values are immutable, so we ne... | go | {
"resource": ""
} |
q181358 | convertString | test | func convertString(src string, dst interface{}) (err error) {
switch v := dst.(type) {
case *bool:
*v, err = strconv.ParseBool(src)
case *string:
*v = src
case *int:
var tmp int64
// this is a cheat, we only know int is at least 32 bits
// but we have to make a compromise here
tmp, err = strconv.ParseIn... | go | {
"resource": ""
} |
q181359 | Do | test | func Do(d DB, f func(t Tx) error) error {
t, err := d.TxBegin()
if err != nil {
return err
}
defer t.TxFinish()
err = f(t)
if err != nil {
return err
}
return t.TxCommit()
} | go | {
"resource": ""
} |
q181360 | NewFile | test | func NewFile(filename string) io.Writer {
if err, _ := os.Open(filename); err != nil {
os.Remove(filename)
}
file, _ := os.Create(filename)
return file
} | go | {
"resource": ""
} |
q181361 | internalRun | test | func (b *Bench) internalRun(showProgress bool) results.ResultSet {
startTime := time.Now()
endTime := startTime.Add(b.duration)
sem := semaphore.NewSemaphore(b.threads, b.rampUp) // create a new semaphore with an initiall capacity or 0
out := make(chan results.Result)
resultsChan := make(chan []results.Result)
... | go | {
"resource": ""
} |
q181362 | String | test | func (r Row) String() string {
rStr := fmt.Sprintf("Start Time: %v\n", r.StartTime.UTC())
rStr = fmt.Sprintf("%vElapsed Time: %v\n", rStr, r.ElapsedTime)
rStr = fmt.Sprintf("%vThreads: %v\n", rStr, r.Threads)
rStr = fmt.Sprintf("%vTotal Requests: %v\n", rStr, r.TotalRequests)
rStr = fmt.Sprintf("%vAvg Request Tim... | go | {
"resource": ""
} |
q181363 | Tabulate | test | func (t *TabularResults) Tabulate(results []ResultSet) []Row {
var rows []Row
startTime := time.Unix(0, 0)
for _, bucket := range results {
if len(bucket) > 0 {
var elapsedTime time.Duration
if startTime == time.Unix(0, 0) {
startTime = bucket[0].Timestamp
}
elapsedTime = bucket[0].Timestamp.S... | go | {
"resource": ""
} |
q181364 | AmazonRequest | test | func AmazonRequest() error {
resp, err := http.Get("http://www.amazon.co.uk/")
defer func(response *http.Response) {
if response != nil && response.Body != nil {
response.Body.Close()
}
}(resp)
if err != nil || resp.StatusCode != 200 {
return err
}
return nil
} | go | {
"resource": ""
} |
q181365 | WriteTabularData | test | func WriteTabularData(interval time.Duration, r results.ResultSet, w io.Writer) {
set := r.Reduce(interval)
t := results.TabularResults{}
rows := t.Tabulate(set)
for _, row := range rows {
w.Write([]byte(row.String()))
w.Write([]byte("\n"))
}
} | go | {
"resource": ""
} |
q181366 | Reduce | test | func (r ResultSet) Reduce(interval time.Duration) []ResultSet {
sort.Sort(r)
start := r[0].Timestamp
end := r[len(r)-1].Timestamp
// create the buckets
bucketCount := getBucketCount(start, end, interval)
buckets := make([]ResultSet, bucketCount)
for _, result := range r {
currentBucket := getBucketNumber(r... | go | {
"resource": ""
} |
q181367 | NewSemaphore | test | func NewSemaphore(capacity int, rampUp time.Duration) *Semaphore {
s := Semaphore{
lockDone: make(chan struct{}),
lockLock: make(chan struct{}),
rampUp: rampUp,
}
// if the rampup time is less than 1 then return immediately
if rampUp < 1 {
s.s = make(chan struct{}, capacity)
} else {
s.s = make(chan s... | go | {
"resource": ""
} |
q181368 | Release | test | func (t *Semaphore) Release() {
t.waitIfResizing()
// we need a read lock to ensure we do not resize whilst resizing
t.readMutex.RLock()
defer t.readMutex.RUnlock()
// make sure we have not called Release without Lock
if len(t.s) == 0 {
return
}
<-t.s
} | go | {
"resource": ""
} |
q181369 | Resize | test | func (t *Semaphore) Resize(capacity int) {
// only allow one resize to be called from one thread
t.resizeMutex.Lock()
if capacity == cap(t.s) {
t.resizeMutex.Unlock()
return
}
// lock the locks
t.resizeLock()
t.readMutex.Lock()
defer t.resizeUnlock()
defer t.resizeMutex.Unlock()
defer t.readMutex.Unloc... | go | {
"resource": ""
} |
q181370 | AddOutput | test | func (b *Bench) AddOutput(interval time.Duration, writer io.Writer, output output.OutputFunc) {
o := outputContainer{
interval: interval,
writer: writer,
function: output,
}
b.outputs = append(b.outputs, o)
} | go | {
"resource": ""
} |
q181371 | RunBenchmarks | test | func (b *Bench) RunBenchmarks(r RequestFunc) {
b.request = r
results := b.internalRun(b.showProgress)
b.processResults(results)
} | go | {
"resource": ""
} |
q181372 | parseBool | test | func parseBool(bytes []byte) (ret bool, err error) {
if len(bytes) != 1 {
err = asn1.SyntaxError{Msg: "invalid boolean"}
return
}
// DER demands that "If the encoding represents the boolean value TRUE,
// its single contents octet shall have all eight bits set to one."
// Thus only 0 and 255 are valid encoded... | go | {
"resource": ""
} |
q181373 | checkInteger | test | func checkInteger(bytes []byte) error {
if len(bytes) == 0 {
return asn1.StructuralError{Msg: "empty integer"}
}
if len(bytes) == 1 {
return nil
}
if (bytes[0] == 0 && bytes[1]&0x80 == 0) || (bytes[0] == 0xff && bytes[1]&0x80 == 0x80) {
return asn1.StructuralError{Msg: "integer not minimally-encoded"}
}
re... | go | {
"resource": ""
} |
q181374 | parseInt64 | test | func parseInt64(bytes []byte) (ret int64, err error) {
err = checkInteger(bytes)
if err != nil {
return
}
if len(bytes) > 8 {
// We'll overflow an int64 in this case.
err = asn1.StructuralError{Msg: "integer too large"}
return
}
for bytesRead := 0; bytesRead < len(bytes); bytesRead++ {
ret <<= 8
ret |... | go | {
"resource": ""
} |
q181375 | parseInt32 | test | func parseInt32(bytes []byte) (int32, error) {
if err := checkInteger(bytes); err != nil {
return 0, err
}
ret64, err := parseInt64(bytes)
if err != nil {
return 0, err
}
if ret64 != int64(int32(ret64)) {
return 0, asn1.StructuralError{Msg: "integer too large"}
}
return int32(ret64), nil
} | go | {
"resource": ""
} |
q181376 | parseBigInt | test | func parseBigInt(bytes []byte) (*big.Int, error) {
if err := checkInteger(bytes); err != nil {
return nil, err
}
ret := new(big.Int)
if len(bytes) > 0 && bytes[0]&0x80 == 0x80 {
// This is a negative number.
notBytes := make([]byte, len(bytes))
for i := range notBytes {
notBytes[i] = ^bytes[i]
}
ret.... | go | {
"resource": ""
} |
q181377 | parseBitString | test | func parseBitString(bytes []byte) (ret asn1.BitString, err error) {
if len(bytes) == 0 {
err = asn1.SyntaxError{Msg: "zero length BIT STRING"}
return
}
paddingBits := int(bytes[0])
if paddingBits > 7 ||
len(bytes) == 1 && paddingBits > 0 ||
bytes[len(bytes)-1]&((1<<bytes[0])-1) != 0 {
err = asn1.SyntaxErr... | go | {
"resource": ""
} |
q181378 | parseObjectIdentifier | test | func parseObjectIdentifier(bytes []byte) (s []int, err error) {
if len(bytes) == 0 {
err = asn1.SyntaxError{Msg: "zero length OBJECT IDENTIFIER"}
return
}
// In the worst case, we get two elements from the first byte (which is
// encoded differently) and then every varint is a single byte long.
s = make([]int... | go | {
"resource": ""
} |
q181379 | parseBase128Int | test | func parseBase128Int(bytes []byte, initOffset int) (ret, offset int, err error) {
ret, offset, err = _parseBase128Int(bytes, initOffset)
if offset-initOffset >= 4 {
err = asn1.StructuralError{Msg: "base 128 integer too large"}
return
}
return
} | go | {
"resource": ""
} |
q181380 | parseGeneralizedTime | test | func parseGeneralizedTime(bytes []byte) (ret time.Time, err error) {
const formatStr = "20060102150405Z0700"
s := string(bytes)
if ret, err = time.Parse(formatStr, s); err != nil {
return
}
if serialized := ret.Format(formatStr); serialized != s {
err = fmt.Errorf("asn1: time did not serialize back to the or... | go | {
"resource": ""
} |
q181381 | parsePrintableString | test | func parsePrintableString(bytes []byte) (ret string, err error) {
for _, b := range bytes {
if !isPrintable(b) {
err = asn1.SyntaxError{Msg: "PrintableString contains invalid character"}
return
}
}
ret = string(bytes)
return
} | go | {
"resource": ""
} |
q181382 | isPrintable | test | func isPrintable(b byte) bool {
return 'a' <= b && b <= 'z' ||
'A' <= b && b <= 'Z' ||
'0' <= b && b <= '9' ||
'\'' <= b && b <= ')' ||
'+' <= b && b <= '/' ||
b == ' ' ||
b == ':' ||
b == '=' ||
b == '?' ||
// This is technically not allowed in a PrintableString.
// However, x509 certificates with... | go | {
"resource": ""
} |
q181383 | parseSequenceOf | test | func parseSequenceOf(bytes []byte, sliceType reflect.Type, elemType reflect.Type) (ret reflect.Value, err error) {
expectedTag, compoundType, ok := getUniversalType(elemType)
if !ok {
err = asn1.StructuralError{Msg: "unknown Go type for slice"}
return
}
// First we iterate over the input and count the number o... | go | {
"resource": ""
} |
q181384 | invalidLength | test | func invalidLength(offset, length, sliceLength int) bool {
return offset+length < offset || offset+length > sliceLength
} | go | {
"resource": ""
} |
q181385 | setDefaultValue | test | func setDefaultValue(v reflect.Value, params fieldParameters) (ok bool) {
if !params.optional {
return
}
ok = true
if params.defaultValue == nil {
return
}
if canHaveDefaultValue(v.Kind()) {
v.SetInt(*params.defaultValue)
}
return
} | go | {
"resource": ""
} |
q181386 | UnmarshalWithParams | test | func UnmarshalWithParams(b []byte, val interface{}, params string) (rest []byte, err error) {
v := reflect.ValueOf(val).Elem()
offset, err := parseField(v, b, 0, parseFieldParameters(params))
if err != nil {
return nil, err
}
return b[offset:], nil
} | go | {
"resource": ""
} |
q181387 | parseFieldParameters | test | func parseFieldParameters(str string) (ret fieldParameters) {
for _, part := range strings.Split(str, ",") {
switch {
case part == "optional":
ret.optional = true
case part == "explicit":
ret.explicit = true
if ret.tag == nil {
ret.tag = new(int)
}
case part == "generalized":
ret.timeType = ... | go | {
"resource": ""
} |
q181388 | getUniversalType | test | func getUniversalType(t reflect.Type) (tagNumber int, isCompound, ok bool) {
switch t {
case objectIdentifierType:
return tagOID, false, true
case bitStringType:
return tagBitString, false, true
case timeType:
return tagUTCTime, false, true
case enumeratedType:
return tagEnum, false, true
case bigIntType:... | go | {
"resource": ""
} |
q181389 | DecodeString | test | func DecodeString(raw string) ([]byte, error) {
pad := 8 - (len(raw) % 8)
nb := []byte(raw)
if pad != 8 {
nb = make([]byte, len(raw)+pad)
copy(nb, raw)
for i := 0; i < pad; i++ {
nb[len(raw)+i] = '='
}
}
return lowerBase32.DecodeString(string(nb))
} | go | {
"resource": ""
} |
q181390 | MailNotifier | test | func (m MongoDb) MailNotifier(ctxt string) (models.MailNotifier, error) {
c := m.Connect(models.COLL_NAME_MAIL_NOTIFIER)
defer m.Close(c)
var notifier []models.MailNotifier
if err := c.Find(nil).All(¬ifier); err != nil || len(notifier) == 0 {
logger.Get().Error("%s-Unable to read MailNotifier from DB: %v", ctx... | go | {
"resource": ""
} |
q181391 | SaveMailNotifier | test | func (m MongoDb) SaveMailNotifier(ctxt string, notifier models.MailNotifier) error {
c := m.Connect(models.COLL_NAME_MAIL_NOTIFIER)
defer m.Close(c)
_, err := c.Upsert(bson.M{}, bson.M{"$set": notifier})
if err != nil {
logger.Get().Error("%s-Error Updating the mail notifier info for: %s Error: %v", ctxt, notifie... | go | {
"resource": ""
} |
q181392 | RegisterProvider | test | func RegisterProvider(name string, factory ProvidersFactory) {
providersMutex.Lock()
defer providersMutex.Unlock()
if _, found := providers[name]; found {
logger.Get().Critical("Auth provider %s was registered twice", name)
}
providers[name] = factory
} | go | {
"resource": ""
} |
q181393 | InitDb | test | func (m MongoDb) InitDb() error {
if err := m.InitUser(); err != nil {
logger.Get().Error("Error Initilaizing User Table", err)
return err
}
return nil
} | go | {
"resource": ""
} |
q181394 | Until | test | func Until(f func(), period time.Duration, stopCh <-chan struct{}) {
for {
select {
case <-stopCh:
return
default:
}
func() {
defer HandleCrash()
f()
}()
time.Sleep(period)
}
} | go | {
"resource": ""
} |
q181395 | logPanic | test | func logPanic(r interface{}) {
callers := ""
for i := 0; true; i++ {
_, file, line, ok := runtime.Caller(i)
if !ok {
break
}
callers = callers + fmt.Sprintf("%v:%v\n", file, line)
}
logger.Get().Error("Recovered from panic: %#v (%v)\n%v", r, r, callers)
} | go | {
"resource": ""
} |
q181396 | User | test | func (m MongoDb) User(username string) (user models.User, e error) {
c := m.Connect(models.COLL_NAME_USER)
defer m.Close(c)
err := c.Find(bson.M{"username": username}).One(&user)
if err != nil {
return user, ErrMissingUser
}
return user, nil
} | go | {
"resource": ""
} |
q181397 | Users | test | func (m MongoDb) Users(filter interface{}) (us []models.User, e error) {
c := m.Connect(models.COLL_NAME_USER)
defer m.Close(c)
err := c.Find(filter).All(&us)
if err != nil {
logger.Get().Error("Error getting record from DB. error: %v", err)
return us, mkmgoerror(err.Error())
}
return us, nil
} | go | {
"resource": ""
} |
q181398 | SaveUser | test | func (m MongoDb) SaveUser(user models.User) error {
c := m.Connect(models.COLL_NAME_USER)
defer m.Close(c)
_, err := c.Upsert(bson.M{"username": user.Username}, bson.M{"$set": user})
if err != nil {
logger.Get().Error("Error deleting record from DB for user: %s. error: %v", user.Username, err)
return mkmgoerro... | go | {
"resource": ""
} |
q181399 | DeleteUser | test | func (m MongoDb) DeleteUser(username string) error {
c := m.Connect(models.COLL_NAME_USER)
defer m.Close(c)
// raises error if "username" doesn't exist
err := c.Remove(bson.M{"username": username})
if err != nil {
logger.Get().Error("Error deleting record from DB for user: %s. error: %v", username, err)
retur... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.