Navigation

← Previous Changeset
Next Changeset →

Changeset 448

Timestamp:

02/20/03 02:05:44 (6 years ago)

Author:

sholloway

Message:

*** empty log message ***

Files:

trunk/RBFoundation/RBFoundation/XMLNode.py (modified) (2 diffs)
trunk/RBTelepathy/RBTelepathy/Handlers/__init__.py (modified) (3 diffs)
trunk/RBTelepathy/RBTelepathy/Packet/Elements.py (modified) (10 diffs)
trunk/RBTelepathy/RBTelepathy/Packet/StreamElements.py (modified) (8 diffs)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

trunk/RBFoundation/RBFoundation/XMLNode.py

r447	r448
132	132	"""Sets child element at self.elem[key] = value."""
133	133	if isinstance(key, (int, long, _SliceType)):
134		return self.elems.__setitem__(args, *kw)
	134	return self.elems.__setitem__(key, args, *kw)
135	135	else:
136	136	raise TypeError, "Cannot set node elemenets with non integer key item operations"
…	…
138	138	"""Removes all matching child elements of xmlnode. See delelems."""
139	139	if isinstance(key, (int, long, _SliceType)):
140		return self.elems.__delitem__(args, *kw)
	140	return self.elems.__delitem__(key, args, *kw)
141	141	else:
142	142	self.delelems(key, args, *kw)

trunk/RBTelepathy/RBTelepathy/Handlers/init.py

r443	r448
35	35	documentation is painfully wrong, here is a short pseudocode stub::
36	36
37		class PacketElementToBuild(RBME~~lements.RootElementBase, XMLClassBuilderObject~~Mixin):
	37	class PacketElementToBuild(RBME.RootElementBase, XMLClassBuilderBaseMixin):
38	38	NamespaceSynonyms = {
39	39	'shortname': 'an.extremely.long.xmlns.that.is.used.frequently',
…	…
46	46	None: ElementFactory(...), # For defaults
47	47	})
48		~~_xmlChildFactory = XMLClassBuilderObjectMixin._xmlChildFactory~~
49	48
50	49	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
…	…
81	80	from RBMessaging import ErrorTypes
82	81	from RBMBuilder import *
83		import RBMElements
84		import RBMStreamElements
	82	import RBMElements as RBME
	83	import RBMStreamElements as RBMStream
85	84	import URIAddress
86	85

trunk/RBTelepathy/RBTelepathy/Packet/Elements.py

r442	r448
24	24	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
25	25
26		from RBFoundation~~.XMLProduction import NodeXML~~
	26	from RBFoundation import XMLProduction
27	27	from RBMBuilder import RBMessagingNamespace
28	28	import URIAddress
…	…
32	32	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
33	33
34		class PacketElementBase(NodeXML):
	34	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	35
	36	class PacketElementBase(XMLProduction.xmlnode):
35	37	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
36	38	#~ Constants / Variables / Etc.
37	39	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
38	40
39		__slots__ = [~~'_owner', 'ElementFactories'~~]
	41	__slots__ = []
40	42
41	43	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
…	…
43	45	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
44	46
45		def __init__(self, owner, args, *kw):
46		NodeXML.__init__(self, owner, args, *kw)
47		self._owner = owner
48
49		def OnUpdateContent(self):
	47	def UpdateContent(self, parent, args, *kw):
	48	for node in self.iternodes():
	49	node.UpdateContent(self, args, *kw)
	50	self.OnUpdateContent(parent, args, *kw)
	51
	52	def OnUpdateContent(self, parent, root):
50	53	pass
51
52		~~def _toXML(self, args, *kw):~~
53		~~self.OnUpdateContent()~~
54		~~return NodeXML._toXML(self, args, *kw)~~
55	54
56	55	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
…	…
63	62	class RootElementBase(PacketElementBase):
64	63	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
65		~~#~ Constants / Variables / Etc.~~
66		~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
67
68		~~__slots__ = ['ElementFactories']~~
69
70		~~#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
71	64	#~ Public Methods
72	65	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
…	…
78	71
79	72	def GetStreamHeader(self):
80		return self._toXML()
	73	self.UpdateContent(self, self)
	74	return self.toxml()
81	75
82	76	def GetStreamData(self):
…	…
90	84	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
91	85
92		__slots__ = ['datastreams'~~, '_OnStreamCurrent'~~]
	86	__slots__ = ['datastreams']
93	87
94	88	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
…	…
96	90	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
97	91
98		def _~~xmlInitStarted(self):~~
	92	def __init__(self, args, *kw):
99	93	self.datastreams = []
100
101		def _xmlInitComplete(self):
102		self._OnStreamCurrent = [x for x in self.datastreams]
	94	RootElementBase.__init__(self, args, *kw)
103	95
104	96	def OnStreamData(self, data, OnPacketComplete=None):
105		while self._OnStreamCurrent:
106		current = self._OnStreamCurrent[0]
107		data = current.OnStreamData(data)
	97	while self.datastreams:
	98	data = self.datastreams[0].OnStreamData(data)
108	99	if data is None:
109		return None
110		else:
111		self._OnStreamCurrent.pop(0)
112		del self._OnStreamCurrent
	100	# More data to get for this item
	101	return None
	102	else:
	103	# We're done with this one... on to the next
	104	self.datastreams.pop(0)
113	105	if OnPacketComplete is not None:
114	106	OnPacketComplete(self)
115	107	return data
116	108
	109	def toxml(self, args, *kw):
	110	self.datastreams = []
	111	self.UpdateContent(self, self)
	112	return RootElementBase.toxml(self, args, *kw)
	113
117	114	def GetStreamHeader(self):
118		return self.~~_toXML~~()
	115	return self.toxml()
119	116
120	117	def GetStreamData(self):
…	…
124	121	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
125	122
126		class RouteableRootElement(RootElementBase):
127		#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
128		#~ Constants / Variables / Etc.
129		#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
130
131		__slots__ = []
132
133		#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
134		#~ Public Methods
135		#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
136
137		def GetAddresses(self, nodename='to'):
138		existing = self.iternodes(nodename, RBMessagingNamespace)
139		result = [each.addr for each in existing]
140		return result
141
142		def SetAddresses(self, addresses, nodename='to'):
143		print "XXX: RouteableRootElement.SetAddresses needs work"
144		# Figure out which addresses we are to maintain
145		#existing = self.iternodes(nodename, RBMessagingNamespace)
146		#if existing:
147		# idxAddresses = self._getElementIndex(existing[0])
148		#else: idxAddresses = 0
149		#idxAddresses = 0
150
151		#existing = [(each.addr, each) for each in existing if each.addr in addresses]
152		#existing = dict(existing)
153
154		## Remove all existing addresses
155		#self.delnodes(nodename, RBMessagingNamespace)
156
157		#for address in addresses:
158		# element = existing.get(address)
159		# if element is None:
160		# # Create a new element
161		# element = self.addnode(nodename, self.namespace, klass=URIAddressElement)
162		# element.addr = address
163		# element._xmlInitStarted()
164		# element._xmlInitComplete()
165		# else:
166		# self._addObjectifiedElement(element)
167		#
168		# self._elements.insert(idxAddresses, self._elements.pop())
169
170		#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
171
172		class URIAddressElement(RootElementBase):
	123	class URIAddressElement(PacketElementBase):
173	124	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
174	125	#~ Constants / Variables / Etc.
…	…
181	132	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
182	133
183		def OnUpdateContent(self):
184		RootElementBase.OnUpdateContent(self)
	134	def OnUpdateContent(self, parent, root):
185	135	try: self.attrs['addr'] = str(self._addr)
186	136	except AttributeError: pass
	137
	138	def toxml(self, args, *kw):
	139	self.OnUpdateContent(None, None)
	140	return PacketElementBase.toxml(self, args, *kw)
187	141
188	142	#~ addr property ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
…	…
198	152	addr = property(_get_addr, _set_addr, _del_addr)
199	153
	154	#~ Alias for URIAddressElement ~~~~~~~~~~~~~~~~~~~~~~
	155	URIAddr = URIAddressElement
	156
	157	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	158	#~ XML Processing Adaptors
	159	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	160
	161	#class XMLAdaptor(XMLProduction.NodeXMLAdaptor): pass
	162	#class Factory(XMLProduction.XMLNodeFactory): xmladaptor = XMLAdaptor
	163	XMLAdaptor = XMLProduction.NodeXMLAdaptor
	164	Factory = XMLProduction.XMLNodeFactory
	165
	166	class RootXMLAdaptor(XMLAdaptor):
	167	def _xmlChildFactory(self, owner, parent, node, attributes, namespacemap):
	168	try: GetEF = self.result.ElementFactorySet._GetElementFactory
	169	except AttributeError: pass
	170	else: return GetEF(owner, parent, node, attributes, namespacemap)
	171
	172	class RootFactory(Factory):
	173	xmladaptor = RootXMLAdaptor
	174

trunk/RBTelepathy/RBTelepathy/Packet/StreamElements.py

r442	r448
24	24	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
25	25
26		from RBMElements import PacketElementBase
	26	from RBMessaging import ErrorTypes
	27	from RBMElements import PacketElementBase, Factory, XMLAdaptor
27	28
28	29	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
…	…
32	33	class StreamBase(PacketElementBase):
33	34	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
34		#~ ~~Methods~~
	35	#~ Constants / Variables / Etc.
35	36	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
36	37
37		def _xmlInitStarted(self):
38		self.StreamContent = ''
39		self._owner.datastreams.append(self)
	38	__slots__ = ['_content']
	39	default_node = 'stream'
	40
	41	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	42
	43	def OnUpdateContent(self, parent, root):
	44	PacketElementBase.OnUpdateContent(self, parent, root)
	45	root.datastreams.append(self)
	46
	47	#~ content property ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	48
	49	def _get_content(self):
	50	try:
	51	return self._content
	52	except AttributeError:
	53	self._content = ''
	54	return self._content
	55	def _set_content(self, content):
	56	self._content = content
	57	def _del_content(self, content):
	58	del self._content
	59	content = property(_get_content,_set_content,_del_content)
40	60
41	61	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
…	…
46	66	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
47	67
48		_default_attributes = {
	68	default_attributes = {
49	69	'format':'length',
50	70	#'size': None,
51	71	}
	72	__slots__ = ['_size']
52	73
53	74	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
…	…
55	76	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
56	77
57		def _xmlInitStarted(self):
58		StreamBase._xmlInitStarted(self)
59		self.ContentLen = int(self.attrs['size'])
60
61		def OnUpdateContent(self):
62		StreamBase.OnUpdateContent(self)
63		self.attrs['size'] = str(len(self.StreamContent))
	78	def OnUpdateContent(self, parent, root):
	79	StreamBase.OnUpdateContent(self, parent, root)
	80	size = len(self.content)
	81	self.size = size
	82	self.attrs['size'] = str(size)
64	83
65	84	def OnStreamData(self, data):
66		length = self.~~ContentLen - len(self.StreamC~~ontent)
	85	length = self.size - len(self.content)
67	86	if length > len(data):
68		self.~~StreamC~~ontent += data
	87	self.content += data
69	88	else:
70		self.~~StreamC~~ontent += data[:length]
	89	self.content += data[:length]
71	90	return data[length:]
72	91
73	92	def GetStreamData(self):
74		return self.StreamContent
	93	return self.content
	94
	95	#~ Size Property ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	96
	97	def _get_size(self):
	98	try:
	99	return self._size
	100	except AttributeError:
	101	try:
	102	self._size = int(self.attrs['size'])
	103	return self._size
	104	except KeyError:
	105	raise ErrorTypes.PacketMalformedError('Length stream element requires attribute "size".', shutdown=True)
	106	except ValueError:
	107	raise ErrorTypes.PacketMalformedError('Length stream element attribute "size" is invalid.', shutdown=True)
	108	def _set_size(self, value): self._size = value
	109	def _del_size(self, value): del self._size
	110	size = property(_get_size, _set_size, _del_size)
75	111
76	112	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
…	…
81	117	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
82	118
83		_default_attributes = {
	119	default_attributes = {
84	120	'format':'terminated',
85	121	'ordinal':'4',
86	122	}
	123	__slots__ = ['_ordinal']
87	124
88	125	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
…	…
90	127	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
91	128
92		def _xmlInitStarted(self):
93		StreamBase._xmlInitStarted(self)
94		self.terminator = chr(int(self.attrs['ordinal']))
95
96		def OnUpdateContent(self):
97		StreamBase.OnUpdateContent(self)
98		self.attrs['ordinal'] = str(ord(self.terminator))
	129	def OnUpdateContent(self, parent, root):
	130	StreamBase.OnUpdateContent(self, parent, root)
	131	self.attrs['ordinal'] = str(self.ordinal)
99	132
100	133	def OnStreamData(self, data):
…	…
103	136	except ValueError:
104	137	extra = None
105		self.~~StreamC~~ontent += data
	138	self.content += data
106	139	return extra
107	140
108	141	def GetStreamData(self):
109		return self.StreamContent + self.terminator
	142	return self.content + self.terminator
	143
	144	#~ Size Property ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	145
	146	def _get_ordinal(self):
	147	try:
	148	return self._ordinal
	149	except AttributeError:
	150	try:
	151	self._ordinal = int(self.attrs['ordinal'])
	152	return self._ordinal
	153	except KeyError:
	154	raise ErrorTypes.PacketMalformedError('Terminated stream element requires attribute "ordinal".', shutdown=True)
	155	except ValueError:
	156	raise ErrorTypes.PacketMalformedError('Terminated stream element attribute "ordinal" is invalid.', shutdown=True)
	157	def _set_ordinal(self, value): self._ordinal = value
	158	def _del_ordinal(self, value): del self._ordinal
	159	ordinal = property(_get_ordinal, _set_ordinal, _del_ordinal)
	160
	161	def _get_terminator(self): return chr(self._ordinal)
	162	def _set_terminator(self, value): self._ordinal = ord(value)
	163	def _del_terminator(self, value): del self._ordinal
	164	terminator = property(_get_terminator, _set_terminator, _del_terminator)
110	165
111	166	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
112	167
113		class StreamFormatFactory(object):
	168	class XMLDataStreamAdaptor(XMLAdaptor):
	169	def __init__(self, owner, args, *kw):
	170	XMLAdaptor.__init__(self, owner, args, *kw)
	171	owner.result.datastreams.append(self.result)
	172
	173	class StreamFormatFactory(Factory):
114	174	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
115	175	#~ Constants / Variables / Etc.
…	…
126	186	}
127	187
	188	xmladaptor = XMLDataStreamAdaptor
	189
128	190	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
129	191	#~ Public Methods
130	192	#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
131	193
132		def ~~__call__(self, owner, parent, node, attributes, namespacemap~~):
	194	def BuildNode(self, owner, parent, node, attributes, namespacemap, args, *kw):
133	195	format = attributes.get('format')
134		return self.StreamFormatTable[format]
	196	kw['nodebuilder'] = self.StreamFormatTable[format]
	197	return self.xmladaptor(owner, parent, node, attributes, namespacemap, args, *kw)
135	198

Download in other formats: