signature
stringlengths 8
3.44k
| body
stringlengths 0
1.41M
| docstring
stringlengths 1
122k
| id
stringlengths 5
17
|
|---|---|---|---|
def _get_source_ip(self): | return self.__source_ip<EOL> | Getter method for source_ip, mapped from YANG variable /openflow_state/flow/flow_info_list/source_ip (string)
YANG Description: Source IPv4 | f336796: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/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 | f336796:c0:m37 |
def _get_destination_ip(self): | return self.__destination_ip<EOL> | Getter method for destination_ip, mapped from YANG variable /openflow_state/flow/flow_info_list/destination_ip (string)
YANG Description: Destination IPv4 | f336796: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/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 | f336796:c0:m40 |
def _get_instructions(self): | return self.__instructions<EOL> | Getter method for instructions, mapped from YANG variable /openflow_state/flow/flow_info_list/instructions (string)
YANG Description: Instructions | f336796: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/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 | f336796:c0:m43 |
def _get_action_data(self): | return self.__action_data<EOL> | Getter method for action_data, mapped from YANG variable /openflow_state/flow/flow_info_list/action_data (string)
YANG Description: Action | f336796: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/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 | f336796:c0:m46 |
def _get_meter_id(self): | return self.__meter_id<EOL> | Getter method for meter_id, mapped from YANG variable /openflow_state/flow/flow_info_list/meter_id (uint32)
YANG Description: Meter id | f336796: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/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 | f336796:c0:m49 |
def _get_vlan_upbits(self): | return self.__vlan_upbits<EOL> | Getter method for vlan_upbits, mapped from YANG variable /openflow_state/flow/flow_info_list/vlan_upbits (uint32)
YANG Description: Vlan Priority | f336796: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/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 | f336796:c0:m52 |
def _get_nw_tos(self): | return self.__nw_tos<EOL> | Getter method for nw_tos, mapped from YANG variable /openflow_state/flow/flow_info_list/nw_tos (uint32)
YANG Description: IP DSCP | f336796: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/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 | f336796: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/flow_info_list/source_ip_mask (string)
YANG Description: Source IPv4 Mask | f336796: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/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 | f336796: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/flow_info_list/destination_ip_mask (string)
YANG Description: Destination IPv4 Mask | f336796: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/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 | f336796:c0:m61 |
def _get_total_packets(self): | return self.__total_packets<EOL> | Getter method for total_packets, mapped from YANG variable /openflow_state/flow/flow_info_list/total_packets (uint32)
YANG Description: Total Packets | f336796: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/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 | f336796:c0:m64 |
def _get_total_bytes(self): | return self.__total_bytes<EOL> | Getter method for total_bytes, mapped from YANG variable /openflow_state/flow/flow_info_list/total_bytes (uint32)
YANG Description: Total Bytes | f336796: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/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 | f336796: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/flow_info_list/flow_action_list (list)
YANG Description: Details of an action | f336796: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/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 | f336796:c0:m70 |
def _get_data_packets_sent(self): | return self.__data_packets_sent<EOL> | Getter method for data_packets_sent, mapped from YANG variable /openflow_state/flow/data_packets_sent (uint32)
YANG Description: Total Number of data packets sent to controller | f336797:c0:m3 |
def _set_data_packets_sent(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__data_packets_sent = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for data_packets_sent, mapped from YANG variable /openflow_state/flow/data_packets_sent (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_data_packets_sent is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_data_packets_sent() directly.
YANG Description: Total Number of data packets sent to controller | f336797:c0:m4 |
def _get_data_bytes_sent(self): | return self.__data_bytes_sent<EOL> | Getter method for data_bytes_sent, mapped from YANG variable /openflow_state/flow/data_bytes_sent (uint32)
YANG Description: Total Number of data bytes sent to controller | f336797:c0:m6 |
def _set_data_bytes_sent(self, v, load=False): | if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__data_bytes_sent = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for data_bytes_sent, mapped from YANG variable /openflow_state/flow/data_bytes_sent (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_data_bytes_sent is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_data_bytes_sent() directly.
YANG Description: Total Number of data bytes sent to controller | f336797:c0:m7 |
def _get_port_based_flows(self): | return self.__port_based_flows<EOL> | Getter method for port_based_flows, mapped from YANG variable /openflow_state/flow/port_based_flows (uint32)
YANG Description: Total Number of Port based Flows | f336797:c0:m9 |
def _set_port_based_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.__port_based_flows = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for port_based_flows, mapped from YANG variable /openflow_state/flow/port_based_flows (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_port_based_flows is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port_based_flows() directly.
YANG Description: Total Number of Port based Flows | f336797:c0:m10 |
def _get_hw_generic_flows(self): | return self.__hw_generic_flows<EOL> | Getter method for hw_generic_flows, mapped from YANG variable /openflow_state/flow/hw_generic_flows (uint32)
YANG Description: Total Number of Generic based Flows | f336797:c0:m12 |
def _set_hw_generic_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.__hw_generic_flows = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for hw_generic_flows, mapped from YANG variable /openflow_state/flow/hw_generic_flows (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_hw_generic_flows is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_hw_generic_flows() directly.
YANG Description: Total Number of Generic based Flows | f336797:c0:m13 |
def _get_l2_interfaces(self): | return self.__l2_interfaces<EOL> | Getter method for l2_interfaces, mapped from YANG variable /openflow_state/flow/l2_interfaces (uint32)
YANG Description: Total Number of L2 interfaces | f336797:c0:m15 |
def _set_l2_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=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.__l2_interfaces = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for l2_interfaces, mapped from YANG variable /openflow_state/flow/l2_interfaces (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_l2_interfaces is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_l2_interfaces() directly.
YANG Description: Total Number of L2 interfaces | f336797:c0:m16 |
def _get_l3_interfaces(self): | return self.__l3_interfaces<EOL> | Getter method for l3_interfaces, mapped from YANG variable /openflow_state/flow/l3_interfaces (uint32)
YANG Description: Total Number of L3 interfaces | f336797:c0:m18 |
def _set_l3_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=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.__l3_interfaces = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for l3_interfaces, mapped from YANG variable /openflow_state/flow/l3_interfaces (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_l3_interfaces is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_l3_interfaces() directly.
YANG Description: Total Number of L3 interfaces | f336797:c0:m19 |
def _get_l23_interfaces(self): | return self.__l23_interfaces<EOL> | Getter method for l23_interfaces, mapped from YANG variable /openflow_state/flow/l23_interfaces (uint32)
YANG Description: Total Number of L23 interfaces | f336797:c0:m21 |
def _set_l23_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=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.__l23_interfaces = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for l23_interfaces, mapped from YANG variable /openflow_state/flow/l23_interfaces (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_l23_interfaces is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_l23_interfaces() directly.
YANG Description: Total Number of L23 interfaces | f336797:c0:m22 |
def _get_flow_info_list(self): | return self.__flow_info_list<EOL> | Getter method for flow_info_list, mapped from YANG variable /openflow_state/flow/flow_info_list (list) | f336797:c0:m24 |
def _set_flow_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>",flow_info_list.flow_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>'}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__flow_info_list = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for flow_info_list, mapped from YANG variable /openflow_state/flow/flow_info_list (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_flow_info_list is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_flow_info_list() directly. | f336797:c0:m25 |
def _get_meter_id(self): | return self.__meter_id<EOL> | Getter method for meter_id, mapped from YANG variable /openflow_state/meter_id/meter_id (uint32)
YANG Description: Meter id | f336798:c0:m3 |
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/meter_id/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 | f336798:c0:m4 |
def _get_transaction_id(self): | return self.__transaction_id<EOL> | Getter method for transaction_id, mapped from YANG variable /openflow_state/meter_id/transaction_id (string)
YANG Description: Transaction id | f336798: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_id/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 | f336798:c0:m7 |
def _get_meterflags_type(self): | return self.__meterflags_type<EOL> | Getter method for meterflags_type, mapped from YANG variable /openflow_state/meter_id/meterflags_type (string)
YANG Description: Meter flags | f336798: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_id/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 | f336798:c0:m10 |
def _get_flow_count(self): | return self.__flow_count<EOL> | Getter method for flow_count, mapped from YANG variable /openflow_state/meter_id/flow_count (uint32)
YANG Description: Flow Count | f336798: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_id/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 | f336798: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_id/num_of_bands (uint32)
YANG Description: Number of bands | f336798: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_id/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 | f336798: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_id/in_packet_count (uint32)
YANG Description: In packet count | f336798: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_id/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 | f336798: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_id/in_byte_count (uint32)
YANG Description: In byte count | f336798: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_id/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 | f336798: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_id/meterband_info_list (list)
YANG Description: Meterband details | f336798: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_id/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 | f336798:c0:m25 |
def _get_band_type(self): | return self.__band_type<EOL> | Getter method for band_type, mapped from YANG variable /openflow_state/meter_id/meterband_info_list/band_type (uint32)
YANG Description: Band Type | f336799: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_id/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 | f336799:c0:m4 |
def _get_rate(self): | return self.__rate<EOL> | Getter method for rate, mapped from YANG variable /openflow_state/meter_id/meterband_info_list/rate (uint32)
YANG Description: Rate | f336799:c0:m6 |
def _set_rate(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.__rate = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for rate, mapped from YANG variable /openflow_state/meter_id/meterband_info_list/rate (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_rate is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rate() directly.
YANG Description: Rate | f336799:c0:m7 |
def _get_burst_size(self): | return self.__burst_size<EOL> | Getter method for burst_size, mapped from YANG variable /openflow_state/meter_id/meterband_info_list/burst_size (uint32)
YANG Description: Burst size | f336799:c0:m9 |
def _set_burst_size(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.__burst_size = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for burst_size, mapped from YANG variable /openflow_state/meter_id/meterband_info_list/burst_size (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_burst_size is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_burst_size() directly.
YANG Description: Burst size | f336799:c0:m10 |
def _get_in_packet_band_count(self): | return self.__in_packet_band_count<EOL> | Getter method for in_packet_band_count, mapped from YANG variable /openflow_state/meter_id/meterband_info_list/in_packet_band_count (uint32)
YANG Description: In packet band count | f336799:c0:m12 |
def _set_in_packet_band_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_band_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for in_packet_band_count, mapped from YANG variable /openflow_state/meter_id/meterband_info_list/in_packet_band_count (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_in_packet_band_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_in_packet_band_count() directly.
YANG Description: In packet band count | f336799:c0:m13 |
def _get_in_byte_band_count(self): | return self.__in_byte_band_count<EOL> | Getter method for in_byte_band_count, mapped from YANG variable /openflow_state/meter_id/meterband_info_list/in_byte_band_count (uint32)
YANG Description: In byte band count | f336799:c0:m15 |
def _set_in_byte_band_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_band_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT> | Setter method for in_byte_band_count, mapped from YANG variable /openflow_state/meter_id/meterband_info_list/in_byte_band_count (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_in_byte_band_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_in_byte_band_count() directly.
YANG Description: In byte band count | f336799:c0:m16 |
def _get_flow_id(self): | return self.__flow_id<EOL> | Getter method for flow_id, mapped from YANG variable /openflow_state/flow_id/flow_id (uint32)
YANG Description: Flow ID | f336800:c0:m3 |
def _set_flow_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.__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_id/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 | f336800:c0:m4 |
def _get_priority(self): | return self.__priority<EOL> | Getter method for priority, mapped from YANG variable /openflow_state/flow_id/priority (uint32)
YANG Description: Priority | f336800: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_id/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 | f336800:c0:m7 |
def _get_status(self): | return self.__status<EOL> | Getter method for status, mapped from YANG variable /openflow_state/flow_id/status (flow-status)
YANG Description: Status | f336800: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_id/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 | f336800:c0:m10 |
def _get_in_port(self): | return self.__in_port<EOL> | Getter method for in_port, mapped from YANG variable /openflow_state/flow_id/in_port (string)
YANG Description: In Port | f336800: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_id/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 | f336800:c0:m13 |
def _get_in_vlan(self): | return self.__in_vlan<EOL> | Getter method for in_vlan, mapped from YANG variable /openflow_state/flow_id/in_vlan (string)
YANG Description: In Vlan | f336800: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_id/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 | f336800:c0:m16 |
def _get_source_mac(self): | return self.__source_mac<EOL> | Getter method for source_mac, mapped from YANG variable /openflow_state/flow_id/source_mac (string)
YANG Description: Source Mac | f336800: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_id/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 | f336800:c0:m19 |
def _get_destination_mac(self): | return self.__destination_mac<EOL> | Getter method for destination_mac, mapped from YANG variable /openflow_state/flow_id/destination_mac (string)
YANG Description: Destination Mac | f336800: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_id/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 | f336800:c0:m22 |
def _get_ether_type(self): | return self.__ether_type<EOL> | Getter method for ether_type, mapped from YANG variable /openflow_state/flow_id/ether_type (string)
YANG Description: Ether type | f336800: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_id/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 | f336800:c0:m25 |
def _get_ip_protocol(self): | return self.__ip_protocol<EOL> | Getter method for ip_protocol, mapped from YANG variable /openflow_state/flow_id/ip_protocol (uint32)
YANG Description: IP Protocol | f336800: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_id/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 | f336800: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_id/ip_protocol_source_port (uint32)
YANG Description: IP Protocol Source Port | f336800: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_id/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 | f336800: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_id/ip_protocol_destination_port (uint32)
YANG Description: IP Protocol Destination Port | f336800: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_id/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 | f336800:c0:m34 |
def _get_source_ip(self): | return self.__source_ip<EOL> | Getter method for source_ip, mapped from YANG variable /openflow_state/flow_id/source_ip (string)
YANG Description: Source IPv4 | f336800: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_id/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 | f336800:c0:m37 |
def _get_destination_ip(self): | return self.__destination_ip<EOL> | Getter method for destination_ip, mapped from YANG variable /openflow_state/flow_id/destination_ip (string)
YANG Description: Destination IPv4 | f336800: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_id/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 | f336800:c0:m40 |
def _get_instructions(self): | return self.__instructions<EOL> | Getter method for instructions, mapped from YANG variable /openflow_state/flow_id/instructions (string)
YANG Description: Instructions | f336800: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_id/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 | f336800:c0:m43 |
def _get_action_data(self): | return self.__action_data<EOL> | Getter method for action_data, mapped from YANG variable /openflow_state/flow_id/action_data (string)
YANG Description: Action | f336800: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_id/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 | f336800:c0:m46 |
def _get_meter_id(self): | return self.__meter_id<EOL> | Getter method for meter_id, mapped from YANG variable /openflow_state/flow_id/meter_id (uint32)
YANG Description: Meter id | f336800: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_id/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 | f336800:c0:m49 |
def _get_vlan_upbits(self): | return self.__vlan_upbits<EOL> | Getter method for vlan_upbits, mapped from YANG variable /openflow_state/flow_id/vlan_upbits (uint32)
YANG Description: Vlan Priority | f336800: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_id/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 | f336800:c0:m52 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.