aether_4_0_0

package
v0.9.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 6, 2022 License: Apache-2.0 Imports: 6 Imported by: 1

Documentation

Overview

Code generated by YGOT. DO NOT EDIT.

Package aether_4_0_0 is a generated package which contains definitions of structs which represent a YANG schema. The generated schema can be compressed by a series of transformations (compression was false in this case).

This package was generated by /home/scondon/go/pkg/mod/github.com/openconfig/ygot@v0.13.0/genutil/names.go using the following YANG input files:

  • onf-enterprise.yang
  • onf-connectivity-service.yang
  • onf-aether-types.yang
  • onf-application.yang
  • onf-device-group.yang
  • onf-ip-domain.yang
  • onf-site.yang
  • onf-upf.yang
  • onf-template.yang
  • onf-vcs.yang
  • onf-traffic-class.yang

Imported modules were sourced from:

  • /home/scondon/git/opencord/roc-helm-charts/config-models/aether-4.x/files/yang/...

Index

Constants

This section is empty.

Variables

View Source 
var (
	SchemaTree map[string]*yang.Entry
)
View Source 
var ΛEnumTypes = map[string][]reflect.Type{}

ΛEnumTypes is a map, keyed by a YANG schema path, of the enumerated types that correspond with the leaf. The type is represented as a reflect.Type. The naming of the map ensures that there are no clashes with valid YANG identifiers.

Functions

func Schema 

func Schema() (*ytypes.Schema, error)

Schema returns the details of the generated schema.

func Unmarshal 

func Unmarshal(data []byte, destStruct ygot.GoStruct, opts ...ytypes.UnmarshalOpt) error

Unmarshal unmarshals data, which must be RFC7951 JSON format, into destStruct, which must be non-nil and the correct GoStruct type. It returns an error if the destStruct is not found in the schema or the data cannot be unmarshaled. The supplied options (opts) are used to control the behaviour of the unmarshal function - for example, determining whether errors are thrown for unknown fields in the input JSON.

func UnzipSchema 

func UnzipSchema() (map[string]*yang.Entry, error)

UnzipSchema unzips the zipped schema and returns a map of yang.Entry nodes, keyed by the name of the struct that the yang.Entry describes the schema for.

Types

type Binary 

type Binary []byte

Binary is a type that is used for fields that have a YANG type of binary. It is used such that binary fields can be distinguished from leaf-lists of uint8s (which are mapped to []uint8, equivalent to []byte in reflection).

type Device 

type Device struct {
	Application         *OnfApplication_Application                 `path:"application" module:"onf-application"`
	ConnectivityService *OnfConnectivityService_ConnectivityService `path:"connectivity-service" module:"onf-connectivity-service"`
	DeviceGroup         *OnfDeviceGroup_DeviceGroup                 `path:"device-group" module:"onf-device-group"`
	Enterprise          *OnfEnterprise_Enterprise                   `path:"enterprise" module:"onf-enterprise"`
	IpDomain            *OnfIpDomain_IpDomain                       `path:"ip-domain" module:"onf-ip-domain"`
	Site                *OnfSite_Site                               `path:"site" module:"onf-site"`
	Template            *OnfTemplate_Template                       `path:"template" module:"onf-template"`
	TrafficClass        *OnfTrafficClass_TrafficClass               `path:"traffic-class" module:"onf-traffic-class"`
	Upf                 *OnfUpf_Upf                                 `path:"upf" module:"onf-upf"`
	Vcs                 *OnfVcs_Vcs                                 `path:"vcs" module:"onf-vcs"`
}

Device represents the /device YANG schema element.

func (*Device) IsYANGGoStruct 

func (*Device) IsYANGGoStruct()

IsYANGGoStruct ensures that Device implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*Device) Validate 

func (t *Device) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*Device) ΛEnumTypeMap 

func (t *Device) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OnfApplication_Application 

type OnfApplication_Application struct {
	Application map[string]*OnfApplication_Application_Application `path:"application" module:"onf-application"`
}

OnfApplication_Application represents the /onf-application/application YANG schema element.

func (*OnfApplication_Application) IsYANGGoStruct 

func (*OnfApplication_Application) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfApplication_Application implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfApplication_Application) NewApplication 

func (t *OnfApplication_Application) NewApplication(Id string) (*OnfApplication_Application_Application, error)

NewApplication creates a new entry in the Application list of the OnfApplication_Application struct. The keys of the list are populated from the input arguments.

func (*OnfApplication_Application) Validate 

func (t *OnfApplication_Application) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfApplication_Application) ΛEnumTypeMap 

func (t *OnfApplication_Application) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OnfApplication_Application_Application 

type OnfApplication_Application_Application struct {
	Address     *string                                                     `path:"address" module:"onf-application"`
	Description *string                                                     `path:"description" module:"onf-application"`
	DisplayName *string                                                     `path:"display-name" module:"onf-application"`
	Endpoint    map[string]*OnfApplication_Application_Application_Endpoint `path:"endpoint" module:"onf-application"`
	Enterprise  *string                                                     `path:"enterprise" module:"onf-application"`
	Id          *string                                                     `path:"id" module:"onf-application"`
}

OnfApplication_Application_Application represents the /onf-application/application/application YANG schema element.

func (*OnfApplication_Application_Application) IsYANGGoStruct 

func (*OnfApplication_Application_Application) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfApplication_Application_Application implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfApplication_Application_Application) NewEndpoint 

func (t *OnfApplication_Application_Application) NewEndpoint(EndpointId string) (*OnfApplication_Application_Application_Endpoint, error)

NewEndpoint creates a new entry in the Endpoint list of the OnfApplication_Application_Application struct. The keys of the list are populated from the input arguments.

func (*OnfApplication_Application_Application) Validate 

func (t *OnfApplication_Application_Application) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfApplication_Application_Application) ΛEnumTypeMap 

func (t *OnfApplication_Application_Application) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OnfApplication_Application_Application) ΛListKeyMap 

func (t *OnfApplication_Application_Application) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OnfApplication_Application_Application struct, which is a YANG list entry.

type OnfApplication_Application_Application_Endpoint 

type OnfApplication_Application_Application_Endpoint struct {
	DisplayName  *string                                              `path:"display-name" module:"onf-application"`
	EndpointId   *string                                              `path:"endpoint-id" module:"onf-application"`
	Mbr          *OnfApplication_Application_Application_Endpoint_Mbr `path:"mbr" module:"onf-application"`
	PortEnd      *uint16                                              `path:"port-end" module:"onf-application"`
	PortStart    *uint16                                              `path:"port-start" module:"onf-application"`
	Protocol     *string                                              `path:"protocol" module:"onf-application"`
	TrafficClass *string                                              `path:"traffic-class" module:"onf-application"`
}

OnfApplication_Application_Application_Endpoint represents the /onf-application/application/application/endpoint YANG schema element.

func (*OnfApplication_Application_Application_Endpoint) IsYANGGoStruct 

func (*OnfApplication_Application_Application_Endpoint) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfApplication_Application_Application_Endpoint implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfApplication_Application_Application_Endpoint) Validate 

func (t *OnfApplication_Application_Application_Endpoint) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfApplication_Application_Application_Endpoint) ΛEnumTypeMap 

func (t *OnfApplication_Application_Application_Endpoint) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OnfApplication_Application_Application_Endpoint) ΛListKeyMap 

func (t *OnfApplication_Application_Application_Endpoint) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OnfApplication_Application_Application_Endpoint struct, which is a YANG list entry.

type OnfApplication_Application_Application_Endpoint_Mbr 

type OnfApplication_Application_Application_Endpoint_Mbr struct {
	Downlink *uint64 `path:"downlink" module:"onf-application"`
	Uplink   *uint64 `path:"uplink" module:"onf-application"`
}

OnfApplication_Application_Application_Endpoint_Mbr represents the /onf-application/application/application/endpoint/mbr YANG schema element.

func (*OnfApplication_Application_Application_Endpoint_Mbr) IsYANGGoStruct 

func (*OnfApplication_Application_Application_Endpoint_Mbr) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfApplication_Application_Application_Endpoint_Mbr implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfApplication_Application_Application_Endpoint_Mbr) Validate 

func (t *OnfApplication_Application_Application_Endpoint_Mbr) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfApplication_Application_Application_Endpoint_Mbr) ΛEnumTypeMap 

func (t *OnfApplication_Application_Application_Endpoint_Mbr) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OnfConnectivityService_ConnectivityService 

type OnfConnectivityService_ConnectivityService struct {
	ConnectivityService map[string]*OnfConnectivityService_ConnectivityService_ConnectivityService `path:"connectivity-service" module:"onf-connectivity-service"`
}

OnfConnectivityService_ConnectivityService represents the /onf-connectivity-service/connectivity-service YANG schema element.

func (*OnfConnectivityService_ConnectivityService) IsYANGGoStruct 

func (*OnfConnectivityService_ConnectivityService) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfConnectivityService_ConnectivityService implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfConnectivityService_ConnectivityService) NewConnectivityService 

func (t *OnfConnectivityService_ConnectivityService) NewConnectivityService(Id string) (*OnfConnectivityService_ConnectivityService_ConnectivityService, error)

NewConnectivityService creates a new entry in the ConnectivityService list of the OnfConnectivityService_ConnectivityService struct. The keys of the list are populated from the input arguments.

func (*OnfConnectivityService_ConnectivityService) Validate 

func (t *OnfConnectivityService_ConnectivityService) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfConnectivityService_ConnectivityService) ΛEnumTypeMap 

func (t *OnfConnectivityService_ConnectivityService) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OnfConnectivityService_ConnectivityService_ConnectivityService 

type OnfConnectivityService_ConnectivityService_ConnectivityService struct {
	AccPrometheusUrl *string `path:"acc-prometheus-url" module:"onf-connectivity-service"`
	Core_5GEndpoint  *string `path:"core-5g-endpoint" module:"onf-connectivity-service"`
	Description      *string `path:"description" module:"onf-connectivity-service"`
	DisplayName      *string `path:"display-name" module:"onf-connectivity-service"`
	Id               *string `path:"id" module:"onf-connectivity-service"`
}

OnfConnectivityService_ConnectivityService_ConnectivityService represents the /onf-connectivity-service/connectivity-service/connectivity-service YANG schema element.

func (*OnfConnectivityService_ConnectivityService_ConnectivityService) IsYANGGoStruct 

func (*OnfConnectivityService_ConnectivityService_ConnectivityService) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfConnectivityService_ConnectivityService_ConnectivityService implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfConnectivityService_ConnectivityService_ConnectivityService) Validate 

func (t *OnfConnectivityService_ConnectivityService_ConnectivityService) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfConnectivityService_ConnectivityService_ConnectivityService) ΛEnumTypeMap 

func (t *OnfConnectivityService_ConnectivityService_ConnectivityService) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OnfConnectivityService_ConnectivityService_ConnectivityService) ΛListKeyMap 

func (t *OnfConnectivityService_ConnectivityService_ConnectivityService) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OnfConnectivityService_ConnectivityService_ConnectivityService struct, which is a YANG list entry.

type OnfDeviceGroup_DeviceGroup 

type OnfDeviceGroup_DeviceGroup struct {
	DeviceGroup map[string]*OnfDeviceGroup_DeviceGroup_DeviceGroup `path:"device-group" module:"onf-device-group"`
}

OnfDeviceGroup_DeviceGroup represents the /onf-device-group/device-group YANG schema element.

func (*OnfDeviceGroup_DeviceGroup) IsYANGGoStruct 

func (*OnfDeviceGroup_DeviceGroup) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfDeviceGroup_DeviceGroup implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfDeviceGroup_DeviceGroup) NewDeviceGroup 

func (t *OnfDeviceGroup_DeviceGroup) NewDeviceGroup(Id string) (*OnfDeviceGroup_DeviceGroup_DeviceGroup, error)

NewDeviceGroup creates a new entry in the DeviceGroup list of the OnfDeviceGroup_DeviceGroup struct. The keys of the list are populated from the input arguments.

func (*OnfDeviceGroup_DeviceGroup) Validate 

func (t *OnfDeviceGroup_DeviceGroup) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfDeviceGroup_DeviceGroup) ΛEnumTypeMap 

func (t *OnfDeviceGroup_DeviceGroup) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OnfDeviceGroup_DeviceGroup_DeviceGroup 

type OnfDeviceGroup_DeviceGroup_DeviceGroup struct {
	Description *string                                                  `path:"description" module:"onf-device-group"`
	Device      *OnfDeviceGroup_DeviceGroup_DeviceGroup_Device           `path:"device" module:"onf-device-group"`
	DisplayName *string                                                  `path:"display-name" module:"onf-device-group"`
	Id          *string                                                  `path:"id" module:"onf-device-group"`
	Imsis       map[string]*OnfDeviceGroup_DeviceGroup_DeviceGroup_Imsis `path:"imsis" module:"onf-device-group"`
	IpDomain    *string                                                  `path:"ip-domain" module:"onf-device-group"`
	Site        *string                                                  `path:"site" module:"onf-device-group"`
}

OnfDeviceGroup_DeviceGroup_DeviceGroup represents the /onf-device-group/device-group/device-group YANG schema element.

func (*OnfDeviceGroup_DeviceGroup_DeviceGroup) IsYANGGoStruct 

func (*OnfDeviceGroup_DeviceGroup_DeviceGroup) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfDeviceGroup_DeviceGroup_DeviceGroup implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfDeviceGroup_DeviceGroup_DeviceGroup) NewImsis 

func (t *OnfDeviceGroup_DeviceGroup_DeviceGroup) NewImsis(ImsiId string) (*OnfDeviceGroup_DeviceGroup_DeviceGroup_Imsis, error)

NewImsis creates a new entry in the Imsis list of the OnfDeviceGroup_DeviceGroup_DeviceGroup struct. The keys of the list are populated from the input arguments.

func (*OnfDeviceGroup_DeviceGroup_DeviceGroup) Validate 

func (t *OnfDeviceGroup_DeviceGroup_DeviceGroup) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfDeviceGroup_DeviceGroup_DeviceGroup) ΛEnumTypeMap 

func (t *OnfDeviceGroup_DeviceGroup_DeviceGroup) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OnfDeviceGroup_DeviceGroup_DeviceGroup) ΛListKeyMap 

func (t *OnfDeviceGroup_DeviceGroup_DeviceGroup) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OnfDeviceGroup_DeviceGroup_DeviceGroup struct, which is a YANG list entry.

type OnfDeviceGroup_DeviceGroup_DeviceGroup_Device added in v0.8.3 

type OnfDeviceGroup_DeviceGroup_DeviceGroup_Device struct {
	Mbr          *OnfDeviceGroup_DeviceGroup_DeviceGroup_Device_Mbr `path:"mbr" module:"onf-device-group"`
	TrafficClass *string                                            `path:"traffic-class" module:"onf-device-group"`
}

OnfDeviceGroup_DeviceGroup_DeviceGroup_Device represents the /onf-device-group/device-group/device-group/device YANG schema element.

func (*OnfDeviceGroup_DeviceGroup_DeviceGroup_Device) IsYANGGoStruct added in v0.8.3 

func (*OnfDeviceGroup_DeviceGroup_DeviceGroup_Device) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfDeviceGroup_DeviceGroup_DeviceGroup_Device implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfDeviceGroup_DeviceGroup_DeviceGroup_Device) Validate added in v0.8.3 

func (t *OnfDeviceGroup_DeviceGroup_DeviceGroup_Device) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfDeviceGroup_DeviceGroup_DeviceGroup_Device) ΛEnumTypeMap added in v0.8.3 

func (t *OnfDeviceGroup_DeviceGroup_DeviceGroup_Device) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OnfDeviceGroup_DeviceGroup_DeviceGroup_Device_Mbr added in v0.8.3 

type OnfDeviceGroup_DeviceGroup_DeviceGroup_Device_Mbr struct {
	Downlink *uint64 `path:"downlink" module:"onf-device-group"`
	Uplink   *uint64 `path:"uplink" module:"onf-device-group"`
}

OnfDeviceGroup_DeviceGroup_DeviceGroup_Device_Mbr represents the /onf-device-group/device-group/device-group/device/mbr YANG schema element.

func (*OnfDeviceGroup_DeviceGroup_DeviceGroup_Device_Mbr) IsYANGGoStruct added in v0.8.3 

func (*OnfDeviceGroup_DeviceGroup_DeviceGroup_Device_Mbr) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfDeviceGroup_DeviceGroup_DeviceGroup_Device_Mbr implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfDeviceGroup_DeviceGroup_DeviceGroup_Device_Mbr) Validate added in v0.8.3 

func (t *OnfDeviceGroup_DeviceGroup_DeviceGroup_Device_Mbr) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfDeviceGroup_DeviceGroup_DeviceGroup_Device_Mbr) ΛEnumTypeMap added in v0.8.3 

func (t *OnfDeviceGroup_DeviceGroup_DeviceGroup_Device_Mbr) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OnfDeviceGroup_DeviceGroup_DeviceGroup_Imsis 

type OnfDeviceGroup_DeviceGroup_DeviceGroup_Imsis struct {
	DisplayName   *string `path:"display-name" module:"onf-device-group"`
	ImsiId        *string `path:"imsi-id" module:"onf-device-group"`
	ImsiRangeFrom *uint64 `path:"imsi-range-from" module:"onf-device-group"`
	ImsiRangeTo   *uint64 `path:"imsi-range-to" module:"onf-device-group"`
}

OnfDeviceGroup_DeviceGroup_DeviceGroup_Imsis represents the /onf-device-group/device-group/device-group/imsis YANG schema element.

func (*OnfDeviceGroup_DeviceGroup_DeviceGroup_Imsis) IsYANGGoStruct 

func (*OnfDeviceGroup_DeviceGroup_DeviceGroup_Imsis) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfDeviceGroup_DeviceGroup_DeviceGroup_Imsis implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfDeviceGroup_DeviceGroup_DeviceGroup_Imsis) Validate 

func (t *OnfDeviceGroup_DeviceGroup_DeviceGroup_Imsis) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfDeviceGroup_DeviceGroup_DeviceGroup_Imsis) ΛEnumTypeMap 

func (t *OnfDeviceGroup_DeviceGroup_DeviceGroup_Imsis) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OnfDeviceGroup_DeviceGroup_DeviceGroup_Imsis) ΛListKeyMap 

func (t *OnfDeviceGroup_DeviceGroup_DeviceGroup_Imsis) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OnfDeviceGroup_DeviceGroup_DeviceGroup_Imsis struct, which is a YANG list entry.

type OnfEnterprise_Enterprise 

type OnfEnterprise_Enterprise struct {
	Enterprise map[string]*OnfEnterprise_Enterprise_Enterprise `path:"enterprise" module:"onf-enterprise"`
}

OnfEnterprise_Enterprise represents the /onf-enterprise/enterprise YANG schema element.

func (*OnfEnterprise_Enterprise) IsYANGGoStruct 

func (*OnfEnterprise_Enterprise) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfEnterprise_Enterprise implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfEnterprise_Enterprise) NewEnterprise 

func (t *OnfEnterprise_Enterprise) NewEnterprise(Id string) (*OnfEnterprise_Enterprise_Enterprise, error)

NewEnterprise creates a new entry in the Enterprise list of the OnfEnterprise_Enterprise struct. The keys of the list are populated from the input arguments.

func (*OnfEnterprise_Enterprise) Validate 

func (t *OnfEnterprise_Enterprise) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfEnterprise_Enterprise) ΛEnumTypeMap 

func (t *OnfEnterprise_Enterprise) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OnfEnterprise_Enterprise_Enterprise 

type OnfEnterprise_Enterprise_Enterprise struct {
	ConnectivityService map[string]*OnfEnterprise_Enterprise_Enterprise_ConnectivityService `path:"connectivity-service" module:"onf-enterprise"`
	Description         *string                                                             `path:"description" module:"onf-enterprise"`
	DisplayName         *string                                                             `path:"display-name" module:"onf-enterprise"`
	Id                  *string                                                             `path:"id" module:"onf-enterprise"`
}

OnfEnterprise_Enterprise_Enterprise represents the /onf-enterprise/enterprise/enterprise YANG schema element.

func (*OnfEnterprise_Enterprise_Enterprise) IsYANGGoStruct 

func (*OnfEnterprise_Enterprise_Enterprise) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfEnterprise_Enterprise_Enterprise implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfEnterprise_Enterprise_Enterprise) NewConnectivityService 

func (t *OnfEnterprise_Enterprise_Enterprise) NewConnectivityService(ConnectivityService string) (*OnfEnterprise_Enterprise_Enterprise_ConnectivityService, error)

NewConnectivityService creates a new entry in the ConnectivityService list of the OnfEnterprise_Enterprise_Enterprise struct. The keys of the list are populated from the input arguments.

func (*OnfEnterprise_Enterprise_Enterprise) Validate 

func (t *OnfEnterprise_Enterprise_Enterprise) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfEnterprise_Enterprise_Enterprise) ΛEnumTypeMap 

func (t *OnfEnterprise_Enterprise_Enterprise) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OnfEnterprise_Enterprise_Enterprise) ΛListKeyMap 

func (t *OnfEnterprise_Enterprise_Enterprise) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OnfEnterprise_Enterprise_Enterprise struct, which is a YANG list entry.

type OnfEnterprise_Enterprise_Enterprise_ConnectivityService 

type OnfEnterprise_Enterprise_Enterprise_ConnectivityService struct {
	ConnectivityService *string `path:"connectivity-service" module:"onf-enterprise"`
	Enabled             *bool   `path:"enabled" module:"onf-enterprise"`
}

OnfEnterprise_Enterprise_Enterprise_ConnectivityService represents the /onf-enterprise/enterprise/enterprise/connectivity-service YANG schema element.

func (*OnfEnterprise_Enterprise_Enterprise_ConnectivityService) IsYANGGoStruct 

func (*OnfEnterprise_Enterprise_Enterprise_ConnectivityService) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfEnterprise_Enterprise_Enterprise_ConnectivityService implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfEnterprise_Enterprise_Enterprise_ConnectivityService) Validate 

func (t *OnfEnterprise_Enterprise_Enterprise_ConnectivityService) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfEnterprise_Enterprise_Enterprise_ConnectivityService) ΛEnumTypeMap 

func (t *OnfEnterprise_Enterprise_Enterprise_ConnectivityService) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OnfEnterprise_Enterprise_Enterprise_ConnectivityService) ΛListKeyMap 

func (t *OnfEnterprise_Enterprise_Enterprise_ConnectivityService) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OnfEnterprise_Enterprise_Enterprise_ConnectivityService struct, which is a YANG list entry.

type OnfIpDomain_IpDomain 

type OnfIpDomain_IpDomain struct {
	IpDomain map[string]*OnfIpDomain_IpDomain_IpDomain `path:"ip-domain" module:"onf-ip-domain"`
}

OnfIpDomain_IpDomain represents the /onf-ip-domain/ip-domain YANG schema element.

func (*OnfIpDomain_IpDomain) IsYANGGoStruct 

func (*OnfIpDomain_IpDomain) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfIpDomain_IpDomain implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfIpDomain_IpDomain) NewIpDomain 

func (t *OnfIpDomain_IpDomain) NewIpDomain(Id string) (*OnfIpDomain_IpDomain_IpDomain, error)

NewIpDomain creates a new entry in the IpDomain list of the OnfIpDomain_IpDomain struct. The keys of the list are populated from the input arguments.

func (*OnfIpDomain_IpDomain) Validate 

func (t *OnfIpDomain_IpDomain) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfIpDomain_IpDomain) ΛEnumTypeMap 

func (t *OnfIpDomain_IpDomain) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OnfIpDomain_IpDomain_IpDomain 

type OnfIpDomain_IpDomain_IpDomain struct {
	AdminStatus  *string `path:"admin-status" module:"onf-ip-domain"`
	Description  *string `path:"description" module:"onf-ip-domain"`
	DisplayName  *string `path:"display-name" module:"onf-ip-domain"`
	Dnn          *string `path:"dnn" module:"onf-ip-domain"`
	DnsPrimary   *string `path:"dns-primary" module:"onf-ip-domain"`
	DnsSecondary *string `path:"dns-secondary" module:"onf-ip-domain"`
	Enterprise   *string `path:"enterprise" module:"onf-ip-domain"`
	Id           *string `path:"id" module:"onf-ip-domain"`
	Mtu          *uint16 `path:"mtu" module:"onf-ip-domain"`
	Subnet       *string `path:"subnet" module:"onf-ip-domain"`
}

OnfIpDomain_IpDomain_IpDomain represents the /onf-ip-domain/ip-domain/ip-domain YANG schema element.

func (*OnfIpDomain_IpDomain_IpDomain) IsYANGGoStruct 

func (*OnfIpDomain_IpDomain_IpDomain) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfIpDomain_IpDomain_IpDomain implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfIpDomain_IpDomain_IpDomain) Validate 

func (t *OnfIpDomain_IpDomain_IpDomain) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfIpDomain_IpDomain_IpDomain) ΛEnumTypeMap 

func (t *OnfIpDomain_IpDomain_IpDomain) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OnfIpDomain_IpDomain_IpDomain) ΛListKeyMap 

func (t *OnfIpDomain_IpDomain_IpDomain) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OnfIpDomain_IpDomain_IpDomain struct, which is a YANG list entry.

type OnfSite_Site 

type OnfSite_Site struct {
	Site map[string]*OnfSite_Site_Site `path:"site" module:"onf-site"`
}

OnfSite_Site represents the /onf-site/site YANG schema element.

func (*OnfSite_Site) IsYANGGoStruct 

func (*OnfSite_Site) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfSite_Site implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfSite_Site) NewSite 

func (t *OnfSite_Site) NewSite(Id string) (*OnfSite_Site_Site, error)

NewSite creates a new entry in the Site list of the OnfSite_Site struct. The keys of the list are populated from the input arguments.

func (*OnfSite_Site) Validate 

func (t *OnfSite_Site) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfSite_Site) ΛEnumTypeMap 

func (t *OnfSite_Site) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OnfSite_Site_Site 

type OnfSite_Site_Site struct {
	Description    *string                                 `path:"description" module:"onf-site"`
	DisplayName    *string                                 `path:"display-name" module:"onf-site"`
	Enterprise     *string                                 `path:"enterprise" module:"onf-site"`
	Id             *string                                 `path:"id" module:"onf-site"`
	ImsiDefinition *OnfSite_Site_Site_ImsiDefinition       `path:"imsi-definition" module:"onf-site"`
	Monitoring     *OnfSite_Site_Site_Monitoring           `path:"monitoring" module:"onf-site"`
	SmallCell      map[string]*OnfSite_Site_Site_SmallCell `path:"small-cell" module:"onf-site"`
}

OnfSite_Site_Site represents the /onf-site/site/site YANG schema element.

func (*OnfSite_Site_Site) IsYANGGoStruct 

func (*OnfSite_Site_Site) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfSite_Site_Site implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfSite_Site_Site) NewSmallCell 

func (t *OnfSite_Site_Site) NewSmallCell(SmallCellId string) (*OnfSite_Site_Site_SmallCell, error)

NewSmallCell creates a new entry in the SmallCell list of the OnfSite_Site_Site struct. The keys of the list are populated from the input arguments.

func (*OnfSite_Site_Site) Validate 

func (t *OnfSite_Site_Site) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfSite_Site_Site) ΛEnumTypeMap 

func (t *OnfSite_Site_Site) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OnfSite_Site_Site) ΛListKeyMap 

func (t *OnfSite_Site_Site) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OnfSite_Site_Site struct, which is a YANG list entry.

type OnfSite_Site_Site_ImsiDefinition 

type OnfSite_Site_Site_ImsiDefinition struct {
	Enterprise *uint32 `path:"enterprise" module:"onf-site"`
	Format     *string `path:"format" module:"onf-site"`
	Mcc        *string `path:"mcc" module:"onf-site"`
	Mnc        *string `path:"mnc" module:"onf-site"`
}

OnfSite_Site_Site_ImsiDefinition represents the /onf-site/site/site/imsi-definition YANG schema element.

func (*OnfSite_Site_Site_ImsiDefinition) IsYANGGoStruct 

func (*OnfSite_Site_Site_ImsiDefinition) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfSite_Site_Site_ImsiDefinition implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfSite_Site_Site_ImsiDefinition) Validate 

func (t *OnfSite_Site_Site_ImsiDefinition) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfSite_Site_Site_ImsiDefinition) ΛEnumTypeMap 

func (t *OnfSite_Site_Site_ImsiDefinition) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OnfSite_Site_Site_Monitoring added in v0.8.2 

type OnfSite_Site_Site_Monitoring struct {
	EdgeClusterPrometheusUrl    *string                                             `path:"edge-cluster-prometheus-url" module:"onf-site"`
	EdgeDevice                  map[string]*OnfSite_Site_Site_Monitoring_EdgeDevice `path:"edge-device" module:"onf-site"`
	EdgeMonitoringPrometheusUrl *string                                             `path:"edge-monitoring-prometheus-url" module:"onf-site"`
}

OnfSite_Site_Site_Monitoring represents the /onf-site/site/site/monitoring YANG schema element.

func (*OnfSite_Site_Site_Monitoring) IsYANGGoStruct added in v0.8.2 

func (*OnfSite_Site_Site_Monitoring) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfSite_Site_Site_Monitoring implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfSite_Site_Site_Monitoring) NewEdgeDevice added in v0.8.2 

func (t *OnfSite_Site_Site_Monitoring) NewEdgeDevice(EdgeDeviceId string) (*OnfSite_Site_Site_Monitoring_EdgeDevice, error)

NewEdgeDevice creates a new entry in the EdgeDevice list of the OnfSite_Site_Site_Monitoring struct. The keys of the list are populated from the input arguments.

func (*OnfSite_Site_Site_Monitoring) Validate added in v0.8.2 

func (t *OnfSite_Site_Site_Monitoring) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfSite_Site_Site_Monitoring) ΛEnumTypeMap added in v0.8.2 

func (t *OnfSite_Site_Site_Monitoring) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OnfSite_Site_Site_Monitoring_EdgeDevice added in v0.8.2 

type OnfSite_Site_Site_Monitoring_EdgeDevice struct {
	Description  *string `path:"description" module:"onf-site"`
	DisplayName  *string `path:"display-name" module:"onf-site"`
	EdgeDeviceId *string `path:"edge-device-id" module:"onf-site"`
}

OnfSite_Site_Site_Monitoring_EdgeDevice represents the /onf-site/site/site/monitoring/edge-device YANG schema element.

func (*OnfSite_Site_Site_Monitoring_EdgeDevice) IsYANGGoStruct added in v0.8.2 

func (*OnfSite_Site_Site_Monitoring_EdgeDevice) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfSite_Site_Site_Monitoring_EdgeDevice implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfSite_Site_Site_Monitoring_EdgeDevice) Validate added in v0.8.2 

func (t *OnfSite_Site_Site_Monitoring_EdgeDevice) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfSite_Site_Site_Monitoring_EdgeDevice) ΛEnumTypeMap added in v0.8.2 

func (t *OnfSite_Site_Site_Monitoring_EdgeDevice) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OnfSite_Site_Site_Monitoring_EdgeDevice) ΛListKeyMap added in v0.8.2 

func (t *OnfSite_Site_Site_Monitoring_EdgeDevice) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OnfSite_Site_Site_Monitoring_EdgeDevice struct, which is a YANG list entry.

type OnfSite_Site_Site_SmallCell 

type OnfSite_Site_Site_SmallCell struct {
	Address     *string `path:"address" module:"onf-site"`
	DisplayName *string `path:"display-name" module:"onf-site"`
	Enable      *bool   `path:"enable" module:"onf-site"`
	SmallCellId *string `path:"small-cell-id" module:"onf-site"`
	Tac         *string `path:"tac" module:"onf-site"`
}

OnfSite_Site_Site_SmallCell represents the /onf-site/site/site/small-cell YANG schema element.

func (*OnfSite_Site_Site_SmallCell) IsYANGGoStruct 

func (*OnfSite_Site_Site_SmallCell) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfSite_Site_Site_SmallCell implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfSite_Site_Site_SmallCell) Validate 

func (t *OnfSite_Site_Site_SmallCell) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfSite_Site_Site_SmallCell) ΛEnumTypeMap 

func (t *OnfSite_Site_Site_SmallCell) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OnfSite_Site_Site_SmallCell) ΛListKeyMap 

func (t *OnfSite_Site_Site_SmallCell) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OnfSite_Site_Site_SmallCell struct, which is a YANG list entry.

type OnfTemplate_Template 

type OnfTemplate_Template struct {
	Template map[string]*OnfTemplate_Template_Template `path:"template" module:"onf-template"`
}

OnfTemplate_Template represents the /onf-template/template YANG schema element.

func (*OnfTemplate_Template) IsYANGGoStruct 

func (*OnfTemplate_Template) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfTemplate_Template implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfTemplate_Template) NewTemplate 

func (t *OnfTemplate_Template) NewTemplate(Id string) (*OnfTemplate_Template_Template, error)

NewTemplate creates a new entry in the Template list of the OnfTemplate_Template struct. The keys of the list are populated from the input arguments.

func (*OnfTemplate_Template) Validate 

func (t *OnfTemplate_Template) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfTemplate_Template) ΛEnumTypeMap 

func (t *OnfTemplate_Template) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OnfTemplate_Template_Template 

type OnfTemplate_Template_Template struct {
	DefaultBehavior *string                              `path:"default-behavior" module:"onf-template"`
	Description     *string                              `path:"description" module:"onf-template"`
	DisplayName     *string                              `path:"display-name" module:"onf-template"`
	Id              *string                              `path:"id" module:"onf-template"`
	Sd              *uint32                              `path:"sd" module:"onf-template"`
	Slice           *OnfTemplate_Template_Template_Slice `path:"slice" module:"onf-template"`
	Sst             *uint8                               `path:"sst" module:"onf-template"`
}

OnfTemplate_Template_Template represents the /onf-template/template/template YANG schema element.

func (*OnfTemplate_Template_Template) IsYANGGoStruct 

func (*OnfTemplate_Template_Template) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfTemplate_Template_Template implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfTemplate_Template_Template) Validate 

func (t *OnfTemplate_Template_Template) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfTemplate_Template_Template) ΛEnumTypeMap 

func (t *OnfTemplate_Template_Template) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OnfTemplate_Template_Template) ΛListKeyMap 

func (t *OnfTemplate_Template_Template) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OnfTemplate_Template_Template struct, which is a YANG list entry.

type OnfTemplate_Template_Template_Slice 

type OnfTemplate_Template_Template_Slice struct {
	Mbr *OnfTemplate_Template_Template_Slice_Mbr `path:"mbr" module:"onf-template"`
}

OnfTemplate_Template_Template_Slice represents the /onf-template/template/template/slice YANG schema element.

func (*OnfTemplate_Template_Template_Slice) IsYANGGoStruct 

func (*OnfTemplate_Template_Template_Slice) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfTemplate_Template_Template_Slice implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfTemplate_Template_Template_Slice) Validate 

func (t *OnfTemplate_Template_Template_Slice) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfTemplate_Template_Template_Slice) ΛEnumTypeMap 

func (t *OnfTemplate_Template_Template_Slice) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OnfTemplate_Template_Template_Slice_Mbr 

type OnfTemplate_Template_Template_Slice_Mbr struct {
	Downlink          *uint64 `path:"downlink" module:"onf-template"`
	DownlinkBurstSize *uint32 `path:"downlink-burst-size" module:"onf-template"`
	Uplink            *uint64 `path:"uplink" module:"onf-template"`
	UplinkBurstSize   *uint32 `path:"uplink-burst-size" module:"onf-template"`
}

OnfTemplate_Template_Template_Slice_Mbr represents the /onf-template/template/template/slice/mbr YANG schema element.

func (*OnfTemplate_Template_Template_Slice_Mbr) IsYANGGoStruct 

func (*OnfTemplate_Template_Template_Slice_Mbr) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfTemplate_Template_Template_Slice_Mbr implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfTemplate_Template_Template_Slice_Mbr) Validate 

func (t *OnfTemplate_Template_Template_Slice_Mbr) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfTemplate_Template_Template_Slice_Mbr) ΛEnumTypeMap 

func (t *OnfTemplate_Template_Template_Slice_Mbr) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OnfTrafficClass_TrafficClass 

type OnfTrafficClass_TrafficClass struct {
	TrafficClass map[string]*OnfTrafficClass_TrafficClass_TrafficClass `path:"traffic-class" module:"onf-traffic-class"`
}

OnfTrafficClass_TrafficClass represents the /onf-traffic-class/traffic-class YANG schema element.

func (*OnfTrafficClass_TrafficClass) IsYANGGoStruct 

func (*OnfTrafficClass_TrafficClass) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfTrafficClass_TrafficClass implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfTrafficClass_TrafficClass) NewTrafficClass 

func (t *OnfTrafficClass_TrafficClass) NewTrafficClass(Id string) (*OnfTrafficClass_TrafficClass_TrafficClass, error)

NewTrafficClass creates a new entry in the TrafficClass list of the OnfTrafficClass_TrafficClass struct. The keys of the list are populated from the input arguments.

func (*OnfTrafficClass_TrafficClass) Validate 

func (t *OnfTrafficClass_TrafficClass) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfTrafficClass_TrafficClass) ΛEnumTypeMap 

func (t *OnfTrafficClass_TrafficClass) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OnfTrafficClass_TrafficClass_TrafficClass 

type OnfTrafficClass_TrafficClass_TrafficClass struct {
	Arp         *uint8  `path:"arp" module:"onf-traffic-class"`
	Description *string `path:"description" module:"onf-traffic-class"`
	DisplayName *string `path:"display-name" module:"onf-traffic-class"`
	Id          *string `path:"id" module:"onf-traffic-class"`
	Pdb         *uint16 `path:"pdb" module:"onf-traffic-class"`
	Pelr        *int8   `path:"pelr" module:"onf-traffic-class"`
	Qci         *uint8  `path:"qci" module:"onf-traffic-class"`
}

OnfTrafficClass_TrafficClass_TrafficClass represents the /onf-traffic-class/traffic-class/traffic-class YANG schema element.

func (*OnfTrafficClass_TrafficClass_TrafficClass) IsYANGGoStruct 

func (*OnfTrafficClass_TrafficClass_TrafficClass) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfTrafficClass_TrafficClass_TrafficClass implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfTrafficClass_TrafficClass_TrafficClass) Validate 

func (t *OnfTrafficClass_TrafficClass_TrafficClass) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfTrafficClass_TrafficClass_TrafficClass) ΛEnumTypeMap 

func (t *OnfTrafficClass_TrafficClass_TrafficClass) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OnfTrafficClass_TrafficClass_TrafficClass) ΛListKeyMap 

func (t *OnfTrafficClass_TrafficClass_TrafficClass) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OnfTrafficClass_TrafficClass_TrafficClass struct, which is a YANG list entry.

type OnfUpf_Upf 

type OnfUpf_Upf struct {
	Upf map[string]*OnfUpf_Upf_Upf `path:"upf" module:"onf-upf"`
}

OnfUpf_Upf represents the /onf-upf/upf YANG schema element.

func (*OnfUpf_Upf) IsYANGGoStruct 

func (*OnfUpf_Upf) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfUpf_Upf implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfUpf_Upf) NewUpf 

func (t *OnfUpf_Upf) NewUpf(Id string) (*OnfUpf_Upf_Upf, error)

NewUpf creates a new entry in the Upf list of the OnfUpf_Upf struct. The keys of the list are populated from the input arguments.

func (*OnfUpf_Upf) Validate 

func (t *OnfUpf_Upf) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfUpf_Upf) ΛEnumTypeMap 

func (t *OnfUpf_Upf) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OnfUpf_Upf_Upf 

type OnfUpf_Upf_Upf struct {
	Address        *string `path:"address" module:"onf-upf"`
	ConfigEndpoint *string `path:"config-endpoint" module:"onf-upf"`
	Description    *string `path:"description" module:"onf-upf"`
	DisplayName    *string `path:"display-name" module:"onf-upf"`
	Enterprise     *string `path:"enterprise" module:"onf-upf"`
	Id             *string `path:"id" module:"onf-upf"`
	Port           *uint16 `path:"port" module:"onf-upf"`
	Site           *string `path:"site" module:"onf-upf"`
}

OnfUpf_Upf_Upf represents the /onf-upf/upf/upf YANG schema element.

func (*OnfUpf_Upf_Upf) IsYANGGoStruct 

func (*OnfUpf_Upf_Upf) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfUpf_Upf_Upf implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfUpf_Upf_Upf) Validate 

func (t *OnfUpf_Upf_Upf) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfUpf_Upf_Upf) ΛEnumTypeMap 

func (t *OnfUpf_Upf_Upf) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OnfUpf_Upf_Upf) ΛListKeyMap 

func (t *OnfUpf_Upf_Upf) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OnfUpf_Upf_Upf struct, which is a YANG list entry.

type OnfVcs_Vcs 

type OnfVcs_Vcs struct {
	Vcs map[string]*OnfVcs_Vcs_Vcs `path:"vcs" module:"onf-vcs"`
}

OnfVcs_Vcs represents the /onf-vcs/vcs YANG schema element.

func (*OnfVcs_Vcs) IsYANGGoStruct 

func (*OnfVcs_Vcs) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfVcs_Vcs implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfVcs_Vcs) NewVcs 

func (t *OnfVcs_Vcs) NewVcs(Id string) (*OnfVcs_Vcs_Vcs, error)

NewVcs creates a new entry in the Vcs list of the OnfVcs_Vcs struct. The keys of the list are populated from the input arguments.

func (*OnfVcs_Vcs) Validate 

func (t *OnfVcs_Vcs) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfVcs_Vcs) ΛEnumTypeMap 

func (t *OnfVcs_Vcs) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OnfVcs_Vcs_Vcs 

type OnfVcs_Vcs_Vcs struct {
	DefaultBehavior *string                                `path:"default-behavior" module:"onf-vcs"`
	Description     *string                                `path:"description" module:"onf-vcs"`
	DeviceGroup     map[string]*OnfVcs_Vcs_Vcs_DeviceGroup `path:"device-group" module:"onf-vcs"`
	DisplayName     *string                                `path:"display-name" module:"onf-vcs"`
	Enterprise      *string                                `path:"enterprise" module:"onf-vcs"`
	Filter          map[string]*OnfVcs_Vcs_Vcs_Filter      `path:"filter" module:"onf-vcs"`
	Id              *string                                `path:"id" module:"onf-vcs"`
	Sd              *uint32                                `path:"sd" module:"onf-vcs"`
	Site            *string                                `path:"site" module:"onf-vcs"`
	Slice           *OnfVcs_Vcs_Vcs_Slice                  `path:"slice" module:"onf-vcs"`
	Sst             *uint8                                 `path:"sst" module:"onf-vcs"`
	Upf             *string                                `path:"upf" module:"onf-vcs"`
}

OnfVcs_Vcs_Vcs represents the /onf-vcs/vcs/vcs YANG schema element.

func (*OnfVcs_Vcs_Vcs) IsYANGGoStruct 

func (*OnfVcs_Vcs_Vcs) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfVcs_Vcs_Vcs implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfVcs_Vcs_Vcs) NewDeviceGroup 

func (t *OnfVcs_Vcs_Vcs) NewDeviceGroup(DeviceGroup string) (*OnfVcs_Vcs_Vcs_DeviceGroup, error)

NewDeviceGroup creates a new entry in the DeviceGroup list of the OnfVcs_Vcs_Vcs struct. The keys of the list are populated from the input arguments.

func (*OnfVcs_Vcs_Vcs) NewFilter 

func (t *OnfVcs_Vcs_Vcs) NewFilter(Application string) (*OnfVcs_Vcs_Vcs_Filter, error)

NewFilter creates a new entry in the Filter list of the OnfVcs_Vcs_Vcs struct. The keys of the list are populated from the input arguments.

func (*OnfVcs_Vcs_Vcs) Validate 

func (t *OnfVcs_Vcs_Vcs) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfVcs_Vcs_Vcs) ΛEnumTypeMap 

func (t *OnfVcs_Vcs_Vcs) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OnfVcs_Vcs_Vcs) ΛListKeyMap 

func (t *OnfVcs_Vcs_Vcs) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OnfVcs_Vcs_Vcs struct, which is a YANG list entry.

type OnfVcs_Vcs_Vcs_DeviceGroup 

type OnfVcs_Vcs_Vcs_DeviceGroup struct {
	DeviceGroup *string `path:"device-group" module:"onf-vcs"`
	Enable      *bool   `path:"enable" module:"onf-vcs"`
}

OnfVcs_Vcs_Vcs_DeviceGroup represents the /onf-vcs/vcs/vcs/device-group YANG schema element.

func (*OnfVcs_Vcs_Vcs_DeviceGroup) IsYANGGoStruct 

func (*OnfVcs_Vcs_Vcs_DeviceGroup) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfVcs_Vcs_Vcs_DeviceGroup implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfVcs_Vcs_Vcs_DeviceGroup) Validate 

func (t *OnfVcs_Vcs_Vcs_DeviceGroup) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfVcs_Vcs_Vcs_DeviceGroup) ΛEnumTypeMap 

func (t *OnfVcs_Vcs_Vcs_DeviceGroup) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OnfVcs_Vcs_Vcs_DeviceGroup) ΛListKeyMap 

func (t *OnfVcs_Vcs_Vcs_DeviceGroup) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OnfVcs_Vcs_Vcs_DeviceGroup struct, which is a YANG list entry.

type OnfVcs_Vcs_Vcs_Filter 

type OnfVcs_Vcs_Vcs_Filter struct {
	Allow       *bool   `path:"allow" module:"onf-vcs"`
	Application *string `path:"application" module:"onf-vcs"`
	Priority    *uint8  `path:"priority" module:"onf-vcs"`
}

OnfVcs_Vcs_Vcs_Filter represents the /onf-vcs/vcs/vcs/filter YANG schema element.

func (*OnfVcs_Vcs_Vcs_Filter) IsYANGGoStruct 

func (*OnfVcs_Vcs_Vcs_Filter) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfVcs_Vcs_Vcs_Filter implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfVcs_Vcs_Vcs_Filter) Validate 

func (t *OnfVcs_Vcs_Vcs_Filter) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfVcs_Vcs_Vcs_Filter) ΛEnumTypeMap 

func (t *OnfVcs_Vcs_Vcs_Filter) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

func (*OnfVcs_Vcs_Vcs_Filter) ΛListKeyMap 

func (t *OnfVcs_Vcs_Vcs_Filter) ΛListKeyMap() (map[string]interface{}, error)

ΛListKeyMap returns the keys of the OnfVcs_Vcs_Vcs_Filter struct, which is a YANG list entry.

type OnfVcs_Vcs_Vcs_Slice 

type OnfVcs_Vcs_Vcs_Slice struct {
	Mbr *OnfVcs_Vcs_Vcs_Slice_Mbr `path:"mbr" module:"onf-vcs"`
}

OnfVcs_Vcs_Vcs_Slice represents the /onf-vcs/vcs/vcs/slice YANG schema element.

func (*OnfVcs_Vcs_Vcs_Slice) IsYANGGoStruct 

func (*OnfVcs_Vcs_Vcs_Slice) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfVcs_Vcs_Vcs_Slice implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfVcs_Vcs_Vcs_Slice) Validate 

func (t *OnfVcs_Vcs_Vcs_Slice) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfVcs_Vcs_Vcs_Slice) ΛEnumTypeMap 

func (t *OnfVcs_Vcs_Vcs_Slice) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type OnfVcs_Vcs_Vcs_Slice_Mbr 

type OnfVcs_Vcs_Vcs_Slice_Mbr struct {
	Downlink          *uint64 `path:"downlink" module:"onf-vcs"`
	DownlinkBurstSize *uint32 `path:"downlink-burst-size" module:"onf-vcs"`
	Uplink            *uint64 `path:"uplink" module:"onf-vcs"`
	UplinkBurstSize   *uint32 `path:"uplink-burst-size" module:"onf-vcs"`
}

OnfVcs_Vcs_Vcs_Slice_Mbr represents the /onf-vcs/vcs/vcs/slice/mbr YANG schema element.

func (*OnfVcs_Vcs_Vcs_Slice_Mbr) IsYANGGoStruct 

func (*OnfVcs_Vcs_Vcs_Slice_Mbr) IsYANGGoStruct()

IsYANGGoStruct ensures that OnfVcs_Vcs_Vcs_Slice_Mbr implements the yang.GoStruct interface. This allows functions that need to handle this struct to identify it as being generated by ygen.

func (*OnfVcs_Vcs_Vcs_Slice_Mbr) Validate 

func (t *OnfVcs_Vcs_Vcs_Slice_Mbr) Validate(opts ...ygot.ValidationOption) error

Validate validates s against the YANG schema corresponding to its type.

func (*OnfVcs_Vcs_Vcs_Slice_Mbr) ΛEnumTypeMap 

func (t *OnfVcs_Vcs_Vcs_Slice_Mbr) ΛEnumTypeMap() map[string][]reflect.Type

ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types that are included in the generated code.

type YANGEmpty 

type YANGEmpty bool

YANGEmpty is a type that is used for fields that have a YANG type of empty. It is used such that empty fields can be distinguished from boolean fields in the generated code.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.