signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_cluster_id(self): | return self.__cluster_id<EOL> | Getter method for cluster_id, mapped from YANG variable /bgp_state/summary/evpn/cluster_id (uint32)
YANG Description: Cluster Identifier | f336146:c0:m15 |
def _set_cluster_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.__cluster_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cluster_id, mapped from YANG variable /bgp_state/summary/evpn/cluster_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_cluster_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cluster_id() directly.
YANG Description: Cluster Identifier | f336146:c0:m16 |
def _get_max_ecmp_paths(self): | return self.__max_ecmp_paths<EOL> | Getter method for max_ecmp_paths, mapped from YANG variable /bgp_state/summary/evpn/max_ecmp_paths (uint32)
YANG Description: Maximum number of IP ECMP Paths supported for Load Sharing | f336146:c0:m18 |
def _set_max_ecmp_paths(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.__max_ecmp_paths = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for max_ecmp_paths, mapped from YANG variable /bgp_state/summary/evpn/max_ecmp_paths (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_max_ecmp_paths is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_max_ecmp_paths() directly.
YANG Description: Maximum number of IP ECMP Paths supported for Load Sharing | f336146:c0:m19 |
def _get_max_bgp_routes_in_rtm(self): | return self.__max_bgp_routes_in_rtm<EOL> | Getter method for max_bgp_routes_in_rtm, mapped from YANG variable /bgp_state/summary/evpn/max_bgp_routes_in_rtm (uint32)
YANG Description: Maximum number of BGP routes allowed in RTM | f336146:c0:m21 |
def _set_max_bgp_routes_in_rtm(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.__max_bgp_routes_in_rtm = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for max_bgp_routes_in_rtm, mapped from YANG variable /bgp_state/summary/evpn/max_bgp_routes_in_rtm (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_max_bgp_routes_in_rtm is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_max_bgp_routes_in_rtm() directly.
YANG Description: Maximum number of BGP routes allowed in RTM | f336146:c0:m22 |
def _get_num_neighbor_configured(self): | return self.__num_neighbor_configured<EOL> | Getter method for num_neighbor_configured, mapped from YANG variable /bgp_state/summary/evpn/num_neighbor_configured (uint32)
YANG Description: Number of neighbors configured | f336146:c0:m24 |
def _set_num_neighbor_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=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__num_neighbor_configured = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for num_neighbor_configured, mapped from YANG variable /bgp_state/summary/evpn/num_neighbor_configured (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_num_neighbor_configured is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_num_neighbor_configured() directly.
YANG Description: Number of neighbors configured | f336146:c0:m25 |
def _get_num_neighbor_up(self): | return self.__num_neighbor_up<EOL> | Getter method for num_neighbor_up, mapped from YANG variable /bgp_state/summary/evpn/num_neighbor_up (uint32)
YANG Description: Number of neighbors up | f336146:c0:m27 |
def _set_num_neighbor_up(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__num_neighbor_up = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for num_neighbor_up, mapped from YANG variable /bgp_state/summary/evpn/num_neighbor_up (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_num_neighbor_up is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_num_neighbor_up() directly.
YANG Description: Number of neighbors up | f336146:c0:m28 |
def _get_num_routes_installed(self): | return self.__num_routes_installed<EOL> | Getter method for num_routes_installed, mapped from YANG variable /bgp_state/summary/evpn/num_routes_installed (uint32)
YANG Description: Number of routes installed | f336146:c0:m30 |
def _set_num_routes_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.__num_routes_installed = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for num_routes_installed, mapped from YANG variable /bgp_state/summary/evpn/num_routes_installed (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_num_routes_installed is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_num_routes_installed() directly.
YANG Description: Number of routes installed | f336146:c0:m31 |
def _get_bytes_used_num_routes_installed(self): | return self.__bytes_used_num_routes_installed<EOL> | Getter method for bytes_used_num_routes_installed, mapped from YANG variable /bgp_state/summary/evpn/bytes_used_num_routes_installed (uint32)
YANG Description: Bytes used to store number of routes installed | f336146:c0:m33 |
def _set_bytes_used_num_routes_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.__bytes_used_num_routes_installed = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bytes_used_num_routes_installed, mapped from YANG variable /bgp_state/summary/evpn/bytes_used_num_routes_installed (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_bytes_used_num_routes_installed is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bytes_used_num_routes_installed() directly.
YANG Description: Bytes used to store number of routes installed | f336146:c0:m34 |
def _get_num_routes_adv_all_neighbors(self): | return self.__num_routes_adv_all_neighbors<EOL> | Getter method for num_routes_adv_all_neighbors, mapped from YANG variable /bgp_state/summary/evpn/num_routes_adv_all_neighbors (uint32)
YANG Description: Number of routes advertised to all neighbors | f336146:c0:m36 |
def _set_num_routes_adv_all_neighbors(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__num_routes_adv_all_neighbors = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for num_routes_adv_all_neighbors, mapped from YANG variable /bgp_state/summary/evpn/num_routes_adv_all_neighbors (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_num_routes_adv_all_neighbors is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_num_routes_adv_all_neighbors() directly.
YANG Description: Number of routes advertised to all neighbors | f336146:c0:m37 |
def _get_num_routes_adv_all_neighbors_rib_out_entries(self): | return self.__num_routes_adv_all_neighbors_rib_out_entries<EOL> | Getter method for num_routes_adv_all_neighbors_rib_out_entries, mapped from YANG variable /bgp_state/summary/evpn/num_routes_adv_all_neighbors_rib_out_entries (uint32)
YANG Description: Number of routes advertised to all neighbors(RIB out entries) | f336146:c0:m39 |
def _set_num_routes_adv_all_neighbors_rib_out_entries(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__num_routes_adv_all_neighbors_rib_out_entries = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for num_routes_adv_all_neighbors_rib_out_entries, mapped from YANG variable /bgp_state/summary/evpn/num_routes_adv_all_neighbors_rib_out_entries (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_num_routes_adv_all_neighbors_rib_out_entries is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_num_routes_adv_all_neighbors_rib_out_entries() directly.
YANG Description: Number of routes advertised to all neighbors(RIB out entries) | f336146:c0:m40 |
def _get_bytes_used_num_routes_adv_all_neighbors(self): | return self.__bytes_used_num_routes_adv_all_neighbors<EOL> | Getter method for bytes_used_num_routes_adv_all_neighbors, mapped from YANG variable /bgp_state/summary/evpn/bytes_used_num_routes_adv_all_neighbors (uint32)
YANG Description: Bytes used to store number of routes advertised to all neighbors | f336146:c0:m42 |
def _set_bytes_used_num_routes_adv_all_neighbors(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.__bytes_used_num_routes_adv_all_neighbors = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bytes_used_num_routes_adv_all_neighbors, mapped from YANG variable /bgp_state/summary/evpn/bytes_used_num_routes_adv_all_neighbors (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_bytes_used_num_routes_adv_all_neighbors is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bytes_used_num_routes_adv_all_neighbors() directly.
YANG Description: Bytes used to store number of routes advertised to all neighbors | f336146:c0:m43 |
def _get_num_attr_entries_installed(self): | return self.__num_attr_entries_installed<EOL> | Getter method for num_attr_entries_installed, mapped from YANG variable /bgp_state/summary/evpn/num_attr_entries_installed (uint32)
YANG Description: Number of attribute entries installed | f336146:c0:m45 |
def _set_num_attr_entries_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.__num_attr_entries_installed = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for num_attr_entries_installed, mapped from YANG variable /bgp_state/summary/evpn/num_attr_entries_installed (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_num_attr_entries_installed is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_num_attr_entries_installed() directly.
YANG Description: Number of attribute entries installed | f336146:c0:m46 |
def _get_bytes_used_num_attr_entries_installed(self): | return self.__bytes_used_num_attr_entries_installed<EOL> | Getter method for bytes_used_num_attr_entries_installed, mapped from YANG variable /bgp_state/summary/evpn/bytes_used_num_attr_entries_installed (uint32)
YANG Description: Bytes used to store number of attribute entries installed | f336146:c0:m48 |
def _set_bytes_used_num_attr_entries_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.__bytes_used_num_attr_entries_installed = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for bytes_used_num_attr_entries_installed, mapped from YANG variable /bgp_state/summary/evpn/bytes_used_num_attr_entries_installed (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_bytes_used_num_attr_entries_installed is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_bytes_used_num_attr_entries_installed() directly.
YANG Description: Bytes used to store number of attribute entries installed | f336146:c0:m49 |
def _get_update_msgs_dropped(self): | return self.__update_msgs_dropped<EOL> | Getter method for update_msgs_dropped, mapped from YANG variable /bgp_state/summary/evpn/update_msgs_dropped (uint32)
YANG Description: Update Messages dropped (no Memory for Attribute Entries) | f336146:c0:m51 |
def _set_update_msgs_dropped(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.__update_msgs_dropped = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for update_msgs_dropped, mapped from YANG variable /bgp_state/summary/evpn/update_msgs_dropped (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_update_msgs_dropped is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_update_msgs_dropped() directly.
YANG Description: Update Messages dropped (no Memory for Attribute Entries) | f336146:c0:m52 |
def _get_oom_received_routes(self): | return self.__oom_received_routes<EOL> | Getter method for oom_received_routes, mapped from YANG variable /bgp_state/summary/evpn/oom_received_routes (uint32)
YANG Description: Out of memory count for Received Routes(NLRI) | f336146:c0:m54 |
def _set_oom_received_routes(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.__oom_received_routes = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for oom_received_routes, mapped from YANG variable /bgp_state/summary/evpn/oom_received_routes (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_oom_received_routes is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_oom_received_routes() directly.
YANG Description: Out of memory count for Received Routes(NLRI) | f336146:c0:m55 |
def _get_oom_outgoing_routes(self): | return self.__oom_outgoing_routes<EOL> | Getter method for oom_outgoing_routes, mapped from YANG variable /bgp_state/summary/evpn/oom_outgoing_routes (uint32)
YANG Description: Out of memory count for outgoing routes(RIB-OUT) | f336146:c0:m57 |
def _set_oom_outgoing_routes(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.__oom_outgoing_routes = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for oom_outgoing_routes, mapped from YANG variable /bgp_state/summary/evpn/oom_outgoing_routes (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_oom_outgoing_routes is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_oom_outgoing_routes() directly.
YANG Description: Out of memory count for outgoing routes(RIB-OUT) | f336146:c0:m58 |
def _get_oom_attribute_entries(self): | return self.__oom_attribute_entries<EOL> | Getter method for oom_attribute_entries, mapped from YANG variable /bgp_state/summary/evpn/oom_attribute_entries (uint32)
YANG Description: Out of memory count for attribute entries | f336146:c0:m60 |
def _set_oom_attribute_entries(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.__oom_attribute_entries = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for oom_attribute_entries, mapped from YANG variable /bgp_state/summary/evpn/oom_attribute_entries (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_oom_attribute_entries is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_oom_attribute_entries() directly.
YANG Description: Out of memory count for attribute entries | f336146:c0:m61 |
def _get_confederation_peers(self): | return self.__confederation_peers<EOL> | Getter method for confederation_peers, mapped from YANG variable /bgp_state/summary/evpn/confederation_peers (uint32)
YANG Description: Confederation Peers | f336146:c0:m63 |
def _set_confederation_peers(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)), is_leaf=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__confederation_peers = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for confederation_peers, mapped from YANG variable /bgp_state/summary/evpn/confederation_peers (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_confederation_peers is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_confederation_peers() directly.
YANG Description: Confederation Peers | f336146:c0:m64 |
def _get_prefix_list(self): | return self.__prefix_list<EOL> | Getter method for prefix_list, mapped from YANG variable /ip/hide_prefix_holder/prefix_list (list)
YANG Description: IP address prefix list. | f336147:c0:m3 |
def _set_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=YANGListType("<STR_LIT>",prefix_list.prefix_list, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__prefix_list = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for prefix_list, mapped from YANG variable /ip/hide_prefix_holder/prefix_list (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_prefix_list is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_prefix_list() directly.
YANG Description: IP address prefix list. | f336147:c0:m4 |
def _get_as_path(self): | return self.__as_path<EOL> | Getter method for as_path, mapped from YANG variable /ip/hide_as_path_holder/as_path (container) | f336148:c0:m3 |
def _set_as_path(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=as_path.as_path, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__as_path = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for as_path, mapped from YANG variable /ip/hide_as_path_holder/as_path (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_as_path is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_as_path() directly. | f336148:c0:m4 |
def _get_community_list(self): | return self.__community_list<EOL> | Getter method for community_list, mapped from YANG variable /ip/hide_community_list_holder/community_list (container) | f336149:c0:m3 |
def _set_community_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=community_list.community_list, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__community_list = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for community_list, mapped from YANG variable /ip/hide_community_list_holder/community_list (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_community_list is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_community_list() directly. | f336149:c0:m4 |
def _get_vc_peer_address(self): | return self.__vc_peer_address<EOL> | Getter method for vc_peer_address, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_peer_address (inet:ipv4-address)
YANG Description: peer address name | f336150:c0:m3 |
def _set_vc_peer_address(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.__vc_peer_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_peer_address, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_peer_address (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_peer_address is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_peer_address() directly.
YANG Description: peer address name | f336150:c0:m4 |
def _get_vc_peer_state(self): | return self.__vc_peer_state<EOL> | Getter method for vc_peer_state, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_peer_state (string)
YANG Description: peer state | f336150:c0:m6 |
def _set_vc_peer_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>", 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_peer_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_peer_state, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_peer_state (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_peer_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_peer_state() directly.
YANG Description: peer state | f336150:c0:m7 |
def _get_vc_peer_uptime(self): | return self.__vc_peer_uptime<EOL> | Getter method for vc_peer_uptime, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_peer_uptime (string)
YANG Description: peer uptime | f336150:c0:m9 |
def _set_vc_peer_uptime(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_peer_uptime = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_peer_uptime, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_peer_uptime (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_peer_uptime is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_peer_uptime() directly.
YANG Description: peer uptime | f336150:c0:m10 |
def _get_vc_peer_load_balance(self): | return self.__vc_peer_load_balance<EOL> | Getter method for vc_peer_load_balance, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_peer_load_balance (boolean)
YANG Description: peer load balance | f336150:c0:m12 |
def _set_vc_peer_load_balance(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.__vc_peer_load_balance = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_peer_load_balance, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_peer_load_balance (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_peer_load_balance is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_peer_load_balance() directly.
YANG Description: peer load balance | f336150:c0:m13 |
def _get_vc_peer_cos_enabled(self): | return self.__vc_peer_cos_enabled<EOL> | Getter method for vc_peer_cos_enabled, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_peer_cos_enabled (boolean)
YANG Description: peer cos enabled | f336150:c0:m15 |
def _set_vc_peer_cos_enabled(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.__vc_peer_cos_enabled = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_peer_cos_enabled, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_peer_cos_enabled (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_peer_cos_enabled is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_peer_cos_enabled() directly.
YANG Description: peer cos enabled | f336150:c0:m16 |
def _get_vc_peer_cos_value(self): | return self.__vc_peer_cos_value<EOL> | Getter method for vc_peer_cos_value, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_peer_cos_value (uint8)
YANG Description: peer cos value | f336150:c0:m18 |
def _set_vc_peer_cos_value(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_peer_cos_value = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_peer_cos_value, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_peer_cos_value (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_peer_cos_value is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_peer_cos_value() directly.
YANG Description: peer cos value | f336150:c0:m19 |
def _get_vc_ldp_tnnl_in_use(self): | return self.__vc_ldp_tnnl_in_use<EOL> | Getter method for vc_ldp_tnnl_in_use, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_ldp_tnnl_in_use (string)
YANG Description: peer tunnel in use | f336150:c0:m21 |
def _set_vc_ldp_tnnl_in_use(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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_tnnl_in_use = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_ldp_tnnl_in_use, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_ldp_tnnl_in_use (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_ldp_tnnl_in_use is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_ldp_tnnl_in_use() directly.
YANG Description: peer tunnel in use | f336150:c0:m22 |
def _get_vc_local_label(self): | return self.__vc_local_label<EOL> | Getter method for vc_local_label, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_local_label (uint32)
YANG Description: vc_local_label | f336150:c0:m24 |
def _set_vc_local_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>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__vc_local_label = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_local_label, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_local_label (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_local_label is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_local_label() directly.
YANG Description: vc_local_label | f336150:c0:m25 |
def _get_vc_remote_label(self): | return self.__vc_remote_label<EOL> | Getter method for vc_remote_label, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_remote_label (uint32)
YANG Description: vc_remote_label | f336150:c0:m27 |
def _set_vc_remote_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>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__vc_remote_label = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_remote_label, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_remote_label (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_remote_label is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_remote_label() directly.
YANG Description: vc_remote_label | f336150:c0:m28 |
def _get_vc_local_mtu(self): | return self.__vc_local_mtu<EOL> | Getter method for vc_local_mtu, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_local_mtu (uint32)
YANG Description: vc_local_mtu | f336150:c0:m30 |
def _set_vc_local_mtu(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__vc_local_mtu = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_local_mtu, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_local_mtu (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_local_mtu is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_local_mtu() directly.
YANG Description: vc_local_mtu | f336150:c0:m31 |
def _get_vc_remote_mtu(self): | return self.__vc_remote_mtu<EOL> | Getter method for vc_remote_mtu, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_remote_mtu (uint32)
YANG Description: vc_remote_mtu | f336150:c0:m33 |
def _set_vc_remote_mtu(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__vc_remote_mtu = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_remote_mtu, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_remote_mtu (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_remote_mtu is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_remote_mtu() directly.
YANG Description: vc_remote_mtu | f336150:c0:m34 |
def _get_vc_local_type(self): | return self.__vc_local_type<EOL> | Getter method for vc_local_type, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_local_type (uint32)
YANG Description: vc_local_type | f336150:c0:m36 |
def _set_vc_local_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__vc_local_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_local_type, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_local_type (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_local_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_local_type() directly.
YANG Description: vc_local_type | f336150:c0:m37 |
def _get_vc_remote_type(self): | return self.__vc_remote_type<EOL> | Getter method for vc_remote_type, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_remote_type (uint32)
YANG Description: vc_remote_type | f336150:c0:m39 |
def _set_vc_remote_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__vc_remote_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_remote_type, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_remote_type (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_remote_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_remote_type() directly.
YANG Description: vc_remote_type | f336150:c0:m40 |
def _get_vc_local_pw_status(self): | return self.__vc_local_pw_status<EOL> | Getter method for vc_local_pw_status, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_local_pw_status (string)
YANG Description: vc local pw status | f336150:c0:m42 |
def _set_vc_local_pw_status(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__vc_local_pw_status = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_local_pw_status, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_local_pw_status (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_local_pw_status is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_local_pw_status() directly.
YANG Description: vc local pw status | f336150:c0:m43 |
def _get_vc_remote_pw_status(self): | return self.__vc_remote_pw_status<EOL> | Getter method for vc_remote_pw_status, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_remote_pw_status (string)
YANG Description: vc remote pw status | f336150:c0:m45 |
def _set_vc_remote_pw_status(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__vc_remote_pw_status = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_remote_pw_status, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_remote_pw_status (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_remote_pw_status is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_remote_pw_status() directly.
YANG Description: vc remote pw status | f336150:c0:m46 |
def _get_vc_local_flow_label_tx(self): | return self.__vc_local_flow_label_tx<EOL> | Getter method for vc_local_flow_label_tx, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_local_flow_label_tx (boolean)
YANG Description: vc local flow label Tx | f336150:c0:m48 |
def _set_vc_local_flow_label_tx(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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.__vc_local_flow_label_tx = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_local_flow_label_tx, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_local_flow_label_tx (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_local_flow_label_tx is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_local_flow_label_tx() directly.
YANG Description: vc local flow label Tx | f336150:c0:m49 |
def _get_vc_local_flow_label_rx(self): | return self.__vc_local_flow_label_rx<EOL> | Getter method for vc_local_flow_label_rx, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_local_flow_label_rx (boolean)
YANG Description: vc local flow label Rx | f336150:c0:m51 |
def _set_vc_local_flow_label_rx(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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.__vc_local_flow_label_rx = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_local_flow_label_rx, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_local_flow_label_rx (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_local_flow_label_rx is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_local_flow_label_rx() directly.
YANG Description: vc local flow label Rx | f336150:c0:m52 |
def _get_vc_remote_flow_label_tx(self): | return self.__vc_remote_flow_label_tx<EOL> | Getter method for vc_remote_flow_label_tx, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_remote_flow_label_tx (boolean)
YANG Description: vc remote flow label Tx | f336150:c0:m54 |
def _set_vc_remote_flow_label_tx(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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.__vc_remote_flow_label_tx = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_remote_flow_label_tx, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_remote_flow_label_tx (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_remote_flow_label_tx is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_remote_flow_label_tx() directly.
YANG Description: vc remote flow label Tx | f336150:c0:m55 |
def _get_vc_remote_flow_label_rx(self): | return self.__vc_remote_flow_label_rx<EOL> | Getter method for vc_remote_flow_label_rx, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_remote_flow_label_rx (boolean)
YANG Description: vc remote flow label Rx | f336150:c0:m57 |
def _set_vc_remote_flow_label_rx(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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.__vc_remote_flow_label_rx = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_remote_flow_label_rx, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_remote_flow_label_rx (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_remote_flow_label_rx is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_remote_flow_label_rx() directly.
YANG Description: vc remote flow label Rx | f336150:c0:m58 |
def _get_vc_local_control_word(self): | return self.__vc_local_control_word<EOL> | Getter method for vc_local_control_word, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_local_control_word (boolean)
YANG Description: vc local control word | f336150:c0:m60 |
def _set_vc_local_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=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.__vc_local_control_word = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_local_control_word, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_local_control_word (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_local_control_word is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_local_control_word() directly.
YANG Description: vc local control word | f336150:c0:m61 |
def _get_vc_remote_control_word(self): | return self.__vc_remote_control_word<EOL> | Getter method for vc_remote_control_word, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_remote_control_word (boolean)
YANG Description: vc remote control word | f336150:c0:m63 |
def _set_vc_remote_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=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.__vc_remote_control_word = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_remote_control_word, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_remote_control_word (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_remote_control_word is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_remote_control_word() directly.
YANG Description: vc remote control word | f336150:c0:m64 |
def _get_vc_proto_tnnl(self): | return self.__vc_proto_tnnl<EOL> | Getter method for vc_proto_tnnl, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_proto_tnnl (list)
YANG Description: VC proto tnnl | f336150:c0:m66 |
def _set_vc_proto_tnnl(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",vc_proto_tnnl.vc_proto_tnnl, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__vc_proto_tnnl = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_proto_tnnl, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_proto_tnnl (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_proto_tnnl is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_proto_tnnl() directly.
YANG Description: VC proto tnnl | f336150:c0:m67 |
def _get_vc_assigned_lsp(self): | return self.__vc_assigned_lsp<EOL> | Getter method for vc_assigned_lsp, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_assigned_lsp (list)
YANG Description: VC assigned lsp | f336150:c0:m69 |
def _set_vc_assigned_lsp(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",vc_assigned_lsp.vc_assigned_lsp, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__vc_assigned_lsp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vc_assigned_lsp, mapped from YANG variable /bd_vc_peer_state/bd_vc_peer_data/vc_assigned_lsp (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_vc_assigned_lsp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vc_assigned_lsp() directly.
YANG Description: VC assigned lsp | f336150:c0:m70 |
def _get_agent_addr_type(self): | return self.__agent_addr_type<EOL> | Getter method for agent_addr_type, mapped from YANG variable /sflow/agent_address/agent_addr_type (ip-addr-type)
YANG Description: Agent address type (ipv4/ipv6) to use. | f336151:c0:m3 |
def _set_agent_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=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__agent_addr_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for agent_addr_type, mapped from YANG variable /sflow/agent_address/agent_addr_type (ip-addr-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_agent_addr_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_agent_addr_type() directly.
YANG Description: Agent address type (ipv4/ipv6) to use. | f336151:c0:m4 |
def _get_agent_interface_type(self): | return self.__agent_interface_type<EOL> | Getter method for agent_interface_type, mapped from YANG variable /sflow/agent_address/agent_interface_type (source-interface-type)
YANG Description: Type of the interface. | f336151:c0:m6 |
def _set_agent_interface_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:8>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__agent_interface_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for agent_interface_type, mapped from YANG variable /sflow/agent_address/agent_interface_type (source-interface-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_agent_interface_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_agent_interface_type() directly.
YANG Description: Type of the interface. | f336151:c0:m7 |
def _get_agent_interface_name(self): | return self.__agent_interface_name<EOL> | Getter method for agent_interface_name, mapped from YANG variable /sflow/agent_address/agent_interface_name (union)
YANG Description: The Interface value. The interface value is always
interpreted within the context of the value of
'interface-type' leaf:
interface-type interface-name
----------------- --------------------
ethernet slot/port
loopback Loopback ID
ve ve ID
management 0=Chassis-IP 1=Active-MM-IP
The value of an 'interface-name' must always be
consistent with the value of the associated
'interface-type'. Attempts to set an interface-name
to a value inconsistent with the associated
'interface-type' must fail with an error. | f336151:c0:m9 |
def _set_agent_interface_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=[RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>', '<STR_LIT>': [u'<STR_LIT>']}),RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}),RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}),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, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__agent_interface_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for agent_interface_name, mapped from YANG variable /sflow/agent_address/agent_interface_name (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_agent_interface_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_agent_interface_name() directly.
YANG Description: The Interface value. The interface value is always
interpreted within the context of the value of
'interface-type' leaf:
interface-type interface-name
----------------- --------------------
ethernet slot/port
loopback Loopback ID
ve ve ID
management 0=Chassis-IP 1=Active-MM-IP
The value of an 'interface-name' must always be
consistent with the value of the associated
'interface-type'. Attempts to set an interface-name
to a value inconsistent with the associated
'interface-type' must fail with an error. | f336151:c0:m10 |
def _get_enable(self): | return self.__enable<EOL> | Getter method for enable, mapped from YANG variable /sflow/enable (empty) | f336152:c0:m3 |
def _set_enable(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__enable = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for enable, mapped from YANG variable /sflow/enable (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_enable is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_enable() directly. | f336152:c0:m4 |
def _get_null0_sampling(self): | return self.__null0_sampling<EOL> | Getter method for null0_sampling, mapped from YANG variable /sflow/null0_sampling (empty) | f336152:c0:m6 |
def _set_null0_sampling(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__null0_sampling = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for null0_sampling, mapped from YANG variable /sflow/null0_sampling (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_null0_sampling is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_null0_sampling() directly. | f336152:c0:m7 |
def _get_collector_vrf(self): | return self.__collector_vrf<EOL> | Getter method for collector_vrf, mapped from YANG variable /sflow/collector_vrf (common-def:vrf-name) | f336152:c0:m9 |
def _set_collector_vrf(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>', '<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__collector_vrf = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for collector_vrf, mapped from YANG variable /sflow/collector_vrf (common-def:vrf-name)
If this variable is read-only (config: false) in the
source YANG file, then _set_collector_vrf is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_collector_vrf() directly. | f336152:c0:m10 |
def _get_agent_address(self): | return self.__agent_address<EOL> | Getter method for agent_address, mapped from YANG variable /sflow/agent_address (container) | f336152:c0:m12 |
def _set_agent_address(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=agent_address.agent_address, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__agent_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for agent_address, mapped from YANG variable /sflow/agent_address (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_agent_address is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_agent_address() directly. | f336152:c0:m13 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.