code
stringlengths 12
335k
| docstring
stringlengths 20
20.8k
| func_name
stringlengths 1
105
| language
stringclasses 1
value | repo
stringclasses 498
values | path
stringlengths 5
172
| url
stringlengths 43
235
| license
stringclasses 4
values |
|---|---|---|---|---|---|---|---|
func NewResponses(in *yaml.Node, context *compiler.Context) (*Responses, error) {
errors := make([]error, 0)
x := &Responses{}
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 {
allowedKeys := []string{"default"}
allowedPatterns := []*regexp.Regexp{pattern3, pattern1}
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))
}
// ResponseOrReference default = 1;
v1 := compiler.MapValueForKey(m, "default")
if v1 != nil {
var err error
x.Default, err = NewResponseOrReference(v1, compiler.NewContext("default", v1, context))
if err != nil {
errors = append(errors, err)
}
}
// repeated NamedResponseOrReference response_or_reference = 2;
// MAP: ResponseOrReference ^([0-9X]{3})$
x.ResponseOrReference = make([]*NamedResponseOrReference, 0)
for i := 0; i < len(m.Content); i += 2 {
k, ok := compiler.StringForScalarNode(m.Content[i])
if ok {
v := m.Content[i+1]
if pattern3.MatchString(k) {
pair := &NamedResponseOrReference{}
pair.Name = k
var err error
pair.Value, err = NewResponseOrReference(v, compiler.NewContext(k, v, context))
if err != nil {
errors = append(errors, err)
}
x.ResponseOrReference = append(x.ResponseOrReference, pair)
}
}
}
// repeated NamedAny specification_extension = 3;
// MAP: Any ^x-
x.SpecificationExtension = make([]*NamedAny, 0)
for i := 0; i < len(m.Content); i += 2 {
k, ok := compiler.StringForScalarNode(m.Content[i])
if ok {
v := m.Content[i+1]
if strings.HasPrefix(k, "x-") {
pair := &NamedAny{}
pair.Name = k
result := &Any{}
handled, resultFromExt, err := compiler.CallExtension(context, v, k)
if handled {
if err != nil {
errors = append(errors, err)
} else {
bytes := compiler.Marshal(v)
result.Yaml = string(bytes)
result.Value = resultFromExt
pair.Value = result
}
} else {
pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
if err != nil {
errors = append(errors, err)
}
}
x.SpecificationExtension = append(x.SpecificationExtension, pair)
}
}
}
}
return x, compiler.NewErrorGroupOrNil(errors)
} | NewResponses creates an object of type Responses if possible, returning an error if not. | NewResponses | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func NewResponsesOrReferences(in *yaml.Node, 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 i := 0; i < len(m.Content); i += 2 {
k, ok := compiler.StringForScalarNode(m.Content[i])
if ok {
v := m.Content[i+1]
pair := &NamedResponseOrReference{}
pair.Name = k
var err error
pair.Value, err = NewResponseOrReference(v, compiler.NewContext(k, v, context))
if err != nil {
errors = append(errors, err)
}
x.AdditionalProperties = append(x.AdditionalProperties, pair)
}
}
}
return x, compiler.NewErrorGroupOrNil(errors)
} | NewResponsesOrReferences creates an object of type ResponsesOrReferences if possible, returning an error if not. | NewResponsesOrReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func NewSchema(in *yaml.Node, context *compiler.Context) (*Schema, error) {
errors := make([]error, 0)
x := &Schema{}
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 {
allowedKeys := []string{"additionalProperties", "allOf", "anyOf", "default", "deprecated", "description", "discriminator", "enum", "example", "exclusiveMaximum", "exclusiveMinimum", "externalDocs", "format", "items", "maxItems", "maxLength", "maxProperties", "maximum", "minItems", "minLength", "minProperties", "minimum", "multipleOf", "not", "nullable", "oneOf", "pattern", "properties", "readOnly", "required", "title", "type", "uniqueItems", "writeOnly", "xml"}
allowedPatterns := []*regexp.Regexp{pattern1}
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))
}
// bool nullable = 1;
v1 := compiler.MapValueForKey(m, "nullable")
if v1 != nil {
x.Nullable, ok = compiler.BoolForScalarNode(v1)
if !ok {
message := fmt.Sprintf("has unexpected value for nullable: %s", compiler.Display(v1))
errors = append(errors, compiler.NewError(context, message))
}
}
// Discriminator discriminator = 2;
v2 := compiler.MapValueForKey(m, "discriminator")
if v2 != nil {
var err error
x.Discriminator, err = NewDiscriminator(v2, compiler.NewContext("discriminator", v2, context))
if err != nil {
errors = append(errors, err)
}
}
// bool read_only = 3;
v3 := compiler.MapValueForKey(m, "readOnly")
if v3 != nil {
x.ReadOnly, ok = compiler.BoolForScalarNode(v3)
if !ok {
message := fmt.Sprintf("has unexpected value for readOnly: %s", compiler.Display(v3))
errors = append(errors, compiler.NewError(context, message))
}
}
// bool write_only = 4;
v4 := compiler.MapValueForKey(m, "writeOnly")
if v4 != nil {
x.WriteOnly, ok = compiler.BoolForScalarNode(v4)
if !ok {
message := fmt.Sprintf("has unexpected value for writeOnly: %s", compiler.Display(v4))
errors = append(errors, compiler.NewError(context, message))
}
}
// Xml xml = 5;
v5 := compiler.MapValueForKey(m, "xml")
if v5 != nil {
var err error
x.Xml, err = NewXml(v5, compiler.NewContext("xml", v5, context))
if err != nil {
errors = append(errors, err)
}
}
// ExternalDocs external_docs = 6;
v6 := compiler.MapValueForKey(m, "externalDocs")
if v6 != nil {
var err error
x.ExternalDocs, err = NewExternalDocs(v6, compiler.NewContext("externalDocs", v6, context))
if err != nil {
errors = append(errors, err)
}
}
// Any example = 7;
v7 := compiler.MapValueForKey(m, "example")
if v7 != nil {
var err error
x.Example, err = NewAny(v7, compiler.NewContext("example", v7, context))
if err != nil {
errors = append(errors, err)
}
}
// bool deprecated = 8;
v8 := compiler.MapValueForKey(m, "deprecated")
if v8 != nil {
x.Deprecated, ok = compiler.BoolForScalarNode(v8)
if !ok {
message := fmt.Sprintf("has unexpected value for deprecated: %s", compiler.Display(v8))
errors = append(errors, compiler.NewError(context, message))
}
}
// string title = 9;
v9 := compiler.MapValueForKey(m, "title")
if v9 != nil {
x.Title, ok = compiler.StringForScalarNode(v9)
if !ok {
message := fmt.Sprintf("has unexpected value for title: %s", compiler.Display(v9))
errors = append(errors, compiler.NewError(context, message))
}
}
// float multiple_of = 10;
v10 := compiler.MapValueForKey(m, "multipleOf")
if v10 != nil {
v, ok := compiler.FloatForScalarNode(v10)
if ok {
x.MultipleOf = v
} else {
message := fmt.Sprintf("has unexpected value for multipleOf: %s", compiler.Display(v10))
errors = append(errors, compiler.NewError(context, message))
}
}
// float maximum = 11;
v11 := compiler.MapValueForKey(m, "maximum")
if v11 != nil {
v, ok := compiler.FloatForScalarNode(v11)
if ok {
x.Maximum = v
} else {
message := fmt.Sprintf("has unexpected value for maximum: %s", compiler.Display(v11))
errors = append(errors, compiler.NewError(context, message))
}
}
// bool exclusive_maximum = 12;
v12 := compiler.MapValueForKey(m, "exclusiveMaximum")
if v12 != nil {
x.ExclusiveMaximum, ok = compiler.BoolForScalarNode(v12)
if !ok {
message := fmt.Sprintf("has unexpected value for exclusiveMaximum: %s", compiler.Display(v12))
errors = append(errors, compiler.NewError(context, message))
}
}
// float minimum = 13;
v13 := compiler.MapValueForKey(m, "minimum")
if v13 != nil {
v, ok := compiler.FloatForScalarNode(v13)
if ok {
x.Minimum = v
} else {
message := fmt.Sprintf("has unexpected value for minimum: %s", compiler.Display(v13))
errors = append(errors, compiler.NewError(context, message))
}
}
// bool exclusive_minimum = 14;
v14 := compiler.MapValueForKey(m, "exclusiveMinimum")
if v14 != nil {
x.ExclusiveMinimum, ok = compiler.BoolForScalarNode(v14)
if !ok {
message := fmt.Sprintf("has unexpected value for exclusiveMinimum: %s", compiler.Display(v14))
errors = append(errors, compiler.NewError(context, message))
}
}
// int64 max_length = 15;
v15 := compiler.MapValueForKey(m, "maxLength")
if v15 != nil {
t, ok := compiler.IntForScalarNode(v15)
if ok {
x.MaxLength = int64(t)
} else {
message := fmt.Sprintf("has unexpected value for maxLength: %s", compiler.Display(v15))
errors = append(errors, compiler.NewError(context, message))
}
}
// int64 min_length = 16;
v16 := compiler.MapValueForKey(m, "minLength")
if v16 != nil {
t, ok := compiler.IntForScalarNode(v16)
if ok {
x.MinLength = int64(t)
} else {
message := fmt.Sprintf("has unexpected value for minLength: %s", compiler.Display(v16))
errors = append(errors, compiler.NewError(context, message))
}
}
// string pattern = 17;
v17 := compiler.MapValueForKey(m, "pattern")
if v17 != nil {
x.Pattern, ok = compiler.StringForScalarNode(v17)
if !ok {
message := fmt.Sprintf("has unexpected value for pattern: %s", compiler.Display(v17))
errors = append(errors, compiler.NewError(context, message))
}
}
// int64 max_items = 18;
v18 := compiler.MapValueForKey(m, "maxItems")
if v18 != nil {
t, ok := compiler.IntForScalarNode(v18)
if ok {
x.MaxItems = int64(t)
} else {
message := fmt.Sprintf("has unexpected value for maxItems: %s", compiler.Display(v18))
errors = append(errors, compiler.NewError(context, message))
}
}
// int64 min_items = 19;
v19 := compiler.MapValueForKey(m, "minItems")
if v19 != nil {
t, ok := compiler.IntForScalarNode(v19)
if ok {
x.MinItems = int64(t)
} else {
message := fmt.Sprintf("has unexpected value for minItems: %s", compiler.Display(v19))
errors = append(errors, compiler.NewError(context, message))
}
}
// bool unique_items = 20;
v20 := compiler.MapValueForKey(m, "uniqueItems")
if v20 != nil {
x.UniqueItems, ok = compiler.BoolForScalarNode(v20)
if !ok {
message := fmt.Sprintf("has unexpected value for uniqueItems: %s", compiler.Display(v20))
errors = append(errors, compiler.NewError(context, message))
}
}
// int64 max_properties = 21;
v21 := compiler.MapValueForKey(m, "maxProperties")
if v21 != nil {
t, ok := compiler.IntForScalarNode(v21)
if ok {
x.MaxProperties = int64(t)
} else {
message := fmt.Sprintf("has unexpected value for maxProperties: %s", compiler.Display(v21))
errors = append(errors, compiler.NewError(context, message))
}
}
// int64 min_properties = 22;
v22 := compiler.MapValueForKey(m, "minProperties")
if v22 != nil {
t, ok := compiler.IntForScalarNode(v22)
if ok {
x.MinProperties = int64(t)
} else {
message := fmt.Sprintf("has unexpected value for minProperties: %s", compiler.Display(v22))
errors = append(errors, compiler.NewError(context, message))
}
}
// repeated string required = 23;
v23 := compiler.MapValueForKey(m, "required")
if v23 != nil {
v, ok := compiler.SequenceNodeForNode(v23)
if ok {
x.Required = compiler.StringArrayForSequenceNode(v)
} else {
message := fmt.Sprintf("has unexpected value for required: %s", compiler.Display(v23))
errors = append(errors, compiler.NewError(context, message))
}
}
// repeated Any enum = 24;
v24 := compiler.MapValueForKey(m, "enum")
if v24 != nil {
// repeated Any
x.Enum = make([]*Any, 0)
a, ok := compiler.SequenceNodeForNode(v24)
if ok {
for _, item := range a.Content {
y, err := NewAny(item, compiler.NewContext("enum", item, context))
if err != nil {
errors = append(errors, err)
}
x.Enum = append(x.Enum, y)
}
}
}
// string type = 25;
v25 := compiler.MapValueForKey(m, "type")
if v25 != nil {
x.Type, ok = compiler.StringForScalarNode(v25)
if !ok {
message := fmt.Sprintf("has unexpected value for type: %s", compiler.Display(v25))
errors = append(errors, compiler.NewError(context, message))
}
}
// repeated SchemaOrReference all_of = 26;
v26 := compiler.MapValueForKey(m, "allOf")
if v26 != nil {
// repeated SchemaOrReference
x.AllOf = make([]*SchemaOrReference, 0)
a, ok := compiler.SequenceNodeForNode(v26)
if ok {
for _, item := range a.Content {
y, err := NewSchemaOrReference(item, compiler.NewContext("allOf", item, context))
if err != nil {
errors = append(errors, err)
}
x.AllOf = append(x.AllOf, y)
}
}
}
// repeated SchemaOrReference one_of = 27;
v27 := compiler.MapValueForKey(m, "oneOf")
if v27 != nil {
// repeated SchemaOrReference
x.OneOf = make([]*SchemaOrReference, 0)
a, ok := compiler.SequenceNodeForNode(v27)
if ok {
for _, item := range a.Content {
y, err := NewSchemaOrReference(item, compiler.NewContext("oneOf", item, context))
if err != nil {
errors = append(errors, err)
}
x.OneOf = append(x.OneOf, y)
}
}
}
// repeated SchemaOrReference any_of = 28;
v28 := compiler.MapValueForKey(m, "anyOf")
if v28 != nil {
// repeated SchemaOrReference
x.AnyOf = make([]*SchemaOrReference, 0)
a, ok := compiler.SequenceNodeForNode(v28)
if ok {
for _, item := range a.Content {
y, err := NewSchemaOrReference(item, compiler.NewContext("anyOf", item, context))
if err != nil {
errors = append(errors, err)
}
x.AnyOf = append(x.AnyOf, y)
}
}
}
// Schema not = 29;
v29 := compiler.MapValueForKey(m, "not")
if v29 != nil {
var err error
x.Not, err = NewSchema(v29, compiler.NewContext("not", v29, context))
if err != nil {
errors = append(errors, err)
}
}
// ItemsItem items = 30;
v30 := compiler.MapValueForKey(m, "items")
if v30 != nil {
var err error
x.Items, err = NewItemsItem(v30, compiler.NewContext("items", v30, context))
if err != nil {
errors = append(errors, err)
}
}
// Properties properties = 31;
v31 := compiler.MapValueForKey(m, "properties")
if v31 != nil {
var err error
x.Properties, err = NewProperties(v31, compiler.NewContext("properties", v31, context))
if err != nil {
errors = append(errors, err)
}
}
// AdditionalPropertiesItem additional_properties = 32;
v32 := compiler.MapValueForKey(m, "additionalProperties")
if v32 != nil {
var err error
x.AdditionalProperties, err = NewAdditionalPropertiesItem(v32, compiler.NewContext("additionalProperties", v32, context))
if err != nil {
errors = append(errors, err)
}
}
// DefaultType default = 33;
v33 := compiler.MapValueForKey(m, "default")
if v33 != nil {
var err error
x.Default, err = NewDefaultType(v33, compiler.NewContext("default", v33, context))
if err != nil {
errors = append(errors, err)
}
}
// string description = 34;
v34 := compiler.MapValueForKey(m, "description")
if v34 != nil {
x.Description, ok = compiler.StringForScalarNode(v34)
if !ok {
message := fmt.Sprintf("has unexpected value for description: %s", compiler.Display(v34))
errors = append(errors, compiler.NewError(context, message))
}
}
// string format = 35;
v35 := compiler.MapValueForKey(m, "format")
if v35 != nil {
x.Format, ok = compiler.StringForScalarNode(v35)
if !ok {
message := fmt.Sprintf("has unexpected value for format: %s", compiler.Display(v35))
errors = append(errors, compiler.NewError(context, message))
}
}
// repeated NamedAny specification_extension = 36;
// MAP: Any ^x-
x.SpecificationExtension = make([]*NamedAny, 0)
for i := 0; i < len(m.Content); i += 2 {
k, ok := compiler.StringForScalarNode(m.Content[i])
if ok {
v := m.Content[i+1]
if strings.HasPrefix(k, "x-") {
pair := &NamedAny{}
pair.Name = k
result := &Any{}
handled, resultFromExt, err := compiler.CallExtension(context, v, k)
if handled {
if err != nil {
errors = append(errors, err)
} else {
bytes := compiler.Marshal(v)
result.Yaml = string(bytes)
result.Value = resultFromExt
pair.Value = result
}
} else {
pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
if err != nil {
errors = append(errors, err)
}
}
x.SpecificationExtension = append(x.SpecificationExtension, pair)
}
}
}
}
return x, compiler.NewErrorGroupOrNil(errors)
} | NewSchema creates an object of type Schema if possible, returning an error if not. | NewSchema | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func NewSchemaOrReference(in *yaml.Node, 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", m, 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", m, 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)
} else {
message := fmt.Sprintf("contains an invalid SchemaOrReference")
err := compiler.NewError(context, message)
errors = []error{err}
}
return x, compiler.NewErrorGroupOrNil(errors)
} | NewSchemaOrReference creates an object of type SchemaOrReference if possible, returning an error if not. | NewSchemaOrReference | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func NewSchemasOrReferences(in *yaml.Node, context *compiler.Context) (*SchemasOrReferences, error) {
errors := make([]error, 0)
x := &SchemasOrReferences{}
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 i := 0; i < len(m.Content); i += 2 {
k, ok := compiler.StringForScalarNode(m.Content[i])
if ok {
v := m.Content[i+1]
pair := &NamedSchemaOrReference{}
pair.Name = k
var err error
pair.Value, err = NewSchemaOrReference(v, compiler.NewContext(k, v, context))
if err != nil {
errors = append(errors, err)
}
x.AdditionalProperties = append(x.AdditionalProperties, pair)
}
}
}
return x, compiler.NewErrorGroupOrNil(errors)
} | NewSchemasOrReferences creates an object of type SchemasOrReferences if possible, returning an error if not. | NewSchemasOrReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func NewSecurityRequirement(in *yaml.Node, context *compiler.Context) (*SecurityRequirement, error) {
errors := make([]error, 0)
x := &SecurityRequirement{}
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 NamedStringArray additional_properties = 1;
// MAP: StringArray
x.AdditionalProperties = make([]*NamedStringArray, 0)
for i := 0; i < len(m.Content); i += 2 {
k, ok := compiler.StringForScalarNode(m.Content[i])
if ok {
v := m.Content[i+1]
pair := &NamedStringArray{}
pair.Name = k
var err error
pair.Value, err = NewStringArray(v, compiler.NewContext(k, v, context))
if err != nil {
errors = append(errors, err)
}
x.AdditionalProperties = append(x.AdditionalProperties, pair)
}
}
}
return x, compiler.NewErrorGroupOrNil(errors)
} | NewSecurityRequirement creates an object of type SecurityRequirement if possible, returning an error if not. | NewSecurityRequirement | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func NewSecurityScheme(in *yaml.Node, context *compiler.Context) (*SecurityScheme, error) {
errors := make([]error, 0)
x := &SecurityScheme{}
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{"type"}
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{"bearerFormat", "description", "flows", "in", "name", "openIdConnectUrl", "scheme", "type"}
allowedPatterns := []*regexp.Regexp{pattern1}
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 type = 1;
v1 := compiler.MapValueForKey(m, "type")
if v1 != nil {
x.Type, ok = compiler.StringForScalarNode(v1)
if !ok {
message := fmt.Sprintf("has unexpected value for type: %s", compiler.Display(v1))
errors = append(errors, compiler.NewError(context, message))
}
}
// string description = 2;
v2 := compiler.MapValueForKey(m, "description")
if v2 != nil {
x.Description, ok = compiler.StringForScalarNode(v2)
if !ok {
message := fmt.Sprintf("has unexpected value for description: %s", compiler.Display(v2))
errors = append(errors, compiler.NewError(context, message))
}
}
// string name = 3;
v3 := compiler.MapValueForKey(m, "name")
if v3 != nil {
x.Name, ok = compiler.StringForScalarNode(v3)
if !ok {
message := fmt.Sprintf("has unexpected value for name: %s", compiler.Display(v3))
errors = append(errors, compiler.NewError(context, message))
}
}
// string in = 4;
v4 := compiler.MapValueForKey(m, "in")
if v4 != nil {
x.In, ok = compiler.StringForScalarNode(v4)
if !ok {
message := fmt.Sprintf("has unexpected value for in: %s", compiler.Display(v4))
errors = append(errors, compiler.NewError(context, message))
}
}
// string scheme = 5;
v5 := compiler.MapValueForKey(m, "scheme")
if v5 != nil {
x.Scheme, ok = compiler.StringForScalarNode(v5)
if !ok {
message := fmt.Sprintf("has unexpected value for scheme: %s", compiler.Display(v5))
errors = append(errors, compiler.NewError(context, message))
}
}
// string bearer_format = 6;
v6 := compiler.MapValueForKey(m, "bearerFormat")
if v6 != nil {
x.BearerFormat, ok = compiler.StringForScalarNode(v6)
if !ok {
message := fmt.Sprintf("has unexpected value for bearerFormat: %s", compiler.Display(v6))
errors = append(errors, compiler.NewError(context, message))
}
}
// OauthFlows flows = 7;
v7 := compiler.MapValueForKey(m, "flows")
if v7 != nil {
var err error
x.Flows, err = NewOauthFlows(v7, compiler.NewContext("flows", v7, context))
if err != nil {
errors = append(errors, err)
}
}
// string open_id_connect_url = 8;
v8 := compiler.MapValueForKey(m, "openIdConnectUrl")
if v8 != nil {
x.OpenIdConnectUrl, ok = compiler.StringForScalarNode(v8)
if !ok {
message := fmt.Sprintf("has unexpected value for openIdConnectUrl: %s", compiler.Display(v8))
errors = append(errors, compiler.NewError(context, message))
}
}
// repeated NamedAny specification_extension = 9;
// MAP: Any ^x-
x.SpecificationExtension = make([]*NamedAny, 0)
for i := 0; i < len(m.Content); i += 2 {
k, ok := compiler.StringForScalarNode(m.Content[i])
if ok {
v := m.Content[i+1]
if strings.HasPrefix(k, "x-") {
pair := &NamedAny{}
pair.Name = k
result := &Any{}
handled, resultFromExt, err := compiler.CallExtension(context, v, k)
if handled {
if err != nil {
errors = append(errors, err)
} else {
bytes := compiler.Marshal(v)
result.Yaml = string(bytes)
result.Value = resultFromExt
pair.Value = result
}
} else {
pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
if err != nil {
errors = append(errors, err)
}
}
x.SpecificationExtension = append(x.SpecificationExtension, pair)
}
}
}
}
return x, compiler.NewErrorGroupOrNil(errors)
} | NewSecurityScheme creates an object of type SecurityScheme if possible, returning an error if not. | NewSecurityScheme | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func NewSecuritySchemeOrReference(in *yaml.Node, 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", m, 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", m, 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)
} else {
message := fmt.Sprintf("contains an invalid SecuritySchemeOrReference")
err := compiler.NewError(context, message)
errors = []error{err}
}
return x, compiler.NewErrorGroupOrNil(errors)
} | NewSecuritySchemeOrReference creates an object of type SecuritySchemeOrReference if possible, returning an error if not. | NewSecuritySchemeOrReference | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func NewSecuritySchemesOrReferences(in *yaml.Node, 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 i := 0; i < len(m.Content); i += 2 {
k, ok := compiler.StringForScalarNode(m.Content[i])
if ok {
v := m.Content[i+1]
pair := &NamedSecuritySchemeOrReference{}
pair.Name = k
var err error
pair.Value, err = NewSecuritySchemeOrReference(v, compiler.NewContext(k, v, context))
if err != nil {
errors = append(errors, err)
}
x.AdditionalProperties = append(x.AdditionalProperties, pair)
}
}
}
return x, compiler.NewErrorGroupOrNil(errors)
} | NewSecuritySchemesOrReferences creates an object of type SecuritySchemesOrReferences if possible, returning an error if not. | NewSecuritySchemesOrReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func NewServer(in *yaml.Node, context *compiler.Context) (*Server, error) {
errors := make([]error, 0)
x := &Server{}
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{"url"}
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{"description", "url", "variables"}
allowedPatterns := []*regexp.Regexp{pattern1}
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 url = 1;
v1 := compiler.MapValueForKey(m, "url")
if v1 != nil {
x.Url, ok = compiler.StringForScalarNode(v1)
if !ok {
message := fmt.Sprintf("has unexpected value for url: %s", compiler.Display(v1))
errors = append(errors, compiler.NewError(context, message))
}
}
// string description = 2;
v2 := compiler.MapValueForKey(m, "description")
if v2 != nil {
x.Description, ok = compiler.StringForScalarNode(v2)
if !ok {
message := fmt.Sprintf("has unexpected value for description: %s", compiler.Display(v2))
errors = append(errors, compiler.NewError(context, message))
}
}
// ServerVariables variables = 3;
v3 := compiler.MapValueForKey(m, "variables")
if v3 != nil {
var err error
x.Variables, err = NewServerVariables(v3, compiler.NewContext("variables", v3, context))
if err != nil {
errors = append(errors, err)
}
}
// repeated NamedAny specification_extension = 4;
// MAP: Any ^x-
x.SpecificationExtension = make([]*NamedAny, 0)
for i := 0; i < len(m.Content); i += 2 {
k, ok := compiler.StringForScalarNode(m.Content[i])
if ok {
v := m.Content[i+1]
if strings.HasPrefix(k, "x-") {
pair := &NamedAny{}
pair.Name = k
result := &Any{}
handled, resultFromExt, err := compiler.CallExtension(context, v, k)
if handled {
if err != nil {
errors = append(errors, err)
} else {
bytes := compiler.Marshal(v)
result.Yaml = string(bytes)
result.Value = resultFromExt
pair.Value = result
}
} else {
pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
if err != nil {
errors = append(errors, err)
}
}
x.SpecificationExtension = append(x.SpecificationExtension, pair)
}
}
}
}
return x, compiler.NewErrorGroupOrNil(errors)
} | NewServer creates an object of type Server if possible, returning an error if not. | NewServer | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func NewServerVariable(in *yaml.Node, context *compiler.Context) (*ServerVariable, error) {
errors := make([]error, 0)
x := &ServerVariable{}
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{"default"}
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{"default", "description", "enum"}
allowedPatterns := []*regexp.Regexp{pattern1}
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))
}
// repeated string enum = 1;
v1 := compiler.MapValueForKey(m, "enum")
if v1 != nil {
v, ok := compiler.SequenceNodeForNode(v1)
if ok {
x.Enum = compiler.StringArrayForSequenceNode(v)
} else {
message := fmt.Sprintf("has unexpected value for enum: %s", compiler.Display(v1))
errors = append(errors, compiler.NewError(context, message))
}
}
// string default = 2;
v2 := compiler.MapValueForKey(m, "default")
if v2 != nil {
x.Default, ok = compiler.StringForScalarNode(v2)
if !ok {
message := fmt.Sprintf("has unexpected value for default: %s", compiler.Display(v2))
errors = append(errors, compiler.NewError(context, message))
}
}
// string description = 3;
v3 := compiler.MapValueForKey(m, "description")
if v3 != nil {
x.Description, ok = compiler.StringForScalarNode(v3)
if !ok {
message := fmt.Sprintf("has unexpected value for description: %s", compiler.Display(v3))
errors = append(errors, compiler.NewError(context, message))
}
}
// repeated NamedAny specification_extension = 4;
// MAP: Any ^x-
x.SpecificationExtension = make([]*NamedAny, 0)
for i := 0; i < len(m.Content); i += 2 {
k, ok := compiler.StringForScalarNode(m.Content[i])
if ok {
v := m.Content[i+1]
if strings.HasPrefix(k, "x-") {
pair := &NamedAny{}
pair.Name = k
result := &Any{}
handled, resultFromExt, err := compiler.CallExtension(context, v, k)
if handled {
if err != nil {
errors = append(errors, err)
} else {
bytes := compiler.Marshal(v)
result.Yaml = string(bytes)
result.Value = resultFromExt
pair.Value = result
}
} else {
pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
if err != nil {
errors = append(errors, err)
}
}
x.SpecificationExtension = append(x.SpecificationExtension, pair)
}
}
}
}
return x, compiler.NewErrorGroupOrNil(errors)
} | NewServerVariable creates an object of type ServerVariable if possible, returning an error if not. | NewServerVariable | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func NewServerVariables(in *yaml.Node, 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 i := 0; i < len(m.Content); i += 2 {
k, ok := compiler.StringForScalarNode(m.Content[i])
if ok {
v := m.Content[i+1]
pair := &NamedServerVariable{}
pair.Name = k
var err error
pair.Value, err = NewServerVariable(v, compiler.NewContext(k, v, context))
if err != nil {
errors = append(errors, err)
}
x.AdditionalProperties = append(x.AdditionalProperties, pair)
}
}
}
return x, compiler.NewErrorGroupOrNil(errors)
} | NewServerVariables creates an object of type ServerVariables if possible, returning an error if not. | NewServerVariables | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func NewSpecificationExtension(in *yaml.Node, context *compiler.Context) (*SpecificationExtension, error) {
errors := make([]error, 0)
x := &SpecificationExtension{}
matched := false
switch in.Tag {
case "!!bool":
var v bool
v, matched = compiler.BoolForScalarNode(in)
x.Oneof = &SpecificationExtension_Boolean{Boolean: v}
case "!!str":
var v string
v, matched = compiler.StringForScalarNode(in)
x.Oneof = &SpecificationExtension_String_{String_: v}
case "!!float":
var v float64
v, matched = compiler.FloatForScalarNode(in)
x.Oneof = &SpecificationExtension_Number{Number: v}
case "!!int":
var v int64
v, matched = compiler.IntForScalarNode(in)
x.Oneof = &SpecificationExtension_Number{Number: float64(v)}
}
if matched {
// since the oneof matched one of its possibilities, discard any matching errors
errors = make([]error, 0)
}
return x, compiler.NewErrorGroupOrNil(errors)
} | NewSpecificationExtension creates an object of type SpecificationExtension if possible, returning an error if not. | NewSpecificationExtension | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func NewStringArray(in *yaml.Node, context *compiler.Context) (*StringArray, error) {
errors := make([]error, 0)
x := &StringArray{}
x.Value = make([]string, 0)
for _, node := range in.Content {
s, _ := compiler.StringForScalarNode(node)
x.Value = append(x.Value, s)
}
return x, compiler.NewErrorGroupOrNil(errors)
} | NewStringArray creates an object of type StringArray if possible, returning an error if not. | NewStringArray | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func NewStrings(in *yaml.Node, context *compiler.Context) (*Strings, error) {
errors := make([]error, 0)
x := &Strings{}
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 NamedString additional_properties = 1;
// MAP: string
x.AdditionalProperties = make([]*NamedString, 0)
for i := 0; i < len(m.Content); i += 2 {
k, ok := compiler.StringForScalarNode(m.Content[i])
if ok {
v := m.Content[i+1]
pair := &NamedString{}
pair.Name = k
pair.Value, _ = compiler.StringForScalarNode(v)
x.AdditionalProperties = append(x.AdditionalProperties, pair)
}
}
}
return x, compiler.NewErrorGroupOrNil(errors)
} | NewStrings creates an object of type Strings if possible, returning an error if not. | NewStrings | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func NewTag(in *yaml.Node, context *compiler.Context) (*Tag, error) {
errors := make([]error, 0)
x := &Tag{}
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{"name"}
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{"description", "externalDocs", "name"}
allowedPatterns := []*regexp.Regexp{pattern1}
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 name = 1;
v1 := compiler.MapValueForKey(m, "name")
if v1 != nil {
x.Name, ok = compiler.StringForScalarNode(v1)
if !ok {
message := fmt.Sprintf("has unexpected value for name: %s", compiler.Display(v1))
errors = append(errors, compiler.NewError(context, message))
}
}
// string description = 2;
v2 := compiler.MapValueForKey(m, "description")
if v2 != nil {
x.Description, ok = compiler.StringForScalarNode(v2)
if !ok {
message := fmt.Sprintf("has unexpected value for description: %s", compiler.Display(v2))
errors = append(errors, compiler.NewError(context, message))
}
}
// ExternalDocs external_docs = 3;
v3 := compiler.MapValueForKey(m, "externalDocs")
if v3 != nil {
var err error
x.ExternalDocs, err = NewExternalDocs(v3, compiler.NewContext("externalDocs", v3, context))
if err != nil {
errors = append(errors, err)
}
}
// repeated NamedAny specification_extension = 4;
// MAP: Any ^x-
x.SpecificationExtension = make([]*NamedAny, 0)
for i := 0; i < len(m.Content); i += 2 {
k, ok := compiler.StringForScalarNode(m.Content[i])
if ok {
v := m.Content[i+1]
if strings.HasPrefix(k, "x-") {
pair := &NamedAny{}
pair.Name = k
result := &Any{}
handled, resultFromExt, err := compiler.CallExtension(context, v, k)
if handled {
if err != nil {
errors = append(errors, err)
} else {
bytes := compiler.Marshal(v)
result.Yaml = string(bytes)
result.Value = resultFromExt
pair.Value = result
}
} else {
pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
if err != nil {
errors = append(errors, err)
}
}
x.SpecificationExtension = append(x.SpecificationExtension, pair)
}
}
}
}
return x, compiler.NewErrorGroupOrNil(errors)
} | NewTag creates an object of type Tag if possible, returning an error if not. | NewTag | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func NewXml(in *yaml.Node, context *compiler.Context) (*Xml, error) {
errors := make([]error, 0)
x := &Xml{}
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 {
allowedKeys := []string{"attribute", "name", "namespace", "prefix", "wrapped"}
allowedPatterns := []*regexp.Regexp{pattern1}
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 name = 1;
v1 := compiler.MapValueForKey(m, "name")
if v1 != nil {
x.Name, ok = compiler.StringForScalarNode(v1)
if !ok {
message := fmt.Sprintf("has unexpected value for name: %s", compiler.Display(v1))
errors = append(errors, compiler.NewError(context, message))
}
}
// string namespace = 2;
v2 := compiler.MapValueForKey(m, "namespace")
if v2 != nil {
x.Namespace, ok = compiler.StringForScalarNode(v2)
if !ok {
message := fmt.Sprintf("has unexpected value for namespace: %s", compiler.Display(v2))
errors = append(errors, compiler.NewError(context, message))
}
}
// string prefix = 3;
v3 := compiler.MapValueForKey(m, "prefix")
if v3 != nil {
x.Prefix, ok = compiler.StringForScalarNode(v3)
if !ok {
message := fmt.Sprintf("has unexpected value for prefix: %s", compiler.Display(v3))
errors = append(errors, compiler.NewError(context, message))
}
}
// bool attribute = 4;
v4 := compiler.MapValueForKey(m, "attribute")
if v4 != nil {
x.Attribute, ok = compiler.BoolForScalarNode(v4)
if !ok {
message := fmt.Sprintf("has unexpected value for attribute: %s", compiler.Display(v4))
errors = append(errors, compiler.NewError(context, message))
}
}
// bool wrapped = 5;
v5 := compiler.MapValueForKey(m, "wrapped")
if v5 != nil {
x.Wrapped, ok = compiler.BoolForScalarNode(v5)
if !ok {
message := fmt.Sprintf("has unexpected value for wrapped: %s", compiler.Display(v5))
errors = append(errors, compiler.NewError(context, message))
}
}
// repeated NamedAny specification_extension = 6;
// MAP: Any ^x-
x.SpecificationExtension = make([]*NamedAny, 0)
for i := 0; i < len(m.Content); i += 2 {
k, ok := compiler.StringForScalarNode(m.Content[i])
if ok {
v := m.Content[i+1]
if strings.HasPrefix(k, "x-") {
pair := &NamedAny{}
pair.Name = k
result := &Any{}
handled, resultFromExt, err := compiler.CallExtension(context, v, k)
if handled {
if err != nil {
errors = append(errors, err)
} else {
bytes := compiler.Marshal(v)
result.Yaml = string(bytes)
result.Value = resultFromExt
pair.Value = result
}
} else {
pair.Value, err = NewAny(v, compiler.NewContext(k, v, context))
if err != nil {
errors = append(errors, err)
}
}
x.SpecificationExtension = append(x.SpecificationExtension, pair)
}
}
}
}
return x, compiler.NewErrorGroupOrNil(errors)
} | NewXml creates an object of type Xml if possible, returning an error if not. | NewXml | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *AdditionalPropertiesItem) ResolveReferences(root string) (*yaml.Node, 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)
} | ResolveReferences resolves references found inside AdditionalPropertiesItem objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *Any) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside Any objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *AnyOrExpression) ResolveReferences(root string) (*yaml.Node, 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)
} | ResolveReferences resolves references found inside AnyOrExpression objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *Callback) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
for _, item := range m.Path {
if item != nil {
_, err := item.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)
} | ResolveReferences resolves references found inside Callback objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *CallbackOrReference) ResolveReferences(root string) (*yaml.Node, 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)
} | ResolveReferences resolves references found inside CallbackOrReference objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *CallbacksOrReferences) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
for _, item := range m.AdditionalProperties {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside CallbacksOrReferences objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *Components) ResolveReferences(root string) (*yaml.Node, 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)
} | ResolveReferences resolves references found inside Components objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *Contact) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
for _, item := range m.SpecificationExtension {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside Contact objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *DefaultType) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside DefaultType objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *Discriminator) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
if m.Mapping != nil {
_, err := m.Mapping.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)
} | ResolveReferences resolves references found inside Discriminator objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *Document) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
if m.Info != nil {
_, err := m.Info.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
for _, item := range m.Servers {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
if m.Paths != nil {
_, err := m.Paths.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.Components != nil {
_, err := m.Components.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
for _, item := range m.Security {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
for _, item := range m.Tags {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
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)
} | ResolveReferences resolves references found inside Document objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *Encoding) ResolveReferences(root string) (*yaml.Node, 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)
} | ResolveReferences resolves references found inside Encoding objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *Encodings) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
for _, item := range m.AdditionalProperties {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside Encodings objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *Example) ResolveReferences(root string) (*yaml.Node, 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)
} | ResolveReferences resolves references found inside Example objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *ExampleOrReference) ResolveReferences(root string) (*yaml.Node, 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)
} | ResolveReferences resolves references found inside ExampleOrReference objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *ExamplesOrReferences) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
for _, item := range m.AdditionalProperties {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside ExamplesOrReferences objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *Expression) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
for _, item := range m.AdditionalProperties {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside Expression objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *ExternalDocs) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
for _, item := range m.SpecificationExtension {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside ExternalDocs objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *Header) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
if m.Schema != nil {
_, err := m.Schema.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.Example != nil {
_, err := m.Example.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.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)
} | ResolveReferences resolves references found inside Header objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *HeaderOrReference) ResolveReferences(root string) (*yaml.Node, 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)
} | ResolveReferences resolves references found inside HeaderOrReference objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *HeadersOrReferences) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
for _, item := range m.AdditionalProperties {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside HeadersOrReferences objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *Info) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
if m.Contact != nil {
_, err := m.Contact.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.License != nil {
_, err := m.License.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)
} | ResolveReferences resolves references found inside Info objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *ItemsItem) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
for _, item := range m.SchemaOrReference {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside ItemsItem objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *License) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
for _, item := range m.SpecificationExtension {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside License objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *Link) ResolveReferences(root string) (*yaml.Node, 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)
} | ResolveReferences resolves references found inside Link objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *LinkOrReference) ResolveReferences(root string) (*yaml.Node, 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)
} | ResolveReferences resolves references found inside LinkOrReference objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *LinksOrReferences) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
for _, item := range m.AdditionalProperties {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside LinksOrReferences objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *MediaType) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
if m.Schema != nil {
_, err := m.Schema.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.Example != nil {
_, err := m.Example.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.Encoding != nil {
_, err := m.Encoding.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)
} | ResolveReferences resolves references found inside MediaType objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *MediaTypes) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
for _, item := range m.AdditionalProperties {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside MediaTypes objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *NamedAny) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
if m.Value != nil {
_, err := m.Value.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside NamedAny objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *NamedCallbackOrReference) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
if m.Value != nil {
_, err := m.Value.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside NamedCallbackOrReference objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *NamedEncoding) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
if m.Value != nil {
_, err := m.Value.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside NamedEncoding objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *NamedExampleOrReference) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
if m.Value != nil {
_, err := m.Value.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside NamedExampleOrReference objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *NamedHeaderOrReference) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
if m.Value != nil {
_, err := m.Value.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside NamedHeaderOrReference objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *NamedLinkOrReference) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
if m.Value != nil {
_, err := m.Value.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside NamedLinkOrReference objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *NamedMediaType) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
if m.Value != nil {
_, err := m.Value.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside NamedMediaType objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *NamedParameterOrReference) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
if m.Value != nil {
_, err := m.Value.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside NamedParameterOrReference objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *NamedPathItem) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
if m.Value != nil {
_, err := m.Value.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside NamedPathItem objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *NamedRequestBodyOrReference) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
if m.Value != nil {
_, err := m.Value.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside NamedRequestBodyOrReference objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *NamedResponseOrReference) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
if m.Value != nil {
_, err := m.Value.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside NamedResponseOrReference objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *NamedSchemaOrReference) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
if m.Value != nil {
_, err := m.Value.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside NamedSchemaOrReference objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *NamedSecuritySchemeOrReference) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
if m.Value != nil {
_, err := m.Value.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside NamedSecuritySchemeOrReference objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *NamedServerVariable) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
if m.Value != nil {
_, err := m.Value.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside NamedServerVariable objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *NamedString) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside NamedString objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *NamedStringArray) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
if m.Value != nil {
_, err := m.Value.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside NamedStringArray objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *OauthFlow) ResolveReferences(root string) (*yaml.Node, 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)
} | ResolveReferences resolves references found inside OauthFlow objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *OauthFlows) ResolveReferences(root string) (*yaml.Node, 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)
} | ResolveReferences resolves references found inside OauthFlows objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *Object) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
for _, item := range m.AdditionalProperties {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside Object objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *Operation) ResolveReferences(root string) (*yaml.Node, 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.Parameters {
if item != nil {
_, err := item.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.Responses != nil {
_, err := m.Responses.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.Security {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
for _, item := range m.Servers {
if item != nil {
_, err := item.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)
} | ResolveReferences resolves references found inside Operation objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *Parameter) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
if m.Schema != nil {
_, err := m.Schema.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.Example != nil {
_, err := m.Example.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.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)
} | ResolveReferences resolves references found inside Parameter objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *ParameterOrReference) ResolveReferences(root string) (*yaml.Node, 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)
} | ResolveReferences resolves references found inside ParameterOrReference objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *ParametersOrReferences) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
for _, item := range m.AdditionalProperties {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside ParametersOrReferences objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *PathItem) ResolveReferences(root string) (*yaml.Node, 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 := NewPathItem(info, nil)
if err == nil {
*m = *replacement
return m.ResolveReferences(root)
}
}
return info, nil
}
if m.Get != nil {
_, err := m.Get.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.Put != nil {
_, err := m.Put.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.Post != nil {
_, err := m.Post.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.Delete != nil {
_, err := m.Delete.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.Options != nil {
_, err := m.Options.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.Head != nil {
_, err := m.Head.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.Patch != nil {
_, err := m.Patch.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.Trace != nil {
_, err := m.Trace.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
for _, item := range m.Servers {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
for _, item := range m.Parameters {
if item != nil {
_, err := item.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)
} | ResolveReferences resolves references found inside PathItem objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *Paths) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
for _, item := range m.Path {
if item != nil {
_, err := item.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)
} | ResolveReferences resolves references found inside Paths objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *Properties) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
for _, item := range m.AdditionalProperties {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside Properties objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *Reference) ResolveReferences(root string) (*yaml.Node, 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 := NewReference(info, nil)
if err == nil {
*m = *replacement
return m.ResolveReferences(root)
}
}
return info, nil
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside Reference objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *RequestBodiesOrReferences) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
for _, item := range m.AdditionalProperties {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside RequestBodiesOrReferences objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *RequestBody) ResolveReferences(root string) (*yaml.Node, 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)
} | ResolveReferences resolves references found inside RequestBody objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *RequestBodyOrReference) ResolveReferences(root string) (*yaml.Node, 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)
} | ResolveReferences resolves references found inside RequestBodyOrReference objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *Response) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
if m.Headers != nil {
_, err := m.Headers.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.Content != nil {
_, err := m.Content.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)
}
}
for _, item := range m.SpecificationExtension {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside Response objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *ResponseOrReference) ResolveReferences(root string) (*yaml.Node, 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)
} | ResolveReferences resolves references found inside ResponseOrReference objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *Responses) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
if m.Default != nil {
_, err := m.Default.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
for _, item := range m.ResponseOrReference {
if item != nil {
_, err := item.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)
} | ResolveReferences resolves references found inside Responses objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *ResponsesOrReferences) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
for _, item := range m.AdditionalProperties {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside ResponsesOrReferences objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *Schema) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
if m.Discriminator != nil {
_, err := m.Discriminator.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.Xml != nil {
_, err := m.Xml.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.ExternalDocs != nil {
_, err := m.ExternalDocs.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.Example != nil {
_, err := m.Example.ResolveReferences(root)
if err != 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.AllOf {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
for _, item := range m.OneOf {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
for _, item := range m.AnyOf {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
if m.Not != nil {
_, err := m.Not.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.Items != nil {
_, err := m.Items.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.Properties != nil {
_, err := m.Properties.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.AdditionalProperties != nil {
_, err := m.AdditionalProperties.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
if m.Default != nil {
_, err := m.Default.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)
} | ResolveReferences resolves references found inside Schema objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *SchemaOrReference) ResolveReferences(root string) (*yaml.Node, 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)
} | ResolveReferences resolves references found inside SchemaOrReference objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *SchemasOrReferences) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
for _, item := range m.AdditionalProperties {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside SchemasOrReferences objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *SecurityRequirement) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
for _, item := range m.AdditionalProperties {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside SecurityRequirement objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *SecurityScheme) ResolveReferences(root string) (*yaml.Node, 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)
} | ResolveReferences resolves references found inside SecurityScheme objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *SecuritySchemeOrReference) ResolveReferences(root string) (*yaml.Node, 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)
} | ResolveReferences resolves references found inside SecuritySchemeOrReference objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *SecuritySchemesOrReferences) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
for _, item := range m.AdditionalProperties {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside SecuritySchemesOrReferences objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *Server) ResolveReferences(root string) (*yaml.Node, 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)
} | ResolveReferences resolves references found inside Server objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *ServerVariable) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
for _, item := range m.SpecificationExtension {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside ServerVariable objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *ServerVariables) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
for _, item := range m.AdditionalProperties {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside ServerVariables objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *SpecificationExtension) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside SpecificationExtension objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *StringArray) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside StringArray objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *Strings) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
for _, item := range m.AdditionalProperties {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside Strings objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *Tag) ResolveReferences(root string) (*yaml.Node, 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)
} | ResolveReferences resolves references found inside Tag objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *Xml) ResolveReferences(root string) (*yaml.Node, error) {
errors := make([]error, 0)
for _, item := range m.SpecificationExtension {
if item != nil {
_, err := item.ResolveReferences(root)
if err != nil {
errors = append(errors, err)
}
}
}
return nil, compiler.NewErrorGroupOrNil(errors)
} | ResolveReferences resolves references found inside Xml objects. | ResolveReferences | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *AdditionalPropertiesItem) ToRawInfo() *yaml.Node {
// ONE OF WRAPPER
// AdditionalPropertiesItem
// {Name:schemaOrReference Type:SchemaOrReference StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
v0 := m.GetSchemaOrReference()
if v0 != nil {
return v0.ToRawInfo()
}
// {Name:boolean Type:bool StringEnumValues:[] MapType: Repeated:false Pattern: Implicit:false Description:}
if v1, ok := m.GetOneof().(*AdditionalPropertiesItem_Boolean); ok {
return compiler.NewScalarNodeForBool(v1.Boolean)
}
return compiler.NewNullNode()
} | ToRawInfo returns a description of AdditionalPropertiesItem suitable for JSON or YAML export. | ToRawInfo | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *Any) ToRawInfo() *yaml.Node {
var err error
var node yaml.Node
err = yaml.Unmarshal([]byte(m.Yaml), &node)
if err == nil {
if node.Kind == yaml.DocumentNode {
return node.Content[0]
}
return &node
}
return compiler.NewNullNode()
} | ToRawInfo returns a description of Any suitable for JSON or YAML export. | ToRawInfo | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *AnyOrExpression) ToRawInfo() *yaml.Node {
// 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 compiler.NewNullNode()
} | ToRawInfo returns a description of AnyOrExpression suitable for JSON or YAML export. | ToRawInfo | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *Callback) ToRawInfo() *yaml.Node {
info := compiler.NewMappingNode()
if m == nil {
return info
}
if m.Path != nil {
for _, item := range m.Path {
info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
info.Content = append(info.Content, item.Value.ToRawInfo())
}
}
if m.SpecificationExtension != nil {
for _, item := range m.SpecificationExtension {
info.Content = append(info.Content, compiler.NewScalarNodeForString(item.Name))
info.Content = append(info.Content, item.Value.ToRawInfo())
}
}
return info
} | ToRawInfo returns a description of Callback suitable for JSON or YAML export. | ToRawInfo | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
func (m *CallbackOrReference) ToRawInfo() *yaml.Node {
// 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 compiler.NewNullNode()
} | ToRawInfo returns a description of CallbackOrReference suitable for JSON or YAML export. | ToRawInfo | go | k8snetworkplumbingwg/multus-cni | vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | https://github.com/k8snetworkplumbingwg/multus-cni/blob/master/vendor/github.com/google/gnostic-models/openapiv3/OpenAPIv3.go | Apache-2.0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.