signature
stringlengths 8
3.44k
| body
stringlengths 0
1.41M
| docstring
stringlengths 1
122k
| id
stringlengths 5
17
|
|---|---|---|---|
def _get_ip_mtu(self):
|
return self.__ip_mtu<EOL>
|
Getter method for ip_mtu, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ip_mtu (interface:mtu-type)
YANG Description: This specifies the IP MTU value of this
interface.
|
f336756:c0:m15
|
def _set_ip_mtu(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ip_mtu = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for ip_mtu, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ip_mtu (interface:mtu-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_ip_mtu is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ip_mtu() directly.
YANG Description: This specifies the IP MTU value of this
interface.
|
f336756:c0:m16
|
def _get_if_name(self):
|
return self.__if_name<EOL>
|
Getter method for if_name, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/if_name (string)
YANG Description: This indicates the interface display name as
in MIB-II's ifTable. However interface-name and
interface-type values of this instance forms
fully qualified name for this interface.
|
f336756:c0:m18
|
def _set_if_name(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__if_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for if_name, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/if_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_if_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_if_name() directly.
YANG Description: This indicates the interface display name as
in MIB-II's ifTable. However interface-name and
interface-type values of this instance forms
fully qualified name for this interface.
|
f336756:c0:m19
|
def _get_if_state(self):
|
return self.__if_state<EOL>
|
Getter method for if_state, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/if_state (enumeration)
YANG Description: This indicates the current operational state
of this interface. The 'testing' state
indicates that no operational packets can be
passed. If 'shutdown' leaf of corresponding
interface instance of brocade-interface module
is set, then 'if-state' should be 'down'.
If 'shutdown' is changed deleted, then
'if-state' should change to 'up' if the
interface is ready to transmit and receive
network traffic; it should remain in the 'down'
state if and only if there is a fault that
prevents it from going to the 'up' state.
|
f336756:c0:m21
|
def _set_if_state(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__if_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for if_state, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/if_state (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_if_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_if_state() directly.
YANG Description: This indicates the current operational state
of this interface. The 'testing' state
indicates that no operational packets can be
passed. If 'shutdown' leaf of corresponding
interface instance of brocade-interface module
is set, then 'if-state' should be 'down'.
If 'shutdown' is changed deleted, then
'if-state' should change to 'up' if the
interface is ready to transmit and receive
network traffic; it should remain in the 'down'
state if and only if there is a fault that
prevents it from going to the 'up' state.
|
f336756:c0:m22
|
def _get_line_protocol_state(self):
|
return self.__line_protocol_state<EOL>
|
Getter method for line_protocol_state, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/line_protocol_state (enumeration)
YANG Description: This indicates the 'Line protocol' state of
this interface.
|
f336756:c0:m24
|
def _set_line_protocol_state(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__line_protocol_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for line_protocol_state, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/line_protocol_state (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_line_protocol_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_line_protocol_state() directly.
YANG Description: This indicates the 'Line protocol' state of
this interface.
|
f336756:c0:m25
|
def _get_line_protocol_state_info(self):
|
return self.__line_protocol_state_info<EOL>
|
Getter method for line_protocol_state_info, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/line_protocol_state_info (string)
YANG Description: This indicates the reason for the current line
protocol state of this interface.
|
f336756:c0:m27
|
def _set_line_protocol_state_info(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__line_protocol_state_info = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for line_protocol_state_info, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/line_protocol_state_info (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_line_protocol_state_info is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_line_protocol_state_info() directly.
YANG Description: This indicates the reason for the current line
protocol state of this interface.
|
f336756:c0:m28
|
def _get_line_protocol_exception_info(self):
|
return self.__line_protocol_exception_info<EOL>
|
Getter method for line_protocol_exception_info, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/line_protocol_exception_info (string)
YANG Description: This indicates the 'Exception information' of
line protocol.
|
f336756:c0:m30
|
def _set_line_protocol_exception_info(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__line_protocol_exception_info = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for line_protocol_exception_info, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/line_protocol_exception_info (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_line_protocol_exception_info is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_line_protocol_exception_info() directly.
YANG Description: This indicates the 'Exception information' of
line protocol.
|
f336756:c0:m31
|
def _get_hardware_type(self):
|
return self.__hardware_type<EOL>
|
Getter method for hardware_type, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/hardware_type (enumeration)
YANG Description: This indicates the type of this interface.
|
f336756:c0:m33
|
def _set_hardware_type(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:9>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:10>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:8>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__hardware_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for hardware_type, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/hardware_type (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_hardware_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hardware_type() directly.
YANG Description: This indicates the type of this interface.
|
f336756:c0:m34
|
def _get_logical_hardware_address(self):
|
return self.__logical_hardware_address<EOL>
|
Getter method for logical_hardware_address, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/logical_hardware_address (yang:mac-address)
YANG Description: This indicates the address of this interface at
its protocol sub-layer.
|
f336756:c0:m36
|
def _set_logical_hardware_address(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__logical_hardware_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for logical_hardware_address, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/logical_hardware_address (yang:mac-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_logical_hardware_address is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_logical_hardware_address() directly.
YANG Description: This indicates the address of this interface at
its protocol sub-layer.
|
f336756:c0:m37
|
def _get_current_hardware_address(self):
|
return self.__current_hardware_address<EOL>
|
Getter method for current_hardware_address, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/current_hardware_address (yang:mac-address)
YANG Description: This indicates the address of this interface at
its protocol sub-layer.
|
f336756:c0:m39
|
def _set_current_hardware_address(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__current_hardware_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for current_hardware_address, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/current_hardware_address (yang:mac-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_current_hardware_address is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_current_hardware_address() directly.
YANG Description: This indicates the address of this interface at
its protocol sub-layer.
|
f336756:c0:m40
|
def _get_media_type(self):
|
return self.__media_type<EOL>
|
Getter method for media_type, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/media_type (enumeration)
YANG Description: The specifies the type of the media plugged in
for this interface.
|
f336756:c0:m42
|
def _set_media_type(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:12>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__media_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for media_type, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/media_type (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_media_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_media_type() directly.
YANG Description: The specifies the type of the media plugged in
for this interface.
|
f336756:c0:m43
|
def _get_wavelength(self):
|
return self.__wavelength<EOL>
|
Getter method for wavelength, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/wavelength (uint32)
YANG Description: Wavelength of pluggable media
|
f336756:c0:m45
|
def _set_wavelength(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__wavelength = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for wavelength, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/wavelength (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_wavelength is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_wavelength() directly.
YANG Description: Wavelength of pluggable media
|
f336756:c0:m46
|
def _get_if_description(self):
|
return self.__if_description<EOL>
|
Getter method for if_description, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/if_description (string)
YANG Description: This specifies a textual string containing
information about the interface.
|
f336756:c0:m48
|
def _set_if_description(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__if_description = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for if_description, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/if_description (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_if_description is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_if_description() directly.
YANG Description: This specifies a textual string containing
information about the interface.
|
f336756:c0:m49
|
def _get_actual_line_speed(self):
|
return self.__actual_line_speed<EOL>
|
Getter method for actual_line_speed, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/actual_line_speed (string)
YANG Description: The actual line speed of this interface.
|
f336756:c0:m51
|
def _set_actual_line_speed(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__actual_line_speed = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for actual_line_speed, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/actual_line_speed (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_actual_line_speed is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_actual_line_speed() directly.
YANG Description: The actual line speed of this interface.
|
f336756:c0:m52
|
def _get_configured_line_speed(self):
|
return self.__configured_line_speed<EOL>
|
Getter method for configured_line_speed, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/configured_line_speed (line-speed)
YANG Description: The administratively configured line speed of
this interface. This should be same as what is
returned by value of corresponding instance of
'speed' of 'brocade-interface' module.
|
f336756:c0:m54
|
def _set_configured_line_speed(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:9>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:12>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:8>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:11>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:10>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__configured_line_speed = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for configured_line_speed, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/configured_line_speed (line-speed)
If this variable is read-only (config: false) in the
source YANG file, then _set_configured_line_speed is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_configured_line_speed() directly.
YANG Description: The administratively configured line speed of
this interface. This should be same as what is
returned by value of corresponding instance of
'speed' of 'brocade-interface' module.
|
f336756:c0:m55
|
def _get_line_duplex_state(self):
|
return self.__line_duplex_state<EOL>
|
Getter method for line_duplex_state, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/line_duplex_state (enumeration)
YANG Description: This indicates the 'Line duplex state' of this
interface.
|
f336756:c0:m57
|
def _set_line_duplex_state(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__line_duplex_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for line_duplex_state, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/line_duplex_state (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_line_duplex_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_line_duplex_state() directly.
YANG Description: This indicates the 'Line duplex state' of this
interface.
|
f336756:c0:m58
|
def _get_flow_control(self):
|
return self.__flow_control<EOL>
|
Getter method for flow_control, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/flow_control (enumeration)
YANG Description: This indicates the 'Flow control' for this
interface.
|
f336756:c0:m60
|
def _set_flow_control(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__flow_control = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for flow_control, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/flow_control (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_flow_control is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_flow_control() directly.
YANG Description: This indicates the 'Flow control' for this
interface.
|
f336756:c0:m61
|
def _get_queuing_strategy(self):
|
return self.__queuing_strategy<EOL>
|
Getter method for queuing_strategy, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/queuing_strategy (enumeration)
YANG Description: This indicates the 'Queuing strategy' for
this interface.
|
f336756:c0:m63
|
def _set_queuing_strategy(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__queuing_strategy = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for queuing_strategy, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/queuing_strategy (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_queuing_strategy is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_queuing_strategy() directly.
YANG Description: This indicates the 'Queuing strategy' for
this interface.
|
f336756:c0:m64
|
def _get_port_role(self):
|
return self.__port_role<EOL>
|
Getter method for port_role, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/port_role (enumeration)
YANG Description: This indicates current that this interface is
playing. This is applicable only for physical
interfaces.
|
f336756:c0:m66
|
def _set_port_role(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__port_role = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for port_role, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/port_role (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_port_role is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port_role() directly.
YANG Description: This indicates current that this interface is
playing. This is applicable only for physical
interfaces.
|
f336756:c0:m67
|
def _get_port_mode(self):
|
return self.__port_mode<EOL>
|
Getter method for port_mode, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/port_mode (enumeration)
YANG Description: This indicates operational mode of this
interface. This is applicable only for physical
interfaces/port channel interfaces.
|
f336756:c0:m69
|
def _set_port_mode(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__port_mode = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for port_mode, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/port_mode (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_port_mode is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port_mode() directly.
YANG Description: This indicates operational mode of this
interface. This is applicable only for physical
interfaces/port channel interfaces.
|
f336756:c0:m70
|
def _get_ifHCInOctets(self):
|
return self.__ifHCInOctets<EOL>
|
Getter method for ifHCInOctets, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCInOctets (yang:counter64)
YANG Description: The total number of octets received on the
interface, including framing characters.
|
f336756:c0:m72
|
def _set_ifHCInOctets(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ifHCInOctets = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for ifHCInOctets, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCInOctets (yang:counter64)
If this variable is read-only (config: false) in the
source YANG file, then _set_ifHCInOctets is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ifHCInOctets() directly.
YANG Description: The total number of octets received on the
interface, including framing characters.
|
f336756:c0:m73
|
def _get_ifHCInUcastPkts(self):
|
return self.__ifHCInUcastPkts<EOL>
|
Getter method for ifHCInUcastPkts, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCInUcastPkts (yang:counter64)
YANG Description: The number of packets, delivered by this
sub-layer to a higher (sub-)layer, which were
not addressed to a multicast or broadcast
address at this sub-layer.
|
f336756:c0:m75
|
def _set_ifHCInUcastPkts(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ifHCInUcastPkts = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for ifHCInUcastPkts, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCInUcastPkts (yang:counter64)
If this variable is read-only (config: false) in the
source YANG file, then _set_ifHCInUcastPkts is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ifHCInUcastPkts() directly.
YANG Description: The number of packets, delivered by this
sub-layer to a higher (sub-)layer, which were
not addressed to a multicast or broadcast
address at this sub-layer.
|
f336756:c0:m76
|
def _get_ifHCInMulticastPkts(self):
|
return self.__ifHCInMulticastPkts<EOL>
|
Getter method for ifHCInMulticastPkts, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCInMulticastPkts (yang:counter64)
YANG Description: The number of packets, delivered by this
sub-layer to a higher (sub-)layer, which were
addressed to a multicast address at this
sub-layer. For a MAC layer protocol, this
includes both Group and Functional addresses.
|
f336756:c0:m78
|
def _set_ifHCInMulticastPkts(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ifHCInMulticastPkts = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for ifHCInMulticastPkts, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCInMulticastPkts (yang:counter64)
If this variable is read-only (config: false) in the
source YANG file, then _set_ifHCInMulticastPkts is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ifHCInMulticastPkts() directly.
YANG Description: The number of packets, delivered by this
sub-layer to a higher (sub-)layer, which were
addressed to a multicast address at this
sub-layer. For a MAC layer protocol, this
includes both Group and Functional addresses.
|
f336756:c0:m79
|
def _get_ifHCInBroadcastPkts(self):
|
return self.__ifHCInBroadcastPkts<EOL>
|
Getter method for ifHCInBroadcastPkts, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCInBroadcastPkts (yang:counter64)
YANG Description: The number of packets, delivered by this
sub-layer to a higher (sub-)layer, which were
addressed to a broadcast address at this
sub-layer.
|
f336756:c0:m81
|
def _set_ifHCInBroadcastPkts(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ifHCInBroadcastPkts = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for ifHCInBroadcastPkts, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCInBroadcastPkts (yang:counter64)
If this variable is read-only (config: false) in the
source YANG file, then _set_ifHCInBroadcastPkts is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ifHCInBroadcastPkts() directly.
YANG Description: The number of packets, delivered by this
sub-layer to a higher (sub-)layer, which were
addressed to a broadcast address at this
sub-layer.
|
f336756:c0:m82
|
def _get_ifHCInErrors(self):
|
return self.__ifHCInErrors<EOL>
|
Getter method for ifHCInErrors, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCInErrors (yang:counter64)
YANG Description: For packet-oriented interfaces, the number of
inbound packets that contained errors
preventing them from being deliverable to a
higher-layer protocol. For character-oriented
or fixed-length interfaces, the number of
inbound transmission units that contained
errors preventing them from being deliverable
to a higher-layer protocol.
|
f336756:c0:m84
|
def _set_ifHCInErrors(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ifHCInErrors = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for ifHCInErrors, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCInErrors (yang:counter64)
If this variable is read-only (config: false) in the
source YANG file, then _set_ifHCInErrors is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ifHCInErrors() directly.
YANG Description: For packet-oriented interfaces, the number of
inbound packets that contained errors
preventing them from being deliverable to a
higher-layer protocol. For character-oriented
or fixed-length interfaces, the number of
inbound transmission units that contained
errors preventing them from being deliverable
to a higher-layer protocol.
|
f336756:c0:m85
|
def _get_ifHCOutOctets(self):
|
return self.__ifHCOutOctets<EOL>
|
Getter method for ifHCOutOctets, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCOutOctets (yang:counter64)
YANG Description: The total number of octets transmitted out of
the interface, including framing characters.
|
f336756:c0:m87
|
def _set_ifHCOutOctets(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ifHCOutOctets = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for ifHCOutOctets, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCOutOctets (yang:counter64)
If this variable is read-only (config: false) in the
source YANG file, then _set_ifHCOutOctets is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ifHCOutOctets() directly.
YANG Description: The total number of octets transmitted out of
the interface, including framing characters.
|
f336756:c0:m88
|
def _get_ifHCOutUcastPkts(self):
|
return self.__ifHCOutUcastPkts<EOL>
|
Getter method for ifHCOutUcastPkts, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCOutUcastPkts (yang:counter64)
YANG Description: The total number of packets that higher-level
protocols requested be transmitted, and which
were not addressed to a multicast or broadcast
address at this sub-layer, including those
that were discarded or not sent.
|
f336756:c0:m90
|
def _set_ifHCOutUcastPkts(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ifHCOutUcastPkts = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for ifHCOutUcastPkts, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCOutUcastPkts (yang:counter64)
If this variable is read-only (config: false) in the
source YANG file, then _set_ifHCOutUcastPkts is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ifHCOutUcastPkts() directly.
YANG Description: The total number of packets that higher-level
protocols requested be transmitted, and which
were not addressed to a multicast or broadcast
address at this sub-layer, including those
that were discarded or not sent.
|
f336756:c0:m91
|
def _get_ifHCOutMulticastPkts(self):
|
return self.__ifHCOutMulticastPkts<EOL>
|
Getter method for ifHCOutMulticastPkts, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCOutMulticastPkts (yang:counter64)
YANG Description: The total number of packets that higher-level
protocols requested be transmitted, and which
were addressed to a multicast address at this
sub-layer, including those that were discarded
or not sent. For a MAC layer protocol, this
includes both Group and Functional addresses.
|
f336756:c0:m93
|
def _set_ifHCOutMulticastPkts(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ifHCOutMulticastPkts = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for ifHCOutMulticastPkts, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCOutMulticastPkts (yang:counter64)
If this variable is read-only (config: false) in the
source YANG file, then _set_ifHCOutMulticastPkts is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ifHCOutMulticastPkts() directly.
YANG Description: The total number of packets that higher-level
protocols requested be transmitted, and which
were addressed to a multicast address at this
sub-layer, including those that were discarded
or not sent. For a MAC layer protocol, this
includes both Group and Functional addresses.
|
f336756:c0:m94
|
def _get_ifHCOutBroadcastPkts(self):
|
return self.__ifHCOutBroadcastPkts<EOL>
|
Getter method for ifHCOutBroadcastPkts, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCOutBroadcastPkts (yang:counter64)
YANG Description: The total number of packets that higher-level
protocols requested be transmitted, and which
were addressed to a broadcast address at this
sub-layer, including those that were discarded
or not sent.
|
f336756:c0:m96
|
def _set_ifHCOutBroadcastPkts(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ifHCOutBroadcastPkts = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for ifHCOutBroadcastPkts, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCOutBroadcastPkts (yang:counter64)
If this variable is read-only (config: false) in the
source YANG file, then _set_ifHCOutBroadcastPkts is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ifHCOutBroadcastPkts() directly.
YANG Description: The total number of packets that higher-level
protocols requested be transmitted, and which
were addressed to a broadcast address at this
sub-layer, including those that were discarded
or not sent.
|
f336756:c0:m97
|
def _get_ifHCOutErrors(self):
|
return self.__ifHCOutErrors<EOL>
|
Getter method for ifHCOutErrors, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCOutErrors (yang:counter64)
YANG Description: For packet-oriented interfaces, the number of
outbound packets that could not be transmitted
because of errors. For character-oriented or
fixed-length interfaces, the number of
outbound transmission units that could not be
transmitted because of errors.
|
f336756:c0:m99
|
def _set_ifHCOutErrors(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ifHCOutErrors = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for ifHCOutErrors, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_detail/output/interface/ifHCOutErrors (yang:counter64)
If this variable is read-only (config: false) in the
source YANG file, then _set_ifHCOutErrors is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ifHCOutErrors() directly.
YANG Description: For packet-oriented interfaces, the number of
outbound packets that could not be transmitted
because of errors. For character-oriented or
fixed-length interfaces, the number of
outbound transmission units that could not be
transmitted because of errors.
|
f336756:c0:m100
|
def _get_interface_type(self):
|
return self.__interface_type<EOL>
|
Getter method for interface_type, mapped from YANG variable /brocade_interface_ext_rpc/get_vlan_brief/output/vlan/interface/interface_type (enumeration)
YANG Description: The type of the interface. An 'unknown' type
represents error scenario and should not be used.
|
f336757:c0:m3
|
def _set_interface_type(self, v, load=False):
|
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:8>}, 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:11>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:10>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u"<STR_LIT>"}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__interface_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for interface_type, mapped from YANG variable /brocade_interface_ext_rpc/get_vlan_brief/output/vlan/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.
|
f336757:c0:m4
|
def _get_interface_name(self):
|
return self.__interface_name<EOL>
|
Getter method for interface_name, mapped from YANG variable /brocade_interface_ext_rpc/get_vlan_brief/output/vlan/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
loopback Loopback ID
ve VE Interface 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.
|
f336757:c0:m6
|
def _set_interface_name(self, v, load=False):
|
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=[RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>', '<STR_LIT>': [u'<STR_LIT>']}),RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}),RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}),], is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>'}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__interface_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for interface_name, mapped from YANG variable /brocade_interface_ext_rpc/get_vlan_brief/output/vlan/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
loopback Loopback ID
ve VE Interface 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.
|
f336757:c0:m7
|
def _get_tag(self):
|
return self.__tag<EOL>
|
Getter method for tag, mapped from YANG variable /brocade_interface_ext_rpc/get_vlan_brief/output/vlan/interface/tag (enumeration)
|
f336757:c0:m9
|
def _set_tag(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__tag = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for tag, mapped from YANG variable /brocade_interface_ext_rpc/get_vlan_brief/output/vlan/interface/tag (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_tag is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tag() directly.
|
f336757:c0:m10
|
def _get_classification(self):
|
return self.__classification<EOL>
|
Getter method for classification, mapped from YANG variable /brocade_interface_ext_rpc/get_vlan_brief/output/vlan/interface/classification (list)
YANG Description: This specifies the list of vlan classifications applied
on a given vlan and an interface pair.
|
f336757:c0:m12
|
def _set_classification(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>",classification.classification, 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=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.__classification = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for classification, mapped from YANG variable /brocade_interface_ext_rpc/get_vlan_brief/output/vlan/interface/classification (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_classification is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_classification() directly.
YANG Description: This specifies the list of vlan classifications applied
on a given vlan and an interface pair.
|
f336757:c0:m13
|
def _get_interface_type(self):
|
return self.__interface_type<EOL>
|
Getter method for interface_type, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_switchport/input/last_rcvd_interface/interface_type (enumeration)
YANG Description: The type of the interface. An 'unknown' type
represents error scenario and should not be used.
|
f336758: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:8>}, 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:11>}, 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_interface_ext_rpc/get_interface_switchport/input/last_rcvd_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.
|
f336758:c0:m4
|
def _get_interface_name(self):
|
return self.__interface_name<EOL>
|
Getter method for interface_name, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_switchport/input/last_rcvd_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
loopback Loopback ID
ve VE Interface 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.
|
f336758: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_interface_ext_rpc/get_interface_switchport/input/last_rcvd_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
loopback Loopback ID
ve VE Interface 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.
|
f336758:c0:m7
|
def _get_last_rcvd_interface(self):
|
return self.__last_rcvd_interface<EOL>
|
Getter method for last_rcvd_interface, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_switchport/input/last_rcvd_interface (container)
|
f336759:c0:m3
|
def _set_last_rcvd_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=last_rcvd_interface.last_rcvd_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.__last_rcvd_interface = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for last_rcvd_interface, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_switchport/input/last_rcvd_interface (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_last_rcvd_interface is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_last_rcvd_interface() directly.
|
f336759:c0:m4
|
def _get_input(self):
|
return self.__input<EOL>
|
Getter method for input, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_switchport/input (input)
|
f336760:c0:m3
|
def _set_input(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=input.input, is_leaf=True, yang_name="<STR_LIT:input>", rest_name="<STR_LIT:input>", 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:input>', 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.__input = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for input, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_switchport/input (input)
If this variable is read-only (config: false) in the
source YANG file, then _set_input is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_input() directly.
|
f336760:c0:m4
|
def _get_output(self):
|
return self.__output<EOL>
|
Getter method for output, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_switchport/output (output)
|
f336760:c0:m6
|
def _set_output(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=output.output, 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=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.__output = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for output, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_switchport/output (output)
If this variable is read-only (config: false) in the
source YANG file, then _set_output is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_output() directly.
|
f336760:c0:m7
|
def _get_switchport(self):
|
return self.__switchport<EOL>
|
Getter method for switchport, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_switchport/output/switchport (list)
YANG Description: This is a list of all the switch-ports in the
managed device. Each row represents an L2 port
along with the operational characteristics.
|
f336761:c0:m3
|
def _set_switchport(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>",switchport.switchport, 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=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.__switchport = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for switchport, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_switchport/output/switchport (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_switchport is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_switchport() directly.
YANG Description: This is a list of all the switch-ports in the
managed device. Each row represents an L2 port
along with the operational characteristics.
|
f336761:c0:m4
|
def _get_has_more(self):
|
return self.__has_more<EOL>
|
Getter method for has_more, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_switchport/output/has_more (boolean)
YANG Description: Informs whether backend has more
interfaces that are not part of
current response. Based on this
flag remaining interfaces can be
fetched with another request
|
f336761:c0:m6
|
def _set_has_more(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, 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.__has_more = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for has_more, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_switchport/output/has_more (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_has_more is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_has_more() directly.
YANG Description: Informs whether backend has more
interfaces that are not part of
current response. Based on this
flag remaining interfaces can be
fetched with another request
|
f336761:c0:m7
|
def _get_interface_type(self):
|
return self.__interface_type<EOL>
|
Getter method for interface_type, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_switchport/output/switchport/interface_type (enumeration)
YANG Description: The type of the interface. An 'unknown' type
represents error scenario and should not be used.
|
f336762:c0:m3
|
def _set_interface_type(self, v, load=False):
|
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:8>}, 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:11>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:10>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u"<STR_LIT>"}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__interface_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for interface_type, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_switchport/output/switchport/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.
|
f336762:c0:m4
|
def _get_interface_name(self):
|
return self.__interface_name<EOL>
|
Getter method for interface_name, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_switchport/output/switchport/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
loopback Loopback ID
ve VE Interface 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.
|
f336762:c0:m6
|
def _set_interface_name(self, v, load=False):
|
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=[RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>', '<STR_LIT>': [u'<STR_LIT>']}),RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}),RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}),], is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>'}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__interface_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for interface_name, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_switchport/output/switchport/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
loopback Loopback ID
ve VE Interface 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.
|
f336762:c0:m7
|
def _get_mode(self):
|
return self.__mode<EOL>
|
Getter method for mode, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_switchport/output/switchport/mode (interface:switchport-mode-type)
YANG Description: This indicates the mode of Layer2 interface.
|
f336762:c0:m9
|
def _set_mode(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:9>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:8>}, 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.__mode = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for mode, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_switchport/output/switchport/mode (interface:switchport-mode-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_mode is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mode() directly.
YANG Description: This indicates the mode of Layer2 interface.
|
f336762:c0:m10
|
def _get_ingress_filter_enabled(self):
|
return self.__ingress_filter_enabled<EOL>
|
Getter method for ingress_filter_enabled, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_switchport/output/switchport/ingress_filter_enabled (boolean)
YANG Description: This indicates if the 'Ingress filtering' is
enabled for this interface.
The value of 'true' indicates that the port is
enabled for 'Ingress filtering'. The value of
'false' indicates that the port is not enabled
for 'Ingress filtering'.
|
f336762:c0:m12
|
def _set_ingress_filter_enabled(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, 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.__ingress_filter_enabled = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for ingress_filter_enabled, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_switchport/output/switchport/ingress_filter_enabled (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_ingress_filter_enabled is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ingress_filter_enabled() directly.
YANG Description: This indicates if the 'Ingress filtering' is
enabled for this interface.
The value of 'true' indicates that the port is
enabled for 'Ingress filtering'. The value of
'false' indicates that the port is not enabled
for 'Ingress filtering'.
|
f336762:c0:m13
|
def _get_acceptable_frame_type(self):
|
return self.__acceptable_frame_type<EOL>
|
Getter method for acceptable_frame_type, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_switchport/output/switchport/acceptable_frame_type (enumeration)
YANG Description: This specifies the switch-port ingress
Frame admission policy - whether only tagged
Frames are allowed or all.
|
f336762:c0:m15
|
def _set_acceptable_frame_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:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__acceptable_frame_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for acceptable_frame_type, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_switchport/output/switchport/acceptable_frame_type (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_acceptable_frame_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_acceptable_frame_type() directly.
YANG Description: This specifies the switch-port ingress
Frame admission policy - whether only tagged
Frames are allowed or all.
|
f336762:c0:m16
|
def _get_default_vlan(self):
|
return self.__default_vlan<EOL>
|
Getter method for default_vlan, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_switchport/output/switchport/default_vlan (interface:vlan-type)
YANG Description: This indicates the 'default vlan' identifier
value for this switch-port. If switch-port mode
as indicated by the value of the corresponding
instance of 'mode' is 'trunk', Native vlan is
returned. If switch-port mode is 'access',
default vlan is returned.
|
f336762:c0:m18
|
def _set_default_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=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.__default_vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for default_vlan, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_switchport/output/switchport/default_vlan (interface:vlan-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_default_vlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_default_vlan() directly.
YANG Description: This indicates the 'default vlan' identifier
value for this switch-port. If switch-port mode
as indicated by the value of the corresponding
instance of 'mode' is 'trunk', Native vlan is
returned. If switch-port mode is 'access',
default vlan is returned.
|
f336762:c0:m19
|
def _get_active_vlans(self):
|
return self.__active_vlans<EOL>
|
Getter method for active_vlans, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_switchport/output/switchport/active_vlans (container)
YANG Description: A conceptual group indicating the active vlans
for this switch-port interface.
|
f336762:c0:m21
|
def _set_active_vlans(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=active_vlans.active_vlans, 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=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.__active_vlans = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for active_vlans, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_switchport/output/switchport/active_vlans (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_active_vlans is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_active_vlans() directly.
YANG Description: A conceptual group indicating the active vlans
for this switch-port interface.
|
f336762:c0:m22
|
def _get_inactive_vlans(self):
|
return self.__inactive_vlans<EOL>
|
Getter method for inactive_vlans, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_switchport/output/switchport/inactive_vlans (container)
YANG Description: A conceptual group indicating the in-active
vlans for this switch-port interface.
|
f336762:c0:m24
|
def _set_inactive_vlans(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=inactive_vlans.inactive_vlans, 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=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.__inactive_vlans = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for inactive_vlans, mapped from YANG variable /brocade_interface_ext_rpc/get_interface_switchport/output/switchport/inactive_vlans (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_inactive_vlans is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_inactive_vlans() directly.
YANG Description: A conceptual group indicating the in-active
vlans for this switch-port interface.
|
f336762:c0:m25
|
def _get_defaults(self):
|
return self.__defaults<EOL>
|
Getter method for defaults, mapped from YANG variable /show/defaults (container)
|
f336763:c0:m3
|
def _set_defaults(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=defaults.defaults, 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>'}}, 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.__defaults = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for defaults, mapped from YANG variable /show/defaults (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_defaults is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_defaults() directly.
|
f336763:c0:m4
|
def _get_crypto(self):
|
return self.__crypto<EOL>
|
Getter method for crypto, mapped from YANG variable /show/crypto (container)
|
f336763:c0:m6
|
def _set_crypto(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=crypto.crypto, 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>'}}, 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.__crypto = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for crypto, mapped from YANG variable /show/crypto (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_crypto is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_crypto() directly.
|
f336763:c0:m7
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.