_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q18600 | ResolveReferences | train | func (m *Request) ResolveReferences(root string) (interface{}, error) {
errors := make([]error, 0)
if m.XRef != "" {
info, err := compiler.ReadInfoForRef(root, m.XRef)
if err != nil {
return nil, err
}
if info != nil {
replacement, err := NewRequest(info, nil)
if err == nil {
*m = *replacement
return m.ResolveReferences(root)
}
}
return info, nil
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18601 | ResolveReferences | train | func (m *Resource) ResolveReferences(root string) (interface{}, error) {
errors := make([]error, 0)
if m.Methods != nil {
_, err := m.Methods.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.Resources != nil {
_, err := m.Resources.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18602 | ToRawInfo | train | func (m *Annotations) ToRawInfo() interface{} {
info := yaml.MapSlice{}
if len(m.Required) != 0 {
info = append(info, yaml.MapItem{Key: "required", Value: m.Required})
}
return info
} | go | {
"resource": ""
} |
q18603 | ToRawInfo | train | func (m *Any) ToRawInfo() interface{} {
var err error
var info1 []yaml.MapSlice
err = yaml.Unmarshal([]byte(m.Yaml), &info1)
if err == nil {
return info1
}
var info2 yaml.MapSlice
err = yaml.Unmarshal([]byte(m.Yaml), &info2)
if err == nil {
return info2
}
var info3 interface{}
err = yaml.Unmarshal([]byte(m.Yaml), &info3)
if err == nil {
return info3
}
return nil
} | go | {
"resource": ""
} |
q18604 | ToRawInfo | train | func (m *Auth) ToRawInfo() interface{} {
info := yaml.MapSlice{}
if m.Oauth2 != nil {
info = append(info, yaml.MapItem{Key: "oauth2", Value: m.Oauth2.ToRawInfo()})
}
// &{Name:oauth2 Type:Oauth2 StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
return info
} | go | {
"resource": ""
} |
q18605 | ToRawInfo | train | func (m *Icons) ToRawInfo() interface{} {
info := yaml.MapSlice{}
if m.X16 != "" {
info = append(info, yaml.MapItem{Key: "x16", Value: m.X16})
}
if m.X32 != "" {
info = append(info, yaml.MapItem{Key: "x32", Value: m.X32})
}
return info
} | go | {
"resource": ""
} |
q18606 | ToRawInfo | train | func (m *MediaUpload) ToRawInfo() interface{} {
info := yaml.MapSlice{}
if len(m.Accept) != 0 {
info = append(info, yaml.MapItem{Key: "accept", Value: m.Accept})
}
if m.MaxSize != "" {
info = append(info, yaml.MapItem{Key: "maxSize", Value: m.MaxSize})
}
if m.Protocols != nil {
info = append(info, yaml.MapItem{Key: "protocols", Value: m.Protocols.ToRawInfo()})
}
// &{Name:protocols Type:Protocols StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.SupportsSubscription != false {
info = append(info, yaml.MapItem{Key: "supportsSubscription", Value: m.SupportsSubscription})
}
return info
} | go | {
"resource": ""
} |
q18607 | ToRawInfo | train | func (m *NamedMethod) ToRawInfo() interface{} {
info := yaml.MapSlice{}
if m.Name != "" {
info = append(info, yaml.MapItem{Key: "name", Value: m.Name})
}
// &{Name:value Type:Method StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:Mapped value}
return info
} | go | {
"resource": ""
} |
q18608 | ToRawInfo | train | func (m *Protocols) ToRawInfo() interface{} {
info := yaml.MapSlice{}
if m.Simple != nil {
info = append(info, yaml.MapItem{Key: "simple", Value: m.Simple.ToRawInfo()})
}
// &{Name:simple Type:Simple StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.Resumable != nil {
info = append(info, yaml.MapItem{Key: "resumable", Value: m.Resumable.ToRawInfo()})
}
// &{Name:resumable Type:Resumable StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
return info
} | go | {
"resource": ""
} |
q18609 | ToRawInfo | train | func (m *Request) ToRawInfo() interface{} {
info := yaml.MapSlice{}
if m.XRef != "" {
info = append(info, yaml.MapItem{Key: "$ref", Value: m.XRef})
}
if m.ParameterName != "" {
info = append(info, yaml.MapItem{Key: "parameterName", Value: m.ParameterName})
}
return info
} | go | {
"resource": ""
} |
q18610 | ToRawInfo | train | func (m *Resource) ToRawInfo() interface{} {
info := yaml.MapSlice{}
if m.Methods != nil {
info = append(info, yaml.MapItem{Key: "methods", Value: m.Methods.ToRawInfo()})
}
// &{Name:methods Type:Methods StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.Resources != nil {
info = append(info, yaml.MapItem{Key: "resources", Value: m.Resources.ToRawInfo()})
}
// &{Name:resources Type:Resources StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
return info
} | go | {
"resource": ""
} |
q18611 | ToRawInfo | train | func (m *Scope) ToRawInfo() interface{} {
info := yaml.MapSlice{}
if m.Description != "" {
info = append(info, yaml.MapItem{Key: "description", Value: m.Description})
}
return info
} | go | {
"resource": ""
} |
q18612 | ToRawInfo | train | func (m *Simple) ToRawInfo() interface{} {
info := yaml.MapSlice{}
if m.Multipart != false {
info = append(info, yaml.MapItem{Key: "multipart", Value: m.Multipart})
}
if m.Path != "" {
info = append(info, yaml.MapItem{Key: "path", Value: m.Path})
}
return info
} | go | {
"resource": ""
} |
q18613 | ServiceType | train | func (f *Field) ServiceType(m *Model) *Type {
return m.TypeWithTypeName(f.NativeType)
} | go | {
"resource": ""
} |
q18614 | NewAnyOrExpression | train | func NewAnyOrExpression(in interface{}, context *compiler.Context) (*AnyOrExpression, error) {
errors := make([]error, 0)
x := &AnyOrExpression{}
matched := false
// Any any = 1;
{
m, ok := compiler.UnpackMap(in)
if ok {
// errors might be ok here, they mean we just don't have the right subtype
t, matchingError := NewAny(m, compiler.NewContext("any", context))
if matchingError == nil {
x.Oneof = &AnyOrExpression_Any{Any: t}
matched = true
} else {
errors = append(errors, matchingError)
}
}
}
// Expression expression = 2;
{
m, ok := compiler.UnpackMap(in)
if ok {
// errors might be ok here, they mean we just don't have the right subtype
t, matchingError := NewExpression(m, compiler.NewContext("expression", context))
if matchingError == nil {
x.Oneof = &AnyOrExpression_Expression{Expression: t}
matched = true
} else {
errors = append(errors, matchingError)
}
}
}
if matched {
// since the oneof matched one of its possibilities, discard any matching errors
errors = make([]error, 0)
}
return x, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18615 | NewAnysOrExpressions | train | func NewAnysOrExpressions(in interface{}, context *compiler.Context) (*AnysOrExpressions, error) {
errors := make([]error, 0)
x := &AnysOrExpressions{}
m, ok := compiler.UnpackMap(in)
if !ok {
message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
errors = append(errors, compiler.NewError(context, message))
} else {
// repeated NamedAnyOrExpression additional_properties = 1;
// MAP: AnyOrExpression
x.AdditionalProperties = make([]*NamedAnyOrExpression, 0)
for _, item := range m {
k, ok := compiler.StringValue(item.Key)
if ok {
v := item.Value
pair := &NamedAnyOrExpression{}
pair.Name = k
var err error
pair.Value, err = NewAnyOrExpression(v, compiler.NewContext(k, context))
if err != nil {
errors = append(errors, err)
}
x.AdditionalProperties = append(x.AdditionalProperties, pair)
}
}
}
return x, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18616 | NewCallbackOrReference | train | func NewCallbackOrReference(in interface{}, context *compiler.Context) (*CallbackOrReference, error) {
errors := make([]error, 0)
x := &CallbackOrReference{}
matched := false
// Callback callback = 1;
{
m, ok := compiler.UnpackMap(in)
if ok {
// errors might be ok here, they mean we just don't have the right subtype
t, matchingError := NewCallback(m, compiler.NewContext("callback", context))
if matchingError == nil {
x.Oneof = &CallbackOrReference_Callback{Callback: t}
matched = true
} else {
errors = append(errors, matchingError)
}
}
}
// Reference reference = 2;
{
m, ok := compiler.UnpackMap(in)
if ok {
// errors might be ok here, they mean we just don't have the right subtype
t, matchingError := NewReference(m, compiler.NewContext("reference", context))
if matchingError == nil {
x.Oneof = &CallbackOrReference_Reference{Reference: t}
matched = true
} else {
errors = append(errors, matchingError)
}
}
}
if matched {
// since the oneof matched one of its possibilities, discard any matching errors
errors = make([]error, 0)
}
return x, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18617 | NewCallbacksOrReferences | train | func NewCallbacksOrReferences(in interface{}, context *compiler.Context) (*CallbacksOrReferences, error) {
errors := make([]error, 0)
x := &CallbacksOrReferences{}
m, ok := compiler.UnpackMap(in)
if !ok {
message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
errors = append(errors, compiler.NewError(context, message))
} else {
// repeated NamedCallbackOrReference additional_properties = 1;
// MAP: CallbackOrReference
x.AdditionalProperties = make([]*NamedCallbackOrReference, 0)
for _, item := range m {
k, ok := compiler.StringValue(item.Key)
if ok {
v := item.Value
pair := &NamedCallbackOrReference{}
pair.Name = k
var err error
pair.Value, err = NewCallbackOrReference(v, compiler.NewContext(k, context))
if err != nil {
errors = append(errors, err)
}
x.AdditionalProperties = append(x.AdditionalProperties, pair)
}
}
}
return x, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18618 | NewDefaultType | train | func NewDefaultType(in interface{}, context *compiler.Context) (*DefaultType, error) {
errors := make([]error, 0)
x := &DefaultType{}
matched := false
switch in := in.(type) {
case bool:
x.Oneof = &DefaultType_Boolean{Boolean: in}
matched = true
case string:
x.Oneof = &DefaultType_String_{String_: in}
matched = true
case int64:
x.Oneof = &DefaultType_Number{Number: float64(in)}
matched = true
case int32:
x.Oneof = &DefaultType_Number{Number: float64(in)}
matched = true
case int:
x.Oneof = &DefaultType_Number{Number: float64(in)}
matched = true
case float64:
x.Oneof = &DefaultType_Number{Number: in}
matched = true
case float32:
x.Oneof = &DefaultType_Number{Number: float64(in)}
matched = true
}
if matched {
// since the oneof matched one of its possibilities, discard any matching errors
errors = make([]error, 0)
}
return x, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18619 | NewDiscriminator | train | func NewDiscriminator(in interface{}, context *compiler.Context) (*Discriminator, error) {
errors := make([]error, 0)
x := &Discriminator{}
m, ok := compiler.UnpackMap(in)
if !ok {
message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
errors = append(errors, compiler.NewError(context, message))
} else {
requiredKeys := []string{"propertyName"}
missingKeys := compiler.MissingKeysInMap(m, requiredKeys)
if len(missingKeys) > 0 {
message := fmt.Sprintf("is missing required %s: %+v", compiler.PluralProperties(len(missingKeys)), strings.Join(missingKeys, ", "))
errors = append(errors, compiler.NewError(context, message))
}
allowedKeys := []string{"mapping", "propertyName"}
var allowedPatterns []*regexp.Regexp
invalidKeys := compiler.InvalidKeysInMap(m, allowedKeys, allowedPatterns)
if len(invalidKeys) > 0 {
message := fmt.Sprintf("has invalid %s: %+v", compiler.PluralProperties(len(invalidKeys)), strings.Join(invalidKeys, ", "))
errors = append(errors, compiler.NewError(context, message))
}
// string property_name = 1;
v1 := compiler.MapValueForKey(m, "propertyName")
if v1 != nil {
x.PropertyName, ok = v1.(string)
if !ok {
message := fmt.Sprintf("has unexpected value for propertyName: %+v (%T)", v1, v1)
errors = append(errors, compiler.NewError(context, message))
}
}
// Strings mapping = 2;
v2 := compiler.MapValueForKey(m, "mapping")
if v2 != nil {
var err error
x.Mapping, err = NewStrings(v2, compiler.NewContext("mapping", context))
if err != nil {
errors = append(errors, err)
}
}
}
return x, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18620 | NewEncodings | train | func NewEncodings(in interface{}, context *compiler.Context) (*Encodings, error) {
errors := make([]error, 0)
x := &Encodings{}
m, ok := compiler.UnpackMap(in)
if !ok {
message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
errors = append(errors, compiler.NewError(context, message))
} else {
// repeated NamedEncoding additional_properties = 1;
// MAP: Encoding
x.AdditionalProperties = make([]*NamedEncoding, 0)
for _, item := range m {
k, ok := compiler.StringValue(item.Key)
if ok {
v := item.Value
pair := &NamedEncoding{}
pair.Name = k
var err error
pair.Value, err = NewEncoding(v, compiler.NewContext(k, context))
if err != nil {
errors = append(errors, err)
}
x.AdditionalProperties = append(x.AdditionalProperties, pair)
}
}
}
return x, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18621 | NewExampleOrReference | train | func NewExampleOrReference(in interface{}, context *compiler.Context) (*ExampleOrReference, error) {
errors := make([]error, 0)
x := &ExampleOrReference{}
matched := false
// Example example = 1;
{
m, ok := compiler.UnpackMap(in)
if ok {
// errors might be ok here, they mean we just don't have the right subtype
t, matchingError := NewExample(m, compiler.NewContext("example", context))
if matchingError == nil {
x.Oneof = &ExampleOrReference_Example{Example: t}
matched = true
} else {
errors = append(errors, matchingError)
}
}
}
// Reference reference = 2;
{
m, ok := compiler.UnpackMap(in)
if ok {
// errors might be ok here, they mean we just don't have the right subtype
t, matchingError := NewReference(m, compiler.NewContext("reference", context))
if matchingError == nil {
x.Oneof = &ExampleOrReference_Reference{Reference: t}
matched = true
} else {
errors = append(errors, matchingError)
}
}
}
if matched {
// since the oneof matched one of its possibilities, discard any matching errors
errors = make([]error, 0)
}
return x, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18622 | NewExamplesOrReferences | train | func NewExamplesOrReferences(in interface{}, context *compiler.Context) (*ExamplesOrReferences, error) {
errors := make([]error, 0)
x := &ExamplesOrReferences{}
m, ok := compiler.UnpackMap(in)
if !ok {
message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
errors = append(errors, compiler.NewError(context, message))
} else {
// repeated NamedExampleOrReference additional_properties = 1;
// MAP: ExampleOrReference
x.AdditionalProperties = make([]*NamedExampleOrReference, 0)
for _, item := range m {
k, ok := compiler.StringValue(item.Key)
if ok {
v := item.Value
pair := &NamedExampleOrReference{}
pair.Name = k
var err error
pair.Value, err = NewExampleOrReference(v, compiler.NewContext(k, context))
if err != nil {
errors = append(errors, err)
}
x.AdditionalProperties = append(x.AdditionalProperties, pair)
}
}
}
return x, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18623 | NewHeaderOrReference | train | func NewHeaderOrReference(in interface{}, context *compiler.Context) (*HeaderOrReference, error) {
errors := make([]error, 0)
x := &HeaderOrReference{}
matched := false
// Header header = 1;
{
m, ok := compiler.UnpackMap(in)
if ok {
// errors might be ok here, they mean we just don't have the right subtype
t, matchingError := NewHeader(m, compiler.NewContext("header", context))
if matchingError == nil {
x.Oneof = &HeaderOrReference_Header{Header: t}
matched = true
} else {
errors = append(errors, matchingError)
}
}
}
// Reference reference = 2;
{
m, ok := compiler.UnpackMap(in)
if ok {
// errors might be ok here, they mean we just don't have the right subtype
t, matchingError := NewReference(m, compiler.NewContext("reference", context))
if matchingError == nil {
x.Oneof = &HeaderOrReference_Reference{Reference: t}
matched = true
} else {
errors = append(errors, matchingError)
}
}
}
if matched {
// since the oneof matched one of its possibilities, discard any matching errors
errors = make([]error, 0)
}
return x, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18624 | NewHeadersOrReferences | train | func NewHeadersOrReferences(in interface{}, context *compiler.Context) (*HeadersOrReferences, error) {
errors := make([]error, 0)
x := &HeadersOrReferences{}
m, ok := compiler.UnpackMap(in)
if !ok {
message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
errors = append(errors, compiler.NewError(context, message))
} else {
// repeated NamedHeaderOrReference additional_properties = 1;
// MAP: HeaderOrReference
x.AdditionalProperties = make([]*NamedHeaderOrReference, 0)
for _, item := range m {
k, ok := compiler.StringValue(item.Key)
if ok {
v := item.Value
pair := &NamedHeaderOrReference{}
pair.Name = k
var err error
pair.Value, err = NewHeaderOrReference(v, compiler.NewContext(k, context))
if err != nil {
errors = append(errors, err)
}
x.AdditionalProperties = append(x.AdditionalProperties, pair)
}
}
}
return x, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18625 | NewLinkOrReference | train | func NewLinkOrReference(in interface{}, context *compiler.Context) (*LinkOrReference, error) {
errors := make([]error, 0)
x := &LinkOrReference{}
matched := false
// Link link = 1;
{
m, ok := compiler.UnpackMap(in)
if ok {
// errors might be ok here, they mean we just don't have the right subtype
t, matchingError := NewLink(m, compiler.NewContext("link", context))
if matchingError == nil {
x.Oneof = &LinkOrReference_Link{Link: t}
matched = true
} else {
errors = append(errors, matchingError)
}
}
}
// Reference reference = 2;
{
m, ok := compiler.UnpackMap(in)
if ok {
// errors might be ok here, they mean we just don't have the right subtype
t, matchingError := NewReference(m, compiler.NewContext("reference", context))
if matchingError == nil {
x.Oneof = &LinkOrReference_Reference{Reference: t}
matched = true
} else {
errors = append(errors, matchingError)
}
}
}
if matched {
// since the oneof matched one of its possibilities, discard any matching errors
errors = make([]error, 0)
}
return x, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18626 | NewLinksOrReferences | train | func NewLinksOrReferences(in interface{}, context *compiler.Context) (*LinksOrReferences, error) {
errors := make([]error, 0)
x := &LinksOrReferences{}
m, ok := compiler.UnpackMap(in)
if !ok {
message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
errors = append(errors, compiler.NewError(context, message))
} else {
// repeated NamedLinkOrReference additional_properties = 1;
// MAP: LinkOrReference
x.AdditionalProperties = make([]*NamedLinkOrReference, 0)
for _, item := range m {
k, ok := compiler.StringValue(item.Key)
if ok {
v := item.Value
pair := &NamedLinkOrReference{}
pair.Name = k
var err error
pair.Value, err = NewLinkOrReference(v, compiler.NewContext(k, context))
if err != nil {
errors = append(errors, err)
}
x.AdditionalProperties = append(x.AdditionalProperties, pair)
}
}
}
return x, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18627 | NewMediaTypes | train | func NewMediaTypes(in interface{}, context *compiler.Context) (*MediaTypes, error) {
errors := make([]error, 0)
x := &MediaTypes{}
m, ok := compiler.UnpackMap(in)
if !ok {
message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
errors = append(errors, compiler.NewError(context, message))
} else {
// repeated NamedMediaType additional_properties = 1;
// MAP: MediaType
x.AdditionalProperties = make([]*NamedMediaType, 0)
for _, item := range m {
k, ok := compiler.StringValue(item.Key)
if ok {
v := item.Value
pair := &NamedMediaType{}
pair.Name = k
var err error
pair.Value, err = NewMediaType(v, compiler.NewContext(k, context))
if err != nil {
errors = append(errors, err)
}
x.AdditionalProperties = append(x.AdditionalProperties, pair)
}
}
}
return x, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18628 | NewObject | train | func NewObject(in interface{}, context *compiler.Context) (*Object, error) {
errors := make([]error, 0)
x := &Object{}
m, ok := compiler.UnpackMap(in)
if !ok {
message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
errors = append(errors, compiler.NewError(context, message))
} else {
// repeated NamedAny additional_properties = 1;
// MAP: Any
x.AdditionalProperties = make([]*NamedAny, 0)
for _, item := range m {
k, ok := compiler.StringValue(item.Key)
if ok {
v := item.Value
pair := &NamedAny{}
pair.Name = k
result := &Any{}
handled, resultFromExt, err := compiler.HandleExtension(context, v, k)
if handled {
if err != nil {
errors = append(errors, err)
} else {
bytes, _ := yaml.Marshal(v)
result.Yaml = string(bytes)
result.Value = resultFromExt
pair.Value = result
}
} else {
pair.Value, err = NewAny(v, compiler.NewContext(k, context))
if err != nil {
errors = append(errors, err)
}
}
x.AdditionalProperties = append(x.AdditionalProperties, pair)
}
}
}
return x, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18629 | NewParameterOrReference | train | func NewParameterOrReference(in interface{}, context *compiler.Context) (*ParameterOrReference, error) {
errors := make([]error, 0)
x := &ParameterOrReference{}
matched := false
// Parameter parameter = 1;
{
m, ok := compiler.UnpackMap(in)
if ok {
// errors might be ok here, they mean we just don't have the right subtype
t, matchingError := NewParameter(m, compiler.NewContext("parameter", context))
if matchingError == nil {
x.Oneof = &ParameterOrReference_Parameter{Parameter: t}
matched = true
} else {
errors = append(errors, matchingError)
}
}
}
// Reference reference = 2;
{
m, ok := compiler.UnpackMap(in)
if ok {
// errors might be ok here, they mean we just don't have the right subtype
t, matchingError := NewReference(m, compiler.NewContext("reference", context))
if matchingError == nil {
x.Oneof = &ParameterOrReference_Reference{Reference: t}
matched = true
} else {
errors = append(errors, matchingError)
}
}
}
if matched {
// since the oneof matched one of its possibilities, discard any matching errors
errors = make([]error, 0)
}
return x, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18630 | NewParametersOrReferences | train | func NewParametersOrReferences(in interface{}, context *compiler.Context) (*ParametersOrReferences, error) {
errors := make([]error, 0)
x := &ParametersOrReferences{}
m, ok := compiler.UnpackMap(in)
if !ok {
message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
errors = append(errors, compiler.NewError(context, message))
} else {
// repeated NamedParameterOrReference additional_properties = 1;
// MAP: ParameterOrReference
x.AdditionalProperties = make([]*NamedParameterOrReference, 0)
for _, item := range m {
k, ok := compiler.StringValue(item.Key)
if ok {
v := item.Value
pair := &NamedParameterOrReference{}
pair.Name = k
var err error
pair.Value, err = NewParameterOrReference(v, compiler.NewContext(k, context))
if err != nil {
errors = append(errors, err)
}
x.AdditionalProperties = append(x.AdditionalProperties, pair)
}
}
}
return x, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18631 | NewProperties | train | func NewProperties(in interface{}, context *compiler.Context) (*Properties, error) {
errors := make([]error, 0)
x := &Properties{}
m, ok := compiler.UnpackMap(in)
if !ok {
message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
errors = append(errors, compiler.NewError(context, message))
} else {
// repeated NamedSchemaOrReference additional_properties = 1;
// MAP: SchemaOrReference
x.AdditionalProperties = make([]*NamedSchemaOrReference, 0)
for _, item := range m {
k, ok := compiler.StringValue(item.Key)
if ok {
v := item.Value
pair := &NamedSchemaOrReference{}
pair.Name = k
var err error
pair.Value, err = NewSchemaOrReference(v, compiler.NewContext(k, context))
if err != nil {
errors = append(errors, err)
}
x.AdditionalProperties = append(x.AdditionalProperties, pair)
}
}
}
return x, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18632 | NewRequestBodiesOrReferences | train | func NewRequestBodiesOrReferences(in interface{}, context *compiler.Context) (*RequestBodiesOrReferences, error) {
errors := make([]error, 0)
x := &RequestBodiesOrReferences{}
m, ok := compiler.UnpackMap(in)
if !ok {
message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
errors = append(errors, compiler.NewError(context, message))
} else {
// repeated NamedRequestBodyOrReference additional_properties = 1;
// MAP: RequestBodyOrReference
x.AdditionalProperties = make([]*NamedRequestBodyOrReference, 0)
for _, item := range m {
k, ok := compiler.StringValue(item.Key)
if ok {
v := item.Value
pair := &NamedRequestBodyOrReference{}
pair.Name = k
var err error
pair.Value, err = NewRequestBodyOrReference(v, compiler.NewContext(k, context))
if err != nil {
errors = append(errors, err)
}
x.AdditionalProperties = append(x.AdditionalProperties, pair)
}
}
}
return x, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18633 | NewRequestBodyOrReference | train | func NewRequestBodyOrReference(in interface{}, context *compiler.Context) (*RequestBodyOrReference, error) {
errors := make([]error, 0)
x := &RequestBodyOrReference{}
matched := false
// RequestBody request_body = 1;
{
m, ok := compiler.UnpackMap(in)
if ok {
// errors might be ok here, they mean we just don't have the right subtype
t, matchingError := NewRequestBody(m, compiler.NewContext("requestBody", context))
if matchingError == nil {
x.Oneof = &RequestBodyOrReference_RequestBody{RequestBody: t}
matched = true
} else {
errors = append(errors, matchingError)
}
}
}
// Reference reference = 2;
{
m, ok := compiler.UnpackMap(in)
if ok {
// errors might be ok here, they mean we just don't have the right subtype
t, matchingError := NewReference(m, compiler.NewContext("reference", context))
if matchingError == nil {
x.Oneof = &RequestBodyOrReference_Reference{Reference: t}
matched = true
} else {
errors = append(errors, matchingError)
}
}
}
if matched {
// since the oneof matched one of its possibilities, discard any matching errors
errors = make([]error, 0)
}
return x, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18634 | NewResponseOrReference | train | func NewResponseOrReference(in interface{}, context *compiler.Context) (*ResponseOrReference, error) {
errors := make([]error, 0)
x := &ResponseOrReference{}
matched := false
// Response response = 1;
{
m, ok := compiler.UnpackMap(in)
if ok {
// errors might be ok here, they mean we just don't have the right subtype
t, matchingError := NewResponse(m, compiler.NewContext("response", context))
if matchingError == nil {
x.Oneof = &ResponseOrReference_Response{Response: t}
matched = true
} else {
errors = append(errors, matchingError)
}
}
}
// Reference reference = 2;
{
m, ok := compiler.UnpackMap(in)
if ok {
// errors might be ok here, they mean we just don't have the right subtype
t, matchingError := NewReference(m, compiler.NewContext("reference", context))
if matchingError == nil {
x.Oneof = &ResponseOrReference_Reference{Reference: t}
matched = true
} else {
errors = append(errors, matchingError)
}
}
}
if matched {
// since the oneof matched one of its possibilities, discard any matching errors
errors = make([]error, 0)
}
return x, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18635 | NewResponsesOrReferences | train | func NewResponsesOrReferences(in interface{}, context *compiler.Context) (*ResponsesOrReferences, error) {
errors := make([]error, 0)
x := &ResponsesOrReferences{}
m, ok := compiler.UnpackMap(in)
if !ok {
message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
errors = append(errors, compiler.NewError(context, message))
} else {
// repeated NamedResponseOrReference additional_properties = 1;
// MAP: ResponseOrReference
x.AdditionalProperties = make([]*NamedResponseOrReference, 0)
for _, item := range m {
k, ok := compiler.StringValue(item.Key)
if ok {
v := item.Value
pair := &NamedResponseOrReference{}
pair.Name = k
var err error
pair.Value, err = NewResponseOrReference(v, compiler.NewContext(k, context))
if err != nil {
errors = append(errors, err)
}
x.AdditionalProperties = append(x.AdditionalProperties, pair)
}
}
}
return x, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18636 | NewSchemaOrReference | train | func NewSchemaOrReference(in interface{}, context *compiler.Context) (*SchemaOrReference, error) {
errors := make([]error, 0)
x := &SchemaOrReference{}
matched := false
// Schema schema = 1;
{
m, ok := compiler.UnpackMap(in)
if ok {
// errors might be ok here, they mean we just don't have the right subtype
t, matchingError := NewSchema(m, compiler.NewContext("schema", context))
if matchingError == nil {
x.Oneof = &SchemaOrReference_Schema{Schema: t}
matched = true
} else {
errors = append(errors, matchingError)
}
}
}
// Reference reference = 2;
{
m, ok := compiler.UnpackMap(in)
if ok {
// errors might be ok here, they mean we just don't have the right subtype
t, matchingError := NewReference(m, compiler.NewContext("reference", context))
if matchingError == nil {
x.Oneof = &SchemaOrReference_Reference{Reference: t}
matched = true
} else {
errors = append(errors, matchingError)
}
}
}
if matched {
// since the oneof matched one of its possibilities, discard any matching errors
errors = make([]error, 0)
}
return x, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18637 | NewSecuritySchemeOrReference | train | func NewSecuritySchemeOrReference(in interface{}, context *compiler.Context) (*SecuritySchemeOrReference, error) {
errors := make([]error, 0)
x := &SecuritySchemeOrReference{}
matched := false
// SecurityScheme security_scheme = 1;
{
m, ok := compiler.UnpackMap(in)
if ok {
// errors might be ok here, they mean we just don't have the right subtype
t, matchingError := NewSecurityScheme(m, compiler.NewContext("securityScheme", context))
if matchingError == nil {
x.Oneof = &SecuritySchemeOrReference_SecurityScheme{SecurityScheme: t}
matched = true
} else {
errors = append(errors, matchingError)
}
}
}
// Reference reference = 2;
{
m, ok := compiler.UnpackMap(in)
if ok {
// errors might be ok here, they mean we just don't have the right subtype
t, matchingError := NewReference(m, compiler.NewContext("reference", context))
if matchingError == nil {
x.Oneof = &SecuritySchemeOrReference_Reference{Reference: t}
matched = true
} else {
errors = append(errors, matchingError)
}
}
}
if matched {
// since the oneof matched one of its possibilities, discard any matching errors
errors = make([]error, 0)
}
return x, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18638 | NewSecuritySchemesOrReferences | train | func NewSecuritySchemesOrReferences(in interface{}, context *compiler.Context) (*SecuritySchemesOrReferences, error) {
errors := make([]error, 0)
x := &SecuritySchemesOrReferences{}
m, ok := compiler.UnpackMap(in)
if !ok {
message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
errors = append(errors, compiler.NewError(context, message))
} else {
// repeated NamedSecuritySchemeOrReference additional_properties = 1;
// MAP: SecuritySchemeOrReference
x.AdditionalProperties = make([]*NamedSecuritySchemeOrReference, 0)
for _, item := range m {
k, ok := compiler.StringValue(item.Key)
if ok {
v := item.Value
pair := &NamedSecuritySchemeOrReference{}
pair.Name = k
var err error
pair.Value, err = NewSecuritySchemeOrReference(v, compiler.NewContext(k, context))
if err != nil {
errors = append(errors, err)
}
x.AdditionalProperties = append(x.AdditionalProperties, pair)
}
}
}
return x, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18639 | NewServerVariables | train | func NewServerVariables(in interface{}, context *compiler.Context) (*ServerVariables, error) {
errors := make([]error, 0)
x := &ServerVariables{}
m, ok := compiler.UnpackMap(in)
if !ok {
message := fmt.Sprintf("has unexpected value: %+v (%T)", in, in)
errors = append(errors, compiler.NewError(context, message))
} else {
// repeated NamedServerVariable additional_properties = 1;
// MAP: ServerVariable
x.AdditionalProperties = make([]*NamedServerVariable, 0)
for _, item := range m {
k, ok := compiler.StringValue(item.Key)
if ok {
v := item.Value
pair := &NamedServerVariable{}
pair.Name = k
var err error
pair.Value, err = NewServerVariable(v, compiler.NewContext(k, context))
if err != nil {
errors = append(errors, err)
}
x.AdditionalProperties = append(x.AdditionalProperties, pair)
}
}
}
return x, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18640 | NewSpecificationExtension | train | func NewSpecificationExtension(in interface{}, context *compiler.Context) (*SpecificationExtension, error) {
errors := make([]error, 0)
x := &SpecificationExtension{}
matched := false
switch in := in.(type) {
case bool:
x.Oneof = &SpecificationExtension_Boolean{Boolean: in}
matched = true
case string:
x.Oneof = &SpecificationExtension_String_{String_: in}
matched = true
case int64:
x.Oneof = &SpecificationExtension_Number{Number: float64(in)}
matched = true
case int32:
x.Oneof = &SpecificationExtension_Number{Number: float64(in)}
matched = true
case int:
x.Oneof = &SpecificationExtension_Number{Number: float64(in)}
matched = true
case float64:
x.Oneof = &SpecificationExtension_Number{Number: in}
matched = true
case float32:
x.Oneof = &SpecificationExtension_Number{Number: float64(in)}
matched = true
}
if matched {
// since the oneof matched one of its possibilities, discard any matching errors
errors = make([]error, 0)
}
return x, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18641 | ResolveReferences | train | func (m *AdditionalPropertiesItem) ResolveReferences(root string) (interface{}, error) {
errors := make([]error, 0)
{
p, ok := m.Oneof.(*AdditionalPropertiesItem_SchemaOrReference)
if ok {
_, err := p.SchemaOrReference.ResolveReferences(root)
if err != nil {
return nil, err
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18642 | ResolveReferences | train | func (m *AnyOrExpression) ResolveReferences(root string) (interface{}, error) {
errors := make([]error, 0)
{
p, ok := m.Oneof.(*AnyOrExpression_Any)
if ok {
_, err := p.Any.ResolveReferences(root)
if err != nil {
return nil, err
}
}
}
{
p, ok := m.Oneof.(*AnyOrExpression_Expression)
if ok {
_, err := p.Expression.ResolveReferences(root)
if err != nil {
return nil, err
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18643 | ResolveReferences | train | func (m *CallbackOrReference) ResolveReferences(root string) (interface{}, error) {
errors := make([]error, 0)
{
p, ok := m.Oneof.(*CallbackOrReference_Callback)
if ok {
_, err := p.Callback.ResolveReferences(root)
if err != nil {
return nil, err
}
}
}
{
p, ok := m.Oneof.(*CallbackOrReference_Reference)
if ok {
_, err := p.Reference.ResolveReferences(root)
if err != nil {
return nil, err
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18644 | ResolveReferences | train | func (m *Components) ResolveReferences(root string) (interface{}, error) {
errors := make([]error, 0)
if m.Schemas != nil {
_, err := m.Schemas.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.Responses != nil {
_, err := m.Responses.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.Parameters != nil {
_, err := m.Parameters.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.Examples != nil {
_, err := m.Examples.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.RequestBodies != nil {
_, err := m.RequestBodies.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.Headers != nil {
_, err := m.Headers.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.SecuritySchemes != nil {
_, err := m.SecuritySchemes.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.Links != nil {
_, err := m.Links.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.Callbacks != nil {
_, err := m.Callbacks.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
for _, item := range m.SpecificationExtension {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18645 | ResolveReferences | train | func (m *Discriminator) ResolveReferences(root string) (interface{}, error) {
errors := make([]error, 0)
if m.Mapping != nil {
_, err := m.Mapping.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18646 | ResolveReferences | train | func (m *Encoding) ResolveReferences(root string) (interface{}, error) {
errors := make([]error, 0)
if m.Headers != nil {
_, err := m.Headers.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
for _, item := range m.SpecificationExtension {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18647 | ResolveReferences | train | func (m *Example) ResolveReferences(root string) (interface{}, error) {
errors := make([]error, 0)
if m.Value != nil {
_, err := m.Value.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
for _, item := range m.SpecificationExtension {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18648 | ResolveReferences | train | func (m *ExampleOrReference) ResolveReferences(root string) (interface{}, error) {
errors := make([]error, 0)
{
p, ok := m.Oneof.(*ExampleOrReference_Example)
if ok {
_, err := p.Example.ResolveReferences(root)
if err != nil {
return nil, err
}
}
}
{
p, ok := m.Oneof.(*ExampleOrReference_Reference)
if ok {
_, err := p.Reference.ResolveReferences(root)
if err != nil {
return nil, err
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18649 | ResolveReferences | train | func (m *HeaderOrReference) ResolveReferences(root string) (interface{}, error) {
errors := make([]error, 0)
{
p, ok := m.Oneof.(*HeaderOrReference_Header)
if ok {
_, err := p.Header.ResolveReferences(root)
if err != nil {
return nil, err
}
}
}
{
p, ok := m.Oneof.(*HeaderOrReference_Reference)
if ok {
_, err := p.Reference.ResolveReferences(root)
if err != nil {
return nil, err
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18650 | ResolveReferences | train | func (m *Link) ResolveReferences(root string) (interface{}, error) {
errors := make([]error, 0)
if m.Parameters != nil {
_, err := m.Parameters.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.RequestBody != nil {
_, err := m.RequestBody.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.Server != nil {
_, err := m.Server.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
for _, item := range m.SpecificationExtension {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18651 | ResolveReferences | train | func (m *LinkOrReference) ResolveReferences(root string) (interface{}, error) {
errors := make([]error, 0)
{
p, ok := m.Oneof.(*LinkOrReference_Link)
if ok {
_, err := p.Link.ResolveReferences(root)
if err != nil {
return nil, err
}
}
}
{
p, ok := m.Oneof.(*LinkOrReference_Reference)
if ok {
_, err := p.Reference.ResolveReferences(root)
if err != nil {
return nil, err
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18652 | ResolveReferences | train | func (m *OauthFlow) ResolveReferences(root string) (interface{}, error) {
errors := make([]error, 0)
if m.Scopes != nil {
_, err := m.Scopes.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
for _, item := range m.SpecificationExtension {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18653 | ResolveReferences | train | func (m *OauthFlows) ResolveReferences(root string) (interface{}, error) {
errors := make([]error, 0)
if m.Implicit != nil {
_, err := m.Implicit.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.Password != nil {
_, err := m.Password.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.ClientCredentials != nil {
_, err := m.ClientCredentials.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.AuthorizationCode != nil {
_, err := m.AuthorizationCode.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
for _, item := range m.SpecificationExtension {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18654 | ResolveReferences | train | func (m *ParameterOrReference) ResolveReferences(root string) (interface{}, error) {
errors := make([]error, 0)
{
p, ok := m.Oneof.(*ParameterOrReference_Parameter)
if ok {
_, err := p.Parameter.ResolveReferences(root)
if err != nil {
return nil, err
}
}
}
{
p, ok := m.Oneof.(*ParameterOrReference_Reference)
if ok {
_, err := p.Reference.ResolveReferences(root)
if err != nil {
return nil, err
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18655 | ResolveReferences | train | func (m *Reference) ResolveReferences(root string) (interface{}, error) {
errors := make([]error, 0)
if m.XRef != "" {
info, err := compiler.ReadInfoForRef(root, m.XRef)
if err != nil {
return nil, err
}
return info, nil
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18656 | ResolveReferences | train | func (m *RequestBody) ResolveReferences(root string) (interface{}, error) {
errors := make([]error, 0)
if m.Content != nil {
_, err := m.Content.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
for _, item := range m.SpecificationExtension {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18657 | ResolveReferences | train | func (m *RequestBodyOrReference) ResolveReferences(root string) (interface{}, error) {
errors := make([]error, 0)
{
p, ok := m.Oneof.(*RequestBodyOrReference_RequestBody)
if ok {
_, err := p.RequestBody.ResolveReferences(root)
if err != nil {
return nil, err
}
}
}
{
p, ok := m.Oneof.(*RequestBodyOrReference_Reference)
if ok {
_, err := p.Reference.ResolveReferences(root)
if err != nil {
return nil, err
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18658 | ResolveReferences | train | func (m *ResponseOrReference) ResolveReferences(root string) (interface{}, error) {
errors := make([]error, 0)
{
p, ok := m.Oneof.(*ResponseOrReference_Response)
if ok {
_, err := p.Response.ResolveReferences(root)
if err != nil {
return nil, err
}
}
}
{
p, ok := m.Oneof.(*ResponseOrReference_Reference)
if ok {
_, err := p.Reference.ResolveReferences(root)
if err != nil {
return nil, err
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18659 | ResolveReferences | train | func (m *SchemaOrReference) ResolveReferences(root string) (interface{}, error) {
errors := make([]error, 0)
{
p, ok := m.Oneof.(*SchemaOrReference_Schema)
if ok {
_, err := p.Schema.ResolveReferences(root)
if err != nil {
return nil, err
}
}
}
{
p, ok := m.Oneof.(*SchemaOrReference_Reference)
if ok {
_, err := p.Reference.ResolveReferences(root)
if err != nil {
return nil, err
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18660 | ResolveReferences | train | func (m *SecurityRequirement) ResolveReferences(root string) (interface{}, error) {
errors := make([]error, 0)
return nil, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18661 | ResolveReferences | train | func (m *SecurityScheme) ResolveReferences(root string) (interface{}, error) {
errors := make([]error, 0)
if m.Flows != nil {
_, err := m.Flows.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
for _, item := range m.SpecificationExtension {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18662 | ResolveReferences | train | func (m *SecuritySchemeOrReference) ResolveReferences(root string) (interface{}, error) {
errors := make([]error, 0)
{
p, ok := m.Oneof.(*SecuritySchemeOrReference_SecurityScheme)
if ok {
_, err := p.SecurityScheme.ResolveReferences(root)
if err != nil {
return nil, err
}
}
}
{
p, ok := m.Oneof.(*SecuritySchemeOrReference_Reference)
if ok {
_, err := p.Reference.ResolveReferences(root)
if err != nil {
return nil, err
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18663 | ResolveReferences | train | func (m *Server) ResolveReferences(root string) (interface{}, error) {
errors := make([]error, 0)
if m.Variables != nil {
_, err := m.Variables.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
for _, item := range m.SpecificationExtension {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18664 | ResolveReferences | train | func (m *Tag) ResolveReferences(root string) (interface{}, error) {
errors := make([]error, 0)
if m.ExternalDocs != nil {
_, err := m.ExternalDocs.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
for _, item := range m.SpecificationExtension {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | go | {
"resource": ""
} |
q18665 | ToRawInfo | train | func (m *AnyOrExpression) ToRawInfo() interface{} {
// ONE OF WRAPPER
// AnyOrExpression
// {Name:any Type:Any StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
v0 := m.GetAny()
if v0 != nil {
return v0.ToRawInfo()
}
// {Name:expression Type:Expression StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
v1 := m.GetExpression()
if v1 != nil {
return v1.ToRawInfo()
}
return nil
} | go | {
"resource": ""
} |
q18666 | ToRawInfo | train | func (m *Callback) ToRawInfo() interface{} {
info := yaml.MapSlice{}
if m == nil {
return info
}
if m.Path != nil {
for _, item := range m.Path {
info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
}
}
// &{Name:Path Type:NamedPathItem StringEnumValues:[] MapType:PathItem Repeated:true Pattern:^ Implicit:true Description:}
if m.SpecificationExtension != nil {
for _, item := range m.SpecificationExtension {
info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
}
}
// &{Name:SpecificationExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
return info
} | go | {
"resource": ""
} |
q18667 | ToRawInfo | train | func (m *CallbackOrReference) ToRawInfo() interface{} {
// ONE OF WRAPPER
// CallbackOrReference
// {Name:callback Type:Callback StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
v0 := m.GetCallback()
if v0 != nil {
return v0.ToRawInfo()
}
// {Name:reference Type:Reference StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
v1 := m.GetReference()
if v1 != nil {
return v1.ToRawInfo()
}
return nil
} | go | {
"resource": ""
} |
q18668 | ToRawInfo | train | func (m *Components) ToRawInfo() interface{} {
info := yaml.MapSlice{}
if m == nil {
return info
}
if m.Schemas != nil {
info = append(info, yaml.MapItem{Key: "schemas", Value: m.Schemas.ToRawInfo()})
}
// &{Name:schemas Type:SchemasOrReferences StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.Responses != nil {
info = append(info, yaml.MapItem{Key: "responses", Value: m.Responses.ToRawInfo()})
}
// &{Name:responses Type:ResponsesOrReferences StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.Parameters != nil {
info = append(info, yaml.MapItem{Key: "parameters", Value: m.Parameters.ToRawInfo()})
}
// &{Name:parameters Type:ParametersOrReferences StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.Examples != nil {
info = append(info, yaml.MapItem{Key: "examples", Value: m.Examples.ToRawInfo()})
}
// &{Name:examples Type:ExamplesOrReferences StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.RequestBodies != nil {
info = append(info, yaml.MapItem{Key: "requestBodies", Value: m.RequestBodies.ToRawInfo()})
}
// &{Name:requestBodies Type:RequestBodiesOrReferences StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.Headers != nil {
info = append(info, yaml.MapItem{Key: "headers", Value: m.Headers.ToRawInfo()})
}
// &{Name:headers Type:HeadersOrReferences StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.SecuritySchemes != nil {
info = append(info, yaml.MapItem{Key: "securitySchemes", Value: m.SecuritySchemes.ToRawInfo()})
}
// &{Name:securitySchemes Type:SecuritySchemesOrReferences StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.Links != nil {
info = append(info, yaml.MapItem{Key: "links", Value: m.Links.ToRawInfo()})
}
// &{Name:links Type:LinksOrReferences StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.Callbacks != nil {
info = append(info, yaml.MapItem{Key: "callbacks", Value: m.Callbacks.ToRawInfo()})
}
// &{Name:callbacks Type:CallbacksOrReferences StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.SpecificationExtension != nil {
for _, item := range m.SpecificationExtension {
info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
}
}
// &{Name:SpecificationExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
return info
} | go | {
"resource": ""
} |
q18669 | ToRawInfo | train | func (m *DefaultType) ToRawInfo() interface{} {
// ONE OF WRAPPER
// DefaultType
// {Name:number Type:float StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if v0, ok := m.GetOneof().(*DefaultType_Number); ok {
return v0.Number
}
// {Name:boolean Type:bool StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if v1, ok := m.GetOneof().(*DefaultType_Boolean); ok {
return v1.Boolean
}
// {Name:string Type:string StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if v2, ok := m.GetOneof().(*DefaultType_String_); ok {
return v2.String_
}
return nil
} | go | {
"resource": ""
} |
q18670 | ToRawInfo | train | func (m *Discriminator) ToRawInfo() interface{} {
info := yaml.MapSlice{}
if m == nil {
return info
}
// always include this required field.
info = append(info, yaml.MapItem{Key: "propertyName", Value: m.PropertyName})
if m.Mapping != nil {
info = append(info, yaml.MapItem{Key: "mapping", Value: m.Mapping.ToRawInfo()})
}
// &{Name:mapping Type:Strings StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
return info
} | go | {
"resource": ""
} |
q18671 | ToRawInfo | train | func (m *Encoding) ToRawInfo() interface{} {
info := yaml.MapSlice{}
if m == nil {
return info
}
if m.ContentType != "" {
info = append(info, yaml.MapItem{Key: "contentType", Value: m.ContentType})
}
if m.Headers != nil {
info = append(info, yaml.MapItem{Key: "headers", Value: m.Headers.ToRawInfo()})
}
// &{Name:headers Type:HeadersOrReferences StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.Style != "" {
info = append(info, yaml.MapItem{Key: "style", Value: m.Style})
}
if m.Explode != false {
info = append(info, yaml.MapItem{Key: "explode", Value: m.Explode})
}
if m.AllowReserved != false {
info = append(info, yaml.MapItem{Key: "allowReserved", Value: m.AllowReserved})
}
if m.SpecificationExtension != nil {
for _, item := range m.SpecificationExtension {
info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
}
}
// &{Name:SpecificationExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
return info
} | go | {
"resource": ""
} |
q18672 | ToRawInfo | train | func (m *Example) ToRawInfo() interface{} {
info := yaml.MapSlice{}
if m == nil {
return info
}
if m.Summary != "" {
info = append(info, yaml.MapItem{Key: "summary", Value: m.Summary})
}
if m.Description != "" {
info = append(info, yaml.MapItem{Key: "description", Value: m.Description})
}
// &{Name:value Type:Any StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.ExternalValue != "" {
info = append(info, yaml.MapItem{Key: "externalValue", Value: m.ExternalValue})
}
if m.SpecificationExtension != nil {
for _, item := range m.SpecificationExtension {
info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
}
}
// &{Name:SpecificationExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
return info
} | go | {
"resource": ""
} |
q18673 | ToRawInfo | train | func (m *ExampleOrReference) ToRawInfo() interface{} {
// ONE OF WRAPPER
// ExampleOrReference
// {Name:example Type:Example StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
v0 := m.GetExample()
if v0 != nil {
return v0.ToRawInfo()
}
// {Name:reference Type:Reference StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
v1 := m.GetReference()
if v1 != nil {
return v1.ToRawInfo()
}
return nil
} | go | {
"resource": ""
} |
q18674 | ToRawInfo | train | func (m *Header) ToRawInfo() interface{} {
info := yaml.MapSlice{}
if m == nil {
return info
}
if m.Description != "" {
info = append(info, yaml.MapItem{Key: "description", Value: m.Description})
}
if m.Required != false {
info = append(info, yaml.MapItem{Key: "required", Value: m.Required})
}
if m.Deprecated != false {
info = append(info, yaml.MapItem{Key: "deprecated", Value: m.Deprecated})
}
if m.AllowEmptyValue != false {
info = append(info, yaml.MapItem{Key: "allowEmptyValue", Value: m.AllowEmptyValue})
}
if m.Style != "" {
info = append(info, yaml.MapItem{Key: "style", Value: m.Style})
}
if m.Explode != false {
info = append(info, yaml.MapItem{Key: "explode", Value: m.Explode})
}
if m.AllowReserved != false {
info = append(info, yaml.MapItem{Key: "allowReserved", Value: m.AllowReserved})
}
if m.Schema != nil {
info = append(info, yaml.MapItem{Key: "schema", Value: m.Schema.ToRawInfo()})
}
// &{Name:schema Type:SchemaOrReference StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.Example != nil {
info = append(info, yaml.MapItem{Key: "example", Value: m.Example.ToRawInfo()})
}
// &{Name:example Type:Any StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.Examples != nil {
info = append(info, yaml.MapItem{Key: "examples", Value: m.Examples.ToRawInfo()})
}
// &{Name:examples Type:ExamplesOrReferences StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.Content != nil {
info = append(info, yaml.MapItem{Key: "content", Value: m.Content.ToRawInfo()})
}
// &{Name:content Type:MediaTypes StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.SpecificationExtension != nil {
for _, item := range m.SpecificationExtension {
info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
}
}
// &{Name:SpecificationExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
return info
} | go | {
"resource": ""
} |
q18675 | ToRawInfo | train | func (m *HeaderOrReference) ToRawInfo() interface{} {
// ONE OF WRAPPER
// HeaderOrReference
// {Name:header Type:Header StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
v0 := m.GetHeader()
if v0 != nil {
return v0.ToRawInfo()
}
// {Name:reference Type:Reference StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
v1 := m.GetReference()
if v1 != nil {
return v1.ToRawInfo()
}
return nil
} | go | {
"resource": ""
} |
q18676 | ToRawInfo | train | func (m *Link) ToRawInfo() interface{} {
info := yaml.MapSlice{}
if m == nil {
return info
}
if m.OperationRef != "" {
info = append(info, yaml.MapItem{Key: "operationRef", Value: m.OperationRef})
}
if m.OperationId != "" {
info = append(info, yaml.MapItem{Key: "operationId", Value: m.OperationId})
}
if m.Parameters != nil {
info = append(info, yaml.MapItem{Key: "parameters", Value: m.Parameters.ToRawInfo()})
}
// &{Name:parameters Type:AnysOrExpressions StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.RequestBody != nil {
info = append(info, yaml.MapItem{Key: "requestBody", Value: m.RequestBody.ToRawInfo()})
}
// &{Name:requestBody Type:AnyOrExpression StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.Description != "" {
info = append(info, yaml.MapItem{Key: "description", Value: m.Description})
}
if m.Server != nil {
info = append(info, yaml.MapItem{Key: "server", Value: m.Server.ToRawInfo()})
}
// &{Name:server Type:Server StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.SpecificationExtension != nil {
for _, item := range m.SpecificationExtension {
info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
}
}
// &{Name:SpecificationExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
return info
} | go | {
"resource": ""
} |
q18677 | ToRawInfo | train | func (m *LinkOrReference) ToRawInfo() interface{} {
// ONE OF WRAPPER
// LinkOrReference
// {Name:link Type:Link StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
v0 := m.GetLink()
if v0 != nil {
return v0.ToRawInfo()
}
// {Name:reference Type:Reference StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
v1 := m.GetReference()
if v1 != nil {
return v1.ToRawInfo()
}
return nil
} | go | {
"resource": ""
} |
q18678 | ToRawInfo | train | func (m *MediaType) ToRawInfo() interface{} {
info := yaml.MapSlice{}
if m == nil {
return info
}
if m.Schema != nil {
info = append(info, yaml.MapItem{Key: "schema", Value: m.Schema.ToRawInfo()})
}
// &{Name:schema Type:SchemaOrReference StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.Example != nil {
info = append(info, yaml.MapItem{Key: "example", Value: m.Example.ToRawInfo()})
}
// &{Name:example Type:Any StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.Examples != nil {
info = append(info, yaml.MapItem{Key: "examples", Value: m.Examples.ToRawInfo()})
}
// &{Name:examples Type:ExamplesOrReferences StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.Encoding != nil {
info = append(info, yaml.MapItem{Key: "encoding", Value: m.Encoding.ToRawInfo()})
}
// &{Name:encoding Type:Encodings StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.SpecificationExtension != nil {
for _, item := range m.SpecificationExtension {
info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
}
}
// &{Name:SpecificationExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
return info
} | go | {
"resource": ""
} |
q18679 | ToRawInfo | train | func (m *NamedString) ToRawInfo() interface{} {
info := yaml.MapSlice{}
if m == nil {
return info
}
if m.Name != "" {
info = append(info, yaml.MapItem{Key: "name", Value: m.Name})
}
if m.Value != "" {
info = append(info, yaml.MapItem{Key: "value", Value: m.Value})
}
return info
} | go | {
"resource": ""
} |
q18680 | ToRawInfo | train | func (m *OauthFlow) ToRawInfo() interface{} {
info := yaml.MapSlice{}
if m == nil {
return info
}
if m.AuthorizationUrl != "" {
info = append(info, yaml.MapItem{Key: "authorizationUrl", Value: m.AuthorizationUrl})
}
if m.TokenUrl != "" {
info = append(info, yaml.MapItem{Key: "tokenUrl", Value: m.TokenUrl})
}
if m.RefreshUrl != "" {
info = append(info, yaml.MapItem{Key: "refreshUrl", Value: m.RefreshUrl})
}
if m.Scopes != nil {
info = append(info, yaml.MapItem{Key: "scopes", Value: m.Scopes.ToRawInfo()})
}
// &{Name:scopes Type:Strings StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.SpecificationExtension != nil {
for _, item := range m.SpecificationExtension {
info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
}
}
// &{Name:SpecificationExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
return info
} | go | {
"resource": ""
} |
q18681 | ToRawInfo | train | func (m *OauthFlows) ToRawInfo() interface{} {
info := yaml.MapSlice{}
if m == nil {
return info
}
if m.Implicit != nil {
info = append(info, yaml.MapItem{Key: "implicit", Value: m.Implicit.ToRawInfo()})
}
// &{Name:implicit Type:OauthFlow StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.Password != nil {
info = append(info, yaml.MapItem{Key: "password", Value: m.Password.ToRawInfo()})
}
// &{Name:password Type:OauthFlow StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.ClientCredentials != nil {
info = append(info, yaml.MapItem{Key: "clientCredentials", Value: m.ClientCredentials.ToRawInfo()})
}
// &{Name:clientCredentials Type:OauthFlow StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.AuthorizationCode != nil {
info = append(info, yaml.MapItem{Key: "authorizationCode", Value: m.AuthorizationCode.ToRawInfo()})
}
// &{Name:authorizationCode Type:OauthFlow StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.SpecificationExtension != nil {
for _, item := range m.SpecificationExtension {
info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
}
}
// &{Name:SpecificationExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
return info
} | go | {
"resource": ""
} |
q18682 | ToRawInfo | train | func (m *ParameterOrReference) ToRawInfo() interface{} {
// ONE OF WRAPPER
// ParameterOrReference
// {Name:parameter Type:Parameter StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
v0 := m.GetParameter()
if v0 != nil {
return v0.ToRawInfo()
}
// {Name:reference Type:Reference StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
v1 := m.GetReference()
if v1 != nil {
return v1.ToRawInfo()
}
return nil
} | go | {
"resource": ""
} |
q18683 | ToRawInfo | train | func (m *ParametersOrReferences) ToRawInfo() interface{} {
info := yaml.MapSlice{}
if m == nil {
return info
}
if m.AdditionalProperties != nil {
for _, item := range m.AdditionalProperties {
info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
}
}
// &{Name:additionalProperties Type:NamedParameterOrReference StringEnumValues:[] MapType:ParameterOrReference Repeated:true Pattern: Implicit:true Description:}
return info
} | go | {
"resource": ""
} |
q18684 | ToRawInfo | train | func (m *Reference) ToRawInfo() interface{} {
info := yaml.MapSlice{}
if m == nil {
return info
}
// always include this required field.
info = append(info, yaml.MapItem{Key: "$ref", Value: m.XRef})
return info
} | go | {
"resource": ""
} |
q18685 | ToRawInfo | train | func (m *RequestBody) ToRawInfo() interface{} {
info := yaml.MapSlice{}
if m == nil {
return info
}
if m.Description != "" {
info = append(info, yaml.MapItem{Key: "description", Value: m.Description})
}
// always include this required field.
info = append(info, yaml.MapItem{Key: "content", Value: m.Content.ToRawInfo()})
// &{Name:content Type:MediaTypes StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.Required != false {
info = append(info, yaml.MapItem{Key: "required", Value: m.Required})
}
if m.SpecificationExtension != nil {
for _, item := range m.SpecificationExtension {
info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
}
}
// &{Name:SpecificationExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
return info
} | go | {
"resource": ""
} |
q18686 | ToRawInfo | train | func (m *RequestBodyOrReference) ToRawInfo() interface{} {
// ONE OF WRAPPER
// RequestBodyOrReference
// {Name:requestBody Type:RequestBody StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
v0 := m.GetRequestBody()
if v0 != nil {
return v0.ToRawInfo()
}
// {Name:reference Type:Reference StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
v1 := m.GetReference()
if v1 != nil {
return v1.ToRawInfo()
}
return nil
} | go | {
"resource": ""
} |
q18687 | ToRawInfo | train | func (m *ResponseOrReference) ToRawInfo() interface{} {
// ONE OF WRAPPER
// ResponseOrReference
// {Name:response Type:Response StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
v0 := m.GetResponse()
if v0 != nil {
return v0.ToRawInfo()
}
// {Name:reference Type:Reference StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
v1 := m.GetReference()
if v1 != nil {
return v1.ToRawInfo()
}
return nil
} | go | {
"resource": ""
} |
q18688 | ToRawInfo | train | func (m *SchemaOrReference) ToRawInfo() interface{} {
// ONE OF WRAPPER
// SchemaOrReference
// {Name:schema Type:Schema StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
v0 := m.GetSchema()
if v0 != nil {
return v0.ToRawInfo()
}
// {Name:reference Type:Reference StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
v1 := m.GetReference()
if v1 != nil {
return v1.ToRawInfo()
}
return nil
} | go | {
"resource": ""
} |
q18689 | ToRawInfo | train | func (m *SecurityRequirement) ToRawInfo() interface{} {
info := yaml.MapSlice{}
if m == nil {
return info
}
return info
} | go | {
"resource": ""
} |
q18690 | ToRawInfo | train | func (m *SecurityScheme) ToRawInfo() interface{} {
info := yaml.MapSlice{}
if m == nil {
return info
}
// always include this required field.
info = append(info, yaml.MapItem{Key: "type", Value: m.Type})
if m.Description != "" {
info = append(info, yaml.MapItem{Key: "description", Value: m.Description})
}
if m.Name != "" {
info = append(info, yaml.MapItem{Key: "name", Value: m.Name})
}
if m.In != "" {
info = append(info, yaml.MapItem{Key: "in", Value: m.In})
}
if m.Scheme != "" {
info = append(info, yaml.MapItem{Key: "scheme", Value: m.Scheme})
}
if m.BearerFormat != "" {
info = append(info, yaml.MapItem{Key: "bearerFormat", Value: m.BearerFormat})
}
if m.Flows != nil {
info = append(info, yaml.MapItem{Key: "flows", Value: m.Flows.ToRawInfo()})
}
// &{Name:flows Type:OauthFlows StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if m.OpenIdConnectUrl != "" {
info = append(info, yaml.MapItem{Key: "openIdConnectUrl", Value: m.OpenIdConnectUrl})
}
if m.SpecificationExtension != nil {
for _, item := range m.SpecificationExtension {
info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
}
}
// &{Name:SpecificationExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
return info
} | go | {
"resource": ""
} |
q18691 | ToRawInfo | train | func (m *SecuritySchemeOrReference) ToRawInfo() interface{} {
// ONE OF WRAPPER
// SecuritySchemeOrReference
// {Name:securityScheme Type:SecurityScheme StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
v0 := m.GetSecurityScheme()
if v0 != nil {
return v0.ToRawInfo()
}
// {Name:reference Type:Reference StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
v1 := m.GetReference()
if v1 != nil {
return v1.ToRawInfo()
}
return nil
} | go | {
"resource": ""
} |
q18692 | ToRawInfo | train | func (m *ServerVariable) ToRawInfo() interface{} {
info := yaml.MapSlice{}
if m == nil {
return info
}
if len(m.Enum) != 0 {
info = append(info, yaml.MapItem{Key: "enum", Value: m.Enum})
}
// always include this required field.
info = append(info, yaml.MapItem{Key: "default", Value: m.Default})
if m.Description != "" {
info = append(info, yaml.MapItem{Key: "description", Value: m.Description})
}
if m.SpecificationExtension != nil {
for _, item := range m.SpecificationExtension {
info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
}
}
// &{Name:SpecificationExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
return info
} | go | {
"resource": ""
} |
q18693 | ToRawInfo | train | func (m *SpecificationExtension) ToRawInfo() interface{} {
// ONE OF WRAPPER
// SpecificationExtension
// {Name:number Type:float StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if v0, ok := m.GetOneof().(*SpecificationExtension_Number); ok {
return v0.Number
}
// {Name:boolean Type:bool StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if v1, ok := m.GetOneof().(*SpecificationExtension_Boolean); ok {
return v1.Boolean
}
// {Name:string Type:string StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if v2, ok := m.GetOneof().(*SpecificationExtension_String_); ok {
return v2.String_
}
return nil
} | go | {
"resource": ""
} |
q18694 | ToRawInfo | train | func (m *Strings) ToRawInfo() interface{} {
info := yaml.MapSlice{}
if m == nil {
return info
}
// &{Name:additionalProperties Type:NamedString StringEnumValues:[] MapType:string Repeated:true Pattern: Implicit:true Description:}
return info
} | go | {
"resource": ""
} |
q18695 | ToRawInfo | train | func (m *Xml) ToRawInfo() interface{} {
info := yaml.MapSlice{}
if m == nil {
return info
}
if m.Name != "" {
info = append(info, yaml.MapItem{Key: "name", Value: m.Name})
}
if m.Namespace != "" {
info = append(info, yaml.MapItem{Key: "namespace", Value: m.Namespace})
}
if m.Prefix != "" {
info = append(info, yaml.MapItem{Key: "prefix", Value: m.Prefix})
}
if m.Attribute != false {
info = append(info, yaml.MapItem{Key: "attribute", Value: m.Attribute})
}
if m.Wrapped != false {
info = append(info, yaml.MapItem{Key: "wrapped", Value: m.Wrapped})
}
if m.SpecificationExtension != nil {
for _, item := range m.SpecificationExtension {
info = append(info, yaml.MapItem{Key: item.Name, Value: item.Value.ToRawInfo()})
}
}
// &{Name:SpecificationExtension Type:NamedAny StringEnumValues:[] MapType:Any Repeated:true Pattern:^x- Implicit:true Description:}
return info
} | go | {
"resource": ""
} |
q18696 | ParameterList | train | func ParameterList(parametersType *surface.Type) string {
result := ""
if parametersType != nil {
for _, field := range parametersType.Fields {
result += field.ParameterName + " " + field.NativeType + "," + "\n"
}
}
return result
} | go | {
"resource": ""
} |
q18697 | NewList | train | func NewList(bytes []byte) (*List, error) {
var listResponse List
err := json.Unmarshal(bytes, &listResponse)
return &listResponse, err
} | go | {
"resource": ""
} |
q18698 | APIWithNameAndVersion | train | func (a *List) APIWithNameAndVersion(name string, version string) (*API, error) {
var api *API // the API to return
versions := make([]string, 0) // the matching version names
// Scan the list for matching APIs and versions.
for _, item := range a.APIs {
if item.Name == name {
if version == "" || version == item.Version {
api = item
versions = append(versions, item.Version)
}
}
}
switch {
case len(versions) == 0:
return nil, errors.New(name + " was not found.")
case len(versions) > 1:
return nil, errors.New(name + " has multiple versions: " + strings.Join(versions, ", "))
default:
return api, nil
}
} | go | {
"resource": ""
} |
q18699 | NewServiceRenderer | train | func NewServiceRenderer(model *surface.Model) (renderer *Renderer, err error) {
renderer = &Renderer{}
renderer.Model = model
return renderer, nil
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.