Blame - ofagent/loxi/of12/message.py - voltha

blob: ff34cfa8d56fe87425877dea964cacc530d8b079 [file] [log] [blame]

Nathan Knuth	418fdc8	2016-09-16 22:51:15 -0700	[diff] [blame]	1	# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
				2	# Copyright (c) 2011, 2012 Open Networking Foundation
				3	# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
				4	# See the file LICENSE.pyloxi which should have been included in the source distribution
				5
				6	# Automatically generated by LOXI from template module.py
				7	# Do not modify
				8
				9	import struct
				10	import loxi
				11	import util
				12	import loxi.generic_util
				13
				14	import sys
				15	ofp = sys.modules['loxi.of12']
				16
				17	class message(loxi.OFObject):
				18	subtypes = {}
				19
				20	version = 3
				21
				22	def __init__(self, type=None, xid=None):
				23	if type != None:
				24	self.type = type
				25	else:
				26	self.type = 0
				27	if xid != None:
				28	self.xid = xid
				29	else:
				30	self.xid = None
				31	return
				32
				33	def pack(self):
				34	packed = []
				35	packed.append(struct.pack("!B", self.version))
				36	packed.append(struct.pack("!B", self.type))
				37	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				38	packed.append(struct.pack("!L", self.xid))
				39	length = sum([len(x) for x in packed])
				40	packed[2] = struct.pack("!H", length)
				41	return ''.join(packed)
				42
				43	@staticmethod
				44	def unpack(reader):
				45	subtype, = reader.peek('B', 1)
				46	subclass = message.subtypes.get(subtype)
				47	if subclass:
				48	return subclass.unpack(reader)
				49
				50	obj = message()
				51	_version = reader.read("!B")[0]
				52	assert(_version == 3)
				53	obj.type = reader.read("!B")[0]
				54	_length = reader.read("!H")[0]
				55	orig_reader = reader
				56	reader = orig_reader.slice(_length, 4)
				57	obj.xid = reader.read("!L")[0]
				58	return obj
				59
				60	def __eq__(self, other):
				61	if type(self) != type(other): return False
				62	if self.type != other.type: return False
				63	if self.xid != other.xid: return False
				64	return True
				65
				66	def pretty_print(self, q):
				67	q.text("message {")
				68	with q.group():
				69	with q.indent(2):
				70	q.breakable()
				71	q.text("xid = ");
				72	if self.xid != None:
				73	q.text("%#x" % self.xid)
				74	else:
				75	q.text('None')
				76	q.breakable()
				77	q.text('}')
				78
				79
				80	class stats_reply(message):
				81	subtypes = {}
				82
				83	version = 3
				84	type = 19
				85
				86	def __init__(self, xid=None, stats_type=None, flags=None):
				87	if xid != None:
				88	self.xid = xid
				89	else:
				90	self.xid = None
				91	if stats_type != None:
				92	self.stats_type = stats_type
				93	else:
				94	self.stats_type = 0
				95	if flags != None:
				96	self.flags = flags
				97	else:
				98	self.flags = 0
				99	return
				100
				101	def pack(self):
				102	packed = []
				103	packed.append(struct.pack("!B", self.version))
				104	packed.append(struct.pack("!B", self.type))
				105	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				106	packed.append(struct.pack("!L", self.xid))
				107	packed.append(struct.pack("!H", self.stats_type))
				108	packed.append(struct.pack("!H", self.flags))
				109	packed.append('\x00' * 4)
				110	length = sum([len(x) for x in packed])
				111	packed[2] = struct.pack("!H", length)
				112	return ''.join(packed)
				113
				114	@staticmethod
				115	def unpack(reader):
				116	subtype, = reader.peek('!H', 8)
				117	subclass = stats_reply.subtypes.get(subtype)
				118	if subclass:
				119	return subclass.unpack(reader)
				120
				121	obj = stats_reply()
				122	_version = reader.read("!B")[0]
				123	assert(_version == 3)
				124	_type = reader.read("!B")[0]
				125	assert(_type == 19)
				126	_length = reader.read("!H")[0]
				127	orig_reader = reader
				128	reader = orig_reader.slice(_length, 4)
				129	obj.xid = reader.read("!L")[0]
				130	obj.stats_type = reader.read("!H")[0]
				131	obj.flags = reader.read("!H")[0]
				132	reader.skip(4)
				133	return obj
				134
				135	def __eq__(self, other):
				136	if type(self) != type(other): return False
				137	if self.xid != other.xid: return False
				138	if self.stats_type != other.stats_type: return False
				139	if self.flags != other.flags: return False
				140	return True
				141
				142	def pretty_print(self, q):
				143	q.text("stats_reply {")
				144	with q.group():
				145	with q.indent(2):
				146	q.breakable()
				147	q.text("xid = ");
				148	if self.xid != None:
				149	q.text("%#x" % self.xid)
				150	else:
				151	q.text('None')
				152	q.text(","); q.breakable()
				153	q.text("flags = ");
				154	q.text("%#x" % self.flags)
				155	q.breakable()
				156	q.text('}')
				157
				158	message.subtypes[19] = stats_reply
				159
				160	class aggregate_stats_reply(stats_reply):
				161	version = 3
				162	type = 19
				163	stats_type = 2
				164
				165	def __init__(self, xid=None, flags=None, packet_count=None, byte_count=None, flow_count=None):
				166	if xid != None:
				167	self.xid = xid
				168	else:
				169	self.xid = None
				170	if flags != None:
				171	self.flags = flags
				172	else:
				173	self.flags = 0
				174	if packet_count != None:
				175	self.packet_count = packet_count
				176	else:
				177	self.packet_count = 0
				178	if byte_count != None:
				179	self.byte_count = byte_count
				180	else:
				181	self.byte_count = 0
				182	if flow_count != None:
				183	self.flow_count = flow_count
				184	else:
				185	self.flow_count = 0
				186	return
				187
				188	def pack(self):
				189	packed = []
				190	packed.append(struct.pack("!B", self.version))
				191	packed.append(struct.pack("!B", self.type))
				192	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				193	packed.append(struct.pack("!L", self.xid))
				194	packed.append(struct.pack("!H", self.stats_type))
				195	packed.append(struct.pack("!H", self.flags))
				196	packed.append('\x00' * 4)
				197	packed.append(struct.pack("!Q", self.packet_count))
				198	packed.append(struct.pack("!Q", self.byte_count))
				199	packed.append(struct.pack("!L", self.flow_count))
				200	packed.append('\x00' * 4)
				201	length = sum([len(x) for x in packed])
				202	packed[2] = struct.pack("!H", length)
				203	return ''.join(packed)
				204
				205	@staticmethod
				206	def unpack(reader):
				207	obj = aggregate_stats_reply()
				208	_version = reader.read("!B")[0]
				209	assert(_version == 3)
				210	_type = reader.read("!B")[0]
				211	assert(_type == 19)
				212	_length = reader.read("!H")[0]
				213	orig_reader = reader
				214	reader = orig_reader.slice(_length, 4)
				215	obj.xid = reader.read("!L")[0]
				216	_stats_type = reader.read("!H")[0]
				217	assert(_stats_type == 2)
				218	obj.flags = reader.read("!H")[0]
				219	reader.skip(4)
				220	obj.packet_count = reader.read("!Q")[0]
				221	obj.byte_count = reader.read("!Q")[0]
				222	obj.flow_count = reader.read("!L")[0]
				223	reader.skip(4)
				224	return obj
				225
				226	def __eq__(self, other):
				227	if type(self) != type(other): return False
				228	if self.xid != other.xid: return False
				229	if self.flags != other.flags: return False
				230	if self.packet_count != other.packet_count: return False
				231	if self.byte_count != other.byte_count: return False
				232	if self.flow_count != other.flow_count: return False
				233	return True
				234
				235	def pretty_print(self, q):
				236	q.text("aggregate_stats_reply {")
				237	with q.group():
				238	with q.indent(2):
				239	q.breakable()
				240	q.text("xid = ");
				241	if self.xid != None:
				242	q.text("%#x" % self.xid)
				243	else:
				244	q.text('None')
				245	q.text(","); q.breakable()
				246	q.text("flags = ");
				247	q.text("%#x" % self.flags)
				248	q.text(","); q.breakable()
				249	q.text("packet_count = ");
				250	q.text("%#x" % self.packet_count)
				251	q.text(","); q.breakable()
				252	q.text("byte_count = ");
				253	q.text("%#x" % self.byte_count)
				254	q.text(","); q.breakable()
				255	q.text("flow_count = ");
				256	q.text("%#x" % self.flow_count)
				257	q.breakable()
				258	q.text('}')
				259
				260	stats_reply.subtypes[2] = aggregate_stats_reply
				261
				262	class stats_request(message):
				263	subtypes = {}
				264
				265	version = 3
				266	type = 18
				267
				268	def __init__(self, xid=None, stats_type=None, flags=None):
				269	if xid != None:
				270	self.xid = xid
				271	else:
				272	self.xid = None
				273	if stats_type != None:
				274	self.stats_type = stats_type
				275	else:
				276	self.stats_type = 0
				277	if flags != None:
				278	self.flags = flags
				279	else:
				280	self.flags = 0
				281	return
				282
				283	def pack(self):
				284	packed = []
				285	packed.append(struct.pack("!B", self.version))
				286	packed.append(struct.pack("!B", self.type))
				287	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				288	packed.append(struct.pack("!L", self.xid))
				289	packed.append(struct.pack("!H", self.stats_type))
				290	packed.append(struct.pack("!H", self.flags))
				291	packed.append('\x00' * 4)
				292	length = sum([len(x) for x in packed])
				293	packed[2] = struct.pack("!H", length)
				294	return ''.join(packed)
				295
				296	@staticmethod
				297	def unpack(reader):
				298	subtype, = reader.peek('!H', 8)
				299	subclass = stats_request.subtypes.get(subtype)
				300	if subclass:
				301	return subclass.unpack(reader)
				302
				303	obj = stats_request()
				304	_version = reader.read("!B")[0]
				305	assert(_version == 3)
				306	_type = reader.read("!B")[0]
				307	assert(_type == 18)
				308	_length = reader.read("!H")[0]
				309	orig_reader = reader
				310	reader = orig_reader.slice(_length, 4)
				311	obj.xid = reader.read("!L")[0]
				312	obj.stats_type = reader.read("!H")[0]
				313	obj.flags = reader.read("!H")[0]
				314	reader.skip(4)
				315	return obj
				316
				317	def __eq__(self, other):
				318	if type(self) != type(other): return False
				319	if self.xid != other.xid: return False
				320	if self.stats_type != other.stats_type: return False
				321	if self.flags != other.flags: return False
				322	return True
				323
				324	def pretty_print(self, q):
				325	q.text("stats_request {")
				326	with q.group():
				327	with q.indent(2):
				328	q.breakable()
				329	q.text("xid = ");
				330	if self.xid != None:
				331	q.text("%#x" % self.xid)
				332	else:
				333	q.text('None')
				334	q.text(","); q.breakable()
				335	q.text("flags = ");
				336	q.text("%#x" % self.flags)
				337	q.breakable()
				338	q.text('}')
				339
				340	message.subtypes[18] = stats_request
				341
				342	class aggregate_stats_request(stats_request):
				343	version = 3
				344	type = 18
				345	stats_type = 2
				346
				347	def __init__(self, xid=None, flags=None, table_id=None, out_port=None, out_group=None, cookie=None, cookie_mask=None, match=None):
				348	if xid != None:
				349	self.xid = xid
				350	else:
				351	self.xid = None
				352	if flags != None:
				353	self.flags = flags
				354	else:
				355	self.flags = 0
				356	if table_id != None:
				357	self.table_id = table_id
				358	else:
				359	self.table_id = 0
				360	if out_port != None:
				361	self.out_port = out_port
				362	else:
				363	self.out_port = 0
				364	if out_group != None:
				365	self.out_group = out_group
				366	else:
				367	self.out_group = 0
				368	if cookie != None:
				369	self.cookie = cookie
				370	else:
				371	self.cookie = 0
				372	if cookie_mask != None:
				373	self.cookie_mask = cookie_mask
				374	else:
				375	self.cookie_mask = 0
				376	if match != None:
				377	self.match = match
				378	else:
				379	self.match = ofp.match()
				380	return
				381
				382	def pack(self):
				383	packed = []
				384	packed.append(struct.pack("!B", self.version))
				385	packed.append(struct.pack("!B", self.type))
				386	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				387	packed.append(struct.pack("!L", self.xid))
				388	packed.append(struct.pack("!H", self.stats_type))
				389	packed.append(struct.pack("!H", self.flags))
				390	packed.append('\x00' * 4)
				391	packed.append(struct.pack("!B", self.table_id))
				392	packed.append('\x00' * 3)
				393	packed.append(util.pack_port_no(self.out_port))
				394	packed.append(struct.pack("!L", self.out_group))
				395	packed.append('\x00' * 4)
				396	packed.append(struct.pack("!Q", self.cookie))
				397	packed.append(struct.pack("!Q", self.cookie_mask))
				398	packed.append(self.match.pack())
				399	length = sum([len(x) for x in packed])
				400	packed[2] = struct.pack("!H", length)
				401	return ''.join(packed)
				402
				403	@staticmethod
				404	def unpack(reader):
				405	obj = aggregate_stats_request()
				406	_version = reader.read("!B")[0]
				407	assert(_version == 3)
				408	_type = reader.read("!B")[0]
				409	assert(_type == 18)
				410	_length = reader.read("!H")[0]
				411	orig_reader = reader
				412	reader = orig_reader.slice(_length, 4)
				413	obj.xid = reader.read("!L")[0]
				414	_stats_type = reader.read("!H")[0]
				415	assert(_stats_type == 2)
				416	obj.flags = reader.read("!H")[0]
				417	reader.skip(4)
				418	obj.table_id = reader.read("!B")[0]
				419	reader.skip(3)
				420	obj.out_port = util.unpack_port_no(reader)
				421	obj.out_group = reader.read("!L")[0]
				422	reader.skip(4)
				423	obj.cookie = reader.read("!Q")[0]
				424	obj.cookie_mask = reader.read("!Q")[0]
				425	obj.match = ofp.match.unpack(reader)
				426	return obj
				427
				428	def __eq__(self, other):
				429	if type(self) != type(other): return False
				430	if self.xid != other.xid: return False
				431	if self.flags != other.flags: return False
				432	if self.table_id != other.table_id: return False
				433	if self.out_port != other.out_port: return False
				434	if self.out_group != other.out_group: return False
				435	if self.cookie != other.cookie: return False
				436	if self.cookie_mask != other.cookie_mask: return False
				437	if self.match != other.match: return False
				438	return True
				439
				440	def pretty_print(self, q):
				441	q.text("aggregate_stats_request {")
				442	with q.group():
				443	with q.indent(2):
				444	q.breakable()
				445	q.text("xid = ");
				446	if self.xid != None:
				447	q.text("%#x" % self.xid)
				448	else:
				449	q.text('None')
				450	q.text(","); q.breakable()
				451	q.text("flags = ");
				452	q.text("%#x" % self.flags)
				453	q.text(","); q.breakable()
				454	q.text("table_id = ");
				455	q.text("%#x" % self.table_id)
				456	q.text(","); q.breakable()
				457	q.text("out_port = ");
				458	q.text(util.pretty_port(self.out_port))
				459	q.text(","); q.breakable()
				460	q.text("out_group = ");
				461	q.text("%#x" % self.out_group)
				462	q.text(","); q.breakable()
				463	q.text("cookie = ");
				464	q.text("%#x" % self.cookie)
				465	q.text(","); q.breakable()
				466	q.text("cookie_mask = ");
				467	q.text("%#x" % self.cookie_mask)
				468	q.text(","); q.breakable()
				469	q.text("match = ");
				470	q.pp(self.match)
				471	q.breakable()
				472	q.text('}')
				473
				474	stats_request.subtypes[2] = aggregate_stats_request
				475
				476	class error_msg(message):
				477	subtypes = {}
				478
				479	version = 3
				480	type = 1
				481
				482	def __init__(self, xid=None, err_type=None):
				483	if xid != None:
				484	self.xid = xid
				485	else:
				486	self.xid = None
				487	if err_type != None:
				488	self.err_type = err_type
				489	else:
				490	self.err_type = 0
				491	return
				492
				493	def pack(self):
				494	packed = []
				495	packed.append(struct.pack("!B", self.version))
				496	packed.append(struct.pack("!B", self.type))
				497	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				498	packed.append(struct.pack("!L", self.xid))
				499	packed.append(struct.pack("!H", self.err_type))
				500	length = sum([len(x) for x in packed])
				501	packed[2] = struct.pack("!H", length)
				502	return ''.join(packed)
				503
				504	@staticmethod
				505	def unpack(reader):
				506	subtype, = reader.peek('!H', 8)
				507	subclass = error_msg.subtypes.get(subtype)
				508	if subclass:
				509	return subclass.unpack(reader)
				510
				511	obj = error_msg()
				512	_version = reader.read("!B")[0]
				513	assert(_version == 3)
				514	_type = reader.read("!B")[0]
				515	assert(_type == 1)
				516	_length = reader.read("!H")[0]
				517	orig_reader = reader
				518	reader = orig_reader.slice(_length, 4)
				519	obj.xid = reader.read("!L")[0]
				520	obj.err_type = reader.read("!H")[0]
				521	return obj
				522
				523	def __eq__(self, other):
				524	if type(self) != type(other): return False
				525	if self.xid != other.xid: return False
				526	if self.err_type != other.err_type: return False
				527	return True
				528
				529	def pretty_print(self, q):
				530	q.text("error_msg {")
				531	with q.group():
				532	with q.indent(2):
				533	q.breakable()
				534	q.text("xid = ");
				535	if self.xid != None:
				536	q.text("%#x" % self.xid)
				537	else:
				538	q.text('None')
				539	q.breakable()
				540	q.text('}')
				541
				542	message.subtypes[1] = error_msg
				543
				544	class bad_action_error_msg(error_msg):
				545	version = 3
				546	type = 1
				547	err_type = 2
				548
				549	def __init__(self, xid=None, code=None, data=None):
				550	if xid != None:
				551	self.xid = xid
				552	else:
				553	self.xid = None
				554	if code != None:
				555	self.code = code
				556	else:
				557	self.code = 0
				558	if data != None:
				559	self.data = data
				560	else:
				561	self.data = ''
				562	return
				563
				564	def pack(self):
				565	packed = []
				566	packed.append(struct.pack("!B", self.version))
				567	packed.append(struct.pack("!B", self.type))
				568	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				569	packed.append(struct.pack("!L", self.xid))
				570	packed.append(struct.pack("!H", self.err_type))
				571	packed.append(struct.pack("!H", self.code))
				572	packed.append(self.data)
				573	length = sum([len(x) for x in packed])
				574	packed[2] = struct.pack("!H", length)
				575	return ''.join(packed)
				576
				577	@staticmethod
				578	def unpack(reader):
				579	obj = bad_action_error_msg()
				580	_version = reader.read("!B")[0]
				581	assert(_version == 3)
				582	_type = reader.read("!B")[0]
				583	assert(_type == 1)
				584	_length = reader.read("!H")[0]
				585	orig_reader = reader
				586	reader = orig_reader.slice(_length, 4)
				587	obj.xid = reader.read("!L")[0]
				588	_err_type = reader.read("!H")[0]
				589	assert(_err_type == 2)
				590	obj.code = reader.read("!H")[0]
				591	obj.data = str(reader.read_all())
				592	return obj
				593
				594	def __eq__(self, other):
				595	if type(self) != type(other): return False
				596	if self.xid != other.xid: return False
				597	if self.code != other.code: return False
				598	if self.data != other.data: return False
				599	return True
				600
				601	def pretty_print(self, q):
				602	q.text("bad_action_error_msg {")
				603	with q.group():
				604	with q.indent(2):
				605	q.breakable()
				606	q.text("xid = ");
				607	if self.xid != None:
				608	q.text("%#x" % self.xid)
				609	else:
				610	q.text('None')
				611	q.text(","); q.breakable()
				612	q.text("code = ");
				613	q.text("%#x" % self.code)
				614	q.text(","); q.breakable()
				615	q.text("data = ");
				616	q.pp(self.data)
				617	q.breakable()
				618	q.text('}')
				619
				620	error_msg.subtypes[2] = bad_action_error_msg
				621
				622	class bad_instruction_error_msg(error_msg):
				623	version = 3
				624	type = 1
				625	err_type = 3
				626
				627	def __init__(self, xid=None, code=None, data=None):
				628	if xid != None:
				629	self.xid = xid
				630	else:
				631	self.xid = None
				632	if code != None:
				633	self.code = code
				634	else:
				635	self.code = 0
				636	if data != None:
				637	self.data = data
				638	else:
				639	self.data = ''
				640	return
				641
				642	def pack(self):
				643	packed = []
				644	packed.append(struct.pack("!B", self.version))
				645	packed.append(struct.pack("!B", self.type))
				646	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				647	packed.append(struct.pack("!L", self.xid))
				648	packed.append(struct.pack("!H", self.err_type))
				649	packed.append(struct.pack("!H", self.code))
				650	packed.append(self.data)
				651	length = sum([len(x) for x in packed])
				652	packed[2] = struct.pack("!H", length)
				653	return ''.join(packed)
				654
				655	@staticmethod
				656	def unpack(reader):
				657	obj = bad_instruction_error_msg()
				658	_version = reader.read("!B")[0]
				659	assert(_version == 3)
				660	_type = reader.read("!B")[0]
				661	assert(_type == 1)
				662	_length = reader.read("!H")[0]
				663	orig_reader = reader
				664	reader = orig_reader.slice(_length, 4)
				665	obj.xid = reader.read("!L")[0]
				666	_err_type = reader.read("!H")[0]
				667	assert(_err_type == 3)
				668	obj.code = reader.read("!H")[0]
				669	obj.data = str(reader.read_all())
				670	return obj
				671
				672	def __eq__(self, other):
				673	if type(self) != type(other): return False
				674	if self.xid != other.xid: return False
				675	if self.code != other.code: return False
				676	if self.data != other.data: return False
				677	return True
				678
				679	def pretty_print(self, q):
				680	q.text("bad_instruction_error_msg {")
				681	with q.group():
				682	with q.indent(2):
				683	q.breakable()
				684	q.text("xid = ");
				685	if self.xid != None:
				686	q.text("%#x" % self.xid)
				687	else:
				688	q.text('None')
				689	q.text(","); q.breakable()
				690	q.text("code = ");
				691	q.text("%#x" % self.code)
				692	q.text(","); q.breakable()
				693	q.text("data = ");
				694	q.pp(self.data)
				695	q.breakable()
				696	q.text('}')
				697
				698	error_msg.subtypes[3] = bad_instruction_error_msg
				699
				700	class bad_match_error_msg(error_msg):
				701	version = 3
				702	type = 1
				703	err_type = 4
				704
				705	def __init__(self, xid=None, code=None, data=None):
				706	if xid != None:
				707	self.xid = xid
				708	else:
				709	self.xid = None
				710	if code != None:
				711	self.code = code
				712	else:
				713	self.code = 0
				714	if data != None:
				715	self.data = data
				716	else:
				717	self.data = ''
				718	return
				719
				720	def pack(self):
				721	packed = []
				722	packed.append(struct.pack("!B", self.version))
				723	packed.append(struct.pack("!B", self.type))
				724	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				725	packed.append(struct.pack("!L", self.xid))
				726	packed.append(struct.pack("!H", self.err_type))
				727	packed.append(struct.pack("!H", self.code))
				728	packed.append(self.data)
				729	length = sum([len(x) for x in packed])
				730	packed[2] = struct.pack("!H", length)
				731	return ''.join(packed)
				732
				733	@staticmethod
				734	def unpack(reader):
				735	obj = bad_match_error_msg()
				736	_version = reader.read("!B")[0]
				737	assert(_version == 3)
				738	_type = reader.read("!B")[0]
				739	assert(_type == 1)
				740	_length = reader.read("!H")[0]
				741	orig_reader = reader
				742	reader = orig_reader.slice(_length, 4)
				743	obj.xid = reader.read("!L")[0]
				744	_err_type = reader.read("!H")[0]
				745	assert(_err_type == 4)
				746	obj.code = reader.read("!H")[0]
				747	obj.data = str(reader.read_all())
				748	return obj
				749
				750	def __eq__(self, other):
				751	if type(self) != type(other): return False
				752	if self.xid != other.xid: return False
				753	if self.code != other.code: return False
				754	if self.data != other.data: return False
				755	return True
				756
				757	def pretty_print(self, q):
				758	q.text("bad_match_error_msg {")
				759	with q.group():
				760	with q.indent(2):
				761	q.breakable()
				762	q.text("xid = ");
				763	if self.xid != None:
				764	q.text("%#x" % self.xid)
				765	else:
				766	q.text('None')
				767	q.text(","); q.breakable()
				768	q.text("code = ");
				769	q.text("%#x" % self.code)
				770	q.text(","); q.breakable()
				771	q.text("data = ");
				772	q.pp(self.data)
				773	q.breakable()
				774	q.text('}')
				775
				776	error_msg.subtypes[4] = bad_match_error_msg
				777
				778	class bad_request_error_msg(error_msg):
				779	version = 3
				780	type = 1
				781	err_type = 1
				782
				783	def __init__(self, xid=None, code=None, data=None):
				784	if xid != None:
				785	self.xid = xid
				786	else:
				787	self.xid = None
				788	if code != None:
				789	self.code = code
				790	else:
				791	self.code = 0
				792	if data != None:
				793	self.data = data
				794	else:
				795	self.data = ''
				796	return
				797
				798	def pack(self):
				799	packed = []
				800	packed.append(struct.pack("!B", self.version))
				801	packed.append(struct.pack("!B", self.type))
				802	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				803	packed.append(struct.pack("!L", self.xid))
				804	packed.append(struct.pack("!H", self.err_type))
				805	packed.append(struct.pack("!H", self.code))
				806	packed.append(self.data)
				807	length = sum([len(x) for x in packed])
				808	packed[2] = struct.pack("!H", length)
				809	return ''.join(packed)
				810
				811	@staticmethod
				812	def unpack(reader):
				813	obj = bad_request_error_msg()
				814	_version = reader.read("!B")[0]
				815	assert(_version == 3)
				816	_type = reader.read("!B")[0]
				817	assert(_type == 1)
				818	_length = reader.read("!H")[0]
				819	orig_reader = reader
				820	reader = orig_reader.slice(_length, 4)
				821	obj.xid = reader.read("!L")[0]
				822	_err_type = reader.read("!H")[0]
				823	assert(_err_type == 1)
				824	obj.code = reader.read("!H")[0]
				825	obj.data = str(reader.read_all())
				826	return obj
				827
				828	def __eq__(self, other):
				829	if type(self) != type(other): return False
				830	if self.xid != other.xid: return False
				831	if self.code != other.code: return False
				832	if self.data != other.data: return False
				833	return True
				834
				835	def pretty_print(self, q):
				836	q.text("bad_request_error_msg {")
				837	with q.group():
				838	with q.indent(2):
				839	q.breakable()
				840	q.text("xid = ");
				841	if self.xid != None:
				842	q.text("%#x" % self.xid)
				843	else:
				844	q.text('None')
				845	q.text(","); q.breakable()
				846	q.text("code = ");
				847	q.text("%#x" % self.code)
				848	q.text(","); q.breakable()
				849	q.text("data = ");
				850	q.pp(self.data)
				851	q.breakable()
				852	q.text('}')
				853
				854	error_msg.subtypes[1] = bad_request_error_msg
				855
				856	class barrier_reply(message):
				857	version = 3
				858	type = 21
				859
				860	def __init__(self, xid=None):
				861	if xid != None:
				862	self.xid = xid
				863	else:
				864	self.xid = None
				865	return
				866
				867	def pack(self):
				868	packed = []
				869	packed.append(struct.pack("!B", self.version))
				870	packed.append(struct.pack("!B", self.type))
				871	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				872	packed.append(struct.pack("!L", self.xid))
				873	length = sum([len(x) for x in packed])
				874	packed[2] = struct.pack("!H", length)
				875	return ''.join(packed)
				876
				877	@staticmethod
				878	def unpack(reader):
				879	obj = barrier_reply()
				880	_version = reader.read("!B")[0]
				881	assert(_version == 3)
				882	_type = reader.read("!B")[0]
				883	assert(_type == 21)
				884	_length = reader.read("!H")[0]
				885	orig_reader = reader
				886	reader = orig_reader.slice(_length, 4)
				887	obj.xid = reader.read("!L")[0]
				888	return obj
				889
				890	def __eq__(self, other):
				891	if type(self) != type(other): return False
				892	if self.xid != other.xid: return False
				893	return True
				894
				895	def pretty_print(self, q):
				896	q.text("barrier_reply {")
				897	with q.group():
				898	with q.indent(2):
				899	q.breakable()
				900	q.text("xid = ");
				901	if self.xid != None:
				902	q.text("%#x" % self.xid)
				903	else:
				904	q.text('None')
				905	q.breakable()
				906	q.text('}')
				907
				908	message.subtypes[21] = barrier_reply
				909
				910	class barrier_request(message):
				911	version = 3
				912	type = 20
				913
				914	def __init__(self, xid=None):
				915	if xid != None:
				916	self.xid = xid
				917	else:
				918	self.xid = None
				919	return
				920
				921	def pack(self):
				922	packed = []
				923	packed.append(struct.pack("!B", self.version))
				924	packed.append(struct.pack("!B", self.type))
				925	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				926	packed.append(struct.pack("!L", self.xid))
				927	length = sum([len(x) for x in packed])
				928	packed[2] = struct.pack("!H", length)
				929	return ''.join(packed)
				930
				931	@staticmethod
				932	def unpack(reader):
				933	obj = barrier_request()
				934	_version = reader.read("!B")[0]
				935	assert(_version == 3)
				936	_type = reader.read("!B")[0]
				937	assert(_type == 20)
				938	_length = reader.read("!H")[0]
				939	orig_reader = reader
				940	reader = orig_reader.slice(_length, 4)
				941	obj.xid = reader.read("!L")[0]
				942	return obj
				943
				944	def __eq__(self, other):
				945	if type(self) != type(other): return False
				946	if self.xid != other.xid: return False
				947	return True
				948
				949	def pretty_print(self, q):
				950	q.text("barrier_request {")
				951	with q.group():
				952	with q.indent(2):
				953	q.breakable()
				954	q.text("xid = ");
				955	if self.xid != None:
				956	q.text("%#x" % self.xid)
				957	else:
				958	q.text('None')
				959	q.breakable()
				960	q.text('}')
				961
				962	message.subtypes[20] = barrier_request
				963
				964	class experimenter(message):
				965	subtypes = {}
				966
				967	version = 3
				968	type = 4
				969
				970	def __init__(self, xid=None, experimenter=None, subtype=None, data=None):
				971	if xid != None:
				972	self.xid = xid
				973	else:
				974	self.xid = None
				975	if experimenter != None:
				976	self.experimenter = experimenter
				977	else:
				978	self.experimenter = 0
				979	if subtype != None:
				980	self.subtype = subtype
				981	else:
				982	self.subtype = 0
				983	if data != None:
				984	self.data = data
				985	else:
				986	self.data = ''
				987	return
				988
				989	def pack(self):
				990	packed = []
				991	packed.append(struct.pack("!B", self.version))
				992	packed.append(struct.pack("!B", self.type))
				993	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				994	packed.append(struct.pack("!L", self.xid))
				995	packed.append(struct.pack("!L", self.experimenter))
				996	packed.append(struct.pack("!L", self.subtype))
				997	packed.append(self.data)
				998	length = sum([len(x) for x in packed])
				999	packed[2] = struct.pack("!H", length)
				1000	return ''.join(packed)
				1001
				1002	@staticmethod
				1003	def unpack(reader):
				1004	subtype, = reader.peek('!L', 8)
				1005	subclass = experimenter.subtypes.get(subtype)
				1006	if subclass:
				1007	return subclass.unpack(reader)
				1008
				1009	obj = experimenter()
				1010	_version = reader.read("!B")[0]
				1011	assert(_version == 3)
				1012	_type = reader.read("!B")[0]
				1013	assert(_type == 4)
				1014	_length = reader.read("!H")[0]
				1015	orig_reader = reader
				1016	reader = orig_reader.slice(_length, 4)
				1017	obj.xid = reader.read("!L")[0]
				1018	obj.experimenter = reader.read("!L")[0]
				1019	obj.subtype = reader.read("!L")[0]
				1020	obj.data = str(reader.read_all())
				1021	return obj
				1022
				1023	def __eq__(self, other):
				1024	if type(self) != type(other): return False
				1025	if self.xid != other.xid: return False
				1026	if self.experimenter != other.experimenter: return False
				1027	if self.subtype != other.subtype: return False
				1028	if self.data != other.data: return False
				1029	return True
				1030
				1031	def pretty_print(self, q):
				1032	q.text("experimenter {")
				1033	with q.group():
				1034	with q.indent(2):
				1035	q.breakable()
				1036	q.text("xid = ");
				1037	if self.xid != None:
				1038	q.text("%#x" % self.xid)
				1039	else:
				1040	q.text('None')
				1041	q.text(","); q.breakable()
				1042	q.text("subtype = ");
				1043	q.text("%#x" % self.subtype)
				1044	q.text(","); q.breakable()
				1045	q.text("data = ");
				1046	q.pp(self.data)
				1047	q.breakable()
				1048	q.text('}')
				1049
				1050	message.subtypes[4] = experimenter
				1051
				1052	class bsn_header(experimenter):
				1053	subtypes = {}
				1054
				1055	version = 3
				1056	type = 4
				1057	experimenter = 6035143
				1058
				1059	def __init__(self, xid=None, subtype=None):
				1060	if xid != None:
				1061	self.xid = xid
				1062	else:
				1063	self.xid = None
				1064	if subtype != None:
				1065	self.subtype = subtype
				1066	else:
				1067	self.subtype = 0
				1068	return
				1069
				1070	def pack(self):
				1071	packed = []
				1072	packed.append(struct.pack("!B", self.version))
				1073	packed.append(struct.pack("!B", self.type))
				1074	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				1075	packed.append(struct.pack("!L", self.xid))
				1076	packed.append(struct.pack("!L", self.experimenter))
				1077	packed.append(struct.pack("!L", self.subtype))
				1078	length = sum([len(x) for x in packed])
				1079	packed[2] = struct.pack("!H", length)
				1080	return ''.join(packed)
				1081
				1082	@staticmethod
				1083	def unpack(reader):
				1084	subtype, = reader.peek('!L', 12)
				1085	subclass = bsn_header.subtypes.get(subtype)
				1086	if subclass:
				1087	return subclass.unpack(reader)
				1088
				1089	obj = bsn_header()
				1090	_version = reader.read("!B")[0]
				1091	assert(_version == 3)
				1092	_type = reader.read("!B")[0]
				1093	assert(_type == 4)
				1094	_length = reader.read("!H")[0]
				1095	orig_reader = reader
				1096	reader = orig_reader.slice(_length, 4)
				1097	obj.xid = reader.read("!L")[0]
				1098	_experimenter = reader.read("!L")[0]
				1099	assert(_experimenter == 6035143)
				1100	obj.subtype = reader.read("!L")[0]
				1101	return obj
				1102
				1103	def __eq__(self, other):
				1104	if type(self) != type(other): return False
				1105	if self.xid != other.xid: return False
				1106	if self.subtype != other.subtype: return False
				1107	return True
				1108
				1109	def pretty_print(self, q):
				1110	q.text("bsn_header {")
				1111	with q.group():
				1112	with q.indent(2):
				1113	q.breakable()
				1114	q.text("xid = ");
				1115	if self.xid != None:
				1116	q.text("%#x" % self.xid)
				1117	else:
				1118	q.text('None')
				1119	q.breakable()
				1120	q.text('}')
				1121
				1122	experimenter.subtypes[6035143] = bsn_header
				1123
				1124	class bsn_bw_clear_data_reply(bsn_header):
				1125	version = 3
				1126	type = 4
				1127	experimenter = 6035143
				1128	subtype = 22
				1129
				1130	def __init__(self, xid=None, status=None):
				1131	if xid != None:
				1132	self.xid = xid
				1133	else:
				1134	self.xid = None
				1135	if status != None:
				1136	self.status = status
				1137	else:
				1138	self.status = 0
				1139	return
				1140
				1141	def pack(self):
				1142	packed = []
				1143	packed.append(struct.pack("!B", self.version))
				1144	packed.append(struct.pack("!B", self.type))
				1145	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				1146	packed.append(struct.pack("!L", self.xid))
				1147	packed.append(struct.pack("!L", self.experimenter))
				1148	packed.append(struct.pack("!L", self.subtype))
				1149	packed.append(struct.pack("!L", self.status))
				1150	length = sum([len(x) for x in packed])
				1151	packed[2] = struct.pack("!H", length)
				1152	return ''.join(packed)
				1153
				1154	@staticmethod
				1155	def unpack(reader):
				1156	obj = bsn_bw_clear_data_reply()
				1157	_version = reader.read("!B")[0]
				1158	assert(_version == 3)
				1159	_type = reader.read("!B")[0]
				1160	assert(_type == 4)
				1161	_length = reader.read("!H")[0]
				1162	orig_reader = reader
				1163	reader = orig_reader.slice(_length, 4)
				1164	obj.xid = reader.read("!L")[0]
				1165	_experimenter = reader.read("!L")[0]
				1166	assert(_experimenter == 6035143)
				1167	_subtype = reader.read("!L")[0]
				1168	assert(_subtype == 22)
				1169	obj.status = reader.read("!L")[0]
				1170	return obj
				1171
				1172	def __eq__(self, other):
				1173	if type(self) != type(other): return False
				1174	if self.xid != other.xid: return False
				1175	if self.status != other.status: return False
				1176	return True
				1177
				1178	def pretty_print(self, q):
				1179	q.text("bsn_bw_clear_data_reply {")
				1180	with q.group():
				1181	with q.indent(2):
				1182	q.breakable()
				1183	q.text("xid = ");
				1184	if self.xid != None:
				1185	q.text("%#x" % self.xid)
				1186	else:
				1187	q.text('None')
				1188	q.text(","); q.breakable()
				1189	q.text("status = ");
				1190	q.text("%#x" % self.status)
				1191	q.breakable()
				1192	q.text('}')
				1193
				1194	bsn_header.subtypes[22] = bsn_bw_clear_data_reply
				1195
				1196	class bsn_bw_clear_data_request(bsn_header):
				1197	version = 3
				1198	type = 4
				1199	experimenter = 6035143
				1200	subtype = 21
				1201
				1202	def __init__(self, xid=None):
				1203	if xid != None:
				1204	self.xid = xid
				1205	else:
				1206	self.xid = None
				1207	return
				1208
				1209	def pack(self):
				1210	packed = []
				1211	packed.append(struct.pack("!B", self.version))
				1212	packed.append(struct.pack("!B", self.type))
				1213	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				1214	packed.append(struct.pack("!L", self.xid))
				1215	packed.append(struct.pack("!L", self.experimenter))
				1216	packed.append(struct.pack("!L", self.subtype))
				1217	length = sum([len(x) for x in packed])
				1218	packed[2] = struct.pack("!H", length)
				1219	return ''.join(packed)
				1220
				1221	@staticmethod
				1222	def unpack(reader):
				1223	obj = bsn_bw_clear_data_request()
				1224	_version = reader.read("!B")[0]
				1225	assert(_version == 3)
				1226	_type = reader.read("!B")[0]
				1227	assert(_type == 4)
				1228	_length = reader.read("!H")[0]
				1229	orig_reader = reader
				1230	reader = orig_reader.slice(_length, 4)
				1231	obj.xid = reader.read("!L")[0]
				1232	_experimenter = reader.read("!L")[0]
				1233	assert(_experimenter == 6035143)
				1234	_subtype = reader.read("!L")[0]
				1235	assert(_subtype == 21)
				1236	return obj
				1237
				1238	def __eq__(self, other):
				1239	if type(self) != type(other): return False
				1240	if self.xid != other.xid: return False
				1241	return True
				1242
				1243	def pretty_print(self, q):
				1244	q.text("bsn_bw_clear_data_request {")
				1245	with q.group():
				1246	with q.indent(2):
				1247	q.breakable()
				1248	q.text("xid = ");
				1249	if self.xid != None:
				1250	q.text("%#x" % self.xid)
				1251	else:
				1252	q.text('None')
				1253	q.breakable()
				1254	q.text('}')
				1255
				1256	bsn_header.subtypes[21] = bsn_bw_clear_data_request
				1257
				1258	class bsn_bw_enable_get_reply(bsn_header):
				1259	version = 3
				1260	type = 4
				1261	experimenter = 6035143
				1262	subtype = 20
				1263
				1264	def __init__(self, xid=None, enabled=None):
				1265	if xid != None:
				1266	self.xid = xid
				1267	else:
				1268	self.xid = None
				1269	if enabled != None:
				1270	self.enabled = enabled
				1271	else:
				1272	self.enabled = 0
				1273	return
				1274
				1275	def pack(self):
				1276	packed = []
				1277	packed.append(struct.pack("!B", self.version))
				1278	packed.append(struct.pack("!B", self.type))
				1279	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				1280	packed.append(struct.pack("!L", self.xid))
				1281	packed.append(struct.pack("!L", self.experimenter))
				1282	packed.append(struct.pack("!L", self.subtype))
				1283	packed.append(struct.pack("!L", self.enabled))
				1284	length = sum([len(x) for x in packed])
				1285	packed[2] = struct.pack("!H", length)
				1286	return ''.join(packed)
				1287
				1288	@staticmethod
				1289	def unpack(reader):
				1290	obj = bsn_bw_enable_get_reply()
				1291	_version = reader.read("!B")[0]
				1292	assert(_version == 3)
				1293	_type = reader.read("!B")[0]
				1294	assert(_type == 4)
				1295	_length = reader.read("!H")[0]
				1296	orig_reader = reader
				1297	reader = orig_reader.slice(_length, 4)
				1298	obj.xid = reader.read("!L")[0]
				1299	_experimenter = reader.read("!L")[0]
				1300	assert(_experimenter == 6035143)
				1301	_subtype = reader.read("!L")[0]
				1302	assert(_subtype == 20)
				1303	obj.enabled = reader.read("!L")[0]
				1304	return obj
				1305
				1306	def __eq__(self, other):
				1307	if type(self) != type(other): return False
				1308	if self.xid != other.xid: return False
				1309	if self.enabled != other.enabled: return False
				1310	return True
				1311
				1312	def pretty_print(self, q):
				1313	q.text("bsn_bw_enable_get_reply {")
				1314	with q.group():
				1315	with q.indent(2):
				1316	q.breakable()
				1317	q.text("xid = ");
				1318	if self.xid != None:
				1319	q.text("%#x" % self.xid)
				1320	else:
				1321	q.text('None')
				1322	q.text(","); q.breakable()
				1323	q.text("enabled = ");
				1324	q.text("%#x" % self.enabled)
				1325	q.breakable()
				1326	q.text('}')
				1327
				1328	bsn_header.subtypes[20] = bsn_bw_enable_get_reply
				1329
				1330	class bsn_bw_enable_get_request(bsn_header):
				1331	version = 3
				1332	type = 4
				1333	experimenter = 6035143
				1334	subtype = 19
				1335
				1336	def __init__(self, xid=None):
				1337	if xid != None:
				1338	self.xid = xid
				1339	else:
				1340	self.xid = None
				1341	return
				1342
				1343	def pack(self):
				1344	packed = []
				1345	packed.append(struct.pack("!B", self.version))
				1346	packed.append(struct.pack("!B", self.type))
				1347	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				1348	packed.append(struct.pack("!L", self.xid))
				1349	packed.append(struct.pack("!L", self.experimenter))
				1350	packed.append(struct.pack("!L", self.subtype))
				1351	length = sum([len(x) for x in packed])
				1352	packed[2] = struct.pack("!H", length)
				1353	return ''.join(packed)
				1354
				1355	@staticmethod
				1356	def unpack(reader):
				1357	obj = bsn_bw_enable_get_request()
				1358	_version = reader.read("!B")[0]
				1359	assert(_version == 3)
				1360	_type = reader.read("!B")[0]
				1361	assert(_type == 4)
				1362	_length = reader.read("!H")[0]
				1363	orig_reader = reader
				1364	reader = orig_reader.slice(_length, 4)
				1365	obj.xid = reader.read("!L")[0]
				1366	_experimenter = reader.read("!L")[0]
				1367	assert(_experimenter == 6035143)
				1368	_subtype = reader.read("!L")[0]
				1369	assert(_subtype == 19)
				1370	return obj
				1371
				1372	def __eq__(self, other):
				1373	if type(self) != type(other): return False
				1374	if self.xid != other.xid: return False
				1375	return True
				1376
				1377	def pretty_print(self, q):
				1378	q.text("bsn_bw_enable_get_request {")
				1379	with q.group():
				1380	with q.indent(2):
				1381	q.breakable()
				1382	q.text("xid = ");
				1383	if self.xid != None:
				1384	q.text("%#x" % self.xid)
				1385	else:
				1386	q.text('None')
				1387	q.breakable()
				1388	q.text('}')
				1389
				1390	bsn_header.subtypes[19] = bsn_bw_enable_get_request
				1391
				1392	class bsn_bw_enable_set_reply(bsn_header):
				1393	version = 3
				1394	type = 4
				1395	experimenter = 6035143
				1396	subtype = 23
				1397
				1398	def __init__(self, xid=None, enable=None, status=None):
				1399	if xid != None:
				1400	self.xid = xid
				1401	else:
				1402	self.xid = None
				1403	if enable != None:
				1404	self.enable = enable
				1405	else:
				1406	self.enable = 0
				1407	if status != None:
				1408	self.status = status
				1409	else:
				1410	self.status = 0
				1411	return
				1412
				1413	def pack(self):
				1414	packed = []
				1415	packed.append(struct.pack("!B", self.version))
				1416	packed.append(struct.pack("!B", self.type))
				1417	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				1418	packed.append(struct.pack("!L", self.xid))
				1419	packed.append(struct.pack("!L", self.experimenter))
				1420	packed.append(struct.pack("!L", self.subtype))
				1421	packed.append(struct.pack("!L", self.enable))
				1422	packed.append(struct.pack("!L", self.status))
				1423	length = sum([len(x) for x in packed])
				1424	packed[2] = struct.pack("!H", length)
				1425	return ''.join(packed)
				1426
				1427	@staticmethod
				1428	def unpack(reader):
				1429	obj = bsn_bw_enable_set_reply()
				1430	_version = reader.read("!B")[0]
				1431	assert(_version == 3)
				1432	_type = reader.read("!B")[0]
				1433	assert(_type == 4)
				1434	_length = reader.read("!H")[0]
				1435	orig_reader = reader
				1436	reader = orig_reader.slice(_length, 4)
				1437	obj.xid = reader.read("!L")[0]
				1438	_experimenter = reader.read("!L")[0]
				1439	assert(_experimenter == 6035143)
				1440	_subtype = reader.read("!L")[0]
				1441	assert(_subtype == 23)
				1442	obj.enable = reader.read("!L")[0]
				1443	obj.status = reader.read("!L")[0]
				1444	return obj
				1445
				1446	def __eq__(self, other):
				1447	if type(self) != type(other): return False
				1448	if self.xid != other.xid: return False
				1449	if self.enable != other.enable: return False
				1450	if self.status != other.status: return False
				1451	return True
				1452
				1453	def pretty_print(self, q):
				1454	q.text("bsn_bw_enable_set_reply {")
				1455	with q.group():
				1456	with q.indent(2):
				1457	q.breakable()
				1458	q.text("xid = ");
				1459	if self.xid != None:
				1460	q.text("%#x" % self.xid)
				1461	else:
				1462	q.text('None')
				1463	q.text(","); q.breakable()
				1464	q.text("enable = ");
				1465	q.text("%#x" % self.enable)
				1466	q.text(","); q.breakable()
				1467	q.text("status = ");
				1468	q.text("%#x" % self.status)
				1469	q.breakable()
				1470	q.text('}')
				1471
				1472	bsn_header.subtypes[23] = bsn_bw_enable_set_reply
				1473
				1474	class bsn_bw_enable_set_request(bsn_header):
				1475	version = 3
				1476	type = 4
				1477	experimenter = 6035143
				1478	subtype = 18
				1479
				1480	def __init__(self, xid=None, enable=None):
				1481	if xid != None:
				1482	self.xid = xid
				1483	else:
				1484	self.xid = None
				1485	if enable != None:
				1486	self.enable = enable
				1487	else:
				1488	self.enable = 0
				1489	return
				1490
				1491	def pack(self):
				1492	packed = []
				1493	packed.append(struct.pack("!B", self.version))
				1494	packed.append(struct.pack("!B", self.type))
				1495	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				1496	packed.append(struct.pack("!L", self.xid))
				1497	packed.append(struct.pack("!L", self.experimenter))
				1498	packed.append(struct.pack("!L", self.subtype))
				1499	packed.append(struct.pack("!L", self.enable))
				1500	length = sum([len(x) for x in packed])
				1501	packed[2] = struct.pack("!H", length)
				1502	return ''.join(packed)
				1503
				1504	@staticmethod
				1505	def unpack(reader):
				1506	obj = bsn_bw_enable_set_request()
				1507	_version = reader.read("!B")[0]
				1508	assert(_version == 3)
				1509	_type = reader.read("!B")[0]
				1510	assert(_type == 4)
				1511	_length = reader.read("!H")[0]
				1512	orig_reader = reader
				1513	reader = orig_reader.slice(_length, 4)
				1514	obj.xid = reader.read("!L")[0]
				1515	_experimenter = reader.read("!L")[0]
				1516	assert(_experimenter == 6035143)
				1517	_subtype = reader.read("!L")[0]
				1518	assert(_subtype == 18)
				1519	obj.enable = reader.read("!L")[0]
				1520	return obj
				1521
				1522	def __eq__(self, other):
				1523	if type(self) != type(other): return False
				1524	if self.xid != other.xid: return False
				1525	if self.enable != other.enable: return False
				1526	return True
				1527
				1528	def pretty_print(self, q):
				1529	q.text("bsn_bw_enable_set_request {")
				1530	with q.group():
				1531	with q.indent(2):
				1532	q.breakable()
				1533	q.text("xid = ");
				1534	if self.xid != None:
				1535	q.text("%#x" % self.xid)
				1536	else:
				1537	q.text('None')
				1538	q.text(","); q.breakable()
				1539	q.text("enable = ");
				1540	q.text("%#x" % self.enable)
				1541	q.breakable()
				1542	q.text('}')
				1543
				1544	bsn_header.subtypes[18] = bsn_bw_enable_set_request
				1545
				1546	class bsn_get_interfaces_reply(bsn_header):
				1547	version = 3
				1548	type = 4
				1549	experimenter = 6035143
				1550	subtype = 10
				1551
				1552	def __init__(self, xid=None, interfaces=None):
				1553	if xid != None:
				1554	self.xid = xid
				1555	else:
				1556	self.xid = None
				1557	if interfaces != None:
				1558	self.interfaces = interfaces
				1559	else:
				1560	self.interfaces = []
				1561	return
				1562
				1563	def pack(self):
				1564	packed = []
				1565	packed.append(struct.pack("!B", self.version))
				1566	packed.append(struct.pack("!B", self.type))
				1567	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				1568	packed.append(struct.pack("!L", self.xid))
				1569	packed.append(struct.pack("!L", self.experimenter))
				1570	packed.append(struct.pack("!L", self.subtype))
				1571	packed.append(loxi.generic_util.pack_list(self.interfaces))
				1572	length = sum([len(x) for x in packed])
				1573	packed[2] = struct.pack("!H", length)
				1574	return ''.join(packed)
				1575
				1576	@staticmethod
				1577	def unpack(reader):
				1578	obj = bsn_get_interfaces_reply()
				1579	_version = reader.read("!B")[0]
				1580	assert(_version == 3)
				1581	_type = reader.read("!B")[0]
				1582	assert(_type == 4)
				1583	_length = reader.read("!H")[0]
				1584	orig_reader = reader
				1585	reader = orig_reader.slice(_length, 4)
				1586	obj.xid = reader.read("!L")[0]
				1587	_experimenter = reader.read("!L")[0]
				1588	assert(_experimenter == 6035143)
				1589	_subtype = reader.read("!L")[0]
				1590	assert(_subtype == 10)
				1591	obj.interfaces = loxi.generic_util.unpack_list(reader, ofp.common.bsn_interface.unpack)
				1592	return obj
				1593
				1594	def __eq__(self, other):
				1595	if type(self) != type(other): return False
				1596	if self.xid != other.xid: return False
				1597	if self.interfaces != other.interfaces: return False
				1598	return True
				1599
				1600	def pretty_print(self, q):
				1601	q.text("bsn_get_interfaces_reply {")
				1602	with q.group():
				1603	with q.indent(2):
				1604	q.breakable()
				1605	q.text("xid = ");
				1606	if self.xid != None:
				1607	q.text("%#x" % self.xid)
				1608	else:
				1609	q.text('None')
				1610	q.text(","); q.breakable()
				1611	q.text("interfaces = ");
				1612	q.pp(self.interfaces)
				1613	q.breakable()
				1614	q.text('}')
				1615
				1616	bsn_header.subtypes[10] = bsn_get_interfaces_reply
				1617
				1618	class bsn_get_interfaces_request(bsn_header):
				1619	version = 3
				1620	type = 4
				1621	experimenter = 6035143
				1622	subtype = 9
				1623
				1624	def __init__(self, xid=None):
				1625	if xid != None:
				1626	self.xid = xid
				1627	else:
				1628	self.xid = None
				1629	return
				1630
				1631	def pack(self):
				1632	packed = []
				1633	packed.append(struct.pack("!B", self.version))
				1634	packed.append(struct.pack("!B", self.type))
				1635	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				1636	packed.append(struct.pack("!L", self.xid))
				1637	packed.append(struct.pack("!L", self.experimenter))
				1638	packed.append(struct.pack("!L", self.subtype))
				1639	length = sum([len(x) for x in packed])
				1640	packed[2] = struct.pack("!H", length)
				1641	return ''.join(packed)
				1642
				1643	@staticmethod
				1644	def unpack(reader):
				1645	obj = bsn_get_interfaces_request()
				1646	_version = reader.read("!B")[0]
				1647	assert(_version == 3)
				1648	_type = reader.read("!B")[0]
				1649	assert(_type == 4)
				1650	_length = reader.read("!H")[0]
				1651	orig_reader = reader
				1652	reader = orig_reader.slice(_length, 4)
				1653	obj.xid = reader.read("!L")[0]
				1654	_experimenter = reader.read("!L")[0]
				1655	assert(_experimenter == 6035143)
				1656	_subtype = reader.read("!L")[0]
				1657	assert(_subtype == 9)
				1658	return obj
				1659
				1660	def __eq__(self, other):
				1661	if type(self) != type(other): return False
				1662	if self.xid != other.xid: return False
				1663	return True
				1664
				1665	def pretty_print(self, q):
				1666	q.text("bsn_get_interfaces_request {")
				1667	with q.group():
				1668	with q.indent(2):
				1669	q.breakable()
				1670	q.text("xid = ");
				1671	if self.xid != None:
				1672	q.text("%#x" % self.xid)
				1673	else:
				1674	q.text('None')
				1675	q.breakable()
				1676	q.text('}')
				1677
				1678	bsn_header.subtypes[9] = bsn_get_interfaces_request
				1679
				1680	class bsn_get_mirroring_reply(bsn_header):
				1681	version = 3
				1682	type = 4
				1683	experimenter = 6035143
				1684	subtype = 5
				1685
				1686	def __init__(self, xid=None, report_mirror_ports=None):
				1687	if xid != None:
				1688	self.xid = xid
				1689	else:
				1690	self.xid = None
				1691	if report_mirror_ports != None:
				1692	self.report_mirror_ports = report_mirror_ports
				1693	else:
				1694	self.report_mirror_ports = 0
				1695	return
				1696
				1697	def pack(self):
				1698	packed = []
				1699	packed.append(struct.pack("!B", self.version))
				1700	packed.append(struct.pack("!B", self.type))
				1701	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				1702	packed.append(struct.pack("!L", self.xid))
				1703	packed.append(struct.pack("!L", self.experimenter))
				1704	packed.append(struct.pack("!L", self.subtype))
				1705	packed.append(struct.pack("!B", self.report_mirror_ports))
				1706	packed.append('\x00' * 3)
				1707	length = sum([len(x) for x in packed])
				1708	packed[2] = struct.pack("!H", length)
				1709	return ''.join(packed)
				1710
				1711	@staticmethod
				1712	def unpack(reader):
				1713	obj = bsn_get_mirroring_reply()
				1714	_version = reader.read("!B")[0]
				1715	assert(_version == 3)
				1716	_type = reader.read("!B")[0]
				1717	assert(_type == 4)
				1718	_length = reader.read("!H")[0]
				1719	orig_reader = reader
				1720	reader = orig_reader.slice(_length, 4)
				1721	obj.xid = reader.read("!L")[0]
				1722	_experimenter = reader.read("!L")[0]
				1723	assert(_experimenter == 6035143)
				1724	_subtype = reader.read("!L")[0]
				1725	assert(_subtype == 5)
				1726	obj.report_mirror_ports = reader.read("!B")[0]
				1727	reader.skip(3)
				1728	return obj
				1729
				1730	def __eq__(self, other):
				1731	if type(self) != type(other): return False
				1732	if self.xid != other.xid: return False
				1733	if self.report_mirror_ports != other.report_mirror_ports: return False
				1734	return True
				1735
				1736	def pretty_print(self, q):
				1737	q.text("bsn_get_mirroring_reply {")
				1738	with q.group():
				1739	with q.indent(2):
				1740	q.breakable()
				1741	q.text("xid = ");
				1742	if self.xid != None:
				1743	q.text("%#x" % self.xid)
				1744	else:
				1745	q.text('None')
				1746	q.text(","); q.breakable()
				1747	q.text("report_mirror_ports = ");
				1748	q.text("%#x" % self.report_mirror_ports)
				1749	q.breakable()
				1750	q.text('}')
				1751
				1752	bsn_header.subtypes[5] = bsn_get_mirroring_reply
				1753
				1754	class bsn_get_mirroring_request(bsn_header):
				1755	version = 3
				1756	type = 4
				1757	experimenter = 6035143
				1758	subtype = 4
				1759
				1760	def __init__(self, xid=None, report_mirror_ports=None):
				1761	if xid != None:
				1762	self.xid = xid
				1763	else:
				1764	self.xid = None
				1765	if report_mirror_ports != None:
				1766	self.report_mirror_ports = report_mirror_ports
				1767	else:
				1768	self.report_mirror_ports = 0
				1769	return
				1770
				1771	def pack(self):
				1772	packed = []
				1773	packed.append(struct.pack("!B", self.version))
				1774	packed.append(struct.pack("!B", self.type))
				1775	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				1776	packed.append(struct.pack("!L", self.xid))
				1777	packed.append(struct.pack("!L", self.experimenter))
				1778	packed.append(struct.pack("!L", self.subtype))
				1779	packed.append(struct.pack("!B", self.report_mirror_ports))
				1780	packed.append('\x00' * 3)
				1781	length = sum([len(x) for x in packed])
				1782	packed[2] = struct.pack("!H", length)
				1783	return ''.join(packed)
				1784
				1785	@staticmethod
				1786	def unpack(reader):
				1787	obj = bsn_get_mirroring_request()
				1788	_version = reader.read("!B")[0]
				1789	assert(_version == 3)
				1790	_type = reader.read("!B")[0]
				1791	assert(_type == 4)
				1792	_length = reader.read("!H")[0]
				1793	orig_reader = reader
				1794	reader = orig_reader.slice(_length, 4)
				1795	obj.xid = reader.read("!L")[0]
				1796	_experimenter = reader.read("!L")[0]
				1797	assert(_experimenter == 6035143)
				1798	_subtype = reader.read("!L")[0]
				1799	assert(_subtype == 4)
				1800	obj.report_mirror_ports = reader.read("!B")[0]
				1801	reader.skip(3)
				1802	return obj
				1803
				1804	def __eq__(self, other):
				1805	if type(self) != type(other): return False
				1806	if self.xid != other.xid: return False
				1807	if self.report_mirror_ports != other.report_mirror_ports: return False
				1808	return True
				1809
				1810	def pretty_print(self, q):
				1811	q.text("bsn_get_mirroring_request {")
				1812	with q.group():
				1813	with q.indent(2):
				1814	q.breakable()
				1815	q.text("xid = ");
				1816	if self.xid != None:
				1817	q.text("%#x" % self.xid)
				1818	else:
				1819	q.text('None')
				1820	q.text(","); q.breakable()
				1821	q.text("report_mirror_ports = ");
				1822	q.text("%#x" % self.report_mirror_ports)
				1823	q.breakable()
				1824	q.text('}')
				1825
				1826	bsn_header.subtypes[4] = bsn_get_mirroring_request
				1827
				1828	class bsn_pdu_rx_reply(bsn_header):
				1829	version = 3
				1830	type = 4
				1831	experimenter = 6035143
				1832	subtype = 34
				1833
				1834	def __init__(self, xid=None, status=None, port_no=None, slot_num=None):
				1835	if xid != None:
				1836	self.xid = xid
				1837	else:
				1838	self.xid = None
				1839	if status != None:
				1840	self.status = status
				1841	else:
				1842	self.status = 0
				1843	if port_no != None:
				1844	self.port_no = port_no
				1845	else:
				1846	self.port_no = 0
				1847	if slot_num != None:
				1848	self.slot_num = slot_num
				1849	else:
				1850	self.slot_num = 0
				1851	return
				1852
				1853	def pack(self):
				1854	packed = []
				1855	packed.append(struct.pack("!B", self.version))
				1856	packed.append(struct.pack("!B", self.type))
				1857	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				1858	packed.append(struct.pack("!L", self.xid))
				1859	packed.append(struct.pack("!L", self.experimenter))
				1860	packed.append(struct.pack("!L", self.subtype))
				1861	packed.append(struct.pack("!L", self.status))
				1862	packed.append(util.pack_port_no(self.port_no))
				1863	packed.append(struct.pack("!B", self.slot_num))
				1864	length = sum([len(x) for x in packed])
				1865	packed[2] = struct.pack("!H", length)
				1866	return ''.join(packed)
				1867
				1868	@staticmethod
				1869	def unpack(reader):
				1870	obj = bsn_pdu_rx_reply()
				1871	_version = reader.read("!B")[0]
				1872	assert(_version == 3)
				1873	_type = reader.read("!B")[0]
				1874	assert(_type == 4)
				1875	_length = reader.read("!H")[0]
				1876	orig_reader = reader
				1877	reader = orig_reader.slice(_length, 4)
				1878	obj.xid = reader.read("!L")[0]
				1879	_experimenter = reader.read("!L")[0]
				1880	assert(_experimenter == 6035143)
				1881	_subtype = reader.read("!L")[0]
				1882	assert(_subtype == 34)
				1883	obj.status = reader.read("!L")[0]
				1884	obj.port_no = util.unpack_port_no(reader)
				1885	obj.slot_num = reader.read("!B")[0]
				1886	return obj
				1887
				1888	def __eq__(self, other):
				1889	if type(self) != type(other): return False
				1890	if self.xid != other.xid: return False
				1891	if self.status != other.status: return False
				1892	if self.port_no != other.port_no: return False
				1893	if self.slot_num != other.slot_num: return False
				1894	return True
				1895
				1896	def pretty_print(self, q):
				1897	q.text("bsn_pdu_rx_reply {")
				1898	with q.group():
				1899	with q.indent(2):
				1900	q.breakable()
				1901	q.text("xid = ");
				1902	if self.xid != None:
				1903	q.text("%#x" % self.xid)
				1904	else:
				1905	q.text('None')
				1906	q.text(","); q.breakable()
				1907	q.text("status = ");
				1908	q.text("%#x" % self.status)
				1909	q.text(","); q.breakable()
				1910	q.text("port_no = ");
				1911	q.text(util.pretty_port(self.port_no))
				1912	q.text(","); q.breakable()
				1913	q.text("slot_num = ");
				1914	q.text("%#x" % self.slot_num)
				1915	q.breakable()
				1916	q.text('}')
				1917
				1918	bsn_header.subtypes[34] = bsn_pdu_rx_reply
				1919
				1920	class bsn_pdu_rx_request(bsn_header):
				1921	version = 3
				1922	type = 4
				1923	experimenter = 6035143
				1924	subtype = 33
				1925
				1926	def __init__(self, xid=None, timeout_ms=None, port_no=None, slot_num=None, data=None):
				1927	if xid != None:
				1928	self.xid = xid
				1929	else:
				1930	self.xid = None
				1931	if timeout_ms != None:
				1932	self.timeout_ms = timeout_ms
				1933	else:
				1934	self.timeout_ms = 0
				1935	if port_no != None:
				1936	self.port_no = port_no
				1937	else:
				1938	self.port_no = 0
				1939	if slot_num != None:
				1940	self.slot_num = slot_num
				1941	else:
				1942	self.slot_num = 0
				1943	if data != None:
				1944	self.data = data
				1945	else:
				1946	self.data = ''
				1947	return
				1948
				1949	def pack(self):
				1950	packed = []
				1951	packed.append(struct.pack("!B", self.version))
				1952	packed.append(struct.pack("!B", self.type))
				1953	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				1954	packed.append(struct.pack("!L", self.xid))
				1955	packed.append(struct.pack("!L", self.experimenter))
				1956	packed.append(struct.pack("!L", self.subtype))
				1957	packed.append(struct.pack("!L", self.timeout_ms))
				1958	packed.append(util.pack_port_no(self.port_no))
				1959	packed.append(struct.pack("!B", self.slot_num))
				1960	packed.append('\x00' * 3)
				1961	packed.append(self.data)
				1962	length = sum([len(x) for x in packed])
				1963	packed[2] = struct.pack("!H", length)
				1964	return ''.join(packed)
				1965
				1966	@staticmethod
				1967	def unpack(reader):
				1968	obj = bsn_pdu_rx_request()
				1969	_version = reader.read("!B")[0]
				1970	assert(_version == 3)
				1971	_type = reader.read("!B")[0]
				1972	assert(_type == 4)
				1973	_length = reader.read("!H")[0]
				1974	orig_reader = reader
				1975	reader = orig_reader.slice(_length, 4)
				1976	obj.xid = reader.read("!L")[0]
				1977	_experimenter = reader.read("!L")[0]
				1978	assert(_experimenter == 6035143)
				1979	_subtype = reader.read("!L")[0]
				1980	assert(_subtype == 33)
				1981	obj.timeout_ms = reader.read("!L")[0]
				1982	obj.port_no = util.unpack_port_no(reader)
				1983	obj.slot_num = reader.read("!B")[0]
				1984	reader.skip(3)
				1985	obj.data = str(reader.read_all())
				1986	return obj
				1987
				1988	def __eq__(self, other):
				1989	if type(self) != type(other): return False
				1990	if self.xid != other.xid: return False
				1991	if self.timeout_ms != other.timeout_ms: return False
				1992	if self.port_no != other.port_no: return False
				1993	if self.slot_num != other.slot_num: return False
				1994	if self.data != other.data: return False
				1995	return True
				1996
				1997	def pretty_print(self, q):
				1998	q.text("bsn_pdu_rx_request {")
				1999	with q.group():
				2000	with q.indent(2):
				2001	q.breakable()
				2002	q.text("xid = ");
				2003	if self.xid != None:
				2004	q.text("%#x" % self.xid)
				2005	else:
				2006	q.text('None')
				2007	q.text(","); q.breakable()
				2008	q.text("timeout_ms = ");
				2009	q.text("%#x" % self.timeout_ms)
				2010	q.text(","); q.breakable()
				2011	q.text("port_no = ");
				2012	q.text(util.pretty_port(self.port_no))
				2013	q.text(","); q.breakable()
				2014	q.text("slot_num = ");
				2015	q.text("%#x" % self.slot_num)
				2016	q.text(","); q.breakable()
				2017	q.text("data = ");
				2018	q.pp(self.data)
				2019	q.breakable()
				2020	q.text('}')
				2021
				2022	bsn_header.subtypes[33] = bsn_pdu_rx_request
				2023
				2024	class bsn_pdu_rx_timeout(bsn_header):
				2025	version = 3
				2026	type = 4
				2027	experimenter = 6035143
				2028	subtype = 35
				2029
				2030	def __init__(self, xid=None, port_no=None, slot_num=None):
				2031	if xid != None:
				2032	self.xid = xid
				2033	else:
				2034	self.xid = None
				2035	if port_no != None:
				2036	self.port_no = port_no
				2037	else:
				2038	self.port_no = 0
				2039	if slot_num != None:
				2040	self.slot_num = slot_num
				2041	else:
				2042	self.slot_num = 0
				2043	return
				2044
				2045	def pack(self):
				2046	packed = []
				2047	packed.append(struct.pack("!B", self.version))
				2048	packed.append(struct.pack("!B", self.type))
				2049	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				2050	packed.append(struct.pack("!L", self.xid))
				2051	packed.append(struct.pack("!L", self.experimenter))
				2052	packed.append(struct.pack("!L", self.subtype))
				2053	packed.append(util.pack_port_no(self.port_no))
				2054	packed.append(struct.pack("!B", self.slot_num))
				2055	length = sum([len(x) for x in packed])
				2056	packed[2] = struct.pack("!H", length)
				2057	return ''.join(packed)
				2058
				2059	@staticmethod
				2060	def unpack(reader):
				2061	obj = bsn_pdu_rx_timeout()
				2062	_version = reader.read("!B")[0]
				2063	assert(_version == 3)
				2064	_type = reader.read("!B")[0]
				2065	assert(_type == 4)
				2066	_length = reader.read("!H")[0]
				2067	orig_reader = reader
				2068	reader = orig_reader.slice(_length, 4)
				2069	obj.xid = reader.read("!L")[0]
				2070	_experimenter = reader.read("!L")[0]
				2071	assert(_experimenter == 6035143)
				2072	_subtype = reader.read("!L")[0]
				2073	assert(_subtype == 35)
				2074	obj.port_no = util.unpack_port_no(reader)
				2075	obj.slot_num = reader.read("!B")[0]
				2076	return obj
				2077
				2078	def __eq__(self, other):
				2079	if type(self) != type(other): return False
				2080	if self.xid != other.xid: return False
				2081	if self.port_no != other.port_no: return False
				2082	if self.slot_num != other.slot_num: return False
				2083	return True
				2084
				2085	def pretty_print(self, q):
				2086	q.text("bsn_pdu_rx_timeout {")
				2087	with q.group():
				2088	with q.indent(2):
				2089	q.breakable()
				2090	q.text("xid = ");
				2091	if self.xid != None:
				2092	q.text("%#x" % self.xid)
				2093	else:
				2094	q.text('None')
				2095	q.text(","); q.breakable()
				2096	q.text("port_no = ");
				2097	q.text(util.pretty_port(self.port_no))
				2098	q.text(","); q.breakable()
				2099	q.text("slot_num = ");
				2100	q.text("%#x" % self.slot_num)
				2101	q.breakable()
				2102	q.text('}')
				2103
				2104	bsn_header.subtypes[35] = bsn_pdu_rx_timeout
				2105
				2106	class bsn_pdu_tx_reply(bsn_header):
				2107	version = 3
				2108	type = 4
				2109	experimenter = 6035143
				2110	subtype = 32
				2111
				2112	def __init__(self, xid=None, status=None, port_no=None, slot_num=None):
				2113	if xid != None:
				2114	self.xid = xid
				2115	else:
				2116	self.xid = None
				2117	if status != None:
				2118	self.status = status
				2119	else:
				2120	self.status = 0
				2121	if port_no != None:
				2122	self.port_no = port_no
				2123	else:
				2124	self.port_no = 0
				2125	if slot_num != None:
				2126	self.slot_num = slot_num
				2127	else:
				2128	self.slot_num = 0
				2129	return
				2130
				2131	def pack(self):
				2132	packed = []
				2133	packed.append(struct.pack("!B", self.version))
				2134	packed.append(struct.pack("!B", self.type))
				2135	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				2136	packed.append(struct.pack("!L", self.xid))
				2137	packed.append(struct.pack("!L", self.experimenter))
				2138	packed.append(struct.pack("!L", self.subtype))
				2139	packed.append(struct.pack("!L", self.status))
				2140	packed.append(util.pack_port_no(self.port_no))
				2141	packed.append(struct.pack("!B", self.slot_num))
				2142	length = sum([len(x) for x in packed])
				2143	packed[2] = struct.pack("!H", length)
				2144	return ''.join(packed)
				2145
				2146	@staticmethod
				2147	def unpack(reader):
				2148	obj = bsn_pdu_tx_reply()
				2149	_version = reader.read("!B")[0]
				2150	assert(_version == 3)
				2151	_type = reader.read("!B")[0]
				2152	assert(_type == 4)
				2153	_length = reader.read("!H")[0]
				2154	orig_reader = reader
				2155	reader = orig_reader.slice(_length, 4)
				2156	obj.xid = reader.read("!L")[0]
				2157	_experimenter = reader.read("!L")[0]
				2158	assert(_experimenter == 6035143)
				2159	_subtype = reader.read("!L")[0]
				2160	assert(_subtype == 32)
				2161	obj.status = reader.read("!L")[0]
				2162	obj.port_no = util.unpack_port_no(reader)
				2163	obj.slot_num = reader.read("!B")[0]
				2164	return obj
				2165
				2166	def __eq__(self, other):
				2167	if type(self) != type(other): return False
				2168	if self.xid != other.xid: return False
				2169	if self.status != other.status: return False
				2170	if self.port_no != other.port_no: return False
				2171	if self.slot_num != other.slot_num: return False
				2172	return True
				2173
				2174	def pretty_print(self, q):
				2175	q.text("bsn_pdu_tx_reply {")
				2176	with q.group():
				2177	with q.indent(2):
				2178	q.breakable()
				2179	q.text("xid = ");
				2180	if self.xid != None:
				2181	q.text("%#x" % self.xid)
				2182	else:
				2183	q.text('None')
				2184	q.text(","); q.breakable()
				2185	q.text("status = ");
				2186	q.text("%#x" % self.status)
				2187	q.text(","); q.breakable()
				2188	q.text("port_no = ");
				2189	q.text(util.pretty_port(self.port_no))
				2190	q.text(","); q.breakable()
				2191	q.text("slot_num = ");
				2192	q.text("%#x" % self.slot_num)
				2193	q.breakable()
				2194	q.text('}')
				2195
				2196	bsn_header.subtypes[32] = bsn_pdu_tx_reply
				2197
				2198	class bsn_pdu_tx_request(bsn_header):
				2199	version = 3
				2200	type = 4
				2201	experimenter = 6035143
				2202	subtype = 31
				2203
				2204	def __init__(self, xid=None, tx_interval_ms=None, port_no=None, slot_num=None, data=None):
				2205	if xid != None:
				2206	self.xid = xid
				2207	else:
				2208	self.xid = None
				2209	if tx_interval_ms != None:
				2210	self.tx_interval_ms = tx_interval_ms
				2211	else:
				2212	self.tx_interval_ms = 0
				2213	if port_no != None:
				2214	self.port_no = port_no
				2215	else:
				2216	self.port_no = 0
				2217	if slot_num != None:
				2218	self.slot_num = slot_num
				2219	else:
				2220	self.slot_num = 0
				2221	if data != None:
				2222	self.data = data
				2223	else:
				2224	self.data = ''
				2225	return
				2226
				2227	def pack(self):
				2228	packed = []
				2229	packed.append(struct.pack("!B", self.version))
				2230	packed.append(struct.pack("!B", self.type))
				2231	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				2232	packed.append(struct.pack("!L", self.xid))
				2233	packed.append(struct.pack("!L", self.experimenter))
				2234	packed.append(struct.pack("!L", self.subtype))
				2235	packed.append(struct.pack("!L", self.tx_interval_ms))
				2236	packed.append(util.pack_port_no(self.port_no))
				2237	packed.append(struct.pack("!B", self.slot_num))
				2238	packed.append('\x00' * 3)
				2239	packed.append(self.data)
				2240	length = sum([len(x) for x in packed])
				2241	packed[2] = struct.pack("!H", length)
				2242	return ''.join(packed)
				2243
				2244	@staticmethod
				2245	def unpack(reader):
				2246	obj = bsn_pdu_tx_request()
				2247	_version = reader.read("!B")[0]
				2248	assert(_version == 3)
				2249	_type = reader.read("!B")[0]
				2250	assert(_type == 4)
				2251	_length = reader.read("!H")[0]
				2252	orig_reader = reader
				2253	reader = orig_reader.slice(_length, 4)
				2254	obj.xid = reader.read("!L")[0]
				2255	_experimenter = reader.read("!L")[0]
				2256	assert(_experimenter == 6035143)
				2257	_subtype = reader.read("!L")[0]
				2258	assert(_subtype == 31)
				2259	obj.tx_interval_ms = reader.read("!L")[0]
				2260	obj.port_no = util.unpack_port_no(reader)
				2261	obj.slot_num = reader.read("!B")[0]
				2262	reader.skip(3)
				2263	obj.data = str(reader.read_all())
				2264	return obj
				2265
				2266	def __eq__(self, other):
				2267	if type(self) != type(other): return False
				2268	if self.xid != other.xid: return False
				2269	if self.tx_interval_ms != other.tx_interval_ms: return False
				2270	if self.port_no != other.port_no: return False
				2271	if self.slot_num != other.slot_num: return False
				2272	if self.data != other.data: return False
				2273	return True
				2274
				2275	def pretty_print(self, q):
				2276	q.text("bsn_pdu_tx_request {")
				2277	with q.group():
				2278	with q.indent(2):
				2279	q.breakable()
				2280	q.text("xid = ");
				2281	if self.xid != None:
				2282	q.text("%#x" % self.xid)
				2283	else:
				2284	q.text('None')
				2285	q.text(","); q.breakable()
				2286	q.text("tx_interval_ms = ");
				2287	q.text("%#x" % self.tx_interval_ms)
				2288	q.text(","); q.breakable()
				2289	q.text("port_no = ");
				2290	q.text(util.pretty_port(self.port_no))
				2291	q.text(","); q.breakable()
				2292	q.text("slot_num = ");
				2293	q.text("%#x" % self.slot_num)
				2294	q.text(","); q.breakable()
				2295	q.text("data = ");
				2296	q.pp(self.data)
				2297	q.breakable()
				2298	q.text('}')
				2299
				2300	bsn_header.subtypes[31] = bsn_pdu_tx_request
				2301
				2302	class bsn_set_mirroring(bsn_header):
				2303	version = 3
				2304	type = 4
				2305	experimenter = 6035143
				2306	subtype = 3
				2307
				2308	def __init__(self, xid=None, report_mirror_ports=None):
				2309	if xid != None:
				2310	self.xid = xid
				2311	else:
				2312	self.xid = None
				2313	if report_mirror_ports != None:
				2314	self.report_mirror_ports = report_mirror_ports
				2315	else:
				2316	self.report_mirror_ports = 0
				2317	return
				2318
				2319	def pack(self):
				2320	packed = []
				2321	packed.append(struct.pack("!B", self.version))
				2322	packed.append(struct.pack("!B", self.type))
				2323	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				2324	packed.append(struct.pack("!L", self.xid))
				2325	packed.append(struct.pack("!L", self.experimenter))
				2326	packed.append(struct.pack("!L", self.subtype))
				2327	packed.append(struct.pack("!B", self.report_mirror_ports))
				2328	packed.append('\x00' * 3)
				2329	length = sum([len(x) for x in packed])
				2330	packed[2] = struct.pack("!H", length)
				2331	return ''.join(packed)
				2332
				2333	@staticmethod
				2334	def unpack(reader):
				2335	obj = bsn_set_mirroring()
				2336	_version = reader.read("!B")[0]
				2337	assert(_version == 3)
				2338	_type = reader.read("!B")[0]
				2339	assert(_type == 4)
				2340	_length = reader.read("!H")[0]
				2341	orig_reader = reader
				2342	reader = orig_reader.slice(_length, 4)
				2343	obj.xid = reader.read("!L")[0]
				2344	_experimenter = reader.read("!L")[0]
				2345	assert(_experimenter == 6035143)
				2346	_subtype = reader.read("!L")[0]
				2347	assert(_subtype == 3)
				2348	obj.report_mirror_ports = reader.read("!B")[0]
				2349	reader.skip(3)
				2350	return obj
				2351
				2352	def __eq__(self, other):
				2353	if type(self) != type(other): return False
				2354	if self.xid != other.xid: return False
				2355	if self.report_mirror_ports != other.report_mirror_ports: return False
				2356	return True
				2357
				2358	def pretty_print(self, q):
				2359	q.text("bsn_set_mirroring {")
				2360	with q.group():
				2361	with q.indent(2):
				2362	q.breakable()
				2363	q.text("xid = ");
				2364	if self.xid != None:
				2365	q.text("%#x" % self.xid)
				2366	else:
				2367	q.text('None')
				2368	q.text(","); q.breakable()
				2369	q.text("report_mirror_ports = ");
				2370	q.text("%#x" % self.report_mirror_ports)
				2371	q.breakable()
				2372	q.text('}')
				2373
				2374	bsn_header.subtypes[3] = bsn_set_mirroring
				2375
				2376	class bsn_set_pktin_suppression_reply(bsn_header):
				2377	version = 3
				2378	type = 4
				2379	experimenter = 6035143
				2380	subtype = 25
				2381
				2382	def __init__(self, xid=None, status=None):
				2383	if xid != None:
				2384	self.xid = xid
				2385	else:
				2386	self.xid = None
				2387	if status != None:
				2388	self.status = status
				2389	else:
				2390	self.status = 0
				2391	return
				2392
				2393	def pack(self):
				2394	packed = []
				2395	packed.append(struct.pack("!B", self.version))
				2396	packed.append(struct.pack("!B", self.type))
				2397	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				2398	packed.append(struct.pack("!L", self.xid))
				2399	packed.append(struct.pack("!L", self.experimenter))
				2400	packed.append(struct.pack("!L", self.subtype))
				2401	packed.append(struct.pack("!L", self.status))
				2402	length = sum([len(x) for x in packed])
				2403	packed[2] = struct.pack("!H", length)
				2404	return ''.join(packed)
				2405
				2406	@staticmethod
				2407	def unpack(reader):
				2408	obj = bsn_set_pktin_suppression_reply()
				2409	_version = reader.read("!B")[0]
				2410	assert(_version == 3)
				2411	_type = reader.read("!B")[0]
				2412	assert(_type == 4)
				2413	_length = reader.read("!H")[0]
				2414	orig_reader = reader
				2415	reader = orig_reader.slice(_length, 4)
				2416	obj.xid = reader.read("!L")[0]
				2417	_experimenter = reader.read("!L")[0]
				2418	assert(_experimenter == 6035143)
				2419	_subtype = reader.read("!L")[0]
				2420	assert(_subtype == 25)
				2421	obj.status = reader.read("!L")[0]
				2422	return obj
				2423
				2424	def __eq__(self, other):
				2425	if type(self) != type(other): return False
				2426	if self.xid != other.xid: return False
				2427	if self.status != other.status: return False
				2428	return True
				2429
				2430	def pretty_print(self, q):
				2431	q.text("bsn_set_pktin_suppression_reply {")
				2432	with q.group():
				2433	with q.indent(2):
				2434	q.breakable()
				2435	q.text("xid = ");
				2436	if self.xid != None:
				2437	q.text("%#x" % self.xid)
				2438	else:
				2439	q.text('None')
				2440	q.text(","); q.breakable()
				2441	q.text("status = ");
				2442	q.text("%#x" % self.status)
				2443	q.breakable()
				2444	q.text('}')
				2445
				2446	bsn_header.subtypes[25] = bsn_set_pktin_suppression_reply
				2447
				2448	class bsn_set_pktin_suppression_request(bsn_header):
				2449	version = 3
				2450	type = 4
				2451	experimenter = 6035143
				2452	subtype = 11
				2453
				2454	def __init__(self, xid=None, enabled=None, idle_timeout=None, hard_timeout=None, priority=None, cookie=None):
				2455	if xid != None:
				2456	self.xid = xid
				2457	else:
				2458	self.xid = None
				2459	if enabled != None:
				2460	self.enabled = enabled
				2461	else:
				2462	self.enabled = 0
				2463	if idle_timeout != None:
				2464	self.idle_timeout = idle_timeout
				2465	else:
				2466	self.idle_timeout = 0
				2467	if hard_timeout != None:
				2468	self.hard_timeout = hard_timeout
				2469	else:
				2470	self.hard_timeout = 0
				2471	if priority != None:
				2472	self.priority = priority
				2473	else:
				2474	self.priority = 0
				2475	if cookie != None:
				2476	self.cookie = cookie
				2477	else:
				2478	self.cookie = 0
				2479	return
				2480
				2481	def pack(self):
				2482	packed = []
				2483	packed.append(struct.pack("!B", self.version))
				2484	packed.append(struct.pack("!B", self.type))
				2485	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				2486	packed.append(struct.pack("!L", self.xid))
				2487	packed.append(struct.pack("!L", self.experimenter))
				2488	packed.append(struct.pack("!L", self.subtype))
				2489	packed.append(struct.pack("!B", self.enabled))
				2490	packed.append('\x00' * 1)
				2491	packed.append(struct.pack("!H", self.idle_timeout))
				2492	packed.append(struct.pack("!H", self.hard_timeout))
				2493	packed.append(struct.pack("!H", self.priority))
				2494	packed.append(struct.pack("!Q", self.cookie))
				2495	length = sum([len(x) for x in packed])
				2496	packed[2] = struct.pack("!H", length)
				2497	return ''.join(packed)
				2498
				2499	@staticmethod
				2500	def unpack(reader):
				2501	obj = bsn_set_pktin_suppression_request()
				2502	_version = reader.read("!B")[0]
				2503	assert(_version == 3)
				2504	_type = reader.read("!B")[0]
				2505	assert(_type == 4)
				2506	_length = reader.read("!H")[0]
				2507	orig_reader = reader
				2508	reader = orig_reader.slice(_length, 4)
				2509	obj.xid = reader.read("!L")[0]
				2510	_experimenter = reader.read("!L")[0]
				2511	assert(_experimenter == 6035143)
				2512	_subtype = reader.read("!L")[0]
				2513	assert(_subtype == 11)
				2514	obj.enabled = reader.read("!B")[0]
				2515	reader.skip(1)
				2516	obj.idle_timeout = reader.read("!H")[0]
				2517	obj.hard_timeout = reader.read("!H")[0]
				2518	obj.priority = reader.read("!H")[0]
				2519	obj.cookie = reader.read("!Q")[0]
				2520	return obj
				2521
				2522	def __eq__(self, other):
				2523	if type(self) != type(other): return False
				2524	if self.xid != other.xid: return False
				2525	if self.enabled != other.enabled: return False
				2526	if self.idle_timeout != other.idle_timeout: return False
				2527	if self.hard_timeout != other.hard_timeout: return False
				2528	if self.priority != other.priority: return False
				2529	if self.cookie != other.cookie: return False
				2530	return True
				2531
				2532	def pretty_print(self, q):
				2533	q.text("bsn_set_pktin_suppression_request {")
				2534	with q.group():
				2535	with q.indent(2):
				2536	q.breakable()
				2537	q.text("xid = ");
				2538	if self.xid != None:
				2539	q.text("%#x" % self.xid)
				2540	else:
				2541	q.text('None')
				2542	q.text(","); q.breakable()
				2543	q.text("enabled = ");
				2544	q.text("%#x" % self.enabled)
				2545	q.text(","); q.breakable()
				2546	q.text("idle_timeout = ");
				2547	q.text("%#x" % self.idle_timeout)
				2548	q.text(","); q.breakable()
				2549	q.text("hard_timeout = ");
				2550	q.text("%#x" % self.hard_timeout)
				2551	q.text(","); q.breakable()
				2552	q.text("priority = ");
				2553	q.text("%#x" % self.priority)
				2554	q.text(","); q.breakable()
				2555	q.text("cookie = ");
				2556	q.text("%#x" % self.cookie)
				2557	q.breakable()
				2558	q.text('}')
				2559
				2560	bsn_header.subtypes[11] = bsn_set_pktin_suppression_request
				2561
				2562	class experimenter_stats_reply(stats_reply):
				2563	subtypes = {}
				2564
				2565	version = 3
				2566	type = 19
				2567	stats_type = 65535
				2568
				2569	def __init__(self, xid=None, flags=None, experimenter=None, subtype=None, data=None):
				2570	if xid != None:
				2571	self.xid = xid
				2572	else:
				2573	self.xid = None
				2574	if flags != None:
				2575	self.flags = flags
				2576	else:
				2577	self.flags = 0
				2578	if experimenter != None:
				2579	self.experimenter = experimenter
				2580	else:
				2581	self.experimenter = 0
				2582	if subtype != None:
				2583	self.subtype = subtype
				2584	else:
				2585	self.subtype = 0
				2586	if data != None:
				2587	self.data = data
				2588	else:
				2589	self.data = ''
				2590	return
				2591
				2592	def pack(self):
				2593	packed = []
				2594	packed.append(struct.pack("!B", self.version))
				2595	packed.append(struct.pack("!B", self.type))
				2596	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				2597	packed.append(struct.pack("!L", self.xid))
				2598	packed.append(struct.pack("!H", self.stats_type))
				2599	packed.append(struct.pack("!H", self.flags))
				2600	packed.append('\x00' * 4)
				2601	packed.append(struct.pack("!L", self.experimenter))
				2602	packed.append(struct.pack("!L", self.subtype))
				2603	packed.append(self.data)
				2604	length = sum([len(x) for x in packed])
				2605	packed[2] = struct.pack("!H", length)
				2606	return ''.join(packed)
				2607
				2608	@staticmethod
				2609	def unpack(reader):
				2610	subtype, = reader.peek('!L', 16)
				2611	subclass = experimenter_stats_reply.subtypes.get(subtype)
				2612	if subclass:
				2613	return subclass.unpack(reader)
				2614
				2615	obj = experimenter_stats_reply()
				2616	_version = reader.read("!B")[0]
				2617	assert(_version == 3)
				2618	_type = reader.read("!B")[0]
				2619	assert(_type == 19)
				2620	_length = reader.read("!H")[0]
				2621	orig_reader = reader
				2622	reader = orig_reader.slice(_length, 4)
				2623	obj.xid = reader.read("!L")[0]
				2624	_stats_type = reader.read("!H")[0]
				2625	assert(_stats_type == 65535)
				2626	obj.flags = reader.read("!H")[0]
				2627	reader.skip(4)
				2628	obj.experimenter = reader.read("!L")[0]
				2629	obj.subtype = reader.read("!L")[0]
				2630	obj.data = str(reader.read_all())
				2631	return obj
				2632
				2633	def __eq__(self, other):
				2634	if type(self) != type(other): return False
				2635	if self.xid != other.xid: return False
				2636	if self.flags != other.flags: return False
				2637	if self.experimenter != other.experimenter: return False
				2638	if self.subtype != other.subtype: return False
				2639	if self.data != other.data: return False
				2640	return True
				2641
				2642	def pretty_print(self, q):
				2643	q.text("experimenter_stats_reply {")
				2644	with q.group():
				2645	with q.indent(2):
				2646	q.breakable()
				2647	q.text("xid = ");
				2648	if self.xid != None:
				2649	q.text("%#x" % self.xid)
				2650	else:
				2651	q.text('None')
				2652	q.text(","); q.breakable()
				2653	q.text("flags = ");
				2654	q.text("%#x" % self.flags)
				2655	q.text(","); q.breakable()
				2656	q.text("subtype = ");
				2657	q.text("%#x" % self.subtype)
				2658	q.text(","); q.breakable()
				2659	q.text("data = ");
				2660	q.pp(self.data)
				2661	q.breakable()
				2662	q.text('}')
				2663
				2664	stats_reply.subtypes[65535] = experimenter_stats_reply
				2665
				2666	class bsn_stats_reply(experimenter_stats_reply):
				2667	subtypes = {}
				2668
				2669	version = 3
				2670	type = 19
				2671	stats_type = 65535
				2672	experimenter = 6035143
				2673
				2674	def __init__(self, xid=None, flags=None, subtype=None):
				2675	if xid != None:
				2676	self.xid = xid
				2677	else:
				2678	self.xid = None
				2679	if flags != None:
				2680	self.flags = flags
				2681	else:
				2682	self.flags = 0
				2683	if subtype != None:
				2684	self.subtype = subtype
				2685	else:
				2686	self.subtype = 0
				2687	return
				2688
				2689	def pack(self):
				2690	packed = []
				2691	packed.append(struct.pack("!B", self.version))
				2692	packed.append(struct.pack("!B", self.type))
				2693	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				2694	packed.append(struct.pack("!L", self.xid))
				2695	packed.append(struct.pack("!H", self.stats_type))
				2696	packed.append(struct.pack("!H", self.flags))
				2697	packed.append('\x00' * 4)
				2698	packed.append(struct.pack("!L", self.experimenter))
				2699	packed.append(struct.pack("!L", self.subtype))
				2700	length = sum([len(x) for x in packed])
				2701	packed[2] = struct.pack("!H", length)
				2702	return ''.join(packed)
				2703
				2704	@staticmethod
				2705	def unpack(reader):
				2706	subtype, = reader.peek('!L', 20)
				2707	subclass = bsn_stats_reply.subtypes.get(subtype)
				2708	if subclass:
				2709	return subclass.unpack(reader)
				2710
				2711	obj = bsn_stats_reply()
				2712	_version = reader.read("!B")[0]
				2713	assert(_version == 3)
				2714	_type = reader.read("!B")[0]
				2715	assert(_type == 19)
				2716	_length = reader.read("!H")[0]
				2717	orig_reader = reader
				2718	reader = orig_reader.slice(_length, 4)
				2719	obj.xid = reader.read("!L")[0]
				2720	_stats_type = reader.read("!H")[0]
				2721	assert(_stats_type == 65535)
				2722	obj.flags = reader.read("!H")[0]
				2723	reader.skip(4)
				2724	_experimenter = reader.read("!L")[0]
				2725	assert(_experimenter == 6035143)
				2726	obj.subtype = reader.read("!L")[0]
				2727	return obj
				2728
				2729	def __eq__(self, other):
				2730	if type(self) != type(other): return False
				2731	if self.xid != other.xid: return False
				2732	if self.flags != other.flags: return False
				2733	if self.subtype != other.subtype: return False
				2734	return True
				2735
				2736	def pretty_print(self, q):
				2737	q.text("bsn_stats_reply {")
				2738	with q.group():
				2739	with q.indent(2):
				2740	q.breakable()
				2741	q.text("xid = ");
				2742	if self.xid != None:
				2743	q.text("%#x" % self.xid)
				2744	else:
				2745	q.text('None')
				2746	q.text(","); q.breakable()
				2747	q.text("flags = ");
				2748	q.text("%#x" % self.flags)
				2749	q.breakable()
				2750	q.text('}')
				2751
				2752	experimenter_stats_reply.subtypes[6035143] = bsn_stats_reply
				2753
				2754	class experimenter_stats_request(stats_request):
				2755	subtypes = {}
				2756
				2757	version = 3
				2758	type = 18
				2759	stats_type = 65535
				2760
				2761	def __init__(self, xid=None, flags=None, experimenter=None, subtype=None, data=None):
				2762	if xid != None:
				2763	self.xid = xid
				2764	else:
				2765	self.xid = None
				2766	if flags != None:
				2767	self.flags = flags
				2768	else:
				2769	self.flags = 0
				2770	if experimenter != None:
				2771	self.experimenter = experimenter
				2772	else:
				2773	self.experimenter = 0
				2774	if subtype != None:
				2775	self.subtype = subtype
				2776	else:
				2777	self.subtype = 0
				2778	if data != None:
				2779	self.data = data
				2780	else:
				2781	self.data = ''
				2782	return
				2783
				2784	def pack(self):
				2785	packed = []
				2786	packed.append(struct.pack("!B", self.version))
				2787	packed.append(struct.pack("!B", self.type))
				2788	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				2789	packed.append(struct.pack("!L", self.xid))
				2790	packed.append(struct.pack("!H", self.stats_type))
				2791	packed.append(struct.pack("!H", self.flags))
				2792	packed.append('\x00' * 4)
				2793	packed.append(struct.pack("!L", self.experimenter))
				2794	packed.append(struct.pack("!L", self.subtype))
				2795	packed.append(self.data)
				2796	length = sum([len(x) for x in packed])
				2797	packed[2] = struct.pack("!H", length)
				2798	return ''.join(packed)
				2799
				2800	@staticmethod
				2801	def unpack(reader):
				2802	subtype, = reader.peek('!L', 16)
				2803	subclass = experimenter_stats_request.subtypes.get(subtype)
				2804	if subclass:
				2805	return subclass.unpack(reader)
				2806
				2807	obj = experimenter_stats_request()
				2808	_version = reader.read("!B")[0]
				2809	assert(_version == 3)
				2810	_type = reader.read("!B")[0]
				2811	assert(_type == 18)
				2812	_length = reader.read("!H")[0]
				2813	orig_reader = reader
				2814	reader = orig_reader.slice(_length, 4)
				2815	obj.xid = reader.read("!L")[0]
				2816	_stats_type = reader.read("!H")[0]
				2817	assert(_stats_type == 65535)
				2818	obj.flags = reader.read("!H")[0]
				2819	reader.skip(4)
				2820	obj.experimenter = reader.read("!L")[0]
				2821	obj.subtype = reader.read("!L")[0]
				2822	obj.data = str(reader.read_all())
				2823	return obj
				2824
				2825	def __eq__(self, other):
				2826	if type(self) != type(other): return False
				2827	if self.xid != other.xid: return False
				2828	if self.flags != other.flags: return False
				2829	if self.experimenter != other.experimenter: return False
				2830	if self.subtype != other.subtype: return False
				2831	if self.data != other.data: return False
				2832	return True
				2833
				2834	def pretty_print(self, q):
				2835	q.text("experimenter_stats_request {")
				2836	with q.group():
				2837	with q.indent(2):
				2838	q.breakable()
				2839	q.text("xid = ");
				2840	if self.xid != None:
				2841	q.text("%#x" % self.xid)
				2842	else:
				2843	q.text('None')
				2844	q.text(","); q.breakable()
				2845	q.text("flags = ");
				2846	q.text("%#x" % self.flags)
				2847	q.text(","); q.breakable()
				2848	q.text("subtype = ");
				2849	q.text("%#x" % self.subtype)
				2850	q.text(","); q.breakable()
				2851	q.text("data = ");
				2852	q.pp(self.data)
				2853	q.breakable()
				2854	q.text('}')
				2855
				2856	stats_request.subtypes[65535] = experimenter_stats_request
				2857
				2858	class bsn_stats_request(experimenter_stats_request):
				2859	subtypes = {}
				2860
				2861	version = 3
				2862	type = 18
				2863	stats_type = 65535
				2864	experimenter = 6035143
				2865
				2866	def __init__(self, xid=None, flags=None, subtype=None):
				2867	if xid != None:
				2868	self.xid = xid
				2869	else:
				2870	self.xid = None
				2871	if flags != None:
				2872	self.flags = flags
				2873	else:
				2874	self.flags = 0
				2875	if subtype != None:
				2876	self.subtype = subtype
				2877	else:
				2878	self.subtype = 0
				2879	return
				2880
				2881	def pack(self):
				2882	packed = []
				2883	packed.append(struct.pack("!B", self.version))
				2884	packed.append(struct.pack("!B", self.type))
				2885	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				2886	packed.append(struct.pack("!L", self.xid))
				2887	packed.append(struct.pack("!H", self.stats_type))
				2888	packed.append(struct.pack("!H", self.flags))
				2889	packed.append('\x00' * 4)
				2890	packed.append(struct.pack("!L", self.experimenter))
				2891	packed.append(struct.pack("!L", self.subtype))
				2892	length = sum([len(x) for x in packed])
				2893	packed[2] = struct.pack("!H", length)
				2894	return ''.join(packed)
				2895
				2896	@staticmethod
				2897	def unpack(reader):
				2898	subtype, = reader.peek('!L', 20)
				2899	subclass = bsn_stats_request.subtypes.get(subtype)
				2900	if subclass:
				2901	return subclass.unpack(reader)
				2902
				2903	obj = bsn_stats_request()
				2904	_version = reader.read("!B")[0]
				2905	assert(_version == 3)
				2906	_type = reader.read("!B")[0]
				2907	assert(_type == 18)
				2908	_length = reader.read("!H")[0]
				2909	orig_reader = reader
				2910	reader = orig_reader.slice(_length, 4)
				2911	obj.xid = reader.read("!L")[0]
				2912	_stats_type = reader.read("!H")[0]
				2913	assert(_stats_type == 65535)
				2914	obj.flags = reader.read("!H")[0]
				2915	reader.skip(4)
				2916	_experimenter = reader.read("!L")[0]
				2917	assert(_experimenter == 6035143)
				2918	obj.subtype = reader.read("!L")[0]
				2919	return obj
				2920
				2921	def __eq__(self, other):
				2922	if type(self) != type(other): return False
				2923	if self.xid != other.xid: return False
				2924	if self.flags != other.flags: return False
				2925	if self.subtype != other.subtype: return False
				2926	return True
				2927
				2928	def pretty_print(self, q):
				2929	q.text("bsn_stats_request {")
				2930	with q.group():
				2931	with q.indent(2):
				2932	q.breakable()
				2933	q.text("xid = ");
				2934	if self.xid != None:
				2935	q.text("%#x" % self.xid)
				2936	else:
				2937	q.text('None')
				2938	q.text(","); q.breakable()
				2939	q.text("flags = ");
				2940	q.text("%#x" % self.flags)
				2941	q.breakable()
				2942	q.text('}')
				2943
				2944	experimenter_stats_request.subtypes[6035143] = bsn_stats_request
				2945
				2946	class bsn_virtual_port_create_reply(bsn_header):
				2947	version = 3
				2948	type = 4
				2949	experimenter = 6035143
				2950	subtype = 16
				2951
				2952	def __init__(self, xid=None, status=None, vport_no=None):
				2953	if xid != None:
				2954	self.xid = xid
				2955	else:
				2956	self.xid = None
				2957	if status != None:
				2958	self.status = status
				2959	else:
				2960	self.status = 0
				2961	if vport_no != None:
				2962	self.vport_no = vport_no
				2963	else:
				2964	self.vport_no = 0
				2965	return
				2966
				2967	def pack(self):
				2968	packed = []
				2969	packed.append(struct.pack("!B", self.version))
				2970	packed.append(struct.pack("!B", self.type))
				2971	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				2972	packed.append(struct.pack("!L", self.xid))
				2973	packed.append(struct.pack("!L", self.experimenter))
				2974	packed.append(struct.pack("!L", self.subtype))
				2975	packed.append(struct.pack("!L", self.status))
				2976	packed.append(struct.pack("!L", self.vport_no))
				2977	length = sum([len(x) for x in packed])
				2978	packed[2] = struct.pack("!H", length)
				2979	return ''.join(packed)
				2980
				2981	@staticmethod
				2982	def unpack(reader):
				2983	obj = bsn_virtual_port_create_reply()
				2984	_version = reader.read("!B")[0]
				2985	assert(_version == 3)
				2986	_type = reader.read("!B")[0]
				2987	assert(_type == 4)
				2988	_length = reader.read("!H")[0]
				2989	orig_reader = reader
				2990	reader = orig_reader.slice(_length, 4)
				2991	obj.xid = reader.read("!L")[0]
				2992	_experimenter = reader.read("!L")[0]
				2993	assert(_experimenter == 6035143)
				2994	_subtype = reader.read("!L")[0]
				2995	assert(_subtype == 16)
				2996	obj.status = reader.read("!L")[0]
				2997	obj.vport_no = reader.read("!L")[0]
				2998	return obj
				2999
				3000	def __eq__(self, other):
				3001	if type(self) != type(other): return False
				3002	if self.xid != other.xid: return False
				3003	if self.status != other.status: return False
				3004	if self.vport_no != other.vport_no: return False
				3005	return True
				3006
				3007	def pretty_print(self, q):
				3008	q.text("bsn_virtual_port_create_reply {")
				3009	with q.group():
				3010	with q.indent(2):
				3011	q.breakable()
				3012	q.text("xid = ");
				3013	if self.xid != None:
				3014	q.text("%#x" % self.xid)
				3015	else:
				3016	q.text('None')
				3017	q.text(","); q.breakable()
				3018	q.text("status = ");
				3019	q.text("%#x" % self.status)
				3020	q.text(","); q.breakable()
				3021	q.text("vport_no = ");
				3022	q.text("%#x" % self.vport_no)
				3023	q.breakable()
				3024	q.text('}')
				3025
				3026	bsn_header.subtypes[16] = bsn_virtual_port_create_reply
				3027
				3028	class bsn_virtual_port_create_request(bsn_header):
				3029	version = 3
				3030	type = 4
				3031	experimenter = 6035143
				3032	subtype = 15
				3033
				3034	def __init__(self, xid=None, vport=None):
				3035	if xid != None:
				3036	self.xid = xid
				3037	else:
				3038	self.xid = None
				3039	if vport != None:
				3040	self.vport = vport
				3041	else:
				3042	self.vport = ofp.bsn_vport()
				3043	return
				3044
				3045	def pack(self):
				3046	packed = []
				3047	packed.append(struct.pack("!B", self.version))
				3048	packed.append(struct.pack("!B", self.type))
				3049	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				3050	packed.append(struct.pack("!L", self.xid))
				3051	packed.append(struct.pack("!L", self.experimenter))
				3052	packed.append(struct.pack("!L", self.subtype))
				3053	packed.append(self.vport.pack())
				3054	length = sum([len(x) for x in packed])
				3055	packed[2] = struct.pack("!H", length)
				3056	return ''.join(packed)
				3057
				3058	@staticmethod
				3059	def unpack(reader):
				3060	obj = bsn_virtual_port_create_request()
				3061	_version = reader.read("!B")[0]
				3062	assert(_version == 3)
				3063	_type = reader.read("!B")[0]
				3064	assert(_type == 4)
				3065	_length = reader.read("!H")[0]
				3066	orig_reader = reader
				3067	reader = orig_reader.slice(_length, 4)
				3068	obj.xid = reader.read("!L")[0]
				3069	_experimenter = reader.read("!L")[0]
				3070	assert(_experimenter == 6035143)
				3071	_subtype = reader.read("!L")[0]
				3072	assert(_subtype == 15)
				3073	obj.vport = ofp.bsn_vport.unpack(reader)
				3074	return obj
				3075
				3076	def __eq__(self, other):
				3077	if type(self) != type(other): return False
				3078	if self.xid != other.xid: return False
				3079	if self.vport != other.vport: return False
				3080	return True
				3081
				3082	def pretty_print(self, q):
				3083	q.text("bsn_virtual_port_create_request {")
				3084	with q.group():
				3085	with q.indent(2):
				3086	q.breakable()
				3087	q.text("xid = ");
				3088	if self.xid != None:
				3089	q.text("%#x" % self.xid)
				3090	else:
				3091	q.text('None')
				3092	q.text(","); q.breakable()
				3093	q.text("vport = ");
				3094	q.pp(self.vport)
				3095	q.breakable()
				3096	q.text('}')
				3097
				3098	bsn_header.subtypes[15] = bsn_virtual_port_create_request
				3099
				3100	class bsn_virtual_port_remove_reply(bsn_header):
				3101	version = 3
				3102	type = 4
				3103	experimenter = 6035143
				3104	subtype = 26
				3105
				3106	def __init__(self, xid=None, status=None):
				3107	if xid != None:
				3108	self.xid = xid
				3109	else:
				3110	self.xid = None
				3111	if status != None:
				3112	self.status = status
				3113	else:
				3114	self.status = 0
				3115	return
				3116
				3117	def pack(self):
				3118	packed = []
				3119	packed.append(struct.pack("!B", self.version))
				3120	packed.append(struct.pack("!B", self.type))
				3121	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				3122	packed.append(struct.pack("!L", self.xid))
				3123	packed.append(struct.pack("!L", self.experimenter))
				3124	packed.append(struct.pack("!L", self.subtype))
				3125	packed.append(struct.pack("!L", self.status))
				3126	length = sum([len(x) for x in packed])
				3127	packed[2] = struct.pack("!H", length)
				3128	return ''.join(packed)
				3129
				3130	@staticmethod
				3131	def unpack(reader):
				3132	obj = bsn_virtual_port_remove_reply()
				3133	_version = reader.read("!B")[0]
				3134	assert(_version == 3)
				3135	_type = reader.read("!B")[0]
				3136	assert(_type == 4)
				3137	_length = reader.read("!H")[0]
				3138	orig_reader = reader
				3139	reader = orig_reader.slice(_length, 4)
				3140	obj.xid = reader.read("!L")[0]
				3141	_experimenter = reader.read("!L")[0]
				3142	assert(_experimenter == 6035143)
				3143	_subtype = reader.read("!L")[0]
				3144	assert(_subtype == 26)
				3145	obj.status = reader.read("!L")[0]
				3146	return obj
				3147
				3148	def __eq__(self, other):
				3149	if type(self) != type(other): return False
				3150	if self.xid != other.xid: return False
				3151	if self.status != other.status: return False
				3152	return True
				3153
				3154	def pretty_print(self, q):
				3155	q.text("bsn_virtual_port_remove_reply {")
				3156	with q.group():
				3157	with q.indent(2):
				3158	q.breakable()
				3159	q.text("xid = ");
				3160	if self.xid != None:
				3161	q.text("%#x" % self.xid)
				3162	else:
				3163	q.text('None')
				3164	q.text(","); q.breakable()
				3165	q.text("status = ");
				3166	q.text("%#x" % self.status)
				3167	q.breakable()
				3168	q.text('}')
				3169
				3170	bsn_header.subtypes[26] = bsn_virtual_port_remove_reply
				3171
				3172	class bsn_virtual_port_remove_request(bsn_header):
				3173	version = 3
				3174	type = 4
				3175	experimenter = 6035143
				3176	subtype = 17
				3177
				3178	def __init__(self, xid=None, vport_no=None):
				3179	if xid != None:
				3180	self.xid = xid
				3181	else:
				3182	self.xid = None
				3183	if vport_no != None:
				3184	self.vport_no = vport_no
				3185	else:
				3186	self.vport_no = 0
				3187	return
				3188
				3189	def pack(self):
				3190	packed = []
				3191	packed.append(struct.pack("!B", self.version))
				3192	packed.append(struct.pack("!B", self.type))
				3193	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				3194	packed.append(struct.pack("!L", self.xid))
				3195	packed.append(struct.pack("!L", self.experimenter))
				3196	packed.append(struct.pack("!L", self.subtype))
				3197	packed.append(struct.pack("!L", self.vport_no))
				3198	length = sum([len(x) for x in packed])
				3199	packed[2] = struct.pack("!H", length)
				3200	return ''.join(packed)
				3201
				3202	@staticmethod
				3203	def unpack(reader):
				3204	obj = bsn_virtual_port_remove_request()
				3205	_version = reader.read("!B")[0]
				3206	assert(_version == 3)
				3207	_type = reader.read("!B")[0]
				3208	assert(_type == 4)
				3209	_length = reader.read("!H")[0]
				3210	orig_reader = reader
				3211	reader = orig_reader.slice(_length, 4)
				3212	obj.xid = reader.read("!L")[0]
				3213	_experimenter = reader.read("!L")[0]
				3214	assert(_experimenter == 6035143)
				3215	_subtype = reader.read("!L")[0]
				3216	assert(_subtype == 17)
				3217	obj.vport_no = reader.read("!L")[0]
				3218	return obj
				3219
				3220	def __eq__(self, other):
				3221	if type(self) != type(other): return False
				3222	if self.xid != other.xid: return False
				3223	if self.vport_no != other.vport_no: return False
				3224	return True
				3225
				3226	def pretty_print(self, q):
				3227	q.text("bsn_virtual_port_remove_request {")
				3228	with q.group():
				3229	with q.indent(2):
				3230	q.breakable()
				3231	q.text("xid = ");
				3232	if self.xid != None:
				3233	q.text("%#x" % self.xid)
				3234	else:
				3235	q.text('None')
				3236	q.text(","); q.breakable()
				3237	q.text("vport_no = ");
				3238	q.text("%#x" % self.vport_no)
				3239	q.breakable()
				3240	q.text('}')
				3241
				3242	bsn_header.subtypes[17] = bsn_virtual_port_remove_request
				3243
				3244	class desc_stats_reply(stats_reply):
				3245	version = 3
				3246	type = 19
				3247	stats_type = 0
				3248
				3249	def __init__(self, xid=None, flags=None, mfr_desc=None, hw_desc=None, sw_desc=None, serial_num=None, dp_desc=None):
				3250	if xid != None:
				3251	self.xid = xid
				3252	else:
				3253	self.xid = None
				3254	if flags != None:
				3255	self.flags = flags
				3256	else:
				3257	self.flags = 0
				3258	if mfr_desc != None:
				3259	self.mfr_desc = mfr_desc
				3260	else:
				3261	self.mfr_desc = ""
				3262	if hw_desc != None:
				3263	self.hw_desc = hw_desc
				3264	else:
				3265	self.hw_desc = ""
				3266	if sw_desc != None:
				3267	self.sw_desc = sw_desc
				3268	else:
				3269	self.sw_desc = ""
				3270	if serial_num != None:
				3271	self.serial_num = serial_num
				3272	else:
				3273	self.serial_num = ""
				3274	if dp_desc != None:
				3275	self.dp_desc = dp_desc
				3276	else:
				3277	self.dp_desc = ""
				3278	return
				3279
				3280	def pack(self):
				3281	packed = []
				3282	packed.append(struct.pack("!B", self.version))
				3283	packed.append(struct.pack("!B", self.type))
				3284	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				3285	packed.append(struct.pack("!L", self.xid))
				3286	packed.append(struct.pack("!H", self.stats_type))
				3287	packed.append(struct.pack("!H", self.flags))
				3288	packed.append('\x00' * 4)
				3289	packed.append(struct.pack("!256s", self.mfr_desc))
				3290	packed.append(struct.pack("!256s", self.hw_desc))
				3291	packed.append(struct.pack("!256s", self.sw_desc))
				3292	packed.append(struct.pack("!32s", self.serial_num))
				3293	packed.append(struct.pack("!256s", self.dp_desc))
				3294	length = sum([len(x) for x in packed])
				3295	packed[2] = struct.pack("!H", length)
				3296	return ''.join(packed)
				3297
				3298	@staticmethod
				3299	def unpack(reader):
				3300	obj = desc_stats_reply()
				3301	_version = reader.read("!B")[0]
				3302	assert(_version == 3)
				3303	_type = reader.read("!B")[0]
				3304	assert(_type == 19)
				3305	_length = reader.read("!H")[0]
				3306	orig_reader = reader
				3307	reader = orig_reader.slice(_length, 4)
				3308	obj.xid = reader.read("!L")[0]
				3309	_stats_type = reader.read("!H")[0]
				3310	assert(_stats_type == 0)
				3311	obj.flags = reader.read("!H")[0]
				3312	reader.skip(4)
				3313	obj.mfr_desc = reader.read("!256s")[0].rstrip("\x00")
				3314	obj.hw_desc = reader.read("!256s")[0].rstrip("\x00")
				3315	obj.sw_desc = reader.read("!256s")[0].rstrip("\x00")
				3316	obj.serial_num = reader.read("!32s")[0].rstrip("\x00")
				3317	obj.dp_desc = reader.read("!256s")[0].rstrip("\x00")
				3318	return obj
				3319
				3320	def __eq__(self, other):
				3321	if type(self) != type(other): return False
				3322	if self.xid != other.xid: return False
				3323	if self.flags != other.flags: return False
				3324	if self.mfr_desc != other.mfr_desc: return False
				3325	if self.hw_desc != other.hw_desc: return False
				3326	if self.sw_desc != other.sw_desc: return False
				3327	if self.serial_num != other.serial_num: return False
				3328	if self.dp_desc != other.dp_desc: return False
				3329	return True
				3330
				3331	def pretty_print(self, q):
				3332	q.text("desc_stats_reply {")
				3333	with q.group():
				3334	with q.indent(2):
				3335	q.breakable()
				3336	q.text("xid = ");
				3337	if self.xid != None:
				3338	q.text("%#x" % self.xid)
				3339	else:
				3340	q.text('None')
				3341	q.text(","); q.breakable()
				3342	q.text("flags = ");
				3343	q.text("%#x" % self.flags)
				3344	q.text(","); q.breakable()
				3345	q.text("mfr_desc = ");
				3346	q.pp(self.mfr_desc)
				3347	q.text(","); q.breakable()
				3348	q.text("hw_desc = ");
				3349	q.pp(self.hw_desc)
				3350	q.text(","); q.breakable()
				3351	q.text("sw_desc = ");
				3352	q.pp(self.sw_desc)
				3353	q.text(","); q.breakable()
				3354	q.text("serial_num = ");
				3355	q.pp(self.serial_num)
				3356	q.text(","); q.breakable()
				3357	q.text("dp_desc = ");
				3358	q.pp(self.dp_desc)
				3359	q.breakable()
				3360	q.text('}')
				3361
				3362	stats_reply.subtypes[0] = desc_stats_reply
				3363
				3364	class desc_stats_request(stats_request):
				3365	version = 3
				3366	type = 18
				3367	stats_type = 0
				3368
				3369	def __init__(self, xid=None, flags=None):
				3370	if xid != None:
				3371	self.xid = xid
				3372	else:
				3373	self.xid = None
				3374	if flags != None:
				3375	self.flags = flags
				3376	else:
				3377	self.flags = 0
				3378	return
				3379
				3380	def pack(self):
				3381	packed = []
				3382	packed.append(struct.pack("!B", self.version))
				3383	packed.append(struct.pack("!B", self.type))
				3384	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				3385	packed.append(struct.pack("!L", self.xid))
				3386	packed.append(struct.pack("!H", self.stats_type))
				3387	packed.append(struct.pack("!H", self.flags))
				3388	packed.append('\x00' * 4)
				3389	length = sum([len(x) for x in packed])
				3390	packed[2] = struct.pack("!H", length)
				3391	return ''.join(packed)
				3392
				3393	@staticmethod
				3394	def unpack(reader):
				3395	obj = desc_stats_request()
				3396	_version = reader.read("!B")[0]
				3397	assert(_version == 3)
				3398	_type = reader.read("!B")[0]
				3399	assert(_type == 18)
				3400	_length = reader.read("!H")[0]
				3401	orig_reader = reader
				3402	reader = orig_reader.slice(_length, 4)
				3403	obj.xid = reader.read("!L")[0]
				3404	_stats_type = reader.read("!H")[0]
				3405	assert(_stats_type == 0)
				3406	obj.flags = reader.read("!H")[0]
				3407	reader.skip(4)
				3408	return obj
				3409
				3410	def __eq__(self, other):
				3411	if type(self) != type(other): return False
				3412	if self.xid != other.xid: return False
				3413	if self.flags != other.flags: return False
				3414	return True
				3415
				3416	def pretty_print(self, q):
				3417	q.text("desc_stats_request {")
				3418	with q.group():
				3419	with q.indent(2):
				3420	q.breakable()
				3421	q.text("xid = ");
				3422	if self.xid != None:
				3423	q.text("%#x" % self.xid)
				3424	else:
				3425	q.text('None')
				3426	q.text(","); q.breakable()
				3427	q.text("flags = ");
				3428	q.text("%#x" % self.flags)
				3429	q.breakable()
				3430	q.text('}')
				3431
				3432	stats_request.subtypes[0] = desc_stats_request
				3433
				3434	class echo_reply(message):
				3435	version = 3
				3436	type = 3
				3437
				3438	def __init__(self, xid=None, data=None):
				3439	if xid != None:
				3440	self.xid = xid
				3441	else:
				3442	self.xid = None
				3443	if data != None:
				3444	self.data = data
				3445	else:
				3446	self.data = ''
				3447	return
				3448
				3449	def pack(self):
				3450	packed = []
				3451	packed.append(struct.pack("!B", self.version))
				3452	packed.append(struct.pack("!B", self.type))
				3453	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				3454	packed.append(struct.pack("!L", self.xid))
				3455	packed.append(self.data)
				3456	length = sum([len(x) for x in packed])
				3457	packed[2] = struct.pack("!H", length)
				3458	return ''.join(packed)
				3459
				3460	@staticmethod
				3461	def unpack(reader):
				3462	obj = echo_reply()
				3463	_version = reader.read("!B")[0]
				3464	assert(_version == 3)
				3465	_type = reader.read("!B")[0]
				3466	assert(_type == 3)
				3467	_length = reader.read("!H")[0]
				3468	orig_reader = reader
				3469	reader = orig_reader.slice(_length, 4)
				3470	obj.xid = reader.read("!L")[0]
				3471	obj.data = str(reader.read_all())
				3472	return obj
				3473
				3474	def __eq__(self, other):
				3475	if type(self) != type(other): return False
				3476	if self.xid != other.xid: return False
				3477	if self.data != other.data: return False
				3478	return True
				3479
				3480	def pretty_print(self, q):
				3481	q.text("echo_reply {")
				3482	with q.group():
				3483	with q.indent(2):
				3484	q.breakable()
				3485	q.text("xid = ");
				3486	if self.xid != None:
				3487	q.text("%#x" % self.xid)
				3488	else:
				3489	q.text('None')
				3490	q.text(","); q.breakable()
				3491	q.text("data = ");
				3492	q.pp(self.data)
				3493	q.breakable()
				3494	q.text('}')
				3495
				3496	message.subtypes[3] = echo_reply
				3497
				3498	class echo_request(message):
				3499	version = 3
				3500	type = 2
				3501
				3502	def __init__(self, xid=None, data=None):
				3503	if xid != None:
				3504	self.xid = xid
				3505	else:
				3506	self.xid = None
				3507	if data != None:
				3508	self.data = data
				3509	else:
				3510	self.data = ''
				3511	return
				3512
				3513	def pack(self):
				3514	packed = []
				3515	packed.append(struct.pack("!B", self.version))
				3516	packed.append(struct.pack("!B", self.type))
				3517	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				3518	packed.append(struct.pack("!L", self.xid))
				3519	packed.append(self.data)
				3520	length = sum([len(x) for x in packed])
				3521	packed[2] = struct.pack("!H", length)
				3522	return ''.join(packed)
				3523
				3524	@staticmethod
				3525	def unpack(reader):
				3526	obj = echo_request()
				3527	_version = reader.read("!B")[0]
				3528	assert(_version == 3)
				3529	_type = reader.read("!B")[0]
				3530	assert(_type == 2)
				3531	_length = reader.read("!H")[0]
				3532	orig_reader = reader
				3533	reader = orig_reader.slice(_length, 4)
				3534	obj.xid = reader.read("!L")[0]
				3535	obj.data = str(reader.read_all())
				3536	return obj
				3537
				3538	def __eq__(self, other):
				3539	if type(self) != type(other): return False
				3540	if self.xid != other.xid: return False
				3541	if self.data != other.data: return False
				3542	return True
				3543
				3544	def pretty_print(self, q):
				3545	q.text("echo_request {")
				3546	with q.group():
				3547	with q.indent(2):
				3548	q.breakable()
				3549	q.text("xid = ");
				3550	if self.xid != None:
				3551	q.text("%#x" % self.xid)
				3552	else:
				3553	q.text('None')
				3554	q.text(","); q.breakable()
				3555	q.text("data = ");
				3556	q.pp(self.data)
				3557	q.breakable()
				3558	q.text('}')
				3559
				3560	message.subtypes[2] = echo_request
				3561
				3562	class experimenter_error_msg(error_msg):
				3563	subtypes = {}
				3564
				3565	version = 3
				3566	type = 1
				3567	err_type = 65535
				3568
				3569	def __init__(self, xid=None, subtype=None, experimenter=None, data=None):
				3570	if xid != None:
				3571	self.xid = xid
				3572	else:
				3573	self.xid = None
				3574	if subtype != None:
				3575	self.subtype = subtype
				3576	else:
				3577	self.subtype = 0
				3578	if experimenter != None:
				3579	self.experimenter = experimenter
				3580	else:
				3581	self.experimenter = 0
				3582	if data != None:
				3583	self.data = data
				3584	else:
				3585	self.data = ''
				3586	return
				3587
				3588	def pack(self):
				3589	packed = []
				3590	packed.append(struct.pack("!B", self.version))
				3591	packed.append(struct.pack("!B", self.type))
				3592	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				3593	packed.append(struct.pack("!L", self.xid))
				3594	packed.append(struct.pack("!H", self.err_type))
				3595	packed.append(struct.pack("!H", self.subtype))
				3596	packed.append(struct.pack("!L", self.experimenter))
				3597	packed.append(self.data)
				3598	length = sum([len(x) for x in packed])
				3599	packed[2] = struct.pack("!H", length)
				3600	return ''.join(packed)
				3601
				3602	@staticmethod
				3603	def unpack(reader):
				3604	subtype, = reader.peek('!L', 12)
				3605	subclass = experimenter_error_msg.subtypes.get(subtype)
				3606	if subclass:
				3607	return subclass.unpack(reader)
				3608
				3609	obj = experimenter_error_msg()
				3610	_version = reader.read("!B")[0]
				3611	assert(_version == 3)
				3612	_type = reader.read("!B")[0]
				3613	assert(_type == 1)
				3614	_length = reader.read("!H")[0]
				3615	orig_reader = reader
				3616	reader = orig_reader.slice(_length, 4)
				3617	obj.xid = reader.read("!L")[0]
				3618	_err_type = reader.read("!H")[0]
				3619	assert(_err_type == 65535)
				3620	obj.subtype = reader.read("!H")[0]
				3621	obj.experimenter = reader.read("!L")[0]
				3622	obj.data = str(reader.read_all())
				3623	return obj
				3624
				3625	def __eq__(self, other):
				3626	if type(self) != type(other): return False
				3627	if self.xid != other.xid: return False
				3628	if self.subtype != other.subtype: return False
				3629	if self.experimenter != other.experimenter: return False
				3630	if self.data != other.data: return False
				3631	return True
				3632
				3633	def pretty_print(self, q):
				3634	q.text("experimenter_error_msg {")
				3635	with q.group():
				3636	with q.indent(2):
				3637	q.breakable()
				3638	q.text("xid = ");
				3639	if self.xid != None:
				3640	q.text("%#x" % self.xid)
				3641	else:
				3642	q.text('None')
				3643	q.text(","); q.breakable()
				3644	q.text("subtype = ");
				3645	q.text("%#x" % self.subtype)
				3646	q.text(","); q.breakable()
				3647	q.text("data = ");
				3648	q.pp(self.data)
				3649	q.breakable()
				3650	q.text('}')
				3651
				3652	error_msg.subtypes[65535] = experimenter_error_msg
				3653
				3654	class features_reply(message):
				3655	version = 3
				3656	type = 6
				3657
				3658	def __init__(self, xid=None, datapath_id=None, n_buffers=None, n_tables=None, capabilities=None, reserved=None, ports=None):
				3659	if xid != None:
				3660	self.xid = xid
				3661	else:
				3662	self.xid = None
				3663	if datapath_id != None:
				3664	self.datapath_id = datapath_id
				3665	else:
				3666	self.datapath_id = 0
				3667	if n_buffers != None:
				3668	self.n_buffers = n_buffers
				3669	else:
				3670	self.n_buffers = 0
				3671	if n_tables != None:
				3672	self.n_tables = n_tables
				3673	else:
				3674	self.n_tables = 0
				3675	if capabilities != None:
				3676	self.capabilities = capabilities
				3677	else:
				3678	self.capabilities = 0
				3679	if reserved != None:
				3680	self.reserved = reserved
				3681	else:
				3682	self.reserved = 0
				3683	if ports != None:
				3684	self.ports = ports
				3685	else:
				3686	self.ports = []
				3687	return
				3688
				3689	def pack(self):
				3690	packed = []
				3691	packed.append(struct.pack("!B", self.version))
				3692	packed.append(struct.pack("!B", self.type))
				3693	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				3694	packed.append(struct.pack("!L", self.xid))
				3695	packed.append(struct.pack("!Q", self.datapath_id))
				3696	packed.append(struct.pack("!L", self.n_buffers))
				3697	packed.append(struct.pack("!B", self.n_tables))
				3698	packed.append('\x00' * 3)
				3699	packed.append(struct.pack("!L", self.capabilities))
				3700	packed.append(struct.pack("!L", self.reserved))
				3701	packed.append(loxi.generic_util.pack_list(self.ports))
				3702	length = sum([len(x) for x in packed])
				3703	packed[2] = struct.pack("!H", length)
				3704	return ''.join(packed)
				3705
				3706	@staticmethod
				3707	def unpack(reader):
				3708	obj = features_reply()
				3709	_version = reader.read("!B")[0]
				3710	assert(_version == 3)
				3711	_type = reader.read("!B")[0]
				3712	assert(_type == 6)
				3713	_length = reader.read("!H")[0]
				3714	orig_reader = reader
				3715	reader = orig_reader.slice(_length, 4)
				3716	obj.xid = reader.read("!L")[0]
				3717	obj.datapath_id = reader.read("!Q")[0]
				3718	obj.n_buffers = reader.read("!L")[0]
				3719	obj.n_tables = reader.read("!B")[0]
				3720	reader.skip(3)
				3721	obj.capabilities = reader.read("!L")[0]
				3722	obj.reserved = reader.read("!L")[0]
				3723	obj.ports = loxi.generic_util.unpack_list(reader, ofp.common.port_desc.unpack)
				3724	return obj
				3725
				3726	def __eq__(self, other):
				3727	if type(self) != type(other): return False
				3728	if self.xid != other.xid: return False
				3729	if self.datapath_id != other.datapath_id: return False
				3730	if self.n_buffers != other.n_buffers: return False
				3731	if self.n_tables != other.n_tables: return False
				3732	if self.capabilities != other.capabilities: return False
				3733	if self.reserved != other.reserved: return False
				3734	if self.ports != other.ports: return False
				3735	return True
				3736
				3737	def pretty_print(self, q):
				3738	q.text("features_reply {")
				3739	with q.group():
				3740	with q.indent(2):
				3741	q.breakable()
				3742	q.text("xid = ");
				3743	if self.xid != None:
				3744	q.text("%#x" % self.xid)
				3745	else:
				3746	q.text('None')
				3747	q.text(","); q.breakable()
				3748	q.text("datapath_id = ");
				3749	q.text("%#x" % self.datapath_id)
				3750	q.text(","); q.breakable()
				3751	q.text("n_buffers = ");
				3752	q.text("%#x" % self.n_buffers)
				3753	q.text(","); q.breakable()
				3754	q.text("n_tables = ");
				3755	q.text("%#x" % self.n_tables)
				3756	q.text(","); q.breakable()
				3757	q.text("capabilities = ");
				3758	q.text("%#x" % self.capabilities)
				3759	q.text(","); q.breakable()
				3760	q.text("reserved = ");
				3761	q.text("%#x" % self.reserved)
				3762	q.text(","); q.breakable()
				3763	q.text("ports = ");
				3764	q.pp(self.ports)
				3765	q.breakable()
				3766	q.text('}')
				3767
				3768	message.subtypes[6] = features_reply
				3769
				3770	class features_request(message):
				3771	version = 3
				3772	type = 5
				3773
				3774	def __init__(self, xid=None):
				3775	if xid != None:
				3776	self.xid = xid
				3777	else:
				3778	self.xid = None
				3779	return
				3780
				3781	def pack(self):
				3782	packed = []
				3783	packed.append(struct.pack("!B", self.version))
				3784	packed.append(struct.pack("!B", self.type))
				3785	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				3786	packed.append(struct.pack("!L", self.xid))
				3787	length = sum([len(x) for x in packed])
				3788	packed[2] = struct.pack("!H", length)
				3789	return ''.join(packed)
				3790
				3791	@staticmethod
				3792	def unpack(reader):
				3793	obj = features_request()
				3794	_version = reader.read("!B")[0]
				3795	assert(_version == 3)
				3796	_type = reader.read("!B")[0]
				3797	assert(_type == 5)
				3798	_length = reader.read("!H")[0]
				3799	orig_reader = reader
				3800	reader = orig_reader.slice(_length, 4)
				3801	obj.xid = reader.read("!L")[0]
				3802	return obj
				3803
				3804	def __eq__(self, other):
				3805	if type(self) != type(other): return False
				3806	if self.xid != other.xid: return False
				3807	return True
				3808
				3809	def pretty_print(self, q):
				3810	q.text("features_request {")
				3811	with q.group():
				3812	with q.indent(2):
				3813	q.breakable()
				3814	q.text("xid = ");
				3815	if self.xid != None:
				3816	q.text("%#x" % self.xid)
				3817	else:
				3818	q.text('None')
				3819	q.breakable()
				3820	q.text('}')
				3821
				3822	message.subtypes[5] = features_request
				3823
				3824	class flow_mod(message):
				3825	subtypes = {}
				3826
				3827	version = 3
				3828	type = 14
				3829
				3830	def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, _command=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, match=None, instructions=None):
				3831	if xid != None:
				3832	self.xid = xid
				3833	else:
				3834	self.xid = None
				3835	if cookie != None:
				3836	self.cookie = cookie
				3837	else:
				3838	self.cookie = 0
				3839	if cookie_mask != None:
				3840	self.cookie_mask = cookie_mask
				3841	else:
				3842	self.cookie_mask = 0
				3843	if table_id != None:
				3844	self.table_id = table_id
				3845	else:
				3846	self.table_id = 0
				3847	if _command != None:
				3848	self._command = _command
				3849	else:
				3850	self._command = 0
				3851	if idle_timeout != None:
				3852	self.idle_timeout = idle_timeout
				3853	else:
				3854	self.idle_timeout = 0
				3855	if hard_timeout != None:
				3856	self.hard_timeout = hard_timeout
				3857	else:
				3858	self.hard_timeout = 0
				3859	if priority != None:
				3860	self.priority = priority
				3861	else:
				3862	self.priority = 0
				3863	if buffer_id != None:
				3864	self.buffer_id = buffer_id
				3865	else:
				3866	self.buffer_id = 0
				3867	if out_port != None:
				3868	self.out_port = out_port
				3869	else:
				3870	self.out_port = 0
				3871	if out_group != None:
				3872	self.out_group = out_group
				3873	else:
				3874	self.out_group = 0
				3875	if flags != None:
				3876	self.flags = flags
				3877	else:
				3878	self.flags = 0
				3879	if match != None:
				3880	self.match = match
				3881	else:
				3882	self.match = ofp.match()
				3883	if instructions != None:
				3884	self.instructions = instructions
				3885	else:
				3886	self.instructions = []
				3887	return
				3888
				3889	def pack(self):
				3890	packed = []
				3891	packed.append(struct.pack("!B", self.version))
				3892	packed.append(struct.pack("!B", self.type))
				3893	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				3894	packed.append(struct.pack("!L", self.xid))
				3895	packed.append(struct.pack("!Q", self.cookie))
				3896	packed.append(struct.pack("!Q", self.cookie_mask))
				3897	packed.append(struct.pack("!B", self.table_id))
				3898	packed.append(util.pack_fm_cmd(self._command))
				3899	packed.append(struct.pack("!H", self.idle_timeout))
				3900	packed.append(struct.pack("!H", self.hard_timeout))
				3901	packed.append(struct.pack("!H", self.priority))
				3902	packed.append(struct.pack("!L", self.buffer_id))
				3903	packed.append(util.pack_port_no(self.out_port))
				3904	packed.append(struct.pack("!L", self.out_group))
				3905	packed.append(struct.pack("!H", self.flags))
				3906	packed.append('\x00' * 2)
				3907	packed.append(self.match.pack())
				3908	packed.append(loxi.generic_util.pack_list(self.instructions))
				3909	length = sum([len(x) for x in packed])
				3910	packed[2] = struct.pack("!H", length)
				3911	return ''.join(packed)
				3912
				3913	@staticmethod
				3914	def unpack(reader):
				3915	subtype, = reader.peek('B', 25)
				3916	subclass = flow_mod.subtypes.get(subtype)
				3917	if subclass:
				3918	return subclass.unpack(reader)
				3919
				3920	obj = flow_mod()
				3921	_version = reader.read("!B")[0]
				3922	assert(_version == 3)
				3923	_type = reader.read("!B")[0]
				3924	assert(_type == 14)
				3925	_length = reader.read("!H")[0]
				3926	orig_reader = reader
				3927	reader = orig_reader.slice(_length, 4)
				3928	obj.xid = reader.read("!L")[0]
				3929	obj.cookie = reader.read("!Q")[0]
				3930	obj.cookie_mask = reader.read("!Q")[0]
				3931	obj.table_id = reader.read("!B")[0]
				3932	obj._command = util.unpack_fm_cmd(reader)
				3933	obj.idle_timeout = reader.read("!H")[0]
				3934	obj.hard_timeout = reader.read("!H")[0]
				3935	obj.priority = reader.read("!H")[0]
				3936	obj.buffer_id = reader.read("!L")[0]
				3937	obj.out_port = util.unpack_port_no(reader)
				3938	obj.out_group = reader.read("!L")[0]
				3939	obj.flags = reader.read("!H")[0]
				3940	reader.skip(2)
				3941	obj.match = ofp.match.unpack(reader)
				3942	obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
				3943	return obj
				3944
				3945	def __eq__(self, other):
				3946	if type(self) != type(other): return False
				3947	if self.xid != other.xid: return False
				3948	if self.cookie != other.cookie: return False
				3949	if self.cookie_mask != other.cookie_mask: return False
				3950	if self.table_id != other.table_id: return False
				3951	if self._command != other._command: return False
				3952	if self.idle_timeout != other.idle_timeout: return False
				3953	if self.hard_timeout != other.hard_timeout: return False
				3954	if self.priority != other.priority: return False
				3955	if self.buffer_id != other.buffer_id: return False
				3956	if self.out_port != other.out_port: return False
				3957	if self.out_group != other.out_group: return False
				3958	if self.flags != other.flags: return False
				3959	if self.match != other.match: return False
				3960	if self.instructions != other.instructions: return False
				3961	return True
				3962
				3963	def pretty_print(self, q):
				3964	q.text("flow_mod {")
				3965	with q.group():
				3966	with q.indent(2):
				3967	q.breakable()
				3968	q.text("xid = ");
				3969	if self.xid != None:
				3970	q.text("%#x" % self.xid)
				3971	else:
				3972	q.text('None')
				3973	q.text(","); q.breakable()
				3974	q.text("cookie = ");
				3975	q.text("%#x" % self.cookie)
				3976	q.text(","); q.breakable()
				3977	q.text("cookie_mask = ");
				3978	q.text("%#x" % self.cookie_mask)
				3979	q.text(","); q.breakable()
				3980	q.text("table_id = ");
				3981	q.text("%#x" % self.table_id)
				3982	q.text(","); q.breakable()
				3983	q.text("idle_timeout = ");
				3984	q.text("%#x" % self.idle_timeout)
				3985	q.text(","); q.breakable()
				3986	q.text("hard_timeout = ");
				3987	q.text("%#x" % self.hard_timeout)
				3988	q.text(","); q.breakable()
				3989	q.text("priority = ");
				3990	q.text("%#x" % self.priority)
				3991	q.text(","); q.breakable()
				3992	q.text("buffer_id = ");
				3993	q.text("%#x" % self.buffer_id)
				3994	q.text(","); q.breakable()
				3995	q.text("out_port = ");
				3996	q.text(util.pretty_port(self.out_port))
				3997	q.text(","); q.breakable()
				3998	q.text("out_group = ");
				3999	q.text("%#x" % self.out_group)
				4000	q.text(","); q.breakable()
				4001	q.text("flags = ");
				4002	q.text("%#x" % self.flags)
				4003	q.text(","); q.breakable()
				4004	q.text("match = ");
				4005	q.pp(self.match)
				4006	q.text(","); q.breakable()
				4007	q.text("instructions = ");
				4008	q.pp(self.instructions)
				4009	q.breakable()
				4010	q.text('}')
				4011
				4012	message.subtypes[14] = flow_mod
				4013
				4014	class flow_add(flow_mod):
				4015	version = 3
				4016	type = 14
				4017	_command = 0
				4018
				4019	def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, match=None, instructions=None):
				4020	if xid != None:
				4021	self.xid = xid
				4022	else:
				4023	self.xid = None
				4024	if cookie != None:
				4025	self.cookie = cookie
				4026	else:
				4027	self.cookie = 0
				4028	if cookie_mask != None:
				4029	self.cookie_mask = cookie_mask
				4030	else:
				4031	self.cookie_mask = 0
				4032	if table_id != None:
				4033	self.table_id = table_id
				4034	else:
				4035	self.table_id = 0
				4036	if idle_timeout != None:
				4037	self.idle_timeout = idle_timeout
				4038	else:
				4039	self.idle_timeout = 0
				4040	if hard_timeout != None:
				4041	self.hard_timeout = hard_timeout
				4042	else:
				4043	self.hard_timeout = 0
				4044	if priority != None:
				4045	self.priority = priority
				4046	else:
				4047	self.priority = 0
				4048	if buffer_id != None:
				4049	self.buffer_id = buffer_id
				4050	else:
				4051	self.buffer_id = 0
				4052	if out_port != None:
				4053	self.out_port = out_port
				4054	else:
				4055	self.out_port = 0
				4056	if out_group != None:
				4057	self.out_group = out_group
				4058	else:
				4059	self.out_group = 0
				4060	if flags != None:
				4061	self.flags = flags
				4062	else:
				4063	self.flags = 0
				4064	if match != None:
				4065	self.match = match
				4066	else:
				4067	self.match = ofp.match()
				4068	if instructions != None:
				4069	self.instructions = instructions
				4070	else:
				4071	self.instructions = []
				4072	return
				4073
				4074	def pack(self):
				4075	packed = []
				4076	packed.append(struct.pack("!B", self.version))
				4077	packed.append(struct.pack("!B", self.type))
				4078	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				4079	packed.append(struct.pack("!L", self.xid))
				4080	packed.append(struct.pack("!Q", self.cookie))
				4081	packed.append(struct.pack("!Q", self.cookie_mask))
				4082	packed.append(struct.pack("!B", self.table_id))
				4083	packed.append(util.pack_fm_cmd(self._command))
				4084	packed.append(struct.pack("!H", self.idle_timeout))
				4085	packed.append(struct.pack("!H", self.hard_timeout))
				4086	packed.append(struct.pack("!H", self.priority))
				4087	packed.append(struct.pack("!L", self.buffer_id))
				4088	packed.append(util.pack_port_no(self.out_port))
				4089	packed.append(struct.pack("!L", self.out_group))
				4090	packed.append(struct.pack("!H", self.flags))
				4091	packed.append('\x00' * 2)
				4092	packed.append(self.match.pack())
				4093	packed.append(loxi.generic_util.pack_list(self.instructions))
				4094	length = sum([len(x) for x in packed])
				4095	packed[2] = struct.pack("!H", length)
				4096	return ''.join(packed)
				4097
				4098	@staticmethod
				4099	def unpack(reader):
				4100	obj = flow_add()
				4101	_version = reader.read("!B")[0]
				4102	assert(_version == 3)
				4103	_type = reader.read("!B")[0]
				4104	assert(_type == 14)
				4105	_length = reader.read("!H")[0]
				4106	orig_reader = reader
				4107	reader = orig_reader.slice(_length, 4)
				4108	obj.xid = reader.read("!L")[0]
				4109	obj.cookie = reader.read("!Q")[0]
				4110	obj.cookie_mask = reader.read("!Q")[0]
				4111	obj.table_id = reader.read("!B")[0]
				4112	__command = util.unpack_fm_cmd(reader)
				4113	assert(__command == 0)
				4114	obj.idle_timeout = reader.read("!H")[0]
				4115	obj.hard_timeout = reader.read("!H")[0]
				4116	obj.priority = reader.read("!H")[0]
				4117	obj.buffer_id = reader.read("!L")[0]
				4118	obj.out_port = util.unpack_port_no(reader)
				4119	obj.out_group = reader.read("!L")[0]
				4120	obj.flags = reader.read("!H")[0]
				4121	reader.skip(2)
				4122	obj.match = ofp.match.unpack(reader)
				4123	obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
				4124	return obj
				4125
				4126	def __eq__(self, other):
				4127	if type(self) != type(other): return False
				4128	if self.xid != other.xid: return False
				4129	if self.cookie != other.cookie: return False
				4130	if self.cookie_mask != other.cookie_mask: return False
				4131	if self.table_id != other.table_id: return False
				4132	if self.idle_timeout != other.idle_timeout: return False
				4133	if self.hard_timeout != other.hard_timeout: return False
				4134	if self.priority != other.priority: return False
				4135	if self.buffer_id != other.buffer_id: return False
				4136	if self.out_port != other.out_port: return False
				4137	if self.out_group != other.out_group: return False
				4138	if self.flags != other.flags: return False
				4139	if self.match != other.match: return False
				4140	if self.instructions != other.instructions: return False
				4141	return True
				4142
				4143	def pretty_print(self, q):
				4144	q.text("flow_add {")
				4145	with q.group():
				4146	with q.indent(2):
				4147	q.breakable()
				4148	q.text("xid = ");
				4149	if self.xid != None:
				4150	q.text("%#x" % self.xid)
				4151	else:
				4152	q.text('None')
				4153	q.text(","); q.breakable()
				4154	q.text("cookie = ");
				4155	q.text("%#x" % self.cookie)
				4156	q.text(","); q.breakable()
				4157	q.text("cookie_mask = ");
				4158	q.text("%#x" % self.cookie_mask)
				4159	q.text(","); q.breakable()
				4160	q.text("table_id = ");
				4161	q.text("%#x" % self.table_id)
				4162	q.text(","); q.breakable()
				4163	q.text("idle_timeout = ");
				4164	q.text("%#x" % self.idle_timeout)
				4165	q.text(","); q.breakable()
				4166	q.text("hard_timeout = ");
				4167	q.text("%#x" % self.hard_timeout)
				4168	q.text(","); q.breakable()
				4169	q.text("priority = ");
				4170	q.text("%#x" % self.priority)
				4171	q.text(","); q.breakable()
				4172	q.text("buffer_id = ");
				4173	q.text("%#x" % self.buffer_id)
				4174	q.text(","); q.breakable()
				4175	q.text("out_port = ");
				4176	q.text(util.pretty_port(self.out_port))
				4177	q.text(","); q.breakable()
				4178	q.text("out_group = ");
				4179	q.text("%#x" % self.out_group)
				4180	q.text(","); q.breakable()
				4181	q.text("flags = ");
				4182	q.text("%#x" % self.flags)
				4183	q.text(","); q.breakable()
				4184	q.text("match = ");
				4185	q.pp(self.match)
				4186	q.text(","); q.breakable()
				4187	q.text("instructions = ");
				4188	q.pp(self.instructions)
				4189	q.breakable()
				4190	q.text('}')
				4191
				4192	flow_mod.subtypes[0] = flow_add
				4193
				4194	class flow_delete(flow_mod):
				4195	version = 3
				4196	type = 14
				4197	_command = 3
				4198
				4199	def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, match=None, instructions=None):
				4200	if xid != None:
				4201	self.xid = xid
				4202	else:
				4203	self.xid = None
				4204	if cookie != None:
				4205	self.cookie = cookie
				4206	else:
				4207	self.cookie = 0
				4208	if cookie_mask != None:
				4209	self.cookie_mask = cookie_mask
				4210	else:
				4211	self.cookie_mask = 0
				4212	if table_id != None:
				4213	self.table_id = table_id
				4214	else:
				4215	self.table_id = 0
				4216	if idle_timeout != None:
				4217	self.idle_timeout = idle_timeout
				4218	else:
				4219	self.idle_timeout = 0
				4220	if hard_timeout != None:
				4221	self.hard_timeout = hard_timeout
				4222	else:
				4223	self.hard_timeout = 0
				4224	if priority != None:
				4225	self.priority = priority
				4226	else:
				4227	self.priority = 0
				4228	if buffer_id != None:
				4229	self.buffer_id = buffer_id
				4230	else:
				4231	self.buffer_id = 0
				4232	if out_port != None:
				4233	self.out_port = out_port
				4234	else:
				4235	self.out_port = 0
				4236	if out_group != None:
				4237	self.out_group = out_group
				4238	else:
				4239	self.out_group = 0
				4240	if flags != None:
				4241	self.flags = flags
				4242	else:
				4243	self.flags = 0
				4244	if match != None:
				4245	self.match = match
				4246	else:
				4247	self.match = ofp.match()
				4248	if instructions != None:
				4249	self.instructions = instructions
				4250	else:
				4251	self.instructions = []
				4252	return
				4253
				4254	def pack(self):
				4255	packed = []
				4256	packed.append(struct.pack("!B", self.version))
				4257	packed.append(struct.pack("!B", self.type))
				4258	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				4259	packed.append(struct.pack("!L", self.xid))
				4260	packed.append(struct.pack("!Q", self.cookie))
				4261	packed.append(struct.pack("!Q", self.cookie_mask))
				4262	packed.append(struct.pack("!B", self.table_id))
				4263	packed.append(util.pack_fm_cmd(self._command))
				4264	packed.append(struct.pack("!H", self.idle_timeout))
				4265	packed.append(struct.pack("!H", self.hard_timeout))
				4266	packed.append(struct.pack("!H", self.priority))
				4267	packed.append(struct.pack("!L", self.buffer_id))
				4268	packed.append(util.pack_port_no(self.out_port))
				4269	packed.append(struct.pack("!L", self.out_group))
				4270	packed.append(struct.pack("!H", self.flags))
				4271	packed.append('\x00' * 2)
				4272	packed.append(self.match.pack())
				4273	packed.append(loxi.generic_util.pack_list(self.instructions))
				4274	length = sum([len(x) for x in packed])
				4275	packed[2] = struct.pack("!H", length)
				4276	return ''.join(packed)
				4277
				4278	@staticmethod
				4279	def unpack(reader):
				4280	obj = flow_delete()
				4281	_version = reader.read("!B")[0]
				4282	assert(_version == 3)
				4283	_type = reader.read("!B")[0]
				4284	assert(_type == 14)
				4285	_length = reader.read("!H")[0]
				4286	orig_reader = reader
				4287	reader = orig_reader.slice(_length, 4)
				4288	obj.xid = reader.read("!L")[0]
				4289	obj.cookie = reader.read("!Q")[0]
				4290	obj.cookie_mask = reader.read("!Q")[0]
				4291	obj.table_id = reader.read("!B")[0]
				4292	__command = util.unpack_fm_cmd(reader)
				4293	assert(__command == 3)
				4294	obj.idle_timeout = reader.read("!H")[0]
				4295	obj.hard_timeout = reader.read("!H")[0]
				4296	obj.priority = reader.read("!H")[0]
				4297	obj.buffer_id = reader.read("!L")[0]
				4298	obj.out_port = util.unpack_port_no(reader)
				4299	obj.out_group = reader.read("!L")[0]
				4300	obj.flags = reader.read("!H")[0]
				4301	reader.skip(2)
				4302	obj.match = ofp.match.unpack(reader)
				4303	obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
				4304	return obj
				4305
				4306	def __eq__(self, other):
				4307	if type(self) != type(other): return False
				4308	if self.xid != other.xid: return False
				4309	if self.cookie != other.cookie: return False
				4310	if self.cookie_mask != other.cookie_mask: return False
				4311	if self.table_id != other.table_id: return False
				4312	if self.idle_timeout != other.idle_timeout: return False
				4313	if self.hard_timeout != other.hard_timeout: return False
				4314	if self.priority != other.priority: return False
				4315	if self.buffer_id != other.buffer_id: return False
				4316	if self.out_port != other.out_port: return False
				4317	if self.out_group != other.out_group: return False
				4318	if self.flags != other.flags: return False
				4319	if self.match != other.match: return False
				4320	if self.instructions != other.instructions: return False
				4321	return True
				4322
				4323	def pretty_print(self, q):
				4324	q.text("flow_delete {")
				4325	with q.group():
				4326	with q.indent(2):
				4327	q.breakable()
				4328	q.text("xid = ");
				4329	if self.xid != None:
				4330	q.text("%#x" % self.xid)
				4331	else:
				4332	q.text('None')
				4333	q.text(","); q.breakable()
				4334	q.text("cookie = ");
				4335	q.text("%#x" % self.cookie)
				4336	q.text(","); q.breakable()
				4337	q.text("cookie_mask = ");
				4338	q.text("%#x" % self.cookie_mask)
				4339	q.text(","); q.breakable()
				4340	q.text("table_id = ");
				4341	q.text("%#x" % self.table_id)
				4342	q.text(","); q.breakable()
				4343	q.text("idle_timeout = ");
				4344	q.text("%#x" % self.idle_timeout)
				4345	q.text(","); q.breakable()
				4346	q.text("hard_timeout = ");
				4347	q.text("%#x" % self.hard_timeout)
				4348	q.text(","); q.breakable()
				4349	q.text("priority = ");
				4350	q.text("%#x" % self.priority)
				4351	q.text(","); q.breakable()
				4352	q.text("buffer_id = ");
				4353	q.text("%#x" % self.buffer_id)
				4354	q.text(","); q.breakable()
				4355	q.text("out_port = ");
				4356	q.text(util.pretty_port(self.out_port))
				4357	q.text(","); q.breakable()
				4358	q.text("out_group = ");
				4359	q.text("%#x" % self.out_group)
				4360	q.text(","); q.breakable()
				4361	q.text("flags = ");
				4362	q.text("%#x" % self.flags)
				4363	q.text(","); q.breakable()
				4364	q.text("match = ");
				4365	q.pp(self.match)
				4366	q.text(","); q.breakable()
				4367	q.text("instructions = ");
				4368	q.pp(self.instructions)
				4369	q.breakable()
				4370	q.text('}')
				4371
				4372	flow_mod.subtypes[3] = flow_delete
				4373
				4374	class flow_delete_strict(flow_mod):
				4375	version = 3
				4376	type = 14
				4377	_command = 4
				4378
				4379	def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, match=None, instructions=None):
				4380	if xid != None:
				4381	self.xid = xid
				4382	else:
				4383	self.xid = None
				4384	if cookie != None:
				4385	self.cookie = cookie
				4386	else:
				4387	self.cookie = 0
				4388	if cookie_mask != None:
				4389	self.cookie_mask = cookie_mask
				4390	else:
				4391	self.cookie_mask = 0
				4392	if table_id != None:
				4393	self.table_id = table_id
				4394	else:
				4395	self.table_id = 0
				4396	if idle_timeout != None:
				4397	self.idle_timeout = idle_timeout
				4398	else:
				4399	self.idle_timeout = 0
				4400	if hard_timeout != None:
				4401	self.hard_timeout = hard_timeout
				4402	else:
				4403	self.hard_timeout = 0
				4404	if priority != None:
				4405	self.priority = priority
				4406	else:
				4407	self.priority = 0
				4408	if buffer_id != None:
				4409	self.buffer_id = buffer_id
				4410	else:
				4411	self.buffer_id = 0
				4412	if out_port != None:
				4413	self.out_port = out_port
				4414	else:
				4415	self.out_port = 0
				4416	if out_group != None:
				4417	self.out_group = out_group
				4418	else:
				4419	self.out_group = 0
				4420	if flags != None:
				4421	self.flags = flags
				4422	else:
				4423	self.flags = 0
				4424	if match != None:
				4425	self.match = match
				4426	else:
				4427	self.match = ofp.match()
				4428	if instructions != None:
				4429	self.instructions = instructions
				4430	else:
				4431	self.instructions = []
				4432	return
				4433
				4434	def pack(self):
				4435	packed = []
				4436	packed.append(struct.pack("!B", self.version))
				4437	packed.append(struct.pack("!B", self.type))
				4438	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				4439	packed.append(struct.pack("!L", self.xid))
				4440	packed.append(struct.pack("!Q", self.cookie))
				4441	packed.append(struct.pack("!Q", self.cookie_mask))
				4442	packed.append(struct.pack("!B", self.table_id))
				4443	packed.append(util.pack_fm_cmd(self._command))
				4444	packed.append(struct.pack("!H", self.idle_timeout))
				4445	packed.append(struct.pack("!H", self.hard_timeout))
				4446	packed.append(struct.pack("!H", self.priority))
				4447	packed.append(struct.pack("!L", self.buffer_id))
				4448	packed.append(util.pack_port_no(self.out_port))
				4449	packed.append(struct.pack("!L", self.out_group))
				4450	packed.append(struct.pack("!H", self.flags))
				4451	packed.append('\x00' * 2)
				4452	packed.append(self.match.pack())
				4453	packed.append(loxi.generic_util.pack_list(self.instructions))
				4454	length = sum([len(x) for x in packed])
				4455	packed[2] = struct.pack("!H", length)
				4456	return ''.join(packed)
				4457
				4458	@staticmethod
				4459	def unpack(reader):
				4460	obj = flow_delete_strict()
				4461	_version = reader.read("!B")[0]
				4462	assert(_version == 3)
				4463	_type = reader.read("!B")[0]
				4464	assert(_type == 14)
				4465	_length = reader.read("!H")[0]
				4466	orig_reader = reader
				4467	reader = orig_reader.slice(_length, 4)
				4468	obj.xid = reader.read("!L")[0]
				4469	obj.cookie = reader.read("!Q")[0]
				4470	obj.cookie_mask = reader.read("!Q")[0]
				4471	obj.table_id = reader.read("!B")[0]
				4472	__command = util.unpack_fm_cmd(reader)
				4473	assert(__command == 4)
				4474	obj.idle_timeout = reader.read("!H")[0]
				4475	obj.hard_timeout = reader.read("!H")[0]
				4476	obj.priority = reader.read("!H")[0]
				4477	obj.buffer_id = reader.read("!L")[0]
				4478	obj.out_port = util.unpack_port_no(reader)
				4479	obj.out_group = reader.read("!L")[0]
				4480	obj.flags = reader.read("!H")[0]
				4481	reader.skip(2)
				4482	obj.match = ofp.match.unpack(reader)
				4483	obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
				4484	return obj
				4485
				4486	def __eq__(self, other):
				4487	if type(self) != type(other): return False
				4488	if self.xid != other.xid: return False
				4489	if self.cookie != other.cookie: return False
				4490	if self.cookie_mask != other.cookie_mask: return False
				4491	if self.table_id != other.table_id: return False
				4492	if self.idle_timeout != other.idle_timeout: return False
				4493	if self.hard_timeout != other.hard_timeout: return False
				4494	if self.priority != other.priority: return False
				4495	if self.buffer_id != other.buffer_id: return False
				4496	if self.out_port != other.out_port: return False
				4497	if self.out_group != other.out_group: return False
				4498	if self.flags != other.flags: return False
				4499	if self.match != other.match: return False
				4500	if self.instructions != other.instructions: return False
				4501	return True
				4502
				4503	def pretty_print(self, q):
				4504	q.text("flow_delete_strict {")
				4505	with q.group():
				4506	with q.indent(2):
				4507	q.breakable()
				4508	q.text("xid = ");
				4509	if self.xid != None:
				4510	q.text("%#x" % self.xid)
				4511	else:
				4512	q.text('None')
				4513	q.text(","); q.breakable()
				4514	q.text("cookie = ");
				4515	q.text("%#x" % self.cookie)
				4516	q.text(","); q.breakable()
				4517	q.text("cookie_mask = ");
				4518	q.text("%#x" % self.cookie_mask)
				4519	q.text(","); q.breakable()
				4520	q.text("table_id = ");
				4521	q.text("%#x" % self.table_id)
				4522	q.text(","); q.breakable()
				4523	q.text("idle_timeout = ");
				4524	q.text("%#x" % self.idle_timeout)
				4525	q.text(","); q.breakable()
				4526	q.text("hard_timeout = ");
				4527	q.text("%#x" % self.hard_timeout)
				4528	q.text(","); q.breakable()
				4529	q.text("priority = ");
				4530	q.text("%#x" % self.priority)
				4531	q.text(","); q.breakable()
				4532	q.text("buffer_id = ");
				4533	q.text("%#x" % self.buffer_id)
				4534	q.text(","); q.breakable()
				4535	q.text("out_port = ");
				4536	q.text(util.pretty_port(self.out_port))
				4537	q.text(","); q.breakable()
				4538	q.text("out_group = ");
				4539	q.text("%#x" % self.out_group)
				4540	q.text(","); q.breakable()
				4541	q.text("flags = ");
				4542	q.text("%#x" % self.flags)
				4543	q.text(","); q.breakable()
				4544	q.text("match = ");
				4545	q.pp(self.match)
				4546	q.text(","); q.breakable()
				4547	q.text("instructions = ");
				4548	q.pp(self.instructions)
				4549	q.breakable()
				4550	q.text('}')
				4551
				4552	flow_mod.subtypes[4] = flow_delete_strict
				4553
				4554	class flow_mod_failed_error_msg(error_msg):
				4555	version = 3
				4556	type = 1
				4557	err_type = 5
				4558
				4559	def __init__(self, xid=None, code=None, data=None):
				4560	if xid != None:
				4561	self.xid = xid
				4562	else:
				4563	self.xid = None
				4564	if code != None:
				4565	self.code = code
				4566	else:
				4567	self.code = 0
				4568	if data != None:
				4569	self.data = data
				4570	else:
				4571	self.data = ''
				4572	return
				4573
				4574	def pack(self):
				4575	packed = []
				4576	packed.append(struct.pack("!B", self.version))
				4577	packed.append(struct.pack("!B", self.type))
				4578	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				4579	packed.append(struct.pack("!L", self.xid))
				4580	packed.append(struct.pack("!H", self.err_type))
				4581	packed.append(struct.pack("!H", self.code))
				4582	packed.append(self.data)
				4583	length = sum([len(x) for x in packed])
				4584	packed[2] = struct.pack("!H", length)
				4585	return ''.join(packed)
				4586
				4587	@staticmethod
				4588	def unpack(reader):
				4589	obj = flow_mod_failed_error_msg()
				4590	_version = reader.read("!B")[0]
				4591	assert(_version == 3)
				4592	_type = reader.read("!B")[0]
				4593	assert(_type == 1)
				4594	_length = reader.read("!H")[0]
				4595	orig_reader = reader
				4596	reader = orig_reader.slice(_length, 4)
				4597	obj.xid = reader.read("!L")[0]
				4598	_err_type = reader.read("!H")[0]
				4599	assert(_err_type == 5)
				4600	obj.code = reader.read("!H")[0]
				4601	obj.data = str(reader.read_all())
				4602	return obj
				4603
				4604	def __eq__(self, other):
				4605	if type(self) != type(other): return False
				4606	if self.xid != other.xid: return False
				4607	if self.code != other.code: return False
				4608	if self.data != other.data: return False
				4609	return True
				4610
				4611	def pretty_print(self, q):
				4612	q.text("flow_mod_failed_error_msg {")
				4613	with q.group():
				4614	with q.indent(2):
				4615	q.breakable()
				4616	q.text("xid = ");
				4617	if self.xid != None:
				4618	q.text("%#x" % self.xid)
				4619	else:
				4620	q.text('None')
				4621	q.text(","); q.breakable()
				4622	q.text("code = ");
				4623	q.text("%#x" % self.code)
				4624	q.text(","); q.breakable()
				4625	q.text("data = ");
				4626	q.pp(self.data)
				4627	q.breakable()
				4628	q.text('}')
				4629
				4630	error_msg.subtypes[5] = flow_mod_failed_error_msg
				4631
				4632	class flow_modify(flow_mod):
				4633	version = 3
				4634	type = 14
				4635	_command = 1
				4636
				4637	def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, match=None, instructions=None):
				4638	if xid != None:
				4639	self.xid = xid
				4640	else:
				4641	self.xid = None
				4642	if cookie != None:
				4643	self.cookie = cookie
				4644	else:
				4645	self.cookie = 0
				4646	if cookie_mask != None:
				4647	self.cookie_mask = cookie_mask
				4648	else:
				4649	self.cookie_mask = 0
				4650	if table_id != None:
				4651	self.table_id = table_id
				4652	else:
				4653	self.table_id = 0
				4654	if idle_timeout != None:
				4655	self.idle_timeout = idle_timeout
				4656	else:
				4657	self.idle_timeout = 0
				4658	if hard_timeout != None:
				4659	self.hard_timeout = hard_timeout
				4660	else:
				4661	self.hard_timeout = 0
				4662	if priority != None:
				4663	self.priority = priority
				4664	else:
				4665	self.priority = 0
				4666	if buffer_id != None:
				4667	self.buffer_id = buffer_id
				4668	else:
				4669	self.buffer_id = 0
				4670	if out_port != None:
				4671	self.out_port = out_port
				4672	else:
				4673	self.out_port = 0
				4674	if out_group != None:
				4675	self.out_group = out_group
				4676	else:
				4677	self.out_group = 0
				4678	if flags != None:
				4679	self.flags = flags
				4680	else:
				4681	self.flags = 0
				4682	if match != None:
				4683	self.match = match
				4684	else:
				4685	self.match = ofp.match()
				4686	if instructions != None:
				4687	self.instructions = instructions
				4688	else:
				4689	self.instructions = []
				4690	return
				4691
				4692	def pack(self):
				4693	packed = []
				4694	packed.append(struct.pack("!B", self.version))
				4695	packed.append(struct.pack("!B", self.type))
				4696	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				4697	packed.append(struct.pack("!L", self.xid))
				4698	packed.append(struct.pack("!Q", self.cookie))
				4699	packed.append(struct.pack("!Q", self.cookie_mask))
				4700	packed.append(struct.pack("!B", self.table_id))
				4701	packed.append(util.pack_fm_cmd(self._command))
				4702	packed.append(struct.pack("!H", self.idle_timeout))
				4703	packed.append(struct.pack("!H", self.hard_timeout))
				4704	packed.append(struct.pack("!H", self.priority))
				4705	packed.append(struct.pack("!L", self.buffer_id))
				4706	packed.append(util.pack_port_no(self.out_port))
				4707	packed.append(struct.pack("!L", self.out_group))
				4708	packed.append(struct.pack("!H", self.flags))
				4709	packed.append('\x00' * 2)
				4710	packed.append(self.match.pack())
				4711	packed.append(loxi.generic_util.pack_list(self.instructions))
				4712	length = sum([len(x) for x in packed])
				4713	packed[2] = struct.pack("!H", length)
				4714	return ''.join(packed)
				4715
				4716	@staticmethod
				4717	def unpack(reader):
				4718	obj = flow_modify()
				4719	_version = reader.read("!B")[0]
				4720	assert(_version == 3)
				4721	_type = reader.read("!B")[0]
				4722	assert(_type == 14)
				4723	_length = reader.read("!H")[0]
				4724	orig_reader = reader
				4725	reader = orig_reader.slice(_length, 4)
				4726	obj.xid = reader.read("!L")[0]
				4727	obj.cookie = reader.read("!Q")[0]
				4728	obj.cookie_mask = reader.read("!Q")[0]
				4729	obj.table_id = reader.read("!B")[0]
				4730	__command = util.unpack_fm_cmd(reader)
				4731	assert(__command == 1)
				4732	obj.idle_timeout = reader.read("!H")[0]
				4733	obj.hard_timeout = reader.read("!H")[0]
				4734	obj.priority = reader.read("!H")[0]
				4735	obj.buffer_id = reader.read("!L")[0]
				4736	obj.out_port = util.unpack_port_no(reader)
				4737	obj.out_group = reader.read("!L")[0]
				4738	obj.flags = reader.read("!H")[0]
				4739	reader.skip(2)
				4740	obj.match = ofp.match.unpack(reader)
				4741	obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
				4742	return obj
				4743
				4744	def __eq__(self, other):
				4745	if type(self) != type(other): return False
				4746	if self.xid != other.xid: return False
				4747	if self.cookie != other.cookie: return False
				4748	if self.cookie_mask != other.cookie_mask: return False
				4749	if self.table_id != other.table_id: return False
				4750	if self.idle_timeout != other.idle_timeout: return False
				4751	if self.hard_timeout != other.hard_timeout: return False
				4752	if self.priority != other.priority: return False
				4753	if self.buffer_id != other.buffer_id: return False
				4754	if self.out_port != other.out_port: return False
				4755	if self.out_group != other.out_group: return False
				4756	if self.flags != other.flags: return False
				4757	if self.match != other.match: return False
				4758	if self.instructions != other.instructions: return False
				4759	return True
				4760
				4761	def pretty_print(self, q):
				4762	q.text("flow_modify {")
				4763	with q.group():
				4764	with q.indent(2):
				4765	q.breakable()
				4766	q.text("xid = ");
				4767	if self.xid != None:
				4768	q.text("%#x" % self.xid)
				4769	else:
				4770	q.text('None')
				4771	q.text(","); q.breakable()
				4772	q.text("cookie = ");
				4773	q.text("%#x" % self.cookie)
				4774	q.text(","); q.breakable()
				4775	q.text("cookie_mask = ");
				4776	q.text("%#x" % self.cookie_mask)
				4777	q.text(","); q.breakable()
				4778	q.text("table_id = ");
				4779	q.text("%#x" % self.table_id)
				4780	q.text(","); q.breakable()
				4781	q.text("idle_timeout = ");
				4782	q.text("%#x" % self.idle_timeout)
				4783	q.text(","); q.breakable()
				4784	q.text("hard_timeout = ");
				4785	q.text("%#x" % self.hard_timeout)
				4786	q.text(","); q.breakable()
				4787	q.text("priority = ");
				4788	q.text("%#x" % self.priority)
				4789	q.text(","); q.breakable()
				4790	q.text("buffer_id = ");
				4791	q.text("%#x" % self.buffer_id)
				4792	q.text(","); q.breakable()
				4793	q.text("out_port = ");
				4794	q.text(util.pretty_port(self.out_port))
				4795	q.text(","); q.breakable()
				4796	q.text("out_group = ");
				4797	q.text("%#x" % self.out_group)
				4798	q.text(","); q.breakable()
				4799	q.text("flags = ");
				4800	q.text("%#x" % self.flags)
				4801	q.text(","); q.breakable()
				4802	q.text("match = ");
				4803	q.pp(self.match)
				4804	q.text(","); q.breakable()
				4805	q.text("instructions = ");
				4806	q.pp(self.instructions)
				4807	q.breakable()
				4808	q.text('}')
				4809
				4810	flow_mod.subtypes[1] = flow_modify
				4811
				4812	class flow_modify_strict(flow_mod):
				4813	version = 3
				4814	type = 14
				4815	_command = 2
				4816
				4817	def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, match=None, instructions=None):
				4818	if xid != None:
				4819	self.xid = xid
				4820	else:
				4821	self.xid = None
				4822	if cookie != None:
				4823	self.cookie = cookie
				4824	else:
				4825	self.cookie = 0
				4826	if cookie_mask != None:
				4827	self.cookie_mask = cookie_mask
				4828	else:
				4829	self.cookie_mask = 0
				4830	if table_id != None:
				4831	self.table_id = table_id
				4832	else:
				4833	self.table_id = 0
				4834	if idle_timeout != None:
				4835	self.idle_timeout = idle_timeout
				4836	else:
				4837	self.idle_timeout = 0
				4838	if hard_timeout != None:
				4839	self.hard_timeout = hard_timeout
				4840	else:
				4841	self.hard_timeout = 0
				4842	if priority != None:
				4843	self.priority = priority
				4844	else:
				4845	self.priority = 0
				4846	if buffer_id != None:
				4847	self.buffer_id = buffer_id
				4848	else:
				4849	self.buffer_id = 0
				4850	if out_port != None:
				4851	self.out_port = out_port
				4852	else:
				4853	self.out_port = 0
				4854	if out_group != None:
				4855	self.out_group = out_group
				4856	else:
				4857	self.out_group = 0
				4858	if flags != None:
				4859	self.flags = flags
				4860	else:
				4861	self.flags = 0
				4862	if match != None:
				4863	self.match = match
				4864	else:
				4865	self.match = ofp.match()
				4866	if instructions != None:
				4867	self.instructions = instructions
				4868	else:
				4869	self.instructions = []
				4870	return
				4871
				4872	def pack(self):
				4873	packed = []
				4874	packed.append(struct.pack("!B", self.version))
				4875	packed.append(struct.pack("!B", self.type))
				4876	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				4877	packed.append(struct.pack("!L", self.xid))
				4878	packed.append(struct.pack("!Q", self.cookie))
				4879	packed.append(struct.pack("!Q", self.cookie_mask))
				4880	packed.append(struct.pack("!B", self.table_id))
				4881	packed.append(util.pack_fm_cmd(self._command))
				4882	packed.append(struct.pack("!H", self.idle_timeout))
				4883	packed.append(struct.pack("!H", self.hard_timeout))
				4884	packed.append(struct.pack("!H", self.priority))
				4885	packed.append(struct.pack("!L", self.buffer_id))
				4886	packed.append(util.pack_port_no(self.out_port))
				4887	packed.append(struct.pack("!L", self.out_group))
				4888	packed.append(struct.pack("!H", self.flags))
				4889	packed.append('\x00' * 2)
				4890	packed.append(self.match.pack())
				4891	packed.append(loxi.generic_util.pack_list(self.instructions))
				4892	length = sum([len(x) for x in packed])
				4893	packed[2] = struct.pack("!H", length)
				4894	return ''.join(packed)
				4895
				4896	@staticmethod
				4897	def unpack(reader):
				4898	obj = flow_modify_strict()
				4899	_version = reader.read("!B")[0]
				4900	assert(_version == 3)
				4901	_type = reader.read("!B")[0]
				4902	assert(_type == 14)
				4903	_length = reader.read("!H")[0]
				4904	orig_reader = reader
				4905	reader = orig_reader.slice(_length, 4)
				4906	obj.xid = reader.read("!L")[0]
				4907	obj.cookie = reader.read("!Q")[0]
				4908	obj.cookie_mask = reader.read("!Q")[0]
				4909	obj.table_id = reader.read("!B")[0]
				4910	__command = util.unpack_fm_cmd(reader)
				4911	assert(__command == 2)
				4912	obj.idle_timeout = reader.read("!H")[0]
				4913	obj.hard_timeout = reader.read("!H")[0]
				4914	obj.priority = reader.read("!H")[0]
				4915	obj.buffer_id = reader.read("!L")[0]
				4916	obj.out_port = util.unpack_port_no(reader)
				4917	obj.out_group = reader.read("!L")[0]
				4918	obj.flags = reader.read("!H")[0]
				4919	reader.skip(2)
				4920	obj.match = ofp.match.unpack(reader)
				4921	obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
				4922	return obj
				4923
				4924	def __eq__(self, other):
				4925	if type(self) != type(other): return False
				4926	if self.xid != other.xid: return False
				4927	if self.cookie != other.cookie: return False
				4928	if self.cookie_mask != other.cookie_mask: return False
				4929	if self.table_id != other.table_id: return False
				4930	if self.idle_timeout != other.idle_timeout: return False
				4931	if self.hard_timeout != other.hard_timeout: return False
				4932	if self.priority != other.priority: return False
				4933	if self.buffer_id != other.buffer_id: return False
				4934	if self.out_port != other.out_port: return False
				4935	if self.out_group != other.out_group: return False
				4936	if self.flags != other.flags: return False
				4937	if self.match != other.match: return False
				4938	if self.instructions != other.instructions: return False
				4939	return True
				4940
				4941	def pretty_print(self, q):
				4942	q.text("flow_modify_strict {")
				4943	with q.group():
				4944	with q.indent(2):
				4945	q.breakable()
				4946	q.text("xid = ");
				4947	if self.xid != None:
				4948	q.text("%#x" % self.xid)
				4949	else:
				4950	q.text('None')
				4951	q.text(","); q.breakable()
				4952	q.text("cookie = ");
				4953	q.text("%#x" % self.cookie)
				4954	q.text(","); q.breakable()
				4955	q.text("cookie_mask = ");
				4956	q.text("%#x" % self.cookie_mask)
				4957	q.text(","); q.breakable()
				4958	q.text("table_id = ");
				4959	q.text("%#x" % self.table_id)
				4960	q.text(","); q.breakable()
				4961	q.text("idle_timeout = ");
				4962	q.text("%#x" % self.idle_timeout)
				4963	q.text(","); q.breakable()
				4964	q.text("hard_timeout = ");
				4965	q.text("%#x" % self.hard_timeout)
				4966	q.text(","); q.breakable()
				4967	q.text("priority = ");
				4968	q.text("%#x" % self.priority)
				4969	q.text(","); q.breakable()
				4970	q.text("buffer_id = ");
				4971	q.text("%#x" % self.buffer_id)
				4972	q.text(","); q.breakable()
				4973	q.text("out_port = ");
				4974	q.text(util.pretty_port(self.out_port))
				4975	q.text(","); q.breakable()
				4976	q.text("out_group = ");
				4977	q.text("%#x" % self.out_group)
				4978	q.text(","); q.breakable()
				4979	q.text("flags = ");
				4980	q.text("%#x" % self.flags)
				4981	q.text(","); q.breakable()
				4982	q.text("match = ");
				4983	q.pp(self.match)
				4984	q.text(","); q.breakable()
				4985	q.text("instructions = ");
				4986	q.pp(self.instructions)
				4987	q.breakable()
				4988	q.text('}')
				4989
				4990	flow_mod.subtypes[2] = flow_modify_strict
				4991
				4992	class flow_removed(message):
				4993	version = 3
				4994	type = 11
				4995
				4996	def __init__(self, xid=None, cookie=None, priority=None, reason=None, table_id=None, duration_sec=None, duration_nsec=None, idle_timeout=None, hard_timeout=None, packet_count=None, byte_count=None, match=None):
				4997	if xid != None:
				4998	self.xid = xid
				4999	else:
				5000	self.xid = None
				5001	if cookie != None:
				5002	self.cookie = cookie
				5003	else:
				5004	self.cookie = 0
				5005	if priority != None:
				5006	self.priority = priority
				5007	else:
				5008	self.priority = 0
				5009	if reason != None:
				5010	self.reason = reason
				5011	else:
				5012	self.reason = 0
				5013	if table_id != None:
				5014	self.table_id = table_id
				5015	else:
				5016	self.table_id = 0
				5017	if duration_sec != None:
				5018	self.duration_sec = duration_sec
				5019	else:
				5020	self.duration_sec = 0
				5021	if duration_nsec != None:
				5022	self.duration_nsec = duration_nsec
				5023	else:
				5024	self.duration_nsec = 0
				5025	if idle_timeout != None:
				5026	self.idle_timeout = idle_timeout
				5027	else:
				5028	self.idle_timeout = 0
				5029	if hard_timeout != None:
				5030	self.hard_timeout = hard_timeout
				5031	else:
				5032	self.hard_timeout = 0
				5033	if packet_count != None:
				5034	self.packet_count = packet_count
				5035	else:
				5036	self.packet_count = 0
				5037	if byte_count != None:
				5038	self.byte_count = byte_count
				5039	else:
				5040	self.byte_count = 0
				5041	if match != None:
				5042	self.match = match
				5043	else:
				5044	self.match = ofp.match()
				5045	return
				5046
				5047	def pack(self):
				5048	packed = []
				5049	packed.append(struct.pack("!B", self.version))
				5050	packed.append(struct.pack("!B", self.type))
				5051	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				5052	packed.append(struct.pack("!L", self.xid))
				5053	packed.append(struct.pack("!Q", self.cookie))
				5054	packed.append(struct.pack("!H", self.priority))
				5055	packed.append(struct.pack("!B", self.reason))
				5056	packed.append(struct.pack("!B", self.table_id))
				5057	packed.append(struct.pack("!L", self.duration_sec))
				5058	packed.append(struct.pack("!L", self.duration_nsec))
				5059	packed.append(struct.pack("!H", self.idle_timeout))
				5060	packed.append(struct.pack("!H", self.hard_timeout))
				5061	packed.append(struct.pack("!Q", self.packet_count))
				5062	packed.append(struct.pack("!Q", self.byte_count))
				5063	packed.append(self.match.pack())
				5064	length = sum([len(x) for x in packed])
				5065	packed[2] = struct.pack("!H", length)
				5066	return ''.join(packed)
				5067
				5068	@staticmethod
				5069	def unpack(reader):
				5070	obj = flow_removed()
				5071	_version = reader.read("!B")[0]
				5072	assert(_version == 3)
				5073	_type = reader.read("!B")[0]
				5074	assert(_type == 11)
				5075	_length = reader.read("!H")[0]
				5076	orig_reader = reader
				5077	reader = orig_reader.slice(_length, 4)
				5078	obj.xid = reader.read("!L")[0]
				5079	obj.cookie = reader.read("!Q")[0]
				5080	obj.priority = reader.read("!H")[0]
				5081	obj.reason = reader.read("!B")[0]
				5082	obj.table_id = reader.read("!B")[0]
				5083	obj.duration_sec = reader.read("!L")[0]
				5084	obj.duration_nsec = reader.read("!L")[0]
				5085	obj.idle_timeout = reader.read("!H")[0]
				5086	obj.hard_timeout = reader.read("!H")[0]
				5087	obj.packet_count = reader.read("!Q")[0]
				5088	obj.byte_count = reader.read("!Q")[0]
				5089	obj.match = ofp.match.unpack(reader)
				5090	return obj
				5091
				5092	def __eq__(self, other):
				5093	if type(self) != type(other): return False
				5094	if self.xid != other.xid: return False
				5095	if self.cookie != other.cookie: return False
				5096	if self.priority != other.priority: return False
				5097	if self.reason != other.reason: return False
				5098	if self.table_id != other.table_id: return False
				5099	if self.duration_sec != other.duration_sec: return False
				5100	if self.duration_nsec != other.duration_nsec: return False
				5101	if self.idle_timeout != other.idle_timeout: return False
				5102	if self.hard_timeout != other.hard_timeout: return False
				5103	if self.packet_count != other.packet_count: return False
				5104	if self.byte_count != other.byte_count: return False
				5105	if self.match != other.match: return False
				5106	return True
				5107
				5108	def pretty_print(self, q):
				5109	q.text("flow_removed {")
				5110	with q.group():
				5111	with q.indent(2):
				5112	q.breakable()
				5113	q.text("xid = ");
				5114	if self.xid != None:
				5115	q.text("%#x" % self.xid)
				5116	else:
				5117	q.text('None')
				5118	q.text(","); q.breakable()
				5119	q.text("cookie = ");
				5120	q.text("%#x" % self.cookie)
				5121	q.text(","); q.breakable()
				5122	q.text("priority = ");
				5123	q.text("%#x" % self.priority)
				5124	q.text(","); q.breakable()
				5125	q.text("reason = ");
				5126	q.text("%#x" % self.reason)
				5127	q.text(","); q.breakable()
				5128	q.text("table_id = ");
				5129	q.text("%#x" % self.table_id)
				5130	q.text(","); q.breakable()
				5131	q.text("duration_sec = ");
				5132	q.text("%#x" % self.duration_sec)
				5133	q.text(","); q.breakable()
				5134	q.text("duration_nsec = ");
				5135	q.text("%#x" % self.duration_nsec)
				5136	q.text(","); q.breakable()
				5137	q.text("idle_timeout = ");
				5138	q.text("%#x" % self.idle_timeout)
				5139	q.text(","); q.breakable()
				5140	q.text("hard_timeout = ");
				5141	q.text("%#x" % self.hard_timeout)
				5142	q.text(","); q.breakable()
				5143	q.text("packet_count = ");
				5144	q.text("%#x" % self.packet_count)
				5145	q.text(","); q.breakable()
				5146	q.text("byte_count = ");
				5147	q.text("%#x" % self.byte_count)
				5148	q.text(","); q.breakable()
				5149	q.text("match = ");
				5150	q.pp(self.match)
				5151	q.breakable()
				5152	q.text('}')
				5153
				5154	message.subtypes[11] = flow_removed
				5155
				5156	class flow_stats_reply(stats_reply):
				5157	version = 3
				5158	type = 19
				5159	stats_type = 1
				5160
				5161	def __init__(self, xid=None, flags=None, entries=None):
				5162	if xid != None:
				5163	self.xid = xid
				5164	else:
				5165	self.xid = None
				5166	if flags != None:
				5167	self.flags = flags
				5168	else:
				5169	self.flags = 0
				5170	if entries != None:
				5171	self.entries = entries
				5172	else:
				5173	self.entries = []
				5174	return
				5175
				5176	def pack(self):
				5177	packed = []
				5178	packed.append(struct.pack("!B", self.version))
				5179	packed.append(struct.pack("!B", self.type))
				5180	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				5181	packed.append(struct.pack("!L", self.xid))
				5182	packed.append(struct.pack("!H", self.stats_type))
				5183	packed.append(struct.pack("!H", self.flags))
				5184	packed.append('\x00' * 4)
				5185	packed.append(loxi.generic_util.pack_list(self.entries))
				5186	length = sum([len(x) for x in packed])
				5187	packed[2] = struct.pack("!H", length)
				5188	return ''.join(packed)
				5189
				5190	@staticmethod
				5191	def unpack(reader):
				5192	obj = flow_stats_reply()
				5193	_version = reader.read("!B")[0]
				5194	assert(_version == 3)
				5195	_type = reader.read("!B")[0]
				5196	assert(_type == 19)
				5197	_length = reader.read("!H")[0]
				5198	orig_reader = reader
				5199	reader = orig_reader.slice(_length, 4)
				5200	obj.xid = reader.read("!L")[0]
				5201	_stats_type = reader.read("!H")[0]
				5202	assert(_stats_type == 1)
				5203	obj.flags = reader.read("!H")[0]
				5204	reader.skip(4)
				5205	obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.flow_stats_entry.unpack)
				5206	return obj
				5207
				5208	def __eq__(self, other):
				5209	if type(self) != type(other): return False
				5210	if self.xid != other.xid: return False
				5211	if self.flags != other.flags: return False
				5212	if self.entries != other.entries: return False
				5213	return True
				5214
				5215	def pretty_print(self, q):
				5216	q.text("flow_stats_reply {")
				5217	with q.group():
				5218	with q.indent(2):
				5219	q.breakable()
				5220	q.text("xid = ");
				5221	if self.xid != None:
				5222	q.text("%#x" % self.xid)
				5223	else:
				5224	q.text('None')
				5225	q.text(","); q.breakable()
				5226	q.text("flags = ");
				5227	q.text("%#x" % self.flags)
				5228	q.text(","); q.breakable()
				5229	q.text("entries = ");
				5230	q.pp(self.entries)
				5231	q.breakable()
				5232	q.text('}')
				5233
				5234	stats_reply.subtypes[1] = flow_stats_reply
				5235
				5236	class flow_stats_request(stats_request):
				5237	version = 3
				5238	type = 18
				5239	stats_type = 1
				5240
				5241	def __init__(self, xid=None, flags=None, table_id=None, out_port=None, out_group=None, cookie=None, cookie_mask=None, match=None):
				5242	if xid != None:
				5243	self.xid = xid
				5244	else:
				5245	self.xid = None
				5246	if flags != None:
				5247	self.flags = flags
				5248	else:
				5249	self.flags = 0
				5250	if table_id != None:
				5251	self.table_id = table_id
				5252	else:
				5253	self.table_id = 0
				5254	if out_port != None:
				5255	self.out_port = out_port
				5256	else:
				5257	self.out_port = 0
				5258	if out_group != None:
				5259	self.out_group = out_group
				5260	else:
				5261	self.out_group = 0
				5262	if cookie != None:
				5263	self.cookie = cookie
				5264	else:
				5265	self.cookie = 0
				5266	if cookie_mask != None:
				5267	self.cookie_mask = cookie_mask
				5268	else:
				5269	self.cookie_mask = 0
				5270	if match != None:
				5271	self.match = match
				5272	else:
				5273	self.match = ofp.match()
				5274	return
				5275
				5276	def pack(self):
				5277	packed = []
				5278	packed.append(struct.pack("!B", self.version))
				5279	packed.append(struct.pack("!B", self.type))
				5280	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				5281	packed.append(struct.pack("!L", self.xid))
				5282	packed.append(struct.pack("!H", self.stats_type))
				5283	packed.append(struct.pack("!H", self.flags))
				5284	packed.append('\x00' * 4)
				5285	packed.append(struct.pack("!B", self.table_id))
				5286	packed.append('\x00' * 3)
				5287	packed.append(util.pack_port_no(self.out_port))
				5288	packed.append(struct.pack("!L", self.out_group))
				5289	packed.append('\x00' * 4)
				5290	packed.append(struct.pack("!Q", self.cookie))
				5291	packed.append(struct.pack("!Q", self.cookie_mask))
				5292	packed.append(self.match.pack())
				5293	length = sum([len(x) for x in packed])
				5294	packed[2] = struct.pack("!H", length)
				5295	return ''.join(packed)
				5296
				5297	@staticmethod
				5298	def unpack(reader):
				5299	obj = flow_stats_request()
				5300	_version = reader.read("!B")[0]
				5301	assert(_version == 3)
				5302	_type = reader.read("!B")[0]
				5303	assert(_type == 18)
				5304	_length = reader.read("!H")[0]
				5305	orig_reader = reader
				5306	reader = orig_reader.slice(_length, 4)
				5307	obj.xid = reader.read("!L")[0]
				5308	_stats_type = reader.read("!H")[0]
				5309	assert(_stats_type == 1)
				5310	obj.flags = reader.read("!H")[0]
				5311	reader.skip(4)
				5312	obj.table_id = reader.read("!B")[0]
				5313	reader.skip(3)
				5314	obj.out_port = util.unpack_port_no(reader)
				5315	obj.out_group = reader.read("!L")[0]
				5316	reader.skip(4)
				5317	obj.cookie = reader.read("!Q")[0]
				5318	obj.cookie_mask = reader.read("!Q")[0]
				5319	obj.match = ofp.match.unpack(reader)
				5320	return obj
				5321
				5322	def __eq__(self, other):
				5323	if type(self) != type(other): return False
				5324	if self.xid != other.xid: return False
				5325	if self.flags != other.flags: return False
				5326	if self.table_id != other.table_id: return False
				5327	if self.out_port != other.out_port: return False
				5328	if self.out_group != other.out_group: return False
				5329	if self.cookie != other.cookie: return False
				5330	if self.cookie_mask != other.cookie_mask: return False
				5331	if self.match != other.match: return False
				5332	return True
				5333
				5334	def pretty_print(self, q):
				5335	q.text("flow_stats_request {")
				5336	with q.group():
				5337	with q.indent(2):
				5338	q.breakable()
				5339	q.text("xid = ");
				5340	if self.xid != None:
				5341	q.text("%#x" % self.xid)
				5342	else:
				5343	q.text('None')
				5344	q.text(","); q.breakable()
				5345	q.text("flags = ");
				5346	q.text("%#x" % self.flags)
				5347	q.text(","); q.breakable()
				5348	q.text("table_id = ");
				5349	q.text("%#x" % self.table_id)
				5350	q.text(","); q.breakable()
				5351	q.text("out_port = ");
				5352	q.text(util.pretty_port(self.out_port))
				5353	q.text(","); q.breakable()
				5354	q.text("out_group = ");
				5355	q.text("%#x" % self.out_group)
				5356	q.text(","); q.breakable()
				5357	q.text("cookie = ");
				5358	q.text("%#x" % self.cookie)
				5359	q.text(","); q.breakable()
				5360	q.text("cookie_mask = ");
				5361	q.text("%#x" % self.cookie_mask)
				5362	q.text(","); q.breakable()
				5363	q.text("match = ");
				5364	q.pp(self.match)
				5365	q.breakable()
				5366	q.text('}')
				5367
				5368	stats_request.subtypes[1] = flow_stats_request
				5369
				5370	class get_config_reply(message):
				5371	version = 3
				5372	type = 8
				5373
				5374	def __init__(self, xid=None, flags=None, miss_send_len=None):
				5375	if xid != None:
				5376	self.xid = xid
				5377	else:
				5378	self.xid = None
				5379	if flags != None:
				5380	self.flags = flags
				5381	else:
				5382	self.flags = 0
				5383	if miss_send_len != None:
				5384	self.miss_send_len = miss_send_len
				5385	else:
				5386	self.miss_send_len = 0
				5387	return
				5388
				5389	def pack(self):
				5390	packed = []
				5391	packed.append(struct.pack("!B", self.version))
				5392	packed.append(struct.pack("!B", self.type))
				5393	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				5394	packed.append(struct.pack("!L", self.xid))
				5395	packed.append(struct.pack("!H", self.flags))
				5396	packed.append(struct.pack("!H", self.miss_send_len))
				5397	length = sum([len(x) for x in packed])
				5398	packed[2] = struct.pack("!H", length)
				5399	return ''.join(packed)
				5400
				5401	@staticmethod
				5402	def unpack(reader):
				5403	obj = get_config_reply()
				5404	_version = reader.read("!B")[0]
				5405	assert(_version == 3)
				5406	_type = reader.read("!B")[0]
				5407	assert(_type == 8)
				5408	_length = reader.read("!H")[0]
				5409	orig_reader = reader
				5410	reader = orig_reader.slice(_length, 4)
				5411	obj.xid = reader.read("!L")[0]
				5412	obj.flags = reader.read("!H")[0]
				5413	obj.miss_send_len = reader.read("!H")[0]
				5414	return obj
				5415
				5416	def __eq__(self, other):
				5417	if type(self) != type(other): return False
				5418	if self.xid != other.xid: return False
				5419	if self.flags != other.flags: return False
				5420	if self.miss_send_len != other.miss_send_len: return False
				5421	return True
				5422
				5423	def pretty_print(self, q):
				5424	q.text("get_config_reply {")
				5425	with q.group():
				5426	with q.indent(2):
				5427	q.breakable()
				5428	q.text("xid = ");
				5429	if self.xid != None:
				5430	q.text("%#x" % self.xid)
				5431	else:
				5432	q.text('None')
				5433	q.text(","); q.breakable()
				5434	q.text("flags = ");
				5435	q.text("%#x" % self.flags)
				5436	q.text(","); q.breakable()
				5437	q.text("miss_send_len = ");
				5438	q.text("%#x" % self.miss_send_len)
				5439	q.breakable()
				5440	q.text('}')
				5441
				5442	message.subtypes[8] = get_config_reply
				5443
				5444	class get_config_request(message):
				5445	version = 3
				5446	type = 7
				5447
				5448	def __init__(self, xid=None):
				5449	if xid != None:
				5450	self.xid = xid
				5451	else:
				5452	self.xid = None
				5453	return
				5454
				5455	def pack(self):
				5456	packed = []
				5457	packed.append(struct.pack("!B", self.version))
				5458	packed.append(struct.pack("!B", self.type))
				5459	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				5460	packed.append(struct.pack("!L", self.xid))
				5461	length = sum([len(x) for x in packed])
				5462	packed[2] = struct.pack("!H", length)
				5463	return ''.join(packed)
				5464
				5465	@staticmethod
				5466	def unpack(reader):
				5467	obj = get_config_request()
				5468	_version = reader.read("!B")[0]
				5469	assert(_version == 3)
				5470	_type = reader.read("!B")[0]
				5471	assert(_type == 7)
				5472	_length = reader.read("!H")[0]
				5473	orig_reader = reader
				5474	reader = orig_reader.slice(_length, 4)
				5475	obj.xid = reader.read("!L")[0]
				5476	return obj
				5477
				5478	def __eq__(self, other):
				5479	if type(self) != type(other): return False
				5480	if self.xid != other.xid: return False
				5481	return True
				5482
				5483	def pretty_print(self, q):
				5484	q.text("get_config_request {")
				5485	with q.group():
				5486	with q.indent(2):
				5487	q.breakable()
				5488	q.text("xid = ");
				5489	if self.xid != None:
				5490	q.text("%#x" % self.xid)
				5491	else:
				5492	q.text('None')
				5493	q.breakable()
				5494	q.text('}')
				5495
				5496	message.subtypes[7] = get_config_request
				5497
				5498	class group_mod(message):
				5499	subtypes = {}
				5500
				5501	version = 3
				5502	type = 15
				5503
				5504	def __init__(self, xid=None, command=None, group_type=None, group_id=None, buckets=None):
				5505	if xid != None:
				5506	self.xid = xid
				5507	else:
				5508	self.xid = None
				5509	if command != None:
				5510	self.command = command
				5511	else:
				5512	self.command = 0
				5513	if group_type != None:
				5514	self.group_type = group_type
				5515	else:
				5516	self.group_type = 0
				5517	if group_id != None:
				5518	self.group_id = group_id
				5519	else:
				5520	self.group_id = 0
				5521	if buckets != None:
				5522	self.buckets = buckets
				5523	else:
				5524	self.buckets = []
				5525	return
				5526
				5527	def pack(self):
				5528	packed = []
				5529	packed.append(struct.pack("!B", self.version))
				5530	packed.append(struct.pack("!B", self.type))
				5531	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				5532	packed.append(struct.pack("!L", self.xid))
				5533	packed.append(struct.pack("!H", self.command))
				5534	packed.append(struct.pack("!B", self.group_type))
				5535	packed.append('\x00' * 1)
				5536	packed.append(struct.pack("!L", self.group_id))
				5537	packed.append(loxi.generic_util.pack_list(self.buckets))
				5538	length = sum([len(x) for x in packed])
				5539	packed[2] = struct.pack("!H", length)
				5540	return ''.join(packed)
				5541
				5542	@staticmethod
				5543	def unpack(reader):
				5544	subtype, = reader.peek('!H', 8)
				5545	subclass = group_mod.subtypes.get(subtype)
				5546	if subclass:
				5547	return subclass.unpack(reader)
				5548
				5549	obj = group_mod()
				5550	_version = reader.read("!B")[0]
				5551	assert(_version == 3)
				5552	_type = reader.read("!B")[0]
				5553	assert(_type == 15)
				5554	_length = reader.read("!H")[0]
				5555	orig_reader = reader
				5556	reader = orig_reader.slice(_length, 4)
				5557	obj.xid = reader.read("!L")[0]
				5558	obj.command = reader.read("!H")[0]
				5559	obj.group_type = reader.read("!B")[0]
				5560	reader.skip(1)
				5561	obj.group_id = reader.read("!L")[0]
				5562	obj.buckets = loxi.generic_util.unpack_list(reader, ofp.common.bucket.unpack)
				5563	return obj
				5564
				5565	def __eq__(self, other):
				5566	if type(self) != type(other): return False
				5567	if self.xid != other.xid: return False
				5568	if self.command != other.command: return False
				5569	if self.group_type != other.group_type: return False
				5570	if self.group_id != other.group_id: return False
				5571	if self.buckets != other.buckets: return False
				5572	return True
				5573
				5574	def pretty_print(self, q):
				5575	q.text("group_mod {")
				5576	with q.group():
				5577	with q.indent(2):
				5578	q.breakable()
				5579	q.text("xid = ");
				5580	if self.xid != None:
				5581	q.text("%#x" % self.xid)
				5582	else:
				5583	q.text('None')
				5584	q.text(","); q.breakable()
				5585	q.text("group_type = ");
				5586	q.text("%#x" % self.group_type)
				5587	q.text(","); q.breakable()
				5588	q.text("group_id = ");
				5589	q.text("%#x" % self.group_id)
				5590	q.text(","); q.breakable()
				5591	q.text("buckets = ");
				5592	q.pp(self.buckets)
				5593	q.breakable()
				5594	q.text('}')
				5595
				5596	message.subtypes[15] = group_mod
				5597
				5598	class group_add(group_mod):
				5599	version = 3
				5600	type = 15
				5601	command = 0
				5602
				5603	def __init__(self, xid=None, group_type=None, group_id=None, buckets=None):
				5604	if xid != None:
				5605	self.xid = xid
				5606	else:
				5607	self.xid = None
				5608	if group_type != None:
				5609	self.group_type = group_type
				5610	else:
				5611	self.group_type = 0
				5612	if group_id != None:
				5613	self.group_id = group_id
				5614	else:
				5615	self.group_id = 0
				5616	if buckets != None:
				5617	self.buckets = buckets
				5618	else:
				5619	self.buckets = []
				5620	return
				5621
				5622	def pack(self):
				5623	packed = []
				5624	packed.append(struct.pack("!B", self.version))
				5625	packed.append(struct.pack("!B", self.type))
				5626	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				5627	packed.append(struct.pack("!L", self.xid))
				5628	packed.append(struct.pack("!H", self.command))
				5629	packed.append(struct.pack("!B", self.group_type))
				5630	packed.append('\x00' * 1)
				5631	packed.append(struct.pack("!L", self.group_id))
				5632	packed.append(loxi.generic_util.pack_list(self.buckets))
				5633	length = sum([len(x) for x in packed])
				5634	packed[2] = struct.pack("!H", length)
				5635	return ''.join(packed)
				5636
				5637	@staticmethod
				5638	def unpack(reader):
				5639	obj = group_add()
				5640	_version = reader.read("!B")[0]
				5641	assert(_version == 3)
				5642	_type = reader.read("!B")[0]
				5643	assert(_type == 15)
				5644	_length = reader.read("!H")[0]
				5645	orig_reader = reader
				5646	reader = orig_reader.slice(_length, 4)
				5647	obj.xid = reader.read("!L")[0]
				5648	_command = reader.read("!H")[0]
				5649	assert(_command == 0)
				5650	obj.group_type = reader.read("!B")[0]
				5651	reader.skip(1)
				5652	obj.group_id = reader.read("!L")[0]
				5653	obj.buckets = loxi.generic_util.unpack_list(reader, ofp.common.bucket.unpack)
				5654	return obj
				5655
				5656	def __eq__(self, other):
				5657	if type(self) != type(other): return False
				5658	if self.xid != other.xid: return False
				5659	if self.group_type != other.group_type: return False
				5660	if self.group_id != other.group_id: return False
				5661	if self.buckets != other.buckets: return False
				5662	return True
				5663
				5664	def pretty_print(self, q):
				5665	q.text("group_add {")
				5666	with q.group():
				5667	with q.indent(2):
				5668	q.breakable()
				5669	q.text("xid = ");
				5670	if self.xid != None:
				5671	q.text("%#x" % self.xid)
				5672	else:
				5673	q.text('None')
				5674	q.text(","); q.breakable()
				5675	q.text("group_type = ");
				5676	q.text("%#x" % self.group_type)
				5677	q.text(","); q.breakable()
				5678	q.text("group_id = ");
				5679	q.text("%#x" % self.group_id)
				5680	q.text(","); q.breakable()
				5681	q.text("buckets = ");
				5682	q.pp(self.buckets)
				5683	q.breakable()
				5684	q.text('}')
				5685
				5686	group_mod.subtypes[0] = group_add
				5687
				5688	class group_delete(group_mod):
				5689	version = 3
				5690	type = 15
				5691	command = 2
				5692
				5693	def __init__(self, xid=None, group_type=None, group_id=None, buckets=None):
				5694	if xid != None:
				5695	self.xid = xid
				5696	else:
				5697	self.xid = None
				5698	if group_type != None:
				5699	self.group_type = group_type
				5700	else:
				5701	self.group_type = 0
				5702	if group_id != None:
				5703	self.group_id = group_id
				5704	else:
				5705	self.group_id = 0
				5706	if buckets != None:
				5707	self.buckets = buckets
				5708	else:
				5709	self.buckets = []
				5710	return
				5711
				5712	def pack(self):
				5713	packed = []
				5714	packed.append(struct.pack("!B", self.version))
				5715	packed.append(struct.pack("!B", self.type))
				5716	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				5717	packed.append(struct.pack("!L", self.xid))
				5718	packed.append(struct.pack("!H", self.command))
				5719	packed.append(struct.pack("!B", self.group_type))
				5720	packed.append('\x00' * 1)
				5721	packed.append(struct.pack("!L", self.group_id))
				5722	packed.append(loxi.generic_util.pack_list(self.buckets))
				5723	length = sum([len(x) for x in packed])
				5724	packed[2] = struct.pack("!H", length)
				5725	return ''.join(packed)
				5726
				5727	@staticmethod
				5728	def unpack(reader):
				5729	obj = group_delete()
				5730	_version = reader.read("!B")[0]
				5731	assert(_version == 3)
				5732	_type = reader.read("!B")[0]
				5733	assert(_type == 15)
				5734	_length = reader.read("!H")[0]
				5735	orig_reader = reader
				5736	reader = orig_reader.slice(_length, 4)
				5737	obj.xid = reader.read("!L")[0]
				5738	_command = reader.read("!H")[0]
				5739	assert(_command == 2)
				5740	obj.group_type = reader.read("!B")[0]
				5741	reader.skip(1)
				5742	obj.group_id = reader.read("!L")[0]
				5743	obj.buckets = loxi.generic_util.unpack_list(reader, ofp.common.bucket.unpack)
				5744	return obj
				5745
				5746	def __eq__(self, other):
				5747	if type(self) != type(other): return False
				5748	if self.xid != other.xid: return False
				5749	if self.group_type != other.group_type: return False
				5750	if self.group_id != other.group_id: return False
				5751	if self.buckets != other.buckets: return False
				5752	return True
				5753
				5754	def pretty_print(self, q):
				5755	q.text("group_delete {")
				5756	with q.group():
				5757	with q.indent(2):
				5758	q.breakable()
				5759	q.text("xid = ");
				5760	if self.xid != None:
				5761	q.text("%#x" % self.xid)
				5762	else:
				5763	q.text('None')
				5764	q.text(","); q.breakable()
				5765	q.text("group_type = ");
				5766	q.text("%#x" % self.group_type)
				5767	q.text(","); q.breakable()
				5768	q.text("group_id = ");
				5769	q.text("%#x" % self.group_id)
				5770	q.text(","); q.breakable()
				5771	q.text("buckets = ");
				5772	q.pp(self.buckets)
				5773	q.breakable()
				5774	q.text('}')
				5775
				5776	group_mod.subtypes[2] = group_delete
				5777
				5778	class group_desc_stats_reply(stats_reply):
				5779	version = 3
				5780	type = 19
				5781	stats_type = 7
				5782
				5783	def __init__(self, xid=None, flags=None, entries=None):
				5784	if xid != None:
				5785	self.xid = xid
				5786	else:
				5787	self.xid = None
				5788	if flags != None:
				5789	self.flags = flags
				5790	else:
				5791	self.flags = 0
				5792	if entries != None:
				5793	self.entries = entries
				5794	else:
				5795	self.entries = []
				5796	return
				5797
				5798	def pack(self):
				5799	packed = []
				5800	packed.append(struct.pack("!B", self.version))
				5801	packed.append(struct.pack("!B", self.type))
				5802	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				5803	packed.append(struct.pack("!L", self.xid))
				5804	packed.append(struct.pack("!H", self.stats_type))
				5805	packed.append(struct.pack("!H", self.flags))
				5806	packed.append('\x00' * 4)
				5807	packed.append(loxi.generic_util.pack_list(self.entries))
				5808	length = sum([len(x) for x in packed])
				5809	packed[2] = struct.pack("!H", length)
				5810	return ''.join(packed)
				5811
				5812	@staticmethod
				5813	def unpack(reader):
				5814	obj = group_desc_stats_reply()
				5815	_version = reader.read("!B")[0]
				5816	assert(_version == 3)
				5817	_type = reader.read("!B")[0]
				5818	assert(_type == 19)
				5819	_length = reader.read("!H")[0]
				5820	orig_reader = reader
				5821	reader = orig_reader.slice(_length, 4)
				5822	obj.xid = reader.read("!L")[0]
				5823	_stats_type = reader.read("!H")[0]
				5824	assert(_stats_type == 7)
				5825	obj.flags = reader.read("!H")[0]
				5826	reader.skip(4)
				5827	obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.group_desc_stats_entry.unpack)
				5828	return obj
				5829
				5830	def __eq__(self, other):
				5831	if type(self) != type(other): return False
				5832	if self.xid != other.xid: return False
				5833	if self.flags != other.flags: return False
				5834	if self.entries != other.entries: return False
				5835	return True
				5836
				5837	def pretty_print(self, q):
				5838	q.text("group_desc_stats_reply {")
				5839	with q.group():
				5840	with q.indent(2):
				5841	q.breakable()
				5842	q.text("xid = ");
				5843	if self.xid != None:
				5844	q.text("%#x" % self.xid)
				5845	else:
				5846	q.text('None')
				5847	q.text(","); q.breakable()
				5848	q.text("flags = ");
				5849	q.text("%#x" % self.flags)
				5850	q.text(","); q.breakable()
				5851	q.text("entries = ");
				5852	q.pp(self.entries)
				5853	q.breakable()
				5854	q.text('}')
				5855
				5856	stats_reply.subtypes[7] = group_desc_stats_reply
				5857
				5858	class group_desc_stats_request(stats_request):
				5859	version = 3
				5860	type = 18
				5861	stats_type = 7
				5862
				5863	def __init__(self, xid=None, flags=None):
				5864	if xid != None:
				5865	self.xid = xid
				5866	else:
				5867	self.xid = None
				5868	if flags != None:
				5869	self.flags = flags
				5870	else:
				5871	self.flags = 0
				5872	return
				5873
				5874	def pack(self):
				5875	packed = []
				5876	packed.append(struct.pack("!B", self.version))
				5877	packed.append(struct.pack("!B", self.type))
				5878	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				5879	packed.append(struct.pack("!L", self.xid))
				5880	packed.append(struct.pack("!H", self.stats_type))
				5881	packed.append(struct.pack("!H", self.flags))
				5882	packed.append('\x00' * 4)
				5883	length = sum([len(x) for x in packed])
				5884	packed[2] = struct.pack("!H", length)
				5885	return ''.join(packed)
				5886
				5887	@staticmethod
				5888	def unpack(reader):
				5889	obj = group_desc_stats_request()
				5890	_version = reader.read("!B")[0]
				5891	assert(_version == 3)
				5892	_type = reader.read("!B")[0]
				5893	assert(_type == 18)
				5894	_length = reader.read("!H")[0]
				5895	orig_reader = reader
				5896	reader = orig_reader.slice(_length, 4)
				5897	obj.xid = reader.read("!L")[0]
				5898	_stats_type = reader.read("!H")[0]
				5899	assert(_stats_type == 7)
				5900	obj.flags = reader.read("!H")[0]
				5901	reader.skip(4)
				5902	return obj
				5903
				5904	def __eq__(self, other):
				5905	if type(self) != type(other): return False
				5906	if self.xid != other.xid: return False
				5907	if self.flags != other.flags: return False
				5908	return True
				5909
				5910	def pretty_print(self, q):
				5911	q.text("group_desc_stats_request {")
				5912	with q.group():
				5913	with q.indent(2):
				5914	q.breakable()
				5915	q.text("xid = ");
				5916	if self.xid != None:
				5917	q.text("%#x" % self.xid)
				5918	else:
				5919	q.text('None')
				5920	q.text(","); q.breakable()
				5921	q.text("flags = ");
				5922	q.text("%#x" % self.flags)
				5923	q.breakable()
				5924	q.text('}')
				5925
				5926	stats_request.subtypes[7] = group_desc_stats_request
				5927
				5928	class group_features_stats_reply(stats_reply):
				5929	version = 3
				5930	type = 19
				5931	stats_type = 8
				5932
				5933	def __init__(self, xid=None, flags=None, types=None, capabilities=None, max_groups_all=None, max_groups_select=None, max_groups_indirect=None, max_groups_ff=None, actions_all=None, actions_select=None, actions_indirect=None, actions_ff=None):
				5934	if xid != None:
				5935	self.xid = xid
				5936	else:
				5937	self.xid = None
				5938	if flags != None:
				5939	self.flags = flags
				5940	else:
				5941	self.flags = 0
				5942	if types != None:
				5943	self.types = types
				5944	else:
				5945	self.types = 0
				5946	if capabilities != None:
				5947	self.capabilities = capabilities
				5948	else:
				5949	self.capabilities = 0
				5950	if max_groups_all != None:
				5951	self.max_groups_all = max_groups_all
				5952	else:
				5953	self.max_groups_all = 0
				5954	if max_groups_select != None:
				5955	self.max_groups_select = max_groups_select
				5956	else:
				5957	self.max_groups_select = 0
				5958	if max_groups_indirect != None:
				5959	self.max_groups_indirect = max_groups_indirect
				5960	else:
				5961	self.max_groups_indirect = 0
				5962	if max_groups_ff != None:
				5963	self.max_groups_ff = max_groups_ff
				5964	else:
				5965	self.max_groups_ff = 0
				5966	if actions_all != None:
				5967	self.actions_all = actions_all
				5968	else:
				5969	self.actions_all = 0
				5970	if actions_select != None:
				5971	self.actions_select = actions_select
				5972	else:
				5973	self.actions_select = 0
				5974	if actions_indirect != None:
				5975	self.actions_indirect = actions_indirect
				5976	else:
				5977	self.actions_indirect = 0
				5978	if actions_ff != None:
				5979	self.actions_ff = actions_ff
				5980	else:
				5981	self.actions_ff = 0
				5982	return
				5983
				5984	def pack(self):
				5985	packed = []
				5986	packed.append(struct.pack("!B", self.version))
				5987	packed.append(struct.pack("!B", self.type))
				5988	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				5989	packed.append(struct.pack("!L", self.xid))
				5990	packed.append(struct.pack("!H", self.stats_type))
				5991	packed.append(struct.pack("!H", self.flags))
				5992	packed.append('\x00' * 4)
				5993	packed.append(struct.pack("!L", self.types))
				5994	packed.append(struct.pack("!L", self.capabilities))
				5995	packed.append(struct.pack("!L", self.max_groups_all))
				5996	packed.append(struct.pack("!L", self.max_groups_select))
				5997	packed.append(struct.pack("!L", self.max_groups_indirect))
				5998	packed.append(struct.pack("!L", self.max_groups_ff))
				5999	packed.append(struct.pack("!L", self.actions_all))
				6000	packed.append(struct.pack("!L", self.actions_select))
				6001	packed.append(struct.pack("!L", self.actions_indirect))
				6002	packed.append(struct.pack("!L", self.actions_ff))
				6003	length = sum([len(x) for x in packed])
				6004	packed[2] = struct.pack("!H", length)
				6005	return ''.join(packed)
				6006
				6007	@staticmethod
				6008	def unpack(reader):
				6009	obj = group_features_stats_reply()
				6010	_version = reader.read("!B")[0]
				6011	assert(_version == 3)
				6012	_type = reader.read("!B")[0]
				6013	assert(_type == 19)
				6014	_length = reader.read("!H")[0]
				6015	orig_reader = reader
				6016	reader = orig_reader.slice(_length, 4)
				6017	obj.xid = reader.read("!L")[0]
				6018	_stats_type = reader.read("!H")[0]
				6019	assert(_stats_type == 8)
				6020	obj.flags = reader.read("!H")[0]
				6021	reader.skip(4)
				6022	obj.types = reader.read("!L")[0]
				6023	obj.capabilities = reader.read("!L")[0]
				6024	obj.max_groups_all = reader.read("!L")[0]
				6025	obj.max_groups_select = reader.read("!L")[0]
				6026	obj.max_groups_indirect = reader.read("!L")[0]
				6027	obj.max_groups_ff = reader.read("!L")[0]
				6028	obj.actions_all = reader.read("!L")[0]
				6029	obj.actions_select = reader.read("!L")[0]
				6030	obj.actions_indirect = reader.read("!L")[0]
				6031	obj.actions_ff = reader.read("!L")[0]
				6032	return obj
				6033
				6034	def __eq__(self, other):
				6035	if type(self) != type(other): return False
				6036	if self.xid != other.xid: return False
				6037	if self.flags != other.flags: return False
				6038	if self.types != other.types: return False
				6039	if self.capabilities != other.capabilities: return False
				6040	if self.max_groups_all != other.max_groups_all: return False
				6041	if self.max_groups_select != other.max_groups_select: return False
				6042	if self.max_groups_indirect != other.max_groups_indirect: return False
				6043	if self.max_groups_ff != other.max_groups_ff: return False
				6044	if self.actions_all != other.actions_all: return False
				6045	if self.actions_select != other.actions_select: return False
				6046	if self.actions_indirect != other.actions_indirect: return False
				6047	if self.actions_ff != other.actions_ff: return False
				6048	return True
				6049
				6050	def pretty_print(self, q):
				6051	q.text("group_features_stats_reply {")
				6052	with q.group():
				6053	with q.indent(2):
				6054	q.breakable()
				6055	q.text("xid = ");
				6056	if self.xid != None:
				6057	q.text("%#x" % self.xid)
				6058	else:
				6059	q.text('None')
				6060	q.text(","); q.breakable()
				6061	q.text("flags = ");
				6062	q.text("%#x" % self.flags)
				6063	q.text(","); q.breakable()
				6064	q.text("types = ");
				6065	q.text("%#x" % self.types)
				6066	q.text(","); q.breakable()
				6067	q.text("capabilities = ");
				6068	q.text("%#x" % self.capabilities)
				6069	q.text(","); q.breakable()
				6070	q.text("max_groups_all = ");
				6071	q.text("%#x" % self.max_groups_all)
				6072	q.text(","); q.breakable()
				6073	q.text("max_groups_select = ");
				6074	q.text("%#x" % self.max_groups_select)
				6075	q.text(","); q.breakable()
				6076	q.text("max_groups_indirect = ");
				6077	q.text("%#x" % self.max_groups_indirect)
				6078	q.text(","); q.breakable()
				6079	q.text("max_groups_ff = ");
				6080	q.text("%#x" % self.max_groups_ff)
				6081	q.text(","); q.breakable()
				6082	q.text("actions_all = ");
				6083	q.text("%#x" % self.actions_all)
				6084	q.text(","); q.breakable()
				6085	q.text("actions_select = ");
				6086	q.text("%#x" % self.actions_select)
				6087	q.text(","); q.breakable()
				6088	q.text("actions_indirect = ");
				6089	q.text("%#x" % self.actions_indirect)
				6090	q.text(","); q.breakable()
				6091	q.text("actions_ff = ");
				6092	q.text("%#x" % self.actions_ff)
				6093	q.breakable()
				6094	q.text('}')
				6095
				6096	stats_reply.subtypes[8] = group_features_stats_reply
				6097
				6098	class group_features_stats_request(stats_request):
				6099	version = 3
				6100	type = 18
				6101	stats_type = 8
				6102
				6103	def __init__(self, xid=None, flags=None):
				6104	if xid != None:
				6105	self.xid = xid
				6106	else:
				6107	self.xid = None
				6108	if flags != None:
				6109	self.flags = flags
				6110	else:
				6111	self.flags = 0
				6112	return
				6113
				6114	def pack(self):
				6115	packed = []
				6116	packed.append(struct.pack("!B", self.version))
				6117	packed.append(struct.pack("!B", self.type))
				6118	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				6119	packed.append(struct.pack("!L", self.xid))
				6120	packed.append(struct.pack("!H", self.stats_type))
				6121	packed.append(struct.pack("!H", self.flags))
				6122	packed.append('\x00' * 4)
				6123	length = sum([len(x) for x in packed])
				6124	packed[2] = struct.pack("!H", length)
				6125	return ''.join(packed)
				6126
				6127	@staticmethod
				6128	def unpack(reader):
				6129	obj = group_features_stats_request()
				6130	_version = reader.read("!B")[0]
				6131	assert(_version == 3)
				6132	_type = reader.read("!B")[0]
				6133	assert(_type == 18)
				6134	_length = reader.read("!H")[0]
				6135	orig_reader = reader
				6136	reader = orig_reader.slice(_length, 4)
				6137	obj.xid = reader.read("!L")[0]
				6138	_stats_type = reader.read("!H")[0]
				6139	assert(_stats_type == 8)
				6140	obj.flags = reader.read("!H")[0]
				6141	reader.skip(4)
				6142	return obj
				6143
				6144	def __eq__(self, other):
				6145	if type(self) != type(other): return False
				6146	if self.xid != other.xid: return False
				6147	if self.flags != other.flags: return False
				6148	return True
				6149
				6150	def pretty_print(self, q):
				6151	q.text("group_features_stats_request {")
				6152	with q.group():
				6153	with q.indent(2):
				6154	q.breakable()
				6155	q.text("xid = ");
				6156	if self.xid != None:
				6157	q.text("%#x" % self.xid)
				6158	else:
				6159	q.text('None')
				6160	q.text(","); q.breakable()
				6161	q.text("flags = ");
				6162	q.text("%#x" % self.flags)
				6163	q.breakable()
				6164	q.text('}')
				6165
				6166	stats_request.subtypes[8] = group_features_stats_request
				6167
				6168	class group_mod_failed_error_msg(error_msg):
				6169	version = 3
				6170	type = 1
				6171	err_type = 6
				6172
				6173	def __init__(self, xid=None, code=None, data=None):
				6174	if xid != None:
				6175	self.xid = xid
				6176	else:
				6177	self.xid = None
				6178	if code != None:
				6179	self.code = code
				6180	else:
				6181	self.code = 0
				6182	if data != None:
				6183	self.data = data
				6184	else:
				6185	self.data = ''
				6186	return
				6187
				6188	def pack(self):
				6189	packed = []
				6190	packed.append(struct.pack("!B", self.version))
				6191	packed.append(struct.pack("!B", self.type))
				6192	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				6193	packed.append(struct.pack("!L", self.xid))
				6194	packed.append(struct.pack("!H", self.err_type))
				6195	packed.append(struct.pack("!H", self.code))
				6196	packed.append(self.data)
				6197	length = sum([len(x) for x in packed])
				6198	packed[2] = struct.pack("!H", length)
				6199	return ''.join(packed)
				6200
				6201	@staticmethod
				6202	def unpack(reader):
				6203	obj = group_mod_failed_error_msg()
				6204	_version = reader.read("!B")[0]
				6205	assert(_version == 3)
				6206	_type = reader.read("!B")[0]
				6207	assert(_type == 1)
				6208	_length = reader.read("!H")[0]
				6209	orig_reader = reader
				6210	reader = orig_reader.slice(_length, 4)
				6211	obj.xid = reader.read("!L")[0]
				6212	_err_type = reader.read("!H")[0]
				6213	assert(_err_type == 6)
				6214	obj.code = reader.read("!H")[0]
				6215	obj.data = str(reader.read_all())
				6216	return obj
				6217
				6218	def __eq__(self, other):
				6219	if type(self) != type(other): return False
				6220	if self.xid != other.xid: return False
				6221	if self.code != other.code: return False
				6222	if self.data != other.data: return False
				6223	return True
				6224
				6225	def pretty_print(self, q):
				6226	q.text("group_mod_failed_error_msg {")
				6227	with q.group():
				6228	with q.indent(2):
				6229	q.breakable()
				6230	q.text("xid = ");
				6231	if self.xid != None:
				6232	q.text("%#x" % self.xid)
				6233	else:
				6234	q.text('None')
				6235	q.text(","); q.breakable()
				6236	q.text("code = ");
				6237	q.text("%#x" % self.code)
				6238	q.text(","); q.breakable()
				6239	q.text("data = ");
				6240	q.pp(self.data)
				6241	q.breakable()
				6242	q.text('}')
				6243
				6244	error_msg.subtypes[6] = group_mod_failed_error_msg
				6245
				6246	class group_modify(group_mod):
				6247	version = 3
				6248	type = 15
				6249	command = 1
				6250
				6251	def __init__(self, xid=None, group_type=None, group_id=None, buckets=None):
				6252	if xid != None:
				6253	self.xid = xid
				6254	else:
				6255	self.xid = None
				6256	if group_type != None:
				6257	self.group_type = group_type
				6258	else:
				6259	self.group_type = 0
				6260	if group_id != None:
				6261	self.group_id = group_id
				6262	else:
				6263	self.group_id = 0
				6264	if buckets != None:
				6265	self.buckets = buckets
				6266	else:
				6267	self.buckets = []
				6268	return
				6269
				6270	def pack(self):
				6271	packed = []
				6272	packed.append(struct.pack("!B", self.version))
				6273	packed.append(struct.pack("!B", self.type))
				6274	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				6275	packed.append(struct.pack("!L", self.xid))
				6276	packed.append(struct.pack("!H", self.command))
				6277	packed.append(struct.pack("!B", self.group_type))
				6278	packed.append('\x00' * 1)
				6279	packed.append(struct.pack("!L", self.group_id))
				6280	packed.append(loxi.generic_util.pack_list(self.buckets))
				6281	length = sum([len(x) for x in packed])
				6282	packed[2] = struct.pack("!H", length)
				6283	return ''.join(packed)
				6284
				6285	@staticmethod
				6286	def unpack(reader):
				6287	obj = group_modify()
				6288	_version = reader.read("!B")[0]
				6289	assert(_version == 3)
				6290	_type = reader.read("!B")[0]
				6291	assert(_type == 15)
				6292	_length = reader.read("!H")[0]
				6293	orig_reader = reader
				6294	reader = orig_reader.slice(_length, 4)
				6295	obj.xid = reader.read("!L")[0]
				6296	_command = reader.read("!H")[0]
				6297	assert(_command == 1)
				6298	obj.group_type = reader.read("!B")[0]
				6299	reader.skip(1)
				6300	obj.group_id = reader.read("!L")[0]
				6301	obj.buckets = loxi.generic_util.unpack_list(reader, ofp.common.bucket.unpack)
				6302	return obj
				6303
				6304	def __eq__(self, other):
				6305	if type(self) != type(other): return False
				6306	if self.xid != other.xid: return False
				6307	if self.group_type != other.group_type: return False
				6308	if self.group_id != other.group_id: return False
				6309	if self.buckets != other.buckets: return False
				6310	return True
				6311
				6312	def pretty_print(self, q):
				6313	q.text("group_modify {")
				6314	with q.group():
				6315	with q.indent(2):
				6316	q.breakable()
				6317	q.text("xid = ");
				6318	if self.xid != None:
				6319	q.text("%#x" % self.xid)
				6320	else:
				6321	q.text('None')
				6322	q.text(","); q.breakable()
				6323	q.text("group_type = ");
				6324	q.text("%#x" % self.group_type)
				6325	q.text(","); q.breakable()
				6326	q.text("group_id = ");
				6327	q.text("%#x" % self.group_id)
				6328	q.text(","); q.breakable()
				6329	q.text("buckets = ");
				6330	q.pp(self.buckets)
				6331	q.breakable()
				6332	q.text('}')
				6333
				6334	group_mod.subtypes[1] = group_modify
				6335
				6336	class group_stats_reply(stats_reply):
				6337	version = 3
				6338	type = 19
				6339	stats_type = 6
				6340
				6341	def __init__(self, xid=None, flags=None, entries=None):
				6342	if xid != None:
				6343	self.xid = xid
				6344	else:
				6345	self.xid = None
				6346	if flags != None:
				6347	self.flags = flags
				6348	else:
				6349	self.flags = 0
				6350	if entries != None:
				6351	self.entries = entries
				6352	else:
				6353	self.entries = []
				6354	return
				6355
				6356	def pack(self):
				6357	packed = []
				6358	packed.append(struct.pack("!B", self.version))
				6359	packed.append(struct.pack("!B", self.type))
				6360	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				6361	packed.append(struct.pack("!L", self.xid))
				6362	packed.append(struct.pack("!H", self.stats_type))
				6363	packed.append(struct.pack("!H", self.flags))
				6364	packed.append('\x00' * 4)
				6365	packed.append(loxi.generic_util.pack_list(self.entries))
				6366	length = sum([len(x) for x in packed])
				6367	packed[2] = struct.pack("!H", length)
				6368	return ''.join(packed)
				6369
				6370	@staticmethod
				6371	def unpack(reader):
				6372	obj = group_stats_reply()
				6373	_version = reader.read("!B")[0]
				6374	assert(_version == 3)
				6375	_type = reader.read("!B")[0]
				6376	assert(_type == 19)
				6377	_length = reader.read("!H")[0]
				6378	orig_reader = reader
				6379	reader = orig_reader.slice(_length, 4)
				6380	obj.xid = reader.read("!L")[0]
				6381	_stats_type = reader.read("!H")[0]
				6382	assert(_stats_type == 6)
				6383	obj.flags = reader.read("!H")[0]
				6384	reader.skip(4)
				6385	obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.group_stats_entry.unpack)
				6386	return obj
				6387
				6388	def __eq__(self, other):
				6389	if type(self) != type(other): return False
				6390	if self.xid != other.xid: return False
				6391	if self.flags != other.flags: return False
				6392	if self.entries != other.entries: return False
				6393	return True
				6394
				6395	def pretty_print(self, q):
				6396	q.text("group_stats_reply {")
				6397	with q.group():
				6398	with q.indent(2):
				6399	q.breakable()
				6400	q.text("xid = ");
				6401	if self.xid != None:
				6402	q.text("%#x" % self.xid)
				6403	else:
				6404	q.text('None')
				6405	q.text(","); q.breakable()
				6406	q.text("flags = ");
				6407	q.text("%#x" % self.flags)
				6408	q.text(","); q.breakable()
				6409	q.text("entries = ");
				6410	q.pp(self.entries)
				6411	q.breakable()
				6412	q.text('}')
				6413
				6414	stats_reply.subtypes[6] = group_stats_reply
				6415
				6416	class group_stats_request(stats_request):
				6417	version = 3
				6418	type = 18
				6419	stats_type = 6
				6420
				6421	def __init__(self, xid=None, flags=None, group_id=None):
				6422	if xid != None:
				6423	self.xid = xid
				6424	else:
				6425	self.xid = None
				6426	if flags != None:
				6427	self.flags = flags
				6428	else:
				6429	self.flags = 0
				6430	if group_id != None:
				6431	self.group_id = group_id
				6432	else:
				6433	self.group_id = 0
				6434	return
				6435
				6436	def pack(self):
				6437	packed = []
				6438	packed.append(struct.pack("!B", self.version))
				6439	packed.append(struct.pack("!B", self.type))
				6440	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				6441	packed.append(struct.pack("!L", self.xid))
				6442	packed.append(struct.pack("!H", self.stats_type))
				6443	packed.append(struct.pack("!H", self.flags))
				6444	packed.append('\x00' * 4)
				6445	packed.append(struct.pack("!L", self.group_id))
				6446	packed.append('\x00' * 4)
				6447	length = sum([len(x) for x in packed])
				6448	packed[2] = struct.pack("!H", length)
				6449	return ''.join(packed)
				6450
				6451	@staticmethod
				6452	def unpack(reader):
				6453	obj = group_stats_request()
				6454	_version = reader.read("!B")[0]
				6455	assert(_version == 3)
				6456	_type = reader.read("!B")[0]
				6457	assert(_type == 18)
				6458	_length = reader.read("!H")[0]
				6459	orig_reader = reader
				6460	reader = orig_reader.slice(_length, 4)
				6461	obj.xid = reader.read("!L")[0]
				6462	_stats_type = reader.read("!H")[0]
				6463	assert(_stats_type == 6)
				6464	obj.flags = reader.read("!H")[0]
				6465	reader.skip(4)
				6466	obj.group_id = reader.read("!L")[0]
				6467	reader.skip(4)
				6468	return obj
				6469
				6470	def __eq__(self, other):
				6471	if type(self) != type(other): return False
				6472	if self.xid != other.xid: return False
				6473	if self.flags != other.flags: return False
				6474	if self.group_id != other.group_id: return False
				6475	return True
				6476
				6477	def pretty_print(self, q):
				6478	q.text("group_stats_request {")
				6479	with q.group():
				6480	with q.indent(2):
				6481	q.breakable()
				6482	q.text("xid = ");
				6483	if self.xid != None:
				6484	q.text("%#x" % self.xid)
				6485	else:
				6486	q.text('None')
				6487	q.text(","); q.breakable()
				6488	q.text("flags = ");
				6489	q.text("%#x" % self.flags)
				6490	q.text(","); q.breakable()
				6491	q.text("group_id = ");
				6492	q.text("%#x" % self.group_id)
				6493	q.breakable()
				6494	q.text('}')
				6495
				6496	stats_request.subtypes[6] = group_stats_request
				6497
				6498	class hello(message):
				6499	version = 3
				6500	type = 0
				6501
				6502	def __init__(self, xid=None):
				6503	if xid != None:
				6504	self.xid = xid
				6505	else:
				6506	self.xid = None
				6507	return
				6508
				6509	def pack(self):
				6510	packed = []
				6511	packed.append(struct.pack("!B", self.version))
				6512	packed.append(struct.pack("!B", self.type))
				6513	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				6514	packed.append(struct.pack("!L", self.xid))
				6515	length = sum([len(x) for x in packed])
				6516	packed[2] = struct.pack("!H", length)
				6517	return ''.join(packed)
				6518
				6519	@staticmethod
				6520	def unpack(reader):
				6521	obj = hello()
				6522	_version = reader.read("!B")[0]
				6523	assert(_version == 3)
				6524	_type = reader.read("!B")[0]
				6525	assert(_type == 0)
				6526	_length = reader.read("!H")[0]
				6527	orig_reader = reader
				6528	reader = orig_reader.slice(_length, 4)
				6529	obj.xid = reader.read("!L")[0]
				6530	return obj
				6531
				6532	def __eq__(self, other):
				6533	if type(self) != type(other): return False
				6534	if self.xid != other.xid: return False
				6535	return True
				6536
				6537	def pretty_print(self, q):
				6538	q.text("hello {")
				6539	with q.group():
				6540	with q.indent(2):
				6541	q.breakable()
				6542	q.text("xid = ");
				6543	if self.xid != None:
				6544	q.text("%#x" % self.xid)
				6545	else:
				6546	q.text('None')
				6547	q.breakable()
				6548	q.text('}')
				6549
				6550	message.subtypes[0] = hello
				6551
				6552	class hello_failed_error_msg(error_msg):
				6553	version = 3
				6554	type = 1
				6555	err_type = 0
				6556
				6557	def __init__(self, xid=None, code=None, data=None):
				6558	if xid != None:
				6559	self.xid = xid
				6560	else:
				6561	self.xid = None
				6562	if code != None:
				6563	self.code = code
				6564	else:
				6565	self.code = 0
				6566	if data != None:
				6567	self.data = data
				6568	else:
				6569	self.data = ''
				6570	return
				6571
				6572	def pack(self):
				6573	packed = []
				6574	packed.append(struct.pack("!B", self.version))
				6575	packed.append(struct.pack("!B", self.type))
				6576	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				6577	packed.append(struct.pack("!L", self.xid))
				6578	packed.append(struct.pack("!H", self.err_type))
				6579	packed.append(struct.pack("!H", self.code))
				6580	packed.append(self.data)
				6581	length = sum([len(x) for x in packed])
				6582	packed[2] = struct.pack("!H", length)
				6583	return ''.join(packed)
				6584
				6585	@staticmethod
				6586	def unpack(reader):
				6587	obj = hello_failed_error_msg()
				6588	_version = reader.read("!B")[0]
				6589	assert(_version == 3)
				6590	_type = reader.read("!B")[0]
				6591	assert(_type == 1)
				6592	_length = reader.read("!H")[0]
				6593	orig_reader = reader
				6594	reader = orig_reader.slice(_length, 4)
				6595	obj.xid = reader.read("!L")[0]
				6596	_err_type = reader.read("!H")[0]
				6597	assert(_err_type == 0)
				6598	obj.code = reader.read("!H")[0]
				6599	obj.data = str(reader.read_all())
				6600	return obj
				6601
				6602	def __eq__(self, other):
				6603	if type(self) != type(other): return False
				6604	if self.xid != other.xid: return False
				6605	if self.code != other.code: return False
				6606	if self.data != other.data: return False
				6607	return True
				6608
				6609	def pretty_print(self, q):
				6610	q.text("hello_failed_error_msg {")
				6611	with q.group():
				6612	with q.indent(2):
				6613	q.breakable()
				6614	q.text("xid = ");
				6615	if self.xid != None:
				6616	q.text("%#x" % self.xid)
				6617	else:
				6618	q.text('None')
				6619	q.text(","); q.breakable()
				6620	q.text("code = ");
				6621	q.text("%#x" % self.code)
				6622	q.text(","); q.breakable()
				6623	q.text("data = ");
				6624	q.pp(self.data)
				6625	q.breakable()
				6626	q.text('}')
				6627
				6628	error_msg.subtypes[0] = hello_failed_error_msg
				6629
				6630	class nicira_header(experimenter):
				6631	subtypes = {}
				6632
				6633	version = 3
				6634	type = 4
				6635	experimenter = 8992
				6636
				6637	def __init__(self, xid=None, subtype=None):
				6638	if xid != None:
				6639	self.xid = xid
				6640	else:
				6641	self.xid = None
				6642	if subtype != None:
				6643	self.subtype = subtype
				6644	else:
				6645	self.subtype = 0
				6646	return
				6647
				6648	def pack(self):
				6649	packed = []
				6650	packed.append(struct.pack("!B", self.version))
				6651	packed.append(struct.pack("!B", self.type))
				6652	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				6653	packed.append(struct.pack("!L", self.xid))
				6654	packed.append(struct.pack("!L", self.experimenter))
				6655	packed.append(struct.pack("!L", self.subtype))
				6656	length = sum([len(x) for x in packed])
				6657	packed[2] = struct.pack("!H", length)
				6658	return ''.join(packed)
				6659
				6660	@staticmethod
				6661	def unpack(reader):
				6662	subtype, = reader.peek('!L', 12)
				6663	subclass = nicira_header.subtypes.get(subtype)
				6664	if subclass:
				6665	return subclass.unpack(reader)
				6666
				6667	obj = nicira_header()
				6668	_version = reader.read("!B")[0]
				6669	assert(_version == 3)
				6670	_type = reader.read("!B")[0]
				6671	assert(_type == 4)
				6672	_length = reader.read("!H")[0]
				6673	orig_reader = reader
				6674	reader = orig_reader.slice(_length, 4)
				6675	obj.xid = reader.read("!L")[0]
				6676	_experimenter = reader.read("!L")[0]
				6677	assert(_experimenter == 8992)
				6678	obj.subtype = reader.read("!L")[0]
				6679	return obj
				6680
				6681	def __eq__(self, other):
				6682	if type(self) != type(other): return False
				6683	if self.xid != other.xid: return False
				6684	if self.subtype != other.subtype: return False
				6685	return True
				6686
				6687	def pretty_print(self, q):
				6688	q.text("nicira_header {")
				6689	with q.group():
				6690	with q.indent(2):
				6691	q.breakable()
				6692	q.text("xid = ");
				6693	if self.xid != None:
				6694	q.text("%#x" % self.xid)
				6695	else:
				6696	q.text('None')
				6697	q.breakable()
				6698	q.text('}')
				6699
				6700	experimenter.subtypes[8992] = nicira_header
				6701
				6702	class packet_in(message):
				6703	version = 3
				6704	type = 10
				6705
				6706	def __init__(self, xid=None, buffer_id=None, total_len=None, reason=None, table_id=None, match=None, data=None):
				6707	if xid != None:
				6708	self.xid = xid
				6709	else:
				6710	self.xid = None
				6711	if buffer_id != None:
				6712	self.buffer_id = buffer_id
				6713	else:
				6714	self.buffer_id = 0
				6715	if total_len != None:
				6716	self.total_len = total_len
				6717	else:
				6718	self.total_len = 0
				6719	if reason != None:
				6720	self.reason = reason
				6721	else:
				6722	self.reason = 0
				6723	if table_id != None:
				6724	self.table_id = table_id
				6725	else:
				6726	self.table_id = 0
				6727	if match != None:
				6728	self.match = match
				6729	else:
				6730	self.match = ofp.match()
				6731	if data != None:
				6732	self.data = data
				6733	else:
				6734	self.data = ''
				6735	return
				6736
				6737	def pack(self):
				6738	packed = []
				6739	packed.append(struct.pack("!B", self.version))
				6740	packed.append(struct.pack("!B", self.type))
				6741	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				6742	packed.append(struct.pack("!L", self.xid))
				6743	packed.append(struct.pack("!L", self.buffer_id))
				6744	packed.append(struct.pack("!H", self.total_len))
				6745	packed.append(struct.pack("!B", self.reason))
				6746	packed.append(struct.pack("!B", self.table_id))
				6747	packed.append(self.match.pack())
				6748	packed.append('\x00' * 2)
				6749	packed.append(self.data)
				6750	length = sum([len(x) for x in packed])
				6751	packed[2] = struct.pack("!H", length)
				6752	return ''.join(packed)
				6753
				6754	@staticmethod
				6755	def unpack(reader):
				6756	obj = packet_in()
				6757	_version = reader.read("!B")[0]
				6758	assert(_version == 3)
				6759	_type = reader.read("!B")[0]
				6760	assert(_type == 10)
				6761	_length = reader.read("!H")[0]
				6762	orig_reader = reader
				6763	reader = orig_reader.slice(_length, 4)
				6764	obj.xid = reader.read("!L")[0]
				6765	obj.buffer_id = reader.read("!L")[0]
				6766	obj.total_len = reader.read("!H")[0]
				6767	obj.reason = reader.read("!B")[0]
				6768	obj.table_id = reader.read("!B")[0]
				6769	obj.match = ofp.match.unpack(reader)
				6770	reader.skip(2)
				6771	obj.data = str(reader.read_all())
				6772	return obj
				6773
				6774	def __eq__(self, other):
				6775	if type(self) != type(other): return False
				6776	if self.xid != other.xid: return False
				6777	if self.buffer_id != other.buffer_id: return False
				6778	if self.total_len != other.total_len: return False
				6779	if self.reason != other.reason: return False
				6780	if self.table_id != other.table_id: return False
				6781	if self.match != other.match: return False
				6782	if self.data != other.data: return False
				6783	return True
				6784
				6785	def pretty_print(self, q):
				6786	q.text("packet_in {")
				6787	with q.group():
				6788	with q.indent(2):
				6789	q.breakable()
				6790	q.text("xid = ");
				6791	if self.xid != None:
				6792	q.text("%#x" % self.xid)
				6793	else:
				6794	q.text('None')
				6795	q.text(","); q.breakable()
				6796	q.text("buffer_id = ");
				6797	q.text("%#x" % self.buffer_id)
				6798	q.text(","); q.breakable()
				6799	q.text("total_len = ");
				6800	q.text("%#x" % self.total_len)
				6801	q.text(","); q.breakable()
				6802	q.text("reason = ");
				6803	q.text("%#x" % self.reason)
				6804	q.text(","); q.breakable()
				6805	q.text("table_id = ");
				6806	q.text("%#x" % self.table_id)
				6807	q.text(","); q.breakable()
				6808	q.text("match = ");
				6809	q.pp(self.match)
				6810	q.text(","); q.breakable()
				6811	q.text("data = ");
				6812	q.pp(self.data)
				6813	q.breakable()
				6814	q.text('}')
				6815
				6816	message.subtypes[10] = packet_in
				6817
				6818	class packet_out(message):
				6819	version = 3
				6820	type = 13
				6821
				6822	def __init__(self, xid=None, buffer_id=None, in_port=None, actions=None, data=None):
				6823	if xid != None:
				6824	self.xid = xid
				6825	else:
				6826	self.xid = None
				6827	if buffer_id != None:
				6828	self.buffer_id = buffer_id
				6829	else:
				6830	self.buffer_id = 0
				6831	if in_port != None:
				6832	self.in_port = in_port
				6833	else:
				6834	self.in_port = 0
				6835	if actions != None:
				6836	self.actions = actions
				6837	else:
				6838	self.actions = []
				6839	if data != None:
				6840	self.data = data
				6841	else:
				6842	self.data = ''
				6843	return
				6844
				6845	def pack(self):
				6846	packed = []
				6847	packed.append(struct.pack("!B", self.version))
				6848	packed.append(struct.pack("!B", self.type))
				6849	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				6850	packed.append(struct.pack("!L", self.xid))
				6851	packed.append(struct.pack("!L", self.buffer_id))
				6852	packed.append(util.pack_port_no(self.in_port))
				6853	packed.append(struct.pack("!H", 0)) # placeholder for actions_len at index 6
				6854	packed.append('\x00' * 6)
				6855	packed.append(loxi.generic_util.pack_list(self.actions))
				6856	packed[6] = struct.pack("!H", len(packed[-1]))
				6857	packed.append(self.data)
				6858	length = sum([len(x) for x in packed])
				6859	packed[2] = struct.pack("!H", length)
				6860	return ''.join(packed)
				6861
				6862	@staticmethod
				6863	def unpack(reader):
				6864	obj = packet_out()
				6865	_version = reader.read("!B")[0]
				6866	assert(_version == 3)
				6867	_type = reader.read("!B")[0]
				6868	assert(_type == 13)
				6869	_length = reader.read("!H")[0]
				6870	orig_reader = reader
				6871	reader = orig_reader.slice(_length, 4)
				6872	obj.xid = reader.read("!L")[0]
				6873	obj.buffer_id = reader.read("!L")[0]
				6874	obj.in_port = util.unpack_port_no(reader)
				6875	_actions_len = reader.read("!H")[0]
				6876	reader.skip(6)
				6877	obj.actions = loxi.generic_util.unpack_list(reader.slice(_actions_len), ofp.action.action.unpack)
				6878	obj.data = str(reader.read_all())
				6879	return obj
				6880
				6881	def __eq__(self, other):
				6882	if type(self) != type(other): return False
				6883	if self.xid != other.xid: return False
				6884	if self.buffer_id != other.buffer_id: return False
				6885	if self.in_port != other.in_port: return False
				6886	if self.actions != other.actions: return False
				6887	if self.data != other.data: return False
				6888	return True
				6889
				6890	def pretty_print(self, q):
				6891	q.text("packet_out {")
				6892	with q.group():
				6893	with q.indent(2):
				6894	q.breakable()
				6895	q.text("xid = ");
				6896	if self.xid != None:
				6897	q.text("%#x" % self.xid)
				6898	else:
				6899	q.text('None')
				6900	q.text(","); q.breakable()
				6901	q.text("buffer_id = ");
				6902	q.text("%#x" % self.buffer_id)
				6903	q.text(","); q.breakable()
				6904	q.text("in_port = ");
				6905	q.text(util.pretty_port(self.in_port))
				6906	q.text(","); q.breakable()
				6907	q.text("actions = ");
				6908	q.pp(self.actions)
				6909	q.text(","); q.breakable()
				6910	q.text("data = ");
				6911	q.pp(self.data)
				6912	q.breakable()
				6913	q.text('}')
				6914
				6915	message.subtypes[13] = packet_out
				6916
				6917	class port_mod(message):
				6918	version = 3
				6919	type = 16
				6920
				6921	def __init__(self, xid=None, port_no=None, hw_addr=None, config=None, mask=None, advertise=None):
				6922	if xid != None:
				6923	self.xid = xid
				6924	else:
				6925	self.xid = None
				6926	if port_no != None:
				6927	self.port_no = port_no
				6928	else:
				6929	self.port_no = 0
				6930	if hw_addr != None:
				6931	self.hw_addr = hw_addr
				6932	else:
				6933	self.hw_addr = [0,0,0,0,0,0]
				6934	if config != None:
				6935	self.config = config
				6936	else:
				6937	self.config = 0
				6938	if mask != None:
				6939	self.mask = mask
				6940	else:
				6941	self.mask = 0
				6942	if advertise != None:
				6943	self.advertise = advertise
				6944	else:
				6945	self.advertise = 0
				6946	return
				6947
				6948	def pack(self):
				6949	packed = []
				6950	packed.append(struct.pack("!B", self.version))
				6951	packed.append(struct.pack("!B", self.type))
				6952	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				6953	packed.append(struct.pack("!L", self.xid))
				6954	packed.append(util.pack_port_no(self.port_no))
				6955	packed.append('\x00' * 4)
				6956	packed.append(struct.pack("!6B", *self.hw_addr))
				6957	packed.append('\x00' * 2)
				6958	packed.append(struct.pack("!L", self.config))
				6959	packed.append(struct.pack("!L", self.mask))
				6960	packed.append(struct.pack("!L", self.advertise))
				6961	packed.append('\x00' * 4)
				6962	length = sum([len(x) for x in packed])
				6963	packed[2] = struct.pack("!H", length)
				6964	return ''.join(packed)
				6965
				6966	@staticmethod
				6967	def unpack(reader):
				6968	obj = port_mod()
				6969	_version = reader.read("!B")[0]
				6970	assert(_version == 3)
				6971	_type = reader.read("!B")[0]
				6972	assert(_type == 16)
				6973	_length = reader.read("!H")[0]
				6974	orig_reader = reader
				6975	reader = orig_reader.slice(_length, 4)
				6976	obj.xid = reader.read("!L")[0]
				6977	obj.port_no = util.unpack_port_no(reader)
				6978	reader.skip(4)
				6979	obj.hw_addr = list(reader.read('!6B'))
				6980	reader.skip(2)
				6981	obj.config = reader.read("!L")[0]
				6982	obj.mask = reader.read("!L")[0]
				6983	obj.advertise = reader.read("!L")[0]
				6984	reader.skip(4)
				6985	return obj
				6986
				6987	def __eq__(self, other):
				6988	if type(self) != type(other): return False
				6989	if self.xid != other.xid: return False
				6990	if self.port_no != other.port_no: return False
				6991	if self.hw_addr != other.hw_addr: return False
				6992	if self.config != other.config: return False
				6993	if self.mask != other.mask: return False
				6994	if self.advertise != other.advertise: return False
				6995	return True
				6996
				6997	def pretty_print(self, q):
				6998	q.text("port_mod {")
				6999	with q.group():
				7000	with q.indent(2):
				7001	q.breakable()
				7002	q.text("xid = ");
				7003	if self.xid != None:
				7004	q.text("%#x" % self.xid)
				7005	else:
				7006	q.text('None')
				7007	q.text(","); q.breakable()
				7008	q.text("port_no = ");
				7009	q.text(util.pretty_port(self.port_no))
				7010	q.text(","); q.breakable()
				7011	q.text("hw_addr = ");
				7012	q.text(util.pretty_mac(self.hw_addr))
				7013	q.text(","); q.breakable()
				7014	q.text("config = ");
				7015	q.text("%#x" % self.config)
				7016	q.text(","); q.breakable()
				7017	q.text("mask = ");
				7018	q.text("%#x" % self.mask)
				7019	q.text(","); q.breakable()
				7020	q.text("advertise = ");
				7021	q.text("%#x" % self.advertise)
				7022	q.breakable()
				7023	q.text('}')
				7024
				7025	message.subtypes[16] = port_mod
				7026
				7027	class port_mod_failed_error_msg(error_msg):
				7028	version = 3
				7029	type = 1
				7030	err_type = 7
				7031
				7032	def __init__(self, xid=None, code=None, data=None):
				7033	if xid != None:
				7034	self.xid = xid
				7035	else:
				7036	self.xid = None
				7037	if code != None:
				7038	self.code = code
				7039	else:
				7040	self.code = 0
				7041	if data != None:
				7042	self.data = data
				7043	else:
				7044	self.data = ''
				7045	return
				7046
				7047	def pack(self):
				7048	packed = []
				7049	packed.append(struct.pack("!B", self.version))
				7050	packed.append(struct.pack("!B", self.type))
				7051	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				7052	packed.append(struct.pack("!L", self.xid))
				7053	packed.append(struct.pack("!H", self.err_type))
				7054	packed.append(struct.pack("!H", self.code))
				7055	packed.append(self.data)
				7056	length = sum([len(x) for x in packed])
				7057	packed[2] = struct.pack("!H", length)
				7058	return ''.join(packed)
				7059
				7060	@staticmethod
				7061	def unpack(reader):
				7062	obj = port_mod_failed_error_msg()
				7063	_version = reader.read("!B")[0]
				7064	assert(_version == 3)
				7065	_type = reader.read("!B")[0]
				7066	assert(_type == 1)
				7067	_length = reader.read("!H")[0]
				7068	orig_reader = reader
				7069	reader = orig_reader.slice(_length, 4)
				7070	obj.xid = reader.read("!L")[0]
				7071	_err_type = reader.read("!H")[0]
				7072	assert(_err_type == 7)
				7073	obj.code = reader.read("!H")[0]
				7074	obj.data = str(reader.read_all())
				7075	return obj
				7076
				7077	def __eq__(self, other):
				7078	if type(self) != type(other): return False
				7079	if self.xid != other.xid: return False
				7080	if self.code != other.code: return False
				7081	if self.data != other.data: return False
				7082	return True
				7083
				7084	def pretty_print(self, q):
				7085	q.text("port_mod_failed_error_msg {")
				7086	with q.group():
				7087	with q.indent(2):
				7088	q.breakable()
				7089	q.text("xid = ");
				7090	if self.xid != None:
				7091	q.text("%#x" % self.xid)
				7092	else:
				7093	q.text('None')
				7094	q.text(","); q.breakable()
				7095	q.text("code = ");
				7096	q.text("%#x" % self.code)
				7097	q.text(","); q.breakable()
				7098	q.text("data = ");
				7099	q.pp(self.data)
				7100	q.breakable()
				7101	q.text('}')
				7102
				7103	error_msg.subtypes[7] = port_mod_failed_error_msg
				7104
				7105	class port_stats_reply(stats_reply):
				7106	version = 3
				7107	type = 19
				7108	stats_type = 4
				7109
				7110	def __init__(self, xid=None, flags=None, entries=None):
				7111	if xid != None:
				7112	self.xid = xid
				7113	else:
				7114	self.xid = None
				7115	if flags != None:
				7116	self.flags = flags
				7117	else:
				7118	self.flags = 0
				7119	if entries != None:
				7120	self.entries = entries
				7121	else:
				7122	self.entries = []
				7123	return
				7124
				7125	def pack(self):
				7126	packed = []
				7127	packed.append(struct.pack("!B", self.version))
				7128	packed.append(struct.pack("!B", self.type))
				7129	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				7130	packed.append(struct.pack("!L", self.xid))
				7131	packed.append(struct.pack("!H", self.stats_type))
				7132	packed.append(struct.pack("!H", self.flags))
				7133	packed.append('\x00' * 4)
				7134	packed.append(loxi.generic_util.pack_list(self.entries))
				7135	length = sum([len(x) for x in packed])
				7136	packed[2] = struct.pack("!H", length)
				7137	return ''.join(packed)
				7138
				7139	@staticmethod
				7140	def unpack(reader):
				7141	obj = port_stats_reply()
				7142	_version = reader.read("!B")[0]
				7143	assert(_version == 3)
				7144	_type = reader.read("!B")[0]
				7145	assert(_type == 19)
				7146	_length = reader.read("!H")[0]
				7147	orig_reader = reader
				7148	reader = orig_reader.slice(_length, 4)
				7149	obj.xid = reader.read("!L")[0]
				7150	_stats_type = reader.read("!H")[0]
				7151	assert(_stats_type == 4)
				7152	obj.flags = reader.read("!H")[0]
				7153	reader.skip(4)
				7154	obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.port_stats_entry.unpack)
				7155	return obj
				7156
				7157	def __eq__(self, other):
				7158	if type(self) != type(other): return False
				7159	if self.xid != other.xid: return False
				7160	if self.flags != other.flags: return False
				7161	if self.entries != other.entries: return False
				7162	return True
				7163
				7164	def pretty_print(self, q):
				7165	q.text("port_stats_reply {")
				7166	with q.group():
				7167	with q.indent(2):
				7168	q.breakable()
				7169	q.text("xid = ");
				7170	if self.xid != None:
				7171	q.text("%#x" % self.xid)
				7172	else:
				7173	q.text('None')
				7174	q.text(","); q.breakable()
				7175	q.text("flags = ");
				7176	q.text("%#x" % self.flags)
				7177	q.text(","); q.breakable()
				7178	q.text("entries = ");
				7179	q.pp(self.entries)
				7180	q.breakable()
				7181	q.text('}')
				7182
				7183	stats_reply.subtypes[4] = port_stats_reply
				7184
				7185	class port_stats_request(stats_request):
				7186	version = 3
				7187	type = 18
				7188	stats_type = 4
				7189
				7190	def __init__(self, xid=None, flags=None, port_no=None):
				7191	if xid != None:
				7192	self.xid = xid
				7193	else:
				7194	self.xid = None
				7195	if flags != None:
				7196	self.flags = flags
				7197	else:
				7198	self.flags = 0
				7199	if port_no != None:
				7200	self.port_no = port_no
				7201	else:
				7202	self.port_no = 0
				7203	return
				7204
				7205	def pack(self):
				7206	packed = []
				7207	packed.append(struct.pack("!B", self.version))
				7208	packed.append(struct.pack("!B", self.type))
				7209	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				7210	packed.append(struct.pack("!L", self.xid))
				7211	packed.append(struct.pack("!H", self.stats_type))
				7212	packed.append(struct.pack("!H", self.flags))
				7213	packed.append('\x00' * 4)
				7214	packed.append(util.pack_port_no(self.port_no))
				7215	packed.append('\x00' * 4)
				7216	length = sum([len(x) for x in packed])
				7217	packed[2] = struct.pack("!H", length)
				7218	return ''.join(packed)
				7219
				7220	@staticmethod
				7221	def unpack(reader):
				7222	obj = port_stats_request()
				7223	_version = reader.read("!B")[0]
				7224	assert(_version == 3)
				7225	_type = reader.read("!B")[0]
				7226	assert(_type == 18)
				7227	_length = reader.read("!H")[0]
				7228	orig_reader = reader
				7229	reader = orig_reader.slice(_length, 4)
				7230	obj.xid = reader.read("!L")[0]
				7231	_stats_type = reader.read("!H")[0]
				7232	assert(_stats_type == 4)
				7233	obj.flags = reader.read("!H")[0]
				7234	reader.skip(4)
				7235	obj.port_no = util.unpack_port_no(reader)
				7236	reader.skip(4)
				7237	return obj
				7238
				7239	def __eq__(self, other):
				7240	if type(self) != type(other): return False
				7241	if self.xid != other.xid: return False
				7242	if self.flags != other.flags: return False
				7243	if self.port_no != other.port_no: return False
				7244	return True
				7245
				7246	def pretty_print(self, q):
				7247	q.text("port_stats_request {")
				7248	with q.group():
				7249	with q.indent(2):
				7250	q.breakable()
				7251	q.text("xid = ");
				7252	if self.xid != None:
				7253	q.text("%#x" % self.xid)
				7254	else:
				7255	q.text('None')
				7256	q.text(","); q.breakable()
				7257	q.text("flags = ");
				7258	q.text("%#x" % self.flags)
				7259	q.text(","); q.breakable()
				7260	q.text("port_no = ");
				7261	q.text(util.pretty_port(self.port_no))
				7262	q.breakable()
				7263	q.text('}')
				7264
				7265	stats_request.subtypes[4] = port_stats_request
				7266
				7267	class port_status(message):
				7268	version = 3
				7269	type = 12
				7270
				7271	def __init__(self, xid=None, reason=None, desc=None):
				7272	if xid != None:
				7273	self.xid = xid
				7274	else:
				7275	self.xid = None
				7276	if reason != None:
				7277	self.reason = reason
				7278	else:
				7279	self.reason = 0
				7280	if desc != None:
				7281	self.desc = desc
				7282	else:
				7283	self.desc = ofp.port_desc()
				7284	return
				7285
				7286	def pack(self):
				7287	packed = []
				7288	packed.append(struct.pack("!B", self.version))
				7289	packed.append(struct.pack("!B", self.type))
				7290	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				7291	packed.append(struct.pack("!L", self.xid))
				7292	packed.append(struct.pack("!B", self.reason))
				7293	packed.append('\x00' * 7)
				7294	packed.append(self.desc.pack())
				7295	length = sum([len(x) for x in packed])
				7296	packed[2] = struct.pack("!H", length)
				7297	return ''.join(packed)
				7298
				7299	@staticmethod
				7300	def unpack(reader):
				7301	obj = port_status()
				7302	_version = reader.read("!B")[0]
				7303	assert(_version == 3)
				7304	_type = reader.read("!B")[0]
				7305	assert(_type == 12)
				7306	_length = reader.read("!H")[0]
				7307	orig_reader = reader
				7308	reader = orig_reader.slice(_length, 4)
				7309	obj.xid = reader.read("!L")[0]
				7310	obj.reason = reader.read("!B")[0]
				7311	reader.skip(7)
				7312	obj.desc = ofp.port_desc.unpack(reader)
				7313	return obj
				7314
				7315	def __eq__(self, other):
				7316	if type(self) != type(other): return False
				7317	if self.xid != other.xid: return False
				7318	if self.reason != other.reason: return False
				7319	if self.desc != other.desc: return False
				7320	return True
				7321
				7322	def pretty_print(self, q):
				7323	q.text("port_status {")
				7324	with q.group():
				7325	with q.indent(2):
				7326	q.breakable()
				7327	q.text("xid = ");
				7328	if self.xid != None:
				7329	q.text("%#x" % self.xid)
				7330	else:
				7331	q.text('None')
				7332	q.text(","); q.breakable()
				7333	q.text("reason = ");
				7334	q.text("%#x" % self.reason)
				7335	q.text(","); q.breakable()
				7336	q.text("desc = ");
				7337	q.pp(self.desc)
				7338	q.breakable()
				7339	q.text('}')
				7340
				7341	message.subtypes[12] = port_status
				7342
				7343	class queue_get_config_reply(message):
				7344	version = 3
				7345	type = 23
				7346
				7347	def __init__(self, xid=None, port=None, queues=None):
				7348	if xid != None:
				7349	self.xid = xid
				7350	else:
				7351	self.xid = None
				7352	if port != None:
				7353	self.port = port
				7354	else:
				7355	self.port = 0
				7356	if queues != None:
				7357	self.queues = queues
				7358	else:
				7359	self.queues = []
				7360	return
				7361
				7362	def pack(self):
				7363	packed = []
				7364	packed.append(struct.pack("!B", self.version))
				7365	packed.append(struct.pack("!B", self.type))
				7366	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				7367	packed.append(struct.pack("!L", self.xid))
				7368	packed.append(util.pack_port_no(self.port))
				7369	packed.append('\x00' * 4)
				7370	packed.append(loxi.generic_util.pack_list(self.queues))
				7371	length = sum([len(x) for x in packed])
				7372	packed[2] = struct.pack("!H", length)
				7373	return ''.join(packed)
				7374
				7375	@staticmethod
				7376	def unpack(reader):
				7377	obj = queue_get_config_reply()
				7378	_version = reader.read("!B")[0]
				7379	assert(_version == 3)
				7380	_type = reader.read("!B")[0]
				7381	assert(_type == 23)
				7382	_length = reader.read("!H")[0]
				7383	orig_reader = reader
				7384	reader = orig_reader.slice(_length, 4)
				7385	obj.xid = reader.read("!L")[0]
				7386	obj.port = util.unpack_port_no(reader)
				7387	reader.skip(4)
				7388	obj.queues = loxi.generic_util.unpack_list(reader, ofp.common.packet_queue.unpack)
				7389	return obj
				7390
				7391	def __eq__(self, other):
				7392	if type(self) != type(other): return False
				7393	if self.xid != other.xid: return False
				7394	if self.port != other.port: return False
				7395	if self.queues != other.queues: return False
				7396	return True
				7397
				7398	def pretty_print(self, q):
				7399	q.text("queue_get_config_reply {")
				7400	with q.group():
				7401	with q.indent(2):
				7402	q.breakable()
				7403	q.text("xid = ");
				7404	if self.xid != None:
				7405	q.text("%#x" % self.xid)
				7406	else:
				7407	q.text('None')
				7408	q.text(","); q.breakable()
				7409	q.text("port = ");
				7410	q.text(util.pretty_port(self.port))
				7411	q.text(","); q.breakable()
				7412	q.text("queues = ");
				7413	q.pp(self.queues)
				7414	q.breakable()
				7415	q.text('}')
				7416
				7417	message.subtypes[23] = queue_get_config_reply
				7418
				7419	class queue_get_config_request(message):
				7420	version = 3
				7421	type = 22
				7422
				7423	def __init__(self, xid=None, port=None):
				7424	if xid != None:
				7425	self.xid = xid
				7426	else:
				7427	self.xid = None
				7428	if port != None:
				7429	self.port = port
				7430	else:
				7431	self.port = 0
				7432	return
				7433
				7434	def pack(self):
				7435	packed = []
				7436	packed.append(struct.pack("!B", self.version))
				7437	packed.append(struct.pack("!B", self.type))
				7438	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				7439	packed.append(struct.pack("!L", self.xid))
				7440	packed.append(util.pack_port_no(self.port))
				7441	packed.append('\x00' * 4)
				7442	length = sum([len(x) for x in packed])
				7443	packed[2] = struct.pack("!H", length)
				7444	return ''.join(packed)
				7445
				7446	@staticmethod
				7447	def unpack(reader):
				7448	obj = queue_get_config_request()
				7449	_version = reader.read("!B")[0]
				7450	assert(_version == 3)
				7451	_type = reader.read("!B")[0]
				7452	assert(_type == 22)
				7453	_length = reader.read("!H")[0]
				7454	orig_reader = reader
				7455	reader = orig_reader.slice(_length, 4)
				7456	obj.xid = reader.read("!L")[0]
				7457	obj.port = util.unpack_port_no(reader)
				7458	reader.skip(4)
				7459	return obj
				7460
				7461	def __eq__(self, other):
				7462	if type(self) != type(other): return False
				7463	if self.xid != other.xid: return False
				7464	if self.port != other.port: return False
				7465	return True
				7466
				7467	def pretty_print(self, q):
				7468	q.text("queue_get_config_request {")
				7469	with q.group():
				7470	with q.indent(2):
				7471	q.breakable()
				7472	q.text("xid = ");
				7473	if self.xid != None:
				7474	q.text("%#x" % self.xid)
				7475	else:
				7476	q.text('None')
				7477	q.text(","); q.breakable()
				7478	q.text("port = ");
				7479	q.text(util.pretty_port(self.port))
				7480	q.breakable()
				7481	q.text('}')
				7482
				7483	message.subtypes[22] = queue_get_config_request
				7484
				7485	class queue_op_failed_error_msg(error_msg):
				7486	version = 3
				7487	type = 1
				7488	err_type = 9
				7489
				7490	def __init__(self, xid=None, code=None, data=None):
				7491	if xid != None:
				7492	self.xid = xid
				7493	else:
				7494	self.xid = None
				7495	if code != None:
				7496	self.code = code
				7497	else:
				7498	self.code = 0
				7499	if data != None:
				7500	self.data = data
				7501	else:
				7502	self.data = ''
				7503	return
				7504
				7505	def pack(self):
				7506	packed = []
				7507	packed.append(struct.pack("!B", self.version))
				7508	packed.append(struct.pack("!B", self.type))
				7509	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				7510	packed.append(struct.pack("!L", self.xid))
				7511	packed.append(struct.pack("!H", self.err_type))
				7512	packed.append(struct.pack("!H", self.code))
				7513	packed.append(self.data)
				7514	length = sum([len(x) for x in packed])
				7515	packed[2] = struct.pack("!H", length)
				7516	return ''.join(packed)
				7517
				7518	@staticmethod
				7519	def unpack(reader):
				7520	obj = queue_op_failed_error_msg()
				7521	_version = reader.read("!B")[0]
				7522	assert(_version == 3)
				7523	_type = reader.read("!B")[0]
				7524	assert(_type == 1)
				7525	_length = reader.read("!H")[0]
				7526	orig_reader = reader
				7527	reader = orig_reader.slice(_length, 4)
				7528	obj.xid = reader.read("!L")[0]
				7529	_err_type = reader.read("!H")[0]
				7530	assert(_err_type == 9)
				7531	obj.code = reader.read("!H")[0]
				7532	obj.data = str(reader.read_all())
				7533	return obj
				7534
				7535	def __eq__(self, other):
				7536	if type(self) != type(other): return False
				7537	if self.xid != other.xid: return False
				7538	if self.code != other.code: return False
				7539	if self.data != other.data: return False
				7540	return True
				7541
				7542	def pretty_print(self, q):
				7543	q.text("queue_op_failed_error_msg {")
				7544	with q.group():
				7545	with q.indent(2):
				7546	q.breakable()
				7547	q.text("xid = ");
				7548	if self.xid != None:
				7549	q.text("%#x" % self.xid)
				7550	else:
				7551	q.text('None')
				7552	q.text(","); q.breakable()
				7553	q.text("code = ");
				7554	q.text("%#x" % self.code)
				7555	q.text(","); q.breakable()
				7556	q.text("data = ");
				7557	q.pp(self.data)
				7558	q.breakable()
				7559	q.text('}')
				7560
				7561	error_msg.subtypes[9] = queue_op_failed_error_msg
				7562
				7563	class queue_stats_reply(stats_reply):
				7564	version = 3
				7565	type = 19
				7566	stats_type = 5
				7567
				7568	def __init__(self, xid=None, flags=None, entries=None):
				7569	if xid != None:
				7570	self.xid = xid
				7571	else:
				7572	self.xid = None
				7573	if flags != None:
				7574	self.flags = flags
				7575	else:
				7576	self.flags = 0
				7577	if entries != None:
				7578	self.entries = entries
				7579	else:
				7580	self.entries = []
				7581	return
				7582
				7583	def pack(self):
				7584	packed = []
				7585	packed.append(struct.pack("!B", self.version))
				7586	packed.append(struct.pack("!B", self.type))
				7587	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				7588	packed.append(struct.pack("!L", self.xid))
				7589	packed.append(struct.pack("!H", self.stats_type))
				7590	packed.append(struct.pack("!H", self.flags))
				7591	packed.append('\x00' * 4)
				7592	packed.append(loxi.generic_util.pack_list(self.entries))
				7593	length = sum([len(x) for x in packed])
				7594	packed[2] = struct.pack("!H", length)
				7595	return ''.join(packed)
				7596
				7597	@staticmethod
				7598	def unpack(reader):
				7599	obj = queue_stats_reply()
				7600	_version = reader.read("!B")[0]
				7601	assert(_version == 3)
				7602	_type = reader.read("!B")[0]
				7603	assert(_type == 19)
				7604	_length = reader.read("!H")[0]
				7605	orig_reader = reader
				7606	reader = orig_reader.slice(_length, 4)
				7607	obj.xid = reader.read("!L")[0]
				7608	_stats_type = reader.read("!H")[0]
				7609	assert(_stats_type == 5)
				7610	obj.flags = reader.read("!H")[0]
				7611	reader.skip(4)
				7612	obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.queue_stats_entry.unpack)
				7613	return obj
				7614
				7615	def __eq__(self, other):
				7616	if type(self) != type(other): return False
				7617	if self.xid != other.xid: return False
				7618	if self.flags != other.flags: return False
				7619	if self.entries != other.entries: return False
				7620	return True
				7621
				7622	def pretty_print(self, q):
				7623	q.text("queue_stats_reply {")
				7624	with q.group():
				7625	with q.indent(2):
				7626	q.breakable()
				7627	q.text("xid = ");
				7628	if self.xid != None:
				7629	q.text("%#x" % self.xid)
				7630	else:
				7631	q.text('None')
				7632	q.text(","); q.breakable()
				7633	q.text("flags = ");
				7634	q.text("%#x" % self.flags)
				7635	q.text(","); q.breakable()
				7636	q.text("entries = ");
				7637	q.pp(self.entries)
				7638	q.breakable()
				7639	q.text('}')
				7640
				7641	stats_reply.subtypes[5] = queue_stats_reply
				7642
				7643	class queue_stats_request(stats_request):
				7644	version = 3
				7645	type = 18
				7646	stats_type = 5
				7647
				7648	def __init__(self, xid=None, flags=None, port_no=None, queue_id=None):
				7649	if xid != None:
				7650	self.xid = xid
				7651	else:
				7652	self.xid = None
				7653	if flags != None:
				7654	self.flags = flags
				7655	else:
				7656	self.flags = 0
				7657	if port_no != None:
				7658	self.port_no = port_no
				7659	else:
				7660	self.port_no = 0
				7661	if queue_id != None:
				7662	self.queue_id = queue_id
				7663	else:
				7664	self.queue_id = 0
				7665	return
				7666
				7667	def pack(self):
				7668	packed = []
				7669	packed.append(struct.pack("!B", self.version))
				7670	packed.append(struct.pack("!B", self.type))
				7671	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				7672	packed.append(struct.pack("!L", self.xid))
				7673	packed.append(struct.pack("!H", self.stats_type))
				7674	packed.append(struct.pack("!H", self.flags))
				7675	packed.append('\x00' * 4)
				7676	packed.append(util.pack_port_no(self.port_no))
				7677	packed.append(struct.pack("!L", self.queue_id))
				7678	length = sum([len(x) for x in packed])
				7679	packed[2] = struct.pack("!H", length)
				7680	return ''.join(packed)
				7681
				7682	@staticmethod
				7683	def unpack(reader):
				7684	obj = queue_stats_request()
				7685	_version = reader.read("!B")[0]
				7686	assert(_version == 3)
				7687	_type = reader.read("!B")[0]
				7688	assert(_type == 18)
				7689	_length = reader.read("!H")[0]
				7690	orig_reader = reader
				7691	reader = orig_reader.slice(_length, 4)
				7692	obj.xid = reader.read("!L")[0]
				7693	_stats_type = reader.read("!H")[0]
				7694	assert(_stats_type == 5)
				7695	obj.flags = reader.read("!H")[0]
				7696	reader.skip(4)
				7697	obj.port_no = util.unpack_port_no(reader)
				7698	obj.queue_id = reader.read("!L")[0]
				7699	return obj
				7700
				7701	def __eq__(self, other):
				7702	if type(self) != type(other): return False
				7703	if self.xid != other.xid: return False
				7704	if self.flags != other.flags: return False
				7705	if self.port_no != other.port_no: return False
				7706	if self.queue_id != other.queue_id: return False
				7707	return True
				7708
				7709	def pretty_print(self, q):
				7710	q.text("queue_stats_request {")
				7711	with q.group():
				7712	with q.indent(2):
				7713	q.breakable()
				7714	q.text("xid = ");
				7715	if self.xid != None:
				7716	q.text("%#x" % self.xid)
				7717	else:
				7718	q.text('None')
				7719	q.text(","); q.breakable()
				7720	q.text("flags = ");
				7721	q.text("%#x" % self.flags)
				7722	q.text(","); q.breakable()
				7723	q.text("port_no = ");
				7724	q.text(util.pretty_port(self.port_no))
				7725	q.text(","); q.breakable()
				7726	q.text("queue_id = ");
				7727	q.text("%#x" % self.queue_id)
				7728	q.breakable()
				7729	q.text('}')
				7730
				7731	stats_request.subtypes[5] = queue_stats_request
				7732
				7733	class role_reply(message):
				7734	version = 3
				7735	type = 25
				7736
				7737	def __init__(self, xid=None, role=None, generation_id=None):
				7738	if xid != None:
				7739	self.xid = xid
				7740	else:
				7741	self.xid = None
				7742	if role != None:
				7743	self.role = role
				7744	else:
				7745	self.role = 0
				7746	if generation_id != None:
				7747	self.generation_id = generation_id
				7748	else:
				7749	self.generation_id = 0
				7750	return
				7751
				7752	def pack(self):
				7753	packed = []
				7754	packed.append(struct.pack("!B", self.version))
				7755	packed.append(struct.pack("!B", self.type))
				7756	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				7757	packed.append(struct.pack("!L", self.xid))
				7758	packed.append(struct.pack("!L", self.role))
				7759	packed.append('\x00' * 4)
				7760	packed.append(struct.pack("!Q", self.generation_id))
				7761	length = sum([len(x) for x in packed])
				7762	packed[2] = struct.pack("!H", length)
				7763	return ''.join(packed)
				7764
				7765	@staticmethod
				7766	def unpack(reader):
				7767	obj = role_reply()
				7768	_version = reader.read("!B")[0]
				7769	assert(_version == 3)
				7770	_type = reader.read("!B")[0]
				7771	assert(_type == 25)
				7772	_length = reader.read("!H")[0]
				7773	orig_reader = reader
				7774	reader = orig_reader.slice(_length, 4)
				7775	obj.xid = reader.read("!L")[0]
				7776	obj.role = reader.read("!L")[0]
				7777	reader.skip(4)
				7778	obj.generation_id = reader.read("!Q")[0]
				7779	return obj
				7780
				7781	def __eq__(self, other):
				7782	if type(self) != type(other): return False
				7783	if self.xid != other.xid: return False
				7784	if self.role != other.role: return False
				7785	if self.generation_id != other.generation_id: return False
				7786	return True
				7787
				7788	def pretty_print(self, q):
				7789	q.text("role_reply {")
				7790	with q.group():
				7791	with q.indent(2):
				7792	q.breakable()
				7793	q.text("xid = ");
				7794	if self.xid != None:
				7795	q.text("%#x" % self.xid)
				7796	else:
				7797	q.text('None')
				7798	q.text(","); q.breakable()
				7799	q.text("role = ");
				7800	q.text("%#x" % self.role)
				7801	q.text(","); q.breakable()
				7802	q.text("generation_id = ");
				7803	q.text("%#x" % self.generation_id)
				7804	q.breakable()
				7805	q.text('}')
				7806
				7807	message.subtypes[25] = role_reply
				7808
				7809	class role_request(message):
				7810	version = 3
				7811	type = 24
				7812
				7813	def __init__(self, xid=None, role=None, generation_id=None):
				7814	if xid != None:
				7815	self.xid = xid
				7816	else:
				7817	self.xid = None
				7818	if role != None:
				7819	self.role = role
				7820	else:
				7821	self.role = 0
				7822	if generation_id != None:
				7823	self.generation_id = generation_id
				7824	else:
				7825	self.generation_id = 0
				7826	return
				7827
				7828	def pack(self):
				7829	packed = []
				7830	packed.append(struct.pack("!B", self.version))
				7831	packed.append(struct.pack("!B", self.type))
				7832	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				7833	packed.append(struct.pack("!L", self.xid))
				7834	packed.append(struct.pack("!L", self.role))
				7835	packed.append('\x00' * 4)
				7836	packed.append(struct.pack("!Q", self.generation_id))
				7837	length = sum([len(x) for x in packed])
				7838	packed[2] = struct.pack("!H", length)
				7839	return ''.join(packed)
				7840
				7841	@staticmethod
				7842	def unpack(reader):
				7843	obj = role_request()
				7844	_version = reader.read("!B")[0]
				7845	assert(_version == 3)
				7846	_type = reader.read("!B")[0]
				7847	assert(_type == 24)
				7848	_length = reader.read("!H")[0]
				7849	orig_reader = reader
				7850	reader = orig_reader.slice(_length, 4)
				7851	obj.xid = reader.read("!L")[0]
				7852	obj.role = reader.read("!L")[0]
				7853	reader.skip(4)
				7854	obj.generation_id = reader.read("!Q")[0]
				7855	return obj
				7856
				7857	def __eq__(self, other):
				7858	if type(self) != type(other): return False
				7859	if self.xid != other.xid: return False
				7860	if self.role != other.role: return False
				7861	if self.generation_id != other.generation_id: return False
				7862	return True
				7863
				7864	def pretty_print(self, q):
				7865	q.text("role_request {")
				7866	with q.group():
				7867	with q.indent(2):
				7868	q.breakable()
				7869	q.text("xid = ");
				7870	if self.xid != None:
				7871	q.text("%#x" % self.xid)
				7872	else:
				7873	q.text('None')
				7874	q.text(","); q.breakable()
				7875	q.text("role = ");
				7876	q.text("%#x" % self.role)
				7877	q.text(","); q.breakable()
				7878	q.text("generation_id = ");
				7879	q.text("%#x" % self.generation_id)
				7880	q.breakable()
				7881	q.text('}')
				7882
				7883	message.subtypes[24] = role_request
				7884
				7885	class role_request_failed_error_msg(error_msg):
				7886	version = 3
				7887	type = 1
				7888	err_type = 11
				7889
				7890	def __init__(self, xid=None, code=None, data=None):
				7891	if xid != None:
				7892	self.xid = xid
				7893	else:
				7894	self.xid = None
				7895	if code != None:
				7896	self.code = code
				7897	else:
				7898	self.code = 0
				7899	if data != None:
				7900	self.data = data
				7901	else:
				7902	self.data = ''
				7903	return
				7904
				7905	def pack(self):
				7906	packed = []
				7907	packed.append(struct.pack("!B", self.version))
				7908	packed.append(struct.pack("!B", self.type))
				7909	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				7910	packed.append(struct.pack("!L", self.xid))
				7911	packed.append(struct.pack("!H", self.err_type))
				7912	packed.append(struct.pack("!H", self.code))
				7913	packed.append(self.data)
				7914	length = sum([len(x) for x in packed])
				7915	packed[2] = struct.pack("!H", length)
				7916	return ''.join(packed)
				7917
				7918	@staticmethod
				7919	def unpack(reader):
				7920	obj = role_request_failed_error_msg()
				7921	_version = reader.read("!B")[0]
				7922	assert(_version == 3)
				7923	_type = reader.read("!B")[0]
				7924	assert(_type == 1)
				7925	_length = reader.read("!H")[0]
				7926	orig_reader = reader
				7927	reader = orig_reader.slice(_length, 4)
				7928	obj.xid = reader.read("!L")[0]
				7929	_err_type = reader.read("!H")[0]
				7930	assert(_err_type == 11)
				7931	obj.code = reader.read("!H")[0]
				7932	obj.data = str(reader.read_all())
				7933	return obj
				7934
				7935	def __eq__(self, other):
				7936	if type(self) != type(other): return False
				7937	if self.xid != other.xid: return False
				7938	if self.code != other.code: return False
				7939	if self.data != other.data: return False
				7940	return True
				7941
				7942	def pretty_print(self, q):
				7943	q.text("role_request_failed_error_msg {")
				7944	with q.group():
				7945	with q.indent(2):
				7946	q.breakable()
				7947	q.text("xid = ");
				7948	if self.xid != None:
				7949	q.text("%#x" % self.xid)
				7950	else:
				7951	q.text('None')
				7952	q.text(","); q.breakable()
				7953	q.text("code = ");
				7954	q.text("%#x" % self.code)
				7955	q.text(","); q.breakable()
				7956	q.text("data = ");
				7957	q.pp(self.data)
				7958	q.breakable()
				7959	q.text('}')
				7960
				7961	error_msg.subtypes[11] = role_request_failed_error_msg
				7962
				7963	class set_config(message):
				7964	version = 3
				7965	type = 9
				7966
				7967	def __init__(self, xid=None, flags=None, miss_send_len=None):
				7968	if xid != None:
				7969	self.xid = xid
				7970	else:
				7971	self.xid = None
				7972	if flags != None:
				7973	self.flags = flags
				7974	else:
				7975	self.flags = 0
				7976	if miss_send_len != None:
				7977	self.miss_send_len = miss_send_len
				7978	else:
				7979	self.miss_send_len = 0
				7980	return
				7981
				7982	def pack(self):
				7983	packed = []
				7984	packed.append(struct.pack("!B", self.version))
				7985	packed.append(struct.pack("!B", self.type))
				7986	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				7987	packed.append(struct.pack("!L", self.xid))
				7988	packed.append(struct.pack("!H", self.flags))
				7989	packed.append(struct.pack("!H", self.miss_send_len))
				7990	length = sum([len(x) for x in packed])
				7991	packed[2] = struct.pack("!H", length)
				7992	return ''.join(packed)
				7993
				7994	@staticmethod
				7995	def unpack(reader):
				7996	obj = set_config()
				7997	_version = reader.read("!B")[0]
				7998	assert(_version == 3)
				7999	_type = reader.read("!B")[0]
				8000	assert(_type == 9)
				8001	_length = reader.read("!H")[0]
				8002	orig_reader = reader
				8003	reader = orig_reader.slice(_length, 4)
				8004	obj.xid = reader.read("!L")[0]
				8005	obj.flags = reader.read("!H")[0]
				8006	obj.miss_send_len = reader.read("!H")[0]
				8007	return obj
				8008
				8009	def __eq__(self, other):
				8010	if type(self) != type(other): return False
				8011	if self.xid != other.xid: return False
				8012	if self.flags != other.flags: return False
				8013	if self.miss_send_len != other.miss_send_len: return False
				8014	return True
				8015
				8016	def pretty_print(self, q):
				8017	q.text("set_config {")
				8018	with q.group():
				8019	with q.indent(2):
				8020	q.breakable()
				8021	q.text("xid = ");
				8022	if self.xid != None:
				8023	q.text("%#x" % self.xid)
				8024	else:
				8025	q.text('None')
				8026	q.text(","); q.breakable()
				8027	q.text("flags = ");
				8028	q.text("%#x" % self.flags)
				8029	q.text(","); q.breakable()
				8030	q.text("miss_send_len = ");
				8031	q.text("%#x" % self.miss_send_len)
				8032	q.breakable()
				8033	q.text('}')
				8034
				8035	message.subtypes[9] = set_config
				8036
				8037	class switch_config_failed_error_msg(error_msg):
				8038	version = 3
				8039	type = 1
				8040	err_type = 10
				8041
				8042	def __init__(self, xid=None, code=None, data=None):
				8043	if xid != None:
				8044	self.xid = xid
				8045	else:
				8046	self.xid = None
				8047	if code != None:
				8048	self.code = code
				8049	else:
				8050	self.code = 0
				8051	if data != None:
				8052	self.data = data
				8053	else:
				8054	self.data = ''
				8055	return
				8056
				8057	def pack(self):
				8058	packed = []
				8059	packed.append(struct.pack("!B", self.version))
				8060	packed.append(struct.pack("!B", self.type))
				8061	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				8062	packed.append(struct.pack("!L", self.xid))
				8063	packed.append(struct.pack("!H", self.err_type))
				8064	packed.append(struct.pack("!H", self.code))
				8065	packed.append(self.data)
				8066	length = sum([len(x) for x in packed])
				8067	packed[2] = struct.pack("!H", length)
				8068	return ''.join(packed)
				8069
				8070	@staticmethod
				8071	def unpack(reader):
				8072	obj = switch_config_failed_error_msg()
				8073	_version = reader.read("!B")[0]
				8074	assert(_version == 3)
				8075	_type = reader.read("!B")[0]
				8076	assert(_type == 1)
				8077	_length = reader.read("!H")[0]
				8078	orig_reader = reader
				8079	reader = orig_reader.slice(_length, 4)
				8080	obj.xid = reader.read("!L")[0]
				8081	_err_type = reader.read("!H")[0]
				8082	assert(_err_type == 10)
				8083	obj.code = reader.read("!H")[0]
				8084	obj.data = str(reader.read_all())
				8085	return obj
				8086
				8087	def __eq__(self, other):
				8088	if type(self) != type(other): return False
				8089	if self.xid != other.xid: return False
				8090	if self.code != other.code: return False
				8091	if self.data != other.data: return False
				8092	return True
				8093
				8094	def pretty_print(self, q):
				8095	q.text("switch_config_failed_error_msg {")
				8096	with q.group():
				8097	with q.indent(2):
				8098	q.breakable()
				8099	q.text("xid = ");
				8100	if self.xid != None:
				8101	q.text("%#x" % self.xid)
				8102	else:
				8103	q.text('None')
				8104	q.text(","); q.breakable()
				8105	q.text("code = ");
				8106	q.text("%#x" % self.code)
				8107	q.text(","); q.breakable()
				8108	q.text("data = ");
				8109	q.pp(self.data)
				8110	q.breakable()
				8111	q.text('}')
				8112
				8113	error_msg.subtypes[10] = switch_config_failed_error_msg
				8114
				8115	class table_mod(message):
				8116	version = 3
				8117	type = 17
				8118
				8119	def __init__(self, xid=None, table_id=None, config=None):
				8120	if xid != None:
				8121	self.xid = xid
				8122	else:
				8123	self.xid = None
				8124	if table_id != None:
				8125	self.table_id = table_id
				8126	else:
				8127	self.table_id = 0
				8128	if config != None:
				8129	self.config = config
				8130	else:
				8131	self.config = 0
				8132	return
				8133
				8134	def pack(self):
				8135	packed = []
				8136	packed.append(struct.pack("!B", self.version))
				8137	packed.append(struct.pack("!B", self.type))
				8138	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				8139	packed.append(struct.pack("!L", self.xid))
				8140	packed.append(struct.pack("!B", self.table_id))
				8141	packed.append('\x00' * 3)
				8142	packed.append(struct.pack("!L", self.config))
				8143	length = sum([len(x) for x in packed])
				8144	packed[2] = struct.pack("!H", length)
				8145	return ''.join(packed)
				8146
				8147	@staticmethod
				8148	def unpack(reader):
				8149	obj = table_mod()
				8150	_version = reader.read("!B")[0]
				8151	assert(_version == 3)
				8152	_type = reader.read("!B")[0]
				8153	assert(_type == 17)
				8154	_length = reader.read("!H")[0]
				8155	orig_reader = reader
				8156	reader = orig_reader.slice(_length, 4)
				8157	obj.xid = reader.read("!L")[0]
				8158	obj.table_id = reader.read("!B")[0]
				8159	reader.skip(3)
				8160	obj.config = reader.read("!L")[0]
				8161	return obj
				8162
				8163	def __eq__(self, other):
				8164	if type(self) != type(other): return False
				8165	if self.xid != other.xid: return False
				8166	if self.table_id != other.table_id: return False
				8167	if self.config != other.config: return False
				8168	return True
				8169
				8170	def pretty_print(self, q):
				8171	q.text("table_mod {")
				8172	with q.group():
				8173	with q.indent(2):
				8174	q.breakable()
				8175	q.text("xid = ");
				8176	if self.xid != None:
				8177	q.text("%#x" % self.xid)
				8178	else:
				8179	q.text('None')
				8180	q.text(","); q.breakable()
				8181	q.text("table_id = ");
				8182	q.text("%#x" % self.table_id)
				8183	q.text(","); q.breakable()
				8184	q.text("config = ");
				8185	q.text("%#x" % self.config)
				8186	q.breakable()
				8187	q.text('}')
				8188
				8189	message.subtypes[17] = table_mod
				8190
				8191	class table_mod_failed_error_msg(error_msg):
				8192	version = 3
				8193	type = 1
				8194	err_type = 8
				8195
				8196	def __init__(self, xid=None, code=None, data=None):
				8197	if xid != None:
				8198	self.xid = xid
				8199	else:
				8200	self.xid = None
				8201	if code != None:
				8202	self.code = code
				8203	else:
				8204	self.code = 0
				8205	if data != None:
				8206	self.data = data
				8207	else:
				8208	self.data = ''
				8209	return
				8210
				8211	def pack(self):
				8212	packed = []
				8213	packed.append(struct.pack("!B", self.version))
				8214	packed.append(struct.pack("!B", self.type))
				8215	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				8216	packed.append(struct.pack("!L", self.xid))
				8217	packed.append(struct.pack("!H", self.err_type))
				8218	packed.append(struct.pack("!H", self.code))
				8219	packed.append(self.data)
				8220	length = sum([len(x) for x in packed])
				8221	packed[2] = struct.pack("!H", length)
				8222	return ''.join(packed)
				8223
				8224	@staticmethod
				8225	def unpack(reader):
				8226	obj = table_mod_failed_error_msg()
				8227	_version = reader.read("!B")[0]
				8228	assert(_version == 3)
				8229	_type = reader.read("!B")[0]
				8230	assert(_type == 1)
				8231	_length = reader.read("!H")[0]
				8232	orig_reader = reader
				8233	reader = orig_reader.slice(_length, 4)
				8234	obj.xid = reader.read("!L")[0]
				8235	_err_type = reader.read("!H")[0]
				8236	assert(_err_type == 8)
				8237	obj.code = reader.read("!H")[0]
				8238	obj.data = str(reader.read_all())
				8239	return obj
				8240
				8241	def __eq__(self, other):
				8242	if type(self) != type(other): return False
				8243	if self.xid != other.xid: return False
				8244	if self.code != other.code: return False
				8245	if self.data != other.data: return False
				8246	return True
				8247
				8248	def pretty_print(self, q):
				8249	q.text("table_mod_failed_error_msg {")
				8250	with q.group():
				8251	with q.indent(2):
				8252	q.breakable()
				8253	q.text("xid = ");
				8254	if self.xid != None:
				8255	q.text("%#x" % self.xid)
				8256	else:
				8257	q.text('None')
				8258	q.text(","); q.breakable()
				8259	q.text("code = ");
				8260	q.text("%#x" % self.code)
				8261	q.text(","); q.breakable()
				8262	q.text("data = ");
				8263	q.pp(self.data)
				8264	q.breakable()
				8265	q.text('}')
				8266
				8267	error_msg.subtypes[8] = table_mod_failed_error_msg
				8268
				8269	class table_stats_reply(stats_reply):
				8270	version = 3
				8271	type = 19
				8272	stats_type = 3
				8273
				8274	def __init__(self, xid=None, flags=None, entries=None):
				8275	if xid != None:
				8276	self.xid = xid
				8277	else:
				8278	self.xid = None
				8279	if flags != None:
				8280	self.flags = flags
				8281	else:
				8282	self.flags = 0
				8283	if entries != None:
				8284	self.entries = entries
				8285	else:
				8286	self.entries = []
				8287	return
				8288
				8289	def pack(self):
				8290	packed = []
				8291	packed.append(struct.pack("!B", self.version))
				8292	packed.append(struct.pack("!B", self.type))
				8293	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				8294	packed.append(struct.pack("!L", self.xid))
				8295	packed.append(struct.pack("!H", self.stats_type))
				8296	packed.append(struct.pack("!H", self.flags))
				8297	packed.append('\x00' * 4)
				8298	packed.append(loxi.generic_util.pack_list(self.entries))
				8299	length = sum([len(x) for x in packed])
				8300	packed[2] = struct.pack("!H", length)
				8301	return ''.join(packed)
				8302
				8303	@staticmethod
				8304	def unpack(reader):
				8305	obj = table_stats_reply()
				8306	_version = reader.read("!B")[0]
				8307	assert(_version == 3)
				8308	_type = reader.read("!B")[0]
				8309	assert(_type == 19)
				8310	_length = reader.read("!H")[0]
				8311	orig_reader = reader
				8312	reader = orig_reader.slice(_length, 4)
				8313	obj.xid = reader.read("!L")[0]
				8314	_stats_type = reader.read("!H")[0]
				8315	assert(_stats_type == 3)
				8316	obj.flags = reader.read("!H")[0]
				8317	reader.skip(4)
				8318	obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.table_stats_entry.unpack)
				8319	return obj
				8320
				8321	def __eq__(self, other):
				8322	if type(self) != type(other): return False
				8323	if self.xid != other.xid: return False
				8324	if self.flags != other.flags: return False
				8325	if self.entries != other.entries: return False
				8326	return True
				8327
				8328	def pretty_print(self, q):
				8329	q.text("table_stats_reply {")
				8330	with q.group():
				8331	with q.indent(2):
				8332	q.breakable()
				8333	q.text("xid = ");
				8334	if self.xid != None:
				8335	q.text("%#x" % self.xid)
				8336	else:
				8337	q.text('None')
				8338	q.text(","); q.breakable()
				8339	q.text("flags = ");
				8340	q.text("%#x" % self.flags)
				8341	q.text(","); q.breakable()
				8342	q.text("entries = ");
				8343	q.pp(self.entries)
				8344	q.breakable()
				8345	q.text('}')
				8346
				8347	stats_reply.subtypes[3] = table_stats_reply
				8348
				8349	class table_stats_request(stats_request):
				8350	version = 3
				8351	type = 18
				8352	stats_type = 3
				8353
				8354	def __init__(self, xid=None, flags=None):
				8355	if xid != None:
				8356	self.xid = xid
				8357	else:
				8358	self.xid = None
				8359	if flags != None:
				8360	self.flags = flags
				8361	else:
				8362	self.flags = 0
				8363	return
				8364
				8365	def pack(self):
				8366	packed = []
				8367	packed.append(struct.pack("!B", self.version))
				8368	packed.append(struct.pack("!B", self.type))
				8369	packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
				8370	packed.append(struct.pack("!L", self.xid))
				8371	packed.append(struct.pack("!H", self.stats_type))
				8372	packed.append(struct.pack("!H", self.flags))
				8373	packed.append('\x00' * 4)
				8374	length = sum([len(x) for x in packed])
				8375	packed[2] = struct.pack("!H", length)
				8376	return ''.join(packed)
				8377
				8378	@staticmethod
				8379	def unpack(reader):
				8380	obj = table_stats_request()
				8381	_version = reader.read("!B")[0]
				8382	assert(_version == 3)
				8383	_type = reader.read("!B")[0]
				8384	assert(_type == 18)
				8385	_length = reader.read("!H")[0]
				8386	orig_reader = reader
				8387	reader = orig_reader.slice(_length, 4)
				8388	obj.xid = reader.read("!L")[0]
				8389	_stats_type = reader.read("!H")[0]
				8390	assert(_stats_type == 3)
				8391	obj.flags = reader.read("!H")[0]
				8392	reader.skip(4)
				8393	return obj
				8394
				8395	def __eq__(self, other):
				8396	if type(self) != type(other): return False
				8397	if self.xid != other.xid: return False
				8398	if self.flags != other.flags: return False
				8399	return True
				8400
				8401	def pretty_print(self, q):
				8402	q.text("table_stats_request {")
				8403	with q.group():
				8404	with q.indent(2):
				8405	q.breakable()
				8406	q.text("xid = ");
				8407	if self.xid != None:
				8408	q.text("%#x" % self.xid)
				8409	else:
				8410	q.text('None')
				8411	q.text(","); q.breakable()
				8412	q.text("flags = ");
				8413	q.text("%#x" % self.flags)
				8414	q.breakable()
				8415	q.text('}')
				8416
				8417	stats_request.subtypes[3] = table_stats_request
				8418
				8419
				8420	def parse_header(buf):
				8421	if len(buf) < 8:
				8422	raise loxi.ProtocolError("too short to be an OpenFlow message")
				8423	return struct.unpack_from("!BBHL", buf)
				8424
				8425	def parse_message(buf):
				8426	msg_ver, msg_type, msg_len, msg_xid = parse_header(buf)
				8427	if msg_ver != ofp.OFP_VERSION and msg_type != ofp.OFPT_HELLO:
				8428	raise loxi.ProtocolError("wrong OpenFlow version (expected %d, got %d)" % (ofp.OFP_VERSION, msg_ver))
				8429	if len(buf) != msg_len:
				8430	raise loxi.ProtocolError("incorrect message size")
				8431	return message.unpack(loxi.generic_util.OFReader(buf))