signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_dport_number_eq_neq_udp(self): | return self.__dport_number_eq_neq_udp<EOL> | Getter method for dport_number_eq_neq_udp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dport_number_eq_neq_udp (union) | f336283:c0:m75 |
def _set_dport_number_eq_neq_udp(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>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, 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=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>': 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.__dport_number_eq_neq_udp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dport_number_eq_neq_udp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dport_number_eq_neq_udp (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_dport_number_eq_neq_udp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dport_number_eq_neq_udp() directly. | f336283:c0:m76 |
def _get_dport_number_lt_udp(self): | return self.__dport_number_lt_udp<EOL> | Getter method for dport_number_lt_udp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dport_number_lt_udp (union) | f336283:c0:m78 |
def _set_dport_number_lt_udp(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>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, 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=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>': 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.__dport_number_lt_udp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dport_number_lt_udp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dport_number_lt_udp (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_dport_number_lt_udp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dport_number_lt_udp() directly. | f336283:c0:m79 |
def _get_dport_number_gt_udp(self): | return self.__dport_number_gt_udp<EOL> | Getter method for dport_number_gt_udp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dport_number_gt_udp (union) | f336283:c0:m81 |
def _set_dport_number_gt_udp(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>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, 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=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>': 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.__dport_number_gt_udp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dport_number_gt_udp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dport_number_gt_udp (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_dport_number_gt_udp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dport_number_gt_udp() directly. | f336283:c0:m82 |
def _get_dport_number_range_lower_tcp(self): | return self.__dport_number_range_lower_tcp<EOL> | Getter method for dport_number_range_lower_tcp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dport_number_range_lower_tcp (union) | f336283:c0:m84 |
def _set_dport_number_range_lower_tcp(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>}, 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:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:20>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT:time>': {'<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=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>': 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.__dport_number_range_lower_tcp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dport_number_range_lower_tcp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dport_number_range_lower_tcp (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_dport_number_range_lower_tcp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dport_number_range_lower_tcp() directly. | f336283:c0:m85 |
def _get_dport_number_range_lower_udp(self): | return self.__dport_number_range_lower_udp<EOL> | Getter method for dport_number_range_lower_udp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dport_number_range_lower_udp (union) | f336283:c0:m87 |
def _set_dport_number_range_lower_udp(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>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, 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=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>': 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.__dport_number_range_lower_udp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dport_number_range_lower_udp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dport_number_range_lower_udp (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_dport_number_range_lower_udp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dport_number_range_lower_udp() directly. | f336283:c0:m88 |
def _get_dport_number_range_higher_tcp(self): | return self.__dport_number_range_higher_tcp<EOL> | Getter method for dport_number_range_higher_tcp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dport_number_range_higher_tcp (union) | f336283:c0:m90 |
def _set_dport_number_range_higher_tcp(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>}, 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:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:20>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT:time>': {'<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=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>': 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.__dport_number_range_higher_tcp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dport_number_range_higher_tcp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dport_number_range_higher_tcp (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_dport_number_range_higher_tcp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dport_number_range_higher_tcp() directly. | f336283:c0:m91 |
def _get_dport_number_range_higher_udp(self): | return self.__dport_number_range_higher_udp<EOL> | Getter method for dport_number_range_higher_udp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dport_number_range_higher_udp (union) | f336283:c0:m93 |
def _set_dport_number_range_higher_udp(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>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, 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=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>': 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.__dport_number_range_higher_udp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dport_number_range_higher_udp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dport_number_range_higher_udp (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_dport_number_range_higher_udp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dport_number_range_higher_udp() directly. | f336283:c0:m94 |
def _get_dscp(self): | return self.__dscp<EOL> | Getter method for dscp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dscp (union) | f336283:c0:m96 |
def _set_dscp(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:20>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:30>}, 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>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:12>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:10>}, u'<STR_LIT:default>': {'<STR_LIT:value>': <NUM_LIT:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:32>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:8>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:16>}},),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.__dscp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dscp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dscp (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_dscp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dscp() directly. | f336283:c0:m97 |
def _get_dscp_force(self): | return self.__dscp_force<EOL> | Getter method for dscp_force, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dscp_force (ip-access-list:dscprmrk-uint) | f336283:c0:m99 |
def _set_dscp_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.__dscp_force = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dscp_force, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dscp_force (ip-access-list:dscprmrk-uint)
If this variable is read-only (config: false) in the
source YANG file, then _set_dscp_force is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dscp_force() directly. | f336283:c0:m100 |
def _get_drop_precedence_force(self): | return self.__drop_precedence_force<EOL> | Getter method for drop_precedence_force, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/drop_precedence_force (ip-access-list:drop-prec-uint) | f336283:c0:m102 |
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 /ipv6_acl/ipv6/access_list/extended/seq/drop_precedence_force (ip-access-list: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. | f336283:c0:m103 |
def _get_urg(self): | return self.__urg<EOL> | Getter method for urg, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/urg (empty) | f336283:c0:m105 |
def _set_urg(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.__urg = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for urg, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/urg (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_urg is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_urg() directly. | f336283:c0:m106 |
def _get_ack(self): | return self.__ack<EOL> | Getter method for ack, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/ack (empty) | f336283:c0:m108 |
def _set_ack(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.__ack = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ack, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/ack (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_ack is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ack() directly. | f336283:c0:m109 |
def _get_push(self): | return self.__push<EOL> | Getter method for push, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/push (empty) | f336283:c0:m111 |
def _set_push(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.__push = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for push, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/push (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_push is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_push() directly. | f336283:c0:m112 |
def _get_fin(self): | return self.__fin<EOL> | Getter method for fin, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/fin (empty) | f336283:c0:m114 |
def _set_fin(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.__fin = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fin, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/fin (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_fin is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fin() directly. | f336283:c0:m115 |
def _get_rst(self): | return self.__rst<EOL> | Getter method for rst, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/rst (empty) | f336283:c0:m117 |
def _set_rst(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.__rst = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rst, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/rst (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_rst is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rst() directly. | f336283:c0:m118 |
def _get_sync(self): | return self.__sync<EOL> | Getter method for sync, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/sync (empty) | f336283:c0:m120 |
def _set_sync(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.__sync = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for sync, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/sync (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_sync is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sync() directly. | f336283:c0:m121 |
def _get_vlan(self): | return self.__vlan<EOL> | Getter method for vlan, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/vlan (interface:vlan-type)
YANG Description: Vlan | f336283:c0:m123 |
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=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 /ipv6_acl/ipv6/access_list/extended/seq/vlan (interface:vlan-type)
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 | f336283:c0:m124 |
def _get_count(self): | return self.__count<EOL> | Getter method for count, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/count (empty) | f336283:c0:m126 |
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 /ipv6_acl/ipv6/access_list/extended/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. | f336283:c0:m127 |
def _get_log(self): | return self.__log<EOL> | Getter method for log, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/log (empty) | f336283:c0:m129 |
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 /ipv6_acl/ipv6/access_list/extended/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. | f336283:c0:m130 |
def _get_mirror(self): | return self.__mirror<EOL> | Getter method for mirror, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/mirror (empty) | f336283:c0:m132 |
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 /ipv6_acl/ipv6/access_list/extended/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. | f336283:c0:m133 |
def _get_copy_sflow(self): | return self.__copy_sflow<EOL> | Getter method for copy_sflow, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/copy_sflow (empty) | f336283:c0:m135 |
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 /ipv6_acl/ipv6/access_list/extended/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. | f336283:c0:m136 |
def _get_global_ip_mtu(self): | return self.__global_ip_mtu<EOL> | Getter method for global_ip_mtu, mapped from YANG variable /global_mtu_conf/ip/global_ip_mtu (ip-mtu)
YANG Description: The size of the largest packet which can be sent/
received on the interface, specified in bytes.
For interfaces that are used for transmitting network
datagrams, this is the size of the largest network
datagram that can be sent on the interface. | f336284:c0:m3 |
def _set_global_ip_mtu(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), 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>': 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.__global_ip_mtu = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for global_ip_mtu, mapped from YANG variable /global_mtu_conf/ip/global_ip_mtu (ip-mtu)
If this variable is read-only (config: false) in the
source YANG file, then _set_global_ip_mtu is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_global_ip_mtu() directly.
YANG Description: The size of the largest packet which can be sent/
received on the interface, specified in bytes.
For interfaces that are used for transmitting network
datagrams, this is the size of the largest network
datagram that can be sent on the interface. | f336284:c0:m4 |
def _get_global_ipv6_mtu(self): | return self.__global_ipv6_mtu<EOL> | Getter method for global_ipv6_mtu, mapped from YANG variable /global_mtu_conf/ipv6/global_ipv6_mtu (ip-mtu)
YANG Description: The size of the largest packet which can be sent/
received on the interface, specified in bytes.
For interfaces that are used for transmitting network
datagrams, this is the size of the largest network
datagram that can be sent on the interface. | f336285:c0:m3 |
def _set_global_ipv6_mtu(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), 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>': 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.__global_ipv6_mtu = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for global_ipv6_mtu, mapped from YANG variable /global_mtu_conf/ipv6/global_ipv6_mtu (ip-mtu)
If this variable is read-only (config: false) in the
source YANG file, then _set_global_ipv6_mtu is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_global_ipv6_mtu() directly.
YANG Description: The size of the largest packet which can be sent/
received on the interface, specified in bytes.
For interfaces that are used for transmitting network
datagrams, this is the size of the largest network
datagram that can be sent on the interface. | f336285:c0:m4 |
def _get_global_l2_mtu(self): | return self.__global_l2_mtu<EOL> | Getter method for global_l2_mtu, mapped from YANG variable /global_mtu_conf/global_l2_mtu (mtu-type)
YANG Description: The size of the largest packet which can be sent/
received on the interface, specified in bytes.
For interfaces that are used for transmitting network
datagrams, this is the size of the largest network
datagram that can be sent on the interface. | f336286:c0:m3 |
def _set_global_l2_mtu(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), 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>': 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.__global_l2_mtu = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for global_l2_mtu, mapped from YANG variable /global_mtu_conf/global_l2_mtu (mtu-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_global_l2_mtu is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_global_l2_mtu() directly.
YANG Description: The size of the largest packet which can be sent/
received on the interface, specified in bytes.
For interfaces that are used for transmitting network
datagrams, this is the size of the largest network
datagram that can be sent on the interface. | f336286:c0:m4 |
def _get_ip(self): | return self.__ip<EOL> | Getter method for ip, mapped from YANG variable /global_mtu_conf/ip (container) | f336286:c0:m6 |
def _set_ip(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=ip.ip, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': 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.__ip = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ip, mapped from YANG variable /global_mtu_conf/ip (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_ip is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ip() directly. | f336286:c0:m7 |
def _get_ipv6(self): | return self.__ipv6<EOL> | Getter method for ipv6, mapped from YANG variable /global_mtu_conf/ipv6 (container) | f336286:c0:m9 |
def _set_ipv6(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=ipv6.ipv6, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': 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.__ipv6 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ipv6, mapped from YANG variable /global_mtu_conf/ipv6 (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_ipv6 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ipv6() directly. | f336286:c0:m10 |
def _get_management(self): | return self.__management<EOL> | Getter method for management, mapped from YANG variable /node_id/cluster/management (container) | f336287:c0:m3 |
def _set_management(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=management.management, 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.__management = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for management, mapped from YANG variable /node_id/cluster/management (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_management is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_management() directly. | f336287:c0:m4 |
def _get_principal_priority(self): | return self.__principal_priority<EOL> | Getter method for principal_priority, mapped from YANG variable /node_id/cluster/management/principal_priority (uint32) | f336288:c0:m3 |
def _set_principal_priority(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.__principal_priority = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for principal_priority, mapped from YANG variable /node_id/cluster/management/principal_priority (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_principal_priority is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_principal_priority() directly. | f336288:c0:m4 |
def _get_node_id(self): | return self.__node_id<EOL> | Getter method for node_id, mapped from YANG variable /node_id/node_id (uint32) | f336289:c0:m3 |
def _set_node_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, extensions={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.__node_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for node_id, mapped from YANG variable /node_id/node_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_node_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_node_id() directly. | f336289:c0:m4 |
def _get_cluster(self): | return self.__cluster<EOL> | Getter method for cluster, mapped from YANG variable /node_id/cluster (container) | f336289:c0:m6 |
def _set_cluster(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=cluster.cluster, 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.__cluster = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cluster, mapped from YANG variable /node_id/cluster (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_cluster is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cluster() directly. | f336289:c0:m7 |
def _get_group_id(self): | return self.__group_id<EOL> | Getter method for group_id, mapped from YANG variable /port_channel_redundancy_group/group_id (po-redundancy-group-type)
YANG Description: The port-channel-redundancy-group identifier | f336290:c0:m3 |
def _set_group_id(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, 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.__group_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for group_id, mapped from YANG variable /port_channel_redundancy_group/group_id (po-redundancy-group-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_group_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_group_id() directly.
YANG Description: The port-channel-redundancy-group identifier | f336290:c0:m4 |
def _get_port_channel(self): | return self.__port_channel<EOL> | Getter method for port_channel, mapped from YANG variable /port_channel_redundancy_group/port_channel (list)
YANG Description: The list of port-channels in the managed device. Each
entry represents a port-channel. | f336290:c0:m6 |
def _set_port_channel(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:name>",port_channel.port_channel, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=True, path_helper=self._path_helper, yang_keys='<STR_LIT:name>', 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.__port_channel = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for port_channel, mapped from YANG variable /port_channel_redundancy_group/port_channel (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_port_channel is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port_channel() directly.
YANG Description: The list of port-channels in the managed device. Each
entry represents a port-channel. | f336290:c0:m7 |
def _get_activate(self): | return self.__activate<EOL> | Getter method for activate, mapped from YANG variable /port_channel_redundancy_group/activate (empty) | f336290:c0:m9 |
def _set_activate(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>': 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.__activate = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for activate, mapped from YANG variable /port_channel_redundancy_group/activate (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_activate is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_activate() directly. | f336290:c0:m10 |
def _get_vlan_ipv6(self): | return self.__vlan_ipv6<EOL> | Getter method for vlan_ipv6, mapped from YANG variable /capabilities/vlan/vlan_ipv6 (boolean) | f336291:c0:m3 |
def _set_vlan_ipv6(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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, 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.__vlan_ipv6 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vlan_ipv6, mapped from YANG variable /capabilities/vlan/vlan_ipv6 (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_vlan_ipv6 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vlan_ipv6() directly. | f336291:c0:m4 |
def _get_clear_qos_flowcontrol_statistics(self): | return self.__clear_qos_flowcontrol_statistics<EOL> | Getter method for clear_qos_flowcontrol_statistics, mapped from YANG variable /capabilities/qos/mls/flowcontrol/clear_qos_flowcontrol_statistics (boolean) | f336292:c0:m3 |
def _set_clear_qos_flowcontrol_statistics(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, 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.__clear_qos_flowcontrol_statistics = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for clear_qos_flowcontrol_statistics, mapped from YANG variable /capabilities/qos/mls/flowcontrol/clear_qos_flowcontrol_statistics (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_clear_qos_flowcontrol_statistics is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_clear_qos_flowcontrol_statistics() directly. | f336292:c0:m4 |
def _get_qos_intf_default_cos(self): | return self.__qos_intf_default_cos<EOL> | Getter method for qos_intf_default_cos, mapped from YANG variable /capabilities/qos/mls/qos_intf_default_cos (boolean) | f336293:c0:m3 |
def _set_qos_intf_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=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, 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.__qos_intf_default_cos = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for qos_intf_default_cos, mapped from YANG variable /capabilities/qos/mls/qos_intf_default_cos (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_qos_intf_default_cos is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_qos_intf_default_cos() directly. | f336293:c0:m4 |
def _get_qos_intf_default_traffic_class(self): | return self.__qos_intf_default_traffic_class<EOL> | Getter method for qos_intf_default_traffic_class, mapped from YANG variable /capabilities/qos/mls/qos_intf_default_traffic_class (boolean) | f336293:c0:m6 |
def _set_qos_intf_default_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=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, 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.__qos_intf_default_traffic_class = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for qos_intf_default_traffic_class, mapped from YANG variable /capabilities/qos/mls/qos_intf_default_traffic_class (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_qos_intf_default_traffic_class is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_qos_intf_default_traffic_class() directly. | f336293:c0:m7 |
def _get_flowcontrol(self): | return self.__flowcontrol<EOL> | Getter method for flowcontrol, mapped from YANG variable /capabilities/qos/mls/flowcontrol (container) | f336293:c0:m9 |
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=None, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__flowcontrol = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for flowcontrol, mapped from YANG variable /capabilities/qos/mls/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. | f336293:c0:m10 |
def _get_mls(self): | return self.__mls<EOL> | Getter method for mls, mapped from YANG variable /capabilities/qos/mls (container) | f336294:c0:m3 |
def _set_mls(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=mls.mls, 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=None, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__mls = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mls, mapped from YANG variable /capabilities/qos/mls (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_mls is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mls() directly. | f336294:c0:m4 |
def _get_mqc(self): | return self.__mqc<EOL> | Getter method for mqc, mapped from YANG variable /capabilities/qos/mqc (container) | f336294:c0:m6 |
def _set_mqc(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=mqc.mqc, 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=None, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__mqc = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mqc, mapped from YANG variable /capabilities/qos/mqc (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_mqc is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mqc() directly. | f336294:c0:m7 |
def _get_hardware_vtep(self): | return self.__hardware_vtep<EOL> | Getter method for hardware_vtep, mapped from YANG variable /capabilities/overlay/vxlan/hardware_vtep (boolean) | f336295:c0:m3 |
def _set_hardware_vtep(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, 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.__hardware_vtep = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hardware_vtep, mapped from YANG variable /capabilities/overlay/vxlan/hardware_vtep (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_hardware_vtep is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hardware_vtep() directly. | f336295:c0:m4 |
def _get_vtep_ip_ve(self): | return self.__vtep_ip_ve<EOL> | Getter method for vtep_ip_ve, mapped from YANG variable /capabilities/overlay/vxlan/vtep_ip_ve (boolean) | f336295:c0:m6 |
def _set_vtep_ip_ve(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, 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.__vtep_ip_ve = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vtep_ip_ve, mapped from YANG variable /capabilities/overlay/vxlan/vtep_ip_ve (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_vtep_ip_ve is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vtep_ip_ve() directly. | f336295:c0:m7 |
def _get_vxlan_tunnel_bfd(self): | return self.__vxlan_tunnel_bfd<EOL> | Getter method for vxlan_tunnel_bfd, mapped from YANG variable /capabilities/overlay/vxlan/vxlan_tunnel_bfd (boolean) | f336295:c0:m9 |
def _set_vxlan_tunnel_bfd(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, 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.__vxlan_tunnel_bfd = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vxlan_tunnel_bfd, mapped from YANG variable /capabilities/overlay/vxlan/vxlan_tunnel_bfd (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_vxlan_tunnel_bfd is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vxlan_tunnel_bfd() directly. | f336295:c0:m10 |
def _get_vxlan_tunnel_mac_learn_protocol_bgp(self): | return self.__vxlan_tunnel_mac_learn_protocol_bgp<EOL> | Getter method for vxlan_tunnel_mac_learn_protocol_bgp, mapped from YANG variable /capabilities/overlay/vxlan/vxlan_tunnel_mac_learn_protocol_bgp (boolean) | f336295:c0:m12 |
def _set_vxlan_tunnel_mac_learn_protocol_bgp(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, 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.__vxlan_tunnel_mac_learn_protocol_bgp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vxlan_tunnel_mac_learn_protocol_bgp, mapped from YANG variable /capabilities/overlay/vxlan/vxlan_tunnel_mac_learn_protocol_bgp (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_vxlan_tunnel_mac_learn_protocol_bgp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vxlan_tunnel_mac_learn_protocol_bgp() directly. | f336295:c0:m13 |
def _get_gre(self): | return self.__gre<EOL> | Getter method for gre, mapped from YANG variable /capabilities/overlay/gre (boolean) | f336296:c0:m3 |
def _set_gre(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, 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.__gre = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for gre, mapped from YANG variable /capabilities/overlay/gre (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_gre is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_gre() directly. | f336296:c0:m4 |
def _get_vxlan(self): | return self.__vxlan<EOL> | Getter method for vxlan, mapped from YANG variable /capabilities/overlay/vxlan (container) | f336296:c0:m6 |
def _set_vxlan(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=vxlan.vxlan, 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=None, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__vxlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vxlan, mapped from YANG variable /capabilities/overlay/vxlan (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_vxlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vxlan() directly. | f336296:c0:m7 |
def _get_power(self): | return self.__power<EOL> | Getter method for power, mapped from YANG variable /capabilities/power (container) | f336297:c0:m3 |
def _set_power(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=power.power, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions=None, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__power = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for power, mapped from YANG variable /capabilities/power (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_power is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_power() directly. | f336297:c0:m4 |
def _get_temperature(self): | return self.__temperature<EOL> | Getter method for temperature, mapped from YANG variable /capabilities/temperature (container) | f336297:c0:m6 |
def _set_temperature(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=temperature.temperature, 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=None, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__temperature = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for temperature, mapped from YANG variable /capabilities/temperature (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_temperature is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_temperature() directly. | f336297:c0:m7 |
def _get_qos(self): | return self.__qos<EOL> | Getter method for qos, mapped from YANG variable /capabilities/qos (container) | f336297:c0:m9 |
def _set_qos(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=qos.qos, 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=None, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__qos = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for qos, mapped from YANG variable /capabilities/qos (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_qos is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_qos() directly. | f336297:c0:m10 |
def _get_l3(self): | return self.__l3<EOL> | Getter method for l3, mapped from YANG variable /capabilities/l3 (container) | f336297:c0:m12 |
def _set_l3(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=l3.l3, 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=None, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__l3 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for l3, mapped from YANG variable /capabilities/l3 (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_l3 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_l3() directly. | f336297:c0:m13 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.