ocstruct

package
v0.0.0-...-ad9c0bf Latest Latest
Warning

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

 Go to latest Published: Apr 22, 2019 License: Apache-2.0 Imports: 6 Imported by: 0

Documentation

Overview

Package ocstruct 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 true in this case).

This package was generated by /root/go/src/ovs-gnxi/vendor/github.com/openconfig/ygot/ygen/commongen.go using the following YANG input files:

  • /root/go/src/ovs-gnxi/yang/openconfig/openconfig-interfaces.yang
  • /root/go/src/ovs-gnxi/yang/openconfig/openconfig-openflow.yang
  • /root/go/src/ovs-gnxi/yang/openconfig/openconfig-platform.yang
  • /root/go/src/ovs-gnxi/yang/openconfig/openconfig-system.yang

Imported modules were sourced from:

  • yang/...

Index

Constants

This section is empty.

Variables

View Source 
var (
	SchemaTree map[string]*yang.Entry
)
View Source 
var ΛEnum = map[string]map[int64]ygot.EnumDefinition{
	"E_IETFInterfaces_InterfaceType": {},
	"E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE": {
		1: {Name: "AAA_ACCOUNTING_EVENT_COMMAND", DefiningModule: "openconfig-aaa-types"},
		2: {Name: "AAA_ACCOUNTING_EVENT_LOGIN", DefiningModule: "openconfig-aaa-types"},
	},
	"E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE": {
		1: {Name: "AAA_AUTHORIZATION_EVENT_COMMAND", DefiningModule: "openconfig-aaa-types"},
		2: {Name: "AAA_AUTHORIZATION_EVENT_CONFIG", DefiningModule: "openconfig-aaa-types"},
	},
	"E_OpenconfigAaaTypes_AAA_METHOD_TYPE": {
		1: {Name: "LOCAL", DefiningModule: "openconfig-aaa-types"},
		2: {Name: "RADIUS_ALL", DefiningModule: "openconfig-aaa-types"},
		3: {Name: "TACACS_ALL", DefiningModule: "openconfig-aaa-types"},
	},
	"E_OpenconfigAaaTypes_AAA_SERVER_TYPE": {
		1: {Name: "RADIUS", DefiningModule: "openconfig-aaa"},
		2: {Name: "TACACS", DefiningModule: "openconfig-aaa"},
	},
	"E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES": {
		1: {Name: "SYSTEM_ROLE_ADMIN", DefiningModule: "openconfig-aaa-types"},
	},
	"E_OpenconfigAaa_Event_Record": {
		1: {Name: "START_STOP"},
		2: {Name: "STOP"},
	},
	"E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY": {
		1: {Name: "CRITICAL", DefiningModule: "openconfig-alarm-types"},
		2: {Name: "MAJOR", DefiningModule: "openconfig-alarm-types"},
		3: {Name: "MINOR", DefiningModule: "openconfig-alarm-types"},
		4: {Name: "UNKNOWN", DefiningModule: "openconfig-alarm-types"},
		5: {Name: "WARNING", DefiningModule: "openconfig-alarm-types"},
	},
	"E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID": {
		1: {Name: "AIS", DefiningModule: "openconfig-alarm-types"},
		2: {Name: "EQPT", DefiningModule: "openconfig-alarm-types"},
		3: {Name: "LOS", DefiningModule: "openconfig-alarm-types"},
		4: {Name: "OTS", DefiningModule: "openconfig-alarm-types"},
	},
	"E_OpenconfigInterfaces_Interface_AdminStatus": {
		1: {Name: "UP"},
		2: {Name: "DOWN"},
		3: {Name: "TESTING"},
	},
	"E_OpenconfigInterfaces_Interface_OperStatus": {
		2: {Name: "UP"},
		3: {Name: "DOWN"},
		4: {Name: "TESTING"},
		5: {Name: "UNKNOWN"},
		6: {Name: "DORMANT"},
		7: {Name: "NOT_PRESENT"},
		8: {Name: "LOWER_LAYER_DOWN"},
	},
	"E_OpenconfigOpenflow_FailureMode": {
		1: {Name: "SECURE"},
		2: {Name: "STANDALONE"},
	},
	"E_OpenconfigOpenflow_Transport": {
		1: {Name: "TCP"},
		2: {Name: "TLS"},
	},
	"E_OpenconfigPlatformTypes_COMPONENT_OPER_STATUS": {
		1: {Name: "ACTIVE", DefiningModule: "openconfig-platform-types"},
		2: {Name: "DISABLED", DefiningModule: "openconfig-platform-types"},
		3: {Name: "INACTIVE", DefiningModule: "openconfig-platform-types"},
	},
	"E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT": {
		1:  {Name: "BACKPLANE", DefiningModule: "openconfig-platform-types"},
		2:  {Name: "CHASSIS", DefiningModule: "openconfig-platform-types"},
		3:  {Name: "CONTROLLER_CARD", DefiningModule: "openconfig-platform-types"},
		4:  {Name: "CPU", DefiningModule: "openconfig-platform-types"},
		5:  {Name: "FABRIC", DefiningModule: "openconfig-platform-types"},
		6:  {Name: "FAN", DefiningModule: "openconfig-platform-types"},
		7:  {Name: "FRU", DefiningModule: "openconfig-platform-types"},
		8:  {Name: "INTEGRATED_CIRCUIT", DefiningModule: "openconfig-platform-types"},
		9:  {Name: "LINECARD", DefiningModule: "openconfig-platform-types"},
		10: {Name: "PORT", DefiningModule: "openconfig-platform-types"},
		11: {Name: "POWER_SUPPLY", DefiningModule: "openconfig-platform-types"},
		12: {Name: "SENSOR", DefiningModule: "openconfig-platform-types"},
		13: {Name: "STORAGE", DefiningModule: "openconfig-platform-types"},
		14: {Name: "TRANSCEIVER", DefiningModule: "openconfig-platform-types"},
	},
	"E_OpenconfigPlatformTypes_OPENCONFIG_SOFTWARE_COMPONENT": {
		1: {Name: "OPERATING_SYSTEM", DefiningModule: "openconfig-platform-types"},
	},
	"E_OpenconfigSystemLogging_SYSLOG_FACILITY": {
		1:  {Name: "ALL", DefiningModule: "openconfig-system-logging"},
		2:  {Name: "AUDIT", DefiningModule: "openconfig-system-logging"},
		3:  {Name: "AUTH", DefiningModule: "openconfig-system-logging"},
		4:  {Name: "AUTHPRIV", DefiningModule: "openconfig-system-logging"},
		5:  {Name: "CONSOLE", DefiningModule: "openconfig-system-logging"},
		6:  {Name: "KERNEL", DefiningModule: "openconfig-system-logging"},
		7:  {Name: "LOCAL0", DefiningModule: "openconfig-system-logging"},
		8:  {Name: "LOCAL1", DefiningModule: "openconfig-system-logging"},
		9:  {Name: "LOCAL2", DefiningModule: "openconfig-system-logging"},
		10: {Name: "LOCAL3", DefiningModule: "openconfig-system-logging"},
		11: {Name: "LOCAL4", DefiningModule: "openconfig-system-logging"},
		12: {Name: "LOCAL5", DefiningModule: "openconfig-system-logging"},
		13: {Name: "LOCAL6", DefiningModule: "openconfig-system-logging"},
		14: {Name: "LOCAL7", DefiningModule: "openconfig-system-logging"},
		15: {Name: "MAIL", DefiningModule: "openconfig-system-logging"},
		16: {Name: "NTP", DefiningModule: "openconfig-system-logging"},
		17: {Name: "SYSLOG", DefiningModule: "openconfig-system-logging"},
		18: {Name: "SYSTEM_DAEMON", DefiningModule: "openconfig-system-logging"},
		19: {Name: "USER", DefiningModule: "openconfig-system-logging"},
	},
	"E_OpenconfigSystemLogging_SyslogSeverity": {
		1: {Name: "EMERGENCY"},
		2: {Name: "ALERT"},
		3: {Name: "CRITICAL"},
		4: {Name: "ERROR"},
		5: {Name: "WARNING"},
		6: {Name: "NOTICE"},
		7: {Name: "INFORMATIONAL"},
		8: {Name: "DEBUG"},
	},
	"E_OpenconfigSystemManagement_GrpcServer_ListenAddresses": {
		1: {Name: "ANY"},
	},
	"E_OpenconfigSystemTerminal_SshServer_ProtocolVersion": {
		1: {Name: "V2"},
		2: {Name: "V1"},
		3: {Name: "V1_V2"},
	},
	"E_OpenconfigSystem_Cpu_Index": {
		1: {Name: "ALL"},
	},
	"E_OpenconfigSystem_NTP_AUTH_TYPE": {
		1: {Name: "NTP_AUTH_MD5", DefiningModule: "openconfig-system"},
	},
	"E_OpenconfigSystem_Server_AssociationType": {
		1: {Name: "SERVER"},
		2: {Name: "PEER"},
		3: {Name: "POOL"},
	},
}

ΛEnum is a map, keyed by the name of the type defined for each enum in the generated Go code, which provides a mapping between the constant int64 value of each value of the enumeration, and the string that is used to represent it in the YANG schema. The map is named ΛEnum in order to avoid clash with any valid YANG identifier.

View Source 
var ΛEnumTypes = map[string][]reflect.Type{
	"/components/component/state/oper-status": []reflect.Type{
		reflect.TypeOf((E_OpenconfigPlatformTypes_COMPONENT_OPER_STATUS)(0)),
	},
	"/components/component/state/temperature/alarm-severity": []reflect.Type{
		reflect.TypeOf((E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY)(0)),
	},
	"/components/component/state/type": []reflect.Type{
		reflect.TypeOf((E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT)(0)),
		reflect.TypeOf((E_OpenconfigPlatformTypes_OPENCONFIG_SOFTWARE_COMPONENT)(0)),
	},
	"/interfaces/interface/config/type": []reflect.Type{
		reflect.TypeOf((E_IETFInterfaces_InterfaceType)(0)),
	},
	"/interfaces/interface/state/admin-status": []reflect.Type{
		reflect.TypeOf((E_OpenconfigInterfaces_Interface_AdminStatus)(0)),
	},
	"/interfaces/interface/state/oper-status": []reflect.Type{
		reflect.TypeOf((E_OpenconfigInterfaces_Interface_OperStatus)(0)),
	},
	"/interfaces/interface/subinterfaces/subinterface/state/admin-status": []reflect.Type{
		reflect.TypeOf((E_OpenconfigInterfaces_Interface_AdminStatus)(0)),
	},
	"/interfaces/interface/subinterfaces/subinterface/state/oper-status": []reflect.Type{
		reflect.TypeOf((E_OpenconfigInterfaces_Interface_OperStatus)(0)),
	},
	"/system/aaa/accounting/config/accounting-method": []reflect.Type{
		reflect.TypeOf((E_OpenconfigAaaTypes_AAA_METHOD_TYPE)(0)),
	},
	"/system/aaa/accounting/events/event/config/event-type": []reflect.Type{
		reflect.TypeOf((E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE)(0)),
	},
	"/system/aaa/accounting/events/event/config/record": []reflect.Type{
		reflect.TypeOf((E_OpenconfigAaa_Event_Record)(0)),
	},
	"/system/aaa/authentication/config/authentication-method": []reflect.Type{
		reflect.TypeOf((E_OpenconfigAaaTypes_AAA_METHOD_TYPE)(0)),
	},
	"/system/aaa/authentication/users/user/config/role": []reflect.Type{
		reflect.TypeOf((E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES)(0)),
	},
	"/system/aaa/authorization/config/authorization-method": []reflect.Type{
		reflect.TypeOf((E_OpenconfigAaaTypes_AAA_METHOD_TYPE)(0)),
	},
	"/system/aaa/authorization/events/event/config/event-type": []reflect.Type{
		reflect.TypeOf((E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE)(0)),
	},
	"/system/aaa/server-groups/server-group/config/type": []reflect.Type{
		reflect.TypeOf((E_OpenconfigAaaTypes_AAA_SERVER_TYPE)(0)),
	},
	"/system/alarms/alarm/state/severity": []reflect.Type{
		reflect.TypeOf((E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY)(0)),
	},
	"/system/alarms/alarm/state/type-id": []reflect.Type{
		reflect.TypeOf((E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID)(0)),
	},
	"/system/cpus/cpu/state/index": []reflect.Type{
		reflect.TypeOf((E_OpenconfigSystem_Cpu_Index)(0)),
	},
	"/system/grpc-server/config/listen-addresses": []reflect.Type{
		reflect.TypeOf((E_OpenconfigSystemManagement_GrpcServer_ListenAddresses)(0)),
	},
	"/system/logging/console/selectors/selector/config/facility": []reflect.Type{
		reflect.TypeOf((E_OpenconfigSystemLogging_SYSLOG_FACILITY)(0)),
	},
	"/system/logging/console/selectors/selector/config/severity": []reflect.Type{
		reflect.TypeOf((E_OpenconfigSystemLogging_SyslogSeverity)(0)),
	},
	"/system/logging/remote-servers/remote-server/selectors/selector/config/facility": []reflect.Type{
		reflect.TypeOf((E_OpenconfigSystemLogging_SYSLOG_FACILITY)(0)),
	},
	"/system/logging/remote-servers/remote-server/selectors/selector/config/severity": []reflect.Type{
		reflect.TypeOf((E_OpenconfigSystemLogging_SyslogSeverity)(0)),
	},
	"/system/ntp/ntp-keys/ntp-key/config/key-type": []reflect.Type{
		reflect.TypeOf((E_OpenconfigSystem_NTP_AUTH_TYPE)(0)),
	},
	"/system/ntp/servers/server/config/association-type": []reflect.Type{
		reflect.TypeOf((E_OpenconfigSystem_Server_AssociationType)(0)),
	},
	"/system/openflow/agent/config/failure-mode": []reflect.Type{
		reflect.TypeOf((E_OpenconfigOpenflow_FailureMode)(0)),
	},
	"/system/openflow/controllers/controller/connections/connection/config/transport": []reflect.Type{
		reflect.TypeOf((E_OpenconfigOpenflow_Transport)(0)),
	},
	"/system/ssh-server/config/protocol-version": []reflect.Type{
		reflect.TypeOf((E_OpenconfigSystemTerminal_SshServer_ProtocolVersion)(0)),
	},
}

Λ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 Component 

type Component struct {
	AllocatedPower    *uint32                                         `path:"state/allocated-power" module:"openconfig-platform"`
	Backplane         *Component_Backplane                            `path:"backplane" module:"openconfig-platform"`
	Chassis           *Component_Chassis                              `path:"chassis" module:"openconfig-platform"`
	Cpu               *Component_Cpu                                  `path:"cpu" module:"openconfig-platform"`
	Description       *string                                         `path:"state/description" module:"openconfig-platform"`
	Empty             *bool                                           `path:"state/empty" module:"openconfig-platform"`
	EquipmentFailure  *bool                                           `path:"state/equipment-failure" module:"openconfig-alarms"`
	EquipmentMismatch *bool                                           `path:"state/equipment-mismatch" module:"openconfig-alarms"`
	Fabric            *Component_Fabric                               `path:"fabric" module:"openconfig-platform"`
	Fan               *Component_Fan                                  `path:"fan" module:"openconfig-platform"`
	FirmwareVersion   *string                                         `path:"state/firmware-version" module:"openconfig-platform"`
	HardwareVersion   *string                                         `path:"state/hardware-version" module:"openconfig-platform"`
	Id                *string                                         `path:"state/id" module:"openconfig-platform"`
	IntegratedCircuit *Component_IntegratedCircuit                    `path:"integrated-circuit" module:"openconfig-platform"`
	Location          *string                                         `path:"state/location" module:"openconfig-platform"`
	Memory            *Component_Memory                               `path:"state/memory" module:"openconfig-platform"`
	MfgDate           *string                                         `path:"state/mfg-date" module:"openconfig-platform"`
	MfgName           *string                                         `path:"state/mfg-name" module:"openconfig-platform"`
	Name              *string                                         `path:"config/name|name" module:"openconfig-platform"`
	OperStatus        E_OpenconfigPlatformTypes_COMPONENT_OPER_STATUS `path:"state/oper-status" module:"openconfig-platform"`
	Parent            *string                                         `path:"state/parent" module:"openconfig-platform"`
	PartNo            *string                                         `path:"state/part-no" module:"openconfig-platform"`
	Port              *Component_Port                                 `path:"port" module:"openconfig-platform"`
	PowerSupply       *Component_PowerSupply                          `path:"power-supply" module:"openconfig-platform"`
	Property          map[string]*Component_Property                  `path:"properties/property" module:"openconfig-platform"`
	Removable         *bool                                           `path:"state/removable" module:"openconfig-platform"`
	SerialNo          *string                                         `path:"state/serial-no" module:"openconfig-platform"`
	SoftwareVersion   *string                                         `path:"state/software-version" module:"openconfig-platform"`
	Storage           *Component_Storage                              `path:"storage" module:"openconfig-platform"`
	Subcomponent      map[string]*Component_Subcomponent              `path:"subcomponents/subcomponent" module:"openconfig-platform"`
	Temperature       *Component_Temperature                          `path:"state/temperature" module:"openconfig-platform"`
	Type              Component_Type_Union                            `path:"state/type" module:"openconfig-platform"`
	UsedPower         *uint32                                         `path:"state/used-power" module:"openconfig-platform"`
}

Component represents the /openconfig-platform/components/component YANG schema element.

func (*Component) IsYANGGoStruct 

func (*Component) IsYANGGoStruct()

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

func (*Component) NewProperty 

func (t *Component) NewProperty(Name string) (*Component_Property, error)

NewProperty creates a new entry in the Property list of the Component struct. The keys of the list are populated from the input arguments.

func (*Component) NewSubcomponent 

func (t *Component) NewSubcomponent(Name string) (*Component_Subcomponent, error)

NewSubcomponent creates a new entry in the Subcomponent list of the Component struct. The keys of the list are populated from the input arguments.

func (*Component) To_Component_Type_Union 

func (t *Component) To_Component_Type_Union(i interface{}) (Component_Type_Union, error)

To_Component_Type_Union takes an input interface{} and attempts to convert it to a struct which implements the Component_Type_Union union. It returns an error if the interface{} supplied cannot be converted to a type within the union.

func (*Component) Validate 

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

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

func (*Component) ΛEnumTypeMap 

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

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

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

type Component_Backplane 

type Component_Backplane struct {
}

Component_Backplane represents the /openconfig-platform/components/component/backplane YANG schema element.

func (*Component_Backplane) IsYANGGoStruct 

func (*Component_Backplane) IsYANGGoStruct()

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

func (*Component_Backplane) Validate 

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

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

func (*Component_Backplane) ΛEnumTypeMap 

func (t *Component_Backplane) Λ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 Component_Chassis 

type Component_Chassis struct {
}

Component_Chassis represents the /openconfig-platform/components/component/chassis YANG schema element.

func (*Component_Chassis) IsYANGGoStruct 

func (*Component_Chassis) IsYANGGoStruct()

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

func (*Component_Chassis) Validate 

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

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

func (*Component_Chassis) ΛEnumTypeMap 

func (t *Component_Chassis) Λ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 Component_Cpu 

type Component_Cpu struct {
}

Component_Cpu represents the /openconfig-platform/components/component/cpu YANG schema element.

func (*Component_Cpu) IsYANGGoStruct 

func (*Component_Cpu) IsYANGGoStruct()

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

func (*Component_Cpu) Validate 

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

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

func (*Component_Cpu) ΛEnumTypeMap 

func (t *Component_Cpu) Λ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 Component_Fabric 

type Component_Fabric struct {
}

Component_Fabric represents the /openconfig-platform/components/component/fabric YANG schema element.

func (*Component_Fabric) IsYANGGoStruct 

func (*Component_Fabric) IsYANGGoStruct()

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

func (*Component_Fabric) Validate 

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

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

func (*Component_Fabric) ΛEnumTypeMap 

func (t *Component_Fabric) Λ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 Component_Fan 

type Component_Fan struct {
}

Component_Fan represents the /openconfig-platform/components/component/fan YANG schema element.

func (*Component_Fan) IsYANGGoStruct 

func (*Component_Fan) IsYANGGoStruct()

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

func (*Component_Fan) Validate 

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

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

func (*Component_Fan) ΛEnumTypeMap 

func (t *Component_Fan) Λ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 Component_IntegratedCircuit 

type Component_IntegratedCircuit struct {
}

Component_IntegratedCircuit represents the /openconfig-platform/components/component/integrated-circuit YANG schema element.

func (*Component_IntegratedCircuit) IsYANGGoStruct 

func (*Component_IntegratedCircuit) IsYANGGoStruct()

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

func (*Component_IntegratedCircuit) Validate 

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

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

func (*Component_IntegratedCircuit) ΛEnumTypeMap 

func (t *Component_IntegratedCircuit) Λ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 Component_Memory 

type Component_Memory struct {
	Available *uint64 `path:"available" module:"openconfig-platform"`
	Utilized  *uint64 `path:"utilized" module:"openconfig-platform"`
}

Component_Memory represents the /openconfig-platform/components/component/state/memory YANG schema element.

func (*Component_Memory) IsYANGGoStruct 

func (*Component_Memory) IsYANGGoStruct()

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

func (*Component_Memory) Validate 

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

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

func (*Component_Memory) ΛEnumTypeMap 

func (t *Component_Memory) Λ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 Component_Port 

type Component_Port struct {
}

Component_Port represents the /openconfig-platform/components/component/port YANG schema element.

func (*Component_Port) IsYANGGoStruct 

func (*Component_Port) IsYANGGoStruct()

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

func (*Component_Port) Validate 

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

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

func (*Component_Port) ΛEnumTypeMap 

func (t *Component_Port) Λ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 Component_PowerSupply 

type Component_PowerSupply struct {
}

Component_PowerSupply represents the /openconfig-platform/components/component/power-supply YANG schema element.

func (*Component_PowerSupply) IsYANGGoStruct 

func (*Component_PowerSupply) IsYANGGoStruct()

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

func (*Component_PowerSupply) Validate 

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

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

func (*Component_PowerSupply) ΛEnumTypeMap 

func (t *Component_PowerSupply) Λ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 Component_Property 

type Component_Property struct {
	Configurable *bool                          `path:"state/configurable" module:"openconfig-platform"`
	Name         *string                        `path:"config/name|name" module:"openconfig-platform"`
	Value        Component_Property_Value_Union `path:"config/value" module:"openconfig-platform"`
}

Component_Property represents the /openconfig-platform/components/component/properties/property YANG schema element.

func (*Component_Property) IsYANGGoStruct 

func (*Component_Property) IsYANGGoStruct()

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

func (*Component_Property) To_Component_Property_Value_Union 

func (t *Component_Property) To_Component_Property_Value_Union(i interface{}) (Component_Property_Value_Union, error)

To_Component_Property_Value_Union takes an input interface{} and attempts to convert it to a struct which implements the Component_Property_Value_Union union. It returns an error if the interface{} supplied cannot be converted to a type within the union.

func (*Component_Property) Validate 

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

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

func (*Component_Property) ΛEnumTypeMap 

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

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

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

type Component_Property_Value_Union 

type Component_Property_Value_Union interface {
	Is_Component_Property_Value_Union()
}

Component_Property_Value_Union is an interface that is implemented by valid types for the union for the leaf /openconfig-platform/components/component/properties/property/config/value within the YANG schema.

type Component_Property_Value_Union_Bool 

type Component_Property_Value_Union_Bool struct {
	Bool bool
}

Component_Property_Value_Union_Bool is used when /openconfig-platform/components/component/properties/property/config/value is to be set to a bool value.

func (*Component_Property_Value_Union_Bool) Is_Component_Property_Value_Union 

func (*Component_Property_Value_Union_Bool) Is_Component_Property_Value_Union()

Is_Component_Property_Value_Union ensures that Component_Property_Value_Union_Bool implements the Component_Property_Value_Union interface.

type Component_Property_Value_Union_Float64 

type Component_Property_Value_Union_Float64 struct {
	Float64 float64
}

Component_Property_Value_Union_Float64 is used when /openconfig-platform/components/component/properties/property/config/value is to be set to a float64 value.

func (*Component_Property_Value_Union_Float64) Is_Component_Property_Value_Union 

func (*Component_Property_Value_Union_Float64) Is_Component_Property_Value_Union()

Is_Component_Property_Value_Union ensures that Component_Property_Value_Union_Float64 implements the Component_Property_Value_Union interface.

type Component_Property_Value_Union_Int64 

type Component_Property_Value_Union_Int64 struct {
	Int64 int64
}

Component_Property_Value_Union_Int64 is used when /openconfig-platform/components/component/properties/property/config/value is to be set to a int64 value.

func (*Component_Property_Value_Union_Int64) Is_Component_Property_Value_Union 

func (*Component_Property_Value_Union_Int64) Is_Component_Property_Value_Union()

Is_Component_Property_Value_Union ensures that Component_Property_Value_Union_Int64 implements the Component_Property_Value_Union interface.

type Component_Property_Value_Union_String 

type Component_Property_Value_Union_String struct {
	String string
}

Component_Property_Value_Union_String is used when /openconfig-platform/components/component/properties/property/config/value is to be set to a string value.

func (*Component_Property_Value_Union_String) Is_Component_Property_Value_Union 

func (*Component_Property_Value_Union_String) Is_Component_Property_Value_Union()

Is_Component_Property_Value_Union ensures that Component_Property_Value_Union_String implements the Component_Property_Value_Union interface.

type Component_Property_Value_Union_Uint64 

type Component_Property_Value_Union_Uint64 struct {
	Uint64 uint64
}

Component_Property_Value_Union_Uint64 is used when /openconfig-platform/components/component/properties/property/config/value is to be set to a uint64 value.

func (*Component_Property_Value_Union_Uint64) Is_Component_Property_Value_Union 

func (*Component_Property_Value_Union_Uint64) Is_Component_Property_Value_Union()

Is_Component_Property_Value_Union ensures that Component_Property_Value_Union_Uint64 implements the Component_Property_Value_Union interface.

type Component_Storage 

type Component_Storage struct {
}

Component_Storage represents the /openconfig-platform/components/component/storage YANG schema element.

func (*Component_Storage) IsYANGGoStruct 

func (*Component_Storage) IsYANGGoStruct()

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

func (*Component_Storage) Validate 

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

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

func (*Component_Storage) ΛEnumTypeMap 

func (t *Component_Storage) Λ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 Component_Subcomponent 

type Component_Subcomponent struct {
	Name *string `path:"config/name|name" module:"openconfig-platform"`
}

Component_Subcomponent represents the /openconfig-platform/components/component/subcomponents/subcomponent YANG schema element.

func (*Component_Subcomponent) IsYANGGoStruct 

func (*Component_Subcomponent) IsYANGGoStruct()

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

func (*Component_Subcomponent) Validate 

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

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

func (*Component_Subcomponent) ΛEnumTypeMap 

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

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

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

type Component_Temperature 

type Component_Temperature struct {
	AlarmSeverity  E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY `path:"alarm-severity" module:"openconfig-platform"`
	AlarmStatus    *bool                                            `path:"alarm-status" module:"openconfig-platform"`
	AlarmThreshold *uint32                                          `path:"alarm-threshold" module:"openconfig-platform"`
	Avg            *float64                                         `path:"avg" module:"openconfig-platform"`
	Instant        *float64                                         `path:"instant" module:"openconfig-platform"`
	Interval       *uint64                                          `path:"interval" module:"openconfig-platform"`
	Max            *float64                                         `path:"max" module:"openconfig-platform"`
	MaxTime        *uint64                                          `path:"max-time" module:"openconfig-platform"`
	Min            *float64                                         `path:"min" module:"openconfig-platform"`
	MinTime        *uint64                                          `path:"min-time" module:"openconfig-platform"`
}

Component_Temperature represents the /openconfig-platform/components/component/state/temperature YANG schema element.

func (*Component_Temperature) IsYANGGoStruct 

func (*Component_Temperature) IsYANGGoStruct()

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

func (*Component_Temperature) Validate 

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

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

func (*Component_Temperature) ΛEnumTypeMap 

func (t *Component_Temperature) Λ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 Component_Type_Union 

type Component_Type_Union interface {
	Is_Component_Type_Union()
}

Component_Type_Union is an interface that is implemented by valid types for the union for the leaf /openconfig-platform/components/component/state/type within the YANG schema.

type Component_Type_Union_E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT 

type Component_Type_Union_E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT struct {
	E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT
}

Component_Type_Union_E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT is used when /openconfig-platform/components/component/state/type is to be set to a E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT value.

func (*Component_Type_Union_E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT) Is_Component_Type_Union 

func (*Component_Type_Union_E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT) Is_Component_Type_Union()

Is_Component_Type_Union ensures that Component_Type_Union_E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT implements the Component_Type_Union interface.

type Component_Type_Union_E_OpenconfigPlatformTypes_OPENCONFIG_SOFTWARE_COMPONENT 

type Component_Type_Union_E_OpenconfigPlatformTypes_OPENCONFIG_SOFTWARE_COMPONENT struct {
	E_OpenconfigPlatformTypes_OPENCONFIG_SOFTWARE_COMPONENT E_OpenconfigPlatformTypes_OPENCONFIG_SOFTWARE_COMPONENT
}

Component_Type_Union_E_OpenconfigPlatformTypes_OPENCONFIG_SOFTWARE_COMPONENT is used when /openconfig-platform/components/component/state/type is to be set to a E_OpenconfigPlatformTypes_OPENCONFIG_SOFTWARE_COMPONENT value.

func (*Component_Type_Union_E_OpenconfigPlatformTypes_OPENCONFIG_SOFTWARE_COMPONENT) Is_Component_Type_Union 

func (*Component_Type_Union_E_OpenconfigPlatformTypes_OPENCONFIG_SOFTWARE_COMPONENT) Is_Component_Type_Union()

Is_Component_Type_Union ensures that Component_Type_Union_E_OpenconfigPlatformTypes_OPENCONFIG_SOFTWARE_COMPONENT implements the Component_Type_Union interface.

type Device 

type Device struct {
	Component map[string]*Component `path:"components/component" module:"openconfig-platform"`
	Interface map[string]*Interface `path:"interfaces/interface" module:"openconfig-interfaces"`
	System    *System               `path:"system" module:"openconfig-system"`
}

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) NewComponent 

func (t *Device) NewComponent(Name string) (*Component, error)

NewComponent creates a new entry in the Component list of the Device struct. The keys of the list are populated from the input arguments.

func (*Device) NewInterface 

func (t *Device) NewInterface(Name string) (*Interface, error)

NewInterface creates a new entry in the Interface list of the Device struct. The keys of the list are populated from the input arguments.

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 E_IETFInterfaces_InterfaceType 

type E_IETFInterfaces_InterfaceType int64

E_IETFInterfaces_InterfaceType is a derived int64 type which is used to represent the enumerated node IETFInterfaces_InterfaceType. An additional value named IETFInterfaces_InterfaceType_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// IETFInterfaces_InterfaceType_UNSET corresponds to the value UNSET of IETFInterfaces_InterfaceType
	IETFInterfaces_InterfaceType_UNSET E_IETFInterfaces_InterfaceType = 0
)

func (E_IETFInterfaces_InterfaceType) IsYANGGoEnum 

func (E_IETFInterfaces_InterfaceType) IsYANGGoEnum()

IsYANGGoEnum ensures that IETFInterfaces_InterfaceType implements the yang.GoEnum interface. This ensures that IETFInterfaces_InterfaceType can be identified as a mapped type for a YANG enumeration.

func (E_IETFInterfaces_InterfaceType) ΛMap 

func (E_IETFInterfaces_InterfaceType) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with IETFInterfaces_InterfaceType.

type E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE 

type E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE int64

E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE is a derived int64 type which is used to represent the enumerated node OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE. An additional value named OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE_UNSET corresponds to the value UNSET of OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE
	OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE_UNSET E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE = 0
	// OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE_AAA_ACCOUNTING_EVENT_COMMAND corresponds to the value AAA_ACCOUNTING_EVENT_COMMAND of OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE
	OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE_AAA_ACCOUNTING_EVENT_COMMAND E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE = 1
	// OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE_AAA_ACCOUNTING_EVENT_LOGIN corresponds to the value AAA_ACCOUNTING_EVENT_LOGIN of OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE
	OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE_AAA_ACCOUNTING_EVENT_LOGIN E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE = 2
)

func (E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE) IsYANGGoEnum 

func (E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE implements the yang.GoEnum interface. This ensures that OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE) ΛMap 

func (E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE.

type E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE 

type E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE int64

E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE is a derived int64 type which is used to represent the enumerated node OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE. An additional value named OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE_UNSET corresponds to the value UNSET of OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE
	OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE_UNSET E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE = 0
	// OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE_AAA_AUTHORIZATION_EVENT_COMMAND corresponds to the value AAA_AUTHORIZATION_EVENT_COMMAND of OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE
	OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE_AAA_AUTHORIZATION_EVENT_COMMAND E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE = 1
	// OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE_AAA_AUTHORIZATION_EVENT_CONFIG corresponds to the value AAA_AUTHORIZATION_EVENT_CONFIG of OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE
	OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE_AAA_AUTHORIZATION_EVENT_CONFIG E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE = 2
)

func (E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE) IsYANGGoEnum 

func (E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE implements the yang.GoEnum interface. This ensures that OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE) ΛMap 

func (E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE.

type E_OpenconfigAaaTypes_AAA_METHOD_TYPE 

type E_OpenconfigAaaTypes_AAA_METHOD_TYPE int64

E_OpenconfigAaaTypes_AAA_METHOD_TYPE is a derived int64 type which is used to represent the enumerated node OpenconfigAaaTypes_AAA_METHOD_TYPE. An additional value named OpenconfigAaaTypes_AAA_METHOD_TYPE_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigAaaTypes_AAA_METHOD_TYPE_UNSET corresponds to the value UNSET of OpenconfigAaaTypes_AAA_METHOD_TYPE
	OpenconfigAaaTypes_AAA_METHOD_TYPE_UNSET E_OpenconfigAaaTypes_AAA_METHOD_TYPE = 0
	// OpenconfigAaaTypes_AAA_METHOD_TYPE_LOCAL corresponds to the value LOCAL of OpenconfigAaaTypes_AAA_METHOD_TYPE
	OpenconfigAaaTypes_AAA_METHOD_TYPE_LOCAL E_OpenconfigAaaTypes_AAA_METHOD_TYPE = 1
	// OpenconfigAaaTypes_AAA_METHOD_TYPE_RADIUS_ALL corresponds to the value RADIUS_ALL of OpenconfigAaaTypes_AAA_METHOD_TYPE
	OpenconfigAaaTypes_AAA_METHOD_TYPE_RADIUS_ALL E_OpenconfigAaaTypes_AAA_METHOD_TYPE = 2
	// OpenconfigAaaTypes_AAA_METHOD_TYPE_TACACS_ALL corresponds to the value TACACS_ALL of OpenconfigAaaTypes_AAA_METHOD_TYPE
	OpenconfigAaaTypes_AAA_METHOD_TYPE_TACACS_ALL E_OpenconfigAaaTypes_AAA_METHOD_TYPE = 3
)

func (E_OpenconfigAaaTypes_AAA_METHOD_TYPE) IsYANGGoEnum 

func (E_OpenconfigAaaTypes_AAA_METHOD_TYPE) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigAaaTypes_AAA_METHOD_TYPE implements the yang.GoEnum interface. This ensures that OpenconfigAaaTypes_AAA_METHOD_TYPE can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigAaaTypes_AAA_METHOD_TYPE) ΛMap 

func (E_OpenconfigAaaTypes_AAA_METHOD_TYPE) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigAaaTypes_AAA_METHOD_TYPE.

type E_OpenconfigAaaTypes_AAA_SERVER_TYPE 

type E_OpenconfigAaaTypes_AAA_SERVER_TYPE int64

E_OpenconfigAaaTypes_AAA_SERVER_TYPE is a derived int64 type which is used to represent the enumerated node OpenconfigAaaTypes_AAA_SERVER_TYPE. An additional value named OpenconfigAaaTypes_AAA_SERVER_TYPE_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigAaaTypes_AAA_SERVER_TYPE_UNSET corresponds to the value UNSET of OpenconfigAaaTypes_AAA_SERVER_TYPE
	OpenconfigAaaTypes_AAA_SERVER_TYPE_UNSET E_OpenconfigAaaTypes_AAA_SERVER_TYPE = 0
	// OpenconfigAaaTypes_AAA_SERVER_TYPE_RADIUS corresponds to the value RADIUS of OpenconfigAaaTypes_AAA_SERVER_TYPE
	OpenconfigAaaTypes_AAA_SERVER_TYPE_RADIUS E_OpenconfigAaaTypes_AAA_SERVER_TYPE = 1
	// OpenconfigAaaTypes_AAA_SERVER_TYPE_TACACS corresponds to the value TACACS of OpenconfigAaaTypes_AAA_SERVER_TYPE
	OpenconfigAaaTypes_AAA_SERVER_TYPE_TACACS E_OpenconfigAaaTypes_AAA_SERVER_TYPE = 2
)

func (E_OpenconfigAaaTypes_AAA_SERVER_TYPE) IsYANGGoEnum 

func (E_OpenconfigAaaTypes_AAA_SERVER_TYPE) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigAaaTypes_AAA_SERVER_TYPE implements the yang.GoEnum interface. This ensures that OpenconfigAaaTypes_AAA_SERVER_TYPE can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigAaaTypes_AAA_SERVER_TYPE) ΛMap 

func (E_OpenconfigAaaTypes_AAA_SERVER_TYPE) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigAaaTypes_AAA_SERVER_TYPE.

type E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES 

type E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES int64

E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES is a derived int64 type which is used to represent the enumerated node OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES. An additional value named OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES_UNSET corresponds to the value UNSET of OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES
	OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES_UNSET E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES = 0
	// OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES_SYSTEM_ROLE_ADMIN corresponds to the value SYSTEM_ROLE_ADMIN of OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES
	OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES_SYSTEM_ROLE_ADMIN E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES = 1
)

func (E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES) IsYANGGoEnum 

func (E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES implements the yang.GoEnum interface. This ensures that OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES) ΛMap 

func (E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES.

type E_OpenconfigAaa_Event_Record 

type E_OpenconfigAaa_Event_Record int64

E_OpenconfigAaa_Event_Record is a derived int64 type which is used to represent the enumerated node OpenconfigAaa_Event_Record. An additional value named OpenconfigAaa_Event_Record_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigAaa_Event_Record_UNSET corresponds to the value UNSET of OpenconfigAaa_Event_Record
	OpenconfigAaa_Event_Record_UNSET E_OpenconfigAaa_Event_Record = 0
	// OpenconfigAaa_Event_Record_START_STOP corresponds to the value START_STOP of OpenconfigAaa_Event_Record
	OpenconfigAaa_Event_Record_START_STOP E_OpenconfigAaa_Event_Record = 1
	// OpenconfigAaa_Event_Record_STOP corresponds to the value STOP of OpenconfigAaa_Event_Record
	OpenconfigAaa_Event_Record_STOP E_OpenconfigAaa_Event_Record = 2
)

func (E_OpenconfigAaa_Event_Record) IsYANGGoEnum 

func (E_OpenconfigAaa_Event_Record) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigAaa_Event_Record implements the yang.GoEnum interface. This ensures that OpenconfigAaa_Event_Record can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigAaa_Event_Record) ΛMap 

func (E_OpenconfigAaa_Event_Record) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigAaa_Event_Record.

type E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY 

type E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY int64

E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY is a derived int64 type which is used to represent the enumerated node OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY. An additional value named OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY_UNSET corresponds to the value UNSET of OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY
	OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY_UNSET E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY = 0
	// OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY_CRITICAL corresponds to the value CRITICAL of OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY
	OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY_CRITICAL E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY = 1
	// OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY_MAJOR corresponds to the value MAJOR of OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY
	OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY_MAJOR E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY = 2
	// OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY_MINOR corresponds to the value MINOR of OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY
	OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY_MINOR E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY = 3
	// OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY_UNKNOWN corresponds to the value UNKNOWN of OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY
	OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY_UNKNOWN E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY = 4
	// OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY_WARNING corresponds to the value WARNING of OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY
	OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY_WARNING E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY = 5
)

func (E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY) IsYANGGoEnum 

func (E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY implements the yang.GoEnum interface. This ensures that OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY) ΛMap 

func (E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY.

type E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID 

type E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID int64

E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID is a derived int64 type which is used to represent the enumerated node OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID. An additional value named OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID_UNSET corresponds to the value UNSET of OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID
	OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID_UNSET E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID = 0
	// OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID_AIS corresponds to the value AIS of OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID
	OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID_AIS E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID = 1
	// OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID_EQPT corresponds to the value EQPT of OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID
	OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID_EQPT E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID = 2
	// OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID_LOS corresponds to the value LOS of OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID
	OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID_LOS E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID = 3
	// OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID_OTS corresponds to the value OTS of OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID
	OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID_OTS E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID = 4
)

func (E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID) IsYANGGoEnum 

func (E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID implements the yang.GoEnum interface. This ensures that OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID) ΛMap 

func (E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID.

type E_OpenconfigInterfaces_Interface_AdminStatus 

type E_OpenconfigInterfaces_Interface_AdminStatus int64

E_OpenconfigInterfaces_Interface_AdminStatus is a derived int64 type which is used to represent the enumerated node OpenconfigInterfaces_Interface_AdminStatus. An additional value named OpenconfigInterfaces_Interface_AdminStatus_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigInterfaces_Interface_AdminStatus_UNSET corresponds to the value UNSET of OpenconfigInterfaces_Interface_AdminStatus
	OpenconfigInterfaces_Interface_AdminStatus_UNSET E_OpenconfigInterfaces_Interface_AdminStatus = 0
	// OpenconfigInterfaces_Interface_AdminStatus_UP corresponds to the value UP of OpenconfigInterfaces_Interface_AdminStatus
	OpenconfigInterfaces_Interface_AdminStatus_UP E_OpenconfigInterfaces_Interface_AdminStatus = 1
	// OpenconfigInterfaces_Interface_AdminStatus_DOWN corresponds to the value DOWN of OpenconfigInterfaces_Interface_AdminStatus
	OpenconfigInterfaces_Interface_AdminStatus_DOWN E_OpenconfigInterfaces_Interface_AdminStatus = 2
	// OpenconfigInterfaces_Interface_AdminStatus_TESTING corresponds to the value TESTING of OpenconfigInterfaces_Interface_AdminStatus
	OpenconfigInterfaces_Interface_AdminStatus_TESTING E_OpenconfigInterfaces_Interface_AdminStatus = 3
)

func (E_OpenconfigInterfaces_Interface_AdminStatus) IsYANGGoEnum 

func (E_OpenconfigInterfaces_Interface_AdminStatus) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigInterfaces_Interface_AdminStatus implements the yang.GoEnum interface. This ensures that OpenconfigInterfaces_Interface_AdminStatus can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigInterfaces_Interface_AdminStatus) ΛMap 

func (E_OpenconfigInterfaces_Interface_AdminStatus) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigInterfaces_Interface_AdminStatus.

type E_OpenconfigInterfaces_Interface_OperStatus 

type E_OpenconfigInterfaces_Interface_OperStatus int64

E_OpenconfigInterfaces_Interface_OperStatus is a derived int64 type which is used to represent the enumerated node OpenconfigInterfaces_Interface_OperStatus. An additional value named OpenconfigInterfaces_Interface_OperStatus_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigInterfaces_Interface_OperStatus_UNSET corresponds to the value UNSET of OpenconfigInterfaces_Interface_OperStatus
	OpenconfigInterfaces_Interface_OperStatus_UNSET E_OpenconfigInterfaces_Interface_OperStatus = 0
	// OpenconfigInterfaces_Interface_OperStatus_UP corresponds to the value UP of OpenconfigInterfaces_Interface_OperStatus
	OpenconfigInterfaces_Interface_OperStatus_UP E_OpenconfigInterfaces_Interface_OperStatus = 2
	// OpenconfigInterfaces_Interface_OperStatus_DOWN corresponds to the value DOWN of OpenconfigInterfaces_Interface_OperStatus
	OpenconfigInterfaces_Interface_OperStatus_DOWN E_OpenconfigInterfaces_Interface_OperStatus = 3
	// OpenconfigInterfaces_Interface_OperStatus_TESTING corresponds to the value TESTING of OpenconfigInterfaces_Interface_OperStatus
	OpenconfigInterfaces_Interface_OperStatus_TESTING E_OpenconfigInterfaces_Interface_OperStatus = 4
	// OpenconfigInterfaces_Interface_OperStatus_UNKNOWN corresponds to the value UNKNOWN of OpenconfigInterfaces_Interface_OperStatus
	OpenconfigInterfaces_Interface_OperStatus_UNKNOWN E_OpenconfigInterfaces_Interface_OperStatus = 5
	// OpenconfigInterfaces_Interface_OperStatus_DORMANT corresponds to the value DORMANT of OpenconfigInterfaces_Interface_OperStatus
	OpenconfigInterfaces_Interface_OperStatus_DORMANT E_OpenconfigInterfaces_Interface_OperStatus = 6
	// OpenconfigInterfaces_Interface_OperStatus_NOT_PRESENT corresponds to the value NOT_PRESENT of OpenconfigInterfaces_Interface_OperStatus
	OpenconfigInterfaces_Interface_OperStatus_NOT_PRESENT E_OpenconfigInterfaces_Interface_OperStatus = 7
	// OpenconfigInterfaces_Interface_OperStatus_LOWER_LAYER_DOWN corresponds to the value LOWER_LAYER_DOWN of OpenconfigInterfaces_Interface_OperStatus
	OpenconfigInterfaces_Interface_OperStatus_LOWER_LAYER_DOWN E_OpenconfigInterfaces_Interface_OperStatus = 8
)

func (E_OpenconfigInterfaces_Interface_OperStatus) IsYANGGoEnum 

func (E_OpenconfigInterfaces_Interface_OperStatus) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigInterfaces_Interface_OperStatus implements the yang.GoEnum interface. This ensures that OpenconfigInterfaces_Interface_OperStatus can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigInterfaces_Interface_OperStatus) ΛMap 

func (E_OpenconfigInterfaces_Interface_OperStatus) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigInterfaces_Interface_OperStatus.

type E_OpenconfigOpenflow_FailureMode 

type E_OpenconfigOpenflow_FailureMode int64

E_OpenconfigOpenflow_FailureMode is a derived int64 type which is used to represent the enumerated node OpenconfigOpenflow_FailureMode. An additional value named OpenconfigOpenflow_FailureMode_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigOpenflow_FailureMode_UNSET corresponds to the value UNSET of OpenconfigOpenflow_FailureMode
	OpenconfigOpenflow_FailureMode_UNSET E_OpenconfigOpenflow_FailureMode = 0
	// OpenconfigOpenflow_FailureMode_SECURE corresponds to the value SECURE of OpenconfigOpenflow_FailureMode
	OpenconfigOpenflow_FailureMode_SECURE E_OpenconfigOpenflow_FailureMode = 1
	// OpenconfigOpenflow_FailureMode_STANDALONE corresponds to the value STANDALONE of OpenconfigOpenflow_FailureMode
	OpenconfigOpenflow_FailureMode_STANDALONE E_OpenconfigOpenflow_FailureMode = 2
)

func (E_OpenconfigOpenflow_FailureMode) IsYANGGoEnum 

func (E_OpenconfigOpenflow_FailureMode) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigOpenflow_FailureMode implements the yang.GoEnum interface. This ensures that OpenconfigOpenflow_FailureMode can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigOpenflow_FailureMode) ΛMap 

func (E_OpenconfigOpenflow_FailureMode) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigOpenflow_FailureMode.

type E_OpenconfigOpenflow_Transport 

type E_OpenconfigOpenflow_Transport int64

E_OpenconfigOpenflow_Transport is a derived int64 type which is used to represent the enumerated node OpenconfigOpenflow_Transport. An additional value named OpenconfigOpenflow_Transport_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigOpenflow_Transport_UNSET corresponds to the value UNSET of OpenconfigOpenflow_Transport
	OpenconfigOpenflow_Transport_UNSET E_OpenconfigOpenflow_Transport = 0
	// OpenconfigOpenflow_Transport_TCP corresponds to the value TCP of OpenconfigOpenflow_Transport
	OpenconfigOpenflow_Transport_TCP E_OpenconfigOpenflow_Transport = 1
	// OpenconfigOpenflow_Transport_TLS corresponds to the value TLS of OpenconfigOpenflow_Transport
	OpenconfigOpenflow_Transport_TLS E_OpenconfigOpenflow_Transport = 2
)

func (E_OpenconfigOpenflow_Transport) IsYANGGoEnum 

func (E_OpenconfigOpenflow_Transport) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigOpenflow_Transport implements the yang.GoEnum interface. This ensures that OpenconfigOpenflow_Transport can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigOpenflow_Transport) ΛMap 

func (E_OpenconfigOpenflow_Transport) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigOpenflow_Transport.

type E_OpenconfigPlatformTypes_COMPONENT_OPER_STATUS 

type E_OpenconfigPlatformTypes_COMPONENT_OPER_STATUS int64

E_OpenconfigPlatformTypes_COMPONENT_OPER_STATUS is a derived int64 type which is used to represent the enumerated node OpenconfigPlatformTypes_COMPONENT_OPER_STATUS. An additional value named OpenconfigPlatformTypes_COMPONENT_OPER_STATUS_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigPlatformTypes_COMPONENT_OPER_STATUS_UNSET corresponds to the value UNSET of OpenconfigPlatformTypes_COMPONENT_OPER_STATUS
	OpenconfigPlatformTypes_COMPONENT_OPER_STATUS_UNSET E_OpenconfigPlatformTypes_COMPONENT_OPER_STATUS = 0
	// OpenconfigPlatformTypes_COMPONENT_OPER_STATUS_ACTIVE corresponds to the value ACTIVE of OpenconfigPlatformTypes_COMPONENT_OPER_STATUS
	OpenconfigPlatformTypes_COMPONENT_OPER_STATUS_ACTIVE E_OpenconfigPlatformTypes_COMPONENT_OPER_STATUS = 1
	// OpenconfigPlatformTypes_COMPONENT_OPER_STATUS_DISABLED corresponds to the value DISABLED of OpenconfigPlatformTypes_COMPONENT_OPER_STATUS
	OpenconfigPlatformTypes_COMPONENT_OPER_STATUS_DISABLED E_OpenconfigPlatformTypes_COMPONENT_OPER_STATUS = 2
	// OpenconfigPlatformTypes_COMPONENT_OPER_STATUS_INACTIVE corresponds to the value INACTIVE of OpenconfigPlatformTypes_COMPONENT_OPER_STATUS
	OpenconfigPlatformTypes_COMPONENT_OPER_STATUS_INACTIVE E_OpenconfigPlatformTypes_COMPONENT_OPER_STATUS = 3
)

func (E_OpenconfigPlatformTypes_COMPONENT_OPER_STATUS) IsYANGGoEnum 

func (E_OpenconfigPlatformTypes_COMPONENT_OPER_STATUS) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigPlatformTypes_COMPONENT_OPER_STATUS implements the yang.GoEnum interface. This ensures that OpenconfigPlatformTypes_COMPONENT_OPER_STATUS can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigPlatformTypes_COMPONENT_OPER_STATUS) ΛMap 

func (E_OpenconfigPlatformTypes_COMPONENT_OPER_STATUS) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigPlatformTypes_COMPONENT_OPER_STATUS.

type E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT 

type E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT int64

E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT is a derived int64 type which is used to represent the enumerated node OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT. An additional value named OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT_UNSET corresponds to the value UNSET of OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT
	OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT_UNSET E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT = 0
	// OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT_BACKPLANE corresponds to the value BACKPLANE of OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT
	OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT_BACKPLANE E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT = 1
	// OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT_CHASSIS corresponds to the value CHASSIS of OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT
	OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT_CHASSIS E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT = 2
	// OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT_CONTROLLER_CARD corresponds to the value CONTROLLER_CARD of OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT
	OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT_CONTROLLER_CARD E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT = 3
	// OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT_CPU corresponds to the value CPU of OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT
	OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT_CPU E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT = 4
	// OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT_FABRIC corresponds to the value FABRIC of OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT
	OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT_FABRIC E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT = 5
	// OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT_FAN corresponds to the value FAN of OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT
	OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT_FAN E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT = 6
	// OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT_FRU corresponds to the value FRU of OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT
	OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT_FRU E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT = 7
	// OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT_INTEGRATED_CIRCUIT corresponds to the value INTEGRATED_CIRCUIT of OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT
	OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT_INTEGRATED_CIRCUIT E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT = 8
	// OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT_LINECARD corresponds to the value LINECARD of OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT
	OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT_LINECARD E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT = 9
	// OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT_PORT corresponds to the value PORT of OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT
	OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT_PORT E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT = 10
	// OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT_POWER_SUPPLY corresponds to the value POWER_SUPPLY of OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT
	OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT_POWER_SUPPLY E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT = 11
	// OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT_SENSOR corresponds to the value SENSOR of OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT
	OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT_SENSOR E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT = 12
	// OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT_STORAGE corresponds to the value STORAGE of OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT
	OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT_STORAGE E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT = 13
	// OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT_TRANSCEIVER corresponds to the value TRANSCEIVER of OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT
	OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT_TRANSCEIVER E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT = 14
)

func (E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT) IsYANGGoEnum 

func (E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT implements the yang.GoEnum interface. This ensures that OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT) ΛMap 

func (E_OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigPlatformTypes_OPENCONFIG_HARDWARE_COMPONENT.

type E_OpenconfigPlatformTypes_OPENCONFIG_SOFTWARE_COMPONENT 

type E_OpenconfigPlatformTypes_OPENCONFIG_SOFTWARE_COMPONENT int64

E_OpenconfigPlatformTypes_OPENCONFIG_SOFTWARE_COMPONENT is a derived int64 type which is used to represent the enumerated node OpenconfigPlatformTypes_OPENCONFIG_SOFTWARE_COMPONENT. An additional value named OpenconfigPlatformTypes_OPENCONFIG_SOFTWARE_COMPONENT_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigPlatformTypes_OPENCONFIG_SOFTWARE_COMPONENT_UNSET corresponds to the value UNSET of OpenconfigPlatformTypes_OPENCONFIG_SOFTWARE_COMPONENT
	OpenconfigPlatformTypes_OPENCONFIG_SOFTWARE_COMPONENT_UNSET E_OpenconfigPlatformTypes_OPENCONFIG_SOFTWARE_COMPONENT = 0
	// OpenconfigPlatformTypes_OPENCONFIG_SOFTWARE_COMPONENT_OPERATING_SYSTEM corresponds to the value OPERATING_SYSTEM of OpenconfigPlatformTypes_OPENCONFIG_SOFTWARE_COMPONENT
	OpenconfigPlatformTypes_OPENCONFIG_SOFTWARE_COMPONENT_OPERATING_SYSTEM E_OpenconfigPlatformTypes_OPENCONFIG_SOFTWARE_COMPONENT = 1
)

func (E_OpenconfigPlatformTypes_OPENCONFIG_SOFTWARE_COMPONENT) IsYANGGoEnum 

func (E_OpenconfigPlatformTypes_OPENCONFIG_SOFTWARE_COMPONENT) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigPlatformTypes_OPENCONFIG_SOFTWARE_COMPONENT implements the yang.GoEnum interface. This ensures that OpenconfigPlatformTypes_OPENCONFIG_SOFTWARE_COMPONENT can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigPlatformTypes_OPENCONFIG_SOFTWARE_COMPONENT) ΛMap 

func (E_OpenconfigPlatformTypes_OPENCONFIG_SOFTWARE_COMPONENT) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigPlatformTypes_OPENCONFIG_SOFTWARE_COMPONENT.

type E_OpenconfigSystemLogging_SYSLOG_FACILITY 

type E_OpenconfigSystemLogging_SYSLOG_FACILITY int64

E_OpenconfigSystemLogging_SYSLOG_FACILITY is a derived int64 type which is used to represent the enumerated node OpenconfigSystemLogging_SYSLOG_FACILITY. An additional value named OpenconfigSystemLogging_SYSLOG_FACILITY_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigSystemLogging_SYSLOG_FACILITY_UNSET corresponds to the value UNSET of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_UNSET E_OpenconfigSystemLogging_SYSLOG_FACILITY = 0
	// OpenconfigSystemLogging_SYSLOG_FACILITY_ALL corresponds to the value ALL of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_ALL E_OpenconfigSystemLogging_SYSLOG_FACILITY = 1
	// OpenconfigSystemLogging_SYSLOG_FACILITY_AUDIT corresponds to the value AUDIT of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_AUDIT E_OpenconfigSystemLogging_SYSLOG_FACILITY = 2
	// OpenconfigSystemLogging_SYSLOG_FACILITY_AUTH corresponds to the value AUTH of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_AUTH E_OpenconfigSystemLogging_SYSLOG_FACILITY = 3
	// OpenconfigSystemLogging_SYSLOG_FACILITY_AUTHPRIV corresponds to the value AUTHPRIV of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_AUTHPRIV E_OpenconfigSystemLogging_SYSLOG_FACILITY = 4
	// OpenconfigSystemLogging_SYSLOG_FACILITY_CONSOLE corresponds to the value CONSOLE of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_CONSOLE E_OpenconfigSystemLogging_SYSLOG_FACILITY = 5
	// OpenconfigSystemLogging_SYSLOG_FACILITY_KERNEL corresponds to the value KERNEL of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_KERNEL E_OpenconfigSystemLogging_SYSLOG_FACILITY = 6
	// OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL0 corresponds to the value LOCAL0 of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL0 E_OpenconfigSystemLogging_SYSLOG_FACILITY = 7
	// OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL1 corresponds to the value LOCAL1 of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL1 E_OpenconfigSystemLogging_SYSLOG_FACILITY = 8
	// OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL2 corresponds to the value LOCAL2 of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL2 E_OpenconfigSystemLogging_SYSLOG_FACILITY = 9
	// OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL3 corresponds to the value LOCAL3 of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL3 E_OpenconfigSystemLogging_SYSLOG_FACILITY = 10
	// OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL4 corresponds to the value LOCAL4 of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL4 E_OpenconfigSystemLogging_SYSLOG_FACILITY = 11
	// OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL5 corresponds to the value LOCAL5 of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL5 E_OpenconfigSystemLogging_SYSLOG_FACILITY = 12
	// OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL6 corresponds to the value LOCAL6 of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL6 E_OpenconfigSystemLogging_SYSLOG_FACILITY = 13
	// OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL7 corresponds to the value LOCAL7 of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_LOCAL7 E_OpenconfigSystemLogging_SYSLOG_FACILITY = 14
	// OpenconfigSystemLogging_SYSLOG_FACILITY_MAIL corresponds to the value MAIL of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_MAIL E_OpenconfigSystemLogging_SYSLOG_FACILITY = 15
	// OpenconfigSystemLogging_SYSLOG_FACILITY_NTP corresponds to the value NTP of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_NTP E_OpenconfigSystemLogging_SYSLOG_FACILITY = 16
	// OpenconfigSystemLogging_SYSLOG_FACILITY_SYSLOG corresponds to the value SYSLOG of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_SYSLOG E_OpenconfigSystemLogging_SYSLOG_FACILITY = 17
	// OpenconfigSystemLogging_SYSLOG_FACILITY_SYSTEM_DAEMON corresponds to the value SYSTEM_DAEMON of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_SYSTEM_DAEMON E_OpenconfigSystemLogging_SYSLOG_FACILITY = 18
	// OpenconfigSystemLogging_SYSLOG_FACILITY_USER corresponds to the value USER of OpenconfigSystemLogging_SYSLOG_FACILITY
	OpenconfigSystemLogging_SYSLOG_FACILITY_USER E_OpenconfigSystemLogging_SYSLOG_FACILITY = 19
)

func (E_OpenconfigSystemLogging_SYSLOG_FACILITY) IsYANGGoEnum 

func (E_OpenconfigSystemLogging_SYSLOG_FACILITY) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigSystemLogging_SYSLOG_FACILITY implements the yang.GoEnum interface. This ensures that OpenconfigSystemLogging_SYSLOG_FACILITY can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigSystemLogging_SYSLOG_FACILITY) ΛMap 

func (E_OpenconfigSystemLogging_SYSLOG_FACILITY) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigSystemLogging_SYSLOG_FACILITY.

type E_OpenconfigSystemLogging_SyslogSeverity 

type E_OpenconfigSystemLogging_SyslogSeverity int64

E_OpenconfigSystemLogging_SyslogSeverity is a derived int64 type which is used to represent the enumerated node OpenconfigSystemLogging_SyslogSeverity. An additional value named OpenconfigSystemLogging_SyslogSeverity_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigSystemLogging_SyslogSeverity_UNSET corresponds to the value UNSET of OpenconfigSystemLogging_SyslogSeverity
	OpenconfigSystemLogging_SyslogSeverity_UNSET E_OpenconfigSystemLogging_SyslogSeverity = 0
	// OpenconfigSystemLogging_SyslogSeverity_EMERGENCY corresponds to the value EMERGENCY of OpenconfigSystemLogging_SyslogSeverity
	OpenconfigSystemLogging_SyslogSeverity_EMERGENCY E_OpenconfigSystemLogging_SyslogSeverity = 1
	// OpenconfigSystemLogging_SyslogSeverity_ALERT corresponds to the value ALERT of OpenconfigSystemLogging_SyslogSeverity
	OpenconfigSystemLogging_SyslogSeverity_ALERT E_OpenconfigSystemLogging_SyslogSeverity = 2
	// OpenconfigSystemLogging_SyslogSeverity_CRITICAL corresponds to the value CRITICAL of OpenconfigSystemLogging_SyslogSeverity
	OpenconfigSystemLogging_SyslogSeverity_CRITICAL E_OpenconfigSystemLogging_SyslogSeverity = 3
	// OpenconfigSystemLogging_SyslogSeverity_ERROR corresponds to the value ERROR of OpenconfigSystemLogging_SyslogSeverity
	OpenconfigSystemLogging_SyslogSeverity_ERROR E_OpenconfigSystemLogging_SyslogSeverity = 4
	// OpenconfigSystemLogging_SyslogSeverity_WARNING corresponds to the value WARNING of OpenconfigSystemLogging_SyslogSeverity
	OpenconfigSystemLogging_SyslogSeverity_WARNING E_OpenconfigSystemLogging_SyslogSeverity = 5
	// OpenconfigSystemLogging_SyslogSeverity_NOTICE corresponds to the value NOTICE of OpenconfigSystemLogging_SyslogSeverity
	OpenconfigSystemLogging_SyslogSeverity_NOTICE E_OpenconfigSystemLogging_SyslogSeverity = 6
	// OpenconfigSystemLogging_SyslogSeverity_INFORMATIONAL corresponds to the value INFORMATIONAL of OpenconfigSystemLogging_SyslogSeverity
	OpenconfigSystemLogging_SyslogSeverity_INFORMATIONAL E_OpenconfigSystemLogging_SyslogSeverity = 7
	// OpenconfigSystemLogging_SyslogSeverity_DEBUG corresponds to the value DEBUG of OpenconfigSystemLogging_SyslogSeverity
	OpenconfigSystemLogging_SyslogSeverity_DEBUG E_OpenconfigSystemLogging_SyslogSeverity = 8
)

func (E_OpenconfigSystemLogging_SyslogSeverity) IsYANGGoEnum 

func (E_OpenconfigSystemLogging_SyslogSeverity) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigSystemLogging_SyslogSeverity implements the yang.GoEnum interface. This ensures that OpenconfigSystemLogging_SyslogSeverity can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigSystemLogging_SyslogSeverity) ΛMap 

func (E_OpenconfigSystemLogging_SyslogSeverity) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigSystemLogging_SyslogSeverity.

type E_OpenconfigSystemManagement_GrpcServer_ListenAddresses 

type E_OpenconfigSystemManagement_GrpcServer_ListenAddresses int64

E_OpenconfigSystemManagement_GrpcServer_ListenAddresses is a derived int64 type which is used to represent the enumerated node OpenconfigSystemManagement_GrpcServer_ListenAddresses. An additional value named OpenconfigSystemManagement_GrpcServer_ListenAddresses_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigSystemManagement_GrpcServer_ListenAddresses_UNSET corresponds to the value UNSET of OpenconfigSystemManagement_GrpcServer_ListenAddresses
	OpenconfigSystemManagement_GrpcServer_ListenAddresses_UNSET E_OpenconfigSystemManagement_GrpcServer_ListenAddresses = 0
	// OpenconfigSystemManagement_GrpcServer_ListenAddresses_ANY corresponds to the value ANY of OpenconfigSystemManagement_GrpcServer_ListenAddresses
	OpenconfigSystemManagement_GrpcServer_ListenAddresses_ANY E_OpenconfigSystemManagement_GrpcServer_ListenAddresses = 1
)

func (E_OpenconfigSystemManagement_GrpcServer_ListenAddresses) IsYANGGoEnum 

func (E_OpenconfigSystemManagement_GrpcServer_ListenAddresses) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigSystemManagement_GrpcServer_ListenAddresses implements the yang.GoEnum interface. This ensures that OpenconfigSystemManagement_GrpcServer_ListenAddresses can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigSystemManagement_GrpcServer_ListenAddresses) ΛMap 

func (E_OpenconfigSystemManagement_GrpcServer_ListenAddresses) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigSystemManagement_GrpcServer_ListenAddresses.

type E_OpenconfigSystemTerminal_SshServer_ProtocolVersion 

type E_OpenconfigSystemTerminal_SshServer_ProtocolVersion int64

E_OpenconfigSystemTerminal_SshServer_ProtocolVersion is a derived int64 type which is used to represent the enumerated node OpenconfigSystemTerminal_SshServer_ProtocolVersion. An additional value named OpenconfigSystemTerminal_SshServer_ProtocolVersion_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigSystemTerminal_SshServer_ProtocolVersion_UNSET corresponds to the value UNSET of OpenconfigSystemTerminal_SshServer_ProtocolVersion
	OpenconfigSystemTerminal_SshServer_ProtocolVersion_UNSET E_OpenconfigSystemTerminal_SshServer_ProtocolVersion = 0
	// OpenconfigSystemTerminal_SshServer_ProtocolVersion_V2 corresponds to the value V2 of OpenconfigSystemTerminal_SshServer_ProtocolVersion
	OpenconfigSystemTerminal_SshServer_ProtocolVersion_V2 E_OpenconfigSystemTerminal_SshServer_ProtocolVersion = 1
	// OpenconfigSystemTerminal_SshServer_ProtocolVersion_V1 corresponds to the value V1 of OpenconfigSystemTerminal_SshServer_ProtocolVersion
	OpenconfigSystemTerminal_SshServer_ProtocolVersion_V1 E_OpenconfigSystemTerminal_SshServer_ProtocolVersion = 2
	// OpenconfigSystemTerminal_SshServer_ProtocolVersion_V1_V2 corresponds to the value V1_V2 of OpenconfigSystemTerminal_SshServer_ProtocolVersion
	OpenconfigSystemTerminal_SshServer_ProtocolVersion_V1_V2 E_OpenconfigSystemTerminal_SshServer_ProtocolVersion = 3
)

func (E_OpenconfigSystemTerminal_SshServer_ProtocolVersion) IsYANGGoEnum 

func (E_OpenconfigSystemTerminal_SshServer_ProtocolVersion) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigSystemTerminal_SshServer_ProtocolVersion implements the yang.GoEnum interface. This ensures that OpenconfigSystemTerminal_SshServer_ProtocolVersion can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigSystemTerminal_SshServer_ProtocolVersion) ΛMap 

func (E_OpenconfigSystemTerminal_SshServer_ProtocolVersion) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigSystemTerminal_SshServer_ProtocolVersion.

type E_OpenconfigSystem_Cpu_Index 

type E_OpenconfigSystem_Cpu_Index int64

E_OpenconfigSystem_Cpu_Index is a derived int64 type which is used to represent the enumerated node OpenconfigSystem_Cpu_Index. An additional value named OpenconfigSystem_Cpu_Index_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigSystem_Cpu_Index_UNSET corresponds to the value UNSET of OpenconfigSystem_Cpu_Index
	OpenconfigSystem_Cpu_Index_UNSET E_OpenconfigSystem_Cpu_Index = 0
	// OpenconfigSystem_Cpu_Index_ALL corresponds to the value ALL of OpenconfigSystem_Cpu_Index
	OpenconfigSystem_Cpu_Index_ALL E_OpenconfigSystem_Cpu_Index = 1
)

func (E_OpenconfigSystem_Cpu_Index) IsYANGGoEnum 

func (E_OpenconfigSystem_Cpu_Index) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigSystem_Cpu_Index implements the yang.GoEnum interface. This ensures that OpenconfigSystem_Cpu_Index can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigSystem_Cpu_Index) ΛMap 

func (E_OpenconfigSystem_Cpu_Index) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigSystem_Cpu_Index.

type E_OpenconfigSystem_NTP_AUTH_TYPE 

type E_OpenconfigSystem_NTP_AUTH_TYPE int64

E_OpenconfigSystem_NTP_AUTH_TYPE is a derived int64 type which is used to represent the enumerated node OpenconfigSystem_NTP_AUTH_TYPE. An additional value named OpenconfigSystem_NTP_AUTH_TYPE_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigSystem_NTP_AUTH_TYPE_UNSET corresponds to the value UNSET of OpenconfigSystem_NTP_AUTH_TYPE
	OpenconfigSystem_NTP_AUTH_TYPE_UNSET E_OpenconfigSystem_NTP_AUTH_TYPE = 0
	// OpenconfigSystem_NTP_AUTH_TYPE_NTP_AUTH_MD5 corresponds to the value NTP_AUTH_MD5 of OpenconfigSystem_NTP_AUTH_TYPE
	OpenconfigSystem_NTP_AUTH_TYPE_NTP_AUTH_MD5 E_OpenconfigSystem_NTP_AUTH_TYPE = 1
)

func (E_OpenconfigSystem_NTP_AUTH_TYPE) IsYANGGoEnum 

func (E_OpenconfigSystem_NTP_AUTH_TYPE) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigSystem_NTP_AUTH_TYPE implements the yang.GoEnum interface. This ensures that OpenconfigSystem_NTP_AUTH_TYPE can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigSystem_NTP_AUTH_TYPE) ΛMap 

func (E_OpenconfigSystem_NTP_AUTH_TYPE) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigSystem_NTP_AUTH_TYPE.

type E_OpenconfigSystem_Server_AssociationType 

type E_OpenconfigSystem_Server_AssociationType int64

E_OpenconfigSystem_Server_AssociationType is a derived int64 type which is used to represent the enumerated node OpenconfigSystem_Server_AssociationType. An additional value named OpenconfigSystem_Server_AssociationType_UNSET is added to the enumeration which is used as the nil value, indicating that the enumeration was not explicitly set by the program importing the generated structures. 

const (
	// OpenconfigSystem_Server_AssociationType_UNSET corresponds to the value UNSET of OpenconfigSystem_Server_AssociationType
	OpenconfigSystem_Server_AssociationType_UNSET E_OpenconfigSystem_Server_AssociationType = 0
	// OpenconfigSystem_Server_AssociationType_SERVER corresponds to the value SERVER of OpenconfigSystem_Server_AssociationType
	OpenconfigSystem_Server_AssociationType_SERVER E_OpenconfigSystem_Server_AssociationType = 1
	// OpenconfigSystem_Server_AssociationType_PEER corresponds to the value PEER of OpenconfigSystem_Server_AssociationType
	OpenconfigSystem_Server_AssociationType_PEER E_OpenconfigSystem_Server_AssociationType = 2
	// OpenconfigSystem_Server_AssociationType_POOL corresponds to the value POOL of OpenconfigSystem_Server_AssociationType
	OpenconfigSystem_Server_AssociationType_POOL E_OpenconfigSystem_Server_AssociationType = 3
)

func (E_OpenconfigSystem_Server_AssociationType) IsYANGGoEnum 

func (E_OpenconfigSystem_Server_AssociationType) IsYANGGoEnum()

IsYANGGoEnum ensures that OpenconfigSystem_Server_AssociationType implements the yang.GoEnum interface. This ensures that OpenconfigSystem_Server_AssociationType can be identified as a mapped type for a YANG enumeration.

func (E_OpenconfigSystem_Server_AssociationType) ΛMap 

func (E_OpenconfigSystem_Server_AssociationType) ΛMap() map[string]map[int64]ygot.EnumDefinition

ΛMap returns the value lookup map associated with OpenconfigSystem_Server_AssociationType.

type Interface 

type Interface struct {
	AdminStatus  E_OpenconfigInterfaces_Interface_AdminStatus `path:"state/admin-status" module:"openconfig-interfaces"`
	Counters     *Interface_Counters                          `path:"state/counters" module:"openconfig-interfaces"`
	Description  *string                                      `path:"config/description" module:"openconfig-interfaces"`
	Enabled      *bool                                        `path:"config/enabled" module:"openconfig-interfaces"`
	HoldTime     *Interface_HoldTime                          `path:"hold-time" module:"openconfig-interfaces"`
	Ifindex      *uint32                                      `path:"state/ifindex" module:"openconfig-interfaces"`
	LastChange   *uint64                                      `path:"state/last-change" module:"openconfig-interfaces"`
	Logical      *bool                                        `path:"state/logical" module:"openconfig-interfaces"`
	LoopbackMode *bool                                        `path:"config/loopback-mode" module:"openconfig-interfaces"`
	Mtu          *uint16                                      `path:"config/mtu" module:"openconfig-interfaces"`
	Name         *string                                      `path:"config/name|name" module:"openconfig-interfaces"`
	OperStatus   E_OpenconfigInterfaces_Interface_OperStatus  `path:"state/oper-status" module:"openconfig-interfaces"`
	Subinterface map[uint32]*Interface_Subinterface           `path:"subinterfaces/subinterface" module:"openconfig-interfaces"`
	Type         E_IETFInterfaces_InterfaceType               `path:"config/type" module:"openconfig-interfaces"`
}

Interface represents the /openconfig-interfaces/interfaces/interface YANG schema element.

func (*Interface) IsYANGGoStruct 

func (*Interface) IsYANGGoStruct()

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

func (*Interface) NewSubinterface 

func (t *Interface) NewSubinterface(Index uint32) (*Interface_Subinterface, error)

NewSubinterface creates a new entry in the Subinterface list of the Interface struct. The keys of the list are populated from the input arguments.

func (*Interface) Validate 

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

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

func (*Interface) ΛEnumTypeMap 

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

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

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

type Interface_Counters 

type Interface_Counters struct {
	CarrierTransitions *uint64 `path:"carrier-transitions" module:"openconfig-interfaces"`
	InBroadcastPkts    *uint64 `path:"in-broadcast-pkts" module:"openconfig-interfaces"`
	InDiscards         *uint64 `path:"in-discards" module:"openconfig-interfaces"`
	InErrors           *uint64 `path:"in-errors" module:"openconfig-interfaces"`
	InFcsErrors        *uint64 `path:"in-fcs-errors" module:"openconfig-interfaces"`
	InMulticastPkts    *uint64 `path:"in-multicast-pkts" module:"openconfig-interfaces"`
	InOctets           *uint64 `path:"in-octets" module:"openconfig-interfaces"`
	InPkts             *uint64 `path:"in-pkts" module:"openconfig-interfaces"`
	InUnicastPkts      *uint64 `path:"in-unicast-pkts" module:"openconfig-interfaces"`
	InUnknownProtos    *uint64 `path:"in-unknown-protos" module:"openconfig-interfaces"`
	LastClear          *uint64 `path:"last-clear" module:"openconfig-interfaces"`
	OutBroadcastPkts   *uint64 `path:"out-broadcast-pkts" module:"openconfig-interfaces"`
	OutDiscards        *uint64 `path:"out-discards" module:"openconfig-interfaces"`
	OutErrors          *uint64 `path:"out-errors" module:"openconfig-interfaces"`
	OutMulticastPkts   *uint64 `path:"out-multicast-pkts" module:"openconfig-interfaces"`
	OutOctets          *uint64 `path:"out-octets" module:"openconfig-interfaces"`
	OutPkts            *uint64 `path:"out-pkts" module:"openconfig-interfaces"`
	OutUnicastPkts     *uint64 `path:"out-unicast-pkts" module:"openconfig-interfaces"`
}

Interface_Counters represents the /openconfig-interfaces/interfaces/interface/state/counters YANG schema element.

func (*Interface_Counters) IsYANGGoStruct 

func (*Interface_Counters) IsYANGGoStruct()

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

func (*Interface_Counters) Validate 

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

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

func (*Interface_Counters) ΛEnumTypeMap 

func (t *Interface_Counters) Λ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 Interface_HoldTime 

type Interface_HoldTime struct {
	Down *uint32 `path:"config/down" module:"openconfig-interfaces"`
	Up   *uint32 `path:"config/up" module:"openconfig-interfaces"`
}

Interface_HoldTime represents the /openconfig-interfaces/interfaces/interface/hold-time YANG schema element.

func (*Interface_HoldTime) IsYANGGoStruct 

func (*Interface_HoldTime) IsYANGGoStruct()

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

func (*Interface_HoldTime) Validate 

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

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

func (*Interface_HoldTime) ΛEnumTypeMap 

func (t *Interface_HoldTime) Λ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 Interface_Subinterface 

type Interface_Subinterface struct {
	AdminStatus E_OpenconfigInterfaces_Interface_AdminStatus `path:"state/admin-status" module:"openconfig-interfaces"`
	Counters    *Interface_Subinterface_Counters             `path:"state/counters" module:"openconfig-interfaces"`
	Description *string                                      `path:"config/description" module:"openconfig-interfaces"`
	Enabled     *bool                                        `path:"config/enabled" module:"openconfig-interfaces"`
	Ifindex     *uint32                                      `path:"state/ifindex" module:"openconfig-interfaces"`
	Index       *uint32                                      `path:"config/index|index" module:"openconfig-interfaces"`
	LastChange  *uint64                                      `path:"state/last-change" module:"openconfig-interfaces"`
	Logical     *bool                                        `path:"state/logical" module:"openconfig-interfaces"`
	Name        *string                                      `path:"state/name" module:"openconfig-interfaces"`
	OperStatus  E_OpenconfigInterfaces_Interface_OperStatus  `path:"state/oper-status" module:"openconfig-interfaces"`
}

Interface_Subinterface represents the /openconfig-interfaces/interfaces/interface/subinterfaces/subinterface YANG schema element.

func (*Interface_Subinterface) IsYANGGoStruct 

func (*Interface_Subinterface) IsYANGGoStruct()

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

func (*Interface_Subinterface) Validate 

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

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

func (*Interface_Subinterface) ΛEnumTypeMap 

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

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

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

type Interface_Subinterface_Counters 

type Interface_Subinterface_Counters struct {
	CarrierTransitions *uint64 `path:"carrier-transitions" module:"openconfig-interfaces"`
	InBroadcastPkts    *uint64 `path:"in-broadcast-pkts" module:"openconfig-interfaces"`
	InDiscards         *uint64 `path:"in-discards" module:"openconfig-interfaces"`
	InErrors           *uint64 `path:"in-errors" module:"openconfig-interfaces"`
	InFcsErrors        *uint64 `path:"in-fcs-errors" module:"openconfig-interfaces"`
	InMulticastPkts    *uint64 `path:"in-multicast-pkts" module:"openconfig-interfaces"`
	InOctets           *uint64 `path:"in-octets" module:"openconfig-interfaces"`
	InPkts             *uint64 `path:"in-pkts" module:"openconfig-interfaces"`
	InUnicastPkts      *uint64 `path:"in-unicast-pkts" module:"openconfig-interfaces"`
	InUnknownProtos    *uint64 `path:"in-unknown-protos" module:"openconfig-interfaces"`
	LastClear          *uint64 `path:"last-clear" module:"openconfig-interfaces"`
	OutBroadcastPkts   *uint64 `path:"out-broadcast-pkts" module:"openconfig-interfaces"`
	OutDiscards        *uint64 `path:"out-discards" module:"openconfig-interfaces"`
	OutErrors          *uint64 `path:"out-errors" module:"openconfig-interfaces"`
	OutMulticastPkts   *uint64 `path:"out-multicast-pkts" module:"openconfig-interfaces"`
	OutOctets          *uint64 `path:"out-octets" module:"openconfig-interfaces"`
	OutPkts            *uint64 `path:"out-pkts" module:"openconfig-interfaces"`
	OutUnicastPkts     *uint64 `path:"out-unicast-pkts" module:"openconfig-interfaces"`
}

Interface_Subinterface_Counters represents the /openconfig-interfaces/interfaces/interface/subinterfaces/subinterface/state/counters YANG schema element.

func (*Interface_Subinterface_Counters) IsYANGGoStruct 

func (*Interface_Subinterface_Counters) IsYANGGoStruct()

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

func (*Interface_Subinterface_Counters) Validate 

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

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

func (*Interface_Subinterface_Counters) ΛEnumTypeMap 

func (t *Interface_Subinterface_Counters) Λ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 System 

type System struct {
	Aaa             *System_Aaa                            `path:"aaa" module:"openconfig-system"`
	Alarm           map[string]*System_Alarm               `path:"alarms/alarm" module:"openconfig-system"`
	BootTime        *uint64                                `path:"state/boot-time" module:"openconfig-system"`
	Clock           *System_Clock                          `path:"clock" module:"openconfig-system"`
	Cpu             map[System_Cpu_Index_Union]*System_Cpu `path:"cpus/cpu" module:"openconfig-system"`
	CurrentDatetime *string                                `path:"state/current-datetime" module:"openconfig-system"`
	Dns             *System_Dns                            `path:"dns" module:"openconfig-system"`
	DomainName      *string                                `path:"config/domain-name" module:"openconfig-system"`
	GrpcServer      *System_GrpcServer                     `path:"grpc-server" module:"openconfig-system"`
	Hostname        *string                                `path:"config/hostname" module:"openconfig-system"`
	Logging         *System_Logging                        `path:"logging" module:"openconfig-system"`
	LoginBanner     *string                                `path:"config/login-banner" module:"openconfig-system"`
	Memory          *System_Memory                         `path:"memory" module:"openconfig-system"`
	MotdBanner      *string                                `path:"config/motd-banner" module:"openconfig-system"`
	Ntp             *System_Ntp                            `path:"ntp" module:"openconfig-system"`
	Openflow        *System_Openflow                       `path:"openflow" module:"openconfig-openflow"`
	Process         map[uint64]*System_Process             `path:"processes/process" module:"openconfig-system"`
	SshServer       *System_SshServer                      `path:"ssh-server" module:"openconfig-system"`
	TelnetServer    *System_TelnetServer                   `path:"telnet-server" module:"openconfig-system"`
}

System represents the /openconfig-system/system YANG schema element.

func (*System) IsYANGGoStruct 

func (*System) IsYANGGoStruct()

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

func (*System) NewAlarm 

func (t *System) NewAlarm(Id string) (*System_Alarm, error)

NewAlarm creates a new entry in the Alarm list of the System struct. The keys of the list are populated from the input arguments.

func (*System) NewCpu 

func (t *System) NewCpu(Index System_Cpu_Index_Union) (*System_Cpu, error)

NewCpu creates a new entry in the Cpu list of the System struct. The keys of the list are populated from the input arguments.

func (*System) NewProcess 

func (t *System) NewProcess(Pid uint64) (*System_Process, error)

NewProcess creates a new entry in the Process list of the System struct. The keys of the list are populated from the input arguments.

func (*System) Validate 

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

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

func (*System) ΛEnumTypeMap 

func (t *System) Λ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 System_Aaa 

type System_Aaa struct {
	Accounting     *System_Aaa_Accounting             `path:"accounting" module:"openconfig-system"`
	Authentication *System_Aaa_Authentication         `path:"authentication" module:"openconfig-system"`
	Authorization  *System_Aaa_Authorization          `path:"authorization" module:"openconfig-system"`
	ServerGroup    map[string]*System_Aaa_ServerGroup `path:"server-groups/server-group" module:"openconfig-system"`
}

System_Aaa represents the /openconfig-system/system/aaa YANG schema element.

func (*System_Aaa) IsYANGGoStruct 

func (*System_Aaa) IsYANGGoStruct()

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

func (*System_Aaa) NewServerGroup 

func (t *System_Aaa) NewServerGroup(Name string) (*System_Aaa_ServerGroup, error)

NewServerGroup creates a new entry in the ServerGroup list of the System_Aaa struct. The keys of the list are populated from the input arguments.

func (*System_Aaa) Validate 

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

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

func (*System_Aaa) ΛEnumTypeMap 

func (t *System_Aaa) Λ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 System_Aaa_Accounting 

type System_Aaa_Accounting struct {
	AccountingMethod []System_Aaa_Accounting_AccountingMethod_Union                                  `path:"config/accounting-method" module:"openconfig-system"`
	Event            map[E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE]*System_Aaa_Accounting_Event `path:"events/event" module:"openconfig-system"`
}

System_Aaa_Accounting represents the /openconfig-system/system/aaa/accounting YANG schema element.

func (*System_Aaa_Accounting) IsYANGGoStruct 

func (*System_Aaa_Accounting) IsYANGGoStruct()

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

func (*System_Aaa_Accounting) NewEvent 

func (t *System_Aaa_Accounting) NewEvent(EventType E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE) (*System_Aaa_Accounting_Event, error)

NewEvent creates a new entry in the Event list of the System_Aaa_Accounting struct. The keys of the list are populated from the input arguments.

func (*System_Aaa_Accounting) To_System_Aaa_Accounting_AccountingMethod_Union 

func (t *System_Aaa_Accounting) To_System_Aaa_Accounting_AccountingMethod_Union(i interface{}) (System_Aaa_Accounting_AccountingMethod_Union, error)

To_System_Aaa_Accounting_AccountingMethod_Union takes an input interface{} and attempts to convert it to a struct which implements the System_Aaa_Accounting_AccountingMethod_Union union. It returns an error if the interface{} supplied cannot be converted to a type within the union.

func (*System_Aaa_Accounting) Validate 

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

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

func (*System_Aaa_Accounting) ΛEnumTypeMap 

func (t *System_Aaa_Accounting) Λ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 System_Aaa_Accounting_AccountingMethod_Union 

type System_Aaa_Accounting_AccountingMethod_Union interface {
	Is_System_Aaa_Accounting_AccountingMethod_Union()
}

System_Aaa_Accounting_AccountingMethod_Union is an interface that is implemented by valid types for the union for the leaf /openconfig-system/system/aaa/accounting/config/accounting-method within the YANG schema.

type System_Aaa_Accounting_AccountingMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE 

type System_Aaa_Accounting_AccountingMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE struct {
	E_OpenconfigAaaTypes_AAA_METHOD_TYPE E_OpenconfigAaaTypes_AAA_METHOD_TYPE
}

System_Aaa_Accounting_AccountingMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE is used when /openconfig-system/system/aaa/accounting/config/accounting-method is to be set to a E_OpenconfigAaaTypes_AAA_METHOD_TYPE value.

func (*System_Aaa_Accounting_AccountingMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE) Is_System_Aaa_Accounting_AccountingMethod_Union 

func (*System_Aaa_Accounting_AccountingMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE) Is_System_Aaa_Accounting_AccountingMethod_Union()

Is_System_Aaa_Accounting_AccountingMethod_Union ensures that System_Aaa_Accounting_AccountingMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE implements the System_Aaa_Accounting_AccountingMethod_Union interface.

type System_Aaa_Accounting_AccountingMethod_Union_String 

type System_Aaa_Accounting_AccountingMethod_Union_String struct {
	String string
}

System_Aaa_Accounting_AccountingMethod_Union_String is used when /openconfig-system/system/aaa/accounting/config/accounting-method is to be set to a string value.

func (*System_Aaa_Accounting_AccountingMethod_Union_String) Is_System_Aaa_Accounting_AccountingMethod_Union 

func (*System_Aaa_Accounting_AccountingMethod_Union_String) Is_System_Aaa_Accounting_AccountingMethod_Union()

Is_System_Aaa_Accounting_AccountingMethod_Union ensures that System_Aaa_Accounting_AccountingMethod_Union_String implements the System_Aaa_Accounting_AccountingMethod_Union interface.

type System_Aaa_Accounting_Event 

type System_Aaa_Accounting_Event struct {
	EventType E_OpenconfigAaaTypes_AAA_ACCOUNTING_EVENT_TYPE `path:"config/event-type|event-type" module:"openconfig-system"`
	Record    E_OpenconfigAaa_Event_Record                   `path:"config/record" module:"openconfig-system"`
}

System_Aaa_Accounting_Event represents the /openconfig-system/system/aaa/accounting/events/event YANG schema element.

func (*System_Aaa_Accounting_Event) IsYANGGoStruct 

func (*System_Aaa_Accounting_Event) IsYANGGoStruct()

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

func (*System_Aaa_Accounting_Event) Validate 

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

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

func (*System_Aaa_Accounting_Event) ΛEnumTypeMap 

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

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

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

type System_Aaa_Authentication 

type System_Aaa_Authentication struct {
	AdminUser            *System_Aaa_Authentication_AdminUser                   `path:"admin-user" module:"openconfig-system"`
	AuthenticationMethod []System_Aaa_Authentication_AuthenticationMethod_Union `path:"config/authentication-method" module:"openconfig-system"`
	User                 map[string]*System_Aaa_Authentication_User             `path:"users/user" module:"openconfig-system"`
}

System_Aaa_Authentication represents the /openconfig-system/system/aaa/authentication YANG schema element.

func (*System_Aaa_Authentication) IsYANGGoStruct 

func (*System_Aaa_Authentication) IsYANGGoStruct()

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

func (*System_Aaa_Authentication) NewUser 

func (t *System_Aaa_Authentication) NewUser(Username string) (*System_Aaa_Authentication_User, error)

NewUser creates a new entry in the User list of the System_Aaa_Authentication struct. The keys of the list are populated from the input arguments.

func (*System_Aaa_Authentication) To_System_Aaa_Authentication_AuthenticationMethod_Union 

func (t *System_Aaa_Authentication) To_System_Aaa_Authentication_AuthenticationMethod_Union(i interface{}) (System_Aaa_Authentication_AuthenticationMethod_Union, error)

To_System_Aaa_Authentication_AuthenticationMethod_Union takes an input interface{} and attempts to convert it to a struct which implements the System_Aaa_Authentication_AuthenticationMethod_Union union. It returns an error if the interface{} supplied cannot be converted to a type within the union.

func (*System_Aaa_Authentication) Validate 

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

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

func (*System_Aaa_Authentication) ΛEnumTypeMap 

func (t *System_Aaa_Authentication) Λ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 System_Aaa_Authentication_AdminUser 

type System_Aaa_Authentication_AdminUser struct {
	AdminPassword       *string `path:"config/admin-password" module:"openconfig-system"`
	AdminPasswordHashed *string `path:"config/admin-password-hashed" module:"openconfig-system"`
	AdminUsername       *string `path:"state/admin-username" module:"openconfig-system"`
}

System_Aaa_Authentication_AdminUser represents the /openconfig-system/system/aaa/authentication/admin-user YANG schema element.

func (*System_Aaa_Authentication_AdminUser) IsYANGGoStruct 

func (*System_Aaa_Authentication_AdminUser) IsYANGGoStruct()

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

func (*System_Aaa_Authentication_AdminUser) Validate 

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

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

func (*System_Aaa_Authentication_AdminUser) ΛEnumTypeMap 

func (t *System_Aaa_Authentication_AdminUser) Λ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 System_Aaa_Authentication_AuthenticationMethod_Union 

type System_Aaa_Authentication_AuthenticationMethod_Union interface {
	Is_System_Aaa_Authentication_AuthenticationMethod_Union()
}

System_Aaa_Authentication_AuthenticationMethod_Union is an interface that is implemented by valid types for the union for the leaf /openconfig-system/system/aaa/authentication/config/authentication-method within the YANG schema.

type System_Aaa_Authentication_AuthenticationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE 

type System_Aaa_Authentication_AuthenticationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE struct {
	E_OpenconfigAaaTypes_AAA_METHOD_TYPE E_OpenconfigAaaTypes_AAA_METHOD_TYPE
}

System_Aaa_Authentication_AuthenticationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE is used when /openconfig-system/system/aaa/authentication/config/authentication-method is to be set to a E_OpenconfigAaaTypes_AAA_METHOD_TYPE value.

func (*System_Aaa_Authentication_AuthenticationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE) Is_System_Aaa_Authentication_AuthenticationMethod_Union 

func (*System_Aaa_Authentication_AuthenticationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE) Is_System_Aaa_Authentication_AuthenticationMethod_Union()

Is_System_Aaa_Authentication_AuthenticationMethod_Union ensures that System_Aaa_Authentication_AuthenticationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE implements the System_Aaa_Authentication_AuthenticationMethod_Union interface.

type System_Aaa_Authentication_AuthenticationMethod_Union_String 

type System_Aaa_Authentication_AuthenticationMethod_Union_String struct {
	String string
}

System_Aaa_Authentication_AuthenticationMethod_Union_String is used when /openconfig-system/system/aaa/authentication/config/authentication-method is to be set to a string value.

func (*System_Aaa_Authentication_AuthenticationMethod_Union_String) Is_System_Aaa_Authentication_AuthenticationMethod_Union 

func (*System_Aaa_Authentication_AuthenticationMethod_Union_String) Is_System_Aaa_Authentication_AuthenticationMethod_Union()

Is_System_Aaa_Authentication_AuthenticationMethod_Union ensures that System_Aaa_Authentication_AuthenticationMethod_Union_String implements the System_Aaa_Authentication_AuthenticationMethod_Union interface.

type System_Aaa_Authentication_User 

type System_Aaa_Authentication_User struct {
	Password       *string                                   `path:"config/password" module:"openconfig-system"`
	PasswordHashed *string                                   `path:"config/password-hashed" module:"openconfig-system"`
	Role           System_Aaa_Authentication_User_Role_Union `path:"config/role" module:"openconfig-system"`
	SshKey         *string                                   `path:"config/ssh-key" module:"openconfig-system"`
	Username       *string                                   `path:"config/username|username" module:"openconfig-system"`
}

System_Aaa_Authentication_User represents the /openconfig-system/system/aaa/authentication/users/user YANG schema element.

func (*System_Aaa_Authentication_User) IsYANGGoStruct 

func (*System_Aaa_Authentication_User) IsYANGGoStruct()

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

func (*System_Aaa_Authentication_User) To_System_Aaa_Authentication_User_Role_Union 

func (t *System_Aaa_Authentication_User) To_System_Aaa_Authentication_User_Role_Union(i interface{}) (System_Aaa_Authentication_User_Role_Union, error)

To_System_Aaa_Authentication_User_Role_Union takes an input interface{} and attempts to convert it to a struct which implements the System_Aaa_Authentication_User_Role_Union union. It returns an error if the interface{} supplied cannot be converted to a type within the union.

func (*System_Aaa_Authentication_User) Validate 

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

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

func (*System_Aaa_Authentication_User) ΛEnumTypeMap 

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

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

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

type System_Aaa_Authentication_User_Role_Union 

type System_Aaa_Authentication_User_Role_Union interface {
	Is_System_Aaa_Authentication_User_Role_Union()
}

System_Aaa_Authentication_User_Role_Union is an interface that is implemented by valid types for the union for the leaf /openconfig-system/system/aaa/authentication/users/user/config/role within the YANG schema.

type System_Aaa_Authentication_User_Role_Union_E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES 

type System_Aaa_Authentication_User_Role_Union_E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES struct {
	E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES
}

System_Aaa_Authentication_User_Role_Union_E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES is used when /openconfig-system/system/aaa/authentication/users/user/config/role is to be set to a E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES value.

func (*System_Aaa_Authentication_User_Role_Union_E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES) Is_System_Aaa_Authentication_User_Role_Union 

func (*System_Aaa_Authentication_User_Role_Union_E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES) Is_System_Aaa_Authentication_User_Role_Union()

Is_System_Aaa_Authentication_User_Role_Union ensures that System_Aaa_Authentication_User_Role_Union_E_OpenconfigAaaTypes_SYSTEM_DEFINED_ROLES implements the System_Aaa_Authentication_User_Role_Union interface.

type System_Aaa_Authentication_User_Role_Union_String 

type System_Aaa_Authentication_User_Role_Union_String struct {
	String string
}

System_Aaa_Authentication_User_Role_Union_String is used when /openconfig-system/system/aaa/authentication/users/user/config/role is to be set to a string value.

func (*System_Aaa_Authentication_User_Role_Union_String) Is_System_Aaa_Authentication_User_Role_Union 

func (*System_Aaa_Authentication_User_Role_Union_String) Is_System_Aaa_Authentication_User_Role_Union()

Is_System_Aaa_Authentication_User_Role_Union ensures that System_Aaa_Authentication_User_Role_Union_String implements the System_Aaa_Authentication_User_Role_Union interface.

type System_Aaa_Authorization 

type System_Aaa_Authorization struct {
	AuthorizationMethod []System_Aaa_Authorization_AuthorizationMethod_Union                                  `path:"config/authorization-method" module:"openconfig-system"`
	Event               map[E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE]*System_Aaa_Authorization_Event `path:"events/event" module:"openconfig-system"`
}

System_Aaa_Authorization represents the /openconfig-system/system/aaa/authorization YANG schema element.

func (*System_Aaa_Authorization) IsYANGGoStruct 

func (*System_Aaa_Authorization) IsYANGGoStruct()

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

func (*System_Aaa_Authorization) NewEvent 

func (t *System_Aaa_Authorization) NewEvent(EventType E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE) (*System_Aaa_Authorization_Event, error)

NewEvent creates a new entry in the Event list of the System_Aaa_Authorization struct. The keys of the list are populated from the input arguments.

func (*System_Aaa_Authorization) To_System_Aaa_Authorization_AuthorizationMethod_Union 

func (t *System_Aaa_Authorization) To_System_Aaa_Authorization_AuthorizationMethod_Union(i interface{}) (System_Aaa_Authorization_AuthorizationMethod_Union, error)

To_System_Aaa_Authorization_AuthorizationMethod_Union takes an input interface{} and attempts to convert it to a struct which implements the System_Aaa_Authorization_AuthorizationMethod_Union union. It returns an error if the interface{} supplied cannot be converted to a type within the union.

func (*System_Aaa_Authorization) Validate 

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

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

func (*System_Aaa_Authorization) ΛEnumTypeMap 

func (t *System_Aaa_Authorization) Λ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 System_Aaa_Authorization_AuthorizationMethod_Union 

type System_Aaa_Authorization_AuthorizationMethod_Union interface {
	Is_System_Aaa_Authorization_AuthorizationMethod_Union()
}

System_Aaa_Authorization_AuthorizationMethod_Union is an interface that is implemented by valid types for the union for the leaf /openconfig-system/system/aaa/authorization/config/authorization-method within the YANG schema.

type System_Aaa_Authorization_AuthorizationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE 

type System_Aaa_Authorization_AuthorizationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE struct {
	E_OpenconfigAaaTypes_AAA_METHOD_TYPE E_OpenconfigAaaTypes_AAA_METHOD_TYPE
}

System_Aaa_Authorization_AuthorizationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE is used when /openconfig-system/system/aaa/authorization/config/authorization-method is to be set to a E_OpenconfigAaaTypes_AAA_METHOD_TYPE value.

func (*System_Aaa_Authorization_AuthorizationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE) Is_System_Aaa_Authorization_AuthorizationMethod_Union 

func (*System_Aaa_Authorization_AuthorizationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE) Is_System_Aaa_Authorization_AuthorizationMethod_Union()

Is_System_Aaa_Authorization_AuthorizationMethod_Union ensures that System_Aaa_Authorization_AuthorizationMethod_Union_E_OpenconfigAaaTypes_AAA_METHOD_TYPE implements the System_Aaa_Authorization_AuthorizationMethod_Union interface.

type System_Aaa_Authorization_AuthorizationMethod_Union_String 

type System_Aaa_Authorization_AuthorizationMethod_Union_String struct {
	String string
}

System_Aaa_Authorization_AuthorizationMethod_Union_String is used when /openconfig-system/system/aaa/authorization/config/authorization-method is to be set to a string value.

func (*System_Aaa_Authorization_AuthorizationMethod_Union_String) Is_System_Aaa_Authorization_AuthorizationMethod_Union 

func (*System_Aaa_Authorization_AuthorizationMethod_Union_String) Is_System_Aaa_Authorization_AuthorizationMethod_Union()

Is_System_Aaa_Authorization_AuthorizationMethod_Union ensures that System_Aaa_Authorization_AuthorizationMethod_Union_String implements the System_Aaa_Authorization_AuthorizationMethod_Union interface.

type System_Aaa_Authorization_Event 

type System_Aaa_Authorization_Event struct {
	EventType E_OpenconfigAaaTypes_AAA_AUTHORIZATION_EVENT_TYPE `path:"config/event-type|event-type" module:"openconfig-system"`
}

System_Aaa_Authorization_Event represents the /openconfig-system/system/aaa/authorization/events/event YANG schema element.

func (*System_Aaa_Authorization_Event) IsYANGGoStruct 

func (*System_Aaa_Authorization_Event) IsYANGGoStruct()

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

func (*System_Aaa_Authorization_Event) Validate 

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

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

func (*System_Aaa_Authorization_Event) ΛEnumTypeMap 

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

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

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

type System_Aaa_ServerGroup 

type System_Aaa_ServerGroup struct {
	Name   *string                                   `path:"config/name|name" module:"openconfig-system"`
	Server map[string]*System_Aaa_ServerGroup_Server `path:"servers/server" module:"openconfig-system"`
	Type   E_OpenconfigAaaTypes_AAA_SERVER_TYPE      `path:"config/type" module:"openconfig-system"`
}

System_Aaa_ServerGroup represents the /openconfig-system/system/aaa/server-groups/server-group YANG schema element.

func (*System_Aaa_ServerGroup) IsYANGGoStruct 

func (*System_Aaa_ServerGroup) IsYANGGoStruct()

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

func (*System_Aaa_ServerGroup) NewServer 

func (t *System_Aaa_ServerGroup) NewServer(Address string) (*System_Aaa_ServerGroup_Server, error)

NewServer creates a new entry in the Server list of the System_Aaa_ServerGroup struct. The keys of the list are populated from the input arguments.

func (*System_Aaa_ServerGroup) Validate 

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

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

func (*System_Aaa_ServerGroup) ΛEnumTypeMap 

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

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

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

type System_Aaa_ServerGroup_Server 

type System_Aaa_ServerGroup_Server struct {
	Address            *string                               `path:"config/address|address" module:"openconfig-system"`
	ConnectionAborts   *uint64                               `path:"state/connection-aborts" module:"openconfig-system"`
	ConnectionCloses   *uint64                               `path:"state/connection-closes" module:"openconfig-system"`
	ConnectionFailures *uint64                               `path:"state/connection-failures" module:"openconfig-system"`
	ConnectionOpens    *uint64                               `path:"state/connection-opens" module:"openconfig-system"`
	ConnectionTimeouts *uint64                               `path:"state/connection-timeouts" module:"openconfig-system"`
	ErrorsReceived     *uint64                               `path:"state/errors-received" module:"openconfig-system"`
	MessagesReceived   *uint64                               `path:"state/messages-received" module:"openconfig-system"`
	MessagesSent       *uint64                               `path:"state/messages-sent" module:"openconfig-system"`
	Name               *string                               `path:"config/name" module:"openconfig-system"`
	Radius             *System_Aaa_ServerGroup_Server_Radius `path:"radius" module:"openconfig-system"`
	Tacacs             *System_Aaa_ServerGroup_Server_Tacacs `path:"tacacs" module:"openconfig-system"`
	Timeout            *uint16                               `path:"config/timeout" module:"openconfig-system"`
}

System_Aaa_ServerGroup_Server represents the /openconfig-system/system/aaa/server-groups/server-group/servers/server YANG schema element.

func (*System_Aaa_ServerGroup_Server) IsYANGGoStruct 

func (*System_Aaa_ServerGroup_Server) IsYANGGoStruct()

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

func (*System_Aaa_ServerGroup_Server) Validate 

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

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

func (*System_Aaa_ServerGroup_Server) ΛEnumTypeMap 

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

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

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

type System_Aaa_ServerGroup_Server_Radius 

type System_Aaa_ServerGroup_Server_Radius struct {
	AcctPort           *uint16                                        `path:"config/acct-port" module:"openconfig-system"`
	AuthPort           *uint16                                        `path:"config/auth-port" module:"openconfig-system"`
	Counters           *System_Aaa_ServerGroup_Server_Radius_Counters `path:"state/counters" module:"openconfig-system"`
	RetransmitAttempts *uint8                                         `path:"config/retransmit-attempts" module:"openconfig-system"`
	SecretKey          *string                                        `path:"config/secret-key" module:"openconfig-system"`
	SourceAddress      *string                                        `path:"config/source-address" module:"openconfig-system"`
}

System_Aaa_ServerGroup_Server_Radius represents the /openconfig-system/system/aaa/server-groups/server-group/servers/server/radius YANG schema element.

func (*System_Aaa_ServerGroup_Server_Radius) IsYANGGoStruct 

func (*System_Aaa_ServerGroup_Server_Radius) IsYANGGoStruct()

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

func (*System_Aaa_ServerGroup_Server_Radius) Validate 

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

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

func (*System_Aaa_ServerGroup_Server_Radius) ΛEnumTypeMap 

func (t *System_Aaa_ServerGroup_Server_Radius) Λ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 System_Aaa_ServerGroup_Server_Radius_Counters 

type System_Aaa_ServerGroup_Server_Radius_Counters struct {
	AccessAccepts         *uint64 `path:"access-accepts" module:"openconfig-system"`
	AccessRejects         *uint64 `path:"access-rejects" module:"openconfig-system"`
	RetriedAccessRequests *uint64 `path:"retried-access-requests" module:"openconfig-system"`
	TimeoutAccessRequests *uint64 `path:"timeout-access-requests" module:"openconfig-system"`
}

System_Aaa_ServerGroup_Server_Radius_Counters represents the /openconfig-system/system/aaa/server-groups/server-group/servers/server/radius/state/counters YANG schema element.

func (*System_Aaa_ServerGroup_Server_Radius_Counters) IsYANGGoStruct 

func (*System_Aaa_ServerGroup_Server_Radius_Counters) IsYANGGoStruct()

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

func (*System_Aaa_ServerGroup_Server_Radius_Counters) Validate 

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

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

func (*System_Aaa_ServerGroup_Server_Radius_Counters) ΛEnumTypeMap 

func (t *System_Aaa_ServerGroup_Server_Radius_Counters) Λ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 System_Aaa_ServerGroup_Server_Tacacs 

type System_Aaa_ServerGroup_Server_Tacacs struct {
	Port          *uint16 `path:"config/port" module:"openconfig-system"`
	SecretKey     *string `path:"config/secret-key" module:"openconfig-system"`
	SourceAddress *string `path:"config/source-address" module:"openconfig-system"`
}

System_Aaa_ServerGroup_Server_Tacacs represents the /openconfig-system/system/aaa/server-groups/server-group/servers/server/tacacs YANG schema element.

func (*System_Aaa_ServerGroup_Server_Tacacs) IsYANGGoStruct 

func (*System_Aaa_ServerGroup_Server_Tacacs) IsYANGGoStruct()

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

func (*System_Aaa_ServerGroup_Server_Tacacs) Validate 

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

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

func (*System_Aaa_ServerGroup_Server_Tacacs) ΛEnumTypeMap 

func (t *System_Aaa_ServerGroup_Server_Tacacs) Λ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 System_Alarm 

type System_Alarm struct {
	Id          *string                                          `path:"state/id|id" module:"openconfig-system"`
	Resource    *string                                          `path:"state/resource" module:"openconfig-system"`
	Severity    E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_SEVERITY `path:"state/severity" module:"openconfig-system"`
	Text        *string                                          `path:"state/text" module:"openconfig-system"`
	TimeCreated *uint64                                          `path:"state/time-created" module:"openconfig-system"`
	TypeId      System_Alarm_TypeId_Union                        `path:"state/type-id" module:"openconfig-system"`
}

System_Alarm represents the /openconfig-system/system/alarms/alarm YANG schema element.

func (*System_Alarm) IsYANGGoStruct 

func (*System_Alarm) IsYANGGoStruct()

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

func (*System_Alarm) To_System_Alarm_TypeId_Union 

func (t *System_Alarm) To_System_Alarm_TypeId_Union(i interface{}) (System_Alarm_TypeId_Union, error)

To_System_Alarm_TypeId_Union takes an input interface{} and attempts to convert it to a struct which implements the System_Alarm_TypeId_Union union. It returns an error if the interface{} supplied cannot be converted to a type within the union.

func (*System_Alarm) Validate 

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

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

func (*System_Alarm) ΛEnumTypeMap 

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

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

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

type System_Alarm_TypeId_Union 

type System_Alarm_TypeId_Union interface {
	Is_System_Alarm_TypeId_Union()
}

System_Alarm_TypeId_Union is an interface that is implemented by valid types for the union for the leaf /openconfig-system/system/alarms/alarm/state/type-id within the YANG schema.

type System_Alarm_TypeId_Union_E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID 

type System_Alarm_TypeId_Union_E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID struct {
	E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID
}

System_Alarm_TypeId_Union_E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID is used when /openconfig-system/system/alarms/alarm/state/type-id is to be set to a E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID value.

func (*System_Alarm_TypeId_Union_E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID) Is_System_Alarm_TypeId_Union 

func (*System_Alarm_TypeId_Union_E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID) Is_System_Alarm_TypeId_Union()

Is_System_Alarm_TypeId_Union ensures that System_Alarm_TypeId_Union_E_OpenconfigAlarmTypes_OPENCONFIG_ALARM_TYPE_ID implements the System_Alarm_TypeId_Union interface.

type System_Alarm_TypeId_Union_String 

type System_Alarm_TypeId_Union_String struct {
	String string
}

System_Alarm_TypeId_Union_String is used when /openconfig-system/system/alarms/alarm/state/type-id is to be set to a string value.

func (*System_Alarm_TypeId_Union_String) Is_System_Alarm_TypeId_Union 

func (*System_Alarm_TypeId_Union_String) Is_System_Alarm_TypeId_Union()

Is_System_Alarm_TypeId_Union ensures that System_Alarm_TypeId_Union_String implements the System_Alarm_TypeId_Union interface.

type System_Clock 

type System_Clock struct {
	TimezoneName *string `path:"config/timezone-name" module:"openconfig-system"`
}

System_Clock represents the /openconfig-system/system/clock YANG schema element.

func (*System_Clock) IsYANGGoStruct 

func (*System_Clock) IsYANGGoStruct()

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

func (*System_Clock) Validate 

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

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

func (*System_Clock) ΛEnumTypeMap 

func (t *System_Clock) Λ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 System_Cpu 

type System_Cpu struct {
	HardwareInterrupt *System_Cpu_HardwareInterrupt `path:"state/hardware-interrupt" module:"openconfig-system"`
	Idle              *System_Cpu_Idle              `path:"state/idle" module:"openconfig-system"`
	Index             System_Cpu_Index_Union        `path:"state/index|index" module:"openconfig-system"`
	Kernel            *System_Cpu_Kernel            `path:"state/kernel" module:"openconfig-system"`
	Nice              *System_Cpu_Nice              `path:"state/nice" module:"openconfig-system"`
	SoftwareInterrupt *System_Cpu_SoftwareInterrupt `path:"state/software-interrupt" module:"openconfig-system"`
	Total             *System_Cpu_Total             `path:"state/total" module:"openconfig-system"`
	User              *System_Cpu_User              `path:"state/user" module:"openconfig-system"`
	Wait              *System_Cpu_Wait              `path:"state/wait" module:"openconfig-system"`
}

System_Cpu represents the /openconfig-system/system/cpus/cpu YANG schema element.

func (*System_Cpu) IsYANGGoStruct 

func (*System_Cpu) IsYANGGoStruct()

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

func (*System_Cpu) To_System_Cpu_Index_Union 

func (t *System_Cpu) To_System_Cpu_Index_Union(i interface{}) (System_Cpu_Index_Union, error)

To_System_Cpu_Index_Union takes an input interface{} and attempts to convert it to a struct which implements the System_Cpu_Index_Union union. It returns an error if the interface{} supplied cannot be converted to a type within the union.

func (*System_Cpu) Validate 

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

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

func (*System_Cpu) ΛEnumTypeMap 

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

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

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

type System_Cpu_HardwareInterrupt 

type System_Cpu_HardwareInterrupt struct {
	Avg      *uint8  `path:"avg" module:"openconfig-system"`
	Instant  *uint8  `path:"instant" module:"openconfig-system"`
	Interval *uint64 `path:"interval" module:"openconfig-system"`
	Max      *uint8  `path:"max" module:"openconfig-system"`
	MaxTime  *uint64 `path:"max-time" module:"openconfig-system"`
	Min      *uint8  `path:"min" module:"openconfig-system"`
	MinTime  *uint64 `path:"min-time" module:"openconfig-system"`
}

System_Cpu_HardwareInterrupt represents the /openconfig-system/system/cpus/cpu/state/hardware-interrupt YANG schema element.

func (*System_Cpu_HardwareInterrupt) IsYANGGoStruct 

func (*System_Cpu_HardwareInterrupt) IsYANGGoStruct()

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

func (*System_Cpu_HardwareInterrupt) Validate 

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

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

func (*System_Cpu_HardwareInterrupt) ΛEnumTypeMap 

func (t *System_Cpu_HardwareInterrupt) Λ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 System_Cpu_Idle 

type System_Cpu_Idle struct {
	Avg      *uint8  `path:"avg" module:"openconfig-system"`
	Instant  *uint8  `path:"instant" module:"openconfig-system"`
	Interval *uint64 `path:"interval" module:"openconfig-system"`
	Max      *uint8  `path:"max" module:"openconfig-system"`
	MaxTime  *uint64 `path:"max-time" module:"openconfig-system"`
	Min      *uint8  `path:"min" module:"openconfig-system"`
	MinTime  *uint64 `path:"min-time" module:"openconfig-system"`
}

System_Cpu_Idle represents the /openconfig-system/system/cpus/cpu/state/idle YANG schema element.

func (*System_Cpu_Idle) IsYANGGoStruct 

func (*System_Cpu_Idle) IsYANGGoStruct()

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

func (*System_Cpu_Idle) Validate 

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

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

func (*System_Cpu_Idle) ΛEnumTypeMap 

func (t *System_Cpu_Idle) Λ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 System_Cpu_Index_Union 

type System_Cpu_Index_Union interface {
	Is_System_Cpu_Index_Union()
}

System_Cpu_Index_Union is an interface that is implemented by valid types for the union for the leaf /openconfig-system/system/cpus/cpu/state/index within the YANG schema.

type System_Cpu_Index_Union_E_OpenconfigSystem_Cpu_Index 

type System_Cpu_Index_Union_E_OpenconfigSystem_Cpu_Index struct {
	E_OpenconfigSystem_Cpu_Index E_OpenconfigSystem_Cpu_Index
}

System_Cpu_Index_Union_E_OpenconfigSystem_Cpu_Index is used when /openconfig-system/system/cpus/cpu/state/index is to be set to a E_OpenconfigSystem_Cpu_Index value.

func (*System_Cpu_Index_Union_E_OpenconfigSystem_Cpu_Index) Is_System_Cpu_Index_Union 

func (*System_Cpu_Index_Union_E_OpenconfigSystem_Cpu_Index) Is_System_Cpu_Index_Union()

Is_System_Cpu_Index_Union ensures that System_Cpu_Index_Union_E_OpenconfigSystem_Cpu_Index implements the System_Cpu_Index_Union interface.

type System_Cpu_Index_Union_Uint32 

type System_Cpu_Index_Union_Uint32 struct {
	Uint32 uint32
}

System_Cpu_Index_Union_Uint32 is used when /openconfig-system/system/cpus/cpu/state/index is to be set to a uint32 value.

func (*System_Cpu_Index_Union_Uint32) Is_System_Cpu_Index_Union 

func (*System_Cpu_Index_Union_Uint32) Is_System_Cpu_Index_Union()

Is_System_Cpu_Index_Union ensures that System_Cpu_Index_Union_Uint32 implements the System_Cpu_Index_Union interface.

type System_Cpu_Kernel 

type System_Cpu_Kernel struct {
	Avg      *uint8  `path:"avg" module:"openconfig-system"`
	Instant  *uint8  `path:"instant" module:"openconfig-system"`
	Interval *uint64 `path:"interval" module:"openconfig-system"`
	Max      *uint8  `path:"max" module:"openconfig-system"`
	MaxTime  *uint64 `path:"max-time" module:"openconfig-system"`
	Min      *uint8  `path:"min" module:"openconfig-system"`
	MinTime  *uint64 `path:"min-time" module:"openconfig-system"`
}

System_Cpu_Kernel represents the /openconfig-system/system/cpus/cpu/state/kernel YANG schema element.

func (*System_Cpu_Kernel) IsYANGGoStruct 

func (*System_Cpu_Kernel) IsYANGGoStruct()

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

func (*System_Cpu_Kernel) Validate 

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

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

func (*System_Cpu_Kernel) ΛEnumTypeMap 

func (t *System_Cpu_Kernel) Λ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 System_Cpu_Nice 

type System_Cpu_Nice struct {
	Avg      *uint8  `path:"avg" module:"openconfig-system"`
	Instant  *uint8  `path:"instant" module:"openconfig-system"`
	Interval *uint64 `path:"interval" module:"openconfig-system"`
	Max      *uint8  `path:"max" module:"openconfig-system"`
	MaxTime  *uint64 `path:"max-time" module:"openconfig-system"`
	Min      *uint8  `path:"min" module:"openconfig-system"`
	MinTime  *uint64 `path:"min-time" module:"openconfig-system"`
}

System_Cpu_Nice represents the /openconfig-system/system/cpus/cpu/state/nice YANG schema element.

func (*System_Cpu_Nice) IsYANGGoStruct 

func (*System_Cpu_Nice) IsYANGGoStruct()

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

func (*System_Cpu_Nice) Validate 

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

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

func (*System_Cpu_Nice) ΛEnumTypeMap 

func (t *System_Cpu_Nice) Λ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 System_Cpu_SoftwareInterrupt 

type System_Cpu_SoftwareInterrupt struct {
	Avg      *uint8  `path:"avg" module:"openconfig-system"`
	Instant  *uint8  `path:"instant" module:"openconfig-system"`
	Interval *uint64 `path:"interval" module:"openconfig-system"`
	Max      *uint8  `path:"max" module:"openconfig-system"`
	MaxTime  *uint64 `path:"max-time" module:"openconfig-system"`
	Min      *uint8  `path:"min" module:"openconfig-system"`
	MinTime  *uint64 `path:"min-time" module:"openconfig-system"`
}

System_Cpu_SoftwareInterrupt represents the /openconfig-system/system/cpus/cpu/state/software-interrupt YANG schema element.

func (*System_Cpu_SoftwareInterrupt) IsYANGGoStruct 

func (*System_Cpu_SoftwareInterrupt) IsYANGGoStruct()

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

func (*System_Cpu_SoftwareInterrupt) Validate 

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

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

func (*System_Cpu_SoftwareInterrupt) ΛEnumTypeMap 

func (t *System_Cpu_SoftwareInterrupt) Λ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 System_Cpu_Total 

type System_Cpu_Total struct {
	Avg      *uint8  `path:"avg" module:"openconfig-system"`
	Instant  *uint8  `path:"instant" module:"openconfig-system"`
	Interval *uint64 `path:"interval" module:"openconfig-system"`
	Max      *uint8  `path:"max" module:"openconfig-system"`
	MaxTime  *uint64 `path:"max-time" module:"openconfig-system"`
	Min      *uint8  `path:"min" module:"openconfig-system"`
	MinTime  *uint64 `path:"min-time" module:"openconfig-system"`
}

System_Cpu_Total represents the /openconfig-system/system/cpus/cpu/state/total YANG schema element.

func (*System_Cpu_Total) IsYANGGoStruct 

func (*System_Cpu_Total) IsYANGGoStruct()

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

func (*System_Cpu_Total) Validate 

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

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

func (*System_Cpu_Total) ΛEnumTypeMap 

func (t *System_Cpu_Total) Λ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 System_Cpu_User 

type System_Cpu_User struct {
	Avg      *uint8  `path:"avg" module:"openconfig-system"`
	Instant  *uint8  `path:"instant" module:"openconfig-system"`
	Interval *uint64 `path:"interval" module:"openconfig-system"`
	Max      *uint8  `path:"max" module:"openconfig-system"`
	MaxTime  *uint64 `path:"max-time" module:"openconfig-system"`
	Min      *uint8  `path:"min" module:"openconfig-system"`
	MinTime  *uint64 `path:"min-time" module:"openconfig-system"`
}

System_Cpu_User represents the /openconfig-system/system/cpus/cpu/state/user YANG schema element.

func (*System_Cpu_User) IsYANGGoStruct 

func (*System_Cpu_User) IsYANGGoStruct()

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

func (*System_Cpu_User) Validate 

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

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

func (*System_Cpu_User) ΛEnumTypeMap 

func (t *System_Cpu_User) Λ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 System_Cpu_Wait 

type System_Cpu_Wait struct {
	Avg      *uint8  `path:"avg" module:"openconfig-system"`
	Instant  *uint8  `path:"instant" module:"openconfig-system"`
	Interval *uint64 `path:"interval" module:"openconfig-system"`
	Max      *uint8  `path:"max" module:"openconfig-system"`
	MaxTime  *uint64 `path:"max-time" module:"openconfig-system"`
	Min      *uint8  `path:"min" module:"openconfig-system"`
	MinTime  *uint64 `path:"min-time" module:"openconfig-system"`
}

System_Cpu_Wait represents the /openconfig-system/system/cpus/cpu/state/wait YANG schema element.

func (*System_Cpu_Wait) IsYANGGoStruct 

func (*System_Cpu_Wait) IsYANGGoStruct()

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

func (*System_Cpu_Wait) Validate 

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

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

func (*System_Cpu_Wait) ΛEnumTypeMap 

func (t *System_Cpu_Wait) Λ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 System_Dns 

type System_Dns struct {
	HostEntry map[string]*System_Dns_HostEntry `path:"host-entries/host-entry" module:"openconfig-system"`
	Search    []string                         `path:"config/search" module:"openconfig-system"`
	Server    map[string]*System_Dns_Server    `path:"servers/server" module:"openconfig-system"`
}

System_Dns represents the /openconfig-system/system/dns YANG schema element.

func (*System_Dns) IsYANGGoStruct 

func (*System_Dns) IsYANGGoStruct()

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

func (*System_Dns) NewHostEntry 

func (t *System_Dns) NewHostEntry(Hostname string) (*System_Dns_HostEntry, error)

NewHostEntry creates a new entry in the HostEntry list of the System_Dns struct. The keys of the list are populated from the input arguments.

func (*System_Dns) NewServer 

func (t *System_Dns) NewServer(Address string) (*System_Dns_Server, error)

NewServer creates a new entry in the Server list of the System_Dns struct. The keys of the list are populated from the input arguments.

func (*System_Dns) Validate 

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

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

func (*System_Dns) ΛEnumTypeMap 

func (t *System_Dns) Λ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 System_Dns_HostEntry 

type System_Dns_HostEntry struct {
	Alias       []string `path:"config/alias" module:"openconfig-system"`
	Hostname    *string  `path:"config/hostname|hostname" module:"openconfig-system"`
	Ipv4Address []string `path:"config/ipv4-address" module:"openconfig-system"`
	Ipv6Address []string `path:"config/ipv6-address" module:"openconfig-system"`
}

System_Dns_HostEntry represents the /openconfig-system/system/dns/host-entries/host-entry YANG schema element.

func (*System_Dns_HostEntry) IsYANGGoStruct 

func (*System_Dns_HostEntry) IsYANGGoStruct()

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

func (*System_Dns_HostEntry) Validate 

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

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

func (*System_Dns_HostEntry) ΛEnumTypeMap 

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

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

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

type System_Dns_Server 

type System_Dns_Server struct {
	Address *string `path:"config/address|address" module:"openconfig-system"`
	Port    *uint16 `path:"config/port" module:"openconfig-system"`
}

System_Dns_Server represents the /openconfig-system/system/dns/servers/server YANG schema element.

func (*System_Dns_Server) IsYANGGoStruct 

func (*System_Dns_Server) IsYANGGoStruct()

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

func (*System_Dns_Server) Validate 

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

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

func (*System_Dns_Server) ΛEnumTypeMap 

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

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

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

type System_GrpcServer 

type System_GrpcServer struct {
	CertificateId     *string                                   `path:"config/certificate-id" module:"openconfig-system"`
	Enable            *bool                                     `path:"config/enable" module:"openconfig-system"`
	ListenAddresses   []System_GrpcServer_ListenAddresses_Union `path:"config/listen-addresses" module:"openconfig-system"`
	Port              *uint16                                   `path:"config/port" module:"openconfig-system"`
	TransportSecurity *bool                                     `path:"config/transport-security" module:"openconfig-system"`
}

System_GrpcServer represents the /openconfig-system/system/grpc-server YANG schema element.

func (*System_GrpcServer) IsYANGGoStruct 

func (*System_GrpcServer) IsYANGGoStruct()

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

func (*System_GrpcServer) To_System_GrpcServer_ListenAddresses_Union 

func (t *System_GrpcServer) To_System_GrpcServer_ListenAddresses_Union(i interface{}) (System_GrpcServer_ListenAddresses_Union, error)

To_System_GrpcServer_ListenAddresses_Union takes an input interface{} and attempts to convert it to a struct which implements the System_GrpcServer_ListenAddresses_Union union. It returns an error if the interface{} supplied cannot be converted to a type within the union.

func (*System_GrpcServer) Validate 

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

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

func (*System_GrpcServer) ΛEnumTypeMap 

func (t *System_GrpcServer) Λ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 System_GrpcServer_ListenAddresses_Union 

type System_GrpcServer_ListenAddresses_Union interface {
	Is_System_GrpcServer_ListenAddresses_Union()
}

System_GrpcServer_ListenAddresses_Union is an interface that is implemented by valid types for the union for the leaf /openconfig-system/system/grpc-server/config/listen-addresses within the YANG schema.

type System_GrpcServer_ListenAddresses_Union_E_OpenconfigSystemManagement_GrpcServer_ListenAddresses 

type System_GrpcServer_ListenAddresses_Union_E_OpenconfigSystemManagement_GrpcServer_ListenAddresses struct {
	E_OpenconfigSystemManagement_GrpcServer_ListenAddresses E_OpenconfigSystemManagement_GrpcServer_ListenAddresses
}

System_GrpcServer_ListenAddresses_Union_E_OpenconfigSystemManagement_GrpcServer_ListenAddresses is used when /openconfig-system/system/grpc-server/config/listen-addresses is to be set to a E_OpenconfigSystemManagement_GrpcServer_ListenAddresses value.

func (*System_GrpcServer_ListenAddresses_Union_E_OpenconfigSystemManagement_GrpcServer_ListenAddresses) Is_System_GrpcServer_ListenAddresses_Union 

func (*System_GrpcServer_ListenAddresses_Union_E_OpenconfigSystemManagement_GrpcServer_ListenAddresses) Is_System_GrpcServer_ListenAddresses_Union()

Is_System_GrpcServer_ListenAddresses_Union ensures that System_GrpcServer_ListenAddresses_Union_E_OpenconfigSystemManagement_GrpcServer_ListenAddresses implements the System_GrpcServer_ListenAddresses_Union interface.

type System_GrpcServer_ListenAddresses_Union_String 

type System_GrpcServer_ListenAddresses_Union_String struct {
	String string
}

System_GrpcServer_ListenAddresses_Union_String is used when /openconfig-system/system/grpc-server/config/listen-addresses is to be set to a string value.

func (*System_GrpcServer_ListenAddresses_Union_String) Is_System_GrpcServer_ListenAddresses_Union 

func (*System_GrpcServer_ListenAddresses_Union_String) Is_System_GrpcServer_ListenAddresses_Union()

Is_System_GrpcServer_ListenAddresses_Union ensures that System_GrpcServer_ListenAddresses_Union_String implements the System_GrpcServer_ListenAddresses_Union interface.

type System_Logging 

type System_Logging struct {
	Console      *System_Logging_Console                 `path:"console" module:"openconfig-system"`
	RemoteServer map[string]*System_Logging_RemoteServer `path:"remote-servers/remote-server" module:"openconfig-system"`
}

System_Logging represents the /openconfig-system/system/logging YANG schema element.

func (*System_Logging) IsYANGGoStruct 

func (*System_Logging) IsYANGGoStruct()

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

func (*System_Logging) NewRemoteServer 

func (t *System_Logging) NewRemoteServer(Host string) (*System_Logging_RemoteServer, error)

NewRemoteServer creates a new entry in the RemoteServer list of the System_Logging struct. The keys of the list are populated from the input arguments.

func (*System_Logging) Validate 

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

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

func (*System_Logging) ΛEnumTypeMap 

func (t *System_Logging) Λ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 System_Logging_Console 

type System_Logging_Console struct {
	Selector map[System_Logging_Console_Selector_Key]*System_Logging_Console_Selector `path:"selectors/selector" module:"openconfig-system"`
}

System_Logging_Console represents the /openconfig-system/system/logging/console YANG schema element.

func (*System_Logging_Console) IsYANGGoStruct 

func (*System_Logging_Console) IsYANGGoStruct()

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

func (*System_Logging_Console) NewSelector 

func (t *System_Logging_Console) NewSelector(Facility E_OpenconfigSystemLogging_SYSLOG_FACILITY, Severity E_OpenconfigSystemLogging_SyslogSeverity) (*System_Logging_Console_Selector, error)

NewSelector creates a new entry in the Selector list of the System_Logging_Console struct. The keys of the list are populated from the input arguments.

func (*System_Logging_Console) Validate 

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

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

func (*System_Logging_Console) ΛEnumTypeMap 

func (t *System_Logging_Console) Λ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 System_Logging_Console_Selector 

type System_Logging_Console_Selector struct {
	Facility E_OpenconfigSystemLogging_SYSLOG_FACILITY `path:"config/facility|facility" module:"openconfig-system"`
	Severity E_OpenconfigSystemLogging_SyslogSeverity  `path:"config/severity|severity" module:"openconfig-system"`
}

System_Logging_Console_Selector represents the /openconfig-system/system/logging/console/selectors/selector YANG schema element.

func (*System_Logging_Console_Selector) IsYANGGoStruct 

func (*System_Logging_Console_Selector) IsYANGGoStruct()

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

func (*System_Logging_Console_Selector) Validate 

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

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

func (*System_Logging_Console_Selector) ΛEnumTypeMap 

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

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

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

type System_Logging_Console_Selector_Key 

type System_Logging_Console_Selector_Key struct {
	Facility E_OpenconfigSystemLogging_SYSLOG_FACILITY `path:"facility"`
	Severity E_OpenconfigSystemLogging_SyslogSeverity  `path:"severity"`
}

System_Logging_Console_Selector_Key represents the key for list Selector of element /openconfig-system/system/logging/console.

type System_Logging_RemoteServer 

type System_Logging_RemoteServer struct {
	Host          *string                                                                            `path:"config/host|host" module:"openconfig-system"`
	RemotePort    *uint16                                                                            `path:"config/remote-port" module:"openconfig-system"`
	Selector      map[System_Logging_RemoteServer_Selector_Key]*System_Logging_RemoteServer_Selector `path:"selectors/selector" module:"openconfig-system"`
	SourceAddress *string                                                                            `path:"config/source-address" module:"openconfig-system"`
}

System_Logging_RemoteServer represents the /openconfig-system/system/logging/remote-servers/remote-server YANG schema element.

func (*System_Logging_RemoteServer) IsYANGGoStruct 

func (*System_Logging_RemoteServer) IsYANGGoStruct()

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

func (*System_Logging_RemoteServer) NewSelector 

func (t *System_Logging_RemoteServer) NewSelector(Facility E_OpenconfigSystemLogging_SYSLOG_FACILITY, Severity E_OpenconfigSystemLogging_SyslogSeverity) (*System_Logging_RemoteServer_Selector, error)

NewSelector creates a new entry in the Selector list of the System_Logging_RemoteServer struct. The keys of the list are populated from the input arguments.

func (*System_Logging_RemoteServer) Validate 

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

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

func (*System_Logging_RemoteServer) ΛEnumTypeMap 

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

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

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

type System_Logging_RemoteServer_Selector 

type System_Logging_RemoteServer_Selector struct {
	Facility E_OpenconfigSystemLogging_SYSLOG_FACILITY `path:"config/facility|facility" module:"openconfig-system"`
	Severity E_OpenconfigSystemLogging_SyslogSeverity  `path:"config/severity|severity" module:"openconfig-system"`
}

System_Logging_RemoteServer_Selector represents the /openconfig-system/system/logging/remote-servers/remote-server/selectors/selector YANG schema element.

func (*System_Logging_RemoteServer_Selector) IsYANGGoStruct 

func (*System_Logging_RemoteServer_Selector) IsYANGGoStruct()

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

func (*System_Logging_RemoteServer_Selector) Validate 

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

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

func (*System_Logging_RemoteServer_Selector) ΛEnumTypeMap 

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

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

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

type System_Logging_RemoteServer_Selector_Key 

type System_Logging_RemoteServer_Selector_Key struct {
	Facility E_OpenconfigSystemLogging_SYSLOG_FACILITY `path:"facility"`
	Severity E_OpenconfigSystemLogging_SyslogSeverity  `path:"severity"`
}

System_Logging_RemoteServer_Selector_Key represents the key for list Selector of element /openconfig-system/system/logging/remote-servers/remote-server.

type System_Memory 

type System_Memory struct {
	Physical *uint64 `path:"state/physical" module:"openconfig-system"`
	Reserved *uint64 `path:"state/reserved" module:"openconfig-system"`
}

System_Memory represents the /openconfig-system/system/memory YANG schema element.

func (*System_Memory) IsYANGGoStruct 

func (*System_Memory) IsYANGGoStruct()

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

func (*System_Memory) Validate 

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

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

func (*System_Memory) ΛEnumTypeMap 

func (t *System_Memory) Λ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 System_Ntp 

type System_Ntp struct {
	AuthMismatch     *uint64                       `path:"state/auth-mismatch" module:"openconfig-system"`
	EnableNtpAuth    *bool                         `path:"config/enable-ntp-auth" module:"openconfig-system"`
	Enabled          *bool                         `path:"config/enabled" module:"openconfig-system"`
	NtpKey           map[uint16]*System_Ntp_NtpKey `path:"ntp-keys/ntp-key" module:"openconfig-system"`
	NtpSourceAddress *string                       `path:"config/ntp-source-address" module:"openconfig-system"`
	Server           map[string]*System_Ntp_Server `path:"servers/server" module:"openconfig-system"`
}

System_Ntp represents the /openconfig-system/system/ntp YANG schema element.

func (*System_Ntp) IsYANGGoStruct 

func (*System_Ntp) IsYANGGoStruct()

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

func (*System_Ntp) NewNtpKey 

func (t *System_Ntp) NewNtpKey(KeyId uint16) (*System_Ntp_NtpKey, error)

NewNtpKey creates a new entry in the NtpKey list of the System_Ntp struct. The keys of the list are populated from the input arguments.

func (*System_Ntp) NewServer 

func (t *System_Ntp) NewServer(Address string) (*System_Ntp_Server, error)

NewServer creates a new entry in the Server list of the System_Ntp struct. The keys of the list are populated from the input arguments.

func (*System_Ntp) Validate 

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

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

func (*System_Ntp) ΛEnumTypeMap 

func (t *System_Ntp) Λ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 System_Ntp_NtpKey 

type System_Ntp_NtpKey struct {
	KeyId    *uint16                          `path:"config/key-id|key-id" module:"openconfig-system"`
	KeyType  E_OpenconfigSystem_NTP_AUTH_TYPE `path:"config/key-type" module:"openconfig-system"`
	KeyValue *string                          `path:"config/key-value" module:"openconfig-system"`
}

System_Ntp_NtpKey represents the /openconfig-system/system/ntp/ntp-keys/ntp-key YANG schema element.

func (*System_Ntp_NtpKey) IsYANGGoStruct 

func (*System_Ntp_NtpKey) IsYANGGoStruct()

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

func (*System_Ntp_NtpKey) Validate 

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

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

func (*System_Ntp_NtpKey) ΛEnumTypeMap 

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

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

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

type System_Ntp_Server 

type System_Ntp_Server struct {
	Address         *string                                   `path:"config/address|address" module:"openconfig-system"`
	AssociationType E_OpenconfigSystem_Server_AssociationType `path:"config/association-type" module:"openconfig-system"`
	Iburst          *bool                                     `path:"config/iburst" module:"openconfig-system"`
	Offset          *uint64                                   `path:"state/offset" module:"openconfig-system"`
	PollInterval    *uint32                                   `path:"state/poll-interval" module:"openconfig-system"`
	Port            *uint16                                   `path:"config/port" module:"openconfig-system"`
	Prefer          *bool                                     `path:"config/prefer" module:"openconfig-system"`
	RootDelay       *uint32                                   `path:"state/root-delay" module:"openconfig-system"`
	RootDispersion  *uint64                                   `path:"state/root-dispersion" module:"openconfig-system"`
	Stratum         *uint8                                    `path:"state/stratum" module:"openconfig-system"`
	Version         *uint8                                    `path:"config/version" module:"openconfig-system"`
}

System_Ntp_Server represents the /openconfig-system/system/ntp/servers/server YANG schema element.

func (*System_Ntp_Server) IsYANGGoStruct 

func (*System_Ntp_Server) IsYANGGoStruct()

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

func (*System_Ntp_Server) Validate 

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

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

func (*System_Ntp_Server) ΛEnumTypeMap 

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

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

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

type System_Openflow 

type System_Openflow struct {
	Agent      *System_Openflow_Agent                 `path:"agent" module:"openconfig-openflow"`
	Controller map[string]*System_Openflow_Controller `path:"controllers/controller" module:"openconfig-openflow"`
}

System_Openflow represents the /openconfig-system/system/openflow YANG schema element.

func (*System_Openflow) IsYANGGoStruct 

func (*System_Openflow) IsYANGGoStruct()

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

func (*System_Openflow) NewController 

func (t *System_Openflow) NewController(Name string) (*System_Openflow_Controller, error)

NewController creates a new entry in the Controller list of the System_Openflow struct. The keys of the list are populated from the input arguments.

func (*System_Openflow) Validate 

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

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

func (*System_Openflow) ΛEnumTypeMap 

func (t *System_Openflow) Λ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 System_Openflow_Agent 

type System_Openflow_Agent struct {
	BackoffInterval *uint32                          `path:"config/backoff-interval" module:"openconfig-openflow"`
	DatapathId      *string                          `path:"config/datapath-id" module:"openconfig-openflow"`
	FailureMode     E_OpenconfigOpenflow_FailureMode `path:"config/failure-mode" module:"openconfig-openflow"`
	InactivityProbe *uint32                          `path:"config/inactivity-probe" module:"openconfig-openflow"`
	MaxBackoff      *uint32                          `path:"config/max-backoff" module:"openconfig-openflow"`
}

System_Openflow_Agent represents the /openconfig-system/system/openflow/agent YANG schema element.

func (*System_Openflow_Agent) IsYANGGoStruct 

func (*System_Openflow_Agent) IsYANGGoStruct()

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

func (*System_Openflow_Agent) Validate 

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

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

func (*System_Openflow_Agent) ΛEnumTypeMap 

func (t *System_Openflow_Agent) Λ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 System_Openflow_Controller 

type System_Openflow_Controller struct {
	Connection map[uint8]*System_Openflow_Controller_Connection `path:"connections/connection" module:"openconfig-openflow"`
	Name       *string                                          `path:"config/name|name" module:"openconfig-openflow"`
}

System_Openflow_Controller represents the /openconfig-system/system/openflow/controllers/controller YANG schema element.

func (*System_Openflow_Controller) IsYANGGoStruct 

func (*System_Openflow_Controller) IsYANGGoStruct()

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

func (*System_Openflow_Controller) NewConnection 

func (t *System_Openflow_Controller) NewConnection(AuxId uint8) (*System_Openflow_Controller_Connection, error)

NewConnection creates a new entry in the Connection list of the System_Openflow_Controller struct. The keys of the list are populated from the input arguments.

func (*System_Openflow_Controller) Validate 

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

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

func (*System_Openflow_Controller) ΛEnumTypeMap 

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

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

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

type System_Openflow_Controller_Connection 

type System_Openflow_Controller_Connection struct {
	Address         *string                        `path:"config/address" module:"openconfig-openflow"`
	AuxId           *uint8                         `path:"config/aux-id|aux-id" module:"openconfig-openflow"`
	CertificateId   *string                        `path:"config/certificate-id" module:"openconfig-openflow"`
	Connected       *bool                          `path:"state/connected" module:"openconfig-openflow"`
	Port            *uint16                        `path:"config/port" module:"openconfig-openflow"`
	Priority        *uint8                         `path:"config/priority" module:"openconfig-openflow"`
	SourceInterface *string                        `path:"config/source-interface" module:"openconfig-openflow"`
	Transport       E_OpenconfigOpenflow_Transport `path:"config/transport" module:"openconfig-openflow"`
}

System_Openflow_Controller_Connection represents the /openconfig-system/system/openflow/controllers/controller/connections/connection YANG schema element.

func (*System_Openflow_Controller_Connection) IsYANGGoStruct 

func (*System_Openflow_Controller_Connection) IsYANGGoStruct()

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

func (*System_Openflow_Controller_Connection) Validate 

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

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

func (*System_Openflow_Controller_Connection) ΛEnumTypeMap 

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

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

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

type System_Process 

type System_Process struct {
	Args              []string `path:"state/args" module:"openconfig-system"`
	CpuUsageSystem    *uint64  `path:"state/cpu-usage-system" module:"openconfig-system"`
	CpuUsageUser      *uint64  `path:"state/cpu-usage-user" module:"openconfig-system"`
	CpuUtilization    *uint8   `path:"state/cpu-utilization" module:"openconfig-system"`
	MemoryUsage       *uint64  `path:"state/memory-usage" module:"openconfig-system"`
	MemoryUtilization *uint8   `path:"state/memory-utilization" module:"openconfig-system"`
	Name              *string  `path:"state/name" module:"openconfig-system"`
	Pid               *uint64  `path:"state/pid|pid" module:"openconfig-system"`
	StartTime         *uint64  `path:"state/start-time" module:"openconfig-system"`
	Uptime            *uint64  `path:"state/uptime" module:"openconfig-system"`
}

System_Process represents the /openconfig-system/system/processes/process YANG schema element.

func (*System_Process) IsYANGGoStruct 

func (*System_Process) IsYANGGoStruct()

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

func (*System_Process) Validate 

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

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

func (*System_Process) ΛEnumTypeMap 

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

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

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

type System_SshServer 

type System_SshServer struct {
	Enable          *bool                                                `path:"config/enable" module:"openconfig-system"`
	ProtocolVersion E_OpenconfigSystemTerminal_SshServer_ProtocolVersion `path:"config/protocol-version" module:"openconfig-system"`
	RateLimit       *uint16                                              `path:"config/rate-limit" module:"openconfig-system"`
	SessionLimit    *uint16                                              `path:"config/session-limit" module:"openconfig-system"`
	Timeout         *uint16                                              `path:"config/timeout" module:"openconfig-system"`
}

System_SshServer represents the /openconfig-system/system/ssh-server YANG schema element.

func (*System_SshServer) IsYANGGoStruct 

func (*System_SshServer) IsYANGGoStruct()

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

func (*System_SshServer) Validate 

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

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

func (*System_SshServer) ΛEnumTypeMap 

func (t *System_SshServer) Λ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 System_TelnetServer 

type System_TelnetServer struct {
	Enable       *bool   `path:"config/enable" module:"openconfig-system"`
	RateLimit    *uint16 `path:"config/rate-limit" module:"openconfig-system"`
	SessionLimit *uint16 `path:"config/session-limit" module:"openconfig-system"`
	Timeout      *uint16 `path:"config/timeout" module:"openconfig-system"`
}

System_TelnetServer represents the /openconfig-system/system/telnet-server YANG schema element.

func (*System_TelnetServer) IsYANGGoStruct 

func (*System_TelnetServer) IsYANGGoStruct()

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

func (*System_TelnetServer) Validate 

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

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

func (*System_TelnetServer) ΛEnumTypeMap 

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