pyuno/source/module/pyuno_iterator.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
  20 #include <sal/config.h>
  21
  22 #include "pyuno_impl.hxx"
  23
  24 #include <com/sun/star/container/XEnumeration.hpp>
  25 #include <com/sun/star/container/XIndexAccess.hpp>
  26 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  27 #include <com/sun/star/lang/WrappedTargetException.hpp>
  28 #include <com/sun/star/script/CannotConvertException.hpp>
  29
  30 using com::sun::star::container::XEnumeration;
  31 using com::sun::star::container::XIndexAccess;
  32 using com::sun::star::lang::IndexOutOfBoundsException;
  33 using com::sun::star::lang::WrappedTargetException;
  34 using com::sun::star::uno::Any;
  35 using com::sun::star::uno::Reference;
  36 using com::sun::star::uno::RuntimeException;
  37
  38
  39 namespace pyuno
  40 {
  41
  42 static void PyUNO_iterator_del( PyObject* self )
  43 {
  44     PyUNO_iterator* me = reinterpret_cast<PyUNO_iterator*>(self);
  45
  46     {
  47         PyThreadDetach antiguard;
  48         delete me->members;
  49     }
  50     PyObject_Del( self );
  51 }
  52
  53 static PyObject* PyUNO_iterator_iter( PyObject *self )
  54 {
  55     Py_INCREF( self );
  56     return self;
  57 }
  58
  59 static PyObject* PyUNO_iterator_next( PyObject *self )
  60 {
  61     PyUNO_iterator* me = reinterpret_cast<PyUNO_iterator*>(self);
  62
  63     Runtime runtime;
  64     Any aRet;
  65
  66     try
  67     {
  68         bool hasMoreElements = false;
  69
  70         {
  71             PyThreadDetach antiguard;
  72
  73             hasMoreElements = me->members->xEnumeration->hasMoreElements();
  74             if ( hasMoreElements )
  75             {
  76                 aRet = me->members->xEnumeration->nextElement();
  77             }
  78         }
  79
  80         if ( hasMoreElements )
  81         {
  82             PyRef rRet = runtime.any2PyObject( aRet );
  83             return rRet.getAcquired();
  84         }
  85
  86         PyErr_SetString( PyExc_StopIteration, "" );
  87         return nullptr;
  88     }
  89     catch( css::container::NoSuchElementException &e )
  90     {
  91         raisePyExceptionWithAny( css::uno::makeAny( e ) );
  92     }
  93     catch( css::script::CannotConvertException &e )
  94     {
  95         raisePyExceptionWithAny( css::uno::makeAny( e ) );
  96     }
  97     catch( css::lang::IllegalArgumentException &e )
  98     {
  99         raisePyExceptionWithAny( css::uno::makeAny( e ) );
 100     }
 101     catch( const css::lang::WrappedTargetException &e )
 102     {
 103         raisePyExceptionWithAny( css::uno::makeAny( e ) );
 104     }
 105     catch( const css::uno::RuntimeException &e )
 106     {
 107         raisePyExceptionWithAny( css::uno::makeAny( e ) );
 108     }
 109
 110     return nullptr;
 111 }
 112
 113
 114 static PyTypeObject PyUNO_iterator_Type =
 115 {
 116     PyVarObject_HEAD_INIT( &PyType_Type, 0 )
 117     "PyUNO_iterator",
 118     sizeof (PyUNO_iterator),
 119     0,
 120     PyUNO_iterator_del,
 121 #if PY_VERSION_HEX >= 0x03080000
 122     0, // Py_ssize_t tp_vectorcall_offset
 123 #else
 124     nullptr, // printfunc tp_print
 125 #endif
 126     nullptr,
 127     nullptr,
 128     nullptr,
 129     nullptr,
 130     nullptr,
 131     nullptr,
 132     nullptr,
 133     nullptr,
 134     nullptr,
 135     nullptr,
 136     nullptr,
 137     nullptr,
 138     nullptr,
 139     Py_TPFLAGS_HAVE_ITER,
 140     nullptr,
 141     nullptr,
 142     nullptr,
 143     nullptr,
 144     0,
 145     PyUNO_iterator_iter, // Generic, reused between the iterator types
 146     PyUNO_iterator_next,
 147     nullptr,
 148     nullptr,
 149     nullptr,
 150     nullptr,
 151     nullptr,
 152     nullptr,
 153     nullptr,
 154     0,
 155     nullptr,
 156     nullptr,
 157     nullptr,
 158     nullptr,
 159     nullptr,
 160     nullptr,
 161     nullptr,
 162     nullptr,
 163     nullptr,
 164     nullptr,
 165     nullptr,
 166     0
 167 #if PY_VERSION_HEX >= 0x03040000
 168     , nullptr
 169 #if PY_VERSION_HEX >= 0x03080000
 170     , nullptr // vectorcallfunc tp_vectorcall
 171 #endif
 172 #endif
 173 };
 174
 175 PyObject* PyUNO_iterator_new( const Reference< XEnumeration >& xEnumeration )
 176 {
 177     PyUNO_iterator* self = PyObject_New( PyUNO_iterator, &PyUNO_iterator_Type );
 178     if ( self == nullptr )
 179         return nullptr; // == error
 180     self->members = new PyUNO_iterator_Internals;
 181     self->members->xEnumeration = xEnumeration;
 182     return reinterpret_cast<PyObject*>(self);
 183 }
 184
 185 ///////////////////////////////////////////////////////////////////////////////
 186
 187 static void PyUNO_list_iterator_del( PyObject* self )
 188 {
 189     PyUNO_list_iterator* me = reinterpret_cast<PyUNO_list_iterator*>(self);
 190
 191     {
 192         PyThreadDetach antiguard;
 193         delete me->members;
 194     }
 195     PyObject_Del( self );
 196 }
 197
 198
 199 static PyObject* PyUNO_list_iterator_next( PyObject *self )
 200 {
 201     PyUNO_list_iterator* me = reinterpret_cast<PyUNO_list_iterator*>(self);
 202
 203     Runtime runtime;
 204     Any aRet;
 205     bool noMoreElements = false;
 206
 207     try
 208     {
 209         {
 210             PyThreadDetach antiguard;
 211             try {
 212                 aRet = me->members->xIndexAccess->getByIndex( me->members->index );
 213             }
 214             catch( const css::lang::IndexOutOfBoundsException & )
 215             {
 216                 noMoreElements = true;
 217             }
 218         }
 219
 220         if ( noMoreElements )
 221         {
 222             PyErr_SetString( PyExc_StopIteration, "" );
 223             return nullptr;
 224         }
 225
 226         PyRef rRet = runtime.any2PyObject( aRet );
 227         me->members->index++;
 228         return rRet.getAcquired();
 229     }
 230     catch( css::script::CannotConvertException &e )
 231     {
 232         raisePyExceptionWithAny( css::uno::makeAny( e ) );
 233     }
 234     catch( css::lang::IllegalArgumentException &e )
 235     {
 236         raisePyExceptionWithAny( css::uno::makeAny( e ) );
 237     }
 238     catch( const css::lang::WrappedTargetException &e )
 239     {
 240         raisePyExceptionWithAny( css::uno::makeAny( e ) );
 241     }
 242     catch( const css::uno::RuntimeException &e )
 243     {
 244         raisePyExceptionWithAny( css::uno::makeAny( e ) );
 245     }
 246
 247     return nullptr;
 248 }
 249
 250
 251 static PyTypeObject PyUNO_list_iterator_Type =
 252 {
 253     PyVarObject_HEAD_INIT( &PyType_Type, 0 )
 254     "PyUNO_iterator",
 255     sizeof (PyUNO_list_iterator),
 256      0,
 257     PyUNO_list_iterator_del,
 258 #if PY_VERSION_HEX >= 0x03080000
 259     0, // Py_ssize_t tp_vectorcall_offset
 260 #else
 261     nullptr, // printfunc tp_print
 262 #endif
 263     nullptr,
 264     nullptr,
 265     nullptr,
 266     nullptr,
 267     nullptr,
 268     nullptr,
 269     nullptr,
 270     nullptr,
 271     nullptr,
 272     nullptr,
 273     nullptr,
 274     nullptr,
 275     nullptr,
 276     Py_TPFLAGS_HAVE_ITER,
 277     nullptr,
 278     nullptr,
 279     nullptr,
 280     nullptr,
 281     0,
 282     PyUNO_iterator_iter, // Generic, reused between the iterator types
 283     PyUNO_list_iterator_next,
 284     nullptr,
 285     nullptr,
 286     nullptr,
 287     nullptr,
 288     nullptr,
 289     nullptr,
 290     nullptr,
 291     0,
 292     nullptr,
 293     nullptr,
 294     nullptr,
 295     nullptr,
 296     nullptr,
 297     nullptr,
 298     nullptr,
 299     nullptr,
 300     nullptr,
 301     nullptr,
 302     nullptr,
 303     0
 304 #if PY_VERSION_HEX >= 0x03040000
 305     , nullptr
 306 #if PY_VERSION_HEX >= 0x03080000
 307     , nullptr // vectorcallfunc tp_vectorcall
 308 #endif
 309 #endif
 310 };
 311
 312 PyObject* PyUNO_list_iterator_new( const Reference<XIndexAccess> &xIndexAccess )
 313 {
 314     PyUNO_list_iterator* self = PyObject_New( PyUNO_list_iterator, &PyUNO_list_iterator_Type );
 315     if ( self == nullptr )
 316         return nullptr; // == error
 317     self->members = new PyUNO_list_iterator_Internals;
 318     self->members->xIndexAccess = xIndexAccess;
 319     self->members->index = 0;
 320     return reinterpret_cast<PyObject*>(self);
 321 }
 322
 323 }
 324
 325 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */