id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c18700 | }
if err != nil {
response.Errors = append(response.Errors, fmt.Sprintf("ERROR %v", err))
}
// run generated Go files through imports pkg
if filepath.Ext(file.Name) == ".go" {
file.Data, err = imports.Process(file.Name, file.Data, nil)
}
response.Files = append(response.Files, file)
}
return
} | |
c18701 | if v.Get != nil {
b.buildMethodFromOperation(v.Get, "GET", pair.Name)
}
if v.Post != nil {
b.buildMethodFromOperation(v.Post, "POST", pair.Name)
}
if v.Put != nil {
b.buildMethodFromOperation(v.Put, "PUT", pair.Name)
}
if v.Delete != nil {
b.buildMethodFromOperation(v.Delete, "DELET... | |
c18702 |
// generate package declaration
code.Print("package %s\n", packageName)
code.Print("import (")
for _, filename := range imports {
code.Print("\"" + filename + "\"")
}
code.Print(")\n")
code.Print(codeBody)
return code.String()
} | |
c18703 | s.DefinitionArrayTypes = make(map[string]int, 0)
s.DefinitionPrimitiveTypes = make(map[string]int, 0)
s.AnonymousOperations = make([]string, 0)
s.AnonymousObjects = make([]string, 0)
s.analyzeDocument(source, document)
return s
} | |
c18704 | s.addDefinitionFieldType(path+"/"+pair.Name, propertyType)
}
}
case "array":
s.addDefinitionArrayType(path+"/", typeForSchema(definition))
default: // string, boolean, integer, number, null...
s.addDefinitionPrimitiveType(path+"/", typeName)
}
} | |
c18705 | s.analyzeOperation("delete", "paths"+pair.Name+"/delete", path.Delete)
}
}
if document.Definitions != nil {
for _, pair := range document.Definitions.AdditionalProperties {
definition := pair.Value
s.analyzeDefinition("definitions/"+pair.Name, definition)
}
}
} | |
c18706 | := typeForSchema(schema.AdditionalProperties.GetSchema())
return "map-of-" + additionalPropertiesSchemaType
}
if schema.AdditionalProperties.GetBoolean() == false {
// no additional properties are allowed, so we're not sure what to do if we get here...
return typeName
}
}
if schema.Items != ni... | |
c18707 | != nil {
return strings.Join(*s.StringArray, ", ")
}
return ""
} | |
c18708 | }
case "object":
f.NativeType = "interface{}"
case "string":
f.NativeType = "string"
default:
f.NativeType = strings.Title(filteredTypeName(f.Type))
}
}
}
for _, m := range model.Methods {
m.HandlerName = "Handle" + m.Name
m.ProcessorName = m.Name
m.ClientName = m.Name
}
} | |
c18709 | index > 0 {
out += "_"
}
out += string(runeValue - 'A' + 'a')
} else {
out += string(runeValue)
}
}
return out
} | |
c18710 | nil, errors.New(fmt.Sprintf("Error downloading %s: %s", fileurl, response.Status))
}
defer response.Body.Close()
bytes, err = ioutil.ReadAll(response.Body)
if fileCacheEnable && err == nil {
fileCache[fileurl] = bytes
}
return bytes, err
} | |
c18711 | bytes, err := FetchFile(filename)
if err != nil {
return nil, err
}
return bytes, nil
}
// no, it's a local filename
bytes, err := ioutil.ReadFile(filename)
if err != nil {
return nil, err
}
return bytes, nil
} | |
c18712 |
var info yaml.MapSlice
err := yaml.Unmarshal(bytes, &info)
if err != nil {
return nil, err
}
if infoCacheEnable && len(filename) > 0 {
infoCache[filename] = info
}
return info, nil
} | |
c18713 |
if !ok {
return "", false
}
return fn(variable), ok
} | |
c18714 | p.last++
p.values[value] = num
}
return fmt.Sprintf("%s%d", p.prefix, num)
} | |
c18715 | typeName := range typeNames {
domain.generateConstructorForType(code, typeName, regexPatterns)
}
// generate ResolveReferences() methods for each type
for _, typeName := range typeNames {
domain.generateResolveReferencesMethodsForType(code, typeName)
}
// generate ToRawInfo() methods for each type
for _, t... | |
c18716 | err = proto.Unmarshal(apiData, documentv2)
if err == nil {
env.Request.AddModel("openapi.v2.Document", documentv2)
// include experimental API surface model
surfaceModel, err := surface.NewModelFromOpenAPI2(documentv2)
if err == nil {
env.Request.AddModel("surface.v1.Model", surfaceModel)
}
re... | |
c18717 | env.Response.Errors = append(env.Response.Errors, err.Error())
env.RespondAndExit()
}
} | |
c18718 | err := HandleResponse(env.Response, env.Request.OutputPath)
if err != nil {
log.Printf("%s", err.Error())
}
}
os.Exit(0)
} | |
c18719 |
return nil, errors.New("Must specify a redirect URI in config file or when creating OAuth client")
}
return &oauth2.Config{
ClientID: cfg.Installed.ClientID,
ClientSecret: cfg.Installed.ClientSecret,
Scopes: scopes,
Endpoint: oauth2.Endpoint{cfg.Installed.AuthURI, cfg.Installed.TokenURI},
... | |
c18720 |
}
if api.Methods != nil {
for _, pair := range api.Methods.AdditionalProperties {
addOpenAPI2PathsForMethod(d, pair.Name, pair.Value)
}
}
if api.Resources != nil {
for _, pair := range api.Resources.AdditionalProperties {
addOpenAPI2PathsForResource(d, pair.Name, pair.Value)
}
}
return d, nil
} | |
c18721 | errFromPlugin = customAnyProtoGenerator.handle(in, extensionName)
if outFromPlugin == nil {
continue
} else {
handled = true
break
}
}
}
return handled, outFromPlugin, errFromPlugin
} | |
c18722 | = &openapi3.Components{}
d.Components.Schemas = &openapi3.SchemasOrReferences{}
for _, pair := range api.Schemas.AdditionalProperties {
addOpenAPI3SchemaForSchema(d, pair.Name, pair.Value)
}
d.Paths = &openapi3.Paths{}
if api.Methods != nil {
for _, pair := range api.Methods.AdditionalProperties {
addOpen... | |
c18723 | errors = append(errors, matchingError)
}
}
}
// bool boolean = 2;
boolValue, ok := in.(bool)
if ok {
x.Oneof = &AdditionalPropertiesItem_Boolean{Boolean: boolValue}
}
if matched {
// since the oneof matched one of its possibilities, discard any matching errors
errors = make([]error, 0)
}
return x, ... | |
c18724 | // MAP: Header
x.AdditionalProperties = make([]*NamedHeader, 0)
for _, item := range m {
k, ok := compiler.StringValue(item.Key)
if ok {
v := item.Value
pair := &NamedHeader{}
pair.Name = k
var err error
pair.Value, err = NewHeader(v, compiler.NewContext(k, context))
if err != nil {
... | |
c18725 | x.Schema = make([]*Schema, 0)
y, err := NewSchema(m, compiler.NewContext("<array>", context))
if err != nil {
return nil, err
}
x.Schema = append(x.Schema, y)
}
return x, compiler.NewErrorGroupOrNil(errors)
} | |
c18726 | if !ok {
message := fmt.Sprintf("has unexpected value for $ref: %+v (%T)", v1, v1)
errors = append(errors, compiler.NewError(context, message))
}
}
// string description = 2;
v2 := compiler.MapValueForKey(m, "description")
if v2 != nil {
x.Description, ok = v2.(string)
if !ok {
message :... | |
c18727 |
errors = append(errors, matchingError)
}
}
// FormDataParameterSubSchema form_data_parameter_sub_schema = 2;
{
// errors might be ok here, they mean we just don't have the right subtype
t, matchingError := NewFormDataParameterSubSchema(m, compiler.NewContext("formDataParameterSubSchema", context))
... | |
c18728 | k, ok := compiler.StringValue(item.Key)
if ok {
v := item.Value
pair := &NamedString{}
pair.Name = k
pair.Value = v.(string)
x.AdditionalProperties = append(x.AdditionalProperties, pair)
}
}
}
return x, compiler.NewErrorGroupOrNil(errors)
} | |
c18729 |
v := item.Value
pair := &NamedParameter{}
pair.Name = k
var err error
pair.Value, err = NewParameter(v, compiler.NewContext(k, context))
if err != nil {
errors = append(errors, err)
}
x.AdditionalProperties = append(x.AdditionalProperties, pair)
}
}
}
return x, compiler.NewE... | |
c18730 | := NewJsonReference(m, compiler.NewContext("jsonReference", context))
if matchingError == nil {
x.Oneof = &ParametersItem_JsonReference{JsonReference: t}
matched = true
} else {
errors = append(errors, matchingError)
}
}
}
if matched {
// since the oneof matched one of its possibilities, dis... | |
c18731 | {
v := item.Value
pair := &NamedResponse{}
pair.Name = k
var err error
pair.Value, err = NewResponse(v, compiler.NewContext(k, context))
if err != nil {
errors = append(errors, err)
}
x.AdditionalProperties = append(x.AdditionalProperties, pair)
}
}
}
return x, compiler.NewE... | |
c18732 | := NewJsonReference(m, compiler.NewContext("jsonReference", context))
if matchingError == nil {
x.Oneof = &ResponseValue_JsonReference{JsonReference: t}
matched = true
} else {
errors = append(errors, matchingError)
}
}
}
if matched {
// since the oneof matched one of its possibilities, disc... | |
c18733 | NewFileSchema(m, compiler.NewContext("fileSchema", context))
if matchingError == nil {
x.Oneof = &SchemaItem_FileSchema{FileSchema: t}
matched = true
} else {
errors = append(errors, matchingError)
}
}
}
if matched {
// since the oneof matched one of its possibilities, discard any matching e... | |
c18734 | v := item.Value
pair := &NamedSecurityDefinitionsItem{}
pair.Name = k
var err error
pair.Value, err = NewSecurityDefinitionsItem(v, compiler.NewContext(k, context))
if err != nil {
errors = append(errors, err)
}
x.AdditionalProperties = append(x.AdditionalProperties, pair)
}
}
... | |
c18735 | }
// Oauth2ApplicationSecurity oauth2_application_security = 5;
{
m, ok := compiler.UnpackMap(in)
if ok {
// errors might be ok here, they mean we just don't have the right subtype
t, matchingError := NewOauth2ApplicationSecurity(m, compiler.NewContext("oauth2ApplicationSecurity", context))
if matchingE... | |
c18736 | %+v (%T)", value, value)
errors = append(errors, compiler.NewError(context, message))
}
}
default:
message := fmt.Sprintf("has unexpected value for string array: %+v (%T)", in, in)
errors = append(errors, compiler.NewError(context, message))
}
return x, compiler.NewErrorGroupOrNil(errors)
} | |
c18737 | item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | |
c18738 | nil {
errors = append(errors, err)
}
}
for _, item := range m.VendorExtension {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | |
c18739 | {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | |
c18740 | if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | |
c18741 | {
*m = *replacement
return m.ResolveReferences(root)
}
}
return info, nil
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | |
c18742 | {
p, ok := m.Oneof.(*NonBodyParameter_QueryParameterSubSchema)
if ok {
_, err := p.QueryParameterSubSchema.ResolveReferences(root)
if err != nil {
return nil, err
}
}
}
{
p, ok := m.Oneof.(*NonBodyParameter_PathParameterSubSchema)
if ok {
_, err := p.PathParameterSubSchema.ResolveReferences... | |
c18743 | _, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | |
c18744 | } else if info != nil {
n, err := NewParametersItem(info, nil)
if err != nil {
return nil, err
} else if n != nil {
*m = *n
return nil, nil
}
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | |
c18745 | != nil {
errors = append(errors, err)
}
}
for _, item := range m.Enum {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
for _, item := range m.VendorExtension {
if item != nil {
_, err := item.ResolveReferences(root)
if err !=... | |
c18746 | item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | |
c18747 | } else if info != nil {
n, err := NewResponseValue(info, nil)
if err != nil {
return nil, err
} else if n != nil {
*m = *n
return nil, nil
}
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | |
c18748 | {
_, err := p.FileSchema.ResolveReferences(root)
if err != nil {
return nil, err
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | |
c18749 | }
}
}
{
p, ok := m.Oneof.(*SecurityDefinitionsItem_Oauth2ApplicationSecurity)
if ok {
_, err := p.Oauth2ApplicationSecurity.ResolveReferences(root)
if err != nil {
return nil, err
}
}
}
{
p, ok := m.Oneof.(*SecurityDefinitionsItem_Oauth2AccessCodeSecurity)
if ok {
_, err := p.Oauth2Acc... | |
c18750 | // {Name:boolean Type:bool StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if v1, ok := m.GetOneof().(*AdditionalPropertiesItem_Boolean); ok {
return v1.Boolean
}
return nil
} | |
c18751 | for _, item := range m.VendorExtension {
info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
}
}
// &{Name:VendorExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
return info
} | |
c18752 | Pattern: Implicit:false Description:}
if m.VendorExtension != nil {
for _, item := range m.VendorExtension {
info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
}
}
// &{Name:VendorExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Des... | |
c18753 | }
// always include this required field.
info = append(info, yaml.MapItem{Key: "type", Value: m.Type})
if m.ReadOnly != false {
info = append(info, yaml.MapItem{Key: "readOnly", Value: m.ReadOnly})
}
if m.ExternalDocs != nil {
info = append(info, yaml.MapItem{Key: "externalDocs", Value: m.ExternalDocs.ToRawIn... | |
c18754 | info = append(info, yaml.MapItem{Key: "license", Value: m.License.ToRawInfo()})
}
// &{Name:license Type:License StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.VendorExtension != nil {
for _, item := range m.VendorExtension {
info = append(info, yaml.MapItem{Key: item.N... | |
c18755 | append(info, yaml.MapItem{Key: "schema", Value: items})
}
// &{Name:schema Type:Schema StringEnumValues:[] MapType: Repeated:true Pattern: Implicit:false Description:}
return info
} | |
c18756 |
if m.Description != "" {
info = append(info, yaml.MapItem{Key: "description", Value: m.Description})
}
return info
} | |
c18757 | range m.VendorExtension {
info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
}
}
// &{Name:VendorExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
return info
} | |
c18758 | Pattern: Implicit:false Description:}
v1 := m.GetFormDataParameterSubSchema()
if v1 != nil {
return v1.ToRawInfo()
}
// {Name:queryParameterSubSchema Type:QueryParameterSubSchema StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
v2 := m.GetQueryParameterSubSchema()
if v2 != nil ... | |
c18759 | if m.Description != "" {
info = append(info, yaml.MapItem{Key: "description", Value: m.Description})
}
if m.VendorExtension != nil {
for _, item := range m.VendorExtension {
info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
}
}
// &{Name:VendorExtension Type:NamedAny StringE... | |
c18760 |
}
// &{Name:additionalProperties Type:NamedString StringEnumValues:[] MapType:string Repeated:true Pattern: Implicit:true Description:}
return info
} | |
c18761 | {Name:jsonReference Type:JsonReference StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
v1 := m.GetJsonReference()
if v1 != nil {
return v1.ToRawInfo()
}
return nil
} | |
c18762 | {Name:jsonReference Type:JsonReference StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
v1 := m.GetJsonReference()
if v1 != nil {
return v1.ToRawInfo()
}
return nil
} | |
c18763 | {Name:fileSchema Type:FileSchema StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
v1 := m.GetFileSchema()
if v1 != nil {
return v1.ToRawInfo()
}
return nil
} | |
c18764 |
if v3 != nil {
return v3.ToRawInfo()
}
// {Name:oauth2ApplicationSecurity Type:Oauth2ApplicationSecurity StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
v4 := m.GetOauth2ApplicationSecurity()
if v4 != nil {
return v4.ToRawInfo()
}
// {Name:oauth2AccessCodeSecurity Type:Oaut... | |
c18765 | return info
}
if len(m.Value) != 0 {
info = append(info, yaml.MapItem{Key: "value", Value: m.Value})
}
return info
} | |
c18766 | b.model.addType(t)
}
}
}
// Collect service method descriptions from each PathItem.
if document.Paths != nil {
for _, pair := range document.Paths.Path {
b.buildMethodFromPathItem(pair.Name, pair.Value)
}
}
return err
} | |
c18767 |
if len(t.Fields) == 0 {
if schema.AdditionalProperties != nil {
// If the schema has no fixed properties and additional properties of a specified type,
// generate a map pointing to objects of that type.
t.Kind = TypeKind_OBJECT
t.ContentType = typeForRef(schema.AdditionalProperties.GetSchemaOrRef... | |
c18768 | m.Name = sanitizeOperationName(op.OperationId)
if m.Name == "" {
m.Name = generateOperationName(method, path)
}
m.Description = op.Description
m.ParametersTypeName, err = b.buildTypeFromParameters(m.Name, op.Parameters, op.RequestBody)
m.ResponsesTypeName, err = b.buildTypeFromResponses(&m, m.Name, ... | |
c18769 | }
if requestBody != nil {
content := requestBody.GetRequestBody().GetContent()
if content != nil {
for _, pair2 := range content.GetAdditionalProperties() {
if pair2.Name != "application/json" {
log.Printf("unimplemented: %q requestBody(%s)", name, pair2.Name)
continue
}
var f Field
f... | |
c18770 | f.Type, f.Format = b.typeForSchemaOrReference(pair2.GetValue().GetSchema())
f.Kind = FieldKind_REFERENCE
t.addField(&f)
}
}
}
for _, pair := range responses.ResponseOrReference {
addResponse(pair.Name, pair.Value)
}
if responses.Default != nil {
addResponse("default", responses.Default)
}
if l... | |
c18771 | nil {
return b.typeForSchema(value.GetSchema())
}
if value.GetReference() != nil {
return FieldKind_SCALAR, typeForRef(value.GetReference().XRef), ""
}
return FieldKind_SCALAR, "todo", ""
} | |
c18772 | case "object":
if schema.AdditionalProperties == nil {
return FieldKind_MAP, "object", format
}
default:
}
}
if schema.AdditionalProperties != nil {
additionalProperties := schema.AdditionalProperties
if propertySchema := additionalProperties.GetSchemaOrReference().GetReference(); propertySchema ... | |
c18773 | "DOMDebugger.getEventListeners", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "DOMDebugger", Op: "GetEventListeners", Err: err}
}
return
} | |
c18774 |
err = &internal.OpError{Domain: "HeadlessExperimental", Op: "Disable", Err: err}
}
return
} | |
c18775 | "Runtime.awaitPromise", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "Runtime", Op: "AwaitPromise", Err: err}
}
return
} | |
c18776 | rpcc.Invoke(ctx, "Runtime.callFunctionOn", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "Runtime", Op: "CallFunctionOn", Err: err}
}
return
} | |
c18777 | "Runtime.compileScript", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "Runtime", Op: "CompileScript", Err: err}
}
return
} | |
c18778 | rpcc.Invoke(ctx, "Runtime.evaluate", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "Runtime.evaluate", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "Runtime", Op: "Evaluate", Err: err}
}
return
} | |
c18779 | "Runtime.getProperties", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "Runtime", Op: "GetProperties", Err: err}
}
return
} | |
c18780 | err = rpcc.Invoke(ctx, "Runtime.globalLexicalScopeNames", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "Runtime", Op: "GlobalLexicalScopeNames", Err: err}
}
return
} | |
c18781 | "Runtime.queryObjects", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "Runtime", Op: "QueryObjects", Err: err}
}
return
} | |
c18782 | rpcc.Invoke(ctx, "Runtime.runScript", args, reply, d.conn)
} else {
err = rpcc.Invoke(ctx, "Runtime.runScript", nil, reply, d.conn)
}
if err != nil {
err = &internal.OpError{Domain: "Runtime", Op: "RunScript", Err: err}
}
return
} | |
c18783 | new(GetCurrentTimeArgs)
args.ID = id
return args
} | |
c18784 | new(ReleaseAnimationsArgs)
args.Animations = animations
return args
} | |
c18785 | new(ResolveAnimationArgs)
args.AnimationID = animationID
return args
} | |
c18786 | {
args := new(SeekAnimationsArgs)
args.Animations = animations
args.CurrentTime = currentTime
return args
} | |
c18787 | new(SetPausedArgs)
args.Animations = animations
args.Paused = paused
return args
} | |
c18788 | new(SetPlaybackRateArgs)
args.PlaybackRate = playbackRate
return args
} | |
c18789 | {
args := new(SetTimingArgs)
args.AnimationID = animationID
args.Duration = duration
args.Delay = delay
return args
} | |
c18790 | new(ContinueToLocationArgs)
args.Location = location
return args
} | |
c18791 | new(EvaluateOnCallFrameArgs)
args.CallFrameID = callFrameID
args.Expression = expression
return args
} | |
c18792 | a.IncludeCommandLineAPI = &includeCommandLineAPI
return a
} | |
c18793 | a.ThrowOnSideEffect = &throwOnSideEffect
return a
} | |
c18794 | new(GetPossibleBreakpointsArgs)
args.Start = start
return args
} | |
c18795 | new(GetScriptSourceArgs)
args.ScriptID = scriptID
return args
} | |
c18796 | new(GetStackTraceArgs)
args.StackTraceID = stackTraceID
return args
} | |
c18797 | new(PauseOnAsyncCallArgs)
args.ParentStackTraceID = parentStackTraceID
return args
} | |
c18798 | new(RemoveBreakpointArgs)
args.BreakpointID = breakpointID
return args
} | |
c18799 | new(RestartFrameArgs)
args.CallFrameID = callFrameID
return args
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.