stoc/source/corereflection/crarray.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 <typelib/typedescription.h>
  21 #include <uno/data.h>
  22 #include <cppuhelper/queryinterface.hxx>
  23
  24 #include "base.hxx"
  25
  26 using namespace css::lang;
  27 using namespace css::reflection;
  28 using namespace css::uno;
  29
  30 namespace stoc_corefl
  31 {
  32
  33 // XInterface
  34
  35 Any ArrayIdlClassImpl::queryInterface( const Type & rType )
  36     throw(css::uno::RuntimeException, std::exception)
  37 {
  38     Any aRet( ::cppu::queryInterface( rType, static_cast< XIdlArray * >( this ) ) );
  39     return (aRet.hasValue() ? aRet : IdlClassImpl::queryInterface( rType ));
  40 }
  41
  42 void ArrayIdlClassImpl::acquire() throw()
  43 {
  44     IdlClassImpl::acquire();
  45 }
  46
  47 void ArrayIdlClassImpl::release() throw()
  48 {
  49     IdlClassImpl::release();
  50 }
  51
  52 // XTypeProvider
  53
  54 Sequence< Type > ArrayIdlClassImpl::getTypes()
  55     throw (css::uno::RuntimeException, std::exception)
  56 {
  57     static ::cppu::OTypeCollection * s_pTypes = 0;
  58     if (! s_pTypes)
  59     {
  60         ::osl::MutexGuard aGuard( getMutexAccess() );
  61         if (! s_pTypes)
  62         {
  63             static ::cppu::OTypeCollection s_aTypes(
  64                 cppu::UnoType<XIdlArray>::get(),
  65                 IdlClassImpl::getTypes() );
  66             s_pTypes = &s_aTypes;
  67         }
  68     }
  69     return s_pTypes->getTypes();
  70 }
  71
  72 Sequence< sal_Int8 > ArrayIdlClassImpl::getImplementationId()
  73     throw (css::uno::RuntimeException, std::exception)
  74 {
  75     return css::uno::Sequence<sal_Int8>();
  76 }
  77
  78 // XIdlArray
  79
  80 void ArrayIdlClassImpl::realloc( Any & rArray, sal_Int32 nLen )
  81     throw(css::lang::IllegalArgumentException, css::uno::RuntimeException, std::exception)
  82 {
  83     TypeClass eTC = rArray.getValueTypeClass();
  84     if (eTC != TypeClass_SEQUENCE)
  85     {
  86         throw IllegalArgumentException(
  87             "no sequence given!",
  88             (XWeak *)(OWeakObject *)this, 0 );
  89     }
  90     if (nLen < 0)
  91     {
  92         throw IllegalArgumentException(
  93             "illegal length given!",
  94             (XWeak *)(OWeakObject *)this, 1 );
  95     }
  96
  97     uno_Sequence ** ppSeq = const_cast<uno_Sequence **>(static_cast<uno_Sequence * const *>(rArray.getValue()));
  98     uno_sequence_realloc( ppSeq, &getTypeDescr()->aBase,
  99                           nLen,
 100                           reinterpret_cast< uno_AcquireFunc >(cpp_acquire),
 101                           reinterpret_cast< uno_ReleaseFunc >(cpp_release) );
 102     rArray.pData = ppSeq;
 103 }
 104
 105 sal_Int32 ArrayIdlClassImpl::getLen( const Any & rArray )
 106     throw(css::lang::IllegalArgumentException, css::uno::RuntimeException, std::exception)
 107 {
 108     TypeClass eTC = rArray.getValueTypeClass();
 109     if (eTC != TypeClass_SEQUENCE)
 110     {
 111         throw IllegalArgumentException(
 112             "no sequence given!",
 113             (XWeak *)(OWeakObject *)this, 0 );
 114     }
 115
 116     return (*static_cast<uno_Sequence * const *>(rArray.getValue()))->nElements;
 117 }
 118
 119 Any ArrayIdlClassImpl::get( const Any & rArray, sal_Int32 nIndex )
 120     throw(css::lang::IllegalArgumentException, css::lang::ArrayIndexOutOfBoundsException, css::uno::RuntimeException, std::exception)
 121 {
 122     TypeClass eTC = rArray.getValueTypeClass();
 123     if (eTC != TypeClass_SEQUENCE)
 124     {
 125         throw IllegalArgumentException(
 126             "no sequence given!",
 127             (XWeak *)(OWeakObject *)this, 0 );
 128     }
 129
 130     uno_Sequence * pSeq = *static_cast<uno_Sequence * const *>(rArray.getValue());
 131     if (pSeq->nElements <= nIndex)
 132     {
 133         throw ArrayIndexOutOfBoundsException(
 134             "illegal index given!",
 135             (XWeak *)(OWeakObject *)this );
 136     }
 137
 138     Any aRet;
 139     typelib_TypeDescription * pElemTypeDescr = 0;
 140     TYPELIB_DANGER_GET( &pElemTypeDescr, getTypeDescr()->pType );
 141     uno_any_destruct( &aRet, reinterpret_cast< uno_ReleaseFunc >(cpp_release) );
 142     uno_any_construct( &aRet, &pSeq->elements[nIndex * pElemTypeDescr->nSize],
 143                        pElemTypeDescr,
 144                        reinterpret_cast< uno_AcquireFunc >(cpp_acquire) );
 145     TYPELIB_DANGER_RELEASE( pElemTypeDescr );
 146     return aRet;
 147 }
 148
 149
 150 void ArrayIdlClassImpl::set( Any & rArray, sal_Int32 nIndex, const Any & rNewValue )
 151     throw(css::lang::IllegalArgumentException, css::lang::ArrayIndexOutOfBoundsException, css::uno::RuntimeException, std::exception)
 152 {
 153     TypeClass eTC = rArray.getValueTypeClass();
 154     if (eTC != TypeClass_SEQUENCE)
 155     {
 156         throw IllegalArgumentException(
 157             "no sequence given!",
 158             (XWeak *)(OWeakObject *)this, 0 );
 159     }
 160
 161     uno_Sequence * pSeq = *static_cast<uno_Sequence * const *>(rArray.getValue());
 162     if (pSeq->nElements <= nIndex)
 163     {
 164         throw ArrayIndexOutOfBoundsException(
 165             "illegal index given!",
 166             (XWeak *)(OWeakObject *)this );
 167     }
 168
 169     uno_Sequence ** ppSeq = const_cast<uno_Sequence **>(static_cast<uno_Sequence * const *>(rArray.getValue()));
 170     uno_sequence_reference2One(
 171         ppSeq, &getTypeDescr()->aBase,
 172         reinterpret_cast< uno_AcquireFunc >(cpp_acquire),
 173         reinterpret_cast< uno_ReleaseFunc >(cpp_release) );
 174     rArray.pData = ppSeq;
 175     pSeq = *ppSeq;
 176
 177     typelib_TypeDescription * pElemTypeDescr = 0;
 178     TYPELIB_DANGER_GET( &pElemTypeDescr, getTypeDescr()->pType );
 179
 180     if (! coerce_assign( &pSeq->elements[nIndex * pElemTypeDescr->nSize],
 181                          pElemTypeDescr, rNewValue, getReflection() ))
 182     {
 183         TYPELIB_DANGER_RELEASE( pElemTypeDescr );
 184         throw IllegalArgumentException(
 185             "sequence element is not assignable by given value!",
 186             (XWeak *)(OWeakObject *)this, 2 );
 187     }
 188     TYPELIB_DANGER_RELEASE( pElemTypeDescr );
 189 }
 190
 191 // ArrayIdlClassImpl
 192
 193 sal_Bool ArrayIdlClassImpl::isAssignableFrom( const Reference< XIdlClass > & xType )
 194     throw(css::uno::RuntimeException, std::exception)
 195 {
 196     return (xType.is() &&
 197             (equals( xType ) ||
 198              (xType->getTypeClass() == getTypeClass() && // must be sequence|array
 199               getComponentType()->isAssignableFrom( xType->getComponentType() ))));
 200 }
 201
 202 Reference< XIdlClass > ArrayIdlClassImpl::getComponentType()
 203     throw(css::uno::RuntimeException, std::exception)
 204 {
 205     return getReflection()->forType( getTypeDescr()->pType );
 206 }
 207
 208 Reference< XIdlArray > ArrayIdlClassImpl::getArray()
 209     throw(css::uno::RuntimeException, std::exception)
 210 {
 211     return this;
 212 }
 213
 214 }
 215
 216
 217 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */