websrv-python.xsl@ 37952

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

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

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

Download in other formats: