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.