aether_3_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: 2

Documentation

Overview

Code generated by YGOT. DO NOT EDIT.

Package aether_3_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.12.0/genutil/names.go using the following YANG input files:

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

Imported modules were sourced from:

  • ../../../sdran-helm-charts/config-models/aether-3.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 ApList_ApList 

type ApList_ApList struct {
	ApList map[string]*ApList_ApList_ApList `path:"ap-list" module:"ap-list"`
}

ApList_ApList represents the /ap-list/ap-list YANG schema element.

func (*ApList_ApList) IsYANGGoStruct 

func (*ApList_ApList) IsYANGGoStruct()

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

func (*ApList_ApList) NewApList 

func (t *ApList_ApList) NewApList(Id string) (*ApList_ApList_ApList, error)

NewApList creates a new entry in the ApList list of the ApList_ApList struct. The keys of the list are populated from the input arguments.

func (*ApList_ApList) Validate 

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

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

func (*ApList_ApList) ΛEnumTypeMap 

func (t *ApList_ApList) Λ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 ApList_ApList_ApList 

type ApList_ApList_ApList struct {
	AccessPoints map[string]*ApList_ApList_ApList_AccessPoints `path:"access-points" module:"ap-list"`
	Description  *string                                       `path:"description" module:"ap-list"`
	DisplayName  *string                                       `path:"display-name" module:"ap-list"`
	Enterprise   *string                                       `path:"enterprise" module:"ap-list"`
	Id           *string                                       `path:"id" module:"ap-list"`
}

ApList_ApList_ApList represents the /ap-list/ap-list/ap-list YANG schema element.

func (*ApList_ApList_ApList) IsYANGGoStruct 

func (*ApList_ApList_ApList) IsYANGGoStruct()

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

func (*ApList_ApList_ApList) NewAccessPoints 

func (t *ApList_ApList_ApList) NewAccessPoints(Address string) (*ApList_ApList_ApList_AccessPoints, error)

NewAccessPoints creates a new entry in the AccessPoints list of the ApList_ApList_ApList struct. The keys of the list are populated from the input arguments.

func (*ApList_ApList_ApList) Validate 

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

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

func (*ApList_ApList_ApList) ΛEnumTypeMap 

func (t *ApList_ApList_ApList) Λ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 (*ApList_ApList_ApList) ΛListKeyMap 

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

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

type ApList_ApList_ApList_AccessPoints 

type ApList_ApList_ApList_AccessPoints struct {
	Address *string `path:"address" module:"ap-list"`
	Enable  *bool   `path:"enable" module:"ap-list"`
	Tac     *string `path:"tac" module:"ap-list"`
}

ApList_ApList_ApList_AccessPoints represents the /ap-list/ap-list/ap-list/access-points YANG schema element.

func (*ApList_ApList_ApList_AccessPoints) IsYANGGoStruct 

func (*ApList_ApList_ApList_AccessPoints) IsYANGGoStruct()

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

func (*ApList_ApList_ApList_AccessPoints) Validate 

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

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

func (*ApList_ApList_ApList_AccessPoints) ΛEnumTypeMap 

func (t *ApList_ApList_ApList_AccessPoints) Λ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 (*ApList_ApList_ApList_AccessPoints) ΛListKeyMap 

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

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

type Application_Application 

type Application_Application struct {
	Application map[string]*Application_Application_Application `path:"application" module:"application"`
}

Application_Application represents the /application/application YANG schema element.

func (*Application_Application) IsYANGGoStruct 

func (*Application_Application) IsYANGGoStruct()

IsYANGGoStruct ensures that 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 (*Application_Application) NewApplication 

func (t *Application_Application) NewApplication(Id string) (*Application_Application_Application, error)

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

func (*Application_Application) Validate 

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

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

func (*Application_Application) ΛEnumTypeMap 

func (t *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.

type Application_Application_Application 

type Application_Application_Application struct {
	Description *string                                                  `path:"description" module:"application"`
	DisplayName *string                                                  `path:"display-name" module:"application"`
	Endpoint    map[string]*Application_Application_Application_Endpoint `path:"endpoint" module:"application"`
	Enterprise  *string                                                  `path:"enterprise" module:"application"`
	Id          *string                                                  `path:"id" module:"application"`
}

Application_Application_Application represents the /application/application/application YANG schema element.

func (*Application_Application_Application) IsYANGGoStruct 

func (*Application_Application_Application) IsYANGGoStruct()

IsYANGGoStruct ensures that Application_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 (*Application_Application_Application) NewEndpoint 

func (t *Application_Application_Application) NewEndpoint(Name string) (*Application_Application_Application_Endpoint, error)

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

func (*Application_Application_Application) Validate 

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

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

func (*Application_Application_Application) ΛEnumTypeMap 

func (t *Application_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 (*Application_Application_Application) ΛListKeyMap 

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

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

type Application_Application_Application_Endpoint 

type Application_Application_Application_Endpoint struct {
	Address   *string `path:"address" module:"application"`
	Name      *string `path:"name" module:"application"`
	PortEnd   *uint16 `path:"port-end" module:"application"`
	PortStart *uint16 `path:"port-start" module:"application"`
	Protocol  *string `path:"protocol" module:"application"`
}

Application_Application_Application_Endpoint represents the /application/application/application/endpoint YANG schema element.

func (*Application_Application_Application_Endpoint) IsYANGGoStruct 

func (*Application_Application_Application_Endpoint) IsYANGGoStruct()

IsYANGGoStruct ensures that Application_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 (*Application_Application_Application_Endpoint) Validate 

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

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

func (*Application_Application_Application_Endpoint) ΛEnumTypeMap 

func (t *Application_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 (*Application_Application_Application_Endpoint) ΛListKeyMap 

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

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

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 ConnectivityService_ConnectivityService 

type ConnectivityService_ConnectivityService struct {
	ConnectivityService map[string]*ConnectivityService_ConnectivityService_ConnectivityService `path:"connectivity-service" module:"connectivity-service"`
}

ConnectivityService_ConnectivityService represents the /connectivity-service/connectivity-service YANG schema element.

func (*ConnectivityService_ConnectivityService) IsYANGGoStruct 

func (*ConnectivityService_ConnectivityService) IsYANGGoStruct()

IsYANGGoStruct ensures that 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 (*ConnectivityService_ConnectivityService) NewConnectivityService 

func (t *ConnectivityService_ConnectivityService) NewConnectivityService(Id string) (*ConnectivityService_ConnectivityService_ConnectivityService, error)

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

func (*ConnectivityService_ConnectivityService) Validate 

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

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

func (*ConnectivityService_ConnectivityService) ΛEnumTypeMap 

func (t *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.

type ConnectivityService_ConnectivityService_ConnectivityService 

type ConnectivityService_ConnectivityService_ConnectivityService struct {
	Core_5GEndpoint *string `path:"core-5g-endpoint" module:"connectivity-service"`
	Description     *string `path:"description" module:"connectivity-service"`
	DisplayName     *string `path:"display-name" module:"connectivity-service"`
	HssEndpoint     *string `path:"hss-endpoint" module:"connectivity-service"`
	Id              *string `path:"id" module:"connectivity-service"`
	PcrfEndpoint    *string `path:"pcrf-endpoint" module:"connectivity-service"`
	SpgwcEndpoint   *string `path:"spgwc-endpoint" module:"connectivity-service"`
}

ConnectivityService_ConnectivityService_ConnectivityService represents the /connectivity-service/connectivity-service/connectivity-service YANG schema element.

func (*ConnectivityService_ConnectivityService_ConnectivityService) IsYANGGoStruct 

func (*ConnectivityService_ConnectivityService_ConnectivityService) IsYANGGoStruct()

IsYANGGoStruct ensures that ConnectivityService_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 (*ConnectivityService_ConnectivityService_ConnectivityService) Validate 

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

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

func (*ConnectivityService_ConnectivityService_ConnectivityService) ΛEnumTypeMap 

func (t *ConnectivityService_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 (*ConnectivityService_ConnectivityService_ConnectivityService) ΛListKeyMap 

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

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

type Device 

type Device struct {
	ApList              *ApList_ApList                           `path:"ap-list" module:"ap-list"`
	Application         *Application_Application                 `path:"application" module:"application"`
	ConnectivityService *ConnectivityService_ConnectivityService `path:"connectivity-service" module:"connectivity-service"`
	DeviceGroup         *DeviceGroup_DeviceGroup                 `path:"device-group" module:"device-group"`
	Enterprise          *Enterprise_Enterprise                   `path:"enterprise" module:"enterprise"`
	IpDomain            *IpDomain_IpDomain                       `path:"ip-domain" module:"ip-domain"`
	Site                *Site_Site                               `path:"site" module:"site"`
	Template            *Template_Template                       `path:"template" module:"template"`
	TrafficClass        *TrafficClass_TrafficClass               `path:"traffic-class" module:"traffic-class"`
	Upf                 *Upf_Upf                                 `path:"upf" module:"upf"`
	Vcs                 *Vcs_Vcs                                 `path:"vcs" module:"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 DeviceGroup_DeviceGroup 

type DeviceGroup_DeviceGroup struct {
	DeviceGroup map[string]*DeviceGroup_DeviceGroup_DeviceGroup `path:"device-group" module:"device-group"`
}

DeviceGroup_DeviceGroup represents the /device-group/device-group YANG schema element.

func (*DeviceGroup_DeviceGroup) IsYANGGoStruct 

func (*DeviceGroup_DeviceGroup) IsYANGGoStruct()

IsYANGGoStruct ensures that 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 (*DeviceGroup_DeviceGroup) NewDeviceGroup 

func (t *DeviceGroup_DeviceGroup) NewDeviceGroup(Id string) (*DeviceGroup_DeviceGroup_DeviceGroup, error)

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

func (*DeviceGroup_DeviceGroup) Validate 

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

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

func (*DeviceGroup_DeviceGroup) ΛEnumTypeMap 

func (t *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.

type DeviceGroup_DeviceGroup_DeviceGroup 

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

DeviceGroup_DeviceGroup_DeviceGroup represents the /device-group/device-group/device-group YANG schema element.

func (*DeviceGroup_DeviceGroup_DeviceGroup) IsYANGGoStruct 

func (*DeviceGroup_DeviceGroup_DeviceGroup) IsYANGGoStruct()

IsYANGGoStruct ensures that DeviceGroup_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 (*DeviceGroup_DeviceGroup_DeviceGroup) NewImsis 

func (t *DeviceGroup_DeviceGroup_DeviceGroup) NewImsis(Name string) (*DeviceGroup_DeviceGroup_DeviceGroup_Imsis, error)

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

func (*DeviceGroup_DeviceGroup_DeviceGroup) Validate 

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

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

func (*DeviceGroup_DeviceGroup_DeviceGroup) ΛEnumTypeMap 

func (t *DeviceGroup_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 (*DeviceGroup_DeviceGroup_DeviceGroup) ΛListKeyMap 

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

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

type DeviceGroup_DeviceGroup_DeviceGroup_Imsis 

type DeviceGroup_DeviceGroup_DeviceGroup_Imsis struct {
	ImsiRangeFrom *uint64 `path:"imsi-range-from" module:"device-group"`
	ImsiRangeTo   *uint64 `path:"imsi-range-to" module:"device-group"`
	Name          *string `path:"name" module:"device-group"`
}

DeviceGroup_DeviceGroup_DeviceGroup_Imsis represents the /device-group/device-group/device-group/imsis YANG schema element.

func (*DeviceGroup_DeviceGroup_DeviceGroup_Imsis) IsYANGGoStruct 

func (*DeviceGroup_DeviceGroup_DeviceGroup_Imsis) IsYANGGoStruct()

IsYANGGoStruct ensures that DeviceGroup_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 (*DeviceGroup_DeviceGroup_DeviceGroup_Imsis) Validate 

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

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

func (*DeviceGroup_DeviceGroup_DeviceGroup_Imsis) ΛEnumTypeMap 

func (t *DeviceGroup_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 (*DeviceGroup_DeviceGroup_DeviceGroup_Imsis) ΛListKeyMap 

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

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

type Enterprise_Enterprise 

type Enterprise_Enterprise struct {
	Enterprise map[string]*Enterprise_Enterprise_Enterprise `path:"enterprise" module:"enterprise"`
}

Enterprise_Enterprise represents the /enterprise/enterprise YANG schema element.

func (*Enterprise_Enterprise) IsYANGGoStruct 

func (*Enterprise_Enterprise) IsYANGGoStruct()

IsYANGGoStruct ensures that 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 (*Enterprise_Enterprise) NewEnterprise 

func (t *Enterprise_Enterprise) NewEnterprise(Id string) (*Enterprise_Enterprise_Enterprise, error)

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

func (*Enterprise_Enterprise) Validate 

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

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

func (*Enterprise_Enterprise) ΛEnumTypeMap 

func (t *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.

type Enterprise_Enterprise_Enterprise 

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

Enterprise_Enterprise_Enterprise represents the /enterprise/enterprise/enterprise YANG schema element.

func (*Enterprise_Enterprise_Enterprise) IsYANGGoStruct 

func (*Enterprise_Enterprise_Enterprise) IsYANGGoStruct()

IsYANGGoStruct ensures that Enterprise_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 (*Enterprise_Enterprise_Enterprise) NewConnectivityService 

func (t *Enterprise_Enterprise_Enterprise) NewConnectivityService(ConnectivityService string) (*Enterprise_Enterprise_Enterprise_ConnectivityService, error)

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

func (*Enterprise_Enterprise_Enterprise) Validate 

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

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

func (*Enterprise_Enterprise_Enterprise) ΛEnumTypeMap 

func (t *Enterprise_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 (*Enterprise_Enterprise_Enterprise) ΛListKeyMap 

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

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

type Enterprise_Enterprise_Enterprise_ConnectivityService 

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

Enterprise_Enterprise_Enterprise_ConnectivityService represents the /enterprise/enterprise/enterprise/connectivity-service YANG schema element.

func (*Enterprise_Enterprise_Enterprise_ConnectivityService) IsYANGGoStruct 

func (*Enterprise_Enterprise_Enterprise_ConnectivityService) IsYANGGoStruct()

IsYANGGoStruct ensures that Enterprise_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 (*Enterprise_Enterprise_Enterprise_ConnectivityService) Validate 

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

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

func (*Enterprise_Enterprise_Enterprise_ConnectivityService) ΛEnumTypeMap 

func (t *Enterprise_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 (*Enterprise_Enterprise_Enterprise_ConnectivityService) ΛListKeyMap 

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

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

type IpDomain_IpDomain 

type IpDomain_IpDomain struct {
	IpDomain map[string]*IpDomain_IpDomain_IpDomain `path:"ip-domain" module:"ip-domain"`
}

IpDomain_IpDomain represents the /ip-domain/ip-domain YANG schema element.

func (*IpDomain_IpDomain) IsYANGGoStruct 

func (*IpDomain_IpDomain) IsYANGGoStruct()

IsYANGGoStruct ensures that 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 (*IpDomain_IpDomain) NewIpDomain 

func (t *IpDomain_IpDomain) NewIpDomain(Id string) (*IpDomain_IpDomain_IpDomain, error)

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

func (*IpDomain_IpDomain) Validate 

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

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

func (*IpDomain_IpDomain) ΛEnumTypeMap 

func (t *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.

type IpDomain_IpDomain_IpDomain 

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

IpDomain_IpDomain_IpDomain represents the /ip-domain/ip-domain/ip-domain YANG schema element.

func (*IpDomain_IpDomain_IpDomain) IsYANGGoStruct 

func (*IpDomain_IpDomain_IpDomain) IsYANGGoStruct()

IsYANGGoStruct ensures that IpDomain_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 (*IpDomain_IpDomain_IpDomain) Validate 

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

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

func (*IpDomain_IpDomain_IpDomain) ΛEnumTypeMap 

func (t *IpDomain_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 (*IpDomain_IpDomain_IpDomain) ΛListKeyMap 

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

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

type Site_Site 

type Site_Site struct {
	Site map[string]*Site_Site_Site `path:"site" module:"site"`
}

Site_Site represents the /site/site YANG schema element.

func (*Site_Site) IsYANGGoStruct 

func (*Site_Site) IsYANGGoStruct()

IsYANGGoStruct ensures that 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 (*Site_Site) NewSite 

func (t *Site_Site) NewSite(Id string) (*Site_Site_Site, error)

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

func (*Site_Site) Validate 

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

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

func (*Site_Site) ΛEnumTypeMap 

func (t *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.

type Site_Site_Site 

type Site_Site_Site struct {
	Description    *string                        `path:"description" module:"site"`
	DisplayName    *string                        `path:"display-name" module:"site"`
	Enterprise     *string                        `path:"enterprise" module:"site"`
	Id             *string                        `path:"id" module:"site"`
	ImsiDefinition *Site_Site_Site_ImsiDefinition `path:"imsi-definition" module:"site"`
}

Site_Site_Site represents the /site/site/site YANG schema element.

func (*Site_Site_Site) IsYANGGoStruct 

func (*Site_Site_Site) IsYANGGoStruct()

IsYANGGoStruct ensures that Site_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 (*Site_Site_Site) Validate 

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

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

func (*Site_Site_Site) ΛEnumTypeMap 

func (t *Site_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 (*Site_Site_Site) ΛListKeyMap 

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

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

type Site_Site_Site_ImsiDefinition added in v0.6.35 

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

Site_Site_Site_ImsiDefinition represents the /site/site/site/imsi-definition YANG schema element.

func (*Site_Site_Site_ImsiDefinition) IsYANGGoStruct added in v0.6.35 

func (*Site_Site_Site_ImsiDefinition) IsYANGGoStruct()

IsYANGGoStruct ensures that Site_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 (*Site_Site_Site_ImsiDefinition) Validate added in v0.6.35 

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

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

func (*Site_Site_Site_ImsiDefinition) ΛEnumTypeMap added in v0.6.35 

func (t *Site_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 Template_Template 

type Template_Template struct {
	Template map[string]*Template_Template_Template `path:"template" module:"template"`
}

Template_Template represents the /template/template YANG schema element.

func (*Template_Template) IsYANGGoStruct 

func (*Template_Template) IsYANGGoStruct()

IsYANGGoStruct ensures that 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 (*Template_Template) NewTemplate 

func (t *Template_Template) NewTemplate(Id string) (*Template_Template_Template, error)

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

func (*Template_Template) Validate 

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

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

func (*Template_Template) ΛEnumTypeMap 

func (t *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.

type Template_Template_Template 

type Template_Template_Template struct {
	Description  *string `path:"description" module:"template"`
	DisplayName  *string `path:"display-name" module:"template"`
	Downlink     *uint32 `path:"downlink" module:"template"`
	Id           *string `path:"id" module:"template"`
	Sd           *uint32 `path:"sd" module:"template"`
	Sst          *uint8  `path:"sst" module:"template"`
	TrafficClass *string `path:"traffic-class" module:"template"`
	Uplink       *uint32 `path:"uplink" module:"template"`
}

Template_Template_Template represents the /template/template/template YANG schema element.

func (*Template_Template_Template) IsYANGGoStruct 

func (*Template_Template_Template) IsYANGGoStruct()

IsYANGGoStruct ensures that Template_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 (*Template_Template_Template) Validate 

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

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

func (*Template_Template_Template) ΛEnumTypeMap 

func (t *Template_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 (*Template_Template_Template) ΛListKeyMap 

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

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

type TrafficClass_TrafficClass added in v0.6.30 

type TrafficClass_TrafficClass struct {
	TrafficClass map[string]*TrafficClass_TrafficClass_TrafficClass `path:"traffic-class" module:"traffic-class"`
}

TrafficClass_TrafficClass represents the /traffic-class/traffic-class YANG schema element.

func (*TrafficClass_TrafficClass) IsYANGGoStruct added in v0.6.30 

func (*TrafficClass_TrafficClass) IsYANGGoStruct()

IsYANGGoStruct ensures that 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 (*TrafficClass_TrafficClass) NewTrafficClass added in v0.6.30 

func (t *TrafficClass_TrafficClass) NewTrafficClass(Id string) (*TrafficClass_TrafficClass_TrafficClass, error)

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

func (*TrafficClass_TrafficClass) Validate added in v0.6.30 

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

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

func (*TrafficClass_TrafficClass) ΛEnumTypeMap added in v0.6.30 

func (t *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.

type TrafficClass_TrafficClass_TrafficClass added in v0.6.30 

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

TrafficClass_TrafficClass_TrafficClass represents the /traffic-class/traffic-class/traffic-class YANG schema element.

func (*TrafficClass_TrafficClass_TrafficClass) IsYANGGoStruct added in v0.6.30 

func (*TrafficClass_TrafficClass_TrafficClass) IsYANGGoStruct()

IsYANGGoStruct ensures that TrafficClass_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 (*TrafficClass_TrafficClass_TrafficClass) Validate added in v0.6.30 

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

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

func (*TrafficClass_TrafficClass_TrafficClass) ΛEnumTypeMap added in v0.6.30 

func (t *TrafficClass_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 (*TrafficClass_TrafficClass_TrafficClass) ΛListKeyMap added in v0.6.30 

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

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

type Upf_Upf 

type Upf_Upf struct {
	Upf map[string]*Upf_Upf_Upf `path:"upf" module:"upf"`
}

Upf_Upf represents the /upf/upf YANG schema element.

func (*Upf_Upf) IsYANGGoStruct 

func (*Upf_Upf) IsYANGGoStruct()

IsYANGGoStruct ensures that 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 (*Upf_Upf) NewUpf 

func (t *Upf_Upf) NewUpf(Id string) (*Upf_Upf_Upf, error)

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

func (*Upf_Upf) Validate 

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

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

func (*Upf_Upf) ΛEnumTypeMap 

func (t *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.

type Upf_Upf_Upf 

type Upf_Upf_Upf struct {
	Address     *string `path:"address" module:"upf"`
	Description *string `path:"description" module:"upf"`
	DisplayName *string `path:"display-name" module:"upf"`
	Enterprise  *string `path:"enterprise" module:"upf"`
	Id          *string `path:"id" module:"upf"`
	Port        *uint16 `path:"port" module:"upf"`
}

Upf_Upf_Upf represents the /upf/upf/upf YANG schema element.

func (*Upf_Upf_Upf) IsYANGGoStruct 

func (*Upf_Upf_Upf) IsYANGGoStruct()

IsYANGGoStruct ensures that Upf_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 (*Upf_Upf_Upf) Validate 

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

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

func (*Upf_Upf_Upf) ΛEnumTypeMap 

func (t *Upf_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 (*Upf_Upf_Upf) ΛListKeyMap 

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

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

type Vcs_Vcs 

type Vcs_Vcs struct {
	Vcs map[string]*Vcs_Vcs_Vcs `path:"vcs" module:"vcs"`
}

Vcs_Vcs represents the /vcs/vcs YANG schema element.

func (*Vcs_Vcs) IsYANGGoStruct 

func (*Vcs_Vcs) IsYANGGoStruct()

IsYANGGoStruct ensures that 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 (*Vcs_Vcs) NewVcs 

func (t *Vcs_Vcs) NewVcs(Id string) (*Vcs_Vcs_Vcs, error)

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

func (*Vcs_Vcs) Validate 

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

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

func (*Vcs_Vcs) ΛEnumTypeMap 

func (t *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.

type Vcs_Vcs_Vcs 

type Vcs_Vcs_Vcs struct {
	Ap           *string                             `path:"ap" module:"vcs"`
	Application  map[string]*Vcs_Vcs_Vcs_Application `path:"application" module:"vcs"`
	Description  *string                             `path:"description" module:"vcs"`
	DeviceGroup  map[string]*Vcs_Vcs_Vcs_DeviceGroup `path:"device-group" module:"vcs"`
	DisplayName  *string                             `path:"display-name" module:"vcs"`
	Downlink     *uint32                             `path:"downlink" module:"vcs"`
	Enterprise   *string                             `path:"enterprise" module:"vcs"`
	Id           *string                             `path:"id" module:"vcs"`
	Sd           *uint32                             `path:"sd" module:"vcs"`
	Sst          *uint8                              `path:"sst" module:"vcs"`
	Template     *string                             `path:"template" module:"vcs"`
	TrafficClass *string                             `path:"traffic-class" module:"vcs"`
	Upf          *string                             `path:"upf" module:"vcs"`
	Uplink       *uint32                             `path:"uplink" module:"vcs"`
}

Vcs_Vcs_Vcs represents the /vcs/vcs/vcs YANG schema element.

func (*Vcs_Vcs_Vcs) IsYANGGoStruct 

func (*Vcs_Vcs_Vcs) IsYANGGoStruct()

IsYANGGoStruct ensures that Vcs_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 (*Vcs_Vcs_Vcs) NewApplication 

func (t *Vcs_Vcs_Vcs) NewApplication(Application string) (*Vcs_Vcs_Vcs_Application, error)

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

func (*Vcs_Vcs_Vcs) NewDeviceGroup added in v0.6.34 

func (t *Vcs_Vcs_Vcs) NewDeviceGroup(DeviceGroup string) (*Vcs_Vcs_Vcs_DeviceGroup, error)

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

func (*Vcs_Vcs_Vcs) Validate 

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

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

func (*Vcs_Vcs_Vcs) ΛEnumTypeMap 

func (t *Vcs_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 (*Vcs_Vcs_Vcs) ΛListKeyMap 

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

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

type Vcs_Vcs_Vcs_Application 

type Vcs_Vcs_Vcs_Application struct {
	Allow       *bool   `path:"allow" module:"vcs"`
	Application *string `path:"application" module:"vcs"`
}

Vcs_Vcs_Vcs_Application represents the /vcs/vcs/vcs/application YANG schema element.

func (*Vcs_Vcs_Vcs_Application) IsYANGGoStruct 

func (*Vcs_Vcs_Vcs_Application) IsYANGGoStruct()

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

func (*Vcs_Vcs_Vcs_Application) Validate 

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

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

func (*Vcs_Vcs_Vcs_Application) ΛEnumTypeMap 

func (t *Vcs_Vcs_Vcs_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 (*Vcs_Vcs_Vcs_Application) ΛListKeyMap 

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

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

type Vcs_Vcs_Vcs_DeviceGroup added in v0.6.34 

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

Vcs_Vcs_Vcs_DeviceGroup represents the /vcs/vcs/vcs/device-group YANG schema element.

func (*Vcs_Vcs_Vcs_DeviceGroup) IsYANGGoStruct added in v0.6.34 

func (*Vcs_Vcs_Vcs_DeviceGroup) IsYANGGoStruct()

IsYANGGoStruct ensures that Vcs_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 (*Vcs_Vcs_Vcs_DeviceGroup) Validate added in v0.6.34 

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

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

func (*Vcs_Vcs_Vcs_DeviceGroup) ΛEnumTypeMap added in v0.6.34 

func (t *Vcs_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 (*Vcs_Vcs_Vcs_DeviceGroup) ΛListKeyMap added in v0.6.34 

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

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

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.