signature
stringlengths 8
3.44k
| body
stringlengths 0
1.41M
| docstring
stringlengths 1
122k
| id
stringlengths 5
17
|
|---|---|---|---|
def _get_vc_remote_mtu(self): | return self.__vc_remote_mtu<EOL> | Getter method for vc_remote_mtu, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_remote_mtu (uint32)
YANG Description: vc_remote_mtu | f336830:c0:m33 |
def _set_vc_remote_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=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.__vc_remote_mtu = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_remote_mtu, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_remote_mtu (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_remote_mtu is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_remote_mtu() directly.
YANG Description: vc_remote_mtu | f336830:c0:m34 |
def _get_vc_local_type(self): | return self.__vc_local_type<EOL> | Getter method for vc_local_type, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_local_type (uint32)
YANG Description: vc_local_type | f336830:c0:m36 |
def _set_vc_local_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=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.__vc_local_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_local_type, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_local_type (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_local_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_local_type() directly.
YANG Description: vc_local_type | f336830:c0:m37 |
def _get_vc_remote_type(self): | return self.__vc_remote_type<EOL> | Getter method for vc_remote_type, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_remote_type (uint32)
YANG Description: vc_remote_type | f336830:c0:m39 |
def _set_vc_remote_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=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.__vc_remote_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_remote_type, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_remote_type (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_remote_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_remote_type() directly.
YANG Description: vc_remote_type | f336830:c0:m40 |
def _get_vc_proto_tnnl(self): | return self.__vc_proto_tnnl<EOL> | Getter method for vc_proto_tnnl, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_proto_tnnl (list)
YANG Description: VC proto tnnl | f336830:c0:m42 |
def _set_vc_proto_tnnl(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>",vc_proto_tnnl.vc_proto_tnnl, 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.__vc_proto_tnnl = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_proto_tnnl, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_proto_tnnl (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_proto_tnnl is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_proto_tnnl() directly.
YANG Description: VC proto tnnl | f336830:c0:m43 |
def _get_vc_assigned_lsp(self): | return self.__vc_assigned_lsp<EOL> | Getter method for vc_assigned_lsp, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_assigned_lsp (list)
YANG Description: VC assigned lsp | f336830:c0:m45 |
def _set_vc_assigned_lsp(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>",vc_assigned_lsp.vc_assigned_lsp, 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.__vc_assigned_lsp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_assigned_lsp, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_assigned_lsp (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_assigned_lsp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_assigned_lsp() directly.
YANG Description: VC assigned lsp | f336830:c0:m46 |
def _get_enable(self): | return self.__enable<EOL> | Getter method for enable, mapped from YANG variable /sflow/enable (empty) | f336831:c0:m3 |
def _set_enable(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__enable = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for enable, mapped from YANG variable /sflow/enable (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_enable is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_enable() directly. | f336831:c0:m4 |
def _get_null0_sampling(self): | return self.__null0_sampling<EOL> | Getter method for null0_sampling, mapped from YANG variable /sflow/null0_sampling (empty) | f336831:c0:m6 |
def _set_null0_sampling(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__null0_sampling = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for null0_sampling, mapped from YANG variable /sflow/null0_sampling (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_null0_sampling is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_null0_sampling() directly. | f336831:c0:m7 |
def _get_collector_vrf(self): | return self.__collector_vrf<EOL> | Getter method for collector_vrf, mapped from YANG variable /sflow/collector_vrf (common-def:vrf-name) | f336831:c0:m9 |
def _set_collector_vrf(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>', '<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT: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.__collector_vrf = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for collector_vrf, mapped from YANG variable /sflow/collector_vrf (common-def:vrf-name)
If this variable is read-only (config: false) in the
source YANG file, then _set_collector_vrf is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_collector_vrf() directly. | f336831:c0:m10 |
def _get_source_interface(self): | return self.__source_interface<EOL> | Getter method for source_interface, mapped from YANG variable /sflow/source_interface (container) | f336831:c0:m12 |
def _set_source_interface(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=source_interface.source_interface, 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: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.__source_interface = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for source_interface, mapped from YANG variable /sflow/source_interface (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_source_interface is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_source_interface() directly. | f336831:c0:m13 |
def _get_collector(self): | return self.__collector<EOL> | Getter method for collector, mapped from YANG variable /sflow/collector (list) | f336831:c0:m15 |
def _set_collector(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>",collector.collector, 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>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT:info>': 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>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT:info>': 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.__collector = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for collector, mapped from YANG variable /sflow/collector (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_collector is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_collector() directly. | f336831:c0:m16 |
def _get_polling_interval(self): | return self.__polling_interval<EOL> | Getter method for polling_interval, mapped from YANG variable /sflow/polling_interval (uint32) | f336831:c0:m18 |
def _set_polling_interval(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_LIT:20>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__polling_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for polling_interval, mapped from YANG variable /sflow/polling_interval (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_polling_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_polling_interval() directly. | f336831:c0:m19 |
def _get_sample_rate(self): | return self.__sample_rate<EOL> | Getter method for sample_rate, mapped from YANG variable /sflow/sample_rate (uint32) | f336831:c0:m21 |
def _set_sample_rate(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_LIT>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__sample_rate = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for sample_rate, mapped from YANG variable /sflow/sample_rate (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_sample_rate is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sample_rate() directly. | f336831:c0:m22 |
def _get_policy_name(self): | return self.__policy_name<EOL> | Getter method for policy_name, mapped from YANG variable /overlay_service_policy_state/policy_name (string)
YANG Description: Overlay Policy Map name | f336832:c0:m3 |
def _set_policy_name(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__policy_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for policy_name, mapped from YANG variable /overlay_service_policy_state/policy_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_policy_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_policy_name() directly.
YANG Description: Overlay Policy Map name | f336832:c0:m4 |
def _get_details(self): | return self.__details<EOL> | Getter method for details, mapped from YANG variable /overlay_service_policy_state/details (boolean)
YANG Description: Get Overlay class map details | f336832:c0:m6 |
def _set_details(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.__details = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for details, mapped from YANG variable /overlay_service_policy_state/details (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_details is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_details() directly.
YANG Description: Get Overlay class map details | f336832:c0:m7 |
def _get_bind_interfaces(self): | return self.__bind_interfaces<EOL> | Getter method for bind_interfaces, mapped from YANG variable /overlay_service_policy_state/bind_interfaces (container)
YANG Description: Overlay Service Policy Binding Interfaces | f336832:c0:m9 |
def _set_bind_interfaces(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=bind_interfaces.bind_interfaces, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__bind_interfaces = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bind_interfaces, mapped from YANG variable /overlay_service_policy_state/bind_interfaces (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_bind_interfaces is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bind_interfaces() directly.
YANG Description: Overlay Service Policy Binding Interfaces | f336832:c0:m10 |
def _get_interface_type(self): | return self.__interface_type<EOL> | Getter method for interface_type, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/interface_type (string)
YANG Description: Interface type | f336833:c0:m3 |
def _set_interface_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__interface_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_type, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/interface_type (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_type() directly.
YANG Description: Interface type | f336833:c0:m4 |
def _get_interface_name(self): | return self.__interface_name<EOL> | Getter method for interface_name, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/interface_name (string)
YANG Description: Interface name | f336833:c0:m6 |
def _set_interface_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__interface_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_name, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/interface_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_name() directly.
YANG Description: Interface name | f336833:c0:m7 |
def _get_direction(self): | return self.__direction<EOL> | Getter method for direction, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/direction (string)
YANG Description: direction | f336833:c0:m9 |
def _set_direction(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__direction = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for direction, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/direction (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_direction is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_direction() directly.
YANG Description: direction | f336833:c0:m10 |
def _get_class_list(self): | return self.__class_list<EOL> | Getter method for class_list, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list (list)
YANG Description: Overlay Class | f336833:c0:m12 |
def _set_class_list(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",class_list.class_list, 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.__class_list = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for class_list, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_class_list is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_class_list() directly.
YANG Description: Overlay Class | f336833:c0:m13 |
def _get_seq_id(self): | return self.__seq_id<EOL> | Getter method for seq_id, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/rules_list/seq_id (uint32)
YANG Description: Sequence Id | f336834:c0:m3 |
def _set_seq_id(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__seq_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for seq_id, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/rules_list/seq_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_seq_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_seq_id() directly.
YANG Description: Sequence Id | f336834:c0:m4 |
def _get_source(self): | return self.__source<EOL> | Getter method for source, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/rules_list/source (string)
YANG Description: Source | f336834:c0:m6 |
def _set_source(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT:source>", rest_name="<STR_LIT:source>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__source = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for source, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/rules_list/source (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_source is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_source() directly.
YANG Description: Source | f336834:c0:m7 |
def _get_destination(self): | return self.__destination<EOL> | Getter method for destination, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/rules_list/destination (string)
YANG Description: Destination | f336834:c0:m9 |
def _set_destination(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__destination = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for destination, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/rules_list/destination (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_destination is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_destination() directly.
YANG Description: Destination | f336834:c0:m10 |
def _get_endpoint(self): | return self.__endpoint<EOL> | Getter method for endpoint, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/rules_list/endpoint (string)
YANG Description: Endpoint | f336834:c0:m12 |
def _set_endpoint(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__endpoint = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for endpoint, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/rules_list/endpoint (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_endpoint is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_endpoint() directly.
YANG Description: Endpoint | f336834:c0:m13 |
def _get_encap_type(self): | return self.__encap_type<EOL> | Getter method for encap_type, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/rules_list/encap_type (string)
YANG Description: Tunnel Type | f336834:c0:m15 |
def _set_encap_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__encap_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for encap_type, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/rules_list/encap_type (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_encap_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_encap_type() directly.
YANG Description: Tunnel Type | f336834:c0:m16 |
def _get_vni(self): | return self.__vni<EOL> | Getter method for vni, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/rules_list/vni (uint32)
YANG Description: VXLAN VNI | f336834:c0:m18 |
def _set_vni(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__vni = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vni, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/rules_list/vni (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vni is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vni() directly.
YANG Description: VXLAN VNI | f336834:c0:m19 |
def _get_status(self): | return self.__status<EOL> | Getter method for status, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/rules_list/status (string)
YANG Description: status | f336834:c0:m21 |
def _set_status(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:status>", rest_name="<STR_LIT:status>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__status = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for status, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/rules_list/status (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_status is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_status() directly.
YANG Description: status | f336834:c0:m22 |
def _get_seq_id(self): | return self.__seq_id<EOL> | Getter method for seq_id, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/seq_id (uint32)
YANG Description: Sequence Id | f336835:c0:m3 |
def _set_seq_id(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__seq_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for seq_id, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/seq_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_seq_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_seq_id() directly.
YANG Description: Sequence Id | f336835:c0:m4 |
def _get_overlay_class_name(self): | return self.__overlay_class_name<EOL> | Getter method for overlay_class_name, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/overlay_class_name (string)
YANG Description: Overlay Class name | f336835:c0:m6 |
def _set_overlay_class_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__overlay_class_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for overlay_class_name, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/overlay_class_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_overlay_class_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_overlay_class_name() directly.
YANG Description: Overlay Class name | f336835:c0:m7 |
def _get_overlay_class_status(self): | return self.__overlay_class_status<EOL> | Getter method for overlay_class_status, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/overlay_class_status (string)
YANG Description: Overlay Class status | f336835:c0:m9 |
def _set_overlay_class_status(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__overlay_class_status = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for overlay_class_status, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/overlay_class_status (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_overlay_class_status is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_overlay_class_status() directly.
YANG Description: Overlay Class status | f336835:c0:m10 |
def _get_mac_acl_name(self): | return self.__mac_acl_name<EOL> | Getter method for mac_acl_name, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/mac_acl_name (string)
YANG Description: Mac Access List name | f336835:c0:m12 |
def _set_mac_acl_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__mac_acl_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mac_acl_name, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/mac_acl_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_mac_acl_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mac_acl_name() directly.
YANG Description: Mac Access List name | f336835:c0:m13 |
def _get_mac_acl_status(self): | return self.__mac_acl_status<EOL> | Getter method for mac_acl_status, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/mac_acl_status (string)
YANG Description: Mac Access List status | f336835:c0:m15 |
def _set_mac_acl_status(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__mac_acl_status = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mac_acl_status, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/mac_acl_status (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_mac_acl_status is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mac_acl_status() directly.
YANG Description: Mac Access List status | f336835:c0:m16 |
def _get_ip_acl_name(self): | return self.__ip_acl_name<EOL> | Getter method for ip_acl_name, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/ip_acl_name (string)
YANG Description: IP Access List name | f336835:c0:m18 |
def _set_ip_acl_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ip_acl_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ip_acl_name, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/ip_acl_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_ip_acl_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ip_acl_name() directly.
YANG Description: IP Access List name | f336835:c0:m19 |
def _get_ip_acl_status(self): | return self.__ip_acl_status<EOL> | Getter method for ip_acl_status, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/ip_acl_status (string)
YANG Description: IP Access List status | f336835:c0:m21 |
def _set_ip_acl_status(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ip_acl_status = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ip_acl_status, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/ip_acl_status (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_ip_acl_status is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ip_acl_status() directly.
YANG Description: IP Access List status | f336835:c0:m22 |
def _get_ipv6_acl_name(self): | return self.__ipv6_acl_name<EOL> | Getter method for ipv6_acl_name, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/ipv6_acl_name (string)
YANG Description: IPv6 Access List name | f336835:c0:m24 |
def _set_ipv6_acl_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ipv6_acl_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ipv6_acl_name, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/ipv6_acl_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_ipv6_acl_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ipv6_acl_name() directly.
YANG Description: IPv6 Access List name | f336835:c0:m25 |
def _get_ipv6_acl_status(self): | return self.__ipv6_acl_status<EOL> | Getter method for ipv6_acl_status, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/ipv6_acl_status (string)
YANG Description: IPv6 Access List status | f336835:c0:m27 |
def _set_ipv6_acl_status(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ipv6_acl_status = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ipv6_acl_status, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/ipv6_acl_status (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_ipv6_acl_status is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ipv6_acl_status() directly.
YANG Description: IPv6 Access List status | f336835:c0:m28 |
def _get_service_policy_name(self): | return self.__service_policy_name<EOL> | Getter method for service_policy_name, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/service_policy_name (string)
YANG Description: Service Policy name | f336835:c0:m30 |
def _set_service_policy_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__service_policy_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for service_policy_name, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/service_policy_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_service_policy_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_service_policy_name() directly.
YANG Description: Service Policy name | f336835:c0:m31 |
def _get_service_policy_status(self): | return self.__service_policy_status<EOL> | Getter method for service_policy_status, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/service_policy_status (string)
YANG Description: Service Policy status | f336835:c0:m33 |
def _set_service_policy_status(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__service_policy_status = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for service_policy_status, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/service_policy_status (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_service_policy_status is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_service_policy_status() directly.
YANG Description: Service Policy status | f336835:c0:m34 |
def _get_rules_list(self): | return self.__rules_list<EOL> | Getter method for rules_list, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/rules_list (list)
YANG Description: Overlay Class Map Rule | f336835:c0:m36 |
def _set_rules_list(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",rules_list.rules_list, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rules_list = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rules_list, mapped from YANG variable /overlay_service_policy_state/bind_interfaces/class_list/rules_list (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_rules_list is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rules_list() directly.
YANG Description: Overlay Class Map Rule | f336835:c0:m37 |
def _get_cpu(self): | return self.__cpu<EOL> | Getter method for cpu, mapped from YANG variable /qos/qos_cpu_queue/cpu (container) | f336836:c0:m3 |
def _set_cpu(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=cpu.cpu, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, 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.__cpu = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cpu, mapped from YANG variable /qos/qos_cpu_queue/cpu (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_cpu is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cpu() directly. | f336836:c0:m4 |
def _get_queue(self): | return self.__queue<EOL> | Getter method for queue, mapped from YANG variable /qos/qos_cpu_queue/cpu/queue (list) | f336837:c0:m3 |
def _set_queue(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT:id>",queue.queue, 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:id>', 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>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', 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>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__queue = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for queue, mapped from YANG variable /qos/qos_cpu_queue/cpu/queue (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_queue is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_queue() directly. | f336837:c0:m4 |
def _get_id(self): | return self.__id<EOL> | Getter method for id, mapped from YANG variable /qos/qos_cpu_queue/cpu/queue/id (queue-id-type) | f336838:c0:m3 |
def _set_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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT:id>", rest_name="<STR_LIT:id>", 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.__id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for id, mapped from YANG variable /qos/qos_cpu_queue/cpu/queue/id (queue-id-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_id() directly. | f336838:c0:m4 |
def _get_rate_limit(self): | return self.__rate_limit<EOL> | Getter method for rate_limit, mapped from YANG variable /qos/qos_cpu_queue/cpu/queue/rate_limit (rate-limit-type) | f336838:c0:m6 |
def _set_rate_limit(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.__rate_limit = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rate_limit, mapped from YANG variable /qos/qos_cpu_queue/cpu/queue/rate_limit (rate-limit-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_rate_limit is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rate_limit() directly. | f336838:c0:m7 |
def _get_name(self): | return self.__name<EOL> | Getter method for name, mapped from YANG variable /qos/map/cos_dscp/name (map-name-type) | f336839:c0:m3 |
def _set_name(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT:name>", rest_name="<STR_LIT:name>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>'}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for name, mapped from YANG variable /qos/map/cos_dscp/name (map-name-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_name() directly. | f336839:c0:m4 |
def _get_cos_to_dscp_mappings(self): | return self.__cos_to_dscp_mappings<EOL> | Getter method for cos_to_dscp_mappings, mapped from YANG variable /qos/map/cos_dscp/cos_to_dscp_mappings (list) | f336839:c0:m6 |
def _set_cos_to_dscp_mappings(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>",cos_to_dscp_mappings.cos_to_dscp_mappings, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', 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>': u'<STR_LIT>', 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.__cos_to_dscp_mappings = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cos_to_dscp_mappings, mapped from YANG variable /qos/map/cos_dscp/cos_to_dscp_mappings (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_cos_to_dscp_mappings is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cos_to_dscp_mappings() directly. | f336839:c0:m7 |
def _get_to_dscp(self): | return self.__to_dscp<EOL> | Getter method for to_dscp, mapped from YANG variable /qos/map/cos_dscp/cos_to_dscp_mappings/to/to_dscp (dscp-id-type) | f336840:c0:m3 |
def _set_to_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=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': 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.__to_dscp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for to_dscp, mapped from YANG variable /qos/map/cos_dscp/cos_to_dscp_mappings/to/to_dscp (dscp-id-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_to_dscp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_to_dscp() directly. | f336840:c0:m4 |
def _get_from_cos(self): | return self.__from_cos<EOL> | Getter method for from_cos, mapped from YANG variable /qos/map/cos_dscp/cos_to_dscp_mappings/from_cos (cos-id-type) | f336841:c0:m3 |
def _set_from_cos(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': 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.__from_cos = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for from_cos, mapped from YANG variable /qos/map/cos_dscp/cos_to_dscp_mappings/from_cos (cos-id-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_from_cos is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_from_cos() directly. | f336841:c0:m4 |
def _get_to(self): | return self.__to<EOL> | Getter method for to, mapped from YANG variable /qos/map/cos_dscp/cos_to_dscp_mappings/to (container) | f336841:c0:m6 |
def _set_to(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=to.to, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT:to>", rest_name="<STR_LIT:to>", 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.__to = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for to, mapped from YANG variable /qos/map/cos_dscp/cos_to_dscp_mappings/to (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_to is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_to() directly. | f336841:c0:m7 |
def _get_cos_mutation(self): | return self.__cos_mutation<EOL> | Getter method for cos_mutation, mapped from YANG variable /qos/map/cos_mutation (list) | f336842:c0:m3 |
def _set_cos_mutation(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT:name>",cos_mutation.cos_mutation, 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: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>': u'<STR_LIT>', 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>': u'<STR_LIT>', 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.__cos_mutation = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cos_mutation, mapped from YANG variable /qos/map/cos_mutation (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_cos_mutation is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cos_mutation() directly. | f336842:c0:m4 |
def _get_cos_traffic_class(self): | return self.__cos_traffic_class<EOL> | Getter method for cos_traffic_class, mapped from YANG variable /qos/map/cos_traffic_class (list) | f336842:c0:m6 |
def _set_cos_traffic_class(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT:name>",cos_traffic_class.cos_traffic_class, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT: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>': u'<STR_LIT>', 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>': u'<STR_LIT>', 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.__cos_traffic_class = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cos_traffic_class, mapped from YANG variable /qos/map/cos_traffic_class (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_cos_traffic_class is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cos_traffic_class() directly. | f336842:c0:m7 |
def _get_cos_dscp(self): | return self.__cos_dscp<EOL> | Getter method for cos_dscp, mapped from YANG variable /qos/map/cos_dscp (list) | f336842:c0:m9 |
def _set_cos_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=YANGListType("<STR_LIT:name>",cos_dscp.cos_dscp, 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: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>': u'<STR_LIT>', 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>': u'<STR_LIT>', 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.__cos_dscp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cos_dscp, mapped from YANG variable /qos/map/cos_dscp (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_cos_dscp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cos_dscp() directly. | f336842:c0:m10 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.