signature
stringlengths 8
3.44k
| body
stringlengths 0
1.41M
| docstring
stringlengths 1
122k
| id
stringlengths 5
17
|
|---|---|---|---|
def _get_ma_name(self): | return self.__ma_name<EOL> | Getter method for ma_name, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/ma_name (string)
YANG Description: ma name | f336814:c0:m3 |
def _set_ma_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.__ma_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ma_name, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/ma_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_ma_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ma_name() directly.
YANG Description: ma name | f336814:c0:m4 |
def _get_ma_idx(self): | return self.__ma_idx<EOL> | Getter method for ma_idx, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/ma_idx (uint16)
YANG Description: ma index | f336814:c0:m6 |
def _set_ma_idx(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.__ma_idx = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ma_idx, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/ma_idx (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_ma_idx is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ma_idx() directly.
YANG Description: ma index | f336814:c0:m7 |
def _get_ma_type(self): | return self.__ma_type<EOL> | Getter method for ma_type, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/ma_type (uint8)
YANG Description: Bridge Domain or VLAN MA | f336814:c0:m9 |
def _set_ma_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=int, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:8>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ma_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ma_type, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/ma_type (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_ma_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ma_type() directly.
YANG Description: Bridge Domain or VLAN MA | f336814:c0:m10 |
def _get_ccm_interval(self): | return self.__ccm_interval<EOL> | Getter method for ccm_interval, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/ccm_interval (uint32)
YANG Description: CCM Interval | f336814:c0:m12 |
def _set_ccm_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.__ccm_interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ccm_interval, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/ccm_interval (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_ccm_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ccm_interval() directly.
YANG Description: CCM Interval | f336814:c0:m13 |
def _get_vlan_id(self): | return self.__vlan_id<EOL> | Getter method for vlan_id, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/vlan_id (uint32)
YANG Description: VLAN Id | f336814:c0:m15 |
def _set_vlan_id(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__vlan_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vlan_id, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/vlan_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vlan_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vlan_id() directly.
YANG Description: VLAN Id | f336814:c0:m16 |
def _get_priority(self): | return self.__priority<EOL> | Getter method for priority, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/priority (uint8)
YANG Description: ma priority | f336814:c0:m18 |
def _set_priority(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.__priority = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for priority, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/priority (uint8)
If this variable is read-only (config: false) in the
source YANG file, then _set_priority is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_priority() directly.
YANG Description: ma priority | f336814:c0:m19 |
def _get_mep(self): | return self.__mep<EOL> | Getter method for mep, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mep (list)
YANG Description: MEP Details | f336814:c0:m21 |
def _set_mep(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>",mep.mep, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__mep = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mep, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mep (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_mep is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mep() directly.
YANG Description: MEP Details | f336814:c0:m22 |
def _get_mip(self): | return self.__mip<EOL> | Getter method for mip, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mip (list)
YANG Description: MIP Details | f336814:c0:m24 |
def _set_mip(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>",mip.mip, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__mip = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mip, mapped from YANG variable /cfm_state/cfm_detail/domain/ma/mip (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_mip is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mip() directly.
YANG Description: MIP Details | f336814:c0:m25 |
def _get_vxlan_acl(self): | return self.__vxlan_acl<EOL> | Getter method for vxlan_acl, mapped from YANG variable /acl_state/vxlan_acl (list)
YANG Description: Vxlan ACL information | f336815:c0:m3 |
def _set_vxlan_acl(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>",vxlan_acl.vxlan_acl, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__vxlan_acl = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vxlan_acl, mapped from YANG variable /acl_state/vxlan_acl (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_vxlan_acl is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vxlan_acl() directly.
YANG Description: Vxlan ACL information | f336815:c0:m4 |
def _get_overlay_acl_tr_name(self): | return self.__overlay_acl_tr_name<EOL> | Getter method for overlay_acl_tr_name, mapped from YANG variable /acl_state/vxlan_acl/overlay_acl_tr_name (string)
YANG Description: overlay_acl_tr_name | f336816:c0:m3 |
def _set_overlay_acl_tr_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.__overlay_acl_tr_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for overlay_acl_tr_name, mapped from YANG variable /acl_state/vxlan_acl/overlay_acl_tr_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_overlay_acl_tr_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_overlay_acl_tr_name() directly.
YANG Description: overlay_acl_tr_name | f336816:c0:m4 |
def _get_extended_data(self): | return self.__extended_data<EOL> | Getter method for extended_data, mapped from YANG variable /acl_state/vxlan_acl/extended_data (list) | f336816:c0:m6 |
def _set_extended_data(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>",extended_data.extended_data, 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.__extended_data = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for extended_data, mapped from YANG variable /acl_state/vxlan_acl/extended_data (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_extended_data is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_extended_data() directly. | f336816:c0:m7 |
def _get_acl_name(self): | return self.__acl_name<EOL> | Getter method for acl_name, mapped from YANG variable /acl_state/vxlan_acl/extended_data/acl_name (string)
YANG Description: input_Acl_name | f336817:c0:m3 |
def _set_acl_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.__acl_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for acl_name, mapped from YANG variable /acl_state/vxlan_acl/extended_data/acl_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_acl_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_acl_name() directly.
YANG Description: input_Acl_name | f336817:c0:m4 |
def _get_seq_num(self): | return self.__seq_num<EOL> | Getter method for seq_num, mapped from YANG variable /acl_state/vxlan_acl/extended_data/seq_num (uint32)
YANG Description: sequence number | f336817:c0:m6 |
def _set_seq_num(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.__seq_num = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for seq_num, mapped from YANG variable /acl_state/vxlan_acl/extended_data/seq_num (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_seq_num is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_seq_num() directly.
YANG Description: sequence number | f336817:c0:m7 |
def _get_permit_deny(self): | return self.__permit_deny<EOL> | Getter method for permit_deny, mapped from YANG variable /acl_state/vxlan_acl/extended_data/permit_deny (string)
YANG Description: permit or deny | f336817:c0:m9 |
def _set_permit_deny(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.__permit_deny = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for permit_deny, mapped from YANG variable /acl_state/vxlan_acl/extended_data/permit_deny (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_permit_deny is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_permit_deny() directly.
YANG Description: permit or deny | f336817:c0:m10 |
def _get_dst_vtep_ip(self): | return self.__dst_vtep_ip<EOL> | Getter method for dst_vtep_ip, mapped from YANG variable /acl_state/vxlan_acl/extended_data/dst_vtep_ip (inet:ipv4-address)
YANG Description: dst vtep ip or any | f336817:c0:m12 |
def _set_dst_vtep_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, 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.__dst_vtep_ip = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dst_vtep_ip, mapped from YANG variable /acl_state/vxlan_acl/extended_data/dst_vtep_ip (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_dst_vtep_ip is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dst_vtep_ip() directly.
YANG Description: dst vtep ip or any | f336817:c0:m13 |
def _get_src_vtep_ip(self): | return self.__src_vtep_ip<EOL> | Getter method for src_vtep_ip, mapped from YANG variable /acl_state/vxlan_acl/extended_data/src_vtep_ip (inet:ipv4-address)
YANG Description: src vtep ip or any | f336817:c0:m15 |
def _set_src_vtep_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, 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.__src_vtep_ip = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for src_vtep_ip, mapped from YANG variable /acl_state/vxlan_acl/extended_data/src_vtep_ip (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_src_vtep_ip is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_src_vtep_ip() directly.
YANG Description: src vtep ip or any | f336817:c0:m16 |
def _get_vni(self): | return self.__vni<EOL> | Getter method for vni, mapped from YANG variable /acl_state/vxlan_acl/extended_data/vni (string)
YANG Description: vni number or any | f336817:c0:m18 |
def _set_vni(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.__vni = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vni, mapped from YANG variable /acl_state/vxlan_acl/extended_data/vni (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_vni is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vni() directly.
YANG Description: vni number or any | f336817:c0:m19 |
def _get_vni_mask(self): | return self.__vni_mask<EOL> | Getter method for vni_mask, mapped from YANG variable /acl_state/vxlan_acl/extended_data/vni_mask (string)
YANG Description: vni mask | f336817:c0:m21 |
def _set_vni_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=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.__vni_mask = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vni_mask, mapped from YANG variable /acl_state/vxlan_acl/extended_data/vni_mask (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_vni_mask is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vni_mask() directly.
YANG Description: vni mask | f336817:c0:m22 |
def _get_native_tag(self): | return self.__native_tag<EOL> | Getter method for native_tag, mapped from YANG variable /acl_state/vxlan_acl/extended_data/native_tag (string)
YANG Description: native tag | f336817:c0:m24 |
def _set_native_tag(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.__native_tag = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for native_tag, mapped from YANG variable /acl_state/vxlan_acl/extended_data/native_tag (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_native_tag is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_native_tag() directly.
YANG Description: native tag | f336817:c0:m25 |
def _get_dst_ip(self): | return self.__dst_ip<EOL> | Getter method for dst_ip, mapped from YANG variable /acl_state/vxlan_acl/extended_data/dst_ip (inet:ipv4-address)
YANG Description: dst ip or any | f336817:c0:m27 |
def _set_dst_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, 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.__dst_ip = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dst_ip, mapped from YANG variable /acl_state/vxlan_acl/extended_data/dst_ip (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_dst_ip is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dst_ip() directly.
YANG Description: dst ip or any | f336817:c0:m28 |
def _get_dst_ip_mask(self): | return self.__dst_ip_mask<EOL> | Getter method for dst_ip_mask, mapped from YANG variable /acl_state/vxlan_acl/extended_data/dst_ip_mask (uint16)
YANG Description: dst ip mask | f336817:c0:m30 |
def _set_dst_ip_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=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.__dst_ip_mask = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dst_ip_mask, mapped from YANG variable /acl_state/vxlan_acl/extended_data/dst_ip_mask (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_dst_ip_mask is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dst_ip_mask() directly.
YANG Description: dst ip mask | f336817:c0:m31 |
def _get_src_ip(self): | return self.__src_ip<EOL> | Getter method for src_ip, mapped from YANG variable /acl_state/vxlan_acl/extended_data/src_ip (inet:ipv4-address)
YANG Description: src ip or any | f336817:c0:m33 |
def _set_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=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__src_ip = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for src_ip, mapped from YANG variable /acl_state/vxlan_acl/extended_data/src_ip (inet:ipv4-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_src_ip is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_src_ip() directly.
YANG Description: src ip or any | f336817:c0:m34 |
def _get_src_ip_mask(self): | return self.__src_ip_mask<EOL> | Getter method for src_ip_mask, mapped from YANG variable /acl_state/vxlan_acl/extended_data/src_ip_mask (uint16)
YANG Description: src ip mask | f336817:c0:m36 |
def _set_src_ip_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=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.__src_ip_mask = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for src_ip_mask, mapped from YANG variable /acl_state/vxlan_acl/extended_data/src_ip_mask (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_src_ip_mask is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_src_ip_mask() directly.
YANG Description: src ip mask | f336817:c0:m37 |
def _get_dst_port(self): | return self.__dst_port<EOL> | Getter method for dst_port, mapped from YANG variable /acl_state/vxlan_acl/extended_data/dst_port (uint16)
YANG Description: dst port number | f336817:c0:m39 |
def _set_dst_port(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.__dst_port = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for dst_port, mapped from YANG variable /acl_state/vxlan_acl/extended_data/dst_port (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_dst_port is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dst_port() directly.
YANG Description: dst port number | f336817:c0:m40 |
def _get_src_port(self): | return self.__src_port<EOL> | Getter method for src_port, mapped from YANG variable /acl_state/vxlan_acl/extended_data/src_port (uint16)
YANG Description: src port number | f336817:c0:m42 |
def _set_src_port(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.__src_port = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for src_port, mapped from YANG variable /acl_state/vxlan_acl/extended_data/src_port (uint16)
If this variable is read-only (config: false) in the
source YANG file, then _set_src_port is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_src_port() directly.
YANG Description: src port number | f336817:c0:m43 |
def _get_count(self): | return self.__count<EOL> | Getter method for count, mapped from YANG variable /acl_state/vxlan_acl/extended_data/count (uint64)
YANG Description: count | f336817:c0:m45 |
def _set_count(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:count>", rest_name="<STR_LIT:count>", 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.__count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for count, mapped from YANG variable /acl_state/vxlan_acl/extended_data/count (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_count() directly.
YANG Description: count | f336817:c0:m46 |
def _get_byte_count(self): | return self.__byte_count<EOL> | Getter method for byte_count, mapped from YANG variable /acl_state/vxlan_acl/extended_data/byte_count (uint64)
YANG Description: byte_count | f336817:c0:m48 |
def _set_byte_count(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.__byte_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for byte_count, mapped from YANG variable /acl_state/vxlan_acl/extended_data/byte_count (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_byte_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_byte_count() directly.
YANG Description: byte_count | f336817:c0:m49 |
def _get_transit_name(self): | return self.__transit_name<EOL> | Getter method for transit_name, mapped from YANG variable /acl_state/vxlan_acl/extended_data/transit_name (string)
YANG Description: transit_name | f336817:c0:m51 |
def _set_transit_name(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=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.__transit_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for transit_name, mapped from YANG variable /acl_state/vxlan_acl/extended_data/transit_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_transit_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_transit_name() directly.
YANG Description: transit_name | f336817:c0:m52 |
def _get_sflow(self): | return self.__sflow<EOL> | Getter method for sflow, mapped from YANG variable /acl_state/vxlan_acl/extended_data/sflow (boolean)
YANG Description: sflow enable or disable | f336817:c0:m54 |
def _set_sflow(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__sflow = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for sflow, mapped from YANG variable /acl_state/vxlan_acl/extended_data/sflow (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_sflow is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sflow() directly.
YANG Description: sflow enable or disable | f336817:c0:m55 |
def _get_redir_interface(self): | return self.__redir_interface<EOL> | Getter method for redir_interface, mapped from YANG variable /acl_state/vxlan_acl/extended_data/redir_interface (string)
YANG Description: redirect interface | f336817:c0:m57 |
def _set_redir_interface(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.__redir_interface = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for redir_interface, mapped from YANG variable /acl_state/vxlan_acl/extended_data/redir_interface (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_redir_interface is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_redir_interface() directly.
YANG Description: redirect interface | f336817:c0:m58 |
def _get_mirror_interface(self): | return self.__mirror_interface<EOL> | Getter method for mirror_interface, mapped from YANG variable /acl_state/vxlan_acl/extended_data/mirror_interface (string)
YANG Description: mirror interface | f336817:c0:m60 |
def _set_mirror_interface(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.__mirror_interface = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for mirror_interface, mapped from YANG variable /acl_state/vxlan_acl/extended_data/mirror_interface (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_mirror_interface is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mirror_interface() directly.
YANG Description: mirror interface | f336817:c0:m61 |
def _get_memory(self): | return self.__memory<EOL> | Getter method for memory, mapped from YANG variable /resource_monitor/process/memory (container) | f336818:c0:m3 |
def _set_memory(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=memory.memory, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': 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.__memory = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for memory, mapped from YANG variable /resource_monitor/process/memory (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_memory is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_memory() directly. | f336818:c0:m4 |
def _get_enable_process(self): | return self.__enable_process<EOL> | Getter method for enable_process, mapped from YANG variable /resource_monitor/process/memory/enable_process (empty) | f336819:c0:m3 |
def _set_enable_process(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', 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.__enable_process = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for enable_process, mapped from YANG variable /resource_monitor/process/memory/enable_process (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_enable_process is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_enable_process() directly. | f336819:c0:m4 |
def _get_thresh_mem_alarm(self): | return self.__thresh_mem_alarm<EOL> | Getter method for thresh_mem_alarm, mapped from YANG variable /resource_monitor/process/memory/thresh_mem_alarm (uint32) | f336819:c0:m6 |
def _set_thresh_mem_alarm(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:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=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.__thresh_mem_alarm = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for thresh_mem_alarm, mapped from YANG variable /resource_monitor/process/memory/thresh_mem_alarm (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_thresh_mem_alarm is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_thresh_mem_alarm() directly. | f336819:c0:m7 |
def _get_thresh_mem_critic(self): | return self.__thresh_mem_critic<EOL> | Getter method for thresh_mem_critic, mapped from YANG variable /resource_monitor/process/memory/thresh_mem_critic (uint32) | f336819:c0:m9 |
def _set_thresh_mem_critic(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:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=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.__thresh_mem_critic = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for thresh_mem_critic, mapped from YANG variable /resource_monitor/process/memory/thresh_mem_critic (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_thresh_mem_critic is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_thresh_mem_critic() directly. | f336819:c0:m10 |
def _get_cpu(self): | return self.__cpu<EOL> | Getter method for cpu, mapped from YANG variable /resource_monitor/cpu (container) | f336820:c0:m3 |
def _set_cpu(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=cpu.cpu, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', 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.__cpu = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for cpu, mapped from YANG variable /resource_monitor/cpu (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_cpu is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cpu() directly. | f336820:c0:m4 |
def _get_memory(self): | return self.__memory<EOL> | Getter method for memory, mapped from YANG variable /resource_monitor/memory (container) | f336820:c0:m6 |
def _set_memory(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=memory.memory, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', 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.__memory = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for memory, mapped from YANG variable /resource_monitor/memory (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_memory is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_memory() directly. | f336820:c0:m7 |
def _get_process(self): | return self.__process<EOL> | Getter method for process, mapped from YANG variable /resource_monitor/process (container) | f336820:c0:m9 |
def _set_process(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=process.process, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': 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.__process = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for process, mapped from YANG variable /resource_monitor/process (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_process is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_process() directly. | f336820:c0:m10 |
def _get_enable_cpu(self): | return self.__enable_cpu<EOL> | Getter method for enable_cpu, mapped from YANG variable /resource_monitor/cpu/enable_cpu (empty) | f336821:c0:m3 |
def _set_enable_cpu(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__enable_cpu = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for enable_cpu, mapped from YANG variable /resource_monitor/cpu/enable_cpu (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_enable_cpu is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_enable_cpu() directly. | f336821:c0:m4 |
def _get_threshold_cpu(self): | return self.__threshold_cpu<EOL> | Getter method for threshold_cpu, mapped from YANG variable /resource_monitor/cpu/threshold_cpu (uint32) | f336821:c0:m6 |
def _set_threshold_cpu(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:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=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.__threshold_cpu = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for threshold_cpu, mapped from YANG variable /resource_monitor/cpu/threshold_cpu (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_threshold_cpu is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_threshold_cpu() directly. | f336821:c0:m7 |
def _get_action_cpu(self): | return self.__action_cpu<EOL> | Getter method for action_cpu, mapped from YANG variable /resource_monitor/cpu/action_cpu (resource-monitor-actiontype) | f336821:c0:m9 |
def _set_action_cpu(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), is_leaf=True, yang_name="<STR_LIT>", 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:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT:action>', 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_cpu = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for action_cpu, mapped from YANG variable /resource_monitor/cpu/action_cpu (resource-monitor-actiontype)
If this variable is read-only (config: false) in the
source YANG file, then _set_action_cpu is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_action_cpu() directly. | f336821:c0:m10 |
def _get_sample_rate_cpu(self): | return self.__sample_rate_cpu<EOL> | Getter method for sample_rate_cpu, mapped from YANG variable /resource_monitor/cpu/sample_rate_cpu (uint32) | f336821:c0:m12 |
def _set_sample_rate_cpu(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:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=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.__sample_rate_cpu = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for sample_rate_cpu, mapped from YANG variable /resource_monitor/cpu/sample_rate_cpu (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_sample_rate_cpu is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sample_rate_cpu() directly. | f336821:c0:m13 |
def _get_logging_rate_cpu(self): | return self.__logging_rate_cpu<EOL> | Getter method for logging_rate_cpu, mapped from YANG variable /resource_monitor/cpu/logging_rate_cpu (uint32) | f336821:c0:m15 |
def _set_logging_rate_cpu(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:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=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.__logging_rate_cpu = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for logging_rate_cpu, mapped from YANG variable /resource_monitor/cpu/logging_rate_cpu (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_logging_rate_cpu is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_logging_rate_cpu() directly. | f336821:c0:m16 |
def _get_grace_period_cpu(self): | return self.__grace_period_cpu<EOL> | Getter method for grace_period_cpu, mapped from YANG variable /resource_monitor/cpu/grace_period_cpu (uint32) | f336821:c0:m18 |
def _set_grace_period_cpu(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:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=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.__grace_period_cpu = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for grace_period_cpu, mapped from YANG variable /resource_monitor/cpu/grace_period_cpu (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_grace_period_cpu is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_grace_period_cpu() directly. | f336821:c0:m19 |
def _get_offset_cpu(self): | return self.__offset_cpu<EOL> | Getter method for offset_cpu, mapped from YANG variable /resource_monitor/cpu/offset_cpu (uint32) | f336821:c0:m21 |
def _set_offset_cpu(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:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=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.__offset_cpu = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for offset_cpu, mapped from YANG variable /resource_monitor/cpu/offset_cpu (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_offset_cpu is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_offset_cpu() directly. | f336821:c0:m22 |
def _get_enable_memory(self): | return self.__enable_memory<EOL> | Getter method for enable_memory, mapped from YANG variable /resource_monitor/memory/enable_memory (empty) | f336822:c0:m3 |
def _set_enable_memory(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', 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.__enable_memory = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for enable_memory, mapped from YANG variable /resource_monitor/memory/enable_memory (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_enable_memory is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_enable_memory() directly. | f336822:c0:m4 |
def _get_threshold_memory(self): | return self.__threshold_memory<EOL> | Getter method for threshold_memory, mapped from YANG variable /resource_monitor/memory/threshold_memory (uint32) | f336822:c0:m6 |
def _set_threshold_memory(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:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=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.__threshold_memory = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for threshold_memory, mapped from YANG variable /resource_monitor/memory/threshold_memory (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_threshold_memory is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_threshold_memory() directly. | f336822:c0:m7 |
def _get_action_memory(self): | return self.__action_memory<EOL> | Getter method for action_memory, mapped from YANG variable /resource_monitor/memory/action_memory (resource-monitor-actiontype) | f336822:c0:m9 |
def _set_action_memory(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), is_leaf=True, yang_name="<STR_LIT>", 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:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT:action>', 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_memory = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for action_memory, mapped from YANG variable /resource_monitor/memory/action_memory (resource-monitor-actiontype)
If this variable is read-only (config: false) in the
source YANG file, then _set_action_memory is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_action_memory() directly. | f336822:c0:m10 |
def _get_sample_rate_memory(self): | return self.__sample_rate_memory<EOL> | Getter method for sample_rate_memory, mapped from YANG variable /resource_monitor/memory/sample_rate_memory (uint32) | f336822:c0:m12 |
def _set_sample_rate_memory(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:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=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.__sample_rate_memory = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for sample_rate_memory, mapped from YANG variable /resource_monitor/memory/sample_rate_memory (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_sample_rate_memory is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sample_rate_memory() directly. | f336822:c0:m13 |
def _get_logging_rate_memory(self): | return self.__logging_rate_memory<EOL> | Getter method for logging_rate_memory, mapped from YANG variable /resource_monitor/memory/logging_rate_memory (uint32) | f336822:c0:m15 |
def _set_logging_rate_memory(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:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=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.__logging_rate_memory = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for logging_rate_memory, mapped from YANG variable /resource_monitor/memory/logging_rate_memory (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_logging_rate_memory is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_logging_rate_memory() directly. | f336822:c0:m16 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.