VirtualBox

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

Last change on this file since 21819 was 21819, checked in by vboxsync, 16 years ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette