signature
stringlengths 8
3.44k
| body
stringlengths 0
1.41M
| docstring
stringlengths 1
122k
| id
stringlengths 5
17
|
|---|---|---|---|
def _get_nw_tos(self): | return self.__nw_tos<EOL> | Getter method for nw_tos, mapped from YANG variable /openflow_state/flow_id/nw_tos (uint32)
YANG Description: IP DSCP | f336800:c0:m54 |
def _set_nw_tos(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.__nw_tos = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for nw_tos, mapped from YANG variable /openflow_state/flow_id/nw_tos (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_nw_tos is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_nw_tos() directly.
YANG Description: IP DSCP | f336800:c0:m55 |
def _get_source_ip_mask(self): | return self.__source_ip_mask<EOL> | Getter method for source_ip_mask, mapped from YANG variable /openflow_state/flow_id/source_ip_mask (string)
YANG Description: Source IPv4 Mask | f336800:c0:m57 |
def _set_source_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=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.__source_ip_mask = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for source_ip_mask, mapped from YANG variable /openflow_state/flow_id/source_ip_mask (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_source_ip_mask is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_source_ip_mask() directly.
YANG Description: Source IPv4 Mask | f336800:c0:m58 |
def _get_destination_ip_mask(self): | return self.__destination_ip_mask<EOL> | Getter method for destination_ip_mask, mapped from YANG variable /openflow_state/flow_id/destination_ip_mask (string)
YANG Description: Destination IPv4 Mask | f336800:c0:m60 |
def _set_destination_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=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.__destination_ip_mask = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for destination_ip_mask, mapped from YANG variable /openflow_state/flow_id/destination_ip_mask (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_destination_ip_mask is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_destination_ip_mask() directly.
YANG Description: Destination IPv4 Mask | f336800:c0:m61 |
def _get_total_packets(self): | return self.__total_packets<EOL> | Getter method for total_packets, mapped from YANG variable /openflow_state/flow_id/total_packets (uint32)
YANG Description: Total Packets | f336800:c0:m63 |
def _set_total_packets(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.__total_packets = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for total_packets, mapped from YANG variable /openflow_state/flow_id/total_packets (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_total_packets is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_total_packets() directly.
YANG Description: Total Packets | f336800:c0:m64 |
def _get_total_bytes(self): | return self.__total_bytes<EOL> | Getter method for total_bytes, mapped from YANG variable /openflow_state/flow_id/total_bytes (uint32)
YANG Description: Total Bytes | f336800:c0:m66 |
def _set_total_bytes(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.__total_bytes = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for total_bytes, mapped from YANG variable /openflow_state/flow_id/total_bytes (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_total_bytes is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_total_bytes() directly.
YANG Description: Total Bytes | f336800:c0:m67 |
def _get_flow_action_list(self): | return self.__flow_action_list<EOL> | Getter method for flow_action_list, mapped from YANG variable /openflow_state/flow_id/flow_action_list (list)
YANG Description: Details of an action | f336800:c0:m69 |
def _set_flow_action_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>",flow_action_list.flow_action_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>', 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.__flow_action_list = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for flow_action_list, mapped from YANG variable /openflow_state/flow_id/flow_action_list (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_flow_action_list is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_flow_action_list() directly.
YANG Description: Details of an action | f336800:c0:m70 |
def _get_flow_id(self): | return self.__flow_id<EOL> | Getter method for flow_id, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/flow_id (uint32)
YANG Description: Flow ID | f336801:c0:m3 |
def _set_flow_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=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.__flow_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for flow_id, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/flow_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_flow_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_flow_id() directly.
YANG Description: Flow ID | f336801:c0:m4 |
def _get_priority(self): | return self.__priority<EOL> | Getter method for priority, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/priority (uint32)
YANG Description: Priority | f336801:c0:m6 |
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=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.__priority = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for priority, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/priority (uint32)
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: Priority | f336801:c0:m7 |
def _get_status(self): | return self.__status<EOL> | Getter method for status, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/status (flow-status)
YANG Description: Status | f336801:c0:m9 |
def _set_status(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:4>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}},), is_leaf=True, yang_name="<STR_LIT:status>", rest_name="<STR_LIT:status>", 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.__status = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for status, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/status (flow-status)
If this variable is read-only (config: false) in the
source YANG file, then _set_status is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_status() directly.
YANG Description: Status | f336801:c0:m10 |
def _get_in_port(self): | return self.__in_port<EOL> | Getter method for in_port, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/in_port (string)
YANG Description: In Port | f336801:c0:m12 |
def _set_in_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=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.__in_port = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for in_port, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/in_port (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_in_port is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_in_port() directly.
YANG Description: In Port | f336801:c0:m13 |
def _get_in_vlan(self): | return self.__in_vlan<EOL> | Getter method for in_vlan, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/in_vlan (string)
YANG Description: In Vlan | f336801:c0:m15 |
def _set_in_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=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.__in_vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for in_vlan, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/in_vlan (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_in_vlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_in_vlan() directly.
YANG Description: In Vlan | f336801:c0:m16 |
def _get_source_mac(self): | return self.__source_mac<EOL> | Getter method for source_mac, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/source_mac (string)
YANG Description: Source Mac | f336801:c0:m18 |
def _set_source_mac(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.__source_mac = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for source_mac, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/source_mac (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_source_mac is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_source_mac() directly.
YANG Description: Source Mac | f336801:c0:m19 |
def _get_destination_mac(self): | return self.__destination_mac<EOL> | Getter method for destination_mac, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/destination_mac (string)
YANG Description: Destination Mac | f336801:c0:m21 |
def _set_destination_mac(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.__destination_mac = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for destination_mac, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/destination_mac (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_destination_mac is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_destination_mac() directly.
YANG Description: Destination Mac | f336801:c0:m22 |
def _get_ether_type(self): | return self.__ether_type<EOL> | Getter method for ether_type, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/ether_type (string)
YANG Description: Ether type | f336801:c0:m24 |
def _set_ether_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__ether_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ether_type, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/ether_type (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_ether_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ether_type() directly.
YANG Description: Ether type | f336801:c0:m25 |
def _get_ip_protocol(self): | return self.__ip_protocol<EOL> | Getter method for ip_protocol, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/ip_protocol (uint32)
YANG Description: IP Protocol | f336801:c0:m27 |
def _set_ip_protocol(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.__ip_protocol = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ip_protocol, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/ip_protocol (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_ip_protocol is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ip_protocol() directly.
YANG Description: IP Protocol | f336801:c0:m28 |
def _get_ip_protocol_source_port(self): | return self.__ip_protocol_source_port<EOL> | Getter method for ip_protocol_source_port, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/ip_protocol_source_port (uint32)
YANG Description: IP Protocol Source Port | f336801:c0:m30 |
def _set_ip_protocol_source_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=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.__ip_protocol_source_port = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ip_protocol_source_port, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/ip_protocol_source_port (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_ip_protocol_source_port is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ip_protocol_source_port() directly.
YANG Description: IP Protocol Source Port | f336801:c0:m31 |
def _get_ip_protocol_destination_port(self): | return self.__ip_protocol_destination_port<EOL> | Getter method for ip_protocol_destination_port, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/ip_protocol_destination_port (uint32)
YANG Description: IP Protocol Destination Port | f336801:c0:m33 |
def _set_ip_protocol_destination_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=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.__ip_protocol_destination_port = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ip_protocol_destination_port, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/ip_protocol_destination_port (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_ip_protocol_destination_port is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ip_protocol_destination_port() directly.
YANG Description: IP Protocol Destination Port | f336801:c0:m34 |
def _get_source_ip(self): | return self.__source_ip<EOL> | Getter method for source_ip, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/source_ip (string)
YANG Description: Source IPv4 | f336801:c0:m36 |
def _set_source_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=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.__source_ip = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for source_ip, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/source_ip (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_source_ip is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_source_ip() directly.
YANG Description: Source IPv4 | f336801:c0:m37 |
def _get_destination_ip(self): | return self.__destination_ip<EOL> | Getter method for destination_ip, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/destination_ip (string)
YANG Description: Destination IPv4 | f336801:c0:m39 |
def _set_destination_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=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.__destination_ip = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for destination_ip, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/destination_ip (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_destination_ip is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_destination_ip() directly.
YANG Description: Destination IPv4 | f336801:c0:m40 |
def _get_instructions(self): | return self.__instructions<EOL> | Getter method for instructions, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/instructions (string)
YANG Description: Instructions | f336801:c0:m42 |
def _set_instructions(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.__instructions = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for instructions, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/instructions (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_instructions is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_instructions() directly.
YANG Description: Instructions | f336801:c0:m43 |
def _get_action_data(self): | return self.__action_data<EOL> | Getter method for action_data, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/action_data (string)
YANG Description: Action | f336801:c0:m45 |
def _set_action_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=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.__action_data = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for action_data, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/action_data (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_action_data is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_action_data() directly.
YANG Description: Action | f336801:c0:m46 |
def _get_meter_id(self): | return self.__meter_id<EOL> | Getter method for meter_id, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/meter_id (uint32)
YANG Description: Meter id | f336801:c0:m48 |
def _set_meter_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.__meter_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for meter_id, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/meter_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_meter_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_meter_id() directly.
YANG Description: Meter id | f336801:c0:m49 |
def _get_vlan_upbits(self): | return self.__vlan_upbits<EOL> | Getter method for vlan_upbits, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/vlan_upbits (uint32)
YANG Description: Vlan Priority | f336801:c0:m51 |
def _set_vlan_upbits(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_upbits = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for vlan_upbits, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/vlan_upbits (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_vlan_upbits is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vlan_upbits() directly.
YANG Description: Vlan Priority | f336801:c0:m52 |
def _get_nw_tos(self): | return self.__nw_tos<EOL> | Getter method for nw_tos, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/nw_tos (uint32)
YANG Description: IP DSCP | f336801:c0:m54 |
def _set_nw_tos(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.__nw_tos = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for nw_tos, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/nw_tos (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_nw_tos is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_nw_tos() directly.
YANG Description: IP DSCP | f336801:c0:m55 |
def _get_source_ip_mask(self): | return self.__source_ip_mask<EOL> | Getter method for source_ip_mask, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/source_ip_mask (string)
YANG Description: Source IPv4 Mask | f336801:c0:m57 |
def _set_source_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=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.__source_ip_mask = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for source_ip_mask, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/source_ip_mask (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_source_ip_mask is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_source_ip_mask() directly.
YANG Description: Source IPv4 Mask | f336801:c0:m58 |
def _get_destination_ip_mask(self): | return self.__destination_ip_mask<EOL> | Getter method for destination_ip_mask, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/destination_ip_mask (string)
YANG Description: Destination IPv4 Mask | f336801:c0:m60 |
def _set_destination_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=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.__destination_ip_mask = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for destination_ip_mask, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/destination_ip_mask (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_destination_ip_mask is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_destination_ip_mask() directly.
YANG Description: Destination IPv4 Mask | f336801:c0:m61 |
def _get_total_packets(self): | return self.__total_packets<EOL> | Getter method for total_packets, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/total_packets (uint32)
YANG Description: Total Packets | f336801:c0:m63 |
def _set_total_packets(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.__total_packets = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for total_packets, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/total_packets (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_total_packets is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_total_packets() directly.
YANG Description: Total Packets | f336801:c0:m64 |
def _get_total_bytes(self): | return self.__total_bytes<EOL> | Getter method for total_bytes, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/total_bytes (uint32)
YANG Description: Total Bytes | f336801:c0:m66 |
def _set_total_bytes(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.__total_bytes = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for total_bytes, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/total_bytes (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_total_bytes is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_total_bytes() directly.
YANG Description: Total Bytes | f336801:c0:m67 |
def _get_flow_action_list(self): | return self.__flow_action_list<EOL> | Getter method for flow_action_list, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/flow_action_list (list)
YANG Description: Details of an action | f336801:c0:m69 |
def _set_flow_action_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>",flow_action_list.flow_action_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>', 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.__flow_action_list = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for flow_action_list, mapped from YANG variable /openflow_state/flow_interface/flow_info_list/flow_action_list (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_flow_action_list is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_flow_action_list() directly.
YANG Description: Details of an action | f336801:c0:m70 |
def _get_admin_status(self): | return self.__admin_status<EOL> | Getter method for admin_status, mapped from YANG variable /openflow_state/detail/admin_status (boolean)
YANG Description: Admin status Enabled or Disabled | f336802:c0:m3 |
def _set_admin_status(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.__admin_status = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for admin_status, mapped from YANG variable /openflow_state/detail/admin_status (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_admin_status is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_admin_status() directly.
YANG Description: Admin status Enabled or Disabled | f336802:c0:m4 |
def _get_ssl_status(self): | return self.__ssl_status<EOL> | Getter method for ssl_status, mapped from YANG variable /openflow_state/detail/ssl_status (boolean)
YANG Description: SSL status Enabled or Disabled | f336802:c0:m6 |
def _set_ssl_status(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.__ssl_status = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for ssl_status, mapped from YANG variable /openflow_state/detail/ssl_status (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_ssl_status is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ssl_status() directly.
YANG Description: SSL status Enabled or Disabled | f336802:c0:m7 |
def _get_num_controllers(self): | return self.__num_controllers<EOL> | Getter method for num_controllers, mapped from YANG variable /openflow_state/detail/num_controllers (uint32)
YANG Description: Number of controllers | f336802:c0:m9 |
def _set_num_controllers(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.__num_controllers = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for num_controllers, mapped from YANG variable /openflow_state/detail/num_controllers (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_num_controllers is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_num_controllers() directly.
YANG Description: Number of controllers | f336802:c0:m10 |
def _get_data_path(self): | return self.__data_path<EOL> | Getter method for data_path, mapped from YANG variable /openflow_state/detail/data_path (string)
YANG Description: Data path | f336802:c0:m12 |
def _set_data_path(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.__data_path = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for data_path, mapped from YANG variable /openflow_state/detail/data_path (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_data_path is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_data_path() directly.
YANG Description: Data path | f336802:c0:m13 |
def _get_l2_match(self): | return self.__l2_match<EOL> | Getter method for l2_match, mapped from YANG variable /openflow_state/detail/l2_match (string)
YANG Description: L2 match | f336802:c0:m15 |
def _set_l2_match(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.__l2_match = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for l2_match, mapped from YANG variable /openflow_state/detail/l2_match (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_l2_match is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_l2_match() directly.
YANG Description: L2 match | f336802:c0:m16 |
def _get_l3_match(self): | return self.__l3_match<EOL> | Getter method for l3_match, mapped from YANG variable /openflow_state/detail/l3_match (string)
YANG Description: L3 match | f336802:c0:m18 |
def _set_l3_match(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.__l3_match = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for l3_match, mapped from YANG variable /openflow_state/detail/l3_match (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_l3_match is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_l3_match() directly.
YANG Description: L3 match | f336802:c0:m19 |
def _get_max_l2_flows(self): | return self.__max_l2_flows<EOL> | Getter method for max_l2_flows, mapped from YANG variable /openflow_state/detail/max_l2_flows (uint32)
YANG Description: Maximum number of flows allowed | f336802:c0:m21 |
def _set_max_l2_flows(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.__max_l2_flows = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for max_l2_flows, mapped from YANG variable /openflow_state/detail/max_l2_flows (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_max_l2_flows is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_max_l2_flows() directly.
YANG Description: Maximum number of flows allowed | f336802:c0:m22 |
def _get_active_flows(self): | return self.__active_flows<EOL> | Getter method for active_flows, mapped from YANG variable /openflow_state/detail/active_flows (uint32)
YANG Description: Active flows | f336802:c0:m24 |
def _set_active_flows(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.__active_flows = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for active_flows, mapped from YANG variable /openflow_state/detail/active_flows (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_active_flows is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_active_flows() directly.
YANG Description: Active flows | f336802:c0:m25 |
def _get_enabled_ports(self): | return self.__enabled_ports<EOL> | Getter method for enabled_ports, mapped from YANG variable /openflow_state/detail/enabled_ports (string)
YANG Description: Openflow Enabled Ports | f336802:c0:m27 |
def _set_enabled_ports(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.__enabled_ports = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for enabled_ports, mapped from YANG variable /openflow_state/detail/enabled_ports (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_enabled_ports is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_enabled_ports() directly.
YANG Description: Openflow Enabled Ports | f336802:c0:m28 |
def _get_default_action(self): | return self.__default_action<EOL> | Getter method for default_action, mapped from YANG variable /openflow_state/detail/default_action (default-packet-action)
YANG Description: Default action | f336802:c0:m30 |
def _set_default_action(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), 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.__default_action = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for default_action, mapped from YANG variable /openflow_state/detail/default_action (default-packet-action)
If this variable is read-only (config: false) in the
source YANG file, then _set_default_action is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_default_action() directly.
YANG Description: Default action | f336802:c0:m31 |
def _get_controller_detail_list(self): | return self.__controller_detail_list<EOL> | Getter method for controller_detail_list, mapped from YANG variable /openflow_state/detail/controller_detail_list (list)
YANG Description: Controller detail | f336802:c0:m33 |
def _set_controller_detail_list(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",controller_detail_list.controller_detail_list, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', 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.__controller_detail_list = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for controller_detail_list, mapped from YANG variable /openflow_state/detail/controller_detail_list (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_controller_detail_list is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_controller_detail_list() directly.
YANG Description: Controller detail | f336802:c0:m34 |
def _get_hybrid_interfaces(self): | return self.__hybrid_interfaces<EOL> | Getter method for hybrid_interfaces, mapped from YANG variable /openflow_state/detail/hybrid_interfaces (list) | f336802:c0:m36 |
def _set_hybrid_interfaces(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>",hybrid_interfaces.hybrid_interfaces, 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.__hybrid_interfaces = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hybrid_interfaces, mapped from YANG variable /openflow_state/detail/hybrid_interfaces (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_hybrid_interfaces is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hybrid_interfaces() directly. | f336802:c0:m37 |
def _get_meter_id(self): | return self.__meter_id<EOL> | Getter method for meter_id, mapped from YANG variable /openflow_state/meter/meter_info_list/meter_id (uint32)
YANG Description: Meter id | f336803:c0:m3 |
def _set_meter_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=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.__meter_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for meter_id, mapped from YANG variable /openflow_state/meter/meter_info_list/meter_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_meter_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_meter_id() directly.
YANG Description: Meter id | f336803:c0:m4 |
def _get_transaction_id(self): | return self.__transaction_id<EOL> | Getter method for transaction_id, mapped from YANG variable /openflow_state/meter/meter_info_list/transaction_id (string)
YANG Description: Transaction id | f336803:c0:m6 |
def _set_transaction_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=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.__transaction_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for transaction_id, mapped from YANG variable /openflow_state/meter/meter_info_list/transaction_id (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_transaction_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_transaction_id() directly.
YANG Description: Transaction id | f336803:c0:m7 |
def _get_meterflags_type(self): | return self.__meterflags_type<EOL> | Getter method for meterflags_type, mapped from YANG variable /openflow_state/meter/meter_info_list/meterflags_type (string)
YANG Description: Meter flags | f336803:c0:m9 |
def _set_meterflags_type(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__meterflags_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for meterflags_type, mapped from YANG variable /openflow_state/meter/meter_info_list/meterflags_type (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_meterflags_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_meterflags_type() directly.
YANG Description: Meter flags | f336803:c0:m10 |
def _get_flow_count(self): | return self.__flow_count<EOL> | Getter method for flow_count, mapped from YANG variable /openflow_state/meter/meter_info_list/flow_count (uint32)
YANG Description: Flow Count | f336803:c0:m12 |
def _set_flow_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: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.__flow_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for flow_count, mapped from YANG variable /openflow_state/meter/meter_info_list/flow_count (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_flow_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_flow_count() directly.
YANG Description: Flow Count | f336803:c0:m13 |
def _get_num_of_bands(self): | return self.__num_of_bands<EOL> | Getter method for num_of_bands, mapped from YANG variable /openflow_state/meter/meter_info_list/num_of_bands (uint32)
YANG Description: Number of bands | f336803:c0:m15 |
def _set_num_of_bands(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.__num_of_bands = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for num_of_bands, mapped from YANG variable /openflow_state/meter/meter_info_list/num_of_bands (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_num_of_bands is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_num_of_bands() directly.
YANG Description: Number of bands | f336803:c0:m16 |
def _get_in_packet_count(self): | return self.__in_packet_count<EOL> | Getter method for in_packet_count, mapped from YANG variable /openflow_state/meter/meter_info_list/in_packet_count (uint32)
YANG Description: In packet count | f336803:c0:m18 |
def _set_in_packet_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: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.__in_packet_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for in_packet_count, mapped from YANG variable /openflow_state/meter/meter_info_list/in_packet_count (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_in_packet_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_in_packet_count() directly.
YANG Description: In packet count | f336803:c0:m19 |
def _get_in_byte_count(self): | return self.__in_byte_count<EOL> | Getter method for in_byte_count, mapped from YANG variable /openflow_state/meter/meter_info_list/in_byte_count (uint32)
YANG Description: In byte count | f336803:c0:m21 |
def _set_in_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: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.__in_byte_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for in_byte_count, mapped from YANG variable /openflow_state/meter/meter_info_list/in_byte_count (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_in_byte_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_in_byte_count() directly.
YANG Description: In byte count | f336803:c0:m22 |
def _get_meterband_info_list(self): | return self.__meterband_info_list<EOL> | Getter method for meterband_info_list, mapped from YANG variable /openflow_state/meter/meter_info_list/meterband_info_list (list)
YANG Description: Meterband details | f336803:c0:m24 |
def _set_meterband_info_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>",meterband_info_list.meterband_info_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>', 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.__meterband_info_list = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for meterband_info_list, mapped from YANG variable /openflow_state/meter/meter_info_list/meterband_info_list (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_meterband_info_list is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_meterband_info_list() directly.
YANG Description: Meterband details | f336803:c0:m25 |
def _get_band_type(self): | return self.__band_type<EOL> | Getter method for band_type, mapped from YANG variable /openflow_state/meter/meter_info_list/meterband_info_list/band_type (uint32)
YANG Description: Band Type | f336804:c0:m3 |
def _set_band_type(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.__band_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for band_type, mapped from YANG variable /openflow_state/meter/meter_info_list/meterband_info_list/band_type (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_band_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_band_type() directly.
YANG Description: Band Type | f336804:c0:m4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.