signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_ldp_interface_hello_next(self): | return self.__ldp_interface_hello_next<EOL> | Getter method for ldp_interface_hello_next, mapped from YANG variable /mpls_state/ldp/interface/ldp_interface_data/ldp_interface_hello_next (uint32)
YANG Description: ldp interface hello next | f336397:c0:m21 |
def _set_ldp_interface_hello_next(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.__ldp_interface_hello_next = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_interface_hello_next, mapped from YANG variable /mpls_state/ldp/interface/ldp_interface_data/ldp_interface_hello_next (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_interface_hello_next is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_interface_hello_next() directly.
YANG Description: ldp interface hello next | f336397:c0:m22 |
def _get_ldp_interface_data(self): | return self.__ldp_interface_data<EOL> | Getter method for ldp_interface_data, mapped from YANG variable /mpls_state/ldp/interface/ldp_interface_data (list)
YANG Description: LDP interface | f336398:c0:m3 |
def _set_ldp_interface_data(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_interface_data.ldp_interface_data, 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_interface_data = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_interface_data, mapped from YANG variable /mpls_state/ldp/interface/ldp_interface_data (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_interface_data is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_interface_data() directly.
YANG Description: LDP interface | f336398:c0:m4 |
def _get_protocol_stats(self): | return self.__protocol_stats<EOL> | Getter method for protocol_stats, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_stats_instance_since_clear/protocol_stats (list)
YANG Description: protocol stats rx/tx | f336399:c0:m3 |
def _set_protocol_stats(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>",protocol_stats.protocol_stats, 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.__protocol_stats = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for protocol_stats, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_stats_instance_since_clear/protocol_stats (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_protocol_stats is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_protocol_stats() directly.
YANG Description: protocol stats rx/tx | f336399:c0:m4 |
def _get_stat_type(self): | return self.__stat_type<EOL> | Getter method for stat_type, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_stats_instance_since_clear/protocol_stats/stat_type (uint32)
YANG Description: Stat Counts | f336400:c0:m3 |
def _set_stat_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=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.__stat_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for stat_type, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_stats_instance_since_clear/protocol_stats/stat_type (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_stat_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_stat_type() directly.
YANG Description: Stat Counts | f336400:c0:m4 |
def _get_rx_count(self): | return self.__rx_count<EOL> | Getter method for rx_count, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_stats_instance_since_clear/protocol_stats/rx_count (uint32)
YANG Description: Receive Count | f336400:c0:m6 |
def _set_rx_count(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rx_count, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_stats_instance_since_clear/protocol_stats/rx_count (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_count() directly.
YANG Description: Receive Count | f336400:c0:m7 |
def _get_tx_count(self): | return self.__tx_count<EOL> | Getter method for tx_count, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_stats_instance_since_clear/protocol_stats/tx_count (uint32)
YANG Description: Transmit Count | f336400:c0:m9 |
def _set_tx_count(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_count, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_stats_instance_since_clear/protocol_stats/tx_count (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_count() directly.
YANG Description: Transmit Count | f336400:c0:m10 |
def _get_protocol_stats(self): | return self.__protocol_stats<EOL> | Getter method for protocol_stats, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_stats_instance_total/protocol_stats (list)
YANG Description: protocol stats rx/tx | f336401:c0:m3 |
def _set_protocol_stats(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>",protocol_stats.protocol_stats, 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.__protocol_stats = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for protocol_stats, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_stats_instance_total/protocol_stats (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_protocol_stats is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_protocol_stats() directly.
YANG Description: protocol stats rx/tx | f336401:c0:m4 |
def _get_stat_type(self): | return self.__stat_type<EOL> | Getter method for stat_type, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_stats_instance_total/protocol_stats/stat_type (uint32)
YANG Description: Stat Counts | f336402:c0:m3 |
def _set_stat_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=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.__stat_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for stat_type, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_stats_instance_total/protocol_stats/stat_type (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_stat_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_stat_type() directly.
YANG Description: Stat Counts | f336402:c0:m4 |
def _get_rx_count(self): | return self.__rx_count<EOL> | Getter method for rx_count, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_stats_instance_total/protocol_stats/rx_count (uint32)
YANG Description: Receive Count | f336402:c0:m6 |
def _set_rx_count(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rx_count, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_stats_instance_total/protocol_stats/rx_count (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_count() directly.
YANG Description: Receive Count | f336402:c0:m7 |
def _get_tx_count(self): | return self.__tx_count<EOL> | Getter method for tx_count, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_stats_instance_total/protocol_stats/tx_count (uint32)
YANG Description: Transmit Count | f336402:c0:m9 |
def _set_tx_count(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tx_count, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_stats_instance_total/protocol_stats/tx_count (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_count() directly.
YANG Description: Transmit Count | f336402:c0:m10 |
def _get_error_type(self): | return self.__error_type<EOL> | Getter method for error_type, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_errors_instance_since_clear/protocol_errors/error_type (uint32)
YANG Description: Error Counts | f336403:c0:m3 |
def _set_error_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=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.__error_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for error_type, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_errors_instance_since_clear/protocol_errors/error_type (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_error_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_error_type() directly.
YANG Description: Error Counts | f336403:c0:m4 |
def _get_count(self): | return self.__count<EOL> | Getter method for count, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_errors_instance_since_clear/protocol_errors/count (uint32)
YANG Description: count | f336403:c0:m6 |
def _set_count(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT:count>", rest_name="<STR_LIT:count>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, 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.__count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for count, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_errors_instance_since_clear/protocol_errors/count (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_count() directly.
YANG Description: count | f336403:c0:m7 |
def _get_protocol_errors(self): | return self.__protocol_errors<EOL> | Getter method for protocol_errors, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_errors_instance_since_clear/protocol_errors (list)
YANG Description: protocol errors | f336404:c0:m3 |
def _set_protocol_errors(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>",protocol_errors.protocol_errors, 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.__protocol_errors = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for protocol_errors, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_errors_instance_since_clear/protocol_errors (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_protocol_errors is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_protocol_errors() directly.
YANG Description: protocol errors | f336404:c0:m4 |
def _get_ldp_protocol_errors_instance_total(self): | return self.__ldp_protocol_errors_instance_total<EOL> | Getter method for ldp_protocol_errors_instance_total, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_errors_instance_total (container) | f336405:c0:m3 |
def _set_ldp_protocol_errors_instance_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=ldp_protocol_errors_instance_total.ldp_protocol_errors_instance_total, 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>'}}, 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_protocol_errors_instance_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_protocol_errors_instance_total, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_errors_instance_total (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_protocol_errors_instance_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_protocol_errors_instance_total() directly. | f336405:c0:m4 |
def _get_ldp_protocol_stats_instance_total(self): | return self.__ldp_protocol_stats_instance_total<EOL> | Getter method for ldp_protocol_stats_instance_total, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_stats_instance_total (container) | f336405:c0:m6 |
def _set_ldp_protocol_stats_instance_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=ldp_protocol_stats_instance_total.ldp_protocol_stats_instance_total, 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>'}}, 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_protocol_stats_instance_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_protocol_stats_instance_total, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_stats_instance_total (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_protocol_stats_instance_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_protocol_stats_instance_total() directly. | f336405:c0:m7 |
def _get_ldp_protocol_stats_instance_since_clear(self): | return self.__ldp_protocol_stats_instance_since_clear<EOL> | Getter method for ldp_protocol_stats_instance_since_clear, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_stats_instance_since_clear (container) | f336405:c0:m9 |
def _set_ldp_protocol_stats_instance_since_clear(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_protocol_stats_instance_since_clear.ldp_protocol_stats_instance_since_clear, 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>'}}, 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_protocol_stats_instance_since_clear = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_protocol_stats_instance_since_clear, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_stats_instance_since_clear (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_protocol_stats_instance_since_clear is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_protocol_stats_instance_since_clear() directly. | f336405:c0:m10 |
def _get_ldp_protocol_errors_instance_since_clear(self): | return self.__ldp_protocol_errors_instance_since_clear<EOL> | Getter method for ldp_protocol_errors_instance_since_clear, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_errors_instance_since_clear (container) | f336405:c0:m12 |
def _set_ldp_protocol_errors_instance_since_clear(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_protocol_errors_instance_since_clear.ldp_protocol_errors_instance_since_clear, 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>'}}, 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_protocol_errors_instance_since_clear = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_protocol_errors_instance_since_clear, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_errors_instance_since_clear (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_protocol_errors_instance_since_clear is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_protocol_errors_instance_since_clear() directly. | f336405:c0:m13 |
def _get_error_type(self): | return self.__error_type<EOL> | Getter method for error_type, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_errors_instance_total/protocol_errors/error_type (uint32)
YANG Description: Error Counts | f336406:c0:m3 |
def _set_error_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=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.__error_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for error_type, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_errors_instance_total/protocol_errors/error_type (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_error_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_error_type() directly.
YANG Description: Error Counts | f336406:c0:m4 |
def _get_count(self): | return self.__count<EOL> | Getter method for count, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_errors_instance_total/protocol_errors/count (uint32)
YANG Description: count | f336406:c0:m6 |
def _set_count(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT:count>", rest_name="<STR_LIT:count>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, 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.__count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for count, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_errors_instance_total/protocol_errors/count (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_count() directly.
YANG Description: count | f336406:c0:m7 |
def _get_protocol_errors(self): | return self.__protocol_errors<EOL> | Getter method for protocol_errors, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_errors_instance_total/protocol_errors (list)
YANG Description: protocol errors | f336407:c0:m3 |
def _set_protocol_errors(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>",protocol_errors.protocol_errors, 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.__protocol_errors = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for protocol_errors, mapped from YANG variable /mpls_state/ldp/statistics/ldp_protocol_errors_instance_total/protocol_errors (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_protocol_errors is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_protocol_errors() directly.
YANG Description: protocol errors | f336407:c0:m4 |
def _get_ldp_initialized(self): | return self.__ldp_initialized<EOL> | Getter method for ldp_initialized, mapped from YANG variable /mpls_state/ldp/ldp_out/ldp_initialized (boolean)
YANG Description: ldp_initialized | f336408: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_out/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 | f336408:c0:m4 |
def _get_lsr_id(self): | return self.__lsr_id<EOL> | Getter method for lsr_id, mapped from YANG variable /mpls_state/ldp/ldp_out/lsr_id (inet:ipv4-address)
YANG Description: lsr_id | f336408: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/ldp_out/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 | f336408: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/ldp_out/lsr_id_configured (boolean)
YANG Description: lsr_id_configured | f336408: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/ldp_out/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 | f336408:c0:m10 |
def _get_loopback(self): | return self.__loopback<EOL> | Getter method for loopback, mapped from YANG variable /mpls_state/ldp/ldp_out/loopback (uint8)
YANG Description: loopback | f336408: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/ldp_out/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 | f336408: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/ldp_out/hello_interval_link (uint32)
YANG Description: hello_interval_link | f336408: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/ldp_out/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 | f336408: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/ldp_out/hello_interval_target (uint32)
YANG Description: hello_interval_target | f336408: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/ldp_out/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 | f336408: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/ldp_out/hold_time_sent_link (uint32)
YANG Description: hold_time_sent_link | f336408: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/ldp_out/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 | f336408: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/ldp_out/hold_time_sent_target (uint32)
YANG Description: hold_time_sent_target | f336408: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/ldp_out/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 | f336408:c0:m25 |
def _get_ka_interval(self): | return self.__ka_interval<EOL> | Getter method for ka_interval, mapped from YANG variable /mpls_state/ldp/ldp_out/ka_interval (uint32)
YANG Description: ka_interval | f336408: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/ldp_out/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 | f336408:c0:m28 |
def _get_ka_multiple(self): | return self.__ka_multiple<EOL> | Getter method for ka_multiple, mapped from YANG variable /mpls_state/ldp/ldp_out/ka_multiple (uint32)
YANG Description: ka_multiple | f336408: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/ldp_out/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 | f336408:c0:m31 |
def _get_ka_timeout(self): | return self.__ka_timeout<EOL> | Getter method for ka_timeout, mapped from YANG variable /mpls_state/ldp/ldp_out/ka_timeout (uint32)
YANG Description: ka_timeout | f336408: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/ldp_out/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 | f336408: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/ldp_out/ka_timeout_default (boolean)
YANG Description: ka_timeout_default | f336408: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/ldp_out/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 | f336408:c0:m37 |
def _get_load_sharing(self): | return self.__load_sharing<EOL> | Getter method for load_sharing, mapped from YANG variable /mpls_state/ldp/ldp_out/load_sharing (uint8)
YANG Description: load_sharing | f336408: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/ldp_out/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 | f336408: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/ldp_out/advertise_fecs_for_prefix_list (string)
YANG Description: advertise_fecs_for_prefix_list | f336408: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/ldp_out/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 | f336408: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/ldp_out/advertise_fecs_for_prefix_list_exists (boolean)
YANG Description: advertise_fecs_for_prefix_list_exists | f336408: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/ldp_out/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 | f336408: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/ldp_out/inbound_fecs_filtering_prefix_list (string)
YANG Description: inbound_fecs_filtering_prefix_list | f336408: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/ldp_out/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 | f336408: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/ldp_out/inbound_fecs_filtering_prefix_list_exists (boolean)
YANG Description: inbound_fecs_filtering_prefix_list_exists | f336408: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/ldp_out/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 | f336408: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/ldp_out/outbound_fecs_filtering_prefix_list (string)
YANG Description: outbound_fecs_filtering_prefix_list | f336408: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/ldp_out/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 | f336408: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/ldp_out/outbound_fecs_filtering_prefix_list_exists (boolean)
YANG Description: outbound_fecs_filtering_prefix_list_exists | f336408: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/ldp_out/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 | f336408:c0:m58 |
def _get_tunnel_metric(self): | return self.__tunnel_metric<EOL> | Getter method for tunnel_metric, mapped from YANG variable /mpls_state/ldp/ldp_out/tunnel_metric (uint16)
YANG Description: tunnel_metric | f336408: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/ldp_out/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 | f336408: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/ldp_out/fec_128_used_for_auto_disc_current (boolean)
YANG Description: fec_128_used_for_auto_disc_current | f336408: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/ldp_out/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 | f336408: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/ldp_out/fec_128_used_for_auto_disc_configured (boolean)
YANG Description: fec_128_used_for_auto_disc_configured | f336408: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/ldp_out/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 | f336408: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/ldp_out/end_of_lib (boolean)
YANG Description: end_of_lib | f336408: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/ldp_out/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 | f336408: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/ldp_out/eol_notification_time (uint32)
YANG Description: eol_notification_time | f336408: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/ldp_out/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 | f336408: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/ldp_out/tx_silence_time (uint32)
YANG Description: tx_silence_time | f336408: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/ldp_out/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 | f336408: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/ldp_out/rx_silence_time (uint32)
YANG Description: rx_silence_time | f336408: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/ldp_out/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 | f336408:c0:m79 |
def _get_gr_enable(self): | return self.__gr_enable<EOL> | Getter method for gr_enable, mapped from YANG variable /mpls_state/ldp/ldp_out/gr_enable (boolean)
YANG Description: gr_enable | f336408: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/ldp_out/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 | f336408:c0:m82 |
def _get_gr_helper(self): | return self.__gr_helper<EOL> | Getter method for gr_helper, mapped from YANG variable /mpls_state/ldp/ldp_out/gr_helper (boolean)
YANG Description: gr_helper | f336408: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/ldp_out/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 | f336408: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/ldp_out/gr_reconnect_time (uint32)
YANG Description: gr_reconnect_time | f336408: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/ldp_out/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 | f336408: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/ldp_out/gr_max_peer_reconnect_time (uint32)
YANG Description: gr_max_peer_reconnect_time | f336408: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/ldp_out/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 | f336408:c0:m91 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.