signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_flow_mod_total(self): | return self.__flow_mod_total<EOL> | Getter method for flow_mod_total, mapped from YANG variable /statistics_protocol_state/flow_mod_total (uint64)
YANG Description: flow_mod total | f336282:c0:m108 |
def _set_flow_mod_total(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), 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.__flow_mod_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for flow_mod_total, mapped from YANG variable /statistics_protocol_state/flow_mod_total (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_flow_mod_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_flow_mod_total() directly.
YANG Description: flow_mod total | f336282:c0:m109 |
def _get_flow_mod_last(self): | return self.__flow_mod_last<EOL> | Getter method for flow_mod_last, mapped from YANG variable /statistics_protocol_state/flow_mod_last (uint64)
YANG Description: flow_mod since last clear | f336282:c0:m111 |
def _set_flow_mod_last(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:64>), 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.__flow_mod_last = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for flow_mod_last, mapped from YANG variable /statistics_protocol_state/flow_mod_last (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_flow_mod_last is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_flow_mod_last() directly.
YANG Description: flow_mod since last clear | f336282:c0:m112 |
def _get_group_mod_total(self): | return self.__group_mod_total<EOL> | Getter method for group_mod_total, mapped from YANG variable /statistics_protocol_state/group_mod_total (uint64)
YANG Description: group_mod total | f336282:c0:m114 |
def _set_group_mod_total(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), 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.__group_mod_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for group_mod_total, mapped from YANG variable /statistics_protocol_state/group_mod_total (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_group_mod_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_group_mod_total() directly.
YANG Description: group_mod total | f336282:c0:m115 |
def _get_group_mod_last(self): | return self.__group_mod_last<EOL> | Getter method for group_mod_last, mapped from YANG variable /statistics_protocol_state/group_mod_last (uint64)
YANG Description: group_mod since last clear | f336282:c0:m117 |
def _set_group_mod_last(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:64>), 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.__group_mod_last = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for group_mod_last, mapped from YANG variable /statistics_protocol_state/group_mod_last (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_group_mod_last is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_group_mod_last() directly.
YANG Description: group_mod since last clear | f336282:c0:m118 |
def _get_meter_mod_total(self): | return self.__meter_mod_total<EOL> | Getter method for meter_mod_total, mapped from YANG variable /statistics_protocol_state/meter_mod_total (uint64)
YANG Description: meter_mod total | f336282:c0:m120 |
def _set_meter_mod_total(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), 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.__meter_mod_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for meter_mod_total, mapped from YANG variable /statistics_protocol_state/meter_mod_total (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_meter_mod_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_meter_mod_total() directly.
YANG Description: meter_mod total | f336282:c0:m121 |
def _get_meter_mod_last(self): | return self.__meter_mod_last<EOL> | Getter method for meter_mod_last, mapped from YANG variable /statistics_protocol_state/meter_mod_last (uint64)
YANG Description: meter_mod since last clear | f336282:c0:m123 |
def _set_meter_mod_last(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:64>), 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.__meter_mod_last = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for meter_mod_last, mapped from YANG variable /statistics_protocol_state/meter_mod_last (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_meter_mod_last is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_meter_mod_last() directly.
YANG Description: meter_mod since last clear | f336282:c0:m124 |
def _get_barrier_req_total(self): | return self.__barrier_req_total<EOL> | Getter method for barrier_req_total, mapped from YANG variable /statistics_protocol_state/barrier_req_total (uint64)
YANG Description: barrier req total | f336282:c0:m126 |
def _set_barrier_req_total(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), 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.__barrier_req_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for barrier_req_total, mapped from YANG variable /statistics_protocol_state/barrier_req_total (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_barrier_req_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_barrier_req_total() directly.
YANG Description: barrier req total | f336282:c0:m127 |
def _get_barrier_reply_total(self): | return self.__barrier_reply_total<EOL> | Getter method for barrier_reply_total, mapped from YANG variable /statistics_protocol_state/barrier_reply_total (uint64)
YANG Description: barrier reply total | f336282:c0:m129 |
def _set_barrier_reply_total(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), 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.__barrier_reply_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for barrier_reply_total, mapped from YANG variable /statistics_protocol_state/barrier_reply_total (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_barrier_reply_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_barrier_reply_total() directly.
YANG Description: barrier reply total | f336282:c0:m130 |
def _get_barrier_req_last(self): | return self.__barrier_req_last<EOL> | Getter method for barrier_req_last, mapped from YANG variable /statistics_protocol_state/barrier_req_last (uint64)
YANG Description: barrier req since last clear | f336282:c0:m132 |
def _set_barrier_req_last(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:64>), 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.__barrier_req_last = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for barrier_req_last, mapped from YANG variable /statistics_protocol_state/barrier_req_last (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_barrier_req_last is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_barrier_req_last() directly.
YANG Description: barrier req since last clear | f336282:c0:m133 |
def _get_barrier_reply_last(self): | return self.__barrier_reply_last<EOL> | Getter method for barrier_reply_last, mapped from YANG variable /statistics_protocol_state/barrier_reply_last (uint64)
YANG Description: barrier reply since last clear | f336282:c0:m135 |
def _set_barrier_reply_last(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:64>), 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.__barrier_reply_last = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for barrier_reply_last, mapped from YANG variable /statistics_protocol_state/barrier_reply_last (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_barrier_reply_last is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_barrier_reply_last() directly.
YANG Description: barrier reply since last clear | f336282:c0:m136 |
def _get_role_req_total(self): | return self.__role_req_total<EOL> | Getter method for role_req_total, mapped from YANG variable /statistics_protocol_state/role_req_total (uint64)
YANG Description: role req total | f336282:c0:m138 |
def _set_role_req_total(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), 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.__role_req_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for role_req_total, mapped from YANG variable /statistics_protocol_state/role_req_total (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_role_req_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_role_req_total() directly.
YANG Description: role req total | f336282:c0:m139 |
def _get_role_reply_total(self): | return self.__role_reply_total<EOL> | Getter method for role_reply_total, mapped from YANG variable /statistics_protocol_state/role_reply_total (uint64)
YANG Description: role reply total | f336282:c0:m141 |
def _set_role_reply_total(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), 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.__role_reply_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for role_reply_total, mapped from YANG variable /statistics_protocol_state/role_reply_total (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_role_reply_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_role_reply_total() directly.
YANG Description: role reply total | f336282:c0:m142 |
def _get_role_req_last(self): | return self.__role_req_last<EOL> | Getter method for role_req_last, mapped from YANG variable /statistics_protocol_state/role_req_last (uint64)
YANG Description: role req since last clear | f336282:c0:m144 |
def _set_role_req_last(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:64>), 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.__role_req_last = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for role_req_last, mapped from YANG variable /statistics_protocol_state/role_req_last (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_role_req_last is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_role_req_last() directly.
YANG Description: role req since last clear | f336282:c0:m145 |
def _get_role_reply_last(self): | return self.__role_reply_last<EOL> | Getter method for role_reply_last, mapped from YANG variable /statistics_protocol_state/role_reply_last (uint64)
YANG Description: role reply since last clear | f336282:c0:m147 |
def _set_role_reply_last(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:64>), 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.__role_reply_last = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for role_reply_last, mapped from YANG variable /statistics_protocol_state/role_reply_last (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_role_reply_last is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_role_reply_last() directly.
YANG Description: role reply since last clear | f336282:c0:m148 |
def _get_get_async_req_total(self): | return self.__get_async_req_total<EOL> | Getter method for get_async_req_total, mapped from YANG variable /statistics_protocol_state/get_async_req_total (uint64)
YANG Description: get_async req total | f336282:c0:m150 |
def _set_get_async_req_total(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), 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.__get_async_req_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for get_async_req_total, mapped from YANG variable /statistics_protocol_state/get_async_req_total (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_get_async_req_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_get_async_req_total() directly.
YANG Description: get_async req total | f336282:c0:m151 |
def _get_get_async_reply_total(self): | return self.__get_async_reply_total<EOL> | Getter method for get_async_reply_total, mapped from YANG variable /statistics_protocol_state/get_async_reply_total (uint64)
YANG Description: get_async reply total | f336282:c0:m153 |
def _set_get_async_reply_total(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), 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.__get_async_reply_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for get_async_reply_total, mapped from YANG variable /statistics_protocol_state/get_async_reply_total (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_get_async_reply_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_get_async_reply_total() directly.
YANG Description: get_async reply total | f336282:c0:m154 |
def _get_get_async_req_last(self): | return self.__get_async_req_last<EOL> | Getter method for get_async_req_last, mapped from YANG variable /statistics_protocol_state/get_async_req_last (uint64)
YANG Description: get_async req since last clear | f336282:c0:m156 |
def _set_get_async_req_last(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:64>), 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.__get_async_req_last = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for get_async_req_last, mapped from YANG variable /statistics_protocol_state/get_async_req_last (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_get_async_req_last is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_get_async_req_last() directly.
YANG Description: get_async req since last clear | f336282:c0:m157 |
def _get_get_async_reply_last(self): | return self.__get_async_reply_last<EOL> | Getter method for get_async_reply_last, mapped from YANG variable /statistics_protocol_state/get_async_reply_last (uint64)
YANG Description: get_async reply since last clear | f336282:c0:m159 |
def _set_get_async_reply_last(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:64>), 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.__get_async_reply_last = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for get_async_reply_last, mapped from YANG variable /statistics_protocol_state/get_async_reply_last (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_get_async_reply_last is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_get_async_reply_last() directly.
YANG Description: get_async reply since last clear | f336282:c0:m160 |
def _get_set_async_reply_total(self): | return self.__set_async_reply_total<EOL> | Getter method for set_async_reply_total, mapped from YANG variable /statistics_protocol_state/set_async_reply_total (uint64)
YANG Description: set_async reply total | f336282:c0:m162 |
def _set_set_async_reply_total(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), 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.__set_async_reply_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for set_async_reply_total, mapped from YANG variable /statistics_protocol_state/set_async_reply_total (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_set_async_reply_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_set_async_reply_total() directly.
YANG Description: set_async reply total | f336282:c0:m163 |
def _get_set_async_req_last(self): | return self.__set_async_req_last<EOL> | Getter method for set_async_req_last, mapped from YANG variable /statistics_protocol_state/set_async_req_last (uint64)
YANG Description: set_async req since last clear | f336282:c0:m165 |
def _set_set_async_req_last(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:64>), 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.__set_async_req_last = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for set_async_req_last, mapped from YANG variable /statistics_protocol_state/set_async_req_last (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_set_async_req_last is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_set_async_req_last() directly.
YANG Description: set_async req since last clear | f336282:c0:m166 |
def _get_total_rx_total(self): | return self.__total_rx_total<EOL> | Getter method for total_rx_total, mapped from YANG variable /statistics_protocol_state/total_rx_total (uint64)
YANG Description: total Rx total | f336282:c0:m168 |
def _set_total_rx_total(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), 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.__total_rx_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for total_rx_total, mapped from YANG variable /statistics_protocol_state/total_rx_total (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_total_rx_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_total_rx_total() directly.
YANG Description: total Rx total | f336282:c0:m169 |
def _get_total_tx_total(self): | return self.__total_tx_total<EOL> | Getter method for total_tx_total, mapped from YANG variable /statistics_protocol_state/total_tx_total (uint64)
YANG Description: total Tx total | f336282:c0:m171 |
def _set_total_tx_total(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), 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.__total_tx_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for total_tx_total, mapped from YANG variable /statistics_protocol_state/total_tx_total (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_total_tx_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_total_tx_total() directly.
YANG Description: total Tx total | f336282:c0:m172 |
def _get_total_rx_last(self): | return self.__total_rx_last<EOL> | Getter method for total_rx_last, mapped from YANG variable /statistics_protocol_state/total_rx_last (uint64)
YANG Description: total Rx since last clear | f336282:c0:m174 |
def _set_total_rx_last(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:64>), 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.__total_rx_last = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for total_rx_last, mapped from YANG variable /statistics_protocol_state/total_rx_last (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_total_rx_last is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_total_rx_last() directly.
YANG Description: total Rx since last clear | f336282:c0:m175 |
def _get_total_tx_last(self): | return self.__total_tx_last<EOL> | Getter method for total_tx_last, mapped from YANG variable /statistics_protocol_state/total_tx_last (uint64)
YANG Description: total Tx since last clear | f336282:c0:m177 |
def _set_total_tx_last(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:64>), 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.__total_tx_last = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for total_tx_last, mapped from YANG variable /statistics_protocol_state/total_tx_last (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_total_tx_last is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_total_tx_last() directly.
YANG Description: total Tx since last clear | f336282:c0:m178 |
def _get_unknown_rx_total(self): | return self.__unknown_rx_total<EOL> | Getter method for unknown_rx_total, mapped from YANG variable /statistics_protocol_state/unknown_rx_total (uint64)
YANG Description: unknown_rx total | f336282:c0:m180 |
def _set_unknown_rx_total(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), 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.__unknown_rx_total = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for unknown_rx_total, mapped from YANG variable /statistics_protocol_state/unknown_rx_total (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_unknown_rx_total is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_unknown_rx_total() directly.
YANG Description: unknown_rx total | f336282:c0:m181 |
def _get_unknown_rx_last(self): | return self.__unknown_rx_last<EOL> | Getter method for unknown_rx_last, mapped from YANG variable /statistics_protocol_state/unknown_rx_last (uint64)
YANG Description: unknown_rx since last clear | f336282:c0:m183 |
def _set_unknown_rx_last(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:64>), 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.__unknown_rx_last = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for unknown_rx_last, mapped from YANG variable /statistics_protocol_state/unknown_rx_last (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_unknown_rx_last is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_unknown_rx_last() directly.
YANG Description: unknown_rx since last clear | f336282:c0:m184 |
def _get_seq_id(self): | return self.__seq_id<EOL> | Getter method for seq_id, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/seq_id (ip-access-list:seq-id-std-ext) | f336283:c0:m3 |
def _set_seq_id(self, v, load=False): | parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), 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}}, 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.__seq_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for seq_id, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/seq_id (ip-access-list:seq-id-std-ext)
If this variable is read-only (config: false) in the
source YANG file, then _set_seq_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_seq_id() directly. | f336283:c0:m4 |
def _get_action(self): | return self.__action<EOL> | Getter method for action, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/action (enumeration) | f336283:c0:m6 |
def _set_action(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:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), is_leaf=True, yang_name="<STR_LIT:action>", rest_name="<STR_LIT:action>", 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.__action = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for action, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/action (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_action is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_action() directly. | f336283:c0:m7 |
def _get_protocol_type(self): | return self.__protocol_type<EOL> | Getter method for protocol_type, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/protocol_type (union) | f336283:c0:m9 |
def _set_protocol_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=[RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}},),RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}),], 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.__protocol_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for protocol_type, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/protocol_type (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_protocol_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_protocol_type() directly. | f336283:c0:m10 |
def _get_src_host_any_sip(self): | return self.__src_host_any_sip<EOL> | Getter method for src_host_any_sip, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/src_host_any_sip (union) | f336283:c0:m12 |
def _set_src_host_any_sip(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:host>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},),RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}),], is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': 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_host_any_sip = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for src_host_any_sip, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/src_host_any_sip (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_src_host_any_sip is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_src_host_any_sip() directly. | f336283:c0:m13 |
def _get_src_host_ip(self): | return self.__src_host_ip<EOL> | Getter method for src_host_ip, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/src_host_ip (sip) | f336283:c0:m15 |
def _set_src_host_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=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': 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_host_ip = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for src_host_ip, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/src_host_ip (sip)
If this variable is read-only (config: false) in the
source YANG file, then _set_src_host_ip is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_src_host_ip() directly. | f336283:c0:m16 |
def _get_src_mask(self): | return self.__src_mask<EOL> | Getter method for src_mask, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/src_mask (sip-mask) | f336283:c0:m18 |
def _set_src_mask(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>': 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_mask = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for src_mask, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/src_mask (sip-mask)
If this variable is read-only (config: false) in the
source YANG file, then _set_src_mask is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_src_mask() directly. | f336283:c0:m19 |
def _get_sport(self): | return self.__sport<EOL> | Getter method for sport, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/sport (enumeration) | f336283:c0:m21 |
def _set_sport(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:3>}, 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:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}},), 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, 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.__sport = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for sport, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/sport (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_sport is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sport() directly. | f336283:c0:m22 |
def _get_sport_number_eq_neq_tcp(self): | return self.__sport_number_eq_neq_tcp<EOL> | Getter method for sport_number_eq_neq_tcp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/sport_number_eq_neq_tcp (union) | f336283:c0:m24 |
def _set_sport_number_eq_neq_tcp(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>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:20>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT:time>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}},),RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}),], 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}}, 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.__sport_number_eq_neq_tcp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for sport_number_eq_neq_tcp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/sport_number_eq_neq_tcp (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_sport_number_eq_neq_tcp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sport_number_eq_neq_tcp() directly. | f336283:c0:m25 |
def _get_sport_number_lt_tcp(self): | return self.__sport_number_lt_tcp<EOL> | Getter method for sport_number_lt_tcp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/sport_number_lt_tcp (union) | f336283:c0:m27 |
def _set_sport_number_lt_tcp(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>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:20>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT:time>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}},),RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}),], 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}}, 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.__sport_number_lt_tcp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for sport_number_lt_tcp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/sport_number_lt_tcp (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_sport_number_lt_tcp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sport_number_lt_tcp() directly. | f336283:c0:m28 |
def _get_sport_number_gt_tcp(self): | return self.__sport_number_gt_tcp<EOL> | Getter method for sport_number_gt_tcp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/sport_number_gt_tcp (union) | f336283:c0:m30 |
def _set_sport_number_gt_tcp(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>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:20>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT:time>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}},),RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}),], 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}}, 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.__sport_number_gt_tcp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for sport_number_gt_tcp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/sport_number_gt_tcp (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_sport_number_gt_tcp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sport_number_gt_tcp() directly. | f336283:c0:m31 |
def _get_sport_number_eq_neq_udp(self): | return self.__sport_number_eq_neq_udp<EOL> | Getter method for sport_number_eq_neq_udp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/sport_number_eq_neq_udp (union) | f336283:c0:m33 |
def _set_sport_number_eq_neq_udp(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>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}},),RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}),], 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}}, 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.__sport_number_eq_neq_udp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for sport_number_eq_neq_udp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/sport_number_eq_neq_udp (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_sport_number_eq_neq_udp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sport_number_eq_neq_udp() directly. | f336283:c0:m34 |
def _get_sport_number_lt_udp(self): | return self.__sport_number_lt_udp<EOL> | Getter method for sport_number_lt_udp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/sport_number_lt_udp (union) | f336283:c0:m36 |
def _set_sport_number_lt_udp(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>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}},),RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}),], 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}}, 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.__sport_number_lt_udp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for sport_number_lt_udp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/sport_number_lt_udp (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_sport_number_lt_udp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sport_number_lt_udp() directly. | f336283:c0:m37 |
def _get_sport_number_gt_udp(self): | return self.__sport_number_gt_udp<EOL> | Getter method for sport_number_gt_udp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/sport_number_gt_udp (union) | f336283:c0:m39 |
def _set_sport_number_gt_udp(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>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}},),RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}),], 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}}, 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.__sport_number_gt_udp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for sport_number_gt_udp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/sport_number_gt_udp (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_sport_number_gt_udp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sport_number_gt_udp() directly. | f336283:c0:m40 |
def _get_sport_number_range_lower_tcp(self): | return self.__sport_number_range_lower_tcp<EOL> | Getter method for sport_number_range_lower_tcp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/sport_number_range_lower_tcp (union) | f336283:c0:m42 |
def _set_sport_number_range_lower_tcp(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>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:20>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT:time>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}},),RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}),], 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.__sport_number_range_lower_tcp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for sport_number_range_lower_tcp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/sport_number_range_lower_tcp (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_sport_number_range_lower_tcp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sport_number_range_lower_tcp() directly. | f336283:c0:m43 |
def _get_sport_number_range_lower_udp(self): | return self.__sport_number_range_lower_udp<EOL> | Getter method for sport_number_range_lower_udp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/sport_number_range_lower_udp (union) | f336283:c0:m45 |
def _set_sport_number_range_lower_udp(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>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}},),RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}),], 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.__sport_number_range_lower_udp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for sport_number_range_lower_udp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/sport_number_range_lower_udp (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_sport_number_range_lower_udp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sport_number_range_lower_udp() directly. | f336283:c0:m46 |
def _get_sport_number_range_higher_tcp(self): | return self.__sport_number_range_higher_tcp<EOL> | Getter method for sport_number_range_higher_tcp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/sport_number_range_higher_tcp (union) | f336283:c0:m48 |
def _set_sport_number_range_higher_tcp(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>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:20>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT:time>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}},),RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}),], 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}}, 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.__sport_number_range_higher_tcp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for sport_number_range_higher_tcp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/sport_number_range_higher_tcp (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_sport_number_range_higher_tcp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sport_number_range_higher_tcp() directly. | f336283:c0:m49 |
def _get_sport_number_range_higher_udp(self): | return self.__sport_number_range_higher_udp<EOL> | Getter method for sport_number_range_higher_udp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/sport_number_range_higher_udp (union) | f336283:c0:m51 |
def _set_sport_number_range_higher_udp(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>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}},),RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}),], 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}}, 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.__sport_number_range_higher_udp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for sport_number_range_higher_udp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/sport_number_range_higher_udp (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_sport_number_range_higher_udp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sport_number_range_higher_udp() directly. | f336283:c0:m52 |
def _get_dst_host_any_dip(self): | return self.__dst_host_any_dip<EOL> | Getter method for dst_host_any_dip, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dst_host_any_dip (union) | f336283:c0:m54 |
def _set_dst_host_any_dip(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:host>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},),RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}),], is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': None}}, 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.__dst_host_any_dip = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dst_host_any_dip, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dst_host_any_dip (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_dst_host_any_dip is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dst_host_any_dip() directly. | f336283:c0:m55 |
def _get_dst_host_ip(self): | return self.__dst_host_ip<EOL> | Getter method for dst_host_ip, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dst_host_ip (dip) | f336283:c0:m57 |
def _set_dst_host_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=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': None}}, 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.__dst_host_ip = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dst_host_ip, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dst_host_ip (dip)
If this variable is read-only (config: false) in the
source YANG file, then _set_dst_host_ip is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dst_host_ip() directly. | f336283:c0:m58 |
def _get_dst_mask(self): | return self.__dst_mask<EOL> | Getter method for dst_mask, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dst_mask (dip-mask) | f336283:c0:m60 |
def _set_dst_mask(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>': 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.__dst_mask = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dst_mask, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dst_mask (dip-mask)
If this variable is read-only (config: false) in the
source YANG file, then _set_dst_mask is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dst_mask() directly. | f336283:c0:m61 |
def _get_dport(self): | return self.__dport<EOL> | Getter method for dport, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dport (enumeration) | f336283:c0:m63 |
def _set_dport(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:3>}, 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:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}},), 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, 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.__dport = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dport, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dport (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_dport is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dport() directly. | f336283:c0:m64 |
def _get_dport_number_eq_neq_tcp(self): | return self.__dport_number_eq_neq_tcp<EOL> | Getter method for dport_number_eq_neq_tcp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dport_number_eq_neq_tcp (union) | f336283:c0:m66 |
def _set_dport_number_eq_neq_tcp(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>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:20>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT:time>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}},),RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}),], 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}}, 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.__dport_number_eq_neq_tcp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dport_number_eq_neq_tcp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dport_number_eq_neq_tcp (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_dport_number_eq_neq_tcp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dport_number_eq_neq_tcp() directly. | f336283:c0:m67 |
def _get_dport_number_lt_tcp(self): | return self.__dport_number_lt_tcp<EOL> | Getter method for dport_number_lt_tcp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dport_number_lt_tcp (union) | f336283:c0:m69 |
def _set_dport_number_lt_tcp(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>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:20>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT:time>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}},),RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}),], 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}}, 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.__dport_number_lt_tcp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dport_number_lt_tcp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dport_number_lt_tcp (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_dport_number_lt_tcp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dport_number_lt_tcp() directly. | f336283:c0:m70 |
def _get_dport_number_gt_tcp(self): | return self.__dport_number_gt_tcp<EOL> | Getter method for dport_number_gt_tcp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dport_number_gt_tcp (union) | f336283:c0:m72 |
def _set_dport_number_gt_tcp(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>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:20>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT:time>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT>}},),RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}),], 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}}, 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.__dport_number_gt_tcp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dport_number_gt_tcp, mapped from YANG variable /ipv6_acl/ipv6/access_list/extended/seq/dport_number_gt_tcp (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_dport_number_gt_tcp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dport_number_gt_tcp() directly. | f336283:c0:m73 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.