signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_interface_name(self): | return self.__interface_name<EOL> | Getter method for interface_name, mapped from YANG variable /brocade_mac_address_table_rpc/get_mac_address_table/input/forwarding_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. | f335802: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=[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, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>'}}, 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_mac_address_table_rpc/get_mac_address_table/input/forwarding_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. | f335802:c0:m7 |
def _get_mac_address(self): | return self.__mac_address<EOL> | Getter method for mac_address, mapped from YANG variable /brocade_mac_address_table_rpc/get_mac_address_table/input/mac_address (yang:mac-address)
YANG Description: The Mac Address for which the
corresponding mac entry will be
fetched. The i/p should be in
xx:xx:xx:xx:xx:xx format. | f335803:c0:m3 |
def _set_mac_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, 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.__mac_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mac_address, mapped from YANG variable /brocade_mac_address_table_rpc/get_mac_address_table/input/mac_address (yang:mac-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_mac_address is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mac_address() directly.
YANG Description: The Mac Address for which the
corresponding mac entry will be
fetched. The i/p should be in
xx:xx:xx:xx:xx:xx format. | f335803:c0:m4 |
def _get_forwarding_interface(self): | return self.__forwarding_interface<EOL> | Getter method for forwarding_interface, mapped from YANG variable /brocade_mac_address_table_rpc/get_mac_address_table/input/forwarding_interface (container)
YANG Description: The interface for which corresponding
MAC entries will be fetched. | f335803:c0:m6 |
def _set_forwarding_interface(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=forwarding_interface.forwarding_interface, is_container='<STR_LIT>', presence=False, 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, extensions=None, 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.__forwarding_interface = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for forwarding_interface, mapped from YANG variable /brocade_mac_address_table_rpc/get_mac_address_table/input/forwarding_interface (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_forwarding_interface is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_forwarding_interface() directly.
YANG Description: The interface for which corresponding
MAC entries will be fetched. | f335803:c0:m7 |
def _get_mac_type(self): | return self.__mac_type<EOL> | Getter method for mac_type, mapped from YANG variable /brocade_mac_address_table_rpc/get_mac_address_table/input/mac_type (enumeration)
YANG Description: Type of MAC addresses to be fetched. | f335803:c0:m9 |
def _set_mac_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:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <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.__mac_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mac_type, mapped from YANG variable /brocade_mac_address_table_rpc/get_mac_address_table/input/mac_type (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_mac_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mac_type() directly.
YANG Description: Type of MAC addresses to be fetched. | f335803:c0:m10 |
def _get_last_mac_address_details(self): | return self.__last_mac_address_details<EOL> | Getter method for last_mac_address_details, mapped from YANG variable /brocade_mac_address_table_rpc/get_mac_address_table/input/last_mac_address_details (container) | f335803:c0:m12 |
def _set_last_mac_address_details(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=last_mac_address_details.last_mac_address_details, is_container='<STR_LIT>', presence=False, 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, extensions=None, 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.__last_mac_address_details = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for last_mac_address_details, mapped from YANG variable /brocade_mac_address_table_rpc/get_mac_address_table/input/last_mac_address_details (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_last_mac_address_details is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_last_mac_address_details() directly. | f335803:c0:m13 |
def _get_forwarding_interface_type(self): | return self.__forwarding_interface_type<EOL> | Getter method for forwarding_interface_type, mapped from YANG variable /brocade_mac_address_table_rpc/get_mac_address_table/input/forwarding_interface_type (enumeration)
YANG Description: The type of the interface. An 'unknown' type
represents error scenario and should not be used. | f335803:c0:m15 |
def _set_forwarding_interface_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: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:10>}},), 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, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u"<STR_LIT>"}}, 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.__forwarding_interface_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for forwarding_interface_type, mapped from YANG variable /brocade_mac_address_table_rpc/get_mac_address_table/input/forwarding_interface_type (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_forwarding_interface_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_forwarding_interface_type() directly.
YANG Description: The type of the interface. An 'unknown' type
represents error scenario and should not be used. | f335803:c0:m16 |
def _get_forwarding_interface_name(self): | return self.__forwarding_interface_name<EOL> | Getter method for forwarding_interface_name, mapped from YANG variable /brocade_mac_address_table_rpc/get_mac_address_table/input/forwarding_interface_name (union)
YANG Description: The Interface name. The interface name 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
unknown Zero-length string.
The value of an 'forwarding-interface-name' must always be
consistent with the value of the associated
'forwarding-interface-type'. Attempts to set an interface-name
to a value inconsistent with the associated
'forwarding-interface-type' must fail with an error. | f335803:c0:m18 |
def _set_forwarding_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=[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, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>'}}, 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.__forwarding_interface_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for forwarding_interface_name, mapped from YANG variable /brocade_mac_address_table_rpc/get_mac_address_table/input/forwarding_interface_name (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_forwarding_interface_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_forwarding_interface_name() directly.
YANG Description: The Interface name. The interface name 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
unknown Zero-length string.
The value of an 'forwarding-interface-name' must always be
consistent with the value of the associated
'forwarding-interface-type'. Attempts to set an interface-name
to a value inconsistent with the associated
'forwarding-interface-type' must fail with an error. | f335803:c0:m19 |
def _get_mac_address_type(self): | return self.__mac_address_type<EOL> | Getter method for mac_address_type, mapped from YANG variable /brocade_mac_address_table_rpc/get_mac_address_table/input/mac_address_type (enumeration)
YANG Description: Type of MAC addresses to be fetched. | f335803:c0:m21 |
def _set_mac_address_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:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <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.__mac_address_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mac_address_type, mapped from YANG variable /brocade_mac_address_table_rpc/get_mac_address_table/input/mac_address_type (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_mac_address_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mac_address_type() directly.
YANG Description: Type of MAC addresses to be fetched. | f335803:c0:m22 |
def _get_interface_type(self): | return self.__interface_type<EOL> | Getter method for interface_type, mapped from YANG variable /brocade_mac_address_table_rpc/get_mac_address_table/output/mac_address_table/forwarding_interface/interface_type (enumeration)
YANG Description: The type of the interface. An 'unknown' type
represents error scenario and should not be used. | f335804:c0:m3 |
def _set_interface_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: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>"}}, 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_mac_address_table_rpc/get_mac_address_table/output/mac_address_table/forwarding_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. | f335804:c0:m4 |
def _get_interface_name(self): | return self.__interface_name<EOL> | Getter method for interface_name, mapped from YANG variable /brocade_mac_address_table_rpc/get_mac_address_table/output/mac_address_table/forwarding_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. | f335804: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=[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>'}}, 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_mac_address_table_rpc/get_mac_address_table/output/mac_address_table/forwarding_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. | f335804:c0:m7 |
def _get_vlanid(self): | return self.__vlanid<EOL> | Getter method for vlanid, mapped from YANG variable /brocade_mac_address_table_rpc/get_mac_address_table/output/mac_address_table/vlanid (interface:vlan-type)
YANG Description: vlan id | f335805:c0:m3 |
def _set_vlanid(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=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, 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.__vlanid = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vlanid, mapped from YANG variable /brocade_mac_address_table_rpc/get_mac_address_table/output/mac_address_table/vlanid (interface:vlan-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_vlanid is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vlanid() directly.
YANG Description: vlan id | f335805:c0:m4 |
def _get_mac_address(self): | return self.__mac_address<EOL> | Getter method for mac_address, mapped from YANG variable /brocade_mac_address_table_rpc/get_mac_address_table/output/mac_address_table/mac_address (yang:mac-address)
YANG Description: Mac Address | f335805:c0:m6 |
def _set_mac_address(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>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__mac_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mac_address, mapped from YANG variable /brocade_mac_address_table_rpc/get_mac_address_table/output/mac_address_table/mac_address (yang:mac-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_mac_address is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mac_address() directly.
YANG Description: Mac Address | f335805:c0:m7 |
def _get_mac_type(self): | return self.__mac_type<EOL> | Getter method for mac_type, mapped from YANG variable /brocade_mac_address_table_rpc/get_mac_address_table/output/mac_address_table/mac_type (enumeration)
YANG Description: Mac Address type | f335805:c0:m9 |
def _set_mac_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:2>}, 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>}},), 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.__mac_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mac_type, mapped from YANG variable /brocade_mac_address_table_rpc/get_mac_address_table/output/mac_address_table/mac_type (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_mac_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mac_type() directly.
YANG Description: Mac Address type | f335805:c0:m10 |
def _get_mac_state(self): | return self.__mac_state<EOL> | Getter method for mac_state, mapped from YANG variable /brocade_mac_address_table_rpc/get_mac_address_table/output/mac_address_table/mac_state (enumeration)
YANG Description: Mac Address state | f335805:c0:m12 |
def _set_mac_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:4>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, 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.__mac_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mac_state, mapped from YANG variable /brocade_mac_address_table_rpc/get_mac_address_table/output/mac_address_table/mac_state (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_mac_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mac_state() directly.
YANG Description: Mac Address state | f335805:c0:m13 |
def _get_forwarding_interface(self): | return self.__forwarding_interface<EOL> | Getter method for forwarding_interface, mapped from YANG variable /brocade_mac_address_table_rpc/get_mac_address_table/output/mac_address_table/forwarding_interface (list)
YANG Description: List of forwarding interfaces | f335805:c0:m15 |
def _set_forwarding_interface(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(False,forwarding_interface.forwarding_interface, 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:False>', extensions=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=False, extensions=None, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=True)<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.__forwarding_interface = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for forwarding_interface, mapped from YANG variable /brocade_mac_address_table_rpc/get_mac_address_table/output/mac_address_table/forwarding_interface (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_forwarding_interface is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_forwarding_interface() directly.
YANG Description: List of forwarding interfaces | f335805:c0:m16 |
def _get_vrf_name(self): | return self.__vrf_name<EOL> | Getter method for vrf_name, mapped from YANG variable /pim_anycast_state/vrf_name (string)
YANG Description: vrf name | f335806:c0:m3 |
def _set_vrf_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=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, is_keyval=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.__vrf_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vrf_name, mapped from YANG variable /pim_anycast_state/vrf_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_vrf_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vrf_name() directly.
YANG Description: vrf name | f335806:c0:m4 |
def _get_anycast_rp(self): | return self.__anycast_rp<EOL> | Getter method for anycast_rp, mapped from YANG variable /pim_anycast_state/anycast_rp (inet:ipv4-address)
YANG Description: ipv4 anycast rp address | f335806:c0:m6 |
def _set_anycast_rp(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>'}), 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.__anycast_rp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for anycast_rp, mapped from YANG variable /pim_anycast_state/anycast_rp (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_anycast_rp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_anycast_rp() directly.
YANG Description: ipv4 anycast rp address | f335806:c0:m7 |
def _get_prefix_name(self): | return self.__prefix_name<EOL> | Getter method for prefix_name, mapped from YANG variable /pim_anycast_state/prefix_name (string)
YANG Description: Prefix name | f335806:c0:m9 |
def _set_prefix_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.__prefix_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for prefix_name, mapped from YANG variable /pim_anycast_state/prefix_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_prefix_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_prefix_name() directly.
YANG Description: Prefix name | f335806:c0:m10 |
def _get_peer_list(self): | return self.__peer_list<EOL> | Getter method for peer_list, mapped from YANG variable /pim_anycast_state/peer_list (list)
YANG Description: Peer Source IP Address information | f335806:c0:m12 |
def _set_peer_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=YANGListType("<STR_LIT>",peer_list.peer_list, 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.__peer_list = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for peer_list, mapped from YANG variable /pim_anycast_state/peer_list (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_peer_list is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_peer_list() directly.
YANG Description: Peer Source IP Address information | f335806:c0:m13 |
def _get_ipv4_addr(self): | return self.__ipv4_addr<EOL> | Getter method for ipv4_addr, mapped from YANG variable /pim_anycast_state/peer_list/ipv4_addr (inet:ipv4-address)
YANG Description: Peer Source IP Address | f335807:c0:m3 |
def _set_ipv4_addr(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>'}), 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.__ipv4_addr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ipv4_addr, mapped from YANG variable /pim_anycast_state/peer_list/ipv4_addr (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_ipv4_addr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ipv4_addr() directly.
YANG Description: Peer Source IP Address | f335807:c0:m4 |
def _get_fabric_virtual_gateway(self): | return self.__fabric_virtual_gateway<EOL> | Getter method for fabric_virtual_gateway, mapped from YANG variable /router/fabric_virtual_gateway (container)
YANG Description: Fabric virtual gateway | f335808:c0:m3 |
def _set_fabric_virtual_gateway(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=fabric_virtual_gateway.fabric_virtual_gateway, is_container='<STR_LIT>', presence=True, 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:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, 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.__fabric_virtual_gateway = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fabric_virtual_gateway, mapped from YANG variable /router/fabric_virtual_gateway (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_fabric_virtual_gateway is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fabric_virtual_gateway() directly.
YANG Description: Fabric virtual gateway | f335808:c0:m4 |
def _get_interface_type(self): | return self.__interface_type<EOL> | Getter method for interface_type, mapped from YANG variable /brocade_lldp_ext_rpc/get_lldp_neighbor_detail/input/interface_type (enumeration)
YANG Description: The type of the interface. An 'unknown' type
represents error scenario and should not be used. | f335809:c0:m3 |
def _set_interface_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: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, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u"<STR_LIT>"}}, 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_lldp_ext_rpc/get_lldp_neighbor_detail/input/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. | f335809:c0:m4 |
def _get_interface_name(self): | return self.__interface_name<EOL> | Getter method for interface_name, mapped from YANG variable /brocade_lldp_ext_rpc/get_lldp_neighbor_detail/input/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. | f335809: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=[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, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>'}}, 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_lldp_ext_rpc/get_lldp_neighbor_detail/input/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. | f335809:c0:m7 |
def _get_last_rcvd_ifindex(self): | return self.__last_rcvd_ifindex<EOL> | Getter method for last_rcvd_ifindex, mapped from YANG variable /brocade_lldp_ext_rpc/get_lldp_neighbor_detail/input/last_rcvd_ifindex (uint32)
YANG Description: This specifies the ifindex of last interface
received in previous requests to fetch next
set of records. This is optional input,when
not specified means fetch records from beginning
from the managed entity. | f335809:c0:m9 |
def _set_last_rcvd_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: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.__last_rcvd_ifindex = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for last_rcvd_ifindex, mapped from YANG variable /brocade_lldp_ext_rpc/get_lldp_neighbor_detail/input/last_rcvd_ifindex (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_last_rcvd_ifindex is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_last_rcvd_ifindex() directly.
YANG Description: This specifies the ifindex of last interface
received in previous requests to fetch next
set of records. This is optional input,when
not specified means fetch records from beginning
from the managed entity. | f335809:c0:m10 |
def _get_local_interface_name(self): | return self.__local_interface_name<EOL> | Getter method for local_interface_name, mapped from YANG variable /brocade_lldp_ext_rpc/get_lldp_neighbor_detail/output/lldp_neighbor_detail/local_interface_name (string)
YANG Description: This indicates the local interface display name. | f335810:c0:m3 |
def _set_local_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=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, is_keyval=True, 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.__local_interface_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for local_interface_name, mapped from YANG variable /brocade_lldp_ext_rpc/get_lldp_neighbor_detail/output/lldp_neighbor_detail/local_interface_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_local_interface_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_local_interface_name() directly.
YANG Description: This indicates the local interface display name. | f335810:c0:m4 |
def _get_local_interface_mac(self): | return self.__local_interface_mac<EOL> | Getter method for local_interface_mac, mapped from YANG variable /brocade_lldp_ext_rpc/get_lldp_neighbor_detail/output/lldp_neighbor_detail/local_interface_mac (interface:mac-address-type)
YANG Description: This indicates the local interface mac. | f335810:c0:m6 |
def _set_local_interface_mac(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.__local_interface_mac = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for local_interface_mac, mapped from YANG variable /brocade_lldp_ext_rpc/get_lldp_neighbor_detail/output/lldp_neighbor_detail/local_interface_mac (interface:mac-address-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_local_interface_mac is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_local_interface_mac() directly.
YANG Description: This indicates the local interface mac. | f335810:c0:m7 |
def _get_local_interface_ifindex(self): | return self.__local_interface_ifindex<EOL> | Getter method for local_interface_ifindex, mapped from YANG variable /brocade_lldp_ext_rpc/get_lldp_neighbor_detail/output/lldp_neighbor_detail/local_interface_ifindex (uint64)
YANG Description: This indicates the local interface IfIndex. | f335810:c0:m9 |
def _set_local_interface_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.__local_interface_ifindex = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for local_interface_ifindex, mapped from YANG variable /brocade_lldp_ext_rpc/get_lldp_neighbor_detail/output/lldp_neighbor_detail/local_interface_ifindex (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_local_interface_ifindex is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_local_interface_ifindex() directly.
YANG Description: This indicates the local interface IfIndex. | f335810:c0:m10 |
def _get_remote_interface_name(self): | return self.__remote_interface_name<EOL> | Getter method for remote_interface_name, mapped from YANG variable /brocade_lldp_ext_rpc/get_lldp_neighbor_detail/output/lldp_neighbor_detail/remote_interface_name (string)
YANG Description: This indicates the remote interface display name. | f335810:c0:m12 |
def _set_remote_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=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, is_keyval=True, 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.__remote_interface_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for remote_interface_name, mapped from YANG variable /brocade_lldp_ext_rpc/get_lldp_neighbor_detail/output/lldp_neighbor_detail/remote_interface_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_remote_interface_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_remote_interface_name() directly.
YANG Description: This indicates the remote interface display name. | f335810:c0:m13 |
def _get_remote_interface_mac(self): | return self.__remote_interface_mac<EOL> | Getter method for remote_interface_mac, mapped from YANG variable /brocade_lldp_ext_rpc/get_lldp_neighbor_detail/output/lldp_neighbor_detail/remote_interface_mac (interface:mac-address-type)
YANG Description: This indicates the remote interface mac. | f335810:c0:m15 |
def _set_remote_interface_mac(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.__remote_interface_mac = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for remote_interface_mac, mapped from YANG variable /brocade_lldp_ext_rpc/get_lldp_neighbor_detail/output/lldp_neighbor_detail/remote_interface_mac (interface:mac-address-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_remote_interface_mac is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_remote_interface_mac() directly.
YANG Description: This indicates the remote interface mac. | f335810:c0:m16 |
def _get_remote_port_description(self): | return self.__remote_port_description<EOL> | Getter method for remote_port_description, mapped from YANG variable /brocade_lldp_ext_rpc/get_lldp_neighbor_detail/output/lldp_neighbor_detail/remote_port_description (string)
YANG Description: This indicates the remote port description. | f335810:c0:m18 |
def _set_remote_port_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.__remote_port_description = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for remote_port_description, mapped from YANG variable /brocade_lldp_ext_rpc/get_lldp_neighbor_detail/output/lldp_neighbor_detail/remote_port_description (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_remote_port_description is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_remote_port_description() directly.
YANG Description: This indicates the remote port description. | f335810:c0:m19 |
def _get_remote_chassis_id(self): | return self.__remote_chassis_id<EOL> | Getter method for remote_chassis_id, mapped from YANG variable /brocade_lldp_ext_rpc/get_lldp_neighbor_detail/output/lldp_neighbor_detail/remote_chassis_id (string)
YANG Description: This indicates the remote chassis id. | f335810:c0:m21 |
def _set_remote_chassis_id(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.__remote_chassis_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for remote_chassis_id, mapped from YANG variable /brocade_lldp_ext_rpc/get_lldp_neighbor_detail/output/lldp_neighbor_detail/remote_chassis_id (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_remote_chassis_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_remote_chassis_id() directly.
YANG Description: This indicates the remote chassis id. | f335810:c0:m22 |
def _get_remote_system_name(self): | return self.__remote_system_name<EOL> | Getter method for remote_system_name, mapped from YANG variable /brocade_lldp_ext_rpc/get_lldp_neighbor_detail/output/lldp_neighbor_detail/remote_system_name (string)
YANG Description: This indicates the remote system name. | f335810:c0:m24 |
def _set_remote_system_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.__remote_system_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for remote_system_name, mapped from YANG variable /brocade_lldp_ext_rpc/get_lldp_neighbor_detail/output/lldp_neighbor_detail/remote_system_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_remote_system_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_remote_system_name() directly.
YANG Description: This indicates the remote system name. | f335810:c0:m25 |
def _get_remote_system_description(self): | return self.__remote_system_description<EOL> | Getter method for remote_system_description, mapped from YANG variable /brocade_lldp_ext_rpc/get_lldp_neighbor_detail/output/lldp_neighbor_detail/remote_system_description (string)
YANG Description: This indicates the remote system description. | f335810:c0:m27 |
def _set_remote_system_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.__remote_system_description = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for remote_system_description, mapped from YANG variable /brocade_lldp_ext_rpc/get_lldp_neighbor_detail/output/lldp_neighbor_detail/remote_system_description (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_remote_system_description is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_remote_system_description() directly.
YANG Description: This indicates the remote system description. | f335810:c0:m28 |
def _get_dead_interval(self): | return self.__dead_interval<EOL> | Getter method for dead_interval, mapped from YANG variable /brocade_lldp_ext_rpc/get_lldp_neighbor_detail/output/lldp_neighbor_detail/dead_interval (uint64)
YANG Description: This indicates the dead interval | f335810:c0:m30 |
def _set_dead_interval(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.__dead_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dead_interval, mapped from YANG variable /brocade_lldp_ext_rpc/get_lldp_neighbor_detail/output/lldp_neighbor_detail/dead_interval (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_dead_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dead_interval() directly.
YANG Description: This indicates the dead interval | f335810:c0:m31 |
def _get_remaining_life(self): | return self.__remaining_life<EOL> | Getter method for remaining_life, mapped from YANG variable /brocade_lldp_ext_rpc/get_lldp_neighbor_detail/output/lldp_neighbor_detail/remaining_life (uint64)
YANG Description: This indicates the dead interval | f335810:c0:m33 |
def _set_remaining_life(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.__remaining_life = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for remaining_life, mapped from YANG variable /brocade_lldp_ext_rpc/get_lldp_neighbor_detail/output/lldp_neighbor_detail/remaining_life (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_remaining_life is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_remaining_life() directly.
YANG Description: This indicates the dead interval | f335810:c0:m34 |
def _get_lldp_pdu_transmitted(self): | return self.__lldp_pdu_transmitted<EOL> | Getter method for lldp_pdu_transmitted, mapped from YANG variable /brocade_lldp_ext_rpc/get_lldp_neighbor_detail/output/lldp_neighbor_detail/lldp_pdu_transmitted (yang:counter64)
YANG Description: The number of Lldp PDUs transmitted from
the interface | f335810:c0:m36 |
def _set_lldp_pdu_transmitted(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.__lldp_pdu_transmitted = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lldp_pdu_transmitted, mapped from YANG variable /brocade_lldp_ext_rpc/get_lldp_neighbor_detail/output/lldp_neighbor_detail/lldp_pdu_transmitted (yang:counter64)
If this variable is read-only (config: false) in the
source YANG file, then _set_lldp_pdu_transmitted is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lldp_pdu_transmitted() directly.
YANG Description: The number of Lldp PDUs transmitted from
the interface | f335810:c0:m37 |
def _get_lldp_pdu_received(self): | return self.__lldp_pdu_received<EOL> | Getter method for lldp_pdu_received, mapped from YANG variable /brocade_lldp_ext_rpc/get_lldp_neighbor_detail/output/lldp_neighbor_detail/lldp_pdu_received (yang:counter64)
YANG Description: The number of Lldp PDUs received by the
interface | f335810:c0:m39 |
def _set_lldp_pdu_received(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.__lldp_pdu_received = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lldp_pdu_received, mapped from YANG variable /brocade_lldp_ext_rpc/get_lldp_neighbor_detail/output/lldp_neighbor_detail/lldp_pdu_received (yang:counter64)
If this variable is read-only (config: false) in the
source YANG file, then _set_lldp_pdu_received is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lldp_pdu_received() directly.
YANG Description: The number of Lldp PDUs received by the
interface | f335810:c0:m40 |
def _get_member_bridge_domain_add(self): | return self.__member_bridge_domain_add<EOL> | Getter method for member_bridge_domain_add, mapped from YANG variable /topology_group/member_bridge_domain/member_bridge_domain_add (bd:ui32-bridge-domain-range)
YANG Description: This specifies list of Member Bridge Domains to
be added to this topology group | f335811:c0:m3 |
def _set_member_bridge_domain_add(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>', '<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=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, 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.__member_bridge_domain_add = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for member_bridge_domain_add, mapped from YANG variable /topology_group/member_bridge_domain/member_bridge_domain_add (bd:ui32-bridge-domain-range)
If this variable is read-only (config: false) in the
source YANG file, then _set_member_bridge_domain_add is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_member_bridge_domain_add() directly.
YANG Description: This specifies list of Member Bridge Domains to
be added to this topology group | f335811:c0:m4 |
def _get_member_bridge_domain_remove(self): | return self.__member_bridge_domain_remove<EOL> | Getter method for member_bridge_domain_remove, mapped from YANG variable /topology_group/member_bridge_domain/member_bridge_domain_remove (bd:ui32-bridge-domain-range)
YANG Description: This specifies list of Member Bridge Domains to
be removed from this topology group | f335811:c0:m6 |
def _set_member_bridge_domain_remove(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>', '<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=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, 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.__member_bridge_domain_remove = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for member_bridge_domain_remove, mapped from YANG variable /topology_group/member_bridge_domain/member_bridge_domain_remove (bd:ui32-bridge-domain-range)
If this variable is read-only (config: false) in the
source YANG file, then _set_member_bridge_domain_remove is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_member_bridge_domain_remove() directly.
YANG Description: This specifies list of Member Bridge Domains to
be removed from this topology group | f335811:c0:m7 |
def _get_topology_group_id(self): | return self.__topology_group_id<EOL> | Getter method for topology_group_id, mapped from YANG variable /topology_group/topology_group_id (uint32) | f335812:c0:m3 |
def _set_topology_group_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=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=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None}}, 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.__topology_group_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for topology_group_id, mapped from YANG variable /topology_group/topology_group_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_topology_group_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_topology_group_id() directly. | f335812:c0:m4 |
def _get_master_vlan(self): | return self.__master_vlan<EOL> | Getter method for master_vlan, mapped from YANG variable /topology_group/master_vlan (uint32) | f335812:c0:m6 |
def _set_master_vlan(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=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}, 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.__master_vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for master_vlan, mapped from YANG variable /topology_group/master_vlan (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_master_vlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_master_vlan() directly. | f335812:c0:m7 |
def _get_member_vlan(self): | return self.__member_vlan<EOL> | Getter method for member_vlan, mapped from YANG variable /topology_group/member_vlan (container) | f335812:c0:m9 |
def _set_member_vlan(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=member_vlan.member_vlan, 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:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, 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.__member_vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for member_vlan, mapped from YANG variable /topology_group/member_vlan (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_member_vlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_member_vlan() directly. | f335812:c0:m10 |
def _get_member_bridge_domain(self): | return self.__member_bridge_domain<EOL> | Getter method for member_bridge_domain, mapped from YANG variable /topology_group/member_bridge_domain (container) | f335812:c0:m12 |
def _set_member_bridge_domain(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=member_bridge_domain.member_bridge_domain, 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:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, 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.__member_bridge_domain = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for member_bridge_domain, mapped from YANG variable /topology_group/member_bridge_domain (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_member_bridge_domain is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_member_bridge_domain() directly. | f335812:c0:m13 |
def _get_member_vlan_add(self): | return self.__member_vlan_add<EOL> | Getter method for member_vlan_add, mapped from YANG variable /topology_group/member_vlan/member_vlan_add (ui32-member-vlan-range)
YANG Description: This specifies list of Member VLANs to
be added to this topology group | f335813:c0:m3 |
def _set_member_vlan_add(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>', '<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=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, 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.__member_vlan_add = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for member_vlan_add, mapped from YANG variable /topology_group/member_vlan/member_vlan_add (ui32-member-vlan-range)
If this variable is read-only (config: false) in the
source YANG file, then _set_member_vlan_add is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_member_vlan_add() directly.
YANG Description: This specifies list of Member VLANs to
be added to this topology group | f335813:c0:m4 |
def _get_member_vlan_remove(self): | return self.__member_vlan_remove<EOL> | Getter method for member_vlan_remove, mapped from YANG variable /topology_group/member_vlan/member_vlan_remove (ui32-member-vlan-range)
YANG Description: This specifies list of Member VLANs to
be removed from this topology group | f335813:c0:m6 |
def _set_member_vlan_remove(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>', '<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=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, 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.__member_vlan_remove = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for member_vlan_remove, mapped from YANG variable /topology_group/member_vlan/member_vlan_remove (ui32-member-vlan-range)
If this variable is read-only (config: false) in the
source YANG file, then _set_member_vlan_remove is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_member_vlan_remove() directly.
YANG Description: This specifies list of Member VLANs to
be removed from this topology group | f335813:c0:m7 |
def _get_rbridge_id(self): | return self.__rbridge_id<EOL> | Getter method for rbridge_id, mapped from YANG variable /brocade_port_profile_ext_rpc/get_port_profile_for_intf/input/rbridge_id (uint32)
YANG Description: rbridge id of the node from which the data needs
to be fetched. When no rbridge id is given, data is fetched
from all rbridges | f335814:c0:m3 |
def _set_rbridge_id(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.__rbridge_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rbridge_id, mapped from YANG variable /brocade_port_profile_ext_rpc/get_port_profile_for_intf/input/rbridge_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_rbridge_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rbridge_id() directly.
YANG Description: rbridge id of the node from which the data needs
to be fetched. When no rbridge id is given, data is fetched
from all rbridges | f335814:c0:m4 |
def _get_interface_type(self): | return self.__interface_type<EOL> | Getter method for interface_type, mapped from YANG variable /brocade_port_profile_ext_rpc/get_port_profile_for_intf/input/interface_type (enumeration)
YANG Description: The type of the interface. An 'unknown' type
represents error scenario and should not be used. | f335814:c0:m6 |
def _set_interface_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: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, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u"<STR_LIT>"}}, 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_port_profile_ext_rpc/get_port_profile_for_intf/input/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. | f335814:c0:m7 |
def _get_interface_name(self): | return self.__interface_name<EOL> | Getter method for interface_name, mapped from YANG variable /brocade_port_profile_ext_rpc/get_port_profile_for_intf/input/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. | f335814:c0:m9 |
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=[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, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>'}}, 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_port_profile_ext_rpc/get_port_profile_for_intf/input/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. | f335814:c0:m10 |
def _get_last_received_interface_info(self): | return self.__last_received_interface_info<EOL> | Getter method for last_received_interface_info, mapped from YANG variable /brocade_port_profile_ext_rpc/get_port_profile_for_intf/input/last_received_interface_info (container)
YANG Description: The rpc returns the list of
port-profiles associated with the next set of
interfaces.
The rpc request would look as below:
get-port-profile-for-intf
last-received-interface-info/interface-type=
fortygigabitethernet
last-received-interface-info/interface-name=
1/0/1.
The rpc response will contain the list of
port-profiles applied on the interface fo 1/0/2,
1/0/3 and so on till the page limit is reached.
The rpc response has an attribute is-more, which
will be false, when all the interfaces are
exhausted.
The getnext-request model can be used to retrieve
the port-profiles applied on all the interfaces.
The rpc returns the list of port-profiles applied
on the first set of interfaces when interface name
and interface type are not specified. | f335814:c0:m12 |
def _set_last_received_interface_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=last_received_interface_info.last_received_interface_info, is_container='<STR_LIT>', presence=False, 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, extensions=None, 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.__last_received_interface_info = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for last_received_interface_info, mapped from YANG variable /brocade_port_profile_ext_rpc/get_port_profile_for_intf/input/last_received_interface_info (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_last_received_interface_info is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_last_received_interface_info() directly.
YANG Description: The rpc returns the list of
port-profiles associated with the next set of
interfaces.
The rpc request would look as below:
get-port-profile-for-intf
last-received-interface-info/interface-type=
fortygigabitethernet
last-received-interface-info/interface-name=
1/0/1.
The rpc response will contain the list of
port-profiles applied on the interface fo 1/0/2,
1/0/3 and so on till the page limit is reached.
The rpc response has an attribute is-more, which
will be false, when all the interfaces are
exhausted.
The getnext-request model can be used to retrieve
the port-profiles applied on all the interfaces.
The rpc returns the list of port-profiles applied
on the first set of interfaces when interface name
and interface type are not specified. | f335814:c0:m13 |
def _get_interface_type(self): | return self.__interface_type<EOL> | Getter method for interface_type, mapped from YANG variable /brocade_port_profile_ext_rpc/get_port_profile_for_intf/input/last_received_interface_info/interface_type (enumeration)
YANG Description: The type of the interface. An 'unknown' type
represents error scenario and should not be used. | f335815:c0:m3 |
def _set_interface_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: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, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u"<STR_LIT>"}}, 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_port_profile_ext_rpc/get_port_profile_for_intf/input/last_received_interface_info/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. | f335815:c0:m4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.