websrv-python.xsl@ 59486

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

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

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

Download in other formats: