pyuno/source/module/pyuno_callable.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19 #include "pyuno_impl.hxx"
  20
  21 #include <osl/thread.h>
  22 #include <rtl/ustrbuf.hxx>
  23
  24 using com::sun::star::uno::Sequence;
  25 using com::sun::star::uno::Reference;
  26 using com::sun::star::uno::XInterface;
  27 using com::sun::star::uno::Any;
  28 using com::sun::star::uno::Type;
  29 using com::sun::star::uno::TypeClass;
  30 using com::sun::star::uno::RuntimeException;
  31 using com::sun::star::uno::XComponentContext;
  32 using com::sun::star::lang::XSingleServiceFactory;
  33 using com::sun::star::script::XTypeConverter;
  34 using com::sun::star::script::XInvocation2;
  35
  36 namespace pyuno
  37 {
  38 typedef struct
  39 {
  40     Reference<XInvocation2> xInvocation;
  41     Reference<XSingleServiceFactory> xInvocationFactory;
  42     Reference<XTypeConverter> xTypeConverter;
  43     OUString methodName;
  44     ConversionMode mode;
  45 } PyUNO_callable_Internals;
  46
  47 typedef struct
  48 {
  49     PyObject_HEAD
  50     PyUNO_callable_Internals* members;
  51 } PyUNO_callable;
  52
  53 void PyUNO_callable_del (PyObject* self)
  54 {
  55     PyUNO_callable* me;
  56
  57     me = (PyUNO_callable*) self;
  58     delete me->members;
  59     PyObject_Del (self);
  60
  61     return;
  62 }
  63
  64 PyObject* PyUNO_callable_call(
  65     PyObject* self, PyObject* args, SAL_UNUSED_PARAMETER PyObject*)
  66 {
  67     PyUNO_callable* me;
  68
  69     Sequence<short> aOutParamIndex;
  70     Sequence<Any> aOutParam;
  71     Sequence<Any> aParams;
  72     Sequence<Type> aParamTypes;
  73     Any any_params;
  74     Any out_params;
  75     Any ret_value;
  76     RuntimeCargo *cargo = 0;
  77     me = (PyUNO_callable*) self;
  78
  79     PyRef ret;
  80     try
  81     {
  82         Runtime runtime;
  83         cargo = runtime.getImpl()->cargo;
  84         any_params = runtime.pyObject2Any (args, me->members->mode);
  85
  86         if (any_params.getValueTypeClass () == com::sun::star::uno::TypeClass_SEQUENCE)
  87         {
  88             any_params >>= aParams;
  89         }
  90         else
  91         {
  92             aParams.realloc (1);
  93             aParams [0] <<= any_params;
  94         }
  95
  96         {
  97             PyThreadDetach antiguard; //pyhton free zone
  98
  99             // do some logging if desired ...
 100             if( isLog( cargo, LogLevel::CALL ) )
 101             {
 102                 logCall( cargo, "try     py->uno[0x", me->members->xInvocation.get(),
 103                          me->members->methodName, aParams );
 104             }
 105
 106             // do the call
 107             ret_value = me->members->xInvocation->invoke (
 108                 me->members->methodName, aParams, aOutParamIndex, aOutParam);
 109
 110             // log the reply, if desired
 111             if( isLog( cargo, LogLevel::CALL ) )
 112             {
 113                 logReply( cargo, "success py->uno[0x", me->members->xInvocation.get(),
 114                           me->members->methodName, ret_value, aOutParam);
 115             }
 116         }
 117
 118
 119         PyRef temp = runtime.any2PyObject (ret_value);
 120         if( aOutParam.getLength() )
 121         {
 122             PyRef return_list( PyTuple_New (1+aOutParam.getLength()), SAL_NO_ACQUIRE );
 123             PyTuple_SetItem (return_list.get(), 0, temp.getAcquired());
 124
 125             // initialize with defaults in case of exceptions
 126             int i;
 127             for( i = 1 ; i < 1+aOutParam.getLength() ; i ++ )
 128             {
 129                 Py_INCREF( Py_None );
 130                 PyTuple_SetItem( return_list.get() , i , Py_None );
 131             }
 132
 133             for( i = 0 ; i < aOutParam.getLength() ; i ++ )
 134             {
 135                 PyRef ref = runtime.any2PyObject( aOutParam[i] );
 136                 PyTuple_SetItem (return_list.get(), 1+i, ref.getAcquired());
 137             }
 138             ret = return_list;
 139         }
 140         else
 141         {
 142             ret = temp;
 143         }
 144     }
 145     catch( const com::sun::star::reflection::InvocationTargetException & e )
 146     {
 147
 148         if( isLog( cargo, LogLevel::CALL ) )
 149         {
 150             logException( cargo, "except  py->uno[0x", me->members->xInvocation.get() ,
 151                           me->members->methodName, e.TargetException.getValue(), e.TargetException.getValueTypeRef());
 152         }
 153         raisePyExceptionWithAny( e.TargetException );
 154     }
 155     catch( const com::sun::star::script::CannotConvertException &e )
 156     {
 157         if( isLog( cargo, LogLevel::CALL ) )
 158         {
 159             logException( cargo, "error  py->uno[0x", me->members->xInvocation.get() ,
 160                           me->members->methodName, &e, getCppuType(&e).getTypeLibType());
 161         }
 162         raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
 163     }
 164     catch( const com::sun::star::lang::IllegalArgumentException &e )
 165     {
 166         if( isLog( cargo, LogLevel::CALL ) )
 167         {
 168             logException( cargo, "error  py->uno[0x", me->members->xInvocation.get() ,
 169                           me->members->methodName, &e, getCppuType(&e).getTypeLibType());
 170         }
 171         raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
 172     }
 173     catch (const ::com::sun::star::uno::RuntimeException &e)
 174     {
 175         if( cargo && isLog( cargo, LogLevel::CALL ) )
 176         {
 177             logException( cargo, "error  py->uno[0x", me->members->xInvocation.get() ,
 178                           me->members->methodName, &e, getCppuType(&e).getTypeLibType());
 179         }
 180         raisePyExceptionWithAny( com::sun::star::uno::makeAny( e ) );
 181     }
 182
 183     return ret.getAcquired();
 184 }
 185
 186
 187 static PyTypeObject PyUNO_callable_Type =
 188 {
 189     PyVarObject_HEAD_INIT( &PyType_Type, 0 )
 190     "PyUNO_callable",
 191     sizeof (PyUNO_callable),
 192     0,
 193     (destructor) ::pyuno::PyUNO_callable_del,
 194     (printfunc) 0,
 195     (getattrfunc) 0,
 196     (setattrfunc) 0,
 197     0,
 198     (reprfunc) 0,
 199     0,
 200     0,
 201     0,
 202     (hashfunc) 0,
 203     (ternaryfunc) ::pyuno::PyUNO_callable_call,
 204     (reprfunc) 0,
 205     (getattrofunc)0,
 206     (setattrofunc)0,
 207     NULL,
 208     0,
 209     NULL,
 210     (traverseproc)0,
 211     (inquiry)0,
 212     (richcmpfunc)0,
 213     0,
 214     (getiterfunc)0,
 215     (iternextfunc)0,
 216     NULL,
 217     NULL,
 218     NULL,
 219     NULL,
 220     NULL,
 221     (descrgetfunc)0,
 222     (descrsetfunc)0,
 223     0,
 224     (initproc)0,
 225     (allocfunc)0,
 226     (newfunc)0,
 227     (freefunc)0,
 228     (inquiry)0,
 229     NULL,
 230     NULL,
 231     NULL,
 232     NULL,
 233     NULL,
 234     (destructor)0
 235 #if PY_VERSION_HEX >= 0x02060000
 236     , 0
 237 #endif
 238 };
 239
 240 PyRef PyUNO_callable_new (
 241     const Reference<XInvocation2> &my_inv,
 242     const OUString & methodName,
 243     const Reference<XSingleServiceFactory> &xInvocationFactory,
 244     const Reference<XTypeConverter> &tc,
 245     enum ConversionMode mode )
 246 {
 247     PyUNO_callable* self;
 248
 249     OSL_ENSURE (my_inv.is(), "XInvocation must be valid");
 250
 251     self = PyObject_New (PyUNO_callable, &PyUNO_callable_Type);
 252     if (self == NULL)
 253         return NULL; //NULL == Error!
 254
 255     self->members = new PyUNO_callable_Internals;
 256     self->members->xInvocation = my_inv;
 257     self->members->methodName = methodName;
 258     self->members->xInvocationFactory = xInvocationFactory;
 259     self->members->xTypeConverter = tc;
 260     self->members->mode = mode;
 261
 262     return PyRef( (PyObject*)self, SAL_NO_ACQUIRE );
 263 }
 264
 265 }
 266
 267 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */