Python-UNO bridge

Python内部只知道C数据类型long和longlong作为整数类型。在大多数机器上,一个long是一个32位值而longlong是一个64位的值.

• 值来自UNO（例如，UNO方法的返回值）
  byte,short,unsigned short,long or unsigned long 转换到python long. 
  type hyper or unsigned hyper 转换到python long long.

• 值传给UNO（例如，作为UNO方法的参数）

  如果有一个具体类型的idl方法,值转化为具体的类型（实际上调用服务做了这个工作）。

  如果方法只有一个any,每一个整数值转换为最小的数据类型（5 becomes a byte, 150 becomes a short, 0x1f023 becomes a long and values larger than 0xffffffff become a hyper）

#idl signature void takeBool( [in] boolean bool )

unoObject.takeBool( 1 )       # valid, passing true (PyUNO runtime
                              # does the conversion
unoObject.takeBool( True) )   # valid, passing true
unoObject.takeBool( False )   # valid, passing false
然而当你想明确的指定传递boolean，并用any类型作为参数，你必须使用True 或 False

# idl signature void foo( [in] any value )

# implementation expects a boolean (which is separately documented
# e.g. in the service specification.
unoObject.foo( True ) # valid, pass a true
unoObject.foo( 1 )    # bad, just passing a 1, implementation will

# idl signature foo( [in] string value )
# both lines are valid
unoObject.foo( u‘my foo string‘ )
unoObject.foo( ‘my foo string‘ )

from com.sun.star.uno.TypeClass import UNSIGNED_LONG

unoObject.setValue(UNSIGNED_LONG)

if unoObject.getValue() == UNSIGNED_LONG;

unoObject 映射为枚举类型

例：

from com.sun.star.lang import typeOfXComponent

unoObject.setType( typeOfXComponent )
if unoObject.getType() == typeOfXComponent:

第一种实现方式：使用结构体的构造函数，拷贝构造函数，以及结构体支持等于号操作。

from com.sun.star.beans import PropertyValue

from com.sun.star.uno import Exception,RuntimeException

propVal = PropertyValue()                 # Default constructor
propVal.Name = "foo"
propVal.Value = 2

if propVal == PropertyValue( "foo", 2 ):  # Memberwise constructor
   # true !
   pass

if propVal == PropertyValue( propVal ):   # Copy Constructor
   # true

第二种实现方式： uno.createUnoStruct()

struct = uno.createUnoStruct( "com.sun.star.beans.PropertyValue" )

struct.Name = "foo"
struct2 = struct
struct2.Name = "python"           # modifies also struct, probably not desired !
unoObject.call( struct, struct2 ) # passes the same struct 2 times !

struct.Name = "doobidooo"         # even worse style. If the UNO object is implemented
                                  # in python, you possibly modify the callee‘s value.
				  # Don‘t do this !

secquence<byte>映射为uno.ByteSecquence. 包含字符串类型的成员变量value, value存放字节流。

# idl signature writeBytes( [in] sequence%lt; byte > data )
#
out.writeBytes( uno.ByteSequence( "abc" ) )

# you could also write the following
begin = uno.ByteSequence( "ab" )
out.writeBytes( begin + "c" )

# but this does not work !
out.writeBytes( "abc" ) # ERROR, no implicit conversion supported by the runtime !

# idl signature long readBytes( [out] sequence<byte> , [in] length )
len,seq = in.readBytes( dummy, 3 )

# the statements do the same thing
print seq == "abc":
print seq == uno.ByteSequence( "abc" )

# the normal call
uno.setPropertyValue( "foo", (4,5))

# the uno.invoke call
uno.invoke( obj, "setPropertyValue" , ("foo",uno.Any( "[]short", (4,5))) )

我们可以使用uno.Any()，传递类型名称和值来构造Any

# constructs a uno.Any, that contains a byte
byteAny = uno.Any( "byte" , 5 )

# constructs a sequences of shorts
byteAny = uno.Any( "[]short", (4,5))