websrv-python.xsl@ 35691

Last change on this file since 35691 was 31117, checked in by vboxsync, 14 years ago
Python WS: generate code compatible with newer ZSI
Property svn:eol-style set to `native`
File size: 27.7 KB

Line
1	<xsl:stylesheet version = '1.0'
2	xmlns:xsl='http://www.w3.org/1999/XSL/Transform'
3	xmlns:vbox="http://www.virtualbox.org/">
4
5	<!--
6
7	websrv-python.xsl:
8	XSLT stylesheet that generates VirtualBox_services.py from
9	VirtualBox.xidl. This Python file represents our
10	web service API. Depends on WSDL file for actual SOAP bindings.
11
12	Copyright (C) 2008-2010 Oracle Corporation
13
14	This file is part of VirtualBox Open Source Edition (OSE), as
15	available from http://www.virtualbox.org. This file is free software;
16	you can redistribute it and/or modify it under the terms of the GNU
17	General Public License (GPL) as published by the Free Software
18	Foundation, in version 2 as it comes in the "COPYING" file of the
19	VirtualBox OSE distribution. VirtualBox OSE is distributed in the
20	hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
21	-->
22
23
24	<xsl:output
25	method="text"
26	version="1.0"
27	encoding="utf-8"
28	indent="no"/>
29
30	<xsl:include href="websrv-shared.inc.xsl" />
31
32	<xsl:variable name="G_setSuppressedInterfaces"
33	select="//interface[@wsmap='suppress']" />
34
35	<xsl:template name="emitConvertedType">
36	<xsl:param name="ifname" />
37	<xsl:param name="methodname" />
38	<xsl:param name="type" />
39	<xsl:choose>
40	<xsl:when test="$type='wstring'">String</xsl:when>
41	<xsl:when test="$type='uuid'">String</xsl:when>
42	<xsl:when test="$type='boolean'">Boolean</xsl:when>
43	<xsl:when test="$type='unsigned long'">UnsignedInt</xsl:when>
44	<xsl:when test="$type='double'">Double</xsl:when>
45	<xsl:when test="$type='float'">Float</xsl:when>
46	<xsl:when test="$type='long'">Int</xsl:when>
47	<xsl:when test="$type='long long'">Long</xsl:when>
48	<xsl:when test="$type='short'">Short</xsl:when>
49	<xsl:when test="$type='unsigned short'">UnsignedShort</xsl:when>
50	<xsl:when test="$type='unsigned long long'">UnsignedLong</xsl:when>
51	<xsl:when test="$type='result'">UnsignedInt</xsl:when>
52	<xsl:when test="$type='octet'">Octet</xsl:when>
53	<xsl:when test="$type='$unknown'">IUnknown</xsl:when>
54	<xsl:when test="$type='$dispatched'">IUnknown</xsl:when>
55	<xsl:otherwise><xsl:value-of select="$type" /></xsl:otherwise>
56	</xsl:choose>
57	</xsl:template>
58
59	<xsl:template name="emitOutParam">
60	<xsl:param name="ifname" />
61	<xsl:param name="methodname" />
62	<xsl:param name="type" />
63	<xsl:param name="value" />
64	<xsl:param name="safearray" />
65
66	<xsl:call-template name="emitConvertedType">
67	<xsl:with-param name="ifname" select="$ifname" />
68	<xsl:with-param name="methodname" select="$methodname" />
69	<xsl:with-param name="type" select="$type" />
70	</xsl:call-template>
71	<xsl:text>(</xsl:text>
72	<xsl:text>self.mgr,</xsl:text>
73	<xsl:value-of select="$value"/>
74	<xsl:if test="$safearray='yes'">
75	<xsl:value-of select="', True'"/>
76	</xsl:if>
77	<xsl:text>)</xsl:text>
78	</xsl:template>
79
80
81	<xsl:template name="emitGetAttribute">
82	<xsl:param name="ifname" />
83	<xsl:param name="attrname" />
84	<xsl:param name="attrtype" />
85	<xsl:param name="attrsafearray" />
86	<xsl:variable name="fname"><xsl:call-template name="makeGetterName"><xsl:with-param name="attrname" select="$attrname"/></xsl:call-template> </xsl:variable>
87	def <xsl:value-of select="$fname"/>(self):
88	req=<xsl:value-of select="$ifname"/>_<xsl:value-of select="$fname"/>RequestMsg()
89	req._this=self.handle
90	val=self.mgr.getPort().<xsl:value-of select="$ifname"/>_<xsl:value-of select="$fname"/>(req)
91	<xsl:text>return </xsl:text>
92	<xsl:call-template name="emitOutParam">
93	<xsl:with-param name="ifname" select="$ifname" />
94	<xsl:with-param name="methodname" select="@name" />
95	<xsl:with-param name="type" select="$attrtype" />
96	<xsl:with-param name="value" select="concat('val.','_returnval')" />
97	<xsl:with-param name="safearray" select="@safearray"/>
98	</xsl:call-template>
99	</xsl:template>
100
101	<xsl:template name="emitSetAttribute">
102	<xsl:param name="ifname" />
103	<xsl:param name="attrname" />
104	<xsl:param name="attrtype" />
105	<xsl:param name="attrsafearray" />
106	<xsl:variable name="fname"><xsl:call-template name="makeSetterName"><xsl:with-param name="attrname" select="$attrname"/></xsl:call-template> </xsl:variable>
107	def <xsl:value-of select="$fname"/>(self, value):
108	req=<xsl:value-of select="$ifname"/>_<xsl:value-of select="$fname"/>RequestMsg()
109	req._this=self.handle
110	if type(value) in [int, bool, basestring, str]:
111	req._<xsl:value-of select="$attrname"/> = value
112	else:
113	req._<xsl:value-of select="$attrname"/> = value.handle
114	self.mgr.getPort().<xsl:value-of select="$ifname"/>_<xsl:value-of select="$fname"/>(req)
115	</xsl:template>
116
117	<xsl:template name="collection">
118	<xsl:variable name="cname"><xsl:value-of select="@name" /></xsl:variable>
119	<xsl:variable name="ename"><xsl:value-of select="@type" /></xsl:variable>
120	class <xsl:value-of select="$cname"/>:
121	def __init__(self, mgr, array):
122	self.array = array
123	self.mgr = mgr
124
125	def __next(self):
126	return self.array.__next()
127
128	def __size(self):
129	return self.array._array.__size()
130
131	def __len__(self):
132	return self.array._array.__len__()
133
134	def __getitem__(self, index):
135	return <xsl:value-of select="$ename"/>(self.mgr, self.array._array[index])
136
137	</xsl:template>
138
139
140	<xsl:template name="computeExtends">
141	<xsl:param name="base" />
142
143	<xsl:choose>
144	<xsl:when test="($base = '$unknown') or ($base = '$dispatched')">
145	<xsl:value-of select="'IUnknown'"/>
146	</xsl:when>
147	<xsl:when test="($base = '$errorinfo') ">
148	<xsl:value-of select="'IUnknown'"/>
149	</xsl:when>
150	<xsl:otherwise>
151	<xsl:value-of select="$base"/>
152	</xsl:otherwise>
153	</xsl:choose>
154	</xsl:template>
155
156	<xsl:template name="interface">
157	<xsl:variable name="base">
158	<xsl:call-template name="computeExtends">
159	<xsl:with-param name="base" select="@extends" />
160	</xsl:call-template>
161	</xsl:variable>
162	<xsl:variable name="ifname"><xsl:value-of select="@name" /></xsl:variable>
163
164	class <xsl:value-of select="$ifname"/>(<xsl:value-of select="$base" />):
165	def __init__(self, mgr, handle, isarray = False):
166	self.mgr = mgr
167	if handle is None:
168	raise Exception("bad handle: "+str(handle))
169	self.handle = handle
170	self.isarray = isarray
171	<!--
172	This doesn't work now
173	mgr.register(handle)
174
175	def __del__(self):
176	mgr.unregister(self.handle)
177	-->
178	def releaseRemote(self):
179	try:
180	req=IManagedObjectRef_releaseRequestMsg()
181	req._this=handle
182	self.mgr.getPort().IManagedObjectRef_release(req)
183	except:
184	pass
185
186	def __next(self):
187	if self.isarray:
188	return self.handle.__next()
189	raise TypeError, "iteration over non-sequence"
190
191	def __size(self):
192	if self.isarray:
193	return self.handle.__size()
194	raise TypeError, "iteration over non-sequence"
195
196	def __len__(self):
197	if self.isarray:
198	return self.handle.__len__()
199	raise TypeError, "iteration over non-sequence"
200
201	def __getitem__(self, index):
202	if self.isarray:
203	return <xsl:value-of select="$ifname" />(self.mgr, self.handle[index])
204	raise TypeError, "iteration over non-sequence"
205
206	def __str__(self):
207	return self.handle
208
209	def isValid(self):
210	return self.handle != None and self.handle != ''
211
212	def __getattr__(self,name):
213	hndl = <xsl:value-of select="$ifname" />._Attrs_.get(name, None)
214	if hndl != None:
215	if hndl[0] != None:
216	return hndl[0](self)
217	else:
218	raise AttributeError
219	else:
220	return <xsl:value-of select="$base" />.__getattr__(self, name)
221
222	def __setattr__(self, name, val):
223	hndl = <xsl:value-of select="$ifname" />._Attrs_.get(name, None)
224	if (hndl != None and hndl[1] != None):
225	hndl[1](self,val)
226	else:
227	self.__dict__[name] = val
228
229	<xsl:for-each select="method">
230	<xsl:call-template name="method"/>
231	</xsl:for-each>
232
233	<xsl:for-each select="attribute">
234	<xsl:variable name="attrname"><xsl:value-of select="@name" /></xsl:variable>
235	<xsl:variable name="attrtype"><xsl:value-of select="@type" /></xsl:variable>
236	<xsl:variable name="attrreadonly"><xsl:value-of select="@readonly" /></xsl:variable>
237	<!-- skip this attribute if it has parameters of a type that has wsmap="suppress" -->
238	<xsl:choose>
239	<xsl:when test="( $attrtype=($G_setSuppressedInterfaces/@name) )">
240	<xsl:comment><xsl:value-of select="concat('skipping attribute ', $attrtype, ' for it is of a suppressed type')" /></xsl:comment>
241	</xsl:when>
242	<xsl:otherwise>
243	<xsl:choose>
244	<xsl:when test="@readonly='yes'">
245	<xsl:comment> readonly attribute <xsl:copy-of select="$ifname" />::<xsl:copy-of select="$attrname" /> </xsl:comment>
246	</xsl:when>
247	<xsl:otherwise>
248	<xsl:comment> read/write attribute <xsl:copy-of select="$ifname" />::<xsl:copy-of select="$attrname" /> </xsl:comment>
249	</xsl:otherwise>
250	</xsl:choose>
251	<!-- aa) get method: emit request and result -->
252	<xsl:call-template name="emitGetAttribute">
253	<xsl:with-param name="ifname" select="$ifname" />
254	<xsl:with-param name="attrname" select="$attrname" />
255	<xsl:with-param name="attrtype" select="$attrtype" />
256	</xsl:call-template>
257	<!-- bb) emit a set method if the attribute is read/write -->
258	<xsl:if test="not($attrreadonly='yes')">
259	<xsl:call-template name="emitSetAttribute">
260	<xsl:with-param name="ifname" select="$ifname" />
261	<xsl:with-param name="attrname" select="$attrname" />
262	<xsl:with-param name="attrtype" select="$attrtype" />
263	</xsl:call-template>
264	</xsl:if>
265	</xsl:otherwise>
266	</xsl:choose>
267	</xsl:for-each>
268
269
270	_Attrs_=<xsl:text>{</xsl:text>
271	<xsl:for-each select="attribute">
272	<xsl:if test="not( @type=($G_setSuppressedInterfaces/@name) )">
273	<xsl:text> </xsl:text>'<xsl:value-of select="@name"/>'<xsl:text>:[</xsl:text>
274	<xsl:call-template name="makeGetterName">
275	<xsl:with-param name="attrname" select="@name"/>
276	</xsl:call-template>
277	<xsl:text>,</xsl:text>
278	<xsl:choose>
279	<xsl:when test="@readonly='yes'">
280	<xsl:text>None</xsl:text>
281	</xsl:when>
282	<xsl:otherwise>
283	<xsl:call-template name="makeSetterName">
284	<xsl:with-param name="attrname" select="@name"/>
285	</xsl:call-template>,
286	</xsl:otherwise>
287	</xsl:choose>
288	<xsl:text>]</xsl:text>
289	<xsl:if test="not(position()=last())"><xsl:text>, </xsl:text></xsl:if>
290	</xsl:if>
291	</xsl:for-each>
292	<xsl:text>}</xsl:text>
293	</xsl:template>
294
295	<xsl:template name="interfacestruct">
296	<xsl:variable name="ifname"><xsl:value-of select="@name" /></xsl:variable>
297	class <xsl:value-of select="$ifname"/>:
298	def __init__(self, mgr, handle, isarray = False):
299	self.mgr = mgr
300	self.isarray = isarray
301	if isarray:
302	self.handle = handle
303	else:
304	<xsl:for-each select="attribute">
305	self.<xsl:value-of select="@name"/> = <xsl:call-template name="emitConvertedType">
306	<xsl:with-param name="ifname" select="$ifname" />
307	<xsl:with-param name="methodname" select="''" />
308	<xsl:with-param name="type" select="@type" />
309	</xsl:call-template>(self.mgr, handle._<xsl:value-of select="@name"/>)
310	</xsl:for-each>
311	pass
312
313	<!-- also do getters/setters -->
314	<xsl:for-each select="attribute">
315	def <xsl:call-template name="makeGetterName"><xsl:with-param name="attrname" select="@name"/></xsl:call-template>(self):
316	return self.<xsl:value-of select="@name"/>
317
318	def <xsl:call-template name="makeSetterName"><xsl:with-param name="attrname" select="@name"/></xsl:call-template>(self):
319	raise Error, 'setters not supported'
320	</xsl:for-each>
321
322	def __next(self):
323	if self.isarray:
324	return self.handle.__next()
325	raise TypeError, "iteration over non-sequence"
326
327	def __size(self):
328	if self.isarray:
329	return self.handle.__size()
330	raise TypeError, "iteration over non-sequence"
331
332	def __len__(self):
333	if self.isarray:
334	return self.handle.__len__()
335	raise TypeError, "iteration over non-sequence"
336
337	def __getitem__(self, index):
338	if self.isarray:
339	return <xsl:value-of select="$ifname" />(self.mgr, self.handle[index])
340	raise TypeError, "iteration over non-sequence"
341
342	</xsl:template>
343
344	<xsl:template name="genreq">
345	<xsl:text>req=</xsl:text><xsl:value-of select="../@name"/>_<xsl:value-of select="@name"/>RequestMsg()
346	req._this=self.handle
347	<xsl:for-each select="param[@dir='in']">
348	req._<xsl:value-of select="@name" />=_arg_<xsl:value-of select="@name" />
349	</xsl:for-each>
350	val=self.mgr.getPort().<xsl:value-of select="../@name"/>_<xsl:value-of select="@name"/>(req)
351	<!-- return needs to be the first one -->
352	return <xsl:for-each select="param[@dir='return']">
353	<xsl:call-template name="emitOutParam">
354	<xsl:with-param name="ifname" select="../@name" />
355	<xsl:with-param name="methodname" select="@name" />
356	<xsl:with-param name="type" select="@type" />
357	<xsl:with-param name="value" select="concat('val.','_returnval')" />
358	<xsl:with-param name="safearray" select="@safearray"/>
359	</xsl:call-template>
360	<xsl:if test="../param[@dir='out']">
361	<xsl:text>, </xsl:text>
362	</xsl:if>
363	</xsl:for-each>
364	<xsl:for-each select="param[@dir='out']">
365	<xsl:if test="not(position()=1)">
366	<xsl:text>, </xsl:text>
367	</xsl:if>
368	<xsl:call-template name="emitOutParam">
369	<xsl:with-param name="ifname" select="../@name" />
370	<xsl:with-param name="methodname" select="@name" />
371	<xsl:with-param name="type" select="@type" />
372	<xsl:with-param name="value" select="concat('val._',@name)" />
373	<xsl:with-param name="safearray" select="@safearray"/>
374	</xsl:call-template>
375	</xsl:for-each>
376	<xsl:text> </xsl:text>
377	</xsl:template>
378
379	<xsl:template name="method" >
380	def <xsl:value-of select="@name"/><xsl:text>(self</xsl:text>
381	<xsl:for-each select="param[@dir='in']">
382	<xsl:text>, </xsl:text>
383	<xsl:value-of select="concat('_arg_',@name)"/>
384	</xsl:for-each><xsl:text>): </xsl:text>
385	<xsl:call-template name="genreq"/>
386	</xsl:template>
387
388	<xsl:template name="makeConstantName" >
389	<xsl:choose>
390	<!-- special case for reserved word, maybe will need more in the future -->
391	<xsl:when test="@name='None'">
392	<xsl:text>_None</xsl:text>
393	</xsl:when>
394	<xsl:otherwise>
395	<xsl:value-of select="@name"/>
396	</xsl:otherwise>
397	</xsl:choose>
398	</xsl:template>
399
400	<xsl:template name="enum">
401	class <xsl:value-of select="@name"/>:
402	def __init__(self,mgr,handle):
403	self.mgr=mgr
404	if isinstance(handle,basestring):
405	self.handle=<xsl:value-of select="@name"/>._ValueMap[handle]
406	else:
407	self.handle=handle
408
409	def __eq__(self,other):
410	if isinstance(other,<xsl:value-of select="@name"/>):
411	return self.handle == other.handle
412	if isinstance(other,int):
413	return self.handle == other
414	if isinstance(other,basestring):
415	return str(self) == other
416	return False
417
418	def __ne__(self,other):
419	if isinstance(other,<xsl:value-of select="@name"/>):
420	return self.handle != other.handle
421	if isinstance(other,int):
422	return self.handle != other
423	if isinstance(other,basestring):
424	return str(self) != other
425	return True
426
427	def __str__(self):
428	return <xsl:value-of select="@name"/>._NameMap[self.handle]
429
430	def __int__(self):
431	return self.handle
432
433	_NameMap={<xsl:for-each select="const">
434	<xsl:value-of select="@value"/>:'<xsl:value-of select="@name"/>'<xsl:if test="not(position()=last())">,</xsl:if>
435	</xsl:for-each>}
436	_ValueMap={<xsl:for-each select="const">
437	'<xsl:value-of select="@name"/>':<xsl:value-of select="@value"/><xsl:if test="not(position()=last())">,</xsl:if>
438	</xsl:for-each>}
439
440	<xsl:for-each select="const"><xsl:text> </xsl:text><xsl:call-template name="makeConstantName"><xsl:with-param name="name" select="@name"/></xsl:call-template>=<xsl:value-of select="@value"/><xsl:text> </xsl:text>
441	</xsl:for-each>
442	</xsl:template>
443
444	<xsl:template match="/">
445	<xsl:text># Copyright (C) 2008-2010 Oracle Corporation
446	#
447	# This file is part of a free software library; you can redistribute
448	# it and/or modify it under the terms of the GNU Lesser General
449	# Public License version 2.1 as published by the Free Software
450	# Foundation and shipped in the "COPYING.LIB" file with this library.
451	# The library is distributed in the hope that it will be useful,
452	# but WITHOUT ANY WARRANTY of any kind.
453	#
454	# Oracle LGPL Disclaimer: For the avoidance of doubt, except that if
455	# any license choice other than GPL or LGPL is available it will
456	# apply instead, Oracle elects to use only the Lesser General Public
457	# License version 2.1 (LGPLv2) at this time for any software where
458	# a choice of LGPL license versions is made available with the
459	# language indicating that LGPLv2 or any later version may be used,
460	# or where a choice of which version of the LGPL is applied is
461	# otherwise unspecified.
462	#
463	# This file is autogenerated from VirtualBox.xidl, DO NOT EDIT!
464	#
465	from VirtualBox_services import *
466
467	try:
468	from VirtualBox_client import *
469	except:
470	pass
471
472	class ManagedManager:
473	def __init__(self):
474	self.map = {}
475
476	def register(self,handle):
477	if handle == None:
478	return
479	c = self.map.get(handle,0)
480	c = c + 1
481	self.map[handle]=c
482
483	def unregister(self,handle):
484	if handle == None:
485	return
486	c = self.map.get(handle,-1)
487	if c == -1:
488	raise Error, 'wrong refcount'
489	c = c - 1
490	if c == 0:
491	try:
492	req=IManagedObjectRef_releaseRequestMsg()
493	req._this=handle
494	self.mgr.getPort().IManagedObjectRef_release(req)
495	except:
496	pass
497	self.map[handle] = -1
498	else:
499	self.map[handle] = c
500
501	class String:
502	def __init__(self, mgr, handle, isarray = False):
503	self.handle = handle
504	self.mgr = mgr
505	self.isarray = isarray
506
507	def __next(self):
508	if self.isarray:
509	return self.handle.__next()
510	raise TypeError, "iteration over non-sequence"
511
512	def __size(self):
513	if self.isarray:
514	return self.handle.__size()
515	raise TypeError, "iteration over non-sequence"
516
517	def __len__(self):
518	if self.isarray:
519	return self.handle.__len__()
520	raise TypeError, "iteration over non-sequence"
521
522	def __getitem__(self, index):
523	if self.isarray:
524	return String(self.mgr, self.handle[index])
525	raise TypeError, "iteration over non-sequence"
526
527	def __str__(self):
528	return str(self.handle)
529
530	def __eq__(self,other):
531	if self.isarray:
532	return isinstance(other,String) and self.handle == other.handle
533	if isinstance(other,String):
534	return self.handle == other.handle
535	if isinstance(other,basestring):
536	return self.handle == other
537	return False
538
539	def __ne__(self,other):
540	if self.isarray:
541	return not isinstance(other,String) or self.handle != other.handle
542	if isinstance(other,String):
543	return self.handle != other.handle
544	if isinstance(other,basestring):
545	return self.handle != other
546	return True
547
548	def __add__(self,other):
549	return str(self.handle)+str(other)
550
551
552	class Boolean:
553	def __init__(self, mgr, handle, isarray = False):
554	self.handle = handle
555	if self.handle == "false":
556	self.handle = None
557	self.mgr = mgr
558	self.isarray = isarray
559
560	def __str__(self):
561	if self.handle:
562	return "true"
563	else:
564	return "false"
565
566	def __eq__(self,other):
567	if isinstance(other,Bool):
568	return self.handle == other.value
569	if isinstance(other,bool):
570	return self.handle == other
571	return False
572
573	def __ne__(self,other):
574	if isinstance(other,Bool):
575	return self.handle != other.handle
576	if isinstance(other,bool):
577	return self.handle != other
578	return True
579
580	def __int__(self):
581	if self.handle:
582	return 1
583	else:
584	return 0
585
586	def __long__(self):
587	if self.handle:
588	return 1
589	else:
590	return 0
591
592	def __nonzero__(self):
593	if self.handle:
594	return True
595	else:
596	return False
597
598	def __next(self):
599	if self.isarray:
600	return self.handle.__next()
601	raise TypeError, "iteration over non-sequence"
602
603	def __size(self):
604	if self.isarray:
605	return self.handle.__size()
606	raise TypeError, "iteration over non-sequence"
607
608	def __len__(self):
609	if self.isarray:
610	return self.handle.__len__()
611	raise TypeError, "iteration over non-sequence"
612
613	def __getitem__(self, index):
614	if self.isarray:
615	return Boolean(self.mgr, self.handle[index])
616	raise TypeError, "iteration over non-sequence"
617
618	class Number:
619	def __init__(self, mgr, handle, isarray = False):
620	self.handle = handle
621	self.mgr = mgr
622	self.isarray = isarray
623
624	def __next(self):
625	if self.isarray:
626	return self.handle.__next()
627	raise TypeError, "iteration over non-sequence"
628
629	def __size(self):
630	if self.isarray:
631	return self.handle.__size()
632	raise TypeError, "iteration over non-sequence"
633
634	def __len__(self):
635	if self.isarray:
636	return self.handle.__len__()
637	raise TypeError, "iteration over non-sequence"
638
639	def __str__(self):
640	return str(self.handle)
641
642	def __int__(self):
643	return int(self.handle)
644
645	def __long__(self):
646	return long(self.handle)
647
648	def __float__(self):
649	return float(self.handle)
650
651	def __lt__(self, other):
652	if self.isarray:
653	return NotImplemented
654	else:
655	return self.handle < other
656
657	def __le__(self, other):
658	if self.isarray:
659	return NotImplemented
660	else:
661	return self.handle <= other
662
663	def __eq__(self, other):
664	return self.handle == other
665
666	def __ne__(self, other):
667	return self.handle != other
668
669	def __gt__(self, other):
670	if self.isarray:
671	return NotImplemented
672	else:
673	return self.handle > other
674
675	def __ge__(self, other):
676	if self.isarray:
677	return NotImplemented
678	else:
679	return self.handle >= other
680
681	import struct
682
683	class Octet(Number):
684	def __init__(self, mgr, handle, isarray = False):
685	self.handle = handle
686	self.mgr = mgr
687	self.isarray = isarray
688
689	def __getitem__(self, index):
690	if self.isarray:
691	return Octet(self.mgr, self.handle[index])
692	raise TypeError, "iteration over non-sequence"
693
694	def __str__(self):
695	if self.isarray:
696	# array of octets is binary data
697	list = map (None, self.handle)
698	return struct.pack("%dB" % (len(list)), *list)
699	else:
700	return str(self.handle)
701
702	class UnsignedInt(Number):
703	def __init__(self, mgr, handle, isarray = False):
704	self.handle = handle
705	self.mgr = mgr
706	self.isarray = isarray
707
708	def __getitem__(self, index):
709	if self.isarray:
710	return UnsignedInt(self.mgr, self.handle[index])
711	raise TypeError, "iteration over non-sequence"
712
713
714	class Int(Number):
715	def __init__(self, mgr, handle, isarray = False):
716	self.handle = handle
717	self.mgr = mgr
718	self.isarray = isarray
719
720	def __getitem__(self, index):
721	if self.isarray:
722	return Int(self.mgr, self.handle[index])
723	raise TypeError, "iteration over non-sequence"
724
725	class UnsignedShort(Number):
726	def __init__(self, mgr, handle, isarray = False):
727	self.handle = handle
728	self.mgr = mgr
729	self.isarray = isarray
730
731	def __getitem__(self, index):
732	if self.isarray:
733	return UnsignedShort(self.mgr, self.handle[index])
734	raise TypeError, "iteration over non-sequence"
735
736	class Short(Number):
737	def __init__(self, mgr, handle, isarray = False):
738	self.handle = handle
739	self.mgr = mgr
740	self.isarray = isarray
741
742	def __getitem__(self, index):
743	if self.isarray:
744	return Short(self.mgr, self.handle[index])
745	raise TypeError, "iteration over non-sequence"
746
747	class UnsignedLong(Number):
748	def __init__(self, mgr, handle, isarray = False):
749	self.handle = handle
750	self.mgr = mgr
751	self.isarray = isarray
752
753	def __getitem__(self, index):
754	if self.isarray:
755	return UnsignedLong(self.mgr, self.handle[index])
756	raise TypeError, "iteration over non-sequence"
757
758	class Long(Number):
759	def __init__(self, mgr, handle, isarray = False):
760	self.handle = handle
761	self.mgr = mgr
762	self.isarray = isarray
763
764	def __getitem__(self, index):
765	if self.isarray:
766	return Long(self.mgr, self.handle[index])
767	raise TypeError, "iteration over non-sequence"
768
769	class Double(Number):
770	def __init__(self, mgr, handle, isarray = False):
771	self.handle = handle
772	self.mgr = mgr
773	self.isarray = isarray
774
775	def __getitem__(self, index):
776	if self.isarray:
777	return Double(self.mgr, self.handle[index])
778	raise TypeError, "iteration over non-sequence"
779
780	class Float(Number):
781	def __init__(self, mgr, handle, isarray = False):
782	self.handle = handle
783	self.mgr = mgr
784	self.isarray = isarray
785
786	def __getitem__(self, index):
787	if self.isarray:
788	return Float(self.mgr, self.handle[index])
789	raise TypeError, "iteration over non-sequence"
790
791	class IUnknown:
792	def __init__(self, mgr, handle, isarray = False):
793	self.handle = handle
794	self.mgr = mgr
795	self.isarray = isarray
796
797	def __nonzero__(self):
798	if self.handle != "":
799	return True
800	else:
801	return False
802
803	def __next(self):
804	if self.isarray:
805	return self.handle.__next()
806	raise TypeError, "iteration over non-sequence"
807
808	def __size(self):
809	if self.isarray:
810	return self.handle.__size()
811	raise TypeError, "iteration over non-sequence"
812
813	def __len__(self):
814	if self.isarray:
815	return self.handle.__len__()
816	raise TypeError, "iteration over non-sequence"
817
818	def __getitem__(self, index):
819	if self.isarray:
820	return IUnknown(self.mgr, self.handle[index])
821	raise TypeError, "iteration over non-sequence"
822
823	def __str__(self):
824	return str(self.handle)
825
826	def __eq__(self, other):
827	return self.handle == other
828
829	def __ne__(self, other):
830	return self.handle != other
831
832	def __getattr__(self,attr):
833	if self.__class__.__dict__.get(attr) != None:
834	return self.__class__.__dict__.get(attr)
835	if self.__dict__.get(attr) != None:
836	return self.__dict__.get(attr)
837	raise AttributeError
838
839	</xsl:text>
840	<xsl:for-each select="//interface[@wsmap='managed' or @wsmap='global']">
841	<xsl:call-template name="interface"/>
842	</xsl:for-each>
843	<xsl:for-each select="//interface[@wsmap='struct']">
844	<xsl:call-template name="interfacestruct"/>
845	</xsl:for-each>
846	<xsl:for-each select="//collection">
847	<xsl:call-template name="collection"/>
848	</xsl:for-each>
849	<xsl:for-each select="//enum">
850	<xsl:call-template name="enum"/>
851	</xsl:for-each>
852
853	class IWebsessionManager2(IWebsessionManager):
854	def __init__(self, url):
855	self.url = url
856	self.port = None
857	self.handle = None
858	self.mgr = self
859
860	def getPort(self):
861	if self.port is None:
862	try:
863	self.port = vboxServiceLocator().getvboxPortType(self.url)
864	except:
865	self.port = vboxServiceLocator().getvboxServicePort(self.url)
866	return self.port
867
868	</xsl:template>
869
870	</xsl:stylesheet>

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Main/webservice/websrv-python.xsl@ 35691

Download in other formats: