signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_num_bds(self): | return self.__num_bds<EOL> | Getter method for num_bds, mapped from YANG variable /show_cluster_mem_bd_mct_state/num_bds (uint32)
YANG Description: No. of BDs configured | f336326:c0:m6 |
def _set_num_bds(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.__num_bds = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for num_bds, mapped from YANG variable /show_cluster_mem_bd_mct_state/num_bds (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_num_bds is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_num_bds() directly.
YANG Description: No. of BDs configured | f336326:c0:m7 |
def _get_bd_label_info_mct(self): | return self.__bd_label_info_mct<EOL> | Getter method for bd_label_info_mct, mapped from YANG variable /show_cluster_mem_bd_mct_state/bd_label_info_mct (list)
YANG Description: BD Label Info for Show Cluster Clients | f336326:c0:m9 |
def _set_bd_label_info_mct(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>",bd_label_info_mct.bd_label_info_mct, 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.__bd_label_info_mct = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bd_label_info_mct, mapped from YANG variable /show_cluster_mem_bd_mct_state/bd_label_info_mct (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_bd_label_info_mct is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bd_label_info_mct() directly.
YANG Description: BD Label Info for Show Cluster Clients | f336326:c0:m10 |
def _get_bd_id(self): | return self.__bd_id<EOL> | Getter method for bd_id, mapped from YANG variable /show_cluster_mem_bd_mct_state/bd_label_info_mct/bd_id (uint32)
YANG Description: BD Id | f336327:c0:m3 |
def _set_bd_id(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__bd_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bd_id, mapped from YANG variable /show_cluster_mem_bd_mct_state/bd_label_info_mct/bd_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_bd_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bd_id() directly.
YANG Description: BD Id | f336327:c0:m4 |
def _get_unicast_label_local(self): | return self.__unicast_label_local<EOL> | Getter method for unicast_label_local, mapped from YANG variable /show_cluster_mem_bd_mct_state/bd_label_info_mct/unicast_label_local (uint32)
YANG Description: Unicast Local Label | f336327:c0:m6 |
def _set_unicast_label_local(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.__unicast_label_local = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for unicast_label_local, mapped from YANG variable /show_cluster_mem_bd_mct_state/bd_label_info_mct/unicast_label_local (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_unicast_label_local is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_unicast_label_local() directly.
YANG Description: Unicast Local Label | f336327:c0:m7 |
def _get_mcast_label_local(self): | return self.__mcast_label_local<EOL> | Getter method for mcast_label_local, mapped from YANG variable /show_cluster_mem_bd_mct_state/bd_label_info_mct/mcast_label_local (uint32)
YANG Description: Mcast Local Label | f336327:c0:m9 |
def _set_mcast_label_local(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.__mcast_label_local = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mcast_label_local, mapped from YANG variable /show_cluster_mem_bd_mct_state/bd_label_info_mct/mcast_label_local (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_mcast_label_local is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mcast_label_local() directly.
YANG Description: Mcast Local Label | f336327:c0:m10 |
def _get_seq_id(self): | return self.__seq_id<EOL> | Getter method for seq_id, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/seq_id (uint64) | f336328: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=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), 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.__seq_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for seq_id, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/seq_id (uint64)
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. | f336328:c0:m4 |
def _get_action(self): | return self.__action<EOL> | Getter method for action, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/action (enumeration) | f336328:c0:m6 |
def _set_action(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), is_leaf=True, yang_name="<STR_LIT:action>", rest_name="<STR_LIT:action>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, 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.__action = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for action, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/action (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_action is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_action() directly. | f336328:c0:m7 |
def _get_source(self): | return self.__source<EOL> | Getter method for source, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/source (union) | f336328:c0:m9 |
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,RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT:host>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},),], 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, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, 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.__source = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for source, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/source (union)
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. | f336328:c0:m10 |
def _get_srchost(self): | return self.__srchost<EOL> | Getter method for srchost, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/srchost (mac-address-type) | f336328:c0:m12 |
def _set_srchost(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, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, 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.__srchost = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for srchost, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/srchost (mac-address-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_srchost is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_srchost() directly. | f336328:c0:m13 |
def _get_src_mac_addr_mask(self): | return self.__src_mac_addr_mask<EOL> | Getter method for src_mac_addr_mask, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/src_mac_addr_mask (src-dst-mac-address-mask-type) | f336328:c0:m15 |
def _set_src_mac_addr_mask(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, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, 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.__src_mac_addr_mask = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for src_mac_addr_mask, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/src_mac_addr_mask (src-dst-mac-address-mask-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_src_mac_addr_mask is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_src_mac_addr_mask() directly. | f336328:c0:m16 |
def _get_dst(self): | return self.__dst<EOL> | Getter method for dst, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/dst (union) | f336328:c0:m18 |
def _set_dst(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,RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT:host>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},),], is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, 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.__dst = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dst, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/dst (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_dst is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dst() directly. | f336328:c0:m19 |
def _get_dsthost(self): | return self.__dsthost<EOL> | Getter method for dsthost, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/dsthost (mac-address-type) | f336328:c0:m21 |
def _set_dsthost(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, 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.__dsthost = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dsthost, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/dsthost (mac-address-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_dsthost is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dsthost() directly. | f336328:c0:m22 |
def _get_dst_mac_addr_mask(self): | return self.__dst_mac_addr_mask<EOL> | Getter method for dst_mac_addr_mask, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/dst_mac_addr_mask (src-dst-mac-address-mask-type) | f336328:c0:m24 |
def _set_dst_mac_addr_mask(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, 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.__dst_mac_addr_mask = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dst_mac_addr_mask, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/dst_mac_addr_mask (src-dst-mac-address-mask-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_dst_mac_addr_mask is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dst_mac_addr_mask() directly. | f336328:c0:m25 |
def _get_vlan_tag_format(self): | return self.__vlan_tag_format<EOL> | Getter method for vlan_tag_format, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/vlan_tag_format (enumeration) | f336328:c0:m27 |
def _set_vlan_tag_format(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, 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.__vlan_tag_format = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vlan_tag_format, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/vlan_tag_format (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_vlan_tag_format is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vlan_tag_format() directly. | f336328:c0:m28 |
def _get_vlan(self): | return self.__vlan<EOL> | Getter method for vlan, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/vlan (union)
YANG Description: Vlan | f336328:c0:m30 |
def _set_vlan(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=[RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}},),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.__vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vlan, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/vlan (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_vlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vlan() directly.
YANG Description: Vlan | f336328:c0:m31 |
def _get_vlan_id_mask(self): | return self.__vlan_id_mask<EOL> | Getter method for vlan_id_mask, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/vlan_id_mask (vlan-format-vlan-id-mask) | f336328:c0:m33 |
def _set_vlan_id_mask(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:5>']}), 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>': 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.__vlan_id_mask = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vlan_id_mask, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/vlan_id_mask (vlan-format-vlan-id-mask)
If this variable is read-only (config: false) in the
source YANG file, then _set_vlan_id_mask is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vlan_id_mask() directly. | f336328:c0:m34 |
def _get_outer_vlan(self): | return self.__outer_vlan<EOL> | Getter method for outer_vlan, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/outer_vlan (union) | f336328:c0:m36 |
def _set_outer_vlan(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=[RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}),RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}},),], 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>': 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.__outer_vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for outer_vlan, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/outer_vlan (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_outer_vlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_outer_vlan() directly. | f336328:c0:m37 |
def _get_outer_vlan_id_mask(self): | return self.__outer_vlan_id_mask<EOL> | Getter method for outer_vlan_id_mask, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/outer_vlan_id_mask (vlan-format-vlan-id-mask) | f336328:c0:m39 |
def _set_outer_vlan_id_mask(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:5>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None}}, 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.__outer_vlan_id_mask = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for outer_vlan_id_mask, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/outer_vlan_id_mask (vlan-format-vlan-id-mask)
If this variable is read-only (config: false) in the
source YANG file, then _set_outer_vlan_id_mask is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_outer_vlan_id_mask() directly. | f336328:c0:m40 |
def _get_inner_vlan(self): | return self.__inner_vlan<EOL> | Getter method for inner_vlan, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/inner_vlan (union) | f336328:c0:m42 |
def _set_inner_vlan(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=[RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}),RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}},),], 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>': 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.__inner_vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for inner_vlan, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/inner_vlan (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_inner_vlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_inner_vlan() directly. | f336328:c0:m43 |
def _get_inner_vlan_id_mask(self): | return self.__inner_vlan_id_mask<EOL> | Getter method for inner_vlan_id_mask, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/inner_vlan_id_mask (vlan-format-vlan-id-mask) | f336328:c0:m45 |
def _set_inner_vlan_id_mask(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:5>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None}}, 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.__inner_vlan_id_mask = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for inner_vlan_id_mask, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/inner_vlan_id_mask (vlan-format-vlan-id-mask)
If this variable is read-only (config: false) in the
source YANG file, then _set_inner_vlan_id_mask is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_inner_vlan_id_mask() directly. | f336328:c0:m46 |
def _get_ethertype(self): | return self.__ethertype<EOL> | Getter method for ethertype, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/ethertype (union) | f336328:c0:m48 |
def _set_ethertype(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=[RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}},),RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']},int_size=<NUM_LIT:16>), 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>': 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.__ethertype = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ethertype, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/ethertype (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_ethertype is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ethertype() directly. | f336328:c0:m49 |
def _get_arp_guard(self): | return self.__arp_guard<EOL> | Getter method for arp_guard, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/arp_guard (empty) | f336328:c0:m51 |
def _set_arp_guard(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>': 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.__arp_guard = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for arp_guard, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/arp_guard (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_arp_guard is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_arp_guard() directly. | f336328:c0:m52 |
def _get_pcp(self): | return self.__pcp<EOL> | Getter method for pcp, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/pcp (pcp-value) | f336328:c0:m54 |
def _set_pcp(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.__pcp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for pcp, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/pcp (pcp-value)
If this variable is read-only (config: false) in the
source YANG file, then _set_pcp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_pcp() directly. | f336328:c0:m55 |
def _get_pcp_force(self): | return self.__pcp_force<EOL> | Getter method for pcp_force, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/pcp_force (pcp-remark) | f336328:c0:m57 |
def _set_pcp_force(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.__pcp_force = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for pcp_force, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/pcp_force (pcp-remark)
If this variable is read-only (config: false) in the
source YANG file, then _set_pcp_force is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_pcp_force() directly. | f336328:c0:m58 |
def _get_drop_precedence_force(self): | return self.__drop_precedence_force<EOL> | Getter method for drop_precedence_force, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/drop_precedence_force (drop-prec-uint) | f336328:c0:m60 |
def _set_drop_precedence_force(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.__drop_precedence_force = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for drop_precedence_force, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/drop_precedence_force (drop-prec-uint)
If this variable is read-only (config: false) in the
source YANG file, then _set_drop_precedence_force is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_drop_precedence_force() directly. | f336328:c0:m61 |
def _get_count(self): | return self.__count<EOL> | Getter method for count, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/count (empty) | f336328:c0:m63 |
def _set_count(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:count>", rest_name="<STR_LIT:count>", 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.__count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for count, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/count (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_count() directly. | f336328:c0:m64 |
def _get_log(self): | return self.__log<EOL> | Getter method for log, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/log (empty) | f336328:c0:m66 |
def _set_log(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>': 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.__log = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for log, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/log (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_log is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_log() directly. | f336328:c0:m67 |
def _get_mirror(self): | return self.__mirror<EOL> | Getter method for mirror, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/mirror (empty) | f336328:c0:m69 |
def _set_mirror(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>': 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.__mirror = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mirror, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/mirror (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_mirror is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mirror() directly. | f336328:c0:m70 |
def _get_copy_sflow(self): | return self.__copy_sflow<EOL> | Getter method for copy_sflow, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/copy_sflow (empty) | f336328:c0:m72 |
def _set_copy_sflow(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>': None, 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.__copy_sflow = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for copy_sflow, mapped from YANG variable /mac/access_list/extended/hide_mac_acl_ext/seq/copy_sflow (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_copy_sflow is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_copy_sflow() directly. | f336328:c0:m73 |
def _get_hwopt_enable(self): | return self.__hwopt_enable<EOL> | Getter method for hwopt_enable, mapped from YANG variable /hardware/profile/route/predefined/route_parameter/hwopt_enable (hwopt-subtype) | f336329:c0:m3 |
def _set_hwopt_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=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}},), 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>': 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.__hwopt_enable = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hwopt_enable, mapped from YANG variable /hardware/profile/route/predefined/route_parameter/hwopt_enable (hwopt-subtype)
If this variable is read-only (config: false) in the
source YANG file, then _set_hwopt_enable is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hwopt_enable() directly. | f336329:c0:m4 |
def _get_v4fibcomp_enable(self): | return self.__v4fibcomp_enable<EOL> | Getter method for v4fibcomp_enable, mapped from YANG variable /hardware/profile/route/predefined/route_parameter/v4fibcomp_enable (v4fibcomp-subtype) | f336329:c0:m6 |
def _set_v4fibcomp_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=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}},), 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>': 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.__v4fibcomp_enable = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for v4fibcomp_enable, mapped from YANG variable /hardware/profile/route/predefined/route_parameter/v4fibcomp_enable (v4fibcomp-subtype)
If this variable is read-only (config: false) in the
source YANG file, then _set_v4fibcomp_enable is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_v4fibcomp_enable() directly. | f336329:c0:m7 |
def _get_v6fibcomp_enable(self): | return self.__v6fibcomp_enable<EOL> | Getter method for v6fibcomp_enable, mapped from YANG variable /hardware/profile/route/predefined/route_parameter/v6fibcomp_enable (v6fibcomp-subtype) | f336329:c0:m9 |
def _set_v6fibcomp_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=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}},), 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>': 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.__v6fibcomp_enable = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for v6fibcomp_enable, mapped from YANG variable /hardware/profile/route/predefined/route_parameter/v6fibcomp_enable (v6fibcomp-subtype)
If this variable is read-only (config: false) in the
source YANG file, then _set_v6fibcomp_enable is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_v6fibcomp_enable() directly. | f336329:c0:m10 |
def _get_route_profiletype(self): | return self.__route_profiletype<EOL> | Getter method for route_profiletype, mapped from YANG variable /hardware/profile/route/predefined/route_profiletype (route-profile-subtype) | f336330:c0:m3 |
def _set_route_profiletype(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT:default>': {'<STR_LIT:value>': <NUM_LIT:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, 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.__route_profiletype = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for route_profiletype, mapped from YANG variable /hardware/profile/route/predefined/route_profiletype (route-profile-subtype)
If this variable is read-only (config: false) in the
source YANG file, then _set_route_profiletype is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_route_profiletype() directly. | f336330:c0:m4 |
def _get_route_parameter(self): | return self.__route_parameter<EOL> | Getter method for route_parameter, mapped from YANG variable /hardware/profile/route/predefined/route_parameter (container) | f336330:c0:m6 |
def _set_route_parameter(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=route_parameter.route_parameter, 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>': 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.__route_parameter = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for route_parameter, mapped from YANG variable /hardware/profile/route/predefined/route_parameter (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_route_parameter is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_route_parameter() directly. | f336330:c0:m7 |
def _get_predefined(self): | return self.__predefined<EOL> | Getter method for predefined, mapped from YANG variable /hardware/profile/route/predefined (container) | f336331:c0:m3 |
def _set_predefined(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=predefined.predefined, 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>': None, 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.__predefined = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for predefined, mapped from YANG variable /hardware/profile/route/predefined (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_predefined is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_predefined() directly. | f336331:c0:m4 |
def _get_tcam(self): | return self.__tcam<EOL> | Getter method for tcam, mapped from YANG variable /hardware/profile/tcam (container) | f336332:c0:m3 |
def _set_tcam(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=tcam.tcam, 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>'}}, 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.__tcam = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tcam, mapped from YANG variable /hardware/profile/tcam (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_tcam is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tcam() directly. | f336332:c0:m4 |
def _get_route_table(self): | return self.__route_table<EOL> | Getter method for route_table, mapped from YANG variable /hardware/profile/route_table (container) | f336332:c0:m6 |
def _set_route_table(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=route_table.route_table, 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:info>': u'<STR_LIT>', u'<STR_LIT>': 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.__route_table = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for route_table, mapped from YANG variable /hardware/profile/route_table (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_route_table is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_route_table() directly. | f336332:c0:m7 |
def _get_route(self): | return self.__route<EOL> | Getter method for route, mapped from YANG variable /hardware/profile/route (container) | f336332:c0:m9 |
def _set_route(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=route.route, 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.__route = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for route, mapped from YANG variable /hardware/profile/route (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_route is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_route() directly. | f336332:c0:m10 |
def _get_lag(self): | return self.__lag<EOL> | Getter method for lag, mapped from YANG variable /hardware/profile/lag (container) | f336332:c0:m12 |
def _set_lag(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=lag.lag, 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>'}}, 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.__lag = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lag, mapped from YANG variable /hardware/profile/lag (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_lag is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lag() directly. | f336332:c0:m13 |
def _get_counters(self): | return self.__counters<EOL> | Getter method for counters, mapped from YANG variable /hardware/profile/counters (container) | f336332:c0:m15 |
def _set_counters(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=counters.counters, 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>'}}, 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.__counters = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for counters, mapped from YANG variable /hardware/profile/counters (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_counters is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_counters() directly. | f336332:c0:m16 |
def _get_vlan_classification(self): | return self.__vlan_classification<EOL> | Getter method for vlan_classification, mapped from YANG variable /hardware/profile/vlan_classification (container) | f336332:c0:m18 |
def _set_vlan_classification(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=vlan_classification.vlan_classification, 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:info>': u'<STR_LIT>', u'<STR_LIT>': 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.__vlan_classification = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vlan_classification, mapped from YANG variable /hardware/profile/vlan_classification (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_vlan_classification is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vlan_classification() directly. | f336332:c0:m19 |
def _get_kap(self): | return self.__kap<EOL> | Getter method for kap, mapped from YANG variable /hardware/profile/kap (container) | f336332:c0:m21 |
def _set_kap(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=kap.kap, 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>': 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.__kap = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for kap, mapped from YANG variable /hardware/profile/kap (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_kap is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_kap() directly. | f336332:c0:m22 |
def _get_tcam_profiletype(self): | return self.__tcam_profiletype<EOL> | Getter method for tcam_profiletype, mapped from YANG variable /hardware/profile/tcam/predefined/tcam_profiletype (tcam-profile-subtype) | f336333:c0:m3 |
def _set_tcam_profiletype(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, u'<STR_LIT:default>': {'<STR_LIT:value>': <NUM_LIT:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, 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.__tcam_profiletype = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tcam_profiletype, mapped from YANG variable /hardware/profile/tcam/predefined/tcam_profiletype (tcam-profile-subtype)
If this variable is read-only (config: false) in the
source YANG file, then _set_tcam_profiletype is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tcam_profiletype() directly. | f336333:c0:m4 |
def _get_l2_ingress_acl(self): | return self.__l2_ingress_acl<EOL> | Getter method for l2_ingress_acl, mapped from YANG variable /hardware/profile/tcam/cam_share/l2_ingress_acl (empty) | f336334:c0:m3 |
def _set_l2_ingress_acl(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>'}}, 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.__l2_ingress_acl = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for l2_ingress_acl, mapped from YANG variable /hardware/profile/tcam/cam_share/l2_ingress_acl (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_l2_ingress_acl is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_l2_ingress_acl() directly. | f336334:c0:m4 |
def _get_l3_v4_ingress_acl(self): | return self.__l3_v4_ingress_acl<EOL> | Getter method for l3_v4_ingress_acl, mapped from YANG variable /hardware/profile/tcam/cam_share/l3_v4_ingress_acl (empty) | f336334:c0:m6 |
def _set_l3_v4_ingress_acl(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>'}}, 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.__l3_v4_ingress_acl = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for l3_v4_ingress_acl, mapped from YANG variable /hardware/profile/tcam/cam_share/l3_v4_ingress_acl (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_l3_v4_ingress_acl is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_l3_v4_ingress_acl() directly. | f336334:c0:m7 |
def _get_l3_v6_ingress_acl(self): | return self.__l3_v6_ingress_acl<EOL> | Getter method for l3_v6_ingress_acl, mapped from YANG variable /hardware/profile/tcam/cam_share/l3_v6_ingress_acl (empty) | f336334:c0:m9 |
def _set_l3_v6_ingress_acl(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>'}}, 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.__l3_v6_ingress_acl = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for l3_v6_ingress_acl, mapped from YANG variable /hardware/profile/tcam/cam_share/l3_v6_ingress_acl (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_l3_v6_ingress_acl is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_l3_v6_ingress_acl() directly. | f336334:c0:m10 |
def _get_l3_v4_pbr(self): | return self.__l3_v4_pbr<EOL> | Getter method for l3_v4_pbr, mapped from YANG variable /hardware/profile/tcam/cam_share/l3_v4_pbr (empty) | f336334:c0:m12 |
def _set_l3_v4_pbr(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>'}}, 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.__l3_v4_pbr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for l3_v4_pbr, mapped from YANG variable /hardware/profile/tcam/cam_share/l3_v4_pbr (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_l3_v4_pbr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_l3_v4_pbr() directly. | f336334:c0:m13 |
def _get_l3_v6_pbr(self): | return self.__l3_v6_pbr<EOL> | Getter method for l3_v6_pbr, mapped from YANG variable /hardware/profile/tcam/cam_share/l3_v6_pbr (empty) | f336334:c0:m15 |
def _set_l3_v6_pbr(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>'}}, 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.__l3_v6_pbr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for l3_v6_pbr, mapped from YANG variable /hardware/profile/tcam/cam_share/l3_v6_pbr (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_l3_v6_pbr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_l3_v6_pbr() directly. | f336334:c0:m16 |
def _get_openflow_v4(self): | return self.__openflow_v4<EOL> | Getter method for openflow_v4, mapped from YANG variable /hardware/profile/tcam/cam_share/openflow_v4 (empty) | f336334:c0:m18 |
def _set_openflow_v4(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>': 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.__openflow_v4 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for openflow_v4, mapped from YANG variable /hardware/profile/tcam/cam_share/openflow_v4 (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_openflow_v4 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_openflow_v4() directly. | f336334:c0:m19 |
def _get_openflow_v6(self): | return self.__openflow_v6<EOL> | Getter method for openflow_v6, mapped from YANG variable /hardware/profile/tcam/cam_share/openflow_v6 (empty) | f336334:c0:m21 |
def _set_openflow_v6(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>': 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.__openflow_v6 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for openflow_v6, mapped from YANG variable /hardware/profile/tcam/cam_share/openflow_v6 (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_openflow_v6 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_openflow_v6() directly. | f336334:c0:m22 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.