_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q19300 | NewCreateTargetArgs | train | func NewCreateTargetArgs(url string) *CreateTargetArgs {
args := new(CreateTargetArgs)
args.URL = url
return args
} | go | {
"resource": ""
} |
q19301 | SetBrowserContextID | train | func (a *CreateTargetArgs) SetBrowserContextID(browserContextID BrowserContextID) *CreateTargetArgs {
a.BrowserContextID = &browserContextID
return a
} | go | {
"resource": ""
} |
q19302 | SetSessionID | train | func (a *DetachFromTargetArgs) SetSessionID(sessionID SessionID) *DetachFromTargetArgs {
a.SessionID = &sessionID
return a
} | go | {
"resource": ""
} |
q19303 | NewDisposeBrowserContextArgs | train | func NewDisposeBrowserContextArgs(browserContextID BrowserContextID) *DisposeBrowserContextArgs {
args := new(DisposeBrowserContextArgs)
args.BrowserContextID = browserContextID
return args
} | go | {
"resource": ""
} |
q19304 | SetTargetID | train | func (a *GetTargetInfoArgs) SetTargetID(targetID ID) *GetTargetInfoArgs {
a.TargetID = &targetID
return a
} | go | {
"resource": ""
} |
q19305 | NewSendMessageToTargetArgs | train | func NewSendMessageToTargetArgs(message string) *SendMessageToTargetArgs {
args := new(SendMessageToTargetArgs)
args.Message = message
return args
} | go | {
"resource": ""
} |
q19306 | SetSessionID | train | func (a *SendMessageToTargetArgs) SetSessionID(sessionID SessionID) *SendMessageToTargetArgs {
a.SessionID = &sessionID
return a
} | go | {
"resource": ""
} |
q19307 | NewSetAutoAttachArgs | train | func NewSetAutoAttachArgs(autoAttach bool, waitForDebuggerOnStart bool) *SetAutoAttachArgs {
args := new(SetAutoAttachArgs)
args.AutoAttach = autoAttach
args.WaitForDebuggerOnStart = waitForDebuggerOnStart
return args
} | go | {
"resource": ""
} |
q19308 | NewSetDiscoverTargetsArgs | train | func NewSetDiscoverTargetsArgs(discover bool) *SetDiscoverTargetsArgs {
args := new(SetDiscoverTargetsArgs)
args.Discover = discover
return args
} | go | {
"resource": ""
} |
q19309 | NewSetRemoteLocationsArgs | train | func NewSetRemoteLocationsArgs(locations []RemoteLocation) *SetRemoteLocationsArgs {
args := new(SetRemoteLocationsArgs)
args.Locations = locations
return args
} | go | {
"resource": ""
} |
q19310 | NewExecuteSQLArgs | train | func NewExecuteSQLArgs(databaseID ID, query string) *ExecuteSQLArgs {
args := new(ExecuteSQLArgs)
args.DatabaseID = databaseID
args.Query = query
return args
} | go | {
"resource": ""
} |
q19311 | NewGetDatabaseTableNamesArgs | train | func NewGetDatabaseTableNamesArgs(databaseID ID) *GetDatabaseTableNamesArgs {
args := new(GetDatabaseTableNamesArgs)
args.DatabaseID = databaseID
return args
} | go | {
"resource": ""
} |
q19312 | AttachToTarget | train | func (d *domainClient) AttachToTarget(ctx context.Context, args *AttachToTargetArgs) (reply *AttachToTargetReply, err error) {
reply = new(AttachToTargetReply)
if args != nil {
err = rpcc.Invoke(ctx, "Target.attachToTarget", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "Target.attachToTarget", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "Target", Op: "AttachToTarget", Err: err}
}
return
} | go | {
"resource": ""
} |
q19313 | CloseTarget | train | func (d *domainClient) CloseTarget(ctx context.Context, args *CloseTargetArgs) (reply *CloseTargetReply, err error) {
reply = new(CloseTargetReply)
if args != nil {
err = rpcc.Invoke(ctx, "Target.closeTarget", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "Target.closeTarget", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "Target", Op: "CloseTarget", Err: err}
}
return
} | go | {
"resource": ""
} |
q19314 | CreateTarget | train | func (d *domainClient) CreateTarget(ctx context.Context, args *CreateTargetArgs) (reply *CreateTargetReply, err error) {
reply = new(CreateTargetReply)
if args != nil {
err = rpcc.Invoke(ctx, "Target.createTarget", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "Target.createTarget", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "Target", Op: "CreateTarget", Err: err}
}
return
} | go | {
"resource": ""
} |
q19315 | GetTargetInfo | train | func (d *domainClient) GetTargetInfo(ctx context.Context, args *GetTargetInfoArgs) (reply *GetTargetInfoReply, err error) {
reply = new(GetTargetInfoReply)
if args != nil {
err = rpcc.Invoke(ctx, "Target.getTargetInfo", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "Target.getTargetInfo", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "Target", Op: "GetTargetInfo", Err: err}
}
return
} | go | {
"resource": ""
} |
q19316 | NewMockUi | train | func NewMockUi() *MockUi {
m := new(MockUi)
m.once.Do(m.init)
return m
} | go | {
"resource": ""
} |
q19317 | FilteredHelpFunc | train | func FilteredHelpFunc(include []string, f HelpFunc) HelpFunc {
return func(commands map[string]CommandFactory) string {
set := make(map[string]struct{})
for _, k := range include {
set[k] = struct{}{}
}
filtered := make(map[string]CommandFactory)
for k, f := range commands {
if _, ok := set[k]; ok {
filtered[k] = f
}
}
return f(filtered)
}
} | go | {
"resource": ""
} |
q19318 | NewCLI | train | func NewCLI(app, version string) *CLI {
return &CLI{
Name: app,
Version: version,
HelpFunc: BasicHelpFunc(app),
Autocomplete: true,
}
} | go | {
"resource": ""
} |
q19319 | IsHelp | train | func (c *CLI) IsHelp() bool {
c.once.Do(c.init)
return c.isHelp
} | go | {
"resource": ""
} |
q19320 | IsVersion | train | func (c *CLI) IsVersion() bool {
c.once.Do(c.init)
return c.isVersion
} | go | {
"resource": ""
} |
q19321 | Run | train | func (c *CLI) Run() (int, error) {
c.once.Do(c.init)
// If this is a autocompletion request, satisfy it. This must be called
// first before anything else since its possible to be autocompleting
// -help or -version or other flags and we want to show completions
// and not actually write the help or version.
if c.Autocomplete && c.autocomplete.Complete() {
return 0, nil
}
// Just show the version and exit if instructed.
if c.IsVersion() && c.Version != "" {
c.HelpWriter.Write([]byte(c.Version + "\n"))
return 0, nil
}
// Just print the help when only '-h' or '--help' is passed.
if c.IsHelp() && c.Subcommand() == "" {
c.HelpWriter.Write([]byte(c.HelpFunc(c.helpCommands(c.Subcommand())) + "\n"))
return 0, nil
}
// If we're attempting to install or uninstall autocomplete then handle
if c.Autocomplete {
// Autocomplete requires the "Name" to be set so that we know what
// command to setup the autocomplete on.
if c.Name == "" {
return 1, fmt.Errorf(
"internal error: CLI.Name must be specified for autocomplete to work")
}
// If both install and uninstall flags are specified, then error
if c.isAutocompleteInstall && c.isAutocompleteUninstall {
return 1, fmt.Errorf(
"Either the autocomplete install or uninstall flag may " +
"be specified, but not both.")
}
// If the install flag is specified, perform the install or uninstall
if c.isAutocompleteInstall {
if err := c.autocompleteInstaller.Install(c.Name); err != nil {
return 1, err
}
return 0, nil
}
if c.isAutocompleteUninstall {
if err := c.autocompleteInstaller.Uninstall(c.Name); err != nil {
return 1, err
}
return 0, nil
}
}
// 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, err := raw.(CommandFactory)()
if err != nil {
return 1, err
}
// If we've been instructed to just print the help, then print it
if c.IsHelp() {
c.commandHelp(command)
return 0, nil
}
// If there is an invalid flag, then error
if len(c.topFlags) > 0 {
c.HelpWriter.Write([]byte(
"Invalid flags before the subcommand. If these flags are for\n" +
"the subcommand, please put them after the subcommand.\n\n"))
c.commandHelp(command)
return 1, nil
}
code := command.Run(c.SubcommandArgs())
if code == RunResultHelp {
// Requesting help
c.commandHelp(command)
return 1, nil
}
return code, nil
} | go | {
"resource": ""
} |
q19322 | SubcommandArgs | train | func (c *CLI) SubcommandArgs() []string {
c.once.Do(c.init)
return c.subcommandArgs
} | go | {
"resource": ""
} |
q19323 | subcommandParent | train | func (c *CLI) subcommandParent() string {
// Get the subcommand, if it is "" alread just return
sub := c.Subcommand()
if sub == "" {
return sub
}
// Clear any trailing spaces and find the last space
sub = strings.TrimRight(sub, " ")
idx := strings.LastIndex(sub, " ")
if idx == -1 {
// No space means our parent is root
return ""
}
return sub[:idx]
} | go | {
"resource": ""
} |
q19324 | helpCommands | train | func (c *CLI) helpCommands(prefix string) map[string]CommandFactory {
// If our prefix isn't empty, make sure it ends in ' '
if prefix != "" && prefix[len(prefix)-1] != ' ' {
prefix += " "
}
// Get all the subkeys of this command
var keys []string
c.commandTree.WalkPrefix(prefix, func(k string, raw interface{}) bool {
// Ignore any sub-sub keys, i.e. "foo bar baz" when we want "foo bar"
if !strings.Contains(k[len(prefix):], " ") {
keys = append(keys, k)
}
return false
})
// For each of 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.commandHidden[k]; ok {
continue
}
result[k] = raw.(CommandFactory)
}
return result
} | go | {
"resource": ""
} |
q19325 | New | train | func New(hosts []string) HostPool {
p := &standardHostPool{
hosts: make(map[string]*hostEntry, len(hosts)),
hostList: make([]*hostEntry, len(hosts)),
initialRetryDelay: time.Duration(30) * time.Second,
maxRetryInterval: time.Duration(900) * time.Second,
}
for i, h := range hosts {
e := &hostEntry{
host: h,
retryDelay: p.initialRetryDelay,
}
p.hosts[h] = e
p.hostList[i] = e
}
return p
} | go | {
"resource": ""
} |
q19326 | Get | train | func (p *standardHostPool) Get() HostPoolResponse {
p.Lock()
defer p.Unlock()
host := p.getRoundRobin()
return &standardHostPoolResponse{host: host, pool: p}
} | go | {
"resource": ""
} |
q19327 | doResetAll | train | func (p *standardHostPool) doResetAll() {
for _, h := range p.hosts {
h.dead = false
}
} | go | {
"resource": ""
} |
q19328 | SetClaim | train | func (v *Validator) SetClaim(claim string, val interface{}) {
v.expect()
v.Expected.Set(claim, val)
} | go | {
"resource": ""
} |
q19329 | Get | train | func (h Header) Get(key string) interface{} {
if h == nil {
return nil
}
return h[key]
} | go | {
"resource": ""
} |
q19330 | Has | train | func (h Header) Has(key string) bool {
_, ok := h[key]
return ok
} | go | {
"resource": ""
} |
q19331 | MarshalJSON | train | func (h Header) MarshalJSON() ([]byte, error) {
if len(h) == 0 {
return nil, nil
}
b, err := json.Marshal(map[string]interface{}(h))
if err != nil {
return nil, err
}
return EncodeEscape(b), nil
} | go | {
"resource": ""
} |
q19332 | UnmarshalJSON | train | func (h *Header) UnmarshalJSON(b []byte) error {
if b == nil {
return nil
}
b, err := DecodeEscaped(b)
if err != nil {
return err
}
return json.Unmarshal(b, (*map[string]interface{})(h))
} | go | {
"resource": ""
} |
q19333 | Get | train | func (p Protected) Get(key string) interface{} {
if p == nil {
return nil
}
return p[key]
} | go | {
"resource": ""
} |
q19334 | Has | train | func (p Protected) Has(key string) bool {
_, ok := p[key]
return ok
} | go | {
"resource": ""
} |
q19335 | MarshalJSON | train | func (p Protected) MarshalJSON() ([]byte, error) {
b, err := json.Marshal(map[string]interface{}(p))
if err != nil {
return nil, err
}
return EncodeEscape(b), nil
} | go | {
"resource": ""
} |
q19336 | Base64 | train | func (p Protected) Base64() ([]byte, error) {
b, err := json.Marshal(map[string]interface{}(p))
if err != nil {
return nil, err
}
return Base64Encode(b), nil
} | go | {
"resource": ""
} |
q19337 | UnmarshalJSON | train | func (p *Protected) UnmarshalJSON(b []byte) error {
var h Header
if err := h.UnmarshalJSON(b); err != nil {
return err
}
*p = Protected(h)
return nil
} | go | {
"resource": ""
} |
q19338 | MarshalJSON | train | func (c Claims) MarshalJSON() ([]byte, error) {
if c == nil || len(c) == 0 {
return nil, nil
}
return json.Marshal(map[string]interface{}(c))
} | go | {
"resource": ""
} |
q19339 | Base64 | train | func (c Claims) Base64() ([]byte, error) {
b, err := c.MarshalJSON()
if err != nil {
return nil, err
}
return jose.Base64Encode(b), nil
} | go | {
"resource": ""
} |
q19340 | SetTime | train | func (c Claims) SetTime(key string, t time.Time) {
c.Set(key, t.Unix())
} | go | {
"resource": ""
} |
q19341 | UnmarshalJSON | train | func (s *Signature) UnmarshalJSON(b []byte) error {
dec, err := jose.DecodeEscaped(b)
if err != nil {
return err
}
*s = Signature(dec)
return nil
} | go | {
"resource": ""
} |
q19342 | sign | train | func (j *jws) sign(keys ...interface{}) error {
if err := j.cache(); err != nil {
return err
}
if len(keys) < 1 ||
len(keys) > 1 && len(keys) != len(j.sb) {
return ErrNotEnoughKeys
}
if len(keys) == 1 {
k := keys[0]
keys = make([]interface{}, len(j.sb))
for i := range keys {
keys[i] = k
}
}
for i := range j.sb {
if 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
} | go | {
"resource": ""
} |
q19343 | cache | train | func (j *jws) cache() (err error) {
if !j.clean {
j.plcache, err = j.payload.Base64()
j.clean = err == nil
}
return err
} | go | {
"resource": ""
} |
q19344 | cache | train | func (s *sigHead) cache() (err error) {
if !s.clean {
s.Protected, err = s.protected.Base64()
if err != nil {
return err
}
s.Unprotected, err = s.unprotected.Base64()
if err != nil {
return err
}
}
s.clean = true
return nil
} | go | {
"resource": ""
} |
q19345 | VerifyCallback | train | func (j *jws) VerifyCallback(fn VerifyCallback, methods []crypto.SigningMethod, o *SigningOpts) error {
keys, err := fn(j)
if err != nil {
return err
}
return j.VerifyMulti(keys, methods, o)
} | go | {
"resource": ""
} |
q19346 | Error | train | func (m *MultiError) Error() string {
var s string
var n int
for _, err := range *m {
if err != nil {
if n == 0 {
s = err.Error()
}
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)
} | go | {
"resource": ""
} |
q19347 | VerifyMulti | train | func (j *jws) VerifyMulti(keys []interface{}, methods []crypto.SigningMethod, o *SigningOpts) error {
// Catch a simple mistake. Parameter o is irrelevant in this scenario.
if len(keys) == 1 &&
len(methods) == 1 &&
len(j.sb) == 1 {
return j.Verify(keys[0], methods[0])
}
if len(j.sb) != len(methods) {
return ErrNotEnoughMethods
}
if len(keys) < 1 ||
len(keys) > 1 && len(keys) != len(j.sb) {
return ErrNotEnoughKeys
}
// TODO do this better.
if len(keys) == 1 {
k := keys[0]
keys = make([]interface{}, len(methods))
for i := range keys {
keys[i] = k
}
}
var o2 SigningOpts
if o == nil {
o = new(SigningOpts)
}
var 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
}
return &m
} | go | {
"resource": ""
} |
q19348 | Append | train | func (s *SigningOpts) Append(x int) {
s.Indices = append(s.Indices, x)
} | go | {
"resource": ""
} |
q19349 | Needs | train | func (s *SigningOpts) Needs(x int) bool {
return s.ptr < len(s.Indices) && s.Indices[s.ptr] == x
} | go | {
"resource": ""
} |
q19350 | Validate | train | func (s *SigningOpts) Validate(have *SigningOpts) error {
if have.Number < s.Number ||
(s.Indices != nil &&
!eq(s.Indices, have.Indices)) {
return ErrNotEnoughValidSignatures
}
return nil
} | go | {
"resource": ""
} |
q19351 | Verify | train | func (j *jws) Verify(key interface{}, method crypto.SigningMethod) error {
if len(j.sb) < 1 {
return ErrCannotValidate
}
return j.sb[0].verify(j.plcache, key, method)
} | go | {
"resource": ""
} |
q19352 | Verify | train | func (_ *SigningMethodNone) Verify(_ []byte, _ Signature, _ interface{}) error {
return nil
} | go | {
"resource": ""
} |
q19353 | Sign | train | func (_ *SigningMethodNone) Sign(_ []byte, _ interface{}) (Signature, error) {
return nil, nil
} | go | {
"resource": ""
} |
q19354 | Base64Decode | train | func Base64Decode(b []byte) ([]byte, error) {
buf := make([]byte, base64.RawURLEncoding.DecodedLen(len(b)))
n, err := base64.RawURLEncoding.Decode(buf, b)
return buf[:n], err
} | go | {
"resource": ""
} |
q19355 | Base64Encode | train | func Base64Encode(b []byte) []byte {
buf := make([]byte, base64.RawURLEncoding.EncodedLen(len(b)))
base64.RawURLEncoding.Encode(buf, b)
return buf
} | go | {
"resource": ""
} |
q19356 | MarshalJSON | train | func (r rawBase64) MarshalJSON() ([]byte, error) {
buf := make([]byte, len(r)+2)
buf[0] = '"'
copy(buf[1:], r)
buf[len(buf)-1] = '"'
return buf, nil
} | go | {
"resource": ""
} |
q19357 | UnmarshalJSON | train | func (r *rawBase64) UnmarshalJSON(b []byte) error {
if len(b) > 1 && b[0] == '"' && b[len(b)-1] == '"' {
b = b[1 : len(b)-1]
}
*r = rawBase64(b)
return nil
} | go | {
"resource": ""
} |
q19358 | RegisterSigningMethod | train | func RegisterSigningMethod(sm crypto.SigningMethod) {
alg := sm.Alg()
if GetSigningMethod(alg) != nil {
panic("jose/jws: cannot duplicate signing methods")
}
if !sm.Hasher().Available() {
panic("jose/jws: specific hash is unavailable")
}
mu.Lock()
signingMethods[alg] = sm
mu.Unlock()
} | go | {
"resource": ""
} |
q19359 | RemoveSigningMethod | train | func RemoveSigningMethod(sm crypto.SigningMethod) {
mu.Lock()
delete(signingMethods, sm.Alg())
mu.Unlock()
} | go | {
"resource": ""
} |
q19360 | GetSigningMethod | train | func GetSigningMethod(alg string) (method crypto.SigningMethod) {
mu.RLock()
method = signingMethods[alg]
mu.RUnlock()
return method
} | go | {
"resource": ""
} |
q19361 | NewJWT | train | func NewJWT(claims Claims, method crypto.SigningMethod) jwt.JWT {
j, ok := New(claims, method).(*jws)
if !ok {
panic("jws.NewJWT: runtime panic: New(...).(*jws) != true")
}
j.sb[0].protected.Set("typ", "JWT")
j.isJWT = true
return j
} | go | {
"resource": ""
} |
q19362 | Serialize | train | func (j *jws) Serialize(key interface{}) ([]byte, error) {
if j.isJWT {
return j.Compact(key)
}
return nil, ErrIsNotJWT
} | go | {
"resource": ""
} |
q19363 | Claims | train | func (j *jws) Claims() jwt.Claims {
if j.isJWT {
if c, ok := j.payload.v.(Claims); ok {
return jwt.Claims(c)
}
}
return nil
} | go | {
"resource": ""
} |
q19364 | ParseJWTFromRequest | train | func ParseJWTFromRequest(req *http.Request) (jwt.JWT, error) {
if b, ok := fromHeader(req); ok {
return ParseJWT(b)
}
if b, ok := fromForm(req); ok {
return ParseJWT(b)
}
return nil, ErrNoTokenInRequest
} | go | {
"resource": ""
} |
q19365 | NewValidator | train | func NewValidator(c Claims, exp, nbf time.Duration, fn func(Claims) error) *jwt.Validator {
return &jwt.Validator{
Expected: jwt.Claims(c),
EXP: exp,
NBF: nbf,
Fn: Conv(fn),
}
} | go | {
"resource": ""
} |
q19366 | ParseECPrivateKeyFromPEM | train | func ParseECPrivateKeyFromPEM(key []byte) (*ecdsa.PrivateKey, error) {
block, _ := pem.Decode(key)
if block == nil {
return nil, ErrKeyMustBePEMEncoded
}
return x509.ParseECPrivateKey(block.Bytes)
} | go | {
"resource": ""
} |
q19367 | ParseECPublicKeyFromPEM | train | func ParseECPublicKeyFromPEM(key []byte) (*ecdsa.PublicKey, error) {
block, _ := pem.Decode(key)
if block == nil {
return nil, ErrKeyMustBePEMEncoded
}
parsedKey, err := x509.ParsePKIXPublicKey(block.Bytes)
if err != nil {
cert, err := x509.ParseCertificate(block.Bytes)
if err != nil {
return nil, err
}
parsedKey = cert.PublicKey
}
pkey, ok := parsedKey.(*ecdsa.PublicKey)
if !ok {
return nil, ErrNotECPublicKey
}
return pkey, nil
} | go | {
"resource": ""
} |
q19368 | ProtectedAt | train | func (j *jws) ProtectedAt(i int) jose.Protected {
return j.sb[i].protected
} | go | {
"resource": ""
} |
q19369 | HeaderAt | train | func (j *jws) HeaderAt(i int) jose.Header {
return j.sb[i].unprotected
} | go | {
"resource": ""
} |
q19370 | New | train | func New(content interface{}, methods ...crypto.SigningMethod) JWS {
sb := make([]sigHead, len(methods))
for i := range methods {
sb[i] = sigHead{
protected: jose.Protected{
"alg": methods[i].Alg(),
},
unprotected: jose.Header{},
method: methods[i],
}
}
return &jws{
payload: &payload{v: content},
sb: sb,
}
} | go | {
"resource": ""
} |
q19371 | ParseFromHeader | train | func ParseFromHeader(req *http.Request, format Format, u ...json.Unmarshaler) (JWS, error) {
if b, ok := fromHeader(req); ok {
return parseJumpTable[format](b, u...)
}
return nil, ErrNoTokenInRequest
} | go | {
"resource": ""
} |
q19372 | ParseFromForm | train | func ParseFromForm(req *http.Request, format Format, u ...json.Unmarshaler) (JWS, error) {
if b, ok := fromForm(req); ok {
return parseJumpTable[format](b, u...)
}
return nil, ErrNoTokenInRequest
} | go | {
"resource": ""
} |
q19373 | ParseFromRequest | train | func ParseFromRequest(req *http.Request, format Format, u ...json.Unmarshaler) (JWS, error) {
token, err := ParseFromHeader(req, format, u...)
if err == nil {
return token, nil
}
token, err = ParseFromForm(req, format, u...)
if err == nil {
return token, nil
}
return nil, err
} | go | {
"resource": ""
} |
q19374 | checkHeaders | train | func checkHeaders(a, b jose.Header) error {
if len(a)+len(b) == 0 {
return ErrTwoEmptyHeaders
}
for key := range a {
if b.Has(key) && !IgnoreDupes {
return ErrDuplicateHeaderParameter
}
}
return nil
} | go | {
"resource": ""
} |
q19375 | MarshalJSON | train | func (p *payload) MarshalJSON() ([]byte, error) {
b, err := json.Marshal(p.v)
if err != nil {
return nil, err
}
return jose.EncodeEscape(b), nil
} | go | {
"resource": ""
} |
q19376 | Base64 | train | func (p *payload) Base64() ([]byte, error) {
b, err := json.Marshal(p.v)
if err != nil {
return nil, err
}
return jose.Base64Encode(b), nil
} | go | {
"resource": ""
} |
q19377 | UnmarshalJSON | train | func (p *payload) UnmarshalJSON(b []byte) error {
b2, err := jose.DecodeEscaped(b)
if err != nil {
return err
}
if p.u != nil {
err := p.u.UnmarshalJSON(b2)
p.v = p.u
return err
}
return json.Unmarshal(b2, &p.v)
} | go | {
"resource": ""
} |
q19378 | Del | train | func (c Claims) Del(key string) {
jwt.Claims(c).Del(key)
} | go | {
"resource": ""
} |
q19379 | UnmarshalJSON | train | func (c *Claims) UnmarshalJSON(b []byte) error {
if b == nil {
return nil
}
b, err := jose.DecodeEscaped(b)
if err != nil {
return err
}
// Since json.Unmarshal calls UnmarshalJSON,
// calling json.Unmarshal on *p would be infinitely recursive
// A temp variable is needed because &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
} | go | {
"resource": ""
} |
q19380 | NewVariant | train | func NewVariant(vt VT, val int64) VARIANT {
return VARIANT{VT: vt, Val: val}
} | go | {
"resource": ""
} |
q19381 | ToIUnknown | train | func (v *VARIANT) ToIUnknown() *IUnknown {
if v.VT != VT_UNKNOWN {
return nil
}
return (*IUnknown)(unsafe.Pointer(uintptr(v.Val)))
} | go | {
"resource": ""
} |
q19382 | ToIDispatch | train | func (v *VARIANT) ToIDispatch() *IDispatch {
if v.VT != VT_DISPATCH {
return nil
}
return (*IDispatch)(unsafe.Pointer(uintptr(v.Val)))
} | go | {
"resource": ""
} |
q19383 | ToArray | train | func (v *VARIANT) ToArray() *SafeArrayConversion {
if v.VT != VT_SAFEARRAY {
if v.VT&VT_ARRAY == 0 {
return nil
}
}
var safeArray *SafeArray = (*SafeArray)(unsafe.Pointer(uintptr(v.Val)))
return &SafeArrayConversion{safeArray}
} | go | {
"resource": ""
} |
q19384 | ToString | train | func (v *VARIANT) ToString() string {
if v.VT != VT_BSTR {
return ""
}
return BstrToString(*(**uint16)(unsafe.Pointer(&v.Val)))
} | go | {
"resource": ""
} |
q19385 | IsEqualGUID | train | func IsEqualGUID(guid1 *GUID, guid2 *GUID) bool {
return guid1.Data1 == guid2.Data1 &&
guid1.Data2 == guid2.Data2 &&
guid1.Data3 == guid2.Data3 &&
guid1.Data4[0] == guid2.Data4[0] &&
guid1.Data4[1] == guid2.Data4[1] &&
guid1.Data4[2] == guid2.Data4[2] &&
guid1.Data4[3] == guid2.Data4[3] &&
guid1.Data4[4] == guid2.Data4[4] &&
guid1.Data4[5] == guid2.Data4[5] &&
guid1.Data4[6] == guid2.Data4[6] &&
guid1.Data4[7] == guid2.Data4[7]
} | go | {
"resource": ""
} |
q19386 | coInitializeEx | train | func coInitializeEx(coinit uint32) (err error) {
// http://msdn.microsoft.com/en-us/library/windows/desktop/ms695279(v=vs.85).aspx
// Suggests that the first parameter is not only optional but should always be NULL.
hr, _, _ := procCoInitializeEx.Call(uintptr(0), uintptr(coinit))
if hr != 0 {
err = NewError(hr)
}
return
} | go | {
"resource": ""
} |
q19387 | CoInitializeEx | train | func CoInitializeEx(p uintptr, coinit uint32) (err error) {
// Avoid any variable not used errors.
p = uintptr(0)
return coInitializeEx(coinit)
} | go | {
"resource": ""
} |
q19388 | CLSIDFromString | train | func CLSIDFromString(str string) (clsid *GUID, err error) {
var guid GUID
lpsz := uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(str)))
hr, _, _ := procCLSIDFromString.Call(lpsz, uintptr(unsafe.Pointer(&guid)))
if hr != 0 {
err = NewError(hr)
}
clsid = &guid
return
} | go | {
"resource": ""
} |
q19389 | StringFromCLSID | train | func StringFromCLSID(clsid *GUID) (str string, err error) {
var p *uint16
hr, _, _ := procStringFromCLSID.Call(uintptr(unsafe.Pointer(clsid)), uintptr(unsafe.Pointer(&p)))
if hr != 0 {
err = NewError(hr)
}
str = LpOleStrToString(p)
return
} | go | {
"resource": ""
} |
q19390 | IIDFromString | train | func IIDFromString(progId string) (clsid *GUID, err error) {
var guid GUID
lpsz := uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(progId)))
hr, _, _ := procIIDFromString.Call(lpsz, uintptr(unsafe.Pointer(&guid)))
if hr != 0 {
err = NewError(hr)
}
clsid = &guid
return
} | go | {
"resource": ""
} |
q19391 | StringFromIID | train | func StringFromIID(iid *GUID) (str string, err error) {
var p *uint16
hr, _, _ := procStringFromIID.Call(uintptr(unsafe.Pointer(iid)), uintptr(unsafe.Pointer(&p)))
if hr != 0 {
err = NewError(hr)
}
str = LpOleStrToString(p)
return
} | go | {
"resource": ""
} |
q19392 | GetActiveObject | train | func GetActiveObject(clsid *GUID, iid *GUID) (unk *IUnknown, err error) {
if iid == nil {
iid = IID_IUnknown
}
hr, _, _ := procGetActiveObject.Call(
uintptr(unsafe.Pointer(clsid)),
uintptr(unsafe.Pointer(iid)),
uintptr(unsafe.Pointer(&unk)))
if hr != 0 {
err = NewError(hr)
}
return
} | go | {
"resource": ""
} |
q19393 | GetObject | train | func GetObject(programID string, bindOpts *BindOpts, iid *GUID) (unk *IUnknown, err error) {
if bindOpts != nil {
bindOpts.CbStruct = uint32(unsafe.Sizeof(BindOpts{}))
}
if iid == nil {
iid = IID_IUnknown
}
hr, _, _ := procCoGetObject.Call(
uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(programID))),
uintptr(unsafe.Pointer(bindOpts)),
uintptr(unsafe.Pointer(iid)),
uintptr(unsafe.Pointer(&unk)))
if hr != 0 {
err = NewError(hr)
}
return
} | go | {
"resource": ""
} |
q19394 | VariantInit | train | func VariantInit(v *VARIANT) (err error) {
hr, _, _ := procVariantInit.Call(uintptr(unsafe.Pointer(v)))
if hr != 0 {
err = NewError(hr)
}
return
} | go | {
"resource": ""
} |
q19395 | VariantClear | train | func VariantClear(v *VARIANT) (err error) {
hr, _, _ := procVariantClear.Call(uintptr(unsafe.Pointer(v)))
if hr != 0 {
err = NewError(hr)
}
return
} | go | {
"resource": ""
} |
q19396 | SysAllocString | train | func SysAllocString(v string) (ss *int16) {
pss, _, _ := procSysAllocString.Call(uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(v))))
ss = (*int16)(unsafe.Pointer(pss))
return
} | go | {
"resource": ""
} |
q19397 | SysAllocStringLen | train | func SysAllocStringLen(v string) (ss *int16) {
utf16 := utf16.Encode([]rune(v + "\x00"))
ptr := &utf16[0]
pss, _, _ := procSysAllocStringLen.Call(uintptr(unsafe.Pointer(ptr)), uintptr(len(utf16)-1))
ss = (*int16)(unsafe.Pointer(pss))
return
} | go | {
"resource": ""
} |
q19398 | SysFreeString | train | func SysFreeString(v *int16) (err error) {
hr, _, _ := procSysFreeString.Call(uintptr(unsafe.Pointer(v)))
if hr != 0 {
err = NewError(hr)
}
return
} | go | {
"resource": ""
} |
q19399 | SysStringLen | train | func SysStringLen(v *int16) uint32 {
l, _, _ := procSysStringLen.Call(uintptr(unsafe.Pointer(v)))
return uint32(l)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.