websrv-python.xsl@ 59487

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

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

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

Download in other formats: