signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_vc_local_flow_label_tx(self): | return self.__vc_local_flow_label_tx<EOL> | Getter method for vc_local_flow_label_tx, mapped from YANG variable /mpls_state/ldp/ldp_fec_vc/vc_local_flow_label_tx (uint32)
YANG Description: Transmitting the flow label is preferred | f335959:c0:m57 |
def _set_vc_local_flow_label_tx(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_flow_label_tx = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_local_flow_label_tx, mapped from YANG variable /mpls_state/ldp/ldp_fec_vc/vc_local_flow_label_tx (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_local_flow_label_tx is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_local_flow_label_tx() directly.
YANG Description: Transmitting the flow label is preferred | f335959:c0:m58 |
def _get_vc_local_flow_label_rx(self): | return self.__vc_local_flow_label_rx<EOL> | Getter method for vc_local_flow_label_rx, mapped from YANG variable /mpls_state/ldp/ldp_fec_vc/vc_local_flow_label_rx (uint32)
YANG Description: Receiving the flow label is preferred | f335959:c0:m60 |
def _set_vc_local_flow_label_rx(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_flow_label_rx = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_local_flow_label_rx, mapped from YANG variable /mpls_state/ldp/ldp_fec_vc/vc_local_flow_label_rx (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_local_flow_label_rx is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_local_flow_label_rx() directly.
YANG Description: Receiving the flow label is preferred | f335959:c0:m61 |
def _get_vc_remote_flow_label_tx(self): | return self.__vc_remote_flow_label_tx<EOL> | Getter method for vc_remote_flow_label_tx, mapped from YANG variable /mpls_state/ldp/ldp_fec_vc/vc_remote_flow_label_tx (uint32)
YANG Description: Transmitting the flow label is preferred | f335959:c0:m63 |
def _set_vc_remote_flow_label_tx(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_flow_label_tx = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_remote_flow_label_tx, mapped from YANG variable /mpls_state/ldp/ldp_fec_vc/vc_remote_flow_label_tx (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_remote_flow_label_tx is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_remote_flow_label_tx() directly.
YANG Description: Transmitting the flow label is preferred | f335959:c0:m64 |
def _get_vc_remote_flow_label_rx(self): | return self.__vc_remote_flow_label_rx<EOL> | Getter method for vc_remote_flow_label_rx, mapped from YANG variable /mpls_state/ldp/ldp_fec_vc/vc_remote_flow_label_rx (uint32)
YANG Description: Receiving the flow label is preferred | f335959:c0:m66 |
def _set_vc_remote_flow_label_rx(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_flow_label_rx = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_remote_flow_label_rx, mapped from YANG variable /mpls_state/ldp/ldp_fec_vc/vc_remote_flow_label_rx (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_remote_flow_label_rx is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_remote_flow_label_rx() directly.
YANG Description: Receiving the flow label is preferred | f335959:c0:m67 |
def _get_vc_control_word_preferred(self): | return self.__vc_control_word_preferred<EOL> | Getter method for vc_control_word_preferred, mapped from YANG variable /mpls_state/ldp/ldp_fec_vc/vc_control_word_preferred (uint32)
YANG Description: Control word is preferred | f335959:c0:m69 |
def _set_vc_control_word_preferred(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_control_word_preferred = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_control_word_preferred, mapped from YANG variable /mpls_state/ldp/ldp_fec_vc/vc_control_word_preferred (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_control_word_preferred is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_control_word_preferred() directly.
YANG Description: Control word is preferred | f335959:c0:m70 |
def _get_vc_control_word_in_use(self): | return self.__vc_control_word_in_use<EOL> | Getter method for vc_control_word_in_use, mapped from YANG variable /mpls_state/ldp/ldp_fec_vc/vc_control_word_in_use (uint32)
YANG Description: Control word is in use | f335959:c0:m72 |
def _set_vc_control_word_in_use(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_control_word_in_use = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_control_word_in_use, mapped from YANG variable /mpls_state/ldp/ldp_fec_vc/vc_control_word_in_use (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_control_word_in_use is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_control_word_in_use() directly.
YANG Description: Control word is in use | f335959:c0:m73 |
def _get_vc_downstream(self): | return self.__vc_downstream<EOL> | Getter method for vc_downstream, mapped from YANG variable /mpls_state/ldp/ldp_fec_vc/vc_downstream (list)
YANG Description: LDP VC fec for downstream mapping | f335959:c0:m75 |
def _set_vc_downstream(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_downstream.vc_downstream, 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_downstream = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_downstream, mapped from YANG variable /mpls_state/ldp/ldp_fec_vc/vc_downstream (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_downstream is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_downstream() directly.
YANG Description: LDP VC fec for downstream mapping | f335959:c0:m76 |
def _get_vc_upstream(self): | return self.__vc_upstream<EOL> | Getter method for vc_upstream, mapped from YANG variable /mpls_state/ldp/ldp_fec_vc/vc_upstream (list)
YANG Description: LDP VC fec for upstream mapping | f335959:c0:m78 |
def _set_vc_upstream(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_upstream.vc_upstream, 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_upstream = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_upstream, mapped from YANG variable /mpls_state/ldp/ldp_fec_vc/vc_upstream (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_upstream is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_upstream() directly.
YANG Description: LDP VC fec for upstream mapping | f335959:c0:m79 |
def _get_ldp_initialized(self): | return self.__ldp_initialized<EOL> | Getter method for ldp_initialized, mapped from YANG variable /mpls_state/ldp/ldp_initialized (boolean)
YANG Description: ldp_initialized | f335960:c0:m3 |
def _set_ldp_initialized(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.__ldp_initialized = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_initialized, mapped from YANG variable /mpls_state/ldp/ldp_initialized (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_initialized is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_initialized() directly.
YANG Description: ldp_initialized | f335960:c0:m4 |
def _get_lsr_id(self): | return self.__lsr_id<EOL> | Getter method for lsr_id, mapped from YANG variable /mpls_state/ldp/lsr_id (inet:ipv4-address)
YANG Description: lsr_id | f335960:c0:m6 |
def _set_lsr_id(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=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, 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.__lsr_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsr_id, mapped from YANG variable /mpls_state/ldp/lsr_id (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsr_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsr_id() directly.
YANG Description: lsr_id | f335960:c0:m7 |
def _get_lsr_id_configured(self): | return self.__lsr_id_configured<EOL> | Getter method for lsr_id_configured, mapped from YANG variable /mpls_state/ldp/lsr_id_configured (boolean)
YANG Description: lsr_id_configured | f335960:c0:m9 |
def _set_lsr_id_configured(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.__lsr_id_configured = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lsr_id_configured, mapped from YANG variable /mpls_state/ldp/lsr_id_configured (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_lsr_id_configured is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lsr_id_configured() directly.
YANG Description: lsr_id_configured | f335960:c0:m10 |
def _get_loopback(self): | return self.__loopback<EOL> | Getter method for loopback, mapped from YANG variable /mpls_state/ldp/loopback (uint8)
YANG Description: loopback | f335960:c0:m12 |
def _set_loopback(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.__loopback = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for loopback, mapped from YANG variable /mpls_state/ldp/loopback (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_loopback is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_loopback() directly.
YANG Description: loopback | f335960:c0:m13 |
def _get_hello_interval_link(self): | return self.__hello_interval_link<EOL> | Getter method for hello_interval_link, mapped from YANG variable /mpls_state/ldp/hello_interval_link (uint32)
YANG Description: hello_interval_link | f335960:c0:m15 |
def _set_hello_interval_link(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.__hello_interval_link = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hello_interval_link, mapped from YANG variable /mpls_state/ldp/hello_interval_link (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_hello_interval_link is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hello_interval_link() directly.
YANG Description: hello_interval_link | f335960:c0:m16 |
def _get_hello_interval_target(self): | return self.__hello_interval_target<EOL> | Getter method for hello_interval_target, mapped from YANG variable /mpls_state/ldp/hello_interval_target (uint32)
YANG Description: hello_interval_target | f335960:c0:m18 |
def _set_hello_interval_target(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.__hello_interval_target = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hello_interval_target, mapped from YANG variable /mpls_state/ldp/hello_interval_target (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_hello_interval_target is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hello_interval_target() directly.
YANG Description: hello_interval_target | f335960:c0:m19 |
def _get_hold_time_sent_link(self): | return self.__hold_time_sent_link<EOL> | Getter method for hold_time_sent_link, mapped from YANG variable /mpls_state/ldp/hold_time_sent_link (uint32)
YANG Description: hold_time_sent_link | f335960:c0:m21 |
def _set_hold_time_sent_link(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.__hold_time_sent_link = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hold_time_sent_link, mapped from YANG variable /mpls_state/ldp/hold_time_sent_link (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_hold_time_sent_link is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hold_time_sent_link() directly.
YANG Description: hold_time_sent_link | f335960:c0:m22 |
def _get_hold_time_sent_target(self): | return self.__hold_time_sent_target<EOL> | Getter method for hold_time_sent_target, mapped from YANG variable /mpls_state/ldp/hold_time_sent_target (uint32)
YANG Description: hold_time_sent_target | f335960:c0:m24 |
def _set_hold_time_sent_target(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.__hold_time_sent_target = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hold_time_sent_target, mapped from YANG variable /mpls_state/ldp/hold_time_sent_target (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_hold_time_sent_target is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hold_time_sent_target() directly.
YANG Description: hold_time_sent_target | f335960:c0:m25 |
def _get_ka_interval(self): | return self.__ka_interval<EOL> | Getter method for ka_interval, mapped from YANG variable /mpls_state/ldp/ka_interval (uint32)
YANG Description: ka_interval | f335960:c0:m27 |
def _set_ka_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=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.__ka_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ka_interval, mapped from YANG variable /mpls_state/ldp/ka_interval (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_ka_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ka_interval() directly.
YANG Description: ka_interval | f335960:c0:m28 |
def _get_ka_multiple(self): | return self.__ka_multiple<EOL> | Getter method for ka_multiple, mapped from YANG variable /mpls_state/ldp/ka_multiple (uint32)
YANG Description: ka_multiple | f335960:c0:m30 |
def _set_ka_multiple(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.__ka_multiple = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ka_multiple, mapped from YANG variable /mpls_state/ldp/ka_multiple (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_ka_multiple is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ka_multiple() directly.
YANG Description: ka_multiple | f335960:c0:m31 |
def _get_ka_timeout(self): | return self.__ka_timeout<EOL> | Getter method for ka_timeout, mapped from YANG variable /mpls_state/ldp/ka_timeout (uint32)
YANG Description: ka_timeout | f335960:c0:m33 |
def _set_ka_timeout(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.__ka_timeout = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ka_timeout, mapped from YANG variable /mpls_state/ldp/ka_timeout (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_ka_timeout is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ka_timeout() directly.
YANG Description: ka_timeout | f335960:c0:m34 |
def _get_ka_timeout_default(self): | return self.__ka_timeout_default<EOL> | Getter method for ka_timeout_default, mapped from YANG variable /mpls_state/ldp/ka_timeout_default (boolean)
YANG Description: ka_timeout_default | f335960:c0:m36 |
def _set_ka_timeout_default(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.__ka_timeout_default = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ka_timeout_default, mapped from YANG variable /mpls_state/ldp/ka_timeout_default (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_ka_timeout_default is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ka_timeout_default() directly.
YANG Description: ka_timeout_default | f335960:c0:m37 |
def _get_load_sharing(self): | return self.__load_sharing<EOL> | Getter method for load_sharing, mapped from YANG variable /mpls_state/ldp/load_sharing (uint8)
YANG Description: load_sharing | f335960:c0:m39 |
def _set_load_sharing(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.__load_sharing = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for load_sharing, mapped from YANG variable /mpls_state/ldp/load_sharing (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_load_sharing is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_load_sharing() directly.
YANG Description: load_sharing | f335960:c0:m40 |
def _get_advertise_fecs_for_prefix_list(self): | return self.__advertise_fecs_for_prefix_list<EOL> | Getter method for advertise_fecs_for_prefix_list, mapped from YANG variable /mpls_state/ldp/advertise_fecs_for_prefix_list (string)
YANG Description: advertise_fecs_for_prefix_list | f335960:c0:m42 |
def _set_advertise_fecs_for_prefix_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=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.__advertise_fecs_for_prefix_list = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for advertise_fecs_for_prefix_list, mapped from YANG variable /mpls_state/ldp/advertise_fecs_for_prefix_list (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_advertise_fecs_for_prefix_list is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_advertise_fecs_for_prefix_list() directly.
YANG Description: advertise_fecs_for_prefix_list | f335960:c0:m43 |
def _get_advertise_fecs_for_prefix_list_exists(self): | return self.__advertise_fecs_for_prefix_list_exists<EOL> | Getter method for advertise_fecs_for_prefix_list_exists, mapped from YANG variable /mpls_state/ldp/advertise_fecs_for_prefix_list_exists (boolean)
YANG Description: advertise_fecs_for_prefix_list_exists | f335960:c0:m45 |
def _set_advertise_fecs_for_prefix_list_exists(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.__advertise_fecs_for_prefix_list_exists = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for advertise_fecs_for_prefix_list_exists, mapped from YANG variable /mpls_state/ldp/advertise_fecs_for_prefix_list_exists (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_advertise_fecs_for_prefix_list_exists is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_advertise_fecs_for_prefix_list_exists() directly.
YANG Description: advertise_fecs_for_prefix_list_exists | f335960:c0:m46 |
def _get_inbound_fecs_filtering_prefix_list(self): | return self.__inbound_fecs_filtering_prefix_list<EOL> | Getter method for inbound_fecs_filtering_prefix_list, mapped from YANG variable /mpls_state/ldp/inbound_fecs_filtering_prefix_list (string)
YANG Description: inbound_fecs_filtering_prefix_list | f335960:c0:m48 |
def _set_inbound_fecs_filtering_prefix_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=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.__inbound_fecs_filtering_prefix_list = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for inbound_fecs_filtering_prefix_list, mapped from YANG variable /mpls_state/ldp/inbound_fecs_filtering_prefix_list (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_inbound_fecs_filtering_prefix_list is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_inbound_fecs_filtering_prefix_list() directly.
YANG Description: inbound_fecs_filtering_prefix_list | f335960:c0:m49 |
def _get_inbound_fecs_filtering_prefix_list_exists(self): | return self.__inbound_fecs_filtering_prefix_list_exists<EOL> | Getter method for inbound_fecs_filtering_prefix_list_exists, mapped from YANG variable /mpls_state/ldp/inbound_fecs_filtering_prefix_list_exists (boolean)
YANG Description: inbound_fecs_filtering_prefix_list_exists | f335960:c0:m51 |
def _set_inbound_fecs_filtering_prefix_list_exists(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.__inbound_fecs_filtering_prefix_list_exists = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for inbound_fecs_filtering_prefix_list_exists, mapped from YANG variable /mpls_state/ldp/inbound_fecs_filtering_prefix_list_exists (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_inbound_fecs_filtering_prefix_list_exists is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_inbound_fecs_filtering_prefix_list_exists() directly.
YANG Description: inbound_fecs_filtering_prefix_list_exists | f335960:c0:m52 |
def _get_outbound_fecs_filtering_prefix_list(self): | return self.__outbound_fecs_filtering_prefix_list<EOL> | Getter method for outbound_fecs_filtering_prefix_list, mapped from YANG variable /mpls_state/ldp/outbound_fecs_filtering_prefix_list (string)
YANG Description: outbound_fecs_filtering_prefix_list | f335960:c0:m54 |
def _set_outbound_fecs_filtering_prefix_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=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.__outbound_fecs_filtering_prefix_list = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for outbound_fecs_filtering_prefix_list, mapped from YANG variable /mpls_state/ldp/outbound_fecs_filtering_prefix_list (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_outbound_fecs_filtering_prefix_list is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_outbound_fecs_filtering_prefix_list() directly.
YANG Description: outbound_fecs_filtering_prefix_list | f335960:c0:m55 |
def _get_outbound_fecs_filtering_prefix_list_exists(self): | return self.__outbound_fecs_filtering_prefix_list_exists<EOL> | Getter method for outbound_fecs_filtering_prefix_list_exists, mapped from YANG variable /mpls_state/ldp/outbound_fecs_filtering_prefix_list_exists (boolean)
YANG Description: outbound_fecs_filtering_prefix_list_exists | f335960:c0:m57 |
def _set_outbound_fecs_filtering_prefix_list_exists(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.__outbound_fecs_filtering_prefix_list_exists = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for outbound_fecs_filtering_prefix_list_exists, mapped from YANG variable /mpls_state/ldp/outbound_fecs_filtering_prefix_list_exists (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_outbound_fecs_filtering_prefix_list_exists is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_outbound_fecs_filtering_prefix_list_exists() directly.
YANG Description: outbound_fecs_filtering_prefix_list_exists | f335960:c0:m58 |
def _get_tunnel_metric(self): | return self.__tunnel_metric<EOL> | Getter method for tunnel_metric, mapped from YANG variable /mpls_state/ldp/tunnel_metric (uint16)
YANG Description: tunnel_metric | f335960:c0:m60 |
def _set_tunnel_metric(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: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, 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.__tunnel_metric = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tunnel_metric, mapped from YANG variable /mpls_state/ldp/tunnel_metric (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_tunnel_metric is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tunnel_metric() directly.
YANG Description: tunnel_metric | f335960:c0:m61 |
def _get_fec_128_used_for_auto_disc_current(self): | return self.__fec_128_used_for_auto_disc_current<EOL> | Getter method for fec_128_used_for_auto_disc_current, mapped from YANG variable /mpls_state/ldp/fec_128_used_for_auto_disc_current (boolean)
YANG Description: fec_128_used_for_auto_disc_current | f335960:c0:m63 |
def _set_fec_128_used_for_auto_disc_current(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.__fec_128_used_for_auto_disc_current = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fec_128_used_for_auto_disc_current, mapped from YANG variable /mpls_state/ldp/fec_128_used_for_auto_disc_current (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_fec_128_used_for_auto_disc_current is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fec_128_used_for_auto_disc_current() directly.
YANG Description: fec_128_used_for_auto_disc_current | f335960:c0:m64 |
def _get_fec_128_used_for_auto_disc_configured(self): | return self.__fec_128_used_for_auto_disc_configured<EOL> | Getter method for fec_128_used_for_auto_disc_configured, mapped from YANG variable /mpls_state/ldp/fec_128_used_for_auto_disc_configured (boolean)
YANG Description: fec_128_used_for_auto_disc_configured | f335960:c0:m66 |
def _set_fec_128_used_for_auto_disc_configured(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.__fec_128_used_for_auto_disc_configured = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fec_128_used_for_auto_disc_configured, mapped from YANG variable /mpls_state/ldp/fec_128_used_for_auto_disc_configured (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_fec_128_used_for_auto_disc_configured is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fec_128_used_for_auto_disc_configured() directly.
YANG Description: fec_128_used_for_auto_disc_configured | f335960:c0:m67 |
def _get_end_of_lib(self): | return self.__end_of_lib<EOL> | Getter method for end_of_lib, mapped from YANG variable /mpls_state/ldp/end_of_lib (boolean)
YANG Description: end_of_lib | f335960:c0:m69 |
def _set_end_of_lib(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.__end_of_lib = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for end_of_lib, mapped from YANG variable /mpls_state/ldp/end_of_lib (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_end_of_lib is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_end_of_lib() directly.
YANG Description: end_of_lib | f335960:c0:m70 |
def _get_eol_notification_time(self): | return self.__eol_notification_time<EOL> | Getter method for eol_notification_time, mapped from YANG variable /mpls_state/ldp/eol_notification_time (uint32)
YANG Description: eol_notification_time | f335960:c0:m72 |
def _set_eol_notification_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=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.__eol_notification_time = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for eol_notification_time, mapped from YANG variable /mpls_state/ldp/eol_notification_time (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_eol_notification_time is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_eol_notification_time() directly.
YANG Description: eol_notification_time | f335960:c0:m73 |
def _get_tx_silence_time(self): | return self.__tx_silence_time<EOL> | Getter method for tx_silence_time, mapped from YANG variable /mpls_state/ldp/tx_silence_time (uint32)
YANG Description: tx_silence_time | f335960:c0:m75 |
def _set_tx_silence_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=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.__tx_silence_time = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_silence_time, mapped from YANG variable /mpls_state/ldp/tx_silence_time (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_silence_time is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_silence_time() directly.
YANG Description: tx_silence_time | f335960:c0:m76 |
def _get_rx_silence_time(self): | return self.__rx_silence_time<EOL> | Getter method for rx_silence_time, mapped from YANG variable /mpls_state/ldp/rx_silence_time (uint32)
YANG Description: rx_silence_time | f335960:c0:m78 |
def _set_rx_silence_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=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.__rx_silence_time = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rx_silence_time, mapped from YANG variable /mpls_state/ldp/rx_silence_time (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_silence_time is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_silence_time() directly.
YANG Description: rx_silence_time | f335960:c0:m79 |
def _get_gr_enable(self): | return self.__gr_enable<EOL> | Getter method for gr_enable, mapped from YANG variable /mpls_state/ldp/gr_enable (boolean)
YANG Description: gr_enable | f335960:c0:m81 |
def _set_gr_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, 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.__gr_enable = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for gr_enable, mapped from YANG variable /mpls_state/ldp/gr_enable (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_gr_enable is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_gr_enable() directly.
YANG Description: gr_enable | f335960:c0:m82 |
def _get_gr_helper(self): | return self.__gr_helper<EOL> | Getter method for gr_helper, mapped from YANG variable /mpls_state/ldp/gr_helper (boolean)
YANG Description: gr_helper | f335960:c0:m84 |
def _set_gr_helper(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.__gr_helper = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for gr_helper, mapped from YANG variable /mpls_state/ldp/gr_helper (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_gr_helper is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_gr_helper() directly.
YANG Description: gr_helper | f335960:c0:m85 |
def _get_gr_reconnect_time(self): | return self.__gr_reconnect_time<EOL> | Getter method for gr_reconnect_time, mapped from YANG variable /mpls_state/ldp/gr_reconnect_time (uint32)
YANG Description: gr_reconnect_time | f335960:c0:m87 |
def _set_gr_reconnect_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=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.__gr_reconnect_time = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for gr_reconnect_time, mapped from YANG variable /mpls_state/ldp/gr_reconnect_time (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_gr_reconnect_time is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_gr_reconnect_time() directly.
YANG Description: gr_reconnect_time | f335960:c0:m88 |
def _get_gr_max_peer_reconnect_time(self): | return self.__gr_max_peer_reconnect_time<EOL> | Getter method for gr_max_peer_reconnect_time, mapped from YANG variable /mpls_state/ldp/gr_max_peer_reconnect_time (uint32)
YANG Description: gr_max_peer_reconnect_time | f335960:c0:m90 |
def _set_gr_max_peer_reconnect_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=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.__gr_max_peer_reconnect_time = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for gr_max_peer_reconnect_time, mapped from YANG variable /mpls_state/ldp/gr_max_peer_reconnect_time (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_gr_max_peer_reconnect_time is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_gr_max_peer_reconnect_time() directly.
YANG Description: gr_max_peer_reconnect_time | f335960:c0:m91 |
def _get_gr_recovery_time(self): | return self.__gr_recovery_time<EOL> | Getter method for gr_recovery_time, mapped from YANG variable /mpls_state/ldp/gr_recovery_time (uint32)
YANG Description: gr_recovery_time | f335960:c0:m93 |
def _set_gr_recovery_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=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.__gr_recovery_time = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for gr_recovery_time, mapped from YANG variable /mpls_state/ldp/gr_recovery_time (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_gr_recovery_time is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_gr_recovery_time() directly.
YANG Description: gr_recovery_time | f335960:c0:m94 |
def _get_gr_max_peer_recovery_time(self): | return self.__gr_max_peer_recovery_time<EOL> | Getter method for gr_max_peer_recovery_time, mapped from YANG variable /mpls_state/ldp/gr_max_peer_recovery_time (uint32)
YANG Description: gr_max_peer_recovery_time | f335960:c0:m96 |
def _set_gr_max_peer_recovery_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=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.__gr_max_peer_recovery_time = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for gr_max_peer_recovery_time, mapped from YANG variable /mpls_state/ldp/gr_max_peer_recovery_time (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_gr_max_peer_recovery_time is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_gr_max_peer_recovery_time() directly.
YANG Description: gr_max_peer_recovery_time | f335960:c0:m97 |
def _get_forwarding_state_timer_running(self): | return self.__forwarding_state_timer_running<EOL> | Getter method for forwarding_state_timer_running, mapped from YANG variable /mpls_state/ldp/forwarding_state_timer_running (boolean)
YANG Description: forwarding_state_timer_running | f335960:c0:m99 |
def _set_forwarding_state_timer_running(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.__forwarding_state_timer_running = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for forwarding_state_timer_running, mapped from YANG variable /mpls_state/ldp/forwarding_state_timer_running (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_forwarding_state_timer_running is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_forwarding_state_timer_running() directly.
YANG Description: forwarding_state_timer_running | f335960:c0:m100 |
def _get_forwarding_state_timer_remaining(self): | return self.__forwarding_state_timer_remaining<EOL> | Getter method for forwarding_state_timer_remaining, mapped from YANG variable /mpls_state/ldp/forwarding_state_timer_remaining (uint32)
YANG Description: forwarding_state_timer_remaining | f335960:c0:m102 |
def _set_forwarding_state_timer_remaining(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.__forwarding_state_timer_remaining = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for forwarding_state_timer_remaining, mapped from YANG variable /mpls_state/ldp/forwarding_state_timer_remaining (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_forwarding_state_timer_remaining is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_forwarding_state_timer_remaining() directly.
YANG Description: forwarding_state_timer_remaining | f335960:c0:m103 |
def _get_lwd_delay(self): | return self.__lwd_delay<EOL> | Getter method for lwd_delay, mapped from YANG variable /mpls_state/ldp/lwd_delay (uint32)
YANG Description: lwd_delay | f335960:c0:m105 |
def _set_lwd_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=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.__lwd_delay = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lwd_delay, mapped from YANG variable /mpls_state/ldp/lwd_delay (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_lwd_delay is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lwd_delay() directly.
YANG Description: lwd_delay | f335960:c0:m106 |
def _get_lwd_default(self): | return self.__lwd_default<EOL> | Getter method for lwd_default, mapped from YANG variable /mpls_state/ldp/lwd_default (boolean)
YANG Description: lwd_default | f335960:c0:m108 |
def _set_lwd_default(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.__lwd_default = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for lwd_default, mapped from YANG variable /mpls_state/ldp/lwd_default (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_lwd_default is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_lwd_default() directly.
YANG Description: lwd_default | f335960:c0:m109 |
def _get_ldp_session_summary(self): | return self.__ldp_session_summary<EOL> | Getter method for ldp_session_summary, mapped from YANG variable /mpls_state/ldp/ldp_session_summary (container) | f335960:c0:m111 |
def _set_ldp_session_summary(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=ldp_session_summary.ldp_session_summary, 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.__ldp_session_summary = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_session_summary, mapped from YANG variable /mpls_state/ldp/ldp_session_summary (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_session_summary is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_session_summary() directly. | f335960:c0:m112 |
def _get_tunnels(self): | return self.__tunnels<EOL> | Getter method for tunnels, mapped from YANG variable /mpls_state/ldp/tunnels (container)
YANG Description: LDP Tunnels | f335960:c0:m114 |
def _set_tunnels(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=tunnels.tunnels, 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.__tunnels = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tunnels, mapped from YANG variable /mpls_state/ldp/tunnels (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_tunnels is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tunnels() directly.
YANG Description: LDP Tunnels | f335960:c0:m115 |
def _get_statistics(self): | return self.__statistics<EOL> | Getter method for statistics, mapped from YANG variable /mpls_state/ldp/statistics (container)
YANG Description: Global LDP stats | f335960:c0:m117 |
def _set_statistics(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=statistics.statistics, 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.__statistics = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for statistics, mapped from YANG variable /mpls_state/ldp/statistics (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_statistics is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_statistics() directly.
YANG Description: Global LDP stats | f335960:c0:m118 |
def _get_ldp_fec_statistics(self): | return self.__ldp_fec_statistics<EOL> | Getter method for ldp_fec_statistics, mapped from YANG variable /mpls_state/ldp/ldp_fec_statistics (container)
YANG Description: LDP FEC statistics | f335960:c0:m120 |
def _set_ldp_fec_statistics(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=ldp_fec_statistics.ldp_fec_statistics, 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.__ldp_fec_statistics = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_fec_statistics, mapped from YANG variable /mpls_state/ldp/ldp_fec_statistics (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_fec_statistics is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_fec_statistics() directly.
YANG Description: LDP FEC statistics | f335960:c0:m121 |
def _get_interface(self): | return self.__interface<EOL> | Getter method for interface, mapped from YANG variable /mpls_state/ldp/interface (list)
YANG Description: LDP interface | f335960:c0:m123 |
def _set_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=YANGListType("<STR_LIT>",interface.interface, 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.__interface = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface, mapped from YANG variable /mpls_state/ldp/interface (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface() directly.
YANG Description: LDP interface | f335960:c0:m124 |
def _get_ldp_database(self): | return self.__ldp_database<EOL> | Getter method for ldp_database, mapped from YANG variable /mpls_state/ldp/ldp_database (list)
YANG Description: LDP database operational Information | f335960:c0:m126 |
def _set_ldp_database(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>",ldp_database.ldp_database, 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.__ldp_database = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_database, mapped from YANG variable /mpls_state/ldp/ldp_database (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_database is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_database() directly.
YANG Description: LDP database operational Information | f335960:c0:m127 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.