signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_serial_no(self): | return self.__serial_no<EOL> | Getter method for serial_no, mapped from YANG variable /brocade_interface_ext_rpc/get_media_detail/output/interface/qsfp/serial_no (string)
YANG Description: This indicates the Serial number. | f336069:c0:m33 |
def _set_serial_no(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__serial_no = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for serial_no, mapped from YANG variable /brocade_interface_ext_rpc/get_media_detail/output/interface/qsfp/serial_no (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_serial_no is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_serial_no() directly.
YANG Description: This indicates the Serial number. | f336069:c0:m34 |
def _get_date_code(self): | return self.__date_code<EOL> | Getter method for date_code, mapped from YANG variable /brocade_interface_ext_rpc/get_media_detail/output/interface/qsfp/date_code (string)
YANG Description: This indicates the Vendor's
manufactoring date code. | f336069:c0:m36 |
def _set_date_code(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__date_code = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for date_code, mapped from YANG variable /brocade_interface_ext_rpc/get_media_detail/output/interface/qsfp/date_code (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_date_code is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_date_code() directly.
YANG Description: This indicates the Vendor's
manufactoring date code. | f336069:c0:m37 |
def _get_temperature(self): | return self.__temperature<EOL> | Getter method for temperature, mapped from YANG variable /brocade_interface_ext_rpc/get_media_detail/output/interface/qsfp/temperature (uint32)
YANG Description: This indicates the Module
temperature (degrees C) | f336069:c0:m39 |
def _set_temperature(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__temperature = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for temperature, mapped from YANG variable /brocade_interface_ext_rpc/get_media_detail/output/interface/qsfp/temperature (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_temperature is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_temperature() directly.
YANG Description: This indicates the Module
temperature (degrees C) | f336069:c0:m40 |
def _get_voltage(self): | return self.__voltage<EOL> | Getter method for voltage, mapped from YANG variable /brocade_interface_ext_rpc/get_media_detail/output/interface/qsfp/voltage (decimal64)
YANG Description: This indicates the Supply voltage
(Volts) | f336069:c0:m42 |
def _set_voltage(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:1>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__voltage = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for voltage, mapped from YANG variable /brocade_interface_ext_rpc/get_media_detail/output/interface/qsfp/voltage (decimal64)
If this variable is read-only (config: false) in the
source YANG file, then _set_voltage is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_voltage() directly.
YANG Description: This indicates the Supply voltage
(Volts) | f336069:c0:m43 |
def _get_current(self): | return self.__current<EOL> | Getter method for current, mapped from YANG variable /brocade_interface_ext_rpc/get_media_detail/output/interface/qsfp/current (decimal64)
YANG Description: This indicates the Laser diode
drive current (milliAmps) | f336069:c0:m45 |
def _set_current(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:3>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__current = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for current, mapped from YANG variable /brocade_interface_ext_rpc/get_media_detail/output/interface/qsfp/current (decimal64)
If this variable is read-only (config: false) in the
source YANG file, then _set_current is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_current() directly.
YANG Description: This indicates the Laser diode
drive current (milliAmps) | f336069:c0:m46 |
def _get_tx_power(self): | return self.__tx_power<EOL> | Getter method for tx_power, mapped from YANG variable /brocade_interface_ext_rpc/get_media_detail/output/interface/qsfp/tx_power (decimal64)
YANG Description: This indicates the Transmitted
optical power (microWatts) | f336069:c0:m48 |
def _set_tx_power(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:1>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__tx_power = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_power, mapped from YANG variable /brocade_interface_ext_rpc/get_media_detail/output/interface/qsfp/tx_power (decimal64)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_power is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_power() directly.
YANG Description: This indicates the Transmitted
optical power (microWatts) | f336069:c0:m49 |
def _get_rx_power(self): | return self.__rx_power<EOL> | Getter method for rx_power, mapped from YANG variable /brocade_interface_ext_rpc/get_media_detail/output/interface/qsfp/rx_power (decimal64)
YANG Description: This indicates the Received
optical power (microWatts) | f336069:c0:m51 |
def _set_rx_power(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:1>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rx_power = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rx_power, mapped from YANG variable /brocade_interface_ext_rpc/get_media_detail/output/interface/qsfp/rx_power (decimal64)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_power is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_power() directly.
YANG Description: This indicates the Received
optical power (microWatts) | f336069:c0:m52 |
def _get_interface_type(self): | return self.__interface_type<EOL> | Getter method for interface_type, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/interface_type (enumeration)
YANG Description: The type of the interface. An 'unknown' type
represents error scenario and should not be used. | f336070:c0:m3 |
def _set_interface_type(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:12>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:8>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:10>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u"<STR_LIT>"}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__interface_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_type, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/interface_type (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_type() directly.
YANG Description: The type of the interface. An 'unknown' type
represents error scenario and should not be used. | f336070:c0:m4 |
def _get_interface_name(self): | return self.__interface_name<EOL> | Getter method for interface_name, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/interface_name (union)
YANG Description: The Interface value. The interface value is always
interpreted within the context of the value of
'interface-type' leaf:
interface-type interface-name
----------------- --------------------
ethernet slot/port
port-channel Port channel ID
l2vlan Vlan ID
unknown Zero-length string.
The value of an 'interface-name' must always be
consistent with the value of the associated
'interface-type'. Attempts to set an interface-name
to a value inconsistent with the associated
'interface-type' must fail with an error. | f336070:c0:m6 |
def _set_interface_name(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=[RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>', '<STR_LIT>': [u'<STR_LIT>']}),RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}),RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}),], is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>'}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__interface_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_name, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/interface_name (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_name() directly.
YANG Description: The Interface value. The interface value is always
interpreted within the context of the value of
'interface-type' leaf:
interface-type interface-name
----------------- --------------------
ethernet slot/port
port-channel Port channel ID
l2vlan Vlan ID
unknown Zero-length string.
The value of an 'interface-name' must always be
consistent with the value of the associated
'interface-type'. Attempts to set an interface-name
to a value inconsistent with the associated
'interface-type' must fail with an error. | f336070:c0:m7 |
def _get_ifindex(self): | return self.__ifindex<EOL> | Getter method for ifindex, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifindex (uint64)
YANG Description: A unique value, greater than zero, for each
interface. | f336070:c0:m9 |
def _set_ifindex(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ifindex = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ifindex, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifindex (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_ifindex is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ifindex() directly.
YANG Description: A unique value, greater than zero, for each
interface. | f336070:c0:m10 |
def _get_mtu(self): | return self.__mtu<EOL> | Getter method for mtu, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/mtu (interface:mtu-type)
YANG Description: The size of the largest packet which can be
sent/received on the interface, specified in
octets. For interfaces that are used for
transmitting network datagrams, this is the
size of the largest network datagram that can
be sent on the interface. | f336070:c0:m12 |
def _set_mtu(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_LIT>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__mtu = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mtu, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/mtu (interface:mtu-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_mtu is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mtu() directly.
YANG Description: The size of the largest packet which can be
sent/received on the interface, specified in
octets. For interfaces that are used for
transmitting network datagrams, this is the
size of the largest network datagram that can
be sent on the interface. | f336070:c0:m13 |
def _get_ip_mtu(self): | return self.__ip_mtu<EOL> | Getter method for ip_mtu, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ip_mtu (interface:mtu-type)
YANG Description: This specifies the IP MTU value of this
interface. | f336070:c0:m15 |
def _set_ip_mtu(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ip_mtu = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ip_mtu, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ip_mtu (interface:mtu-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_ip_mtu is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ip_mtu() directly.
YANG Description: This specifies the IP MTU value of this
interface. | f336070:c0:m16 |
def _get_if_name(self): | return self.__if_name<EOL> | Getter method for if_name, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/if_name (string)
YANG Description: This indicates the interface display name as
in MIB-II's ifTable. However interface-name and
interface-type values of this instance forms
fully qualified name for this interface. | f336070:c0:m18 |
def _set_if_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__if_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for if_name, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/if_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_if_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_if_name() directly.
YANG Description: This indicates the interface display name as
in MIB-II's ifTable. However interface-name and
interface-type values of this instance forms
fully qualified name for this interface. | f336070:c0:m19 |
def _get_if_state(self): | return self.__if_state<EOL> | Getter method for if_state, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/if_state (enumeration)
YANG Description: This indicates the current operational state
of this interface. The 'testing' state
indicates that no operational packets can be
passed. If 'shutdown' leaf of corresponding
interface instance of brocade-interface module
is set, then 'if-state' should be 'down'.
If 'shutdown' is changed deleted, then
'if-state' should change to 'up' if the
interface is ready to transmit and receive
network traffic; it should remain in the 'down'
state if and only if there is a fault that
prevents it from going to the 'up' state. | f336070:c0:m21 |
def _set_if_state(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__if_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for if_state, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/if_state (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_if_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_if_state() directly.
YANG Description: This indicates the current operational state
of this interface. The 'testing' state
indicates that no operational packets can be
passed. If 'shutdown' leaf of corresponding
interface instance of brocade-interface module
is set, then 'if-state' should be 'down'.
If 'shutdown' is changed deleted, then
'if-state' should change to 'up' if the
interface is ready to transmit and receive
network traffic; it should remain in the 'down'
state if and only if there is a fault that
prevents it from going to the 'up' state. | f336070:c0:m22 |
def _get_line_protocol_state(self): | return self.__line_protocol_state<EOL> | Getter method for line_protocol_state, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/line_protocol_state (enumeration)
YANG Description: This indicates the 'Line protocol' state of
this interface. | f336070:c0:m24 |
def _set_line_protocol_state(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__line_protocol_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for line_protocol_state, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/line_protocol_state (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_line_protocol_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_line_protocol_state() directly.
YANG Description: This indicates the 'Line protocol' state of
this interface. | f336070:c0:m25 |
def _get_line_protocol_state_info(self): | return self.__line_protocol_state_info<EOL> | Getter method for line_protocol_state_info, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/line_protocol_state_info (string)
YANG Description: This indicates the reason for the current line
protocol state of this interface. | f336070:c0:m27 |
def _set_line_protocol_state_info(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__line_protocol_state_info = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for line_protocol_state_info, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/line_protocol_state_info (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_line_protocol_state_info is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_line_protocol_state_info() directly.
YANG Description: This indicates the reason for the current line
protocol state of this interface. | f336070:c0:m28 |
def _get_line_protocol_exception_info(self): | return self.__line_protocol_exception_info<EOL> | Getter method for line_protocol_exception_info, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/line_protocol_exception_info (string)
YANG Description: This indicates the 'Exception information' of
line protocol. | f336070:c0:m30 |
def _set_line_protocol_exception_info(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__line_protocol_exception_info = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for line_protocol_exception_info, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/line_protocol_exception_info (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_line_protocol_exception_info is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_line_protocol_exception_info() directly.
YANG Description: This indicates the 'Exception information' of
line protocol. | f336070:c0:m31 |
def _get_hardware_type(self): | return self.__hardware_type<EOL> | Getter method for hardware_type, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/hardware_type (enumeration)
YANG Description: This indicates the type of this interface. | f336070:c0:m33 |
def _set_hardware_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:9>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:10>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:8>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__hardware_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hardware_type, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/hardware_type (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_hardware_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hardware_type() directly.
YANG Description: This indicates the type of this interface. | f336070:c0:m34 |
def _get_logical_hardware_address(self): | return self.__logical_hardware_address<EOL> | Getter method for logical_hardware_address, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/logical_hardware_address (yang:mac-address)
YANG Description: This indicates the address of this interface at
its protocol sub-layer. | f336070:c0:m36 |
def _set_logical_hardware_address(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__logical_hardware_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for logical_hardware_address, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/logical_hardware_address (yang:mac-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_logical_hardware_address is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_logical_hardware_address() directly.
YANG Description: This indicates the address of this interface at
its protocol sub-layer. | f336070:c0:m37 |
def _get_current_hardware_address(self): | return self.__current_hardware_address<EOL> | Getter method for current_hardware_address, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/current_hardware_address (yang:mac-address)
YANG Description: This indicates the address of this interface at
its protocol sub-layer. | f336070:c0:m39 |
def _set_current_hardware_address(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__current_hardware_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for current_hardware_address, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/current_hardware_address (yang:mac-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_current_hardware_address is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_current_hardware_address() directly.
YANG Description: This indicates the address of this interface at
its protocol sub-layer. | f336070:c0:m40 |
def _get_media_type(self): | return self.__media_type<EOL> | Getter method for media_type, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/media_type (enumeration)
YANG Description: The specifies the type of the media plugged in
for this interface. | f336070:c0:m42 |
def _set_media_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:12>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__media_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for media_type, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/media_type (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_media_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_media_type() directly.
YANG Description: The specifies the type of the media plugged in
for this interface. | f336070:c0:m43 |
def _get_wavelength(self): | return self.__wavelength<EOL> | Getter method for wavelength, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/wavelength (uint32)
YANG Description: Wavelength of pluggable media | f336070:c0:m45 |
def _set_wavelength(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__wavelength = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for wavelength, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/wavelength (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_wavelength is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_wavelength() directly.
YANG Description: Wavelength of pluggable media | f336070:c0:m46 |
def _get_if_description(self): | return self.__if_description<EOL> | Getter method for if_description, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/if_description (string)
YANG Description: This specifies a textual string containing
information about the interface. | f336070:c0:m48 |
def _set_if_description(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__if_description = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for if_description, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/if_description (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_if_description is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_if_description() directly.
YANG Description: This specifies a textual string containing
information about the interface. | f336070:c0:m49 |
def _get_actual_line_speed(self): | return self.__actual_line_speed<EOL> | Getter method for actual_line_speed, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/actual_line_speed (string)
YANG Description: The actual line speed of this interface. | f336070:c0:m51 |
def _set_actual_line_speed(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__actual_line_speed = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for actual_line_speed, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/actual_line_speed (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_actual_line_speed is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_actual_line_speed() directly.
YANG Description: The actual line speed of this interface. | f336070:c0:m52 |
def _get_configured_line_speed(self): | return self.__configured_line_speed<EOL> | Getter method for configured_line_speed, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/configured_line_speed (line-speed)
YANG Description: The administratively configured line speed of
this interface. This should be same as what is
returned by value of corresponding instance of
'speed' of 'brocade-interface' module. | f336070:c0:m54 |
def _set_configured_line_speed(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:9>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:12>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:8>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:11>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:10>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__configured_line_speed = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for configured_line_speed, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/configured_line_speed (line-speed)
If this variable is read-only (config: false) in the
source YANG file, then _set_configured_line_speed is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_configured_line_speed() directly.
YANG Description: The administratively configured line speed of
this interface. This should be same as what is
returned by value of corresponding instance of
'speed' of 'brocade-interface' module. | f336070:c0:m55 |
def _get_line_duplex_state(self): | return self.__line_duplex_state<EOL> | Getter method for line_duplex_state, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/line_duplex_state (enumeration)
YANG Description: This indicates the 'Line duplex state' of this
interface. | f336070:c0:m57 |
def _set_line_duplex_state(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__line_duplex_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for line_duplex_state, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/line_duplex_state (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_line_duplex_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_line_duplex_state() directly.
YANG Description: This indicates the 'Line duplex state' of this
interface. | f336070:c0:m58 |
def _get_flow_control(self): | return self.__flow_control<EOL> | Getter method for flow_control, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/flow_control (enumeration)
YANG Description: This indicates the 'Flow control' for this
interface. | f336070:c0:m60 |
def _set_flow_control(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__flow_control = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for flow_control, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/flow_control (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_flow_control is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_flow_control() directly.
YANG Description: This indicates the 'Flow control' for this
interface. | f336070:c0:m61 |
def _get_queuing_strategy(self): | return self.__queuing_strategy<EOL> | Getter method for queuing_strategy, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/queuing_strategy (enumeration)
YANG Description: This indicates the 'Queuing strategy' for
this interface. | f336070:c0:m63 |
def _set_queuing_strategy(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__queuing_strategy = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for queuing_strategy, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/queuing_strategy (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_queuing_strategy is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_queuing_strategy() directly.
YANG Description: This indicates the 'Queuing strategy' for
this interface. | f336070:c0:m64 |
def _get_port_role(self): | return self.__port_role<EOL> | Getter method for port_role, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/port_role (enumeration)
YANG Description: This indicates current that this interface is
playing. This is applicable only for physical
interfaces. | f336070:c0:m66 |
def _set_port_role(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__port_role = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for port_role, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/port_role (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_port_role is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port_role() directly.
YANG Description: This indicates current that this interface is
playing. This is applicable only for physical
interfaces. | f336070:c0:m67 |
def _get_port_mode(self): | return self.__port_mode<EOL> | Getter method for port_mode, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/port_mode (enumeration)
YANG Description: This indicates operational mode of this
interface. This is applicable only for physical
interfaces/port channel interfaces. | f336070:c0:m69 |
def _set_port_mode(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__port_mode = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for port_mode, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/port_mode (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_port_mode is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port_mode() directly.
YANG Description: This indicates operational mode of this
interface. This is applicable only for physical
interfaces/port channel interfaces. | f336070:c0:m70 |
def _get_ifHCInOctets(self): | return self.__ifHCInOctets<EOL> | Getter method for ifHCInOctets, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCInOctets (yang:counter64)
YANG Description: The total number of octets received on the
interface, including framing characters. | f336070:c0:m72 |
def _set_ifHCInOctets(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ifHCInOctets = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ifHCInOctets, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCInOctets (yang:counter64)
If this variable is read-only (config: false) in the
source YANG file, then _set_ifHCInOctets is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ifHCInOctets() directly.
YANG Description: The total number of octets received on the
interface, including framing characters. | f336070:c0:m73 |
def _get_ifHCInUcastPkts(self): | return self.__ifHCInUcastPkts<EOL> | Getter method for ifHCInUcastPkts, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCInUcastPkts (yang:counter64)
YANG Description: The number of packets, delivered by this
sub-layer to a higher (sub-)layer, which were
not addressed to a multicast or broadcast
address at this sub-layer. | f336070:c0:m75 |
def _set_ifHCInUcastPkts(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ifHCInUcastPkts = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ifHCInUcastPkts, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCInUcastPkts (yang:counter64)
If this variable is read-only (config: false) in the
source YANG file, then _set_ifHCInUcastPkts is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ifHCInUcastPkts() directly.
YANG Description: The number of packets, delivered by this
sub-layer to a higher (sub-)layer, which were
not addressed to a multicast or broadcast
address at this sub-layer. | f336070:c0:m76 |
def _get_ifHCInMulticastPkts(self): | return self.__ifHCInMulticastPkts<EOL> | Getter method for ifHCInMulticastPkts, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCInMulticastPkts (yang:counter64)
YANG Description: The number of packets, delivered by this
sub-layer to a higher (sub-)layer, which were
addressed to a multicast address at this
sub-layer. For a MAC layer protocol, this
includes both Group and Functional addresses. | f336070:c0:m78 |
def _set_ifHCInMulticastPkts(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ifHCInMulticastPkts = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ifHCInMulticastPkts, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCInMulticastPkts (yang:counter64)
If this variable is read-only (config: false) in the
source YANG file, then _set_ifHCInMulticastPkts is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ifHCInMulticastPkts() directly.
YANG Description: The number of packets, delivered by this
sub-layer to a higher (sub-)layer, which were
addressed to a multicast address at this
sub-layer. For a MAC layer protocol, this
includes both Group and Functional addresses. | f336070:c0:m79 |
def _get_ifHCInBroadcastPkts(self): | return self.__ifHCInBroadcastPkts<EOL> | Getter method for ifHCInBroadcastPkts, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCInBroadcastPkts (yang:counter64)
YANG Description: The number of packets, delivered by this
sub-layer to a higher (sub-)layer, which were
addressed to a broadcast address at this
sub-layer. | f336070:c0:m81 |
def _set_ifHCInBroadcastPkts(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ifHCInBroadcastPkts = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ifHCInBroadcastPkts, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCInBroadcastPkts (yang:counter64)
If this variable is read-only (config: false) in the
source YANG file, then _set_ifHCInBroadcastPkts is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ifHCInBroadcastPkts() directly.
YANG Description: The number of packets, delivered by this
sub-layer to a higher (sub-)layer, which were
addressed to a broadcast address at this
sub-layer. | f336070:c0:m82 |
def _get_ifHCInErrors(self): | return self.__ifHCInErrors<EOL> | Getter method for ifHCInErrors, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCInErrors (yang:counter64)
YANG Description: For packet-oriented interfaces, the number of
inbound packets that contained errors
preventing them from being deliverable to a
higher-layer protocol. For character-oriented
or fixed-length interfaces, the number of
inbound transmission units that contained
errors preventing them from being deliverable
to a higher-layer protocol. | f336070:c0:m84 |
def _set_ifHCInErrors(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ifHCInErrors = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ifHCInErrors, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCInErrors (yang:counter64)
If this variable is read-only (config: false) in the
source YANG file, then _set_ifHCInErrors is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ifHCInErrors() directly.
YANG Description: For packet-oriented interfaces, the number of
inbound packets that contained errors
preventing them from being deliverable to a
higher-layer protocol. For character-oriented
or fixed-length interfaces, the number of
inbound transmission units that contained
errors preventing them from being deliverable
to a higher-layer protocol. | f336070:c0:m85 |
def _get_ifHCOutOctets(self): | return self.__ifHCOutOctets<EOL> | Getter method for ifHCOutOctets, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCOutOctets (yang:counter64)
YANG Description: The total number of octets transmitted out of
the interface, including framing characters. | f336070:c0:m87 |
def _set_ifHCOutOctets(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ifHCOutOctets = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ifHCOutOctets, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCOutOctets (yang:counter64)
If this variable is read-only (config: false) in the
source YANG file, then _set_ifHCOutOctets is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ifHCOutOctets() directly.
YANG Description: The total number of octets transmitted out of
the interface, including framing characters. | f336070:c0:m88 |
def _get_ifHCOutUcastPkts(self): | return self.__ifHCOutUcastPkts<EOL> | Getter method for ifHCOutUcastPkts, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCOutUcastPkts (yang:counter64)
YANG Description: The total number of packets that higher-level
protocols requested be transmitted, and which
were not addressed to a multicast or broadcast
address at this sub-layer, including those
that were discarded or not sent. | f336070:c0:m90 |
def _set_ifHCOutUcastPkts(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ifHCOutUcastPkts = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ifHCOutUcastPkts, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCOutUcastPkts (yang:counter64)
If this variable is read-only (config: false) in the
source YANG file, then _set_ifHCOutUcastPkts is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ifHCOutUcastPkts() directly.
YANG Description: The total number of packets that higher-level
protocols requested be transmitted, and which
were not addressed to a multicast or broadcast
address at this sub-layer, including those
that were discarded or not sent. | f336070:c0:m91 |
def _get_ifHCOutMulticastPkts(self): | return self.__ifHCOutMulticastPkts<EOL> | Getter method for ifHCOutMulticastPkts, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCOutMulticastPkts (yang:counter64)
YANG Description: The total number of packets that higher-level
protocols requested be transmitted, and which
were addressed to a multicast address at this
sub-layer, including those that were discarded
or not sent. For a MAC layer protocol, this
includes both Group and Functional addresses. | f336070:c0:m93 |
def _set_ifHCOutMulticastPkts(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ifHCOutMulticastPkts = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ifHCOutMulticastPkts, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCOutMulticastPkts (yang:counter64)
If this variable is read-only (config: false) in the
source YANG file, then _set_ifHCOutMulticastPkts is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ifHCOutMulticastPkts() directly.
YANG Description: The total number of packets that higher-level
protocols requested be transmitted, and which
were addressed to a multicast address at this
sub-layer, including those that were discarded
or not sent. For a MAC layer protocol, this
includes both Group and Functional addresses. | f336070:c0:m94 |
def _get_ifHCOutBroadcastPkts(self): | return self.__ifHCOutBroadcastPkts<EOL> | Getter method for ifHCOutBroadcastPkts, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCOutBroadcastPkts (yang:counter64)
YANG Description: The total number of packets that higher-level
protocols requested be transmitted, and which
were addressed to a broadcast address at this
sub-layer, including those that were discarded
or not sent. | f336070:c0:m96 |
def _set_ifHCOutBroadcastPkts(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ifHCOutBroadcastPkts = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ifHCOutBroadcastPkts, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCOutBroadcastPkts (yang:counter64)
If this variable is read-only (config: false) in the
source YANG file, then _set_ifHCOutBroadcastPkts is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ifHCOutBroadcastPkts() directly.
YANG Description: The total number of packets that higher-level
protocols requested be transmitted, and which
were addressed to a broadcast address at this
sub-layer, including those that were discarded
or not sent. | f336070:c0:m97 |
def _get_ifHCOutErrors(self): | return self.__ifHCOutErrors<EOL> | Getter method for ifHCOutErrors, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCOutErrors (yang:counter64)
YANG Description: For packet-oriented interfaces, the number of
outbound packets that could not be transmitted
because of errors. For character-oriented or
fixed-length interfaces, the number of
outbound transmission units that could not be
transmitted because of errors. | f336070:c0:m99 |
def _set_ifHCOutErrors(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ifHCOutErrors = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ifHCOutErrors, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCOutErrors (yang:counter64)
If this variable is read-only (config: false) in the
source YANG file, then _set_ifHCOutErrors is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ifHCOutErrors() directly.
YANG Description: For packet-oriented interfaces, the number of
outbound packets that could not be transmitted
because of errors. For character-oriented or
fixed-length interfaces, the number of
outbound transmission units that could not be
transmitted because of errors. | f336070:c0:m100 |
def _get_port_name(self): | return self.__port_name<EOL> | Getter method for port_name, mapped from YANG variable /packet_encap_processing_state/packet_encap_info_list/port_name (string)
YANG Description: Port name | f336071:c0:m3 |
def _set_port_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__port_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for port_name, mapped from YANG variable /packet_encap_processing_state/packet_encap_info_list/port_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_port_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port_name() directly.
YANG Description: Port name | f336071:c0:m4 |
def _get_link_status(self): | return self.__link_status<EOL> | Getter method for link_status, mapped from YANG variable /packet_encap_processing_state/packet_encap_info_list/link_status (string)
YANG Description: Link Status | f336071:c0:m6 |
def _set_link_status(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__link_status = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for link_status, mapped from YANG variable /packet_encap_processing_state/packet_encap_info_list/link_status (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_link_status is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_link_status() directly.
YANG Description: Link Status | f336071:c0:m7 |
def _get_encap_type(self): | return self.__encap_type<EOL> | Getter method for encap_type, mapped from YANG variable /packet_encap_processing_state/packet_encap_info_list/encap_type (string)
YANG Description: Encap Type | f336071:c0:m9 |
def _set_encap_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__encap_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for encap_type, mapped from YANG variable /packet_encap_processing_state/packet_encap_info_list/encap_type (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_encap_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_encap_type() directly.
YANG Description: Encap Type | f336071:c0:m10 |
def _get_strip_status(self): | return self.__strip_status<EOL> | Getter method for strip_status, mapped from YANG variable /packet_encap_processing_state/packet_encap_info_list/strip_status (string)
YANG Description: Feature Status | f336071:c0:m12 |
def _set_strip_status(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__strip_status = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for strip_status, mapped from YANG variable /packet_encap_processing_state/packet_encap_info_list/strip_status (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_strip_status is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_strip_status() directly.
YANG Description: Feature Status | f336071:c0:m13 |
def _get_packet_encap_info_list(self): | return self.__packet_encap_info_list<EOL> | Getter method for packet_encap_info_list, mapped from YANG variable /packet_encap_processing_state/packet_encap_info_list (container)
YANG Description: Packet Encapsulation Processing Information | f336072:c0:m3 |
def _set_packet_encap_info_list(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=packet_encap_info_list.packet_encap_info_list, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__packet_encap_info_list = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for packet_encap_info_list, mapped from YANG variable /packet_encap_processing_state/packet_encap_info_list (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_packet_encap_info_list is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_packet_encap_info_list() directly.
YANG Description: Packet Encapsulation Processing Information | f336072:c0:m4 |
def _get_bd_id(self): | return self.__bd_id<EOL> | Getter method for bd_id, mapped from YANG variable /igmp_snooping_bridge_domain_mrouters_state/bd_id (uint32)
YANG Description: bridge-domain id | f336073:c0:m3 |
def _set_bd_id(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__bd_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bd_id, mapped from YANG variable /igmp_snooping_bridge_domain_mrouters_state/bd_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_bd_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bd_id() directly.
YANG Description: bridge-domain id | f336073:c0:m4 |
def _get_igmp_snooping_bridge_domain_mrouters(self): | return self.__igmp_snooping_bridge_domain_mrouters<EOL> | Getter method for igmp_snooping_bridge_domain_mrouters, mapped from YANG variable /igmp_snooping_bridge_domain_mrouters_state/igmp_snooping_bridge_domain_mrouters (list)
YANG Description: Igmp snoopig mrouter info | f336073:c0:m6 |
def _set_igmp_snooping_bridge_domain_mrouters(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",igmp_snooping_bridge_domain_mrouters.igmp_snooping_bridge_domain_mrouters, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__igmp_snooping_bridge_domain_mrouters = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for igmp_snooping_bridge_domain_mrouters, mapped from YANG variable /igmp_snooping_bridge_domain_mrouters_state/igmp_snooping_bridge_domain_mrouters (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_igmp_snooping_bridge_domain_mrouters is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_igmp_snooping_bridge_domain_mrouters() directly.
YANG Description: Igmp snoopig mrouter info | f336073:c0:m7 |
def _get_bd_id(self): | return self.__bd_id<EOL> | Getter method for bd_id, mapped from YANG variable /igmp_snooping_bridge_domain_mrouters_state/igmp_snooping_bridge_domain_mrouters/bd_id (uint32)
YANG Description: bridge-domain id | f336074:c0:m3 |
def _set_bd_id(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__bd_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bd_id, mapped from YANG variable /igmp_snooping_bridge_domain_mrouters_state/igmp_snooping_bridge_domain_mrouters/bd_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_bd_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bd_id() directly.
YANG Description: bridge-domain id | f336074:c0:m4 |
def _get_interface_name(self): | return self.__interface_name<EOL> | Getter method for interface_name, mapped from YANG variable /igmp_snooping_bridge_domain_mrouters_state/igmp_snooping_bridge_domain_mrouters/interface_name (string)
YANG Description: interface_name | f336074:c0:m6 |
def _set_interface_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__interface_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_name, mapped from YANG variable /igmp_snooping_bridge_domain_mrouters_state/igmp_snooping_bridge_domain_mrouters/interface_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_name() directly.
YANG Description: interface_name | f336074:c0:m7 |
def _get_expiry_time(self): | return self.__expiry_time<EOL> | Getter method for expiry_time, mapped from YANG variable /igmp_snooping_bridge_domain_mrouters_state/igmp_snooping_bridge_domain_mrouters/expiry_time (int32)
YANG Description: expiry time: For static mrouter port expiry timer will be -1. | f336074:c0:m9 |
def _set_expiry_time(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__expiry_time = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for expiry_time, mapped from YANG variable /igmp_snooping_bridge_domain_mrouters_state/igmp_snooping_bridge_domain_mrouters/expiry_time (int32)
If this variable is read-only (config: false) in the
source YANG file, then _set_expiry_time is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_expiry_time() directly.
YANG Description: expiry time: For static mrouter port expiry timer will be -1. | f336074:c0:m10 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.