id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c19300 | new(CreateTargetArgs)
args.URL = url
return args
} | |
c19301 | a.BrowserContextID = &browserContextID
return a
} | |
c19302 | SessionID) *DetachFromTargetArgs {
a.SessionID = &sessionID
return a
} | |
c19303 | new(DisposeBrowserContextArgs)
args.BrowserContextID = browserContextID
return args
} | |
c19304 | a.TargetID = &targetID
return a
} | |
c19305 | new(SendMessageToTargetArgs)
args.Message = message
return args
} | |
c19306 | {
a.SessionID = &sessionID
return a
} | |
c19307 |
args.WaitForDebuggerOnStart = waitForDebuggerOnStart
return args
} | |
c19308 | new(SetDiscoverTargetsArgs)
args.Discover = discover
return args
} | |
c19309 | new(SetRemoteLocationsArgs)
args.Locations = locations
return args
} | |
c19310 | new(ExecuteSQLArgs)
args.DatabaseID = databaseID
args.Query = query
return args
} | |
c19311 | new(GetDatabaseTableNamesArgs)
args.DatabaseID = databaseID
return args
} | |
c19312 | rpcc.Invoke(ctx, "Target.attachToTarget", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "Target", Op: "AttachToTarget", Err: err}
}
return
} | |
c19313 | "Target.closeTarget", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "Target", Op: "CloseTarget", Err: err}
}
return
} | |
c19314 | "Target.createTarget", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "Target", Op: "CreateTarget", Err: err}
}
return
} | |
c19315 | rpcc.Invoke(ctx, "Target.getTargetInfo", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "Target", Op: "GetTargetInfo", Err: err}
}
return
} | |
c19316 | m.once.Do(m.init)
return m
} | |
c19317 |
filtered := make(map[string]CommandFactory)
for k, f := range commands {
if _, ok := set[k]; ok {
filtered[k] = f
}
}
return f(filtered)
}
} | |
c19318 | BasicHelpFunc(app),
Autocomplete: true,
}
} | |
c19319 | c.once.Do(c.init)
return c.isHelp
} | |
c19320 | {
c.once.Do(c.init)
return c.isVersion
} | |
c19321 |
}
}
// Attempt to get the factory function for creating the command
// implementation. If the command is invalid or blank, it is an error.
raw, ok := c.commandTree.Get(c.Subcommand())
if !ok {
c.HelpWriter.Write([]byte(c.HelpFunc(c.helpCommands(c.subcommandParent())) + "\n"))
return 127, nil
}
command, ... | |
c19322 | {
c.once.Do(c.init)
return c.subcommandArgs
} | |
c19323 | " ")
idx := strings.LastIndex(sub, " ")
if idx == -1 {
// No space means our parent is root
return ""
}
return sub[:idx]
} | |
c19324 | the keys return that in the map
result := make(map[string]CommandFactory, len(keys))
for _, k := range keys {
raw, ok := c.commandTree.Get(k)
if !ok {
// We just got it via WalkPrefix above, so we just panic
panic("not found: " + k)
}
// If this is a hidden command, don't show it
if _, ok := c.comma... | |
c19325 | range hosts {
e := &hostEntry{
host: h,
retryDelay: p.initialRetryDelay,
}
p.hosts[h] = e
p.hostList[i] = e
}
return p
} | |
c19326 | p.Unlock()
host := p.getRoundRobin()
return &standardHostPoolResponse{host: host, pool: p}
} | |
c19327 | {
for _, h := range p.hosts {
h.dead = false
}
} | |
c19328 | v.expect()
v.Expected.Set(claim, val)
} | |
c19329 | return nil
}
return h[key]
} | |
c19330 | ok := h[key]
return ok
} | |
c19331 | err != nil {
return nil, err
}
return EncodeEscape(b), nil
} | |
c19332 | b, err := DecodeEscaped(b)
if err != nil {
return err
}
return json.Unmarshal(b, (*map[string]interface{})(h))
} | |
c19333 | return nil
}
return p[key]
} | |
c19334 | ok := p[key]
return ok
} | |
c19335 | nil {
return nil, err
}
return EncodeEscape(b), nil
} | |
c19336 |
if err != nil {
return nil, err
}
return Base64Encode(b), nil
} | |
c19337 |
return err
}
*p = Protected(h)
return nil
} | |
c19338 | nil
}
return json.Marshal(map[string]interface{}(c))
} | |
c19339 | nil, err
}
return jose.Base64Encode(b), nil
} | |
c19340 | c.Set(key, t.Unix())
} | |
c19341 | return err
}
*s = Signature(dec)
return nil
} | |
c19342 | err := j.sb[i].cache(); err != nil {
return err
}
raw := format(j.sb[i].Protected, j.plcache)
sig, err := j.sb[i].method.Sign(raw, keys[i])
if err != nil {
return err
}
j.sb[i].Signature = sig
}
return nil
} | |
c19343 | j.payload.Base64()
j.clean = err == nil
}
return err
} | |
c19344 | s.unprotected.Base64()
if err != nil {
return err
}
}
s.clean = true
return nil
} | |
c19345 |
if err != nil {
return err
}
return j.VerifyMulti(keys, methods, o)
} | |
c19346 |
}
n++
}
}
switch n {
case 0:
return ""
case 1:
return s
case 2:
return s + " and 1 other error"
}
return fmt.Sprintf("%s (and %d other errors)", s, n-1)
} | |
c19347 | m MultiError
for i := range j.sb {
err := j.sb[i].verify(j.plcache, keys[i], methods[i])
if err != nil {
m = append(m, err)
} else {
o2.Inc()
if o.Needs(i) {
o.ptr++
o2.Append(i)
}
}
}
err := o.Validate(&o2)
if err != nil {
m = append(m, err)
}
if len(m) == 0 {
return nil
}
ret... | |
c19348 | = append(s.Indices, x)
} | |
c19349 | < len(s.Indices) && s.Indices[s.ptr] == x
} | |
c19350 | !eq(s.Indices, have.Indices)) {
return ErrNotEnoughValidSignatures
}
return nil
} | |
c19351 | return ErrCannotValidate
}
return j.sb[0].verify(j.plcache, key, method)
} | |
c19352 | _ Signature, _ interface{}) error {
return nil
} | |
c19353 | (Signature, error) {
return nil, nil
} | |
c19354 | base64.RawURLEncoding.Decode(buf, b)
return buf[:n], err
} | |
c19355 |
base64.RawURLEncoding.Encode(buf, b)
return buf
} | |
c19356 | '"'
copy(buf[1:], r)
buf[len(buf)-1] = '"'
return buf, nil
} | |
c19357 |
b = b[1 : len(b)-1]
}
*r = rawBase64(b)
return nil
} | |
c19358 | !sm.Hasher().Available() {
panic("jose/jws: specific hash is unavailable")
}
mu.Lock()
signingMethods[alg] = sm
mu.Unlock()
} | |
c19359 | delete(signingMethods, sm.Alg())
mu.Unlock()
} | |
c19360 | method = signingMethods[alg]
mu.RUnlock()
return method
} | |
c19361 | New(...).(*jws) != true")
}
j.sb[0].protected.Set("typ", "JWT")
j.isJWT = true
return j
} | |
c19362 | {
if j.isJWT {
return j.Compact(key)
}
return nil, ErrIsNotJWT
} | |
c19363 | return jwt.Claims(c)
}
}
return nil
} | |
c19364 | if b, ok := fromForm(req); ok {
return ParseJWT(b)
}
return nil, ErrNoTokenInRequest
} | |
c19365 | {
return &jwt.Validator{
Expected: jwt.Claims(c),
EXP: exp,
NBF: nbf,
Fn: Conv(fn),
}
} | |
c19366 | return nil, ErrKeyMustBePEMEncoded
}
return x509.ParseECPrivateKey(block.Bytes)
} | |
c19367 | {
return nil, err
}
parsedKey = cert.PublicKey
}
pkey, ok := parsedKey.(*ecdsa.PublicKey)
if !ok {
return nil, ErrNotECPublicKey
}
return pkey, nil
} | |
c19368 | jose.Protected {
return j.sb[i].protected
} | |
c19369 | j.sb[i].unprotected
} | |
c19370 | unprotected: jose.Header{},
method: methods[i],
}
}
return &jws{
payload: &payload{v: content},
sb: sb,
}
} | |
c19371 | {
return parseJumpTable[format](b, u...)
}
return nil, ErrNoTokenInRequest
} | |
c19372 | {
return parseJumpTable[format](b, u...)
}
return nil, ErrNoTokenInRequest
} | |
c19373 | err = ParseFromForm(req, format, u...)
if err == nil {
return token, nil
}
return nil, err
} | |
c19374 |
if b.Has(key) && !IgnoreDupes {
return ErrDuplicateHeaderParameter
}
}
return nil
} | |
c19375 | return nil, err
}
return jose.EncodeEscape(b), nil
} | |
c19376 | nil, err
}
return jose.Base64Encode(b), nil
} | |
c19377 | := p.u.UnmarshalJSON(b2)
p.v = p.u
return err
}
return json.Unmarshal(b2, &p.v)
} | |
c19378 | string) {
jwt.Claims(c).Del(key)
} | |
c19379 | &map[string]interface{}(*p) is
// invalid Go.
tmp := map[string]interface{}(*c)
if err = json.Unmarshal(b, &tmp); err != nil {
return err
}
*c = Claims(tmp)
return nil
} | |
c19380 | VARIANT{VT: vt, Val: val}
} | |
c19381 | return (*IUnknown)(unsafe.Pointer(uintptr(v.Val)))
} | |
c19382 | return (*IDispatch)(unsafe.Pointer(uintptr(v.Val)))
} | |
c19383 | (*SafeArray)(unsafe.Pointer(uintptr(v.Val)))
return &SafeArrayConversion{safeArray}
} | |
c19384 | BstrToString(*(**uint16)(unsafe.Pointer(&v.Val)))
} | |
c19385 | &&
guid1.Data4[4] == guid2.Data4[4] &&
guid1.Data4[5] == guid2.Data4[5] &&
guid1.Data4[6] == guid2.Data4[6] &&
guid1.Data4[7] == guid2.Data4[7]
} | |
c19386 | _ := procCoInitializeEx.Call(uintptr(0), uintptr(coinit))
if hr != 0 {
err = NewError(hr)
}
return
} | |
c19387 | p = uintptr(0)
return coInitializeEx(coinit)
} | |
c19388 | := procCLSIDFromString.Call(lpsz, uintptr(unsafe.Pointer(&guid)))
if hr != 0 {
err = NewError(hr)
}
clsid = &guid
return
} | |
c19389 | uintptr(unsafe.Pointer(&p)))
if hr != 0 {
err = NewError(hr)
}
str = LpOleStrToString(p)
return
} | |
c19390 | := procIIDFromString.Call(lpsz, uintptr(unsafe.Pointer(&guid)))
if hr != 0 {
err = NewError(hr)
}
clsid = &guid
return
} | |
c19391 | if hr != 0 {
err = NewError(hr)
}
str = LpOleStrToString(p)
return
} | |
c19392 | _ := procGetActiveObject.Call(
uintptr(unsafe.Pointer(clsid)),
uintptr(unsafe.Pointer(iid)),
uintptr(unsafe.Pointer(&unk)))
if hr != 0 {
err = NewError(hr)
}
return
} | |
c19393 | uintptr(unsafe.Pointer(bindOpts)),
uintptr(unsafe.Pointer(iid)),
uintptr(unsafe.Pointer(&unk)))
if hr != 0 {
err = NewError(hr)
}
return
} | |
c19394 |
if hr != 0 {
err = NewError(hr)
}
return
} | |
c19395 |
if hr != 0 {
err = NewError(hr)
}
return
} | |
c19396 | call.StringToUTF16Ptr(v))))
ss = (*int16)(unsafe.Pointer(pss))
return
} | |
c19397 | _ := procSysAllocStringLen.Call(uintptr(unsafe.Pointer(ptr)), uintptr(len(utf16)-1))
ss = (*int16)(unsafe.Pointer(pss))
return
} | |
c19398 |
if hr != 0 {
err = NewError(hr)
}
return
} | |
c19399 | procSysStringLen.Call(uintptr(unsafe.Pointer(v)))
return uint32(l)
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.