signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_port_type(self): | return self.__port_type<EOL> | Getter method for port_type, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/port_type (string) | f336738:c0:m21 |
def _set_port_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=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.__port_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for port_type, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/port_type (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_port_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port_type() directly. | f336738:c0:m22 |
def _get_vlan_info(self): | return self.__vlan_info<EOL> | Getter method for vlan_info, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/vlan_info (uint16) | f336738:c0:m24 |
def _set_vlan_info(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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.__vlan_info = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vlan_info, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/vlan_info (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_vlan_info is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vlan_info() directly. | f336738:c0:m25 |
def _get_dri(self): | return self.__dri<EOL> | Getter method for dri, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/dri (int32) | f336738:c0:m27 |
def _set_dri(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.__dri = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dri, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/dri (int32)
If this variable is read-only (config: false) in the
source YANG file, then _set_dri is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dri() directly. | f336738:c0:m28 |
def _get_arto(self): | return self.__arto<EOL> | Getter method for arto, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/arto (uint16) | f336738:c0:m30 |
def _set_arto(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.__arto = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for arto, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/arto (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_arto is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_arto() directly. | f336738:c0:m31 |
def _get_pmpd(self): | return self.__pmpd<EOL> | Getter method for pmpd, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/pmpd (string) | f336738:c0:m33 |
def _set_pmpd(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.__pmpd = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for pmpd, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/pmpd (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_pmpd is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_pmpd() directly. | f336738:c0:m34 |
def _get_annouce_interval(self): | return self.__annouce_interval<EOL> | Getter method for annouce_interval, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/annouce_interval (int32) | f336738:c0:m36 |
def _set_annouce_interval(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__annouce_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for annouce_interval, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/annouce_interval (int32)
If this variable is read-only (config: false) in the
source YANG file, then _set_annouce_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_annouce_interval() directly. | f336738:c0:m37 |
def _get_sync_interval(self): | return self.__sync_interval<EOL> | Getter method for sync_interval, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/sync_interval (int32) | f336738:c0:m39 |
def _set_sync_interval(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__sync_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for sync_interval, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/sync_interval (int32)
If this variable is read-only (config: false) in the
source YANG file, then _set_sync_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sync_interval() directly. | f336738:c0:m40 |
def _get_delay_mechanism(self): | return self.__delay_mechanism<EOL> | Getter method for delay_mechanism, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/delay_mechanism (string) | f336738:c0:m42 |
def _set_delay_mechanism(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.__delay_mechanism = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for delay_mechanism, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/delay_mechanism (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_delay_mechanism is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_delay_mechanism() directly. | f336738:c0:m43 |
def _get_transport_mode(self): | return self.__transport_mode<EOL> | Getter method for transport_mode, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/transport_mode (string) | f336738:c0:m45 |
def _set_transport_mode(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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.__transport_mode = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for transport_mode, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/transport_mode (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_transport_mode is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_transport_mode() directly. | f336738:c0:m46 |
def _get_announce_msg_sent(self): | return self.__announce_msg_sent<EOL> | Getter method for announce_msg_sent, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/announce_msg_sent (uint32) | f336738:c0:m48 |
def _set_announce_msg_sent(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.__announce_msg_sent = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for announce_msg_sent, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/announce_msg_sent (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_announce_msg_sent is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_announce_msg_sent() directly. | f336738:c0:m49 |
def _get_announce_msg_received(self): | return self.__announce_msg_received<EOL> | Getter method for announce_msg_received, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/announce_msg_received (uint32) | f336738:c0:m51 |
def _set_announce_msg_received(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.__announce_msg_received = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for announce_msg_received, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/announce_msg_received (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_announce_msg_received is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_announce_msg_received() directly. | f336738:c0:m52 |
def _get_sync_msg_sent(self): | return self.__sync_msg_sent<EOL> | Getter method for sync_msg_sent, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/sync_msg_sent (uint32) | f336738:c0:m54 |
def _set_sync_msg_sent(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.__sync_msg_sent = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for sync_msg_sent, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/sync_msg_sent (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_sync_msg_sent is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sync_msg_sent() directly. | f336738:c0:m55 |
def _get_sync_msg_received(self): | return self.__sync_msg_received<EOL> | Getter method for sync_msg_received, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/sync_msg_received (uint32) | f336738:c0:m57 |
def _set_sync_msg_received(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.__sync_msg_received = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for sync_msg_received, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/sync_msg_received (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_sync_msg_received is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sync_msg_received() directly. | f336738:c0:m58 |
def _get_followup_msg_sent(self): | return self.__followup_msg_sent<EOL> | Getter method for followup_msg_sent, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/followup_msg_sent (uint32) | f336738:c0:m60 |
def _set_followup_msg_sent(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.__followup_msg_sent = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for followup_msg_sent, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/followup_msg_sent (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_followup_msg_sent is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_followup_msg_sent() directly. | f336738:c0:m61 |
def _get_followup_msg_received(self): | return self.__followup_msg_received<EOL> | Getter method for followup_msg_received, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/followup_msg_received (uint32) | f336738:c0:m63 |
def _set_followup_msg_received(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.__followup_msg_received = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for followup_msg_received, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/followup_msg_received (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_followup_msg_received is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_followup_msg_received() directly. | f336738:c0:m64 |
def _get_delay_req_msg_sent(self): | return self.__delay_req_msg_sent<EOL> | Getter method for delay_req_msg_sent, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/delay_req_msg_sent (uint32) | f336738:c0:m66 |
def _set_delay_req_msg_sent(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.__delay_req_msg_sent = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for delay_req_msg_sent, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/delay_req_msg_sent (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_delay_req_msg_sent is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_delay_req_msg_sent() directly. | f336738:c0:m67 |
def _get_delay_req_msg_received(self): | return self.__delay_req_msg_received<EOL> | Getter method for delay_req_msg_received, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/delay_req_msg_received (uint32) | f336738:c0:m69 |
def _set_delay_req_msg_received(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.__delay_req_msg_received = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for delay_req_msg_received, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/delay_req_msg_received (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_delay_req_msg_received is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_delay_req_msg_received() directly. | f336738:c0:m70 |
def _get_delay_res_msg_sent(self): | return self.__delay_res_msg_sent<EOL> | Getter method for delay_res_msg_sent, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/delay_res_msg_sent (uint32) | f336738:c0:m72 |
def _set_delay_res_msg_sent(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.__delay_res_msg_sent = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for delay_res_msg_sent, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/delay_res_msg_sent (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_delay_res_msg_sent is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_delay_res_msg_sent() directly. | f336738:c0:m73 |
def _get_delay_res_msg_received(self): | return self.__delay_res_msg_received<EOL> | Getter method for delay_res_msg_received, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/delay_res_msg_received (uint32) | f336738:c0:m75 |
def _set_delay_res_msg_received(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.__delay_res_msg_received = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for delay_res_msg_received, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/delay_res_msg_received (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_delay_res_msg_received is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_delay_res_msg_received() directly. | f336738:c0:m76 |
def _get_peer_delay_req_msg_sent(self): | return self.__peer_delay_req_msg_sent<EOL> | Getter method for peer_delay_req_msg_sent, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/peer_delay_req_msg_sent (uint32) | f336738:c0:m78 |
def _set_peer_delay_req_msg_sent(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_delay_req_msg_sent = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for peer_delay_req_msg_sent, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/peer_delay_req_msg_sent (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_peer_delay_req_msg_sent is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_peer_delay_req_msg_sent() directly. | f336738:c0:m79 |
def _get_peer_delay_req_msg_received(self): | return self.__peer_delay_req_msg_received<EOL> | Getter method for peer_delay_req_msg_received, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/peer_delay_req_msg_received (uint32) | f336738:c0:m81 |
def _set_peer_delay_req_msg_received(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_delay_req_msg_received = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for peer_delay_req_msg_received, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/peer_delay_req_msg_received (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_peer_delay_req_msg_received is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_peer_delay_req_msg_received() directly. | f336738:c0:m82 |
def _get_peer_delay_res_msg_sent(self): | return self.__peer_delay_res_msg_sent<EOL> | Getter method for peer_delay_res_msg_sent, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/peer_delay_res_msg_sent (uint32) | f336738:c0:m84 |
def _set_peer_delay_res_msg_sent(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_delay_res_msg_sent = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for peer_delay_res_msg_sent, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/peer_delay_res_msg_sent (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_peer_delay_res_msg_sent is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_peer_delay_res_msg_sent() directly. | f336738:c0:m85 |
def _get_peer_delay_res_msg_received(self): | return self.__peer_delay_res_msg_received<EOL> | Getter method for peer_delay_res_msg_received, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/peer_delay_res_msg_received (uint32) | f336738:c0:m87 |
def _set_peer_delay_res_msg_received(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_delay_res_msg_received = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for peer_delay_res_msg_received, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/peer_delay_res_msg_received (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_peer_delay_res_msg_received is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_peer_delay_res_msg_received() directly. | f336738:c0:m88 |
def _get_peer_delay_res_fm_sent(self): | return self.__peer_delay_res_fm_sent<EOL> | Getter method for peer_delay_res_fm_sent, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/peer_delay_res_fm_sent (uint32) | f336738:c0:m90 |
def _set_peer_delay_res_fm_sent(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_delay_res_fm_sent = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for peer_delay_res_fm_sent, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/peer_delay_res_fm_sent (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_peer_delay_res_fm_sent is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_peer_delay_res_fm_sent() directly. | f336738:c0:m91 |
def _get_peer_delay_res_fm_received(self): | return self.__peer_delay_res_fm_received<EOL> | Getter method for peer_delay_res_fm_received, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/peer_delay_res_fm_received (uint32) | f336738:c0:m93 |
def _set_peer_delay_res_fm_received(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_delay_res_fm_received = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for peer_delay_res_fm_received, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list/peer_delay_res_fm_received (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_peer_delay_res_fm_received is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_peer_delay_res_fm_received() directly. | f336738:c0:m94 |
def _get_interface_key(self): | return self.__interface_key<EOL> | Getter method for interface_key, mapped from YANG variable /ptp_state/interfaces_detail/interface_key (string) | f336739:c0:m3 |
def _set_interface_key(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.__interface_key = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_key, mapped from YANG variable /ptp_state/interfaces_detail/interface_key (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_key is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_key() directly. | f336739:c0:m4 |
def _get_interface_detail_list(self): | return self.__interface_detail_list<EOL> | Getter method for interface_detail_list, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list (list) | f336739:c0:m6 |
def _set_interface_detail_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:id>",interface_detail_list.interface_detail_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:id>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__interface_detail_list = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_detail_list, mapped from YANG variable /ptp_state/interfaces_detail/interface_detail_list (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_detail_list is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_detail_list() directly. | f336739:c0:m7 |
def _get_source(self): | return self.__source<EOL> | Getter method for source, mapped from YANG variable /monitor/session/span_command/source (enumeration) | f336740:c0:m3 |
def _set_source(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:source>': {'<STR_LIT:value>': <NUM_LIT:0>}},), is_leaf=True, yang_name="<STR_LIT:source>", rest_name="<STR_LIT:source>", 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>': 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.__source = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for source, mapped from YANG variable /monitor/session/span_command/source (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_source is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_source() directly. | f336740:c0:m4 |
def _get_src_ethernet(self): | return self.__src_ethernet<EOL> | Getter method for src_ethernet, mapped from YANG variable /monitor/session/span_command/src_ethernet (enumeration) | f336740:c0:m6 |
def _set_src_ethernet(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: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, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': 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.__src_ethernet = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for src_ethernet, mapped from YANG variable /monitor/session/span_command/src_ethernet (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_src_ethernet is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_src_ethernet() directly. | f336740:c0:m7 |
def _get_src_ethernet_val(self): | return self.__src_ethernet_val<EOL> | Getter method for src_ethernet_val, mapped from YANG variable /monitor/session/span_command/src_ethernet_val (span-if-type) | f336740:c0:m9 |
def _set_src_ethernet_val(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, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': 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.__src_ethernet_val = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for src_ethernet_val, mapped from YANG variable /monitor/session/span_command/src_ethernet_val (span-if-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_src_ethernet_val is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_src_ethernet_val() directly. | f336740:c0:m10 |
def _get_destination(self): | return self.__destination<EOL> | Getter method for destination, mapped from YANG variable /monitor/session/span_command/destination (enumeration) | f336740:c0:m12 |
def _set_destination(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:0>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': 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.__destination = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for destination, mapped from YANG variable /monitor/session/span_command/destination (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_destination is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_destination() directly. | f336740:c0:m13 |
def _get_dest_ethernet(self): | return self.__dest_ethernet<EOL> | Getter method for dest_ethernet, mapped from YANG variable /monitor/session/span_command/dest_ethernet (enumeration) | f336740:c0:m15 |
def _set_dest_ethernet(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:8>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}},), 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>': 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.__dest_ethernet = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dest_ethernet, mapped from YANG variable /monitor/session/span_command/dest_ethernet (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_dest_ethernet is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dest_ethernet() directly. | f336740:c0:m16 |
def _get_dest_ethernet_val(self): | return self.__dest_ethernet_val<EOL> | Getter method for dest_ethernet_val, mapped from YANG variable /monitor/session/span_command/dest_ethernet_val (span-if-type) | f336740:c0:m18 |
def _set_dest_ethernet_val(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, extensions={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.__dest_ethernet_val = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dest_ethernet_val, mapped from YANG variable /monitor/session/span_command/dest_ethernet_val (span-if-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_dest_ethernet_val is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dest_ethernet_val() directly. | f336740:c0:m19 |
def _get_dest_vlan_val(self): | return self.__dest_vlan_val<EOL> | Getter method for dest_vlan_val, mapped from YANG variable /monitor/session/span_command/dest_vlan_val (interface:vlan-type) | f336740:c0:m21 |
def _set_dest_vlan_val(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_LIT:1>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': 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.__dest_vlan_val = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dest_vlan_val, mapped from YANG variable /monitor/session/span_command/dest_vlan_val (interface:vlan-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_dest_vlan_val is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dest_vlan_val() directly. | f336740:c0:m22 |
def _get_dest_port_channel_val(self): | return self.__dest_port_channel_val<EOL> | Getter method for dest_port_channel_val, mapped from YANG variable /monitor/session/span_command/dest_port_channel_val (interface:portchannel-type) | f336740:c0:m24 |
def _set_dest_port_channel_val(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), 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>': 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.__dest_port_channel_val = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dest_port_channel_val, mapped from YANG variable /monitor/session/span_command/dest_port_channel_val (interface:portchannel-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_dest_port_channel_val is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dest_port_channel_val() directly. | f336740:c0:m25 |
def _get_direction(self): | return self.__direction<EOL> | Getter method for direction, mapped from YANG variable /monitor/session/span_command/direction (enumeration) | f336740:c0:m27 |
def _set_direction(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u"<STR_LIT>", u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__direction = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for direction, mapped from YANG variable /monitor/session/span_command/direction (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_direction is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_direction() directly. | f336740:c0:m28 |
def _get_session_number(self): | return self.__session_number<EOL> | Getter method for session_number, mapped from YANG variable /monitor/session/session_number (session-type) | f336741:c0:m3 |
def _set_session_number(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=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), 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:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__session_number = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for session_number, mapped from YANG variable /monitor/session/session_number (session-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_session_number is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_session_number() directly. | f336741:c0:m4 |
def _get_description(self): | return self.__description<EOL> | Getter method for description, mapped from YANG variable /monitor/session/description (string) | f336741:c0:m6 |
def _set_description(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:description>", rest_name="<STR_LIT:description>", 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}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=True)<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.__description = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for description, mapped from YANG variable /monitor/session/description (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_description is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_description() directly. | f336741:c0:m7 |
def _get_span_command(self): | return self.__span_command<EOL> | Getter method for span_command, mapped from YANG variable /monitor/session/span_command (container) | f336741:c0:m9 |
def _set_span_command(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=span_command.span_command, 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>': 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.__span_command = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for span_command, mapped from YANG variable /monitor/session/span_command (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_span_command is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_span_command() directly. | f336741:c0:m10 |
def _get_ipv4_addr(self): | return self.__ipv4_addr<EOL> | Getter method for ipv4_addr, mapped from YANG variable /igmp_static_groups_state/igmp_static_groups/igmpv3_sources/excl_src_ip/ipv4_addr (uint32)
YANG Description: A Simple UI32 MO for string ip address in integer format | f336742:c0:m3 |
def _set_ipv4_addr(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ipv4_addr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ipv4_addr, mapped from YANG variable /igmp_static_groups_state/igmp_static_groups/igmpv3_sources/excl_src_ip/ipv4_addr (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_ipv4_addr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ipv4_addr() directly.
YANG Description: A Simple UI32 MO for string ip address in integer format | f336742:c0:m4 |
def _get_interface_name(self): | return self.__interface_name<EOL> | Getter method for interface_name, mapped from YANG variable /igmp_static_groups_state/igmp_static_groups/igmpv3_sources/interface_name (string)
YANG Description: member ship interface for a igmp group | f336743:c0:m3 |
def _set_interface_name(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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.__interface_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_name, mapped from YANG variable /igmp_static_groups_state/igmp_static_groups/igmpv3_sources/interface_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_name() directly.
YANG Description: member ship interface for a igmp group | f336743:c0:m4 |
def _get_incl_src_ip(self): | return self.__incl_src_ip<EOL> | Getter method for incl_src_ip, mapped from YANG variable /igmp_static_groups_state/igmp_static_groups/igmpv3_sources/incl_src_ip (list) | f336743:c0:m6 |
def _set_incl_src_ip(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>",incl_src_ip.incl_src_ip, 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.__incl_src_ip = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for incl_src_ip, mapped from YANG variable /igmp_static_groups_state/igmp_static_groups/igmpv3_sources/incl_src_ip (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_incl_src_ip is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_incl_src_ip() directly. | f336743:c0:m7 |
def _get_excl_src_ip(self): | return self.__excl_src_ip<EOL> | Getter method for excl_src_ip, mapped from YANG variable /igmp_static_groups_state/igmp_static_groups/igmpv3_sources/excl_src_ip (list) | f336743:c0:m9 |
def _set_excl_src_ip(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>",excl_src_ip.excl_src_ip, 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.__excl_src_ip = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for excl_src_ip, mapped from YANG variable /igmp_static_groups_state/igmp_static_groups/igmpv3_sources/excl_src_ip (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_excl_src_ip is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_excl_src_ip() directly. | f336743:c0:m10 |
def _get_ipv4_addr(self): | return self.__ipv4_addr<EOL> | Getter method for ipv4_addr, mapped from YANG variable /igmp_static_groups_state/igmp_static_groups/igmpv3_sources/incl_src_ip/ipv4_addr (uint32)
YANG Description: A Simple UI32 MO for string ip address in integer format | f336744:c0:m3 |
def _set_ipv4_addr(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ipv4_addr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ipv4_addr, mapped from YANG variable /igmp_static_groups_state/igmp_static_groups/igmpv3_sources/incl_src_ip/ipv4_addr (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_ipv4_addr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ipv4_addr() directly.
YANG Description: A Simple UI32 MO for string ip address in integer format | f336744:c0:m4 |
def _get_group_addr(self): | return self.__group_addr<EOL> | Getter method for group_addr, mapped from YANG variable /igmp_static_groups_state/igmp_static_groups/group_addr (uint32)
YANG Description: group ip address | f336745:c0:m3 |
def _set_group_addr(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__group_addr = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for group_addr, mapped from YANG variable /igmp_static_groups_state/igmp_static_groups/group_addr (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_group_addr is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_group_addr() directly.
YANG Description: group ip address | f336745:c0:m4 |
def _get_interface_name(self): | return self.__interface_name<EOL> | Getter method for interface_name, mapped from YANG variable /igmp_static_groups_state/igmp_static_groups/interface_name (string)
YANG Description: Igmp interface name hosting a group | f336745:c0:m6 |
def _set_interface_name(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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.__interface_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interface_name, mapped from YANG variable /igmp_static_groups_state/igmp_static_groups/interface_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_name() directly.
YANG Description: Igmp interface name hosting a group | f336745:c0:m7 |
def _get_uptime(self): | return self.__uptime<EOL> | Getter method for uptime, mapped from YANG variable /igmp_static_groups_state/igmp_static_groups/uptime (string)
YANG Description: group up time | f336745:c0:m9 |
def _set_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.__uptime = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for uptime, mapped from YANG variable /igmp_static_groups_state/igmp_static_groups/uptime (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_uptime is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_uptime() directly.
YANG Description: group up time | f336745:c0:m10 |
def _get_expiry_time(self): | return self.__expiry_time<EOL> | Getter method for expiry_time, mapped from YANG variable /igmp_static_groups_state/igmp_static_groups/expiry_time (string)
YANG Description: group expiry time | f336745:c0:m12 |
def _set_expiry_time(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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.__expiry_time = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for expiry_time, mapped from YANG variable /igmp_static_groups_state/igmp_static_groups/expiry_time (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_expiry_time is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_expiry_time() directly.
YANG Description: group expiry time | f336745:c0:m13 |
def _get_last_reporter(self): | return self.__last_reporter<EOL> | Getter method for last_reporter, mapped from YANG variable /igmp_static_groups_state/igmp_static_groups/last_reporter (uint32)
YANG Description: last reporter | f336745:c0:m15 |
def _set_last_reporter(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.__last_reporter = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for last_reporter, mapped from YANG variable /igmp_static_groups_state/igmp_static_groups/last_reporter (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_last_reporter is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_last_reporter() directly.
YANG Description: last reporter | f336745:c0:m16 |
def _get_filter_mode(self): | return self.__filter_mode<EOL> | Getter method for filter_mode, mapped from YANG variable /igmp_static_groups_state/igmp_static_groups/filter_mode (uint8)
YANG Description: filter mode | f336745:c0:m18 |
def _set_filter_mode(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=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.__filter_mode = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for filter_mode, mapped from YANG variable /igmp_static_groups_state/igmp_static_groups/filter_mode (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_filter_mode is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_filter_mode() directly.
YANG Description: filter mode | f336745:c0:m19 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.