signature stringlengths 8 3.44k | body stringlengths 0 1.41M | docstring stringlengths 1 122k | id stringlengths 5 17 |
|---|---|---|---|
def _get_map_name_cmd4(self): | return self.__map_name_cmd4<EOL> | Getter method for map_name_cmd4, mapped from YANG variable /qos_mpls/map_apply/apply_exp_dscp_map_name/map_name_cmd4 (map-name-type) | f335875:c0:m3 |
def _set_map_name_cmd4(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, choice=(u'<STR_LIT>', u'<STR_LIT>'), 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.__map_name_cmd4 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for map_name_cmd4, mapped from YANG variable /qos_mpls/map_apply/apply_exp_dscp_map_name/map_name_cmd4 (map-name-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_map_name_cmd4 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_map_name_cmd4() directly. | f335875:c0:m4 |
def _get_all_zero_map_cmd4(self): | return self.__all_zero_map_cmd4<EOL> | Getter method for all_zero_map_cmd4, mapped from YANG variable /qos_mpls/map_apply/apply_exp_dscp_map_name/all_zero_map_cmd4 (empty) | f335875:c0:m6 |
def _set_all_zero_map_cmd4(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, choice=(u'<STR_LIT>', u'<STR_LIT>'), 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.__all_zero_map_cmd4 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for all_zero_map_cmd4, mapped from YANG variable /qos_mpls/map_apply/apply_exp_dscp_map_name/all_zero_map_cmd4 (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_all_zero_map_cmd4 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_all_zero_map_cmd4() directly. | f335875:c0:m7 |
def _get_default_map_cmd4(self): | return self.__default_map_cmd4<EOL> | Getter method for default_map_cmd4, mapped from YANG variable /qos_mpls/map_apply/apply_exp_dscp_map_name/default_map_cmd4 (empty) | f335875:c0:m9 |
def _set_default_map_cmd4(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, choice=(u'<STR_LIT>', u'<STR_LIT>'), 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.__default_map_cmd4 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for default_map_cmd4, mapped from YANG variable /qos_mpls/map_apply/apply_exp_dscp_map_name/default_map_cmd4 (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_default_map_cmd4 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_default_map_cmd4() directly. | f335875:c0:m10 |
def _get_All_cmd4(self): | return self.__All_cmd4<EOL> | Getter method for All_cmd4, mapped from YANG variable /qos_mpls/map_apply/apply_exp_dscp_map_name/All_cmd4 (empty) | f335875:c0:m12 |
def _set_All_cmd4(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>'}}, 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.__All_cmd4 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for All_cmd4, mapped from YANG variable /qos_mpls/map_apply/apply_exp_dscp_map_name/All_cmd4 (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_All_cmd4 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_All_cmd4() directly. | f335875:c0:m13 |
def _get_map_name_cmd2(self): | return self.__map_name_cmd2<EOL> | Getter method for map_name_cmd2, mapped from YANG variable /qos_mpls/map_apply/apply_traffic_class_exp_map_name/map_name_cmd2 (map-name-type) | f335876:c0:m3 |
def _set_map_name_cmd2(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, choice=(u'<STR_LIT>', u'<STR_LIT>'), 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.__map_name_cmd2 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for map_name_cmd2, mapped from YANG variable /qos_mpls/map_apply/apply_traffic_class_exp_map_name/map_name_cmd2 (map-name-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_map_name_cmd2 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_map_name_cmd2() directly. | f335876:c0:m4 |
def _get_all_zero_map_cmd2(self): | return self.__all_zero_map_cmd2<EOL> | Getter method for all_zero_map_cmd2, mapped from YANG variable /qos_mpls/map_apply/apply_traffic_class_exp_map_name/all_zero_map_cmd2 (empty) | f335876:c0:m6 |
def _set_all_zero_map_cmd2(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, choice=(u'<STR_LIT>', u'<STR_LIT>'), 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.__all_zero_map_cmd2 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for all_zero_map_cmd2, mapped from YANG variable /qos_mpls/map_apply/apply_traffic_class_exp_map_name/all_zero_map_cmd2 (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_all_zero_map_cmd2 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_all_zero_map_cmd2() directly. | f335876:c0:m7 |
def _get_default_map_cmd2(self): | return self.__default_map_cmd2<EOL> | Getter method for default_map_cmd2, mapped from YANG variable /qos_mpls/map_apply/apply_traffic_class_exp_map_name/default_map_cmd2 (empty) | f335876:c0:m9 |
def _set_default_map_cmd2(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, choice=(u'<STR_LIT>', u'<STR_LIT>'), 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.__default_map_cmd2 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for default_map_cmd2, mapped from YANG variable /qos_mpls/map_apply/apply_traffic_class_exp_map_name/default_map_cmd2 (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_default_map_cmd2 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_default_map_cmd2() directly. | f335876:c0:m10 |
def _get_All_cmd2(self): | return self.__All_cmd2<EOL> | Getter method for All_cmd2, mapped from YANG variable /qos_mpls/map_apply/apply_traffic_class_exp_map_name/All_cmd2 (empty) | f335876:c0:m12 |
def _set_All_cmd2(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>'}}, 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.__All_cmd2 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for All_cmd2, mapped from YANG variable /qos_mpls/map_apply/apply_traffic_class_exp_map_name/All_cmd2 (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_All_cmd2 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_All_cmd2() directly. | f335876:c0:m13 |
def _get_apply_exp_traffic_class_map_name(self): | return self.__apply_exp_traffic_class_map_name<EOL> | Getter method for apply_exp_traffic_class_map_name, mapped from YANG variable /qos_mpls/map_apply/apply_exp_traffic_class_map_name (container) | f335877:c0:m3 |
def _set_apply_exp_traffic_class_map_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=apply_exp_traffic_class_map_name.apply_exp_traffic_class_map_name, 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.__apply_exp_traffic_class_map_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for apply_exp_traffic_class_map_name, mapped from YANG variable /qos_mpls/map_apply/apply_exp_traffic_class_map_name (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_apply_exp_traffic_class_map_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_apply_exp_traffic_class_map_name() directly. | f335877:c0:m4 |
def _get_apply_traffic_class_exp_map_name(self): | return self.__apply_traffic_class_exp_map_name<EOL> | Getter method for apply_traffic_class_exp_map_name, mapped from YANG variable /qos_mpls/map_apply/apply_traffic_class_exp_map_name (container) | f335877:c0:m6 |
def _set_apply_traffic_class_exp_map_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=apply_traffic_class_exp_map_name.apply_traffic_class_exp_map_name, 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.__apply_traffic_class_exp_map_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for apply_traffic_class_exp_map_name, mapped from YANG variable /qos_mpls/map_apply/apply_traffic_class_exp_map_name (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_apply_traffic_class_exp_map_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_apply_traffic_class_exp_map_name() directly. | f335877:c0:m7 |
def _get_apply_dscp_exp_map_name(self): | return self.__apply_dscp_exp_map_name<EOL> | Getter method for apply_dscp_exp_map_name, mapped from YANG variable /qos_mpls/map_apply/apply_dscp_exp_map_name (container) | f335877:c0:m9 |
def _set_apply_dscp_exp_map_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=apply_dscp_exp_map_name.apply_dscp_exp_map_name, 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.__apply_dscp_exp_map_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for apply_dscp_exp_map_name, mapped from YANG variable /qos_mpls/map_apply/apply_dscp_exp_map_name (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_apply_dscp_exp_map_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_apply_dscp_exp_map_name() directly. | f335877:c0:m10 |
def _get_apply_exp_dscp_map_name(self): | return self.__apply_exp_dscp_map_name<EOL> | Getter method for apply_exp_dscp_map_name, mapped from YANG variable /qos_mpls/map_apply/apply_exp_dscp_map_name (container) | f335877:c0:m12 |
def _set_apply_exp_dscp_map_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=apply_exp_dscp_map_name.apply_exp_dscp_map_name, 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.__apply_exp_dscp_map_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for apply_exp_dscp_map_name, mapped from YANG variable /qos_mpls/map_apply/apply_exp_dscp_map_name (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_apply_exp_dscp_map_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_apply_exp_dscp_map_name() directly. | f335877:c0:m13 |
def _get_apply_inexp_outexp_map_name(self): | return self.__apply_inexp_outexp_map_name<EOL> | Getter method for apply_inexp_outexp_map_name, mapped from YANG variable /qos_mpls/map_apply/apply_inexp_outexp_map_name (container) | f335877:c0:m15 |
def _set_apply_inexp_outexp_map_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=apply_inexp_outexp_map_name.apply_inexp_outexp_map_name, 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>': 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.__apply_inexp_outexp_map_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for apply_inexp_outexp_map_name, mapped from YANG variable /qos_mpls/map_apply/apply_inexp_outexp_map_name (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_apply_inexp_outexp_map_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_apply_inexp_outexp_map_name() directly. | f335877:c0:m16 |
def _get_map_name_cmd1(self): | return self.__map_name_cmd1<EOL> | Getter method for map_name_cmd1, mapped from YANG variable /qos_mpls/map_apply/apply_exp_traffic_class_map_name/map_name_cmd1 (map-name-type) | f335878:c0:m3 |
def _set_map_name_cmd1(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, choice=(u'<STR_LIT>', u'<STR_LIT>'), 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.__map_name_cmd1 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for map_name_cmd1, mapped from YANG variable /qos_mpls/map_apply/apply_exp_traffic_class_map_name/map_name_cmd1 (map-name-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_map_name_cmd1 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_map_name_cmd1() directly. | f335878:c0:m4 |
def _get_all_zero_map_cmd1(self): | return self.__all_zero_map_cmd1<EOL> | Getter method for all_zero_map_cmd1, mapped from YANG variable /qos_mpls/map_apply/apply_exp_traffic_class_map_name/all_zero_map_cmd1 (empty) | f335878:c0:m6 |
def _set_all_zero_map_cmd1(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, choice=(u'<STR_LIT>', u'<STR_LIT>'), 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.__all_zero_map_cmd1 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for all_zero_map_cmd1, mapped from YANG variable /qos_mpls/map_apply/apply_exp_traffic_class_map_name/all_zero_map_cmd1 (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_all_zero_map_cmd1 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_all_zero_map_cmd1() directly. | f335878:c0:m7 |
def _get_default_map_cmd1(self): | return self.__default_map_cmd1<EOL> | Getter method for default_map_cmd1, mapped from YANG variable /qos_mpls/map_apply/apply_exp_traffic_class_map_name/default_map_cmd1 (empty) | f335878:c0:m9 |
def _set_default_map_cmd1(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, choice=(u'<STR_LIT>', u'<STR_LIT>'), 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.__default_map_cmd1 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for default_map_cmd1, mapped from YANG variable /qos_mpls/map_apply/apply_exp_traffic_class_map_name/default_map_cmd1 (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_default_map_cmd1 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_default_map_cmd1() directly. | f335878:c0:m10 |
def _get_All_cmd1(self): | return self.__All_cmd1<EOL> | Getter method for All_cmd1, mapped from YANG variable /qos_mpls/map_apply/apply_exp_traffic_class_map_name/All_cmd1 (empty) | f335878:c0:m12 |
def _set_All_cmd1(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>'}}, 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.__All_cmd1 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for All_cmd1, mapped from YANG variable /qos_mpls/map_apply/apply_exp_traffic_class_map_name/All_cmd1 (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_All_cmd1 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_All_cmd1() directly. | f335878:c0:m13 |
def _get_map_name_cmd5(self): | return self.__map_name_cmd5<EOL> | Getter method for map_name_cmd5, mapped from YANG variable /qos_mpls/map_apply/apply_inexp_outexp_map_name/map_name_cmd5 (map-name-type) | f335879:c0:m3 |
def _set_map_name_cmd5(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, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': 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.__map_name_cmd5 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for map_name_cmd5, mapped from YANG variable /qos_mpls/map_apply/apply_inexp_outexp_map_name/map_name_cmd5 (map-name-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_map_name_cmd5 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_map_name_cmd5() directly. | f335879:c0:m4 |
def _get_all_zero_map_cmd5(self): | return self.__all_zero_map_cmd5<EOL> | Getter method for all_zero_map_cmd5, mapped from YANG variable /qos_mpls/map_apply/apply_inexp_outexp_map_name/all_zero_map_cmd5 (empty) | f335879:c0:m6 |
def _set_all_zero_map_cmd5(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, choice=(u'<STR_LIT>', u'<STR_LIT>'), 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.__all_zero_map_cmd5 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for all_zero_map_cmd5, mapped from YANG variable /qos_mpls/map_apply/apply_inexp_outexp_map_name/all_zero_map_cmd5 (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_all_zero_map_cmd5 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_all_zero_map_cmd5() directly. | f335879:c0:m7 |
def _get_default_map_cmd5(self): | return self.__default_map_cmd5<EOL> | Getter method for default_map_cmd5, mapped from YANG variable /qos_mpls/map_apply/apply_inexp_outexp_map_name/default_map_cmd5 (empty) | f335879:c0:m9 |
def _set_default_map_cmd5(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, choice=(u'<STR_LIT>', u'<STR_LIT>'), 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.__default_map_cmd5 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for default_map_cmd5, mapped from YANG variable /qos_mpls/map_apply/apply_inexp_outexp_map_name/default_map_cmd5 (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_default_map_cmd5 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_default_map_cmd5() directly. | f335879:c0:m10 |
def _get_All_cmd5(self): | return self.__All_cmd5<EOL> | Getter method for All_cmd5, mapped from YANG variable /qos_mpls/map_apply/apply_inexp_outexp_map_name/All_cmd5 (empty) | f335879:c0:m12 |
def _set_All_cmd5(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>'}}, 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.__All_cmd5 = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for All_cmd5, mapped from YANG variable /qos_mpls/map_apply/apply_inexp_outexp_map_name/All_cmd5 (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_All_cmd5 is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_All_cmd5() directly. | f335879:c0:m13 |
def _get_map_(self): | return self.__map_<EOL> | Getter method for map_, mapped from YANG variable /qos_mpls/map (container) | f335880:c0:m3 |
def _set_map_(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=map_.map_, 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>'}}, 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.__map_ = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for map_, mapped from YANG variable /qos_mpls/map (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_map_ is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_map_() directly. | f335880:c0:m4 |
def _get_map_apply(self): | return self.__map_apply<EOL> | Getter method for map_apply, mapped from YANG variable /qos_mpls/map_apply (container) | f335880:c0:m6 |
def _set_map_apply(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=map_apply.map_apply, 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>': 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.__map_apply = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for map_apply, mapped from YANG variable /qos_mpls/map_apply (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_map_apply is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_map_apply() directly. | f335880:c0:m7 |
def _get_fcoe_fabric_map_name(self): | return self.__fcoe_fabric_map_name<EOL> | Getter method for fcoe_fabric_map_name, mapped from YANG variable /fcoe/fcoe_fabric_map/fcoe_fabric_map_name (fcoe-fabric-map-name-type)
YANG Description: This specifies the name for the FCoE fabric map. | f335881:c0:m3 |
def _set_fcoe_fabric_map_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=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:info>': 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.__fcoe_fabric_map_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fcoe_fabric_map_name, mapped from YANG variable /fcoe/fcoe_fabric_map/fcoe_fabric_map_name (fcoe-fabric-map-name-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_fcoe_fabric_map_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fcoe_fabric_map_name() directly.
YANG Description: This specifies the name for the FCoE fabric map. | f335881:c0:m4 |
def _get_fcoe_fabric_map_vlan(self): | return self.__fcoe_fabric_map_vlan<EOL> | Getter method for fcoe_fabric_map_vlan, mapped from YANG variable /fcoe/fcoe_fabric_map/fcoe_fabric_map_vlan (fcoe-vlan-type)
YANG Description: This specifies the VLAN for the FCoE Fabric Map. | f335881:c0:m6 |
def _set_fcoe_fabric_map_vlan(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT: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.__fcoe_fabric_map_vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fcoe_fabric_map_vlan, mapped from YANG variable /fcoe/fcoe_fabric_map/fcoe_fabric_map_vlan (fcoe-vlan-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_fcoe_fabric_map_vlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fcoe_fabric_map_vlan() directly.
YANG Description: This specifies the VLAN for the FCoE Fabric Map. | f335881:c0:m7 |
def _get_fcoe_fabric_mode(self): | return self.__fcoe_fabric_mode<EOL> | Getter method for fcoe_fabric_mode, mapped from YANG variable /fcoe/fcoe_fabric_map/fcoe_fabric_mode (fcoe-fabric-mode-type)
YANG Description: This specifies the san mode. | f335881:c0:m9 |
def _set_fcoe_fabric_mode(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>', '<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, 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.__fcoe_fabric_mode = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fcoe_fabric_mode, mapped from YANG variable /fcoe/fcoe_fabric_map/fcoe_fabric_mode (fcoe-fabric-mode-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_fcoe_fabric_mode is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fcoe_fabric_mode() directly.
YANG Description: This specifies the san mode. | f335881:c0:m10 |
def _get_fcoe_fabric_map_priority(self): | return self.__fcoe_fabric_map_priority<EOL> | Getter method for fcoe_fabric_map_priority, mapped from YANG variable /fcoe/fcoe_fabric_map/fcoe_fabric_map_priority (fcoe-priority-type)
YANG Description: This specifies the priority for the FCoE
Fabric-map. | f335881:c0:m12 |
def _set_fcoe_fabric_map_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=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:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__fcoe_fabric_map_priority = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fcoe_fabric_map_priority, mapped from YANG variable /fcoe/fcoe_fabric_map/fcoe_fabric_map_priority (fcoe-priority-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_fcoe_fabric_map_priority is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fcoe_fabric_map_priority() directly.
YANG Description: This specifies the priority for the FCoE
Fabric-map. | f335881:c0:m13 |
def _get_fcoe_fabric_map_virtual_fabric(self): | return self.__fcoe_fabric_map_virtual_fabric<EOL> | Getter method for fcoe_fabric_map_virtual_fabric, mapped from YANG variable /fcoe/fcoe_fabric_map/fcoe_fabric_map_virtual_fabric (fcoe-vfid-type)
YANG Description: This specifies the Virtual Fabric ID for the
Fabric-map. | f335881:c0:m15 |
def _set_fcoe_fabric_map_virtual_fabric(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__fcoe_fabric_map_virtual_fabric = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fcoe_fabric_map_virtual_fabric, mapped from YANG variable /fcoe/fcoe_fabric_map/fcoe_fabric_map_virtual_fabric (fcoe-vfid-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_fcoe_fabric_map_virtual_fabric is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fcoe_fabric_map_virtual_fabric() directly.
YANG Description: This specifies the Virtual Fabric ID for the
Fabric-map. | f335881:c0:m16 |
def _get_fcoe_fabric_map_fcmap(self): | return self.__fcoe_fabric_map_fcmap<EOL> | Getter method for fcoe_fabric_map_fcmap, mapped from YANG variable /fcoe/fcoe_fabric_map/fcoe_fabric_map_fcmap (fcoe-fcmap-type)
YANG Description: This specifies the FCMAP value for a FCoE
Fabric-map. | f335881:c0:m18 |
def _set_fcoe_fabric_map_fcmap(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>', '<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, 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.__fcoe_fabric_map_fcmap = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fcoe_fabric_map_fcmap, mapped from YANG variable /fcoe/fcoe_fabric_map/fcoe_fabric_map_fcmap (fcoe-fcmap-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_fcoe_fabric_map_fcmap is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fcoe_fabric_map_fcmap() directly.
YANG Description: This specifies the FCMAP value for a FCoE
Fabric-map. | f335881:c0:m19 |
def _get_fcoe_fip_advertisement(self): | return self.__fcoe_fip_advertisement<EOL> | Getter method for fcoe_fip_advertisement, mapped from YANG variable /fcoe/fcoe_fabric_map/fcoe_fip_advertisement (container)
YANG Description: This provides the grouping of all FIP configuration
elements. | f335881:c0:m21 |
def _set_fcoe_fip_advertisement(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=fcoe_fip_advertisement.fcoe_fip_advertisement, 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.__fcoe_fip_advertisement = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fcoe_fip_advertisement, mapped from YANG variable /fcoe/fcoe_fabric_map/fcoe_fip_advertisement (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_fcoe_fip_advertisement is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fcoe_fip_advertisement() directly.
YANG Description: This provides the grouping of all FIP configuration
elements. | f335881:c0:m22 |
def _get_fcoe_fip_keep_alive(self): | return self.__fcoe_fip_keep_alive<EOL> | Getter method for fcoe_fip_keep_alive, mapped from YANG variable /fcoe/fcoe_fabric_map/fcoe_fip_keep_alive (container)
YANG Description: This provides the grouping of FCoE keep alive
configuration elements. | f335881:c0:m24 |
def _set_fcoe_fip_keep_alive(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=fcoe_fip_keep_alive.fcoe_fip_keep_alive, 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.__fcoe_fip_keep_alive = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fcoe_fip_keep_alive, mapped from YANG variable /fcoe/fcoe_fabric_map/fcoe_fip_keep_alive (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_fcoe_fip_keep_alive is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fcoe_fip_keep_alive() directly.
YANG Description: This provides the grouping of FCoE keep alive
configuration elements. | f335881:c0:m25 |
def _get_fcoe_fcf_map(self): | return self.__fcoe_fcf_map<EOL> | Getter method for fcoe_fcf_map, mapped from YANG variable /fcoe/fcoe_fabric_map/fcoe_fcf_map (list)
YANG Description: The list of FCF Groups. Each row contains the FCF group
name, member FCoE map, FCF rbid and FDF rbids | f335881:c0:m27 |
def _set_fcoe_fcf_map(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>",fcoe_fcf_map.fcoe_fcf_map, 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, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT:info>': 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>', u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__fcoe_fcf_map = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fcoe_fcf_map, mapped from YANG variable /fcoe/fcoe_fabric_map/fcoe_fcf_map (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_fcoe_fcf_map is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fcoe_fcf_map() directly.
YANG Description: The list of FCF Groups. Each row contains the FCF group
name, member FCoE map, FCF rbid and FDF rbids | f335881:c0:m28 |
def _get_fcoe_fcport_group_config(self): | return self.__fcoe_fcport_group_config<EOL> | Getter method for fcoe_fcport_group_config, mapped from YANG variable /fcoe/fcoe_fabric_map/fcoe_fcport_group_config (container)
YANG Description: This specifies the fcport-group parameters for the fabric-map | f335881:c0:m30 |
def _set_fcoe_fcport_group_config(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=fcoe_fcport_group_config.fcoe_fcport_group_config, 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, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__fcoe_fcport_group_config = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for fcoe_fcport_group_config, mapped from YANG variable /fcoe/fcoe_fabric_map/fcoe_fcport_group_config (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_fcoe_fcport_group_config is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_fcoe_fcport_group_config() directly.
YANG Description: This specifies the fcport-group parameters for the fabric-map | f335881:c0:m31 |
def _get_trigger_id(self): | return self.__trigger_id<EOL> | Getter method for trigger_id, mapped from YANG variable /event_handler/event_handler_list/trigger/trigger_id (uint32) | f335882:c0:m3 |
def _set_trigger_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: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, 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.__trigger_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for trigger_id, mapped from YANG variable /event_handler/event_handler_list/trigger/trigger_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_trigger_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_trigger_id() directly. | f335882:c0:m4 |
def _get_vcs(self): | return self.__vcs<EOL> | Getter method for vcs, mapped from YANG variable /event_handler/event_handler_list/trigger/vcs (enumeration)
YANG Description: VCS event type. | f335882:c0:m6 |
def _set_vcs(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__vcs = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vcs, mapped from YANG variable /event_handler/event_handler_list/trigger/vcs (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_vcs is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vcs() directly.
YANG Description: VCS event type. | f335882:c0:m7 |
def _get_raslog(self): | return self.__raslog<EOL> | Getter method for raslog, mapped from YANG variable /event_handler/event_handler_list/trigger/raslog (container)
YANG Description: RASlog Id. | f335882:c0:m9 |
def _set_raslog(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=raslog.raslog, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, 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.__raslog = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for raslog, mapped from YANG variable /event_handler/event_handler_list/trigger/raslog (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_raslog is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_raslog() directly.
YANG Description: RASlog Id. | f335882:c0:m10 |
def _get_event_handler_list(self): | return self.__event_handler_list<EOL> | Getter method for event_handler_list, mapped from YANG variable /event_handler/event_handler_list (list) | f335883:c0:m3 |
def _set_event_handler_list(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT:name>",event_handler_list.event_handler_list, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT:name>', extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, 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:info>': u'<STR_LIT>', u'<STR_LIT>': None, 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:list>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__event_handler_list = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for event_handler_list, mapped from YANG variable /event_handler/event_handler_list (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_event_handler_list is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_event_handler_list() directly. | f335883:c0:m4 |
def _get_activate(self): | return self.__activate<EOL> | Getter method for activate, mapped from YANG variable /event_handler/activate (container) | f335883:c0:m6 |
def _set_activate(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=activate.activate, 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>': 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.__activate = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for activate, mapped from YANG variable /event_handler/activate (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_activate is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_activate() directly. | f335883:c0:m7 |
def _get_name(self): | return self.__name<EOL> | Getter method for name, mapped from YANG variable /event_handler/activate/name/name (common-def:name-string32)
YANG Description: Event handler name | f335884:c0:m3 |
def _set_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=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT:name>", rest_name="<STR_LIT:name>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>'}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for name, mapped from YANG variable /event_handler/activate/name/name (common-def:name-string32)
If this variable is read-only (config: false) in the
source YANG file, then _set_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_name() directly.
YANG Description: Event handler name | f335884:c0:m4 |
def _get_delay(self): | return self.__delay<EOL> | Getter method for delay, mapped from YANG variable /event_handler/activate/name/delay (uint32) | f335884:c0:m6 |
def _set_delay(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>), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_LIT:0>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>'}}, 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.__delay = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for delay, mapped from YANG variable /event_handler/activate/name/delay (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_delay is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_delay() directly. | f335884:c0:m7 |
def _get_iterations(self): | return self.__iterations<EOL> | Getter method for iterations, mapped from YANG variable /event_handler/activate/name/iterations (uint32) | f335884:c0:m9 |
def _set_iterations(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>), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_LIT:1>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__iterations = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for iterations, mapped from YANG variable /event_handler/activate/name/iterations (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_iterations is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_iterations() directly. | f335884:c0:m10 |
def _get_interval(self): | return self.__interval<EOL> | Getter method for interval, mapped from YANG variable /event_handler/activate/name/interval (uint32) | f335884:c0:m12 |
def _set_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>), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_LIT:0>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>'}}, 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.__interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for interval, mapped from YANG variable /event_handler/activate/name/interval (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interval() directly. | f335884:c0:m13 |
def _get_run_mode(self): | return self.__run_mode<EOL> | Getter method for run_mode, mapped from YANG variable /event_handler/activate/name/run_mode (enumeration) | f335884:c0:m15 |
def _set_run_mode(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), default=unicode("<STR_LIT>"), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__run_mode = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for run_mode, mapped from YANG variable /event_handler/activate/name/run_mode (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_run_mode is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_run_mode() directly. | f335884:c0:m16 |
def _get_trigger_mode(self): | return self.__trigger_mode<EOL> | Getter method for trigger_mode, mapped from YANG variable /event_handler/activate/name/trigger_mode (enumeration) | f335884:c0:m18 |
def _set_trigger_mode(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), default=unicode("<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>'}}, 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.__trigger_mode = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for trigger_mode, mapped from YANG variable /event_handler/activate/name/trigger_mode (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_trigger_mode is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_trigger_mode() directly. | f335884:c0:m19 |
def _get_trigger_function(self): | return self.__trigger_function<EOL> | Getter method for trigger_function, mapped from YANG variable /event_handler/activate/name/trigger_function (container)
YANG Description: Trigger-function controls how multiple triggers are interpreted to launch the action (default = OR). | f335884:c0:m21 |
def _set_trigger_function(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=trigger_function.trigger_function, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, 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.__trigger_function = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for trigger_function, mapped from YANG variable /event_handler/activate/name/trigger_function (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_trigger_function is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_trigger_function() directly.
YANG Description: Trigger-function controls how multiple triggers are interpreted to launch the action (default = OR). | f335884:c0:m22 |
def _get_action_timeout(self): | return self.__action_timeout<EOL> | Getter method for action_timeout, mapped from YANG variable /event_handler/activate/name/action_timeout (uint32) | f335884:c0:m24 |
def _set_action_timeout(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>), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_LIT:0>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>'}}, 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_timeout = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for action_timeout, mapped from YANG variable /event_handler/activate/name/action_timeout (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_action_timeout is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_action_timeout() directly. | f335884:c0:m25 |
def _get_trigger_function(self): | return self.__trigger_function<EOL> | Getter method for trigger_function, mapped from YANG variable /event_handler/activate/name/trigger_function/trigger_function (enumeration) | f335885:c0:m3 |
def _set_trigger_function(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), default=unicode("<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>': 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.__trigger_function = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for trigger_function, mapped from YANG variable /event_handler/activate/name/trigger_function/trigger_function (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_trigger_function is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_trigger_function() directly. | f335885:c0:m4 |
def _get_time_window(self): | return self.__time_window<EOL> | Getter method for time_window, mapped from YANG variable /event_handler/activate/name/trigger_function/time_window (uint32) | f335885:c0:m6 |
def _set_time_window(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, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__time_window = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for time_window, mapped from YANG variable /event_handler/activate/name/trigger_function/time_window (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_time_window is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_time_window() directly. | f335885:c0:m7 |
def _get_name(self): | return self.__name<EOL> | Getter method for name, mapped from YANG variable /event_handler/activate/name (list) | f335886:c0:m3 |
def _set_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=YANGListType("<STR_LIT:name>",name.name, yang_name="<STR_LIT:name>", rest_name="<STR_LIT:name>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT:name>', extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT:name>", rest_name="<STR_LIT:name>", 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, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for name, mapped from YANG variable /event_handler/activate/name (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_name() directly. | f335886:c0:m4 |
def _get_openflow(self): | return self.__openflow<EOL> | Getter method for openflow, mapped from YANG variable /openflow_global/openflow (container) | f335887:c0:m3 |
def _set_openflow(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=openflow.openflow, 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>'}}, 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.__openflow = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for openflow, mapped from YANG variable /openflow_global/openflow (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_openflow is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_openflow() directly. | f335887:c0:m4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.