signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_prefix_upstream(self): | return self.__prefix_upstream<EOL> | Getter method for prefix_upstream, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_prefix_prefix/prefix_upstream (list) | f336419:c0:m48 |
def _set_prefix_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>",prefix_upstream.prefix_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>'}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__prefix_upstream = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for prefix_upstream, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_prefix_prefix/prefix_upstream (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_prefix_upstream is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_prefix_upstream() directly. | f336419:c0:m49 |
def _get_nexthop(self): | return self.__nexthop<EOL> | Getter method for nexthop, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_prefix_prefix/prefix_nexthops/nexthop (string)
YANG Description: nexthop | f336420:c0:m3 |
def _set_nexthop(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__nexthop = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for nexthop, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_prefix_prefix/prefix_nexthops/nexthop (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_nexthop is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_nexthop() directly.
YANG Description: nexthop | f336420:c0:m4 |
def _get_out_intf(self): | return self.__out_intf<EOL> | Getter method for out_intf, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_prefix_prefix/prefix_nexthops/out_intf (string)
YANG Description: out_intf | f336420:c0:m6 |
def _set_out_intf(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.__out_intf = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for out_intf, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_prefix_prefix/prefix_nexthops/out_intf (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_out_intf is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_out_intf() directly.
YANG Description: out_intf | f336420:c0:m7 |
def _get_ldp_fec_summary(self): | return self.__ldp_fec_summary<EOL> | Getter method for ldp_fec_summary, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_summary (container) | f336421:c0:m3 |
def _set_ldp_fec_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_fec_summary.ldp_fec_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_fec_summary = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_fec_summary, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_summary (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_fec_summary is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_fec_summary() directly. | f336421:c0:m4 |
def _get_ldp_fec_prefixes(self): | return self.__ldp_fec_prefixes<EOL> | Getter method for ldp_fec_prefixes, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_prefixes (container) | f336421:c0:m6 |
def _set_ldp_fec_prefixes(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_prefixes.ldp_fec_prefixes, 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_prefixes = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_fec_prefixes, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_prefixes (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_fec_prefixes is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_fec_prefixes() directly. | f336421:c0:m7 |
def _get_ldp_fec_vcs(self): | return self.__ldp_fec_vcs<EOL> | Getter method for ldp_fec_vcs, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs (container) | f336421:c0:m9 |
def _set_ldp_fec_vcs(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_vcs.ldp_fec_vcs, 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_vcs = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_fec_vcs, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_fec_vcs is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_fec_vcs() directly. | f336421:c0:m10 |
def _get_ldp_fec_prefix_longer(self): | return self.__ldp_fec_prefix_longer<EOL> | Getter method for ldp_fec_prefix_longer, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_prefix_longer (list) | f336421:c0:m12 |
def _set_ldp_fec_prefix_longer(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_fec_prefix_longer.ldp_fec_prefix_longer, 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_fec_prefix_longer = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_fec_prefix_longer, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_prefix_longer (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_fec_prefix_longer is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_fec_prefix_longer() directly. | f336421:c0:m13 |
def _get_ldp_fec_vcid(self): | return self.__ldp_fec_vcid<EOL> | Getter method for ldp_fec_vcid, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcid (list) | f336421:c0:m15 |
def _set_ldp_fec_vcid(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_fec_vcid.ldp_fec_vcid, 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_fec_vcid = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_fec_vcid, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcid (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_fec_vcid is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_fec_vcid() directly. | f336421:c0:m16 |
def _get_ldp_fec_prefix_prefix(self): | return self.__ldp_fec_prefix_prefix<EOL> | Getter method for ldp_fec_prefix_prefix, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_prefix_prefix (container) | f336421:c0:m18 |
def _set_ldp_fec_prefix_prefix(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_prefix_prefix.ldp_fec_prefix_prefix, 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_fec_prefix_prefix = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ldp_fec_prefix_prefix, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_prefix_prefix (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_ldp_fec_prefix_prefix is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ldp_fec_prefix_prefix() directly. | f336421:c0:m19 |
def _get_peer_id(self): | return self.__peer_id<EOL> | Getter method for peer_id, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/vc/peer_id (inet:ipv4-address)
YANG Description: peer_id | f336422:c0:m3 |
def _set_peer_id(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__peer_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for peer_id, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/vc/peer_id (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_peer_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_peer_id() directly.
YANG Description: peer_id | f336422:c0:m4 |
def _get_peer_lblspc(self): | return self.__peer_lblspc<EOL> | Getter method for peer_lblspc, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/vc/peer_lblspc (uint32)
YANG Description: peer_lblspc | f336422:c0:m6 |
def _set_peer_lblspc(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.__peer_lblspc = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for peer_lblspc, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/vc/peer_lblspc (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_peer_lblspc is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_peer_lblspc() directly.
YANG Description: peer_lblspc | f336422:c0:m7 |
def _get_state(self): | return self.__state<EOL> | Getter method for state, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/vc/state (string)
YANG Description: state | f336422:c0:m9 |
def _set_state(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:state>", rest_name="<STR_LIT:state>", 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.__state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for state, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/vc/state (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_state() directly.
YANG Description: state | f336422:c0:m10 |
def _get_vc_id(self): | return self.__vc_id<EOL> | Getter method for vc_id, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/vc/vc_id (uint32)
YANG Description: vc_id | f336422:c0:m12 |
def _set_vc_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=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_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_id, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/vc/vc_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_id() directly.
YANG Description: vc_id | f336422:c0:m13 |
def _get_peer_vc_type(self): | return self.__peer_vc_type<EOL> | Getter method for peer_vc_type, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/vc/peer_vc_type (uint32)
YANG Description: peer_vc_type | f336422:c0:m15 |
def _set_peer_vc_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__peer_vc_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for peer_vc_type, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/vc/peer_vc_type (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_peer_vc_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_peer_vc_type() directly.
YANG Description: peer_vc_type | f336422:c0:m16 |
def _get_peer_fec_type(self): | return self.__peer_fec_type<EOL> | Getter method for peer_fec_type, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/vc/peer_fec_type (uint32)
YANG Description: peer_fec_type | f336422:c0:m18 |
def _set_peer_fec_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__peer_fec_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for peer_fec_type, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/vc/peer_fec_type (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_peer_fec_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_peer_fec_type() directly.
YANG Description: peer_fec_type | f336422:c0:m19 |
def _get_ingress(self): | return self.__ingress<EOL> | Getter method for ingress, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/vc/ingress (string)
YANG Description: ingress | f336422:c0:m21 |
def _set_ingress(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.__ingress = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ingress, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/vc/ingress (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_ingress is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ingress() directly.
YANG Description: ingress | f336422:c0:m22 |
def _get_egress(self): | return self.__egress<EOL> | Getter method for egress, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/vc/egress (string)
YANG Description: egress | f336422:c0:m24 |
def _set_egress(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.__egress = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for egress, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/vc/egress (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_egress is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_egress() directly.
YANG Description: egress | f336422:c0:m25 |
def _get_type(self): | return self.__type<EOL> | Getter method for type, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/type (uint8)
YANG Description: type | f336423:c0:m3 |
def _set_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), is_leaf=True, yang_name="<STR_LIT:type>", rest_name="<STR_LIT:type>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, 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.__type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for type, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/type (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_type() directly.
YANG Description: type | f336423:c0:m4 |
def _get_prefix_len(self): | return self.__prefix_len<EOL> | Getter method for prefix_len, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/prefix_len (uint8)
YANG Description: prefix_len | f336423:c0:m6 |
def _set_prefix_len(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.__prefix_len = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for prefix_len, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/prefix_len (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_prefix_len is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_prefix_len() directly.
YANG Description: prefix_len | f336423:c0:m7 |
def _get_inet_addr_type(self): | return self.__inet_addr_type<EOL> | Getter method for inet_addr_type, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/inet_addr_type (uint8)
YANG Description: inet_addr_type | f336423:c0:m9 |
def _set_inet_addr_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=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.__inet_addr_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for inet_addr_type, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/inet_addr_type (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_inet_addr_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_inet_addr_type() directly.
YANG Description: inet_addr_type | f336423:c0:m10 |
def _get_inet_addr_len(self): | return self.__inet_addr_len<EOL> | Getter method for inet_addr_len, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/inet_addr_len (uint8)
YANG Description: inet_addr_len | f336423:c0:m12 |
def _set_inet_addr_len(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.__inet_addr_len = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for inet_addr_len, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/inet_addr_len (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_inet_addr_len is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_inet_addr_len() directly.
YANG Description: inet_addr_len | f336423:c0:m13 |
def _get_inet_addr(self): | return self.__inet_addr<EOL> | Getter method for inet_addr, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/inet_addr (string)
YANG Description: inet_addr | f336423:c0:m15 |
def _set_inet_addr(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.__inet_addr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for inet_addr, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/inet_addr (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_inet_addr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_inet_addr() directly.
YANG Description: inet_addr | f336423:c0:m16 |
def _get_vc_ldp_peer_id(self): | return self.__vc_ldp_peer_id<EOL> | Getter method for vc_ldp_peer_id, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/vc_ldp_peer_id (string)
YANG Description: vc_ldp_peer_id | f336423:c0:m18 |
def _set_vc_ldp_peer_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=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.__vc_ldp_peer_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_ldp_peer_id, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/vc_ldp_peer_id (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_ldp_peer_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_ldp_peer_id() directly.
YANG Description: vc_ldp_peer_id | f336423:c0:m19 |
def _get_data_fec_type(self): | return self.__data_fec_type<EOL> | Getter method for data_fec_type, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/data_fec_type (uint8)
YANG Description: data_fec_type | f336423:c0:m21 |
def _set_data_fec_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=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.__data_fec_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for data_fec_type, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/data_fec_type (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_data_fec_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_data_fec_type() directly.
YANG Description: data_fec_type | f336423:c0:m22 |
def _get_vc_type(self): | return self.__vc_type<EOL> | Getter method for vc_type, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/vc_type (uint16)
YANG Description: vc_type | f336423:c0:m24 |
def _set_vc_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=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.__vc_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_type, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/vc_type (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_type() directly.
YANG Description: vc_type | f336423:c0:m25 |
def _get_vc_control_word_config(self): | return self.__vc_control_word_config<EOL> | Getter method for vc_control_word_config, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/vc_control_word_config (uint8)
YANG Description: vc_control_word_config | f336423:c0:m27 |
def _set_vc_control_word_config(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.__vc_control_word_config = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_control_word_config, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/vc_control_word_config (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_control_word_config is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_control_word_config() directly.
YANG Description: vc_control_word_config | f336423:c0:m28 |
def _get_vc_use_control_word(self): | return self.__vc_use_control_word<EOL> | Getter method for vc_use_control_word, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/vc_use_control_word (uint8)
YANG Description: vc_use_control_word | f336423:c0:m30 |
def _set_vc_use_control_word(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.__vc_use_control_word = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_use_control_word, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/vc_use_control_word (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_use_control_word is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_use_control_word() directly.
YANG Description: vc_use_control_word | f336423:c0:m31 |
def _get_vc_group_id(self): | return self.__vc_group_id<EOL> | Getter method for vc_group_id, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/vc_group_id (uint32)
YANG Description: vc_group_id | f336423:c0:m33 |
def _set_vc_group_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=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_group_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_group_id, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/vc_group_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_group_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_group_id() directly.
YANG Description: vc_group_id | f336423:c0:m34 |
def _get_vc_id(self): | return self.__vc_id<EOL> | Getter method for vc_id, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/vc_id (uint32)
YANG Description: vc_id | f336423:c0:m36 |
def _set_vc_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=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_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_id, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/vc_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_id() directly.
YANG Description: vc_id | f336423:c0:m37 |
def _get_vc_agi_offset(self): | return self.__vc_agi_offset<EOL> | Getter method for vc_agi_offset, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/vc_agi_offset (uint8)
YANG Description: vc_agi_offset | f336423:c0:m39 |
def _set_vc_agi_offset(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.__vc_agi_offset = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_agi_offset, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/vc_agi_offset (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_agi_offset is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_agi_offset() directly.
YANG Description: vc_agi_offset | f336423:c0:m40 |
def _get_vc_agi_len(self): | return self.__vc_agi_len<EOL> | Getter method for vc_agi_len, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/vc_agi_len (uint8)
YANG Description: vc_agi_len | f336423:c0:m42 |
def _set_vc_agi_len(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.__vc_agi_len = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_agi_len, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/vc_agi_len (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_agi_len is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_agi_len() directly.
YANG Description: vc_agi_len | f336423:c0:m43 |
def _get_vc_saii_offset(self): | return self.__vc_saii_offset<EOL> | Getter method for vc_saii_offset, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/vc_saii_offset (uint8)
YANG Description: vc_saii_offset | f336423:c0:m45 |
def _set_vc_saii_offset(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.__vc_saii_offset = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_saii_offset, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/vc_saii_offset (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_saii_offset is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_saii_offset() directly.
YANG Description: vc_saii_offset | f336423:c0:m46 |
def _get_vc_saii_len(self): | return self.__vc_saii_len<EOL> | Getter method for vc_saii_len, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/vc_saii_len (uint8)
YANG Description: vc_saii_len | f336423:c0:m48 |
def _set_vc_saii_len(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.__vc_saii_len = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_saii_len, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/vc_saii_len (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_saii_len is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_saii_len() directly.
YANG Description: vc_saii_len | f336423:c0:m49 |
def _get_vc_taii_offset(self): | return self.__vc_taii_offset<EOL> | Getter method for vc_taii_offset, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/vc_taii_offset (uint8)
YANG Description: vc_taii_offset | f336423:c0:m51 |
def _set_vc_taii_offset(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.__vc_taii_offset = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_taii_offset, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/vc_taii_offset (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_taii_offset is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_taii_offset() directly.
YANG Description: vc_taii_offset | f336423:c0:m52 |
def _get_vc_taii_len(self): | return self.__vc_taii_len<EOL> | Getter method for vc_taii_len, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/vc_taii_len (uint8)
YANG Description: vc_taii_len | f336423:c0:m54 |
def _set_vc_taii_len(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.__vc_taii_len = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_taii_len, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/vc_taii_len (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_taii_len is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_taii_len() directly.
YANG Description: vc_taii_len | f336423:c0:m55 |
def _get_vc_gen_id_size(self): | return self.__vc_gen_id_size<EOL> | Getter method for vc_gen_id_size, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/vc_gen_id_size (uint16)
YANG Description: vc_gen_id_size | f336423:c0:m57 |
def _set_vc_gen_id_size(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.__vc_gen_id_size = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_gen_id_size, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/vc_gen_id_size (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_gen_id_size is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_gen_id_size() directly.
YANG Description: vc_gen_id_size | f336423:c0:m58 |
def _get_vc_gen_id(self): | return self.__vc_gen_id<EOL> | Getter method for vc_gen_id, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/vc_gen_id (string)
YANG Description: vc_gen_id | f336423:c0:m60 |
def _set_vc_gen_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=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.__vc_gen_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_gen_id, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key/vc_gen_id (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_gen_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_gen_id() directly.
YANG Description: vc_gen_id | f336423:c0:m61 |
def _get_tot_no_of_vc_fec(self): | return self.__tot_no_of_vc_fec<EOL> | Getter method for tot_no_of_vc_fec, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/tot_no_of_vc_fec (uint32)
YANG Description: tot_no_of_vc_fec | f336424:c0:m3 |
def _set_tot_no_of_vc_fec(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.__tot_no_of_vc_fec = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tot_no_of_vc_fec, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/tot_no_of_vc_fec (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_tot_no_of_vc_fec is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tot_no_of_vc_fec() directly.
YANG Description: tot_no_of_vc_fec | f336424:c0:m4 |
def _get_tot_no_of_vc_fec_installed(self): | return self.__tot_no_of_vc_fec_installed<EOL> | Getter method for tot_no_of_vc_fec_installed, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/tot_no_of_vc_fec_installed (uint32)
YANG Description: tot_no_of_vc_fec_installed | f336424:c0:m6 |
def _set_tot_no_of_vc_fec_installed(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.__tot_no_of_vc_fec_installed = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for tot_no_of_vc_fec_installed, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/tot_no_of_vc_fec_installed (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_tot_no_of_vc_fec_installed is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tot_no_of_vc_fec_installed() directly.
YANG Description: tot_no_of_vc_fec_installed | f336424:c0:m7 |
def _get_vc(self): | return self.__vc<EOL> | Getter method for vc, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/vc (list) | f336424:c0:m9 |
def _set_vc(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.vc, 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 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/vc (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc() directly. | f336424:c0:m10 |
def _get_key(self): | return self.__key<EOL> | Getter method for key, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key (container) | f336424:c0:m12 |
def _set_key(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=key.key, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT:key>", rest_name="<STR_LIT:key>", 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.__key = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for key, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcs/key (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_key is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_key() directly. | f336424:c0:m13 |
def _get_local_ldp_id(self): | return self.__local_ldp_id<EOL> | Getter method for local_ldp_id, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcid/vc_downstream/local_ldp_id (inet:ipv4-address)
YANG Description: prefix_local_ldp_id_dw | f336425:c0:m3 |
def _set_local_ldp_id(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__local_ldp_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for local_ldp_id, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcid/vc_downstream/local_ldp_id (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_local_ldp_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_local_ldp_id() directly.
YANG Description: prefix_local_ldp_id_dw | f336425:c0:m4 |
def _get_local_ldp_lblspc(self): | return self.__local_ldp_lblspc<EOL> | Getter method for local_ldp_lblspc, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcid/vc_downstream/local_ldp_lblspc (uint32)
YANG Description: prefix_local_ldp_lblspc_dw | f336425:c0:m6 |
def _set_local_ldp_lblspc(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.__local_ldp_lblspc = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for local_ldp_lblspc, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcid/vc_downstream/local_ldp_lblspc (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_local_ldp_lblspc is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_local_ldp_lblspc() directly.
YANG Description: prefix_local_ldp_lblspc_dw | f336425:c0:m7 |
def _get_peer_ldp_id(self): | return self.__peer_ldp_id<EOL> | Getter method for peer_ldp_id, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcid/vc_downstream/peer_ldp_id (inet:ipv4-address)
YANG Description: prefix_peer_ldp_id_dw | f336425:c0:m9 |
def _set_peer_ldp_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.__peer_ldp_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for peer_ldp_id, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcid/vc_downstream/peer_ldp_id (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_peer_ldp_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_peer_ldp_id() directly.
YANG Description: prefix_peer_ldp_id_dw | f336425:c0:m10 |
def _get_peer_ldp_lblspc(self): | return self.__peer_ldp_lblspc<EOL> | Getter method for peer_ldp_lblspc, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcid/vc_downstream/peer_ldp_lblspc (uint32)
YANG Description: prefix_peer_ldp_lblspc_dw | f336425:c0:m12 |
def _set_peer_ldp_lblspc(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.__peer_ldp_lblspc = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for peer_ldp_lblspc, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcid/vc_downstream/peer_ldp_lblspc (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_peer_ldp_lblspc is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_peer_ldp_lblspc() directly.
YANG Description: prefix_peer_ldp_lblspc_dw | f336425:c0:m13 |
def _get_label(self): | return self.__label<EOL> | Getter method for label, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcid/vc_downstream/label (uint32)
YANG Description: prefix_label_dw | f336425:c0:m15 |
def _set_label(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:label>", rest_name="<STR_LIT:label>", 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.__label = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for label, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcid/vc_downstream/label (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_label is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_label() directly.
YANG Description: prefix_label_dw | f336425:c0:m16 |
def _get_state(self): | return self.__state<EOL> | Getter method for state, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcid/vc_downstream/state (string)
YANG Description: prefix state dw | f336425:c0:m18 |
def _set_state(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:state>", rest_name="<STR_LIT:state>", 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.__state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for state, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcid/vc_downstream/state (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_state() directly.
YANG Description: prefix state dw | f336425:c0:m19 |
def _get_fec_filtered_state(self): | return self.__fec_filtered_state<EOL> | Getter method for fec_filtered_state, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcid/vc_downstream/fec_filtered_state (uint32)
YANG Description: fec_prefix_fec_filtered_state_dw | f336425:c0:m21 |
def _set_fec_filtered_state(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.__fec_filtered_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fec_filtered_state, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcid/vc_downstream/fec_filtered_state (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_fec_filtered_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fec_filtered_state() directly.
YANG Description: fec_prefix_fec_filtered_state_dw | f336425:c0:m22 |
def _get_fec_stale(self): | return self.__fec_stale<EOL> | Getter method for fec_stale, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcid/vc_downstream/fec_stale (uint32)
YANG Description: prefix_fec_stale_dw | f336425:c0:m24 |
def _set_fec_stale(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.__fec_stale = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fec_stale, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcid/vc_downstream/fec_stale (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_fec_stale is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fec_stale() directly.
YANG Description: prefix_fec_stale_dw | f336425:c0:m25 |
def _get_feccb(self): | return self.__feccb<EOL> | Getter method for feccb, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcid/vc_downstream/feccb (uint32)
YANG Description: prefix_feccb_dw | f336425:c0:m27 |
def _set_feccb(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.__feccb = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for feccb, mapped from YANG variable /mpls_state/ldp/fec/ldp_fec_vcid/vc_downstream/feccb (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_feccb is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_feccb() directly.
YANG Description: prefix_feccb_dw | f336425:c0:m28 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.