signature
stringlengths 8
3.44k
| body
stringlengths 0
1.41M
| docstring
stringlengths 1
122k
| id
stringlengths 5
17
|
|---|---|---|---|
def _get_intf_router_isis(self):
|
return self.__intf_router_isis<EOL>
|
Getter method for intf_router_isis, mapped from YANG variable /interface/ethernet/ip/intf_router_isis (container)
|
f336613:c0:m18
|
def _set_intf_router_isis(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=intf_router_isis.intf_router_isis, 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.__intf_router_isis = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for intf_router_isis, mapped from YANG variable /interface/ethernet/ip/intf_router_isis (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_intf_router_isis is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_intf_router_isis() directly.
|
f336613:c0:m19
|
def _get_interface_eth_ospf_conf(self):
|
return self.__interface_eth_ospf_conf<EOL>
|
Getter method for interface_eth_ospf_conf, mapped from YANG variable /interface/ethernet/ip/interface_eth_ospf_conf (container)
|
f336613:c0:m21
|
def _set_interface_eth_ospf_conf(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_eth_ospf_conf.interface_eth_ospf_conf, 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.__interface_eth_ospf_conf = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for interface_eth_ospf_conf, mapped from YANG variable /interface/ethernet/ip/interface_eth_ospf_conf (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_eth_ospf_conf is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_eth_ospf_conf() directly.
|
f336613:c0:m22
|
def _get_pim_intf_phy_cont(self):
|
return self.__pim_intf_phy_cont<EOL>
|
Getter method for pim_intf_phy_cont, mapped from YANG variable /interface/ethernet/ip/pim_intf_phy_cont (container)
|
f336613:c0:m24
|
def _set_pim_intf_phy_cont(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=pim_intf_phy_cont.pim_intf_phy_cont, 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>', 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.__pim_intf_phy_cont = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for pim_intf_phy_cont, mapped from YANG variable /interface/ethernet/ip/pim_intf_phy_cont (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_pim_intf_phy_cont is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_pim_intf_phy_cont() directly.
|
f336613:c0:m25
|
def _get_trust(self):
|
return self.__trust<EOL>
|
Getter method for trust, mapped from YANG variable /interface/ethernet/ip/arp_node_config/arp/inspection/trust (empty)
|
f336614:c0:m3
|
def _set_trust(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}}, 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.__trust = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for trust, mapped from YANG variable /interface/ethernet/ip/arp_node_config/arp/inspection/trust (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_trust is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_trust() directly.
|
f336614:c0:m4
|
def _get_igmp_phy_intf_cfg(self):
|
return self.__igmp_phy_intf_cfg<EOL>
|
Getter method for igmp_phy_intf_cfg, mapped from YANG variable /interface/ethernet/ip/igmp/igmp_phy_intf_cfg (container)
|
f336615:c0:m3
|
def _set_igmp_phy_intf_cfg(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=igmp_phy_intf_cfg.igmp_phy_intf_cfg, 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>', 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.__igmp_phy_intf_cfg = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for igmp_phy_intf_cfg, mapped from YANG variable /interface/ethernet/ip/igmp/igmp_phy_intf_cfg (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_igmp_phy_intf_cfg is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_igmp_phy_intf_cfg() directly.
|
f336615:c0:m4
|
def _get_igmp(self):
|
return self.__igmp<EOL>
|
Getter method for igmp, mapped from YANG variable /interface/ethernet/ip/igmp/igmp_phy_intf_cfg/igmp (container)
|
f336616:c0:m3
|
def _set_igmp(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=igmp.igmp, 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.__igmp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for igmp, mapped from YANG variable /interface/ethernet/ip/igmp/igmp_phy_intf_cfg/igmp (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_igmp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_igmp() directly.
|
f336616:c0:m4
|
def _get_igmpl3_sg_addr(self):
|
return self.__igmpl3_sg_addr<EOL>
|
Getter method for igmpl3_sg_addr, mapped from YANG variable /interface/ethernet/ip/igmp/igmp_phy_intf_cfg/igmp/igmpl3_static_group/igmpl3_sg_addr (inet:ipv4-address)
|
f336617:c0:m3
|
def _set_igmpl3_sg_addr(self, v, load=False):
|
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, 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.__igmpl3_sg_addr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for igmpl3_sg_addr, mapped from YANG variable /interface/ethernet/ip/igmp/igmp_phy_intf_cfg/igmp/igmpl3_static_group/igmpl3_sg_addr (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_igmpl3_sg_addr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_igmpl3_sg_addr() directly.
|
f336617:c0:m4
|
def _get_igmpl3_last_member_query_interval(self):
|
return self.__igmpl3_last_member_query_interval<EOL>
|
Getter method for igmpl3_last_member_query_interval, mapped from YANG variable /interface/ethernet/ip/igmp/igmp_phy_intf_cfg/igmp/igmpl3_last_member_query_interval (igmp-snooping:lmqt-type)
|
f336618:c0:m3
|
def _set_igmpl3_last_member_query_interval(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_LIT:1000>), 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.__igmpl3_last_member_query_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for igmpl3_last_member_query_interval, mapped from YANG variable /interface/ethernet/ip/igmp/igmp_phy_intf_cfg/igmp/igmpl3_last_member_query_interval (igmp-snooping:lmqt-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_igmpl3_last_member_query_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_igmpl3_last_member_query_interval() directly.
|
f336618:c0:m4
|
def _get_igmpl3_query_interval(self):
|
return self.__igmpl3_query_interval<EOL>
|
Getter method for igmpl3_query_interval, mapped from YANG variable /interface/ethernet/ip/igmp/igmp_phy_intf_cfg/igmp/igmpl3_query_interval (igmp-snooping:qi-type)
|
f336618:c0:m6
|
def _set_igmpl3_query_interval(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_LIT>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=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.__igmpl3_query_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for igmpl3_query_interval, mapped from YANG variable /interface/ethernet/ip/igmp/igmp_phy_intf_cfg/igmp/igmpl3_query_interval (igmp-snooping:qi-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_igmpl3_query_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_igmpl3_query_interval() directly.
|
f336618:c0:m7
|
def _get_igmpl3_query_max_response_time(self):
|
return self.__igmpl3_query_max_response_time<EOL>
|
Getter method for igmpl3_query_max_response_time, mapped from YANG variable /interface/ethernet/ip/igmp/igmp_phy_intf_cfg/igmp/igmpl3_query_max_response_time (igmp-snooping:qmrt-type)
|
f336618:c0:m9
|
def _set_igmpl3_query_max_response_time(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_LIT:10>), 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.__igmpl3_query_max_response_time = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for igmpl3_query_max_response_time, mapped from YANG variable /interface/ethernet/ip/igmp/igmp_phy_intf_cfg/igmp/igmpl3_query_max_response_time (igmp-snooping:qmrt-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_igmpl3_query_max_response_time is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_igmpl3_query_max_response_time() directly.
|
f336618:c0:m10
|
def _get_igmpl3_immediate_leave(self):
|
return self.__igmpl3_immediate_leave<EOL>
|
Getter method for igmpl3_immediate_leave, mapped from YANG variable /interface/ethernet/ip/igmp/igmp_phy_intf_cfg/igmp/igmpl3_immediate_leave (empty)
|
f336618:c0:m12
|
def _set_igmpl3_immediate_leave(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.__igmpl3_immediate_leave = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for igmpl3_immediate_leave, mapped from YANG variable /interface/ethernet/ip/igmp/igmp_phy_intf_cfg/igmp/igmpl3_immediate_leave (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_igmpl3_immediate_leave is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_igmpl3_immediate_leave() directly.
|
f336618:c0:m13
|
def _get_igmpl3_version(self):
|
return self.__igmpl3_version<EOL>
|
Getter method for igmpl3_version, mapped from YANG variable /interface/ethernet/ip/igmp/igmp_phy_intf_cfg/igmp/igmpl3_version (uint32)
|
f336618:c0:m15
|
def _set_igmpl3_version(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_LIT:2>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT:version>", 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:version>'}}, 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.__igmpl3_version = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for igmpl3_version, mapped from YANG variable /interface/ethernet/ip/igmp/igmp_phy_intf_cfg/igmp/igmpl3_version (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_igmpl3_version is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_igmpl3_version() directly.
|
f336618:c0:m16
|
def _get_igmpl3_static_group(self):
|
return self.__igmpl3_static_group<EOL>
|
Getter method for igmpl3_static_group, mapped from YANG variable /interface/ethernet/ip/igmp/igmp_phy_intf_cfg/igmp/igmpl3_static_group (list)
|
f336618:c0:m18
|
def _set_igmpl3_static_group(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>",igmpl3_static_group.igmpl3_static_group, 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, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT:info>': 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, u'<STR_LIT>': 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: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.__igmpl3_static_group = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for igmpl3_static_group, mapped from YANG variable /interface/ethernet/ip/igmp/igmp_phy_intf_cfg/igmp/igmpl3_static_group (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_igmpl3_static_group is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_igmpl3_static_group() directly.
|
f336618:c0:m19
|
def _get_enable(self):
|
return self.__enable<EOL>
|
Getter method for enable, mapped from YANG variable /interface/ethernet/sflow/enable (empty)
|
f336619:c0:m3
|
def _set_enable(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>': None, 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.__enable = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for enable, mapped from YANG variable /interface/ethernet/sflow/enable (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_enable is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_enable() directly.
|
f336619:c0:m4
|
def _get_polling_interval(self):
|
return self.__polling_interval<EOL>
|
Getter method for polling_interval, mapped from YANG variable /interface/ethernet/sflow/polling_interval (uint32)
|
f336619:c0:m6
|
def _set_polling_interval(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_LIT:20>), 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}}, 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.__polling_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for polling_interval, mapped from YANG variable /interface/ethernet/sflow/polling_interval (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_polling_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_polling_interval() directly.
|
f336619:c0:m7
|
def _get_sample_rate(self):
|
return self.__sample_rate<EOL>
|
Getter method for sample_rate, mapped from YANG variable /interface/ethernet/sflow/sample_rate (uint32)
|
f336619:c0:m9
|
def _set_sample_rate(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_LIT>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=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.__sample_rate = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for sample_rate, mapped from YANG variable /interface/ethernet/sflow/sample_rate (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_sample_rate is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sample_rate() directly.
|
f336619:c0:m10
|
def _get_red_tc_value(self):
|
return self.__red_tc_value<EOL>
|
Getter method for red_tc_value, mapped from YANG variable /interface/ethernet/qos/random_detect/traffic_class/red_tc_value (traffic-class-id-type)
|
f336620:c0:m3
|
def _set_red_tc_value(self, v, load=False):
|
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__red_tc_value = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for red_tc_value, mapped from YANG variable /interface/ethernet/qos/random_detect/traffic_class/red_tc_value (traffic-class-id-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_red_tc_value is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_red_tc_value() directly.
|
f336620:c0:m4
|
def _get_red_profile_id(self):
|
return self.__red_profile_id<EOL>
|
Getter method for red_profile_id, mapped from YANG variable /interface/ethernet/qos/random_detect/traffic_class/red_profile_id (uint32)
YANG Description: Keyword for all other VDX platforms
|
f336620:c0:m6
|
def _set_red_profile_id(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, 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.__red_profile_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for red_profile_id, mapped from YANG variable /interface/ethernet/qos/random_detect/traffic_class/red_profile_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_red_profile_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_red_profile_id() directly.
YANG Description: Keyword for all other VDX platforms
|
f336620:c0:m7
|
def _get_traffic_class(self):
|
return self.__traffic_class<EOL>
|
Getter method for traffic_class, mapped from YANG variable /interface/ethernet/qos/random_detect/traffic_class (list)
|
f336621:c0:m3
|
def _set_traffic_class(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>",traffic_class.traffic_class, 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:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, 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:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': 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.__traffic_class = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for traffic_class, mapped from YANG variable /interface/ethernet/qos/random_detect/traffic_class (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_traffic_class is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_traffic_class() directly.
|
f336621:c0:m4
|
def _get_drop_monitor_enable(self):
|
return self.__drop_monitor_enable<EOL>
|
Getter method for drop_monitor_enable, mapped from YANG variable /interface/ethernet/qos/drop_monitor/drop_monitor_enable (empty)
|
f336622:c0:m3
|
def _set_drop_monitor_enable(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>', 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.__drop_monitor_enable = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for drop_monitor_enable, mapped from YANG variable /interface/ethernet/qos/drop_monitor/drop_monitor_enable (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_drop_monitor_enable is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_drop_monitor_enable() directly.
|
f336622:c0:m4
|
def _get_default_cos(self):
|
return self.__default_cos<EOL>
|
Getter method for default_cos, mapped from YANG variable /interface/ethernet/qos/default_cos (cos-id-type)
|
f336623:c0:m3
|
def _set_default_cos(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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': 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.__default_cos = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for default_cos, mapped from YANG variable /interface/ethernet/qos/default_cos (cos-id-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_default_cos is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_default_cos() directly.
|
f336623:c0:m4
|
def _get_default_tc(self):
|
return self.__default_tc<EOL>
|
Getter method for default_tc, mapped from YANG variable /interface/ethernet/qos/default_tc (traffic-class-id-type)
|
f336623:c0:m6
|
def _set_default_tc(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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': 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.__default_tc = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for default_tc, mapped from YANG variable /interface/ethernet/qos/default_tc (traffic-class-id-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_default_tc is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_default_tc() directly.
|
f336623:c0:m7
|
def _get_trust(self):
|
return self.__trust<EOL>
|
Getter method for trust, mapped from YANG variable /interface/ethernet/qos/trust (container)
|
f336623:c0:m9
|
def _set_trust(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=trust.trust, 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.__trust = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for trust, mapped from YANG variable /interface/ethernet/qos/trust (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_trust is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_trust() directly.
|
f336623:c0:m10
|
def _get_cos_mutation(self):
|
return self.__cos_mutation<EOL>
|
Getter method for cos_mutation, mapped from YANG variable /interface/ethernet/qos/cos_mutation (map-name-type)
|
f336623:c0:m12
|
def _set_cos_mutation(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=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.__cos_mutation = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for cos_mutation, mapped from YANG variable /interface/ethernet/qos/cos_mutation (map-name-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_cos_mutation is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cos_mutation() directly.
|
f336623:c0:m13
|
def _get_traffic_class_cos(self):
|
return self.__traffic_class_cos<EOL>
|
Getter method for traffic_class_cos, mapped from YANG variable /interface/ethernet/qos/traffic_class_cos (map-name-type)
|
f336623:c0:m15
|
def _set_traffic_class_cos(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=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.__traffic_class_cos = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for traffic_class_cos, mapped from YANG variable /interface/ethernet/qos/traffic_class_cos (map-name-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_traffic_class_cos is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_traffic_class_cos() directly.
|
f336623:c0:m16
|
def _get_cos_traffic_class(self):
|
return self.__cos_traffic_class<EOL>
|
Getter method for cos_traffic_class, mapped from YANG variable /interface/ethernet/qos/cos_traffic_class (map-name-type)
|
f336623:c0:m18
|
def _set_cos_traffic_class(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=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.__cos_traffic_class = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for cos_traffic_class, mapped from YANG variable /interface/ethernet/qos/cos_traffic_class (map-name-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_cos_traffic_class is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cos_traffic_class() directly.
|
f336623:c0:m19
|
def _get_dscp_mutation(self):
|
return self.__dscp_mutation<EOL>
|
Getter method for dscp_mutation, mapped from YANG variable /interface/ethernet/qos/dscp_mutation (map-name-type)
|
f336623:c0:m21
|
def _set_dscp_mutation(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=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.__dscp_mutation = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for dscp_mutation, mapped from YANG variable /interface/ethernet/qos/dscp_mutation (map-name-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_dscp_mutation is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dscp_mutation() directly.
|
f336623:c0:m22
|
def _get_dscp_traffic_class(self):
|
return self.__dscp_traffic_class<EOL>
|
Getter method for dscp_traffic_class, mapped from YANG variable /interface/ethernet/qos/dscp_traffic_class (map-name-type)
|
f336623:c0:m24
|
def _set_dscp_traffic_class(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=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.__dscp_traffic_class = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for dscp_traffic_class, mapped from YANG variable /interface/ethernet/qos/dscp_traffic_class (map-name-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_dscp_traffic_class is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dscp_traffic_class() directly.
|
f336623:c0:m25
|
def _get_dscp_cos(self):
|
return self.__dscp_cos<EOL>
|
Getter method for dscp_cos, mapped from YANG variable /interface/ethernet/qos/dscp_cos (map-name-type)
|
f336623:c0:m27
|
def _set_dscp_cos(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=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.__dscp_cos = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for dscp_cos, mapped from YANG variable /interface/ethernet/qos/dscp_cos (map-name-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_dscp_cos is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dscp_cos() directly.
|
f336623:c0:m28
|
def _get_random_detect(self):
|
return self.__random_detect<EOL>
|
Getter method for random_detect, mapped from YANG variable /interface/ethernet/qos/random_detect (container)
|
f336623:c0:m30
|
def _set_random_detect(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=random_detect.random_detect, 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>': 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.__random_detect = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for random_detect, mapped from YANG variable /interface/ethernet/qos/random_detect (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_random_detect is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_random_detect() directly.
|
f336623:c0:m31
|
def _get_drop_monitor(self):
|
return self.__drop_monitor<EOL>
|
Getter method for drop_monitor, mapped from YANG variable /interface/ethernet/qos/drop_monitor (container)
|
f336623:c0:m33
|
def _set_drop_monitor(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=drop_monitor.drop_monitor, 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.__drop_monitor = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for drop_monitor, mapped from YANG variable /interface/ethernet/qos/drop_monitor (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_drop_monitor is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_drop_monitor() directly.
|
f336623:c0:m34
|
def _get_flowcontrol(self):
|
return self.__flowcontrol<EOL>
|
Getter method for flowcontrol, mapped from YANG variable /interface/ethernet/qos/flowcontrol (container)
|
f336623:c0:m36
|
def _set_flowcontrol(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=flowcontrol.flowcontrol, 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.__flowcontrol = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for flowcontrol, mapped from YANG variable /interface/ethernet/qos/flowcontrol (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_flowcontrol is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_flowcontrol() directly.
|
f336623:c0:m37
|
def _get_rx_queue(self):
|
return self.__rx_queue<EOL>
|
Getter method for rx_queue, mapped from YANG variable /interface/ethernet/qos/rx_queue (container)
YANG Description: Configure Ingress Queue Parameters
|
f336623:c0:m39
|
def _set_rx_queue(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=rx_queue.rx_queue, 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, 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.__rx_queue = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for rx_queue, mapped from YANG variable /interface/ethernet/qos/rx_queue (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_queue is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_queue() directly.
YANG Description: Configure Ingress Queue Parameters
|
f336623:c0:m40
|
def _get_traffic_class(self):
|
return self.__traffic_class<EOL>
|
Getter method for traffic_class, mapped from YANG variable /interface/ethernet/qos/rx_queue/unicast/queue_size/traffic_class (traffic-class-id-type)
|
f336624:c0:m3
|
def _set_traffic_class(self, v, load=False):
|
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}, 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.__traffic_class = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for traffic_class, mapped from YANG variable /interface/ethernet/qos/rx_queue/unicast/queue_size/traffic_class (traffic-class-id-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_traffic_class is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_traffic_class() directly.
|
f336624:c0:m4
|
def _get_min_queue_size(self):
|
return self.__min_queue_size<EOL>
|
Getter method for min_queue_size, mapped from YANG variable /interface/ethernet/qos/rx_queue/unicast/queue_size/min_queue_size (min-queue-size-type)
|
f336624:c0:m6
|
def _set_min_queue_size(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, 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.__min_queue_size = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for min_queue_size, mapped from YANG variable /interface/ethernet/qos/rx_queue/unicast/queue_size/min_queue_size (min-queue-size-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_min_queue_size is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_min_queue_size() directly.
|
f336624:c0:m7
|
def _get_max_queue_size(self):
|
return self.__max_queue_size<EOL>
|
Getter method for max_queue_size, mapped from YANG variable /interface/ethernet/qos/rx_queue/unicast/queue_size/max_queue_size (max-queue-size-type)
|
f336624:c0:m9
|
def _set_max_queue_size(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>'}}, 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.__max_queue_size = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for max_queue_size, mapped from YANG variable /interface/ethernet/qos/rx_queue/unicast/queue_size/max_queue_size (max-queue-size-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_max_queue_size is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_max_queue_size() directly.
|
f336624:c0:m10
|
def _get_traffic_class(self):
|
return self.__traffic_class<EOL>
|
Getter method for traffic_class, mapped from YANG variable /interface/ethernet/qos/rx_queue/multicast/queue_size/traffic_class (traffic-class-id-type)
|
f336625:c0:m3
|
def _set_traffic_class(self, v, load=False):
|
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}, 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.__traffic_class = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for traffic_class, mapped from YANG variable /interface/ethernet/qos/rx_queue/multicast/queue_size/traffic_class (traffic-class-id-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_traffic_class is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_traffic_class() directly.
|
f336625:c0:m4
|
def _get_min_queue_size(self):
|
return self.__min_queue_size<EOL>
|
Getter method for min_queue_size, mapped from YANG variable /interface/ethernet/qos/rx_queue/multicast/queue_size/min_queue_size (min-queue-size-type)
|
f336625:c0:m6
|
def _set_min_queue_size(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, 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.__min_queue_size = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for min_queue_size, mapped from YANG variable /interface/ethernet/qos/rx_queue/multicast/queue_size/min_queue_size (min-queue-size-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_min_queue_size is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_min_queue_size() directly.
|
f336625:c0:m7
|
def _get_max_queue_size(self):
|
return self.__max_queue_size<EOL>
|
Getter method for max_queue_size, mapped from YANG variable /interface/ethernet/qos/rx_queue/multicast/queue_size/max_queue_size (max-queue-size-type)
|
f336625:c0:m9
|
def _set_max_queue_size(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>'}}, 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.__max_queue_size = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for max_queue_size, mapped from YANG variable /interface/ethernet/qos/rx_queue/multicast/queue_size/max_queue_size (max-queue-size-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_max_queue_size is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_max_queue_size() directly.
|
f336625:c0:m10
|
def _get_guarantee_rate(self):
|
return self.__guarantee_rate<EOL>
|
Getter method for guarantee_rate, mapped from YANG variable /interface/ethernet/qos/rx_queue/multicast/guarantee_rate (guarantee-rate-type)
|
f336626:c0:m3
|
def _set_guarantee_rate(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__guarantee_rate = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for guarantee_rate, mapped from YANG variable /interface/ethernet/qos/rx_queue/multicast/guarantee_rate (guarantee-rate-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_guarantee_rate is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_guarantee_rate() directly.
|
f336626:c0:m4
|
def _get_best_effort_rate(self):
|
return self.__best_effort_rate<EOL>
|
Getter method for best_effort_rate, mapped from YANG variable /interface/ethernet/qos/rx_queue/multicast/best_effort_rate (best-effort-rate-type)
|
f336626:c0:m6
|
def _set_best_effort_rate(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__best_effort_rate = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for best_effort_rate, mapped from YANG variable /interface/ethernet/qos/rx_queue/multicast/best_effort_rate (best-effort-rate-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_best_effort_rate is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_best_effort_rate() directly.
|
f336626:c0:m7
|
def _get_queue_size(self):
|
return self.__queue_size<EOL>
|
Getter method for queue_size, mapped from YANG variable /interface/ethernet/qos/rx_queue/multicast/queue_size (list)
|
f336626:c0:m9
|
def _set_queue_size(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>",queue_size.queue_size, 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:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}), 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:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT: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.__queue_size = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for queue_size, mapped from YANG variable /interface/ethernet/qos/rx_queue/multicast/queue_size (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_queue_size is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_queue_size() directly.
|
f336626:c0:m10
|
def _get_unicast(self):
|
return self.__unicast<EOL>
|
Getter method for unicast, mapped from YANG variable /interface/ethernet/qos/rx_queue/unicast (container)
|
f336627:c0:m3
|
def _set_unicast(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicast.unicast, 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.__unicast = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for unicast, mapped from YANG variable /interface/ethernet/qos/rx_queue/unicast (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_unicast is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_unicast() directly.
|
f336627:c0:m4
|
def _get_multicast(self):
|
return self.__multicast<EOL>
|
Getter method for multicast, mapped from YANG variable /interface/ethernet/qos/rx_queue/multicast (container)
|
f336627:c0:m6
|
def _set_multicast(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=multicast.multicast, 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>': 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.__multicast = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for multicast, mapped from YANG variable /interface/ethernet/qos/rx_queue/multicast (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_multicast is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_multicast() directly.
|
f336627:c0:m7
|
def _get_tvfdomain_all(self):
|
return self.__tvfdomain_all<EOL>
|
Getter method for tvfdomain_all, mapped from YANG variable /interface/ethernet/tvf_domain/tvfdomain_all (empty)
|
f336628:c0:m3
|
def _set_tvfdomain_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:all>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT:all>'}}, 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.__tvfdomain_all = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for tvfdomain_all, mapped from YANG variable /interface/ethernet/tvf_domain/tvfdomain_all (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_tvfdomain_all is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tvfdomain_all() directly.
|
f336628:c0:m4
|
def _get_tvfdomain_none(self):
|
return self.__tvfdomain_none<EOL>
|
Getter method for tvfdomain_none, mapped from YANG variable /interface/ethernet/tvf_domain/tvfdomain_none (empty)
|
f336628:c0:m6
|
def _set_tvfdomain_none(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:none>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, 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.__tvfdomain_none = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for tvfdomain_none, mapped from YANG variable /interface/ethernet/tvf_domain/tvfdomain_none (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_tvfdomain_none is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tvfdomain_none() directly.
|
f336628:c0:m7
|
def _get_tvfdomain_add(self):
|
return self.__tvfdomain_add<EOL>
|
Getter method for tvfdomain_add, mapped from YANG variable /interface/ethernet/tvf_domain/tvfdomain_add (tvf-domain-range)
|
f336628:c0:m9
|
def _set_tvfdomain_add(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>', '<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', 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.__tvfdomain_add = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for tvfdomain_add, mapped from YANG variable /interface/ethernet/tvf_domain/tvfdomain_add (tvf-domain-range)
If this variable is read-only (config: false) in the
source YANG file, then _set_tvfdomain_add is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tvfdomain_add() directly.
|
f336628:c0:m10
|
def _get_tvfdomain_remove(self):
|
return self.__tvfdomain_remove<EOL>
|
Getter method for tvfdomain_remove, mapped from YANG variable /interface/ethernet/tvf_domain/tvfdomain_remove (tvf-domain-range)
|
f336628:c0:m12
|
def _set_tvfdomain_remove(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>', '<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', 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.__tvfdomain_remove = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for tvfdomain_remove, mapped from YANG variable /interface/ethernet/tvf_domain/tvfdomain_remove (tvf-domain-range)
If this variable is read-only (config: false) in the
source YANG file, then _set_tvfdomain_remove is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tvfdomain_remove() directly.
|
f336628:c0:m13
|
def _get_tvfdomain_except(self):
|
return self.__tvfdomain_except<EOL>
|
Getter method for tvfdomain_except, mapped from YANG variable /interface/ethernet/tvf_domain/tvfdomain_except (tvf-domain-range)
|
f336628:c0:m15
|
def _set_tvfdomain_except(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>', '<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', 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.__tvfdomain_except = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for tvfdomain_except, mapped from YANG variable /interface/ethernet/tvf_domain/tvfdomain_except (tvf-domain-range)
If this variable is read-only (config: false) in the
source YANG file, then _set_tvfdomain_except is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tvfdomain_except() directly.
|
f336628:c0:m16
|
def _get_autoedge(self):
|
return self.__autoedge<EOL>
|
Getter method for autoedge, mapped from YANG variable /interface/ethernet/spanning_tree/autoedge (empty)
|
f336629:c0:m3
|
def _set_autoedge(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>': None, u'<STR_LIT:info>': u'<STR_LIT>', 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.__autoedge = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for autoedge, mapped from YANG variable /interface/ethernet/spanning_tree/autoedge (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_autoedge is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_autoedge() directly.
|
f336629:c0:m4
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.