signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_rapid_retry(self): | return self.__rapid_retry<EOL> | Getter method for rapid_retry, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/rapid_retry (enable-disable) | f335970:c0:m33 |
def _set_rapid_retry(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': 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.__rapid_retry = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rapid_retry, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/rapid_retry (enable-disable)
If this variable is read-only (config: false) in the
source YANG file, then _set_rapid_retry is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rapid_retry() directly. | f335970:c0:m34 |
def _get_rsvp_periodic_flooding_time(self): | return self.__rsvp_periodic_flooding_time<EOL> | Getter method for rsvp_periodic_flooding_time, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/rsvp_periodic_flooding_time (uint32) | f335970:c0:m36 |
def _set_rsvp_periodic_flooding_time(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT:0>', 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>': 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.__rsvp_periodic_flooding_time = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rsvp_periodic_flooding_time, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/rsvp_periodic_flooding_time (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_rsvp_periodic_flooding_time is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rsvp_periodic_flooding_time() directly. | f335970:c0:m37 |
def _get_rsvp_flooding_threshold(self): | return self.__rsvp_flooding_threshold<EOL> | Getter method for rsvp_flooding_threshold, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/rsvp_flooding_threshold (container) | f335970:c0:m39 |
def _set_rsvp_flooding_threshold(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=rsvp_flooding_threshold.rsvp_flooding_threshold, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rsvp_flooding_threshold = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rsvp_flooding_threshold, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/rsvp_flooding_threshold (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_rsvp_flooding_threshold is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rsvp_flooding_threshold() directly. | f335970:c0:m40 |
def _get_soft_preemption(self): | return self.__soft_preemption<EOL> | Getter method for soft_preemption, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/soft_preemption (container) | f335970:c0:m42 |
def _set_soft_preemption(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=soft_preemption.soft_preemption, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__soft_preemption = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for soft_preemption, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/soft_preemption (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_soft_preemption is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_soft_preemption() directly. | f335970:c0:m43 |
def _get_global_auto_bandwidth(self): | return self.__global_auto_bandwidth<EOL> | Getter method for global_auto_bandwidth, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/global_auto_bandwidth (container) | f335970:c0:m45 |
def _set_global_auto_bandwidth(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=global_auto_bandwidth.global_auto_bandwidth, is_container='<STR_LIT>', presence=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.__global_auto_bandwidth = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for global_auto_bandwidth, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/global_auto_bandwidth (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_global_auto_bandwidth is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_global_auto_bandwidth() directly. | f335970:c0:m46 |
def _get_implicit_commit(self): | return self.__implicit_commit<EOL> | Getter method for implicit_commit, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/implicit_commit (container) | f335970:c0:m48 |
def _set_implicit_commit(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=implicit_commit.implicit_commit, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__implicit_commit = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for implicit_commit, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/implicit_commit (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_implicit_commit is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_implicit_commit() directly. | f335970:c0:m49 |
def _get_traffic_engineering(self): | return self.__traffic_engineering<EOL> | Getter method for traffic_engineering, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/traffic_engineering (container) | f335970:c0:m51 |
def _set_traffic_engineering(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=traffic_engineering.traffic_engineering, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__traffic_engineering = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for traffic_engineering, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/traffic_engineering (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_traffic_engineering is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_traffic_engineering() directly. | f335970:c0:m52 |
def _get_qos_ttl_mode(self): | return self.__qos_ttl_mode<EOL> | Getter method for qos_ttl_mode, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/qos_ttl_mode (enumeration) | f335970:c0:m54 |
def _set_qos_ttl_mode(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT: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.__qos_ttl_mode = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for qos_ttl_mode, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/qos_ttl_mode (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_qos_ttl_mode is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_qos_ttl_mode() directly. | f335970:c0:m55 |
def _get_ingress_tunnel_accounting(self): | return self.__ingress_tunnel_accounting<EOL> | Getter method for ingress_tunnel_accounting, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/ingress_tunnel_accounting (empty) | f335970:c0:m57 |
def _set_ingress_tunnel_accounting(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}}, 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.__ingress_tunnel_accounting = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ingress_tunnel_accounting, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/ingress_tunnel_accounting (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_ingress_tunnel_accounting is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ingress_tunnel_accounting() directly. | f335970:c0:m58 |
def _get_transit_session_accounting(self): | return self.__transit_session_accounting<EOL> | Getter method for transit_session_accounting, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/transit_session_accounting (empty) | f335970:c0:m60 |
def _set_transit_session_accounting(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}}, 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.__transit_session_accounting = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for transit_session_accounting, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/transit_session_accounting (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_transit_session_accounting is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_transit_session_accounting() directly. | f335970:c0:m61 |
def _get_switchover_activation_delay(self): | return self.__switchover_activation_delay<EOL> | Getter method for switchover_activation_delay, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/switchover_activation_delay (uint32) | f335970:c0:m63 |
def _set_switchover_activation_delay(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:0>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT: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.__switchover_activation_delay = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for switchover_activation_delay, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/switchover_activation_delay (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_switchover_activation_delay is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_switchover_activation_delay() directly. | f335970:c0:m64 |
def _get_switchover_hold_tear_delay(self): | return self.__switchover_hold_tear_delay<EOL> | Getter method for switchover_hold_tear_delay, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/switchover_hold_tear_delay (uint32) | f335970:c0:m66 |
def _set_switchover_hold_tear_delay(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:0>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT: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.__switchover_hold_tear_delay = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for switchover_hold_tear_delay, mapped from YANG variable /mpls_config/router/mpls/mpls_cmds_holder/policy/switchover_hold_tear_delay (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_switchover_hold_tear_delay is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_switchover_hold_tear_delay() directly. | f335970:c0:m67 |
def _get_name(self): | return self.__name<EOL> | Getter method for name, mapped from YANG variable /policy_map/name (map-name-type) | f335971: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 /policy_map/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. | f335971:c0:m4 |
def _get_class_(self): | return self.__class_<EOL> | Getter method for class_, mapped from YANG variable /policy_map/class (list) | f335971:c0:m6 |
def _set_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>",class_.class_, yang_name="<STR_LIT:class>", rest_name="<STR_LIT:class>", 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>': u'<STR_LIT>'}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT:class>", rest_name="<STR_LIT:class>", 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>': 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.__class_ = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for class_, mapped from YANG variable /policy_map/class (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_class_ is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_class_() directly. | f335971:c0:m7 |
def _get_type(self): | return self.__type<EOL> | Getter method for type, mapped from YANG variable /threshold_monitor_hidden/threshold_monitor/sfp/policy/area/type (enumeration) | f335972:c0:m3 |
def _set_type(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_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:16>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, 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:9>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:20>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:15>}, 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:10>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<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:12>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:11>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}},), is_leaf=True, yang_name="<STR_LIT:type>", rest_name="<STR_LIT:type>", 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}}, 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.__type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for type, mapped from YANG variable /threshold_monitor_hidden/threshold_monitor/sfp/policy/area/type (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_type() directly. | f335972:c0:m4 |
def _get_area_value(self): | return self.__area_value<EOL> | Getter method for area_value, mapped from YANG variable /threshold_monitor_hidden/threshold_monitor/sfp/policy/area/area_value (enumeration) | f335972:c0:m6 |
def _set_area_value(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': 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.__area_value = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for area_value, mapped from YANG variable /threshold_monitor_hidden/threshold_monitor/sfp/policy/area/area_value (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_area_value is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_area_value() directly. | f335972:c0:m7 |
def _get_threshold(self): | return self.__threshold<EOL> | Getter method for threshold, mapped from YANG variable /threshold_monitor_hidden/threshold_monitor/sfp/policy/area/threshold (container) | f335972:c0:m9 |
def _set_threshold(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=threshold.threshold, 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}}, 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.__threshold = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for threshold, mapped from YANG variable /threshold_monitor_hidden/threshold_monitor/sfp/policy/area/threshold (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_threshold is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_threshold() directly. | f335972:c0:m10 |
def _get_alert(self): | return self.__alert<EOL> | Getter method for alert, mapped from YANG variable /threshold_monitor_hidden/threshold_monitor/sfp/policy/area/alert (container) | f335972:c0:m12 |
def _set_alert(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=alert.alert, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__alert = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for alert, mapped from YANG variable /threshold_monitor_hidden/threshold_monitor/sfp/policy/area/alert (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_alert is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_alert() directly. | f335972:c0:m13 |
def _get_slot(self): | return self.__slot<EOL> | Getter method for slot, mapped from YANG variable /hw_state/hw_route_info/slot (uint16)
YANG Description: slot id | f335973:c0:m3 |
def _set_slot(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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']},int_size=<NUM_LIT:16>), 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.__slot = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for slot, mapped from YANG variable /hw_state/hw_route_info/slot (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_slot is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_slot() directly.
YANG Description: slot id | f335973:c0:m4 |
def _get_tower(self): | return self.__tower<EOL> | Getter method for tower, mapped from YANG variable /hw_state/hw_route_info/tower (uint16)
YANG Description: tower id | f335973:c0:m6 |
def _set_tower(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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']},int_size=<NUM_LIT:16>), 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.__tower = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tower, mapped from YANG variable /hw_state/hw_route_info/tower (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_tower is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tower() directly.
YANG Description: tower id | f335973:c0:m7 |
def _get_lpm_percent(self): | return self.__lpm_percent<EOL> | Getter method for lpm_percent, mapped from YANG variable /hw_state/hw_route_info/lpm_percent (decimal64)
YANG Description: lpm percent | f335973:c0:m9 |
def _set_lpm_percent(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, 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.__lpm_percent = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lpm_percent, mapped from YANG variable /hw_state/hw_route_info/lpm_percent (decimal64)
If this variable is read-only (config: false) in the
source YANG file, then _set_lpm_percent is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lpm_percent() directly.
YANG Description: lpm percent | f335973:c0:m10 |
def _get_lem_percent(self): | return self.__lem_percent<EOL> | Getter method for lem_percent, mapped from YANG variable /hw_state/hw_route_info/lem_percent (decimal64)
YANG Description: lem percent | f335973:c0:m12 |
def _set_lem_percent(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedPrecisionDecimalType(precision=<NUM_LIT:2>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, 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.__lem_percent = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lem_percent, mapped from YANG variable /hw_state/hw_route_info/lem_percent (decimal64)
If this variable is read-only (config: false) in the
source YANG file, then _set_lem_percent is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lem_percent() directly.
YANG Description: lem percent | f335973:c0:m13 |
def _get_lpm_ipv4(self): | return self.__lpm_ipv4<EOL> | Getter method for lpm_ipv4, mapped from YANG variable /hw_state/hw_route_info/lpm_ipv4 (uint32)
YANG Description: lpm ipv4 | f335973:c0:m15 |
def _set_lpm_ipv4(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)), is_leaf=False, 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.__lpm_ipv4 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lpm_ipv4, mapped from YANG variable /hw_state/hw_route_info/lpm_ipv4 (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_lpm_ipv4 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lpm_ipv4() directly.
YANG Description: lpm ipv4 | f335973:c0:m16 |
def _get_lpm_ipv6(self): | return self.__lpm_ipv6<EOL> | Getter method for lpm_ipv6, mapped from YANG variable /hw_state/hw_route_info/lpm_ipv6 (uint32)
YANG Description: lpm ipv6 | f335973:c0:m18 |
def _set_lpm_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=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)), is_leaf=False, 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.__lpm_ipv6 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lpm_ipv6, mapped from YANG variable /hw_state/hw_route_info/lpm_ipv6 (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_lpm_ipv6 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lpm_ipv6() directly.
YANG Description: lpm ipv6 | f335973:c0:m19 |
def _get_lpm_other(self): | return self.__lpm_other<EOL> | Getter method for lpm_other, mapped from YANG variable /hw_state/hw_route_info/lpm_other (uint32)
YANG Description: lpm other | f335973:c0:m21 |
def _set_lpm_other(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)), is_leaf=False, 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.__lpm_other = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lpm_other, mapped from YANG variable /hw_state/hw_route_info/lpm_other (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_lpm_other is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lpm_other() directly.
YANG Description: lpm other | f335973:c0:m22 |
def _get_lem_ipv4(self): | return self.__lem_ipv4<EOL> | Getter method for lem_ipv4, mapped from YANG variable /hw_state/hw_route_info/lem_ipv4 (uint32)
YANG Description: lem ipv4 | f335973:c0:m24 |
def _set_lem_ipv4(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)), is_leaf=False, 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.__lem_ipv4 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lem_ipv4, mapped from YANG variable /hw_state/hw_route_info/lem_ipv4 (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_lem_ipv4 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lem_ipv4() directly.
YANG Description: lem ipv4 | f335973:c0:m25 |
def _get_lem_ipv6(self): | return self.__lem_ipv6<EOL> | Getter method for lem_ipv6, mapped from YANG variable /hw_state/hw_route_info/lem_ipv6 (uint32)
YANG Description: lem ipv6 | f335973:c0:m27 |
def _set_lem_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=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)), is_leaf=False, 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.__lem_ipv6 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lem_ipv6, mapped from YANG variable /hw_state/hw_route_info/lem_ipv6 (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_lem_ipv6 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lem_ipv6() directly.
YANG Description: lem ipv6 | f335973:c0:m28 |
def _get_lem_other(self): | return self.__lem_other<EOL> | Getter method for lem_other, mapped from YANG variable /hw_state/hw_route_info/lem_other (uint32)
YANG Description: lem other | f335973:c0:m30 |
def _set_lem_other(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)), is_leaf=False, 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.__lem_other = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lem_other, mapped from YANG variable /hw_state/hw_route_info/lem_other (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_lem_other is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lem_other() directly.
YANG Description: lem other | f335973:c0:m31 |
def _get_lpm_total(self): | return self.__lpm_total<EOL> | Getter method for lpm_total, mapped from YANG variable /hw_state/hw_route_info/lpm_total (uint32)
YANG Description: lpm total | f335973:c0:m33 |
def _set_lpm_total(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)), is_leaf=False, 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.__lpm_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lpm_total, mapped from YANG variable /hw_state/hw_route_info/lpm_total (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_lpm_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lpm_total() directly.
YANG Description: lpm total | f335973:c0:m34 |
def _get_lem_total(self): | return self.__lem_total<EOL> | Getter method for lem_total, mapped from YANG variable /hw_state/hw_route_info/lem_total (uint32)
YANG Description: lem total | f335973:c0:m36 |
def _set_lem_total(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)), is_leaf=False, 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.__lem_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lem_total, mapped from YANG variable /hw_state/hw_route_info/lem_total (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_lem_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lem_total() directly.
YANG Description: lem total | f335973:c0:m37 |
def _get_hw_route_info(self): | return self.__hw_route_info<EOL> | Getter method for hw_route_info, mapped from YANG variable /hw_state/hw_route_info (list)
YANG Description: HW Route Info | f335974:c0:m3 |
def _set_hw_route_info(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>",hw_route_info.hw_route_info, 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.__hw_route_info = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hw_route_info, mapped from YANG variable /hw_state/hw_route_info (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_hw_route_info is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hw_route_info() directly.
YANG Description: HW Route Info | f335974:c0:m4 |
def _get_grp_ip_addr(self): | return self.__grp_ip_addr<EOL> | Getter method for grp_ip_addr, mapped from YANG variable /igmp_snooping_bridge_domains_state/igmp_snooping_bridge_domains/vlan_groups/grp_ip_addr (inet:ipv4-address)
YANG Description: Igmp group address | f335975:c0:m3 |
def _set_grp_ip_addr(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, 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.__grp_ip_addr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for grp_ip_addr, mapped from YANG variable /igmp_snooping_bridge_domains_state/igmp_snooping_bridge_domains/vlan_groups/grp_ip_addr (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_grp_ip_addr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_grp_ip_addr() directly.
YANG Description: Igmp group address | f335975:c0:m4 |
def _get_member_ports(self): | return self.__member_ports<EOL> | Getter method for member_ports, mapped from YANG variable /igmp_snooping_bridge_domains_state/igmp_snooping_bridge_domains/vlan_groups/member_ports (string)
YANG Description: group membership ports | f335975:c0:m6 |
def _set_member_ports(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.__member_ports = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for member_ports, mapped from YANG variable /igmp_snooping_bridge_domains_state/igmp_snooping_bridge_domains/vlan_groups/member_ports (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_member_ports is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_member_ports() directly.
YANG Description: group membership ports | f335975:c0:m7 |
def _get_bd_id(self): | return self.__bd_id<EOL> | Getter method for bd_id, mapped from YANG variable /igmp_snooping_bridge_domains_state/igmp_snooping_bridge_domains/bd_id (uint32)
YANG Description: bridge-domain id | f335976:c0:m3 |
def _set_bd_id(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__bd_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bd_id, mapped from YANG variable /igmp_snooping_bridge_domains_state/igmp_snooping_bridge_domains/bd_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_bd_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bd_id() directly.
YANG Description: bridge-domain id | f335976:c0:m4 |
def _get_multicast_router_ports(self): | return self.__multicast_router_ports<EOL> | Getter method for multicast_router_ports, mapped from YANG variable /igmp_snooping_bridge_domains_state/igmp_snooping_bridge_domains/multicast_router_ports (string)
YANG Description: Multicast Router ports | f335976:c0:m6 |
def _set_multicast_router_ports(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.__multicast_router_ports = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for multicast_router_ports, mapped from YANG variable /igmp_snooping_bridge_domains_state/igmp_snooping_bridge_domains/multicast_router_ports (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_multicast_router_ports is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_multicast_router_ports() directly.
YANG Description: Multicast Router ports | f335976:c0:m7 |
def _get_is_querier(self): | return self.__is_querier<EOL> | Getter method for is_querier, mapped from YANG variable /igmp_snooping_bridge_domains_state/igmp_snooping_bridge_domains/is_querier (uint8)
YANG Description: Is interface Querier enabled | f335976:c0:m9 |
def _set_is_querier(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=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), 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.__is_querier = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for is_querier, mapped from YANG variable /igmp_snooping_bridge_domains_state/igmp_snooping_bridge_domains/is_querier (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_is_querier is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_is_querier() directly.
YANG Description: Is interface Querier enabled | f335976:c0:m10 |
def _get_igmp_operation_mode(self): | return self.__igmp_operation_mode<EOL> | Getter method for igmp_operation_mode, mapped from YANG variable /igmp_snooping_bridge_domains_state/igmp_snooping_bridge_domains/igmp_operation_mode (uint32)
YANG Description: IGMP Operation mode | f335976:c0:m12 |
def _set_igmp_operation_mode(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.__igmp_operation_mode = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for igmp_operation_mode, mapped from YANG variable /igmp_snooping_bridge_domains_state/igmp_snooping_bridge_domains/igmp_operation_mode (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_igmp_operation_mode is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_igmp_operation_mode() directly.
YANG Description: IGMP Operation mode | f335976:c0:m13 |
def _get_fast_leave(self): | return self.__fast_leave<EOL> | Getter method for fast_leave, mapped from YANG variable /igmp_snooping_bridge_domains_state/igmp_snooping_bridge_domains/fast_leave (uint8)
YANG Description: Is Fast Leave enabled | f335976:c0:m15 |
def _set_fast_leave(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), 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.__fast_leave = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fast_leave, mapped from YANG variable /igmp_snooping_bridge_domains_state/igmp_snooping_bridge_domains/fast_leave (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_fast_leave is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fast_leave() directly.
YANG Description: Is Fast Leave enabled | f335976:c0:m16 |
def _get_qmrt(self): | return self.__qmrt<EOL> | Getter method for qmrt, mapped from YANG variable /igmp_snooping_bridge_domains_state/igmp_snooping_bridge_domains/qmrt (uint32)
YANG Description: Igmp query response time | f335976:c0:m18 |
def _set_qmrt(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.__qmrt = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for qmrt, mapped from YANG variable /igmp_snooping_bridge_domains_state/igmp_snooping_bridge_domains/qmrt (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_qmrt is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_qmrt() directly.
YANG Description: Igmp query response time | f335976:c0:m19 |
def _get_lmqi(self): | return self.__lmqi<EOL> | Getter method for lmqi, mapped from YANG variable /igmp_snooping_bridge_domains_state/igmp_snooping_bridge_domains/lmqi (uint32)
YANG Description: Last Member Query Interval | f335976:c0:m21 |
def _set_lmqi(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.__lmqi = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lmqi, mapped from YANG variable /igmp_snooping_bridge_domains_state/igmp_snooping_bridge_domains/lmqi (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_lmqi is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lmqi() directly.
YANG Description: Last Member Query Interval | f335976:c0:m22 |
def _get_qi(self): | return self.__qi<EOL> | Getter method for qi, mapped from YANG variable /igmp_snooping_bridge_domains_state/igmp_snooping_bridge_domains/qi (uint32)
YANG Description: Query Interval | f335976:c0:m24 |
def _set_qi(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.__qi = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for qi, mapped from YANG variable /igmp_snooping_bridge_domains_state/igmp_snooping_bridge_domains/qi (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_qi is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_qi() directly.
YANG Description: Query Interval | f335976:c0:m25 |
def _get_version(self): | return self.__version<EOL> | Getter method for version, mapped from YANG variable /igmp_snooping_bridge_domains_state/igmp_snooping_bridge_domains/version (uint8)
YANG Description: Igmp Version | f335976:c0:m27 |
def _set_version(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), is_leaf=True, yang_name="<STR_LIT:version>", rest_name="<STR_LIT:version>", 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.__version = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for version, mapped from YANG variable /igmp_snooping_bridge_domains_state/igmp_snooping_bridge_domains/version (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_version is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_version() directly.
YANG Description: Igmp Version | f335976:c0:m28 |
def _get_num_of_mcast_grps(self): | return self.__num_of_mcast_grps<EOL> | Getter method for num_of_mcast_grps, mapped from YANG variable /igmp_snooping_bridge_domains_state/igmp_snooping_bridge_domains/num_of_mcast_grps (uint32)
YANG Description: Number of Multicast Groups | f335976:c0:m30 |
def _set_num_of_mcast_grps(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__num_of_mcast_grps = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for num_of_mcast_grps, mapped from YANG variable /igmp_snooping_bridge_domains_state/igmp_snooping_bridge_domains/num_of_mcast_grps (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_num_of_mcast_grps is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_num_of_mcast_grps() directly.
YANG Description: Number of Multicast Groups | f335976:c0:m31 |
def _get_vlan_groups(self): | return self.__vlan_groups<EOL> | Getter method for vlan_groups, mapped from YANG variable /igmp_snooping_bridge_domains_state/igmp_snooping_bridge_domains/vlan_groups (list) | f335976:c0:m33 |
def _set_vlan_groups(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>",vlan_groups.vlan_groups, 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>'}}), 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>'}}, 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.__vlan_groups = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vlan_groups, mapped from YANG variable /igmp_snooping_bridge_domains_state/igmp_snooping_bridge_domains/vlan_groups (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_vlan_groups is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vlan_groups() directly. | f335976:c0:m34 |
def _get_bd_id(self): | return self.__bd_id<EOL> | Getter method for bd_id, mapped from YANG variable /igmp_snooping_bridge_domains_state/bd_id (uint32)
YANG Description: bridge-domain id | f335977:c0:m3 |
def _set_bd_id(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__bd_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bd_id, mapped from YANG variable /igmp_snooping_bridge_domains_state/bd_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_bd_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bd_id() directly.
YANG Description: bridge-domain id | f335977:c0:m4 |
def _get_igmp_snooping_bridge_domains(self): | return self.__igmp_snooping_bridge_domains<EOL> | Getter method for igmp_snooping_bridge_domains, mapped from YANG variable /igmp_snooping_bridge_domains_state/igmp_snooping_bridge_domains (list)
YANG Description: Igmp snooping enabled bridge-domain | f335977:c0:m6 |
def _set_igmp_snooping_bridge_domains(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>",igmp_snooping_bridge_domains.igmp_snooping_bridge_domains, 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.__igmp_snooping_bridge_domains = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for igmp_snooping_bridge_domains, mapped from YANG variable /igmp_snooping_bridge_domains_state/igmp_snooping_bridge_domains (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_igmp_snooping_bridge_domains is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_igmp_snooping_bridge_domains() directly.
YANG Description: Igmp snooping enabled bridge-domain | f335977:c0:m7 |
def _get_suppress_nd_enable(self): | return self.__suppress_nd_enable<EOL> | Getter method for suppress_nd_enable, mapped from YANG variable /interface_vlan/vlan/suppress_nd/suppress_nd_enable (empty) | f335978:c0:m3 |
def _set_suppress_nd_enable(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, 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.__suppress_nd_enable = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for suppress_nd_enable, mapped from YANG variable /interface_vlan/vlan/suppress_nd/suppress_nd_enable (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_suppress_nd_enable is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_suppress_nd_enable() directly. | f335978:c0:m4 |
def _get_igmps_version(self): | return self.__igmps_version<EOL> | Getter method for igmps_version, mapped from YANG variable /interface_vlan/vlan/ip/igmpVlan/snooping/igmps_version (igmps-version-type) | f335979:c0:m3 |
def _set_igmps_version(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_LIT:2>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT:version>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT:version>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__igmps_version = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for igmps_version, mapped from YANG variable /interface_vlan/vlan/ip/igmpVlan/snooping/igmps_version (igmps-version-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_igmps_version is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_igmps_version() directly. | f335979:c0:m4 |
def _get_igmps_last_member_query_interval(self): | return self.__igmps_last_member_query_interval<EOL> | Getter method for igmps_last_member_query_interval, mapped from YANG variable /interface_vlan/vlan/ip/igmpVlan/snooping/igmps_last_member_query_interval (lmqt-type) | f335979:c0:m6 |
def _set_igmps_last_member_query_interval(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_LIT:1000>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__igmps_last_member_query_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for igmps_last_member_query_interval, mapped from YANG variable /interface_vlan/vlan/ip/igmpVlan/snooping/igmps_last_member_query_interval (lmqt-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_igmps_last_member_query_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_igmps_last_member_query_interval() directly. | f335979:c0:m7 |
def _get_igmps_query_interval(self): | return self.__igmps_query_interval<EOL> | Getter method for igmps_query_interval, mapped from YANG variable /interface_vlan/vlan/ip/igmpVlan/snooping/igmps_query_interval (qi-type) | f335979:c0:m9 |
def _set_igmps_query_interval(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_LIT>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__igmps_query_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for igmps_query_interval, mapped from YANG variable /interface_vlan/vlan/ip/igmpVlan/snooping/igmps_query_interval (qi-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_igmps_query_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_igmps_query_interval() directly. | f335979:c0:m10 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.