signature
stringlengths 8
3.44k
| body
stringlengths 0
1.41M
| docstring
stringlengths 1
122k
| id
stringlengths 5
17
|
|---|---|---|---|
def _get_ipv6_src_l4_port(self): | return self.__ipv6_src_l4_port<EOL> | Getter method for ipv6_src_l4_port, mapped from YANG variable /load_balance/hash/ipv6/ipv6_src_l4_port (empty) | f337082:c0:m3 |
def _set_ipv6_src_l4_port(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=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ipv6_src_l4_port = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ipv6_src_l4_port, mapped from YANG variable /load_balance/hash/ipv6/ipv6_src_l4_port (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_ipv6_src_l4_port is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ipv6_src_l4_port() directly. | f337082:c0:m4 |
def _get_ipv6_dst_l4_port(self): | return self.__ipv6_dst_l4_port<EOL> | Getter method for ipv6_dst_l4_port, mapped from YANG variable /load_balance/hash/ipv6/ipv6_dst_l4_port (empty) | f337082:c0:m6 |
def _set_ipv6_dst_l4_port(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=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ipv6_dst_l4_port = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ipv6_dst_l4_port, mapped from YANG variable /load_balance/hash/ipv6/ipv6_dst_l4_port (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_ipv6_dst_l4_port is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ipv6_dst_l4_port() directly. | f337082:c0:m7 |
def _get_ipv6_src_ip(self): | return self.__ipv6_src_ip<EOL> | Getter method for ipv6_src_ip, mapped from YANG variable /load_balance/hash/ipv6/ipv6_src_ip (empty) | f337082:c0:m9 |
def _set_ipv6_src_ip(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=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ipv6_src_ip = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ipv6_src_ip, mapped from YANG variable /load_balance/hash/ipv6/ipv6_src_ip (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_ipv6_src_ip is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ipv6_src_ip() directly. | f337082:c0:m10 |
def _get_ipv6_dst_ip(self): | return self.__ipv6_dst_ip<EOL> | Getter method for ipv6_dst_ip, mapped from YANG variable /load_balance/hash/ipv6/ipv6_dst_ip (empty) | f337082:c0:m12 |
def _set_ipv6_dst_ip(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=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ipv6_dst_ip = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ipv6_dst_ip, mapped from YANG variable /load_balance/hash/ipv6/ipv6_dst_ip (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_ipv6_dst_ip is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ipv6_dst_ip() directly. | f337082:c0:m13 |
def _get_ipv6_next_hdr(self): | return self.__ipv6_next_hdr<EOL> | Getter method for ipv6_next_hdr, mapped from YANG variable /load_balance/hash/ipv6/ipv6_next_hdr (empty) | f337082:c0:m15 |
def _set_ipv6_next_hdr(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=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ipv6_next_hdr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ipv6_next_hdr, mapped from YANG variable /load_balance/hash/ipv6/ipv6_next_hdr (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_ipv6_next_hdr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ipv6_next_hdr() directly. | f337082:c0:m16 |
def _get_ethernet(self): | return self.__ethernet<EOL> | Getter method for ethernet, mapped from YANG variable /load_balance/hash/ethernet (container) | f337083:c0:m3 |
def _set_ethernet(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=ethernet.ethernet, 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.__ethernet = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ethernet, mapped from YANG variable /load_balance/hash/ethernet (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_ethernet is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ethernet() directly. | f337083:c0:m4 |
def _get_ip(self): | return self.__ip<EOL> | Getter method for ip, mapped from YANG variable /load_balance/hash/ip (container) | f337083:c0:m6 |
def _set_ip(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=ip.ip, 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.__ip = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ip, mapped from YANG variable /load_balance/hash/ip (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_ip is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ip() directly. | f337083:c0:m7 |
def _get_ipv6(self): | return self.__ipv6<EOL> | Getter method for ipv6, mapped from YANG variable /load_balance/hash/ipv6 (container) | f337083:c0:m9 |
def _set_ipv6(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=ipv6.ipv6, 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.__ipv6 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ipv6, mapped from YANG variable /load_balance/hash/ipv6 (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_ipv6 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ipv6() directly. | f337083:c0:m10 |
def _get_mpls(self): | return self.__mpls<EOL> | Getter method for mpls, mapped from YANG variable /load_balance/hash/mpls (container) | f337083:c0:m12 |
def _set_mpls(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=mpls.mpls, 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.__mpls = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mpls, mapped from YANG variable /load_balance/hash/mpls (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_mpls is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mpls() directly. | f337083:c0:m13 |
def _get_hash(self): | return self.__hash<EOL> | Getter method for hash, mapped from YANG variable /load_balance/hash (container) | f337084:c0:m3 |
def _set_hash(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=hash.hash, 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.__hash = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hash, mapped from YANG variable /load_balance/hash (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_hash is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hash() directly. | f337084:c0:m4 |
def _get_po_load_balance(self): | return self.__po_load_balance<EOL> | Getter method for po_load_balance, mapped from YANG variable /load_balance/po_load_balance (container) | f337084:c0:m6 |
def _set_po_load_balance(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=po_load_balance.po_load_balance, 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>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__po_load_balance = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for po_load_balance, mapped from YANG variable /load_balance/po_load_balance (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_po_load_balance is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_po_load_balance() directly. | f337084:c0:m7 |
def _get_fan(self): | return self.__fan<EOL> | Getter method for fan, mapped from YANG variable /system_monitor/fan (container) | f337085:c0:m3 |
def _set_fan(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=fan.fan, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__fan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fan, mapped from YANG variable /system_monitor/fan (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_fan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fan() directly. | f337085:c0:m4 |
def _get_power(self): | return self.__power<EOL> | Getter method for power, mapped from YANG variable /system_monitor/power (container) | f337085:c0:m6 |
def _set_power(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=power.power, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__power = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for power, mapped from YANG variable /system_monitor/power (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_power is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_power() directly. | f337085:c0:m7 |
def _get_temp(self): | return self.__temp<EOL> | Getter method for temp, mapped from YANG variable /system_monitor/temp (container) | f337085:c0:m9 |
def _set_temp(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=temp.temp, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__temp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for temp, mapped from YANG variable /system_monitor/temp (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_temp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_temp() directly. | f337085:c0:m10 |
def _get_cid_card(self): | return self.__cid_card<EOL> | Getter method for cid_card, mapped from YANG variable /system_monitor/cid_card (container) | f337085:c0:m12 |
def _set_cid_card(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=cid_card.cid_card, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__cid_card = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cid_card, mapped from YANG variable /system_monitor/cid_card (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_cid_card is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cid_card() directly. | f337085:c0:m13 |
def _get_compact_flash(self): | return self.__compact_flash<EOL> | Getter method for compact_flash, mapped from YANG variable /system_monitor/compact_flash (container) | f337085:c0:m15 |
def _set_compact_flash(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=compact_flash.compact_flash, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__compact_flash = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for compact_flash, mapped from YANG variable /system_monitor/compact_flash (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_compact_flash is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_compact_flash() directly. | f337085:c0:m16 |
def _get_MM(self): | return self.__MM<EOL> | Getter method for MM, mapped from YANG variable /system_monitor/MM (container) | f337085:c0:m18 |
def _set_MM(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=MM.MM, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__MM = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for MM, mapped from YANG variable /system_monitor/MM (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_MM is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_MM() directly. | f337085:c0:m19 |
def _get_LineCard(self): | return self.__LineCard<EOL> | Getter method for LineCard, mapped from YANG variable /system_monitor/LineCard (container) | f337085:c0:m21 |
def _set_LineCard(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=LineCard.LineCard, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__LineCard = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for LineCard, mapped from YANG variable /system_monitor/LineCard (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_LineCard is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_LineCard() directly. | f337085:c0:m22 |
def _get_SFM(self): | return self.__SFM<EOL> | Getter method for SFM, mapped from YANG variable /system_monitor/SFM (container) | f337085:c0:m24 |
def _set_SFM(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=SFM.SFM, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__SFM = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for SFM, mapped from YANG variable /system_monitor/SFM (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_SFM is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_SFM() directly. | f337085:c0:m25 |
def _get_interface_list(self): | return self.__interface_list<EOL> | Getter method for interface_list, mapped from YANG variable /filter_info_state/interface_list (container)
YANG Description: Active Interfaces | f337086:c0:m3 |
def _set_interface_list(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=interface_list.interface_list, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__interface_list = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_list, mapped from YANG variable /filter_info_state/interface_list (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_list is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_list() directly.
YANG Description: Active Interfaces | f337086:c0:m4 |
def _get_interface_type(self): | return self.__interface_type<EOL> | Getter method for interface_type, mapped from YANG variable /filter_info_state/interface_list/interface_type (string)
YANG Description: Interface Type | f337087: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=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__interface_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_type, mapped from YANG variable /filter_info_state/interface_list/interface_type (string)
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: Interface Type | f337087:c0:m4 |
def _get_interface_name(self): | return self.__interface_name<EOL> | Getter method for interface_name, mapped from YANG variable /filter_info_state/interface_list/interface_name (string)
YANG Description: Interface Name | f337087:c0:m6 |
def _set_interface_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__interface_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_name, mapped from YANG variable /filter_info_state/interface_list/interface_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_name() directly.
YANG Description: Interface Name | f337087:c0:m7 |
def _get_seq_id(self): | return self.__seq_id<EOL> | Getter method for seq_id, mapped from YANG variable /overlay_class_map_state/policies/seq_id (uint32)
YANG Description: Sequence Id | f337088:c0:m3 |
def _set_seq_id(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__seq_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for seq_id, mapped from YANG variable /overlay_class_map_state/policies/seq_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_seq_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_seq_id() directly.
YANG Description: Sequence Id | f337088:c0:m4 |
def _get_name(self): | return self.__name<EOL> | Getter method for name, mapped from YANG variable /overlay_class_map_state/policies/name (string)
YANG Description: Policy Name | f337088:c0:m6 |
def _set_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:name>", rest_name="<STR_LIT:name>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for name, mapped from YANG variable /overlay_class_map_state/policies/name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_name() directly.
YANG Description: Policy Name | f337088:c0:m7 |
def _get_class_map_name(self): | return self.__class_map_name<EOL> | Getter method for class_map_name, mapped from YANG variable /overlay_class_map_state/class_map_name (string)
YANG Description: Overlay Policy Map name | f337089:c0:m3 |
def _set_class_map_name(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__class_map_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for class_map_name, mapped from YANG variable /overlay_class_map_state/class_map_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_class_map_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_class_map_name() directly.
YANG Description: Overlay Policy Map name | f337089:c0:m4 |
def _get_rules(self): | return self.__rules<EOL> | Getter method for rules, mapped from YANG variable /overlay_class_map_state/rules (list)
YANG Description: Overlay Class Map Rule | f337089:c0:m6 |
def _set_rules(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>",rules.rules, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rules = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rules, mapped from YANG variable /overlay_class_map_state/rules (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_rules is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rules() directly.
YANG Description: Overlay Class Map Rule | f337089:c0:m7 |
def _get_policies(self): | return self.__policies<EOL> | Getter method for policies, mapped from YANG variable /overlay_class_map_state/policies (list)
YANG Description: Overlay Class Map Policy References | f337089:c0:m9 |
def _set_policies(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>",policies.policies, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__policies = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for policies, mapped from YANG variable /overlay_class_map_state/policies (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_policies is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_policies() directly.
YANG Description: Overlay Class Map Policy References | f337089:c0:m10 |
def _get_seq_id(self): | return self.__seq_id<EOL> | Getter method for seq_id, mapped from YANG variable /overlay_class_map_state/rules/seq_id (uint32)
YANG Description: Sequence Id | f337090:c0:m3 |
def _set_seq_id(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__seq_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for seq_id, mapped from YANG variable /overlay_class_map_state/rules/seq_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_seq_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_seq_id() directly.
YANG Description: Sequence Id | f337090:c0:m4 |
def _get_source(self): | return self.__source<EOL> | Getter method for source, mapped from YANG variable /overlay_class_map_state/rules/source (string)
YANG Description: Source | f337090:c0:m6 |
def _set_source(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:source>", rest_name="<STR_LIT:source>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__source = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for source, mapped from YANG variable /overlay_class_map_state/rules/source (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_source is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_source() directly.
YANG Description: Source | f337090:c0:m7 |
def _get_destination(self): | return self.__destination<EOL> | Getter method for destination, mapped from YANG variable /overlay_class_map_state/rules/destination (string)
YANG Description: Destination | f337090:c0:m9 |
def _set_destination(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__destination = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for destination, mapped from YANG variable /overlay_class_map_state/rules/destination (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_destination is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_destination() directly.
YANG Description: Destination | f337090:c0:m10 |
def _get_endpoint(self): | return self.__endpoint<EOL> | Getter method for endpoint, mapped from YANG variable /overlay_class_map_state/rules/endpoint (string)
YANG Description: Endpoint | f337090:c0:m12 |
def _set_endpoint(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__endpoint = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for endpoint, mapped from YANG variable /overlay_class_map_state/rules/endpoint (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_endpoint is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_endpoint() directly.
YANG Description: Endpoint | f337090:c0:m13 |
def _get_encap_type(self): | return self.__encap_type<EOL> | Getter method for encap_type, mapped from YANG variable /overlay_class_map_state/rules/encap_type (string)
YANG Description: Tunnel Type | f337090:c0:m15 |
def _set_encap_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__encap_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for encap_type, mapped from YANG variable /overlay_class_map_state/rules/encap_type (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_encap_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_encap_type() directly.
YANG Description: Tunnel Type | f337090:c0:m16 |
def _get_vni(self): | return self.__vni<EOL> | Getter method for vni, mapped from YANG variable /overlay_class_map_state/rules/vni (uint32)
YANG Description: VXLAN VNI | f337090:c0:m18 |
def _set_vni(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__vni = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vni, mapped from YANG variable /overlay_class_map_state/rules/vni (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vni is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vni() directly.
YANG Description: VXLAN VNI | f337090:c0:m19 |
def _get_input(self): | return self.__input<EOL> | Getter method for input, mapped from YANG variable /brocade_mpls_rpc/mpls_reopt_lsp/input (input) | f337092: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_mpls_rpc/mpls_reopt_lsp/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. | f337092:c0:m4 |
def _get_output(self): | return self.__output<EOL> | Getter method for output, mapped from YANG variable /brocade_mpls_rpc/mpls_reopt_lsp/output (output) | f337092: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_mpls_rpc/mpls_reopt_lsp/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. | f337092:c0:m7 |
def _get_reopt_lsp_ret_msg(self): | return self.__reopt_lsp_ret_msg<EOL> | Getter method for reopt_lsp_ret_msg, mapped from YANG variable /brocade_mpls_rpc/mpls_reopt_lsp/output/reopt_lsp_ret_msg (string)
YANG Description: Reoptimize all LSPs | f337093:c0:m3 |
def _set_reopt_lsp_ret_msg(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: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.__reopt_lsp_ret_msg = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for reopt_lsp_ret_msg, mapped from YANG variable /brocade_mpls_rpc/mpls_reopt_lsp/output/reopt_lsp_ret_msg (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_reopt_lsp_ret_msg is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_reopt_lsp_ret_msg() directly.
YANG Description: Reoptimize all LSPs | f337093:c0:m4 |
def _get_clear_mpls_rsvp_statistics_neighbor_address(self): | return self.__clear_mpls_rsvp_statistics_neighbor_address<EOL> | Getter method for clear_mpls_rsvp_statistics_neighbor_address, mapped from YANG variable /brocade_mpls_rpc/clear_mpls_rsvp_statistics_neighbor/input/clear_mpls_rsvp_statistics_neighbor_address (mpls-ipv4-address)
YANG Description: RSVP neighbor IP address | f337094:c0:m3 |
def _set_clear_mpls_rsvp_statistics_neighbor_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.__clear_mpls_rsvp_statistics_neighbor_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for clear_mpls_rsvp_statistics_neighbor_address, mapped from YANG variable /brocade_mpls_rpc/clear_mpls_rsvp_statistics_neighbor/input/clear_mpls_rsvp_statistics_neighbor_address (mpls-ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_clear_mpls_rsvp_statistics_neighbor_address is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_clear_mpls_rsvp_statistics_neighbor_address() directly.
YANG Description: RSVP neighbor IP address | f337094:c0:m4 |
def _get_clear_mpls_rsvp_statistics_neighbor_all(self): | return self.__clear_mpls_rsvp_statistics_neighbor_all<EOL> | Getter method for clear_mpls_rsvp_statistics_neighbor_all, mapped from YANG variable /brocade_mpls_rpc/clear_mpls_rsvp_statistics_neighbor/input/clear_mpls_rsvp_statistics_neighbor_all (empty)
YANG Description: All RSVP neighbors | f337094:c0:m6 |
def _set_clear_mpls_rsvp_statistics_neighbor_all(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.__clear_mpls_rsvp_statistics_neighbor_all = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for clear_mpls_rsvp_statistics_neighbor_all, mapped from YANG variable /brocade_mpls_rpc/clear_mpls_rsvp_statistics_neighbor/input/clear_mpls_rsvp_statistics_neighbor_all (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_clear_mpls_rsvp_statistics_neighbor_all is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_clear_mpls_rsvp_statistics_neighbor_all() directly.
YANG Description: All RSVP neighbors | f337094:c0:m7 |
def _get_clear_mpls_lsp_option(self): | return self.__clear_mpls_lsp_option<EOL> | Getter method for clear_mpls_lsp_option, mapped from YANG variable /brocade_mpls_rpc/clear_mpls_lsp/input/clear_mpls_lsp_option (container) | f337095:c0:m3 |
def _set_clear_mpls_lsp_option(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=clear_mpls_lsp_option.clear_mpls_lsp_option, 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={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__clear_mpls_lsp_option = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for clear_mpls_lsp_option, mapped from YANG variable /brocade_mpls_rpc/clear_mpls_lsp/input/clear_mpls_lsp_option (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_clear_mpls_lsp_option is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_clear_mpls_lsp_option() directly. | f337095:c0:m4 |
def _get_mpls_clear_lsp_name_in(self): | return self.__mpls_clear_lsp_name_in<EOL> | Getter method for mpls_clear_lsp_name_in, mapped from YANG variable /brocade_mpls_rpc/clear_mpls_lsp/input/clear_mpls_lsp_option/mpls_clear_lsp_name_in (string) | f337096:c0:m3 |
def _set_mpls_clear_lsp_name_in(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, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, 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.__mpls_clear_lsp_name_in = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mpls_clear_lsp_name_in, mapped from YANG variable /brocade_mpls_rpc/clear_mpls_lsp/input/clear_mpls_lsp_option/mpls_clear_lsp_name_in (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_mpls_clear_lsp_name_in is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mpls_clear_lsp_name_in() directly. | f337096:c0:m4 |
def _get_primary(self): | return self.__primary<EOL> | Getter method for primary, mapped from YANG variable /brocade_mpls_rpc/clear_mpls_lsp/input/clear_mpls_lsp_option/primary (empty) | f337096:c0:m6 |
def _set_primary(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, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u"<STR_LIT>", u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__primary = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for primary, mapped from YANG variable /brocade_mpls_rpc/clear_mpls_lsp/input/clear_mpls_lsp_option/primary (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_primary is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_primary() directly. | f337096:c0:m7 |
def _get_secondary(self): | return self.__secondary<EOL> | Getter method for secondary, mapped from YANG variable /brocade_mpls_rpc/clear_mpls_lsp/input/clear_mpls_lsp_option/secondary (empty) | f337096:c0:m9 |
def _set_secondary(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, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u"<STR_LIT>", u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__secondary = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for secondary, mapped from YANG variable /brocade_mpls_rpc/clear_mpls_lsp/input/clear_mpls_lsp_option/secondary (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_secondary is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_secondary() directly. | f337096:c0:m10 |
def _get_input(self): | return self.__input<EOL> | Getter method for input, mapped from YANG variable /brocade_mpls_rpc/clear_mpls_lsp/input (input) | f337097: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_mpls_rpc/clear_mpls_lsp/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. | f337097:c0:m4 |
def _get_output(self): | return self.__output<EOL> | Getter method for output, mapped from YANG variable /brocade_mpls_rpc/clear_mpls_lsp/output (output) | f337097: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_mpls_rpc/clear_mpls_lsp/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. | f337097:c0:m7 |
def _get_clear_mpls_lsp_ret_msg(self): | return self.__clear_mpls_lsp_ret_msg<EOL> | Getter method for clear_mpls_lsp_ret_msg, mapped from YANG variable /brocade_mpls_rpc/clear_mpls_lsp/output/clear_mpls_lsp_out/clear_mpls_lsp_ret_msg (string)
YANG Description: clear mpls lsp return message | f337098:c0:m3 |
def _set_clear_mpls_lsp_ret_msg(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: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.__clear_mpls_lsp_ret_msg = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for clear_mpls_lsp_ret_msg, mapped from YANG variable /brocade_mpls_rpc/clear_mpls_lsp/output/clear_mpls_lsp_out/clear_mpls_lsp_ret_msg (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_clear_mpls_lsp_ret_msg is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_clear_mpls_lsp_ret_msg() directly.
YANG Description: clear mpls lsp return message | f337098:c0:m4 |
def _get_clear_mpls_lsp_out(self): | return self.__clear_mpls_lsp_out<EOL> | Getter method for clear_mpls_lsp_out, mapped from YANG variable /brocade_mpls_rpc/clear_mpls_lsp/output/clear_mpls_lsp_out (container) | f337099:c0:m3 |
def _set_clear_mpls_lsp_out(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=clear_mpls_lsp_out.clear_mpls_lsp_out, 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.__clear_mpls_lsp_out = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for clear_mpls_lsp_out, mapped from YANG variable /brocade_mpls_rpc/clear_mpls_lsp/output/clear_mpls_lsp_out (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_clear_mpls_lsp_out is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_clear_mpls_lsp_out() directly. | f337099:c0:m4 |
def _get_mpls_clear_all_ldp_sessions(self): | return self.__mpls_clear_all_ldp_sessions<EOL> | Getter method for mpls_clear_all_ldp_sessions, mapped from YANG variable /brocade_mpls_rpc/clear_mpls_ldp_neighbor/input/mpls_clear_all_ldp_sessions (empty)
YANG Description: Clear All LDP neighbors | f337100:c0:m3 |
def _set_mpls_clear_all_ldp_sessions(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.__mpls_clear_all_ldp_sessions = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mpls_clear_all_ldp_sessions, mapped from YANG variable /brocade_mpls_rpc/clear_mpls_ldp_neighbor/input/mpls_clear_all_ldp_sessions (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_mpls_clear_all_ldp_sessions is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mpls_clear_all_ldp_sessions() directly.
YANG Description: Clear All LDP neighbors | f337100:c0:m4 |
def _get_mpls_clear_one_ldp_sessions(self): | return self.__mpls_clear_one_ldp_sessions<EOL> | Getter method for mpls_clear_one_ldp_sessions, mapped from YANG variable /brocade_mpls_rpc/clear_mpls_ldp_neighbor/input/mpls_clear_one_ldp_sessions (inet:ipv4-address)
YANG Description: LDP neighbors IP to be cleared | f337100:c0:m6 |
def _set_mpls_clear_one_ldp_sessions(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.__mpls_clear_one_ldp_sessions = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mpls_clear_one_ldp_sessions, mapped from YANG variable /brocade_mpls_rpc/clear_mpls_ldp_neighbor/input/mpls_clear_one_ldp_sessions (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_mpls_clear_one_ldp_sessions is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mpls_clear_one_ldp_sessions() directly.
YANG Description: LDP neighbors IP to be cleared | f337100:c0:m7 |
def _get_output(self): | return self.__output<EOL> | Getter method for output, mapped from YANG variable /brocade_mpls_rpc/mpls_adjust_bandwidth_lsp_all/output (output) | f337101:c0:m3 |
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_mpls_rpc/mpls_adjust_bandwidth_lsp_all/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. | f337101:c0:m4 |
def _get_adjust_bandwidth_all_ret_msg(self): | return self.__adjust_bandwidth_all_ret_msg<EOL> | Getter method for adjust_bandwidth_all_ret_msg, mapped from YANG variable /brocade_mpls_rpc/mpls_adjust_bandwidth_lsp_all/output/adjust_bandwidth_all_ret_msg (string)
YANG Description: Adjust Bandwidth all return message | f337102:c0:m3 |
def _set_adjust_bandwidth_all_ret_msg(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: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.__adjust_bandwidth_all_ret_msg = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for adjust_bandwidth_all_ret_msg, mapped from YANG variable /brocade_mpls_rpc/mpls_adjust_bandwidth_lsp_all/output/adjust_bandwidth_all_ret_msg (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_adjust_bandwidth_all_ret_msg is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_adjust_bandwidth_all_ret_msg() directly.
YANG Description: Adjust Bandwidth all return message | f337102:c0:m4 |
Subsets and Splits