include/vbahelper/vbacollectionimpl.hxx

   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 #ifndef INCLUDED_VBAHELPER_VBACOLLECTIONIMPL_HXX
  21 #define INCLUDED_VBAHELPER_VBACOLLECTIONIMPL_HXX
  22
  23 #include <exception>
  24 #include <vector>
  25
  26 #include <com/sun/star/container/NoSuchElementException.hpp>
  27 #include <com/sun/star/container/XEnumeration.hpp>
  28 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  29 #include <com/sun/star/lang/WrappedTargetException.hpp>
  30 #include <com/sun/star/uno/Any.hxx>
  31 #include <com/sun/star/uno/Reference.hxx>
  32 #include <com/sun/star/uno/RuntimeException.hpp>
  33 #include <com/sun/star/uno/Sequence.hxx>
  34 #include <com/sun/star/uno/Type.hxx>
  35 #include <com/sun/star/uno/TypeClass.hpp>
  36 #include <cppu/unotype.hxx>
  37 #include <cppuhelper/implbase.hxx>
  38 #include <cppuhelper/weakref.hxx>
  39 #include <ooo/vba/XCollection.hpp>
  40 #include <com/sun/star/container/XIndexAccess.hpp>
  41 #include <com/sun/star/container/XNameAccess.hpp>
  42 #include <com/sun/star/container/XNamed.hpp>
  43 #include <rtl/ustring.hxx>
  44 #include <sal/types.h>
  45 #include <vbahelper/vbadllapi.h>
  46 #include <vbahelper/vbahelper.hxx>
  47 #include <vbahelper/vbahelperinterface.hxx>
  48
  49 namespace com::sun::star {
  50     namespace container { class XEnumerationAccess; }
  51     namespace uno { class XComponentContext; }
  52 }
  53
  54 namespace ooo::vba {
  55     class XHelperInterface;
  56 }
  57
  58 typedef ::cppu::WeakImplHelper< css::container::XEnumeration > EnumerationHelper_BASE;
  59
  60
  61 /** A wrapper that holds a com.sun.star.container.XIndexAccess and provides a
  62     com.sun.star.container.XEnumeration.
  63
  64     Can be used to provide an enumeration from an index container that contains
  65     completely constructed/initialized VBA implementation objects. CANNOT be
  66     used to provide an enumeration from an index container with other objects
  67     (e.g. UNO objects) where construction of the VBA objects is needed first.
  68  */
  69 class VBAHELPER_DLLPUBLIC SimpleIndexAccessToEnumeration final : public EnumerationHelper_BASE
  70 {
  71 public:
  72     /// @throws css::uno::RuntimeException
  73     explicit SimpleIndexAccessToEnumeration(
  74             const css::uno::Reference< css::container::XIndexAccess >& rxIndexAccess ) :
  75         mxIndexAccess( rxIndexAccess ), mnIndex( 0 ) {}
  76
  77     virtual sal_Bool SAL_CALL hasMoreElements() override
  78     {
  79         return mnIndex < mxIndexAccess->getCount();
  80     }
  81
  82     virtual css::uno::Any SAL_CALL nextElement() override
  83     {
  84         if( !hasMoreElements() )
  85             throw css::container::NoSuchElementException();
  86         return mxIndexAccess->getByIndex( mnIndex++ );
  87     }
  88
  89 private:
  90     css::uno::Reference< css::container::XIndexAccess > mxIndexAccess;
  91     sal_Int32 mnIndex;
  92 };
  93
  94
  95 /** A wrapper that holds a com.sun.star.container.XEnumeration or a
  96     com.sun.star.container.XIndexAccess and provides an enumeration of VBA objects.
  97
  98     The method createCollectionObject() needs to be implemented by the derived
  99     class. This class can be used to convert an enumeration or an index container
 100     containing UNO objects to an enumeration providing the related VBA objects.
 101  */
 102 class VBAHELPER_DLLPUBLIC SimpleEnumerationBase : public EnumerationHelper_BASE
 103 {
 104 public:
 105     /// @throws css::uno::RuntimeException
 106     explicit SimpleEnumerationBase(
 107             const css::uno::Reference< css::container::XIndexAccess >& rxIndexAccess ) :
 108         mxEnumeration( new SimpleIndexAccessToEnumeration( rxIndexAccess ) ) {}
 109
 110     virtual sal_Bool SAL_CALL hasMoreElements() override
 111     {
 112         return mxEnumeration->hasMoreElements();
 113     }
 114
 115     virtual css::uno::Any SAL_CALL nextElement() override
 116     {
 117         return createCollectionObject( mxEnumeration->nextElement() );
 118     }
 119
 120     /** Derived classes implement creation of a VBA implementation object from
 121         the passed container element. */
 122     virtual css::uno::Any createCollectionObject( const css::uno::Any& rSource ) = 0;
 123
 124 private:
 125     css::uno::Reference< css::container::XEnumeration > mxEnumeration;
 126 };
 127
 128
 129 // deprecated, use SimpleEnumerationBase instead!
 130 class VBAHELPER_DLLPUBLIC EnumerationHelperImpl : public EnumerationHelper_BASE
 131 {
 132 protected:
 133     css::uno::WeakReference< ov::XHelperInterface > m_xParent;
 134     css::uno::Reference< css::uno::XComponentContext > m_xContext;
 135     css::uno::Reference< css::container::XEnumeration > m_xEnumeration;
 136 public:
 137     /// @throws css::uno::RuntimeException
 138     EnumerationHelperImpl( const css::uno::Reference< ov::XHelperInterface >& xParent, const css::uno::Reference< css::uno::XComponentContext >& xContext, const css::uno::Reference< css::container::XEnumeration >& xEnumeration ) : m_xParent( xParent ), m_xContext( xContext ),  m_xEnumeration( xEnumeration ) { }
 139     virtual sal_Bool SAL_CALL hasMoreElements(  ) override { return m_xEnumeration->hasMoreElements(); }
 140 };
 141
 142 // a wrapper class for a providing a XIndexAccess, XNameAccess, XEnumerationAccess impl based on providing a vector of interfaces
 143 // only requirement is the object needs to implement XName
 144
 145
 146 template< typename OneIfc >
 147 class XNamedObjectCollectionHelper final : public ::cppu::WeakImplHelper< css::container::XNameAccess,
 148                                                                     css::container::XIndexAccess,
 149                                                                     css::container::XEnumerationAccess >
 150 {
 151 public:
 152 typedef std::vector< css::uno::Reference< OneIfc > >  XNamedVec;
 153 private:
 154
 155     class XNamedEnumerationHelper : public EnumerationHelper_BASE
 156     {
 157         XNamedVec mXNamedVec;
 158         typename XNamedVec::iterator mIt;
 159     public:
 160             XNamedEnumerationHelper( const XNamedVec& sMap ) : mXNamedVec( sMap ), mIt( mXNamedVec.begin() ) {}
 161
 162             virtual sal_Bool SAL_CALL hasMoreElements(  ) override
 163             {
 164             return ( mIt != mXNamedVec.end() );
 165             }
 166
 167             virtual css::uno::Any SAL_CALL nextElement(  ) override
 168             {
 169                 if ( hasMoreElements() )
 170                     return css::uno::makeAny( *mIt++ );
 171                 throw css::container::NoSuchElementException();
 172             }
 173     };
 174
 175     XNamedVec mXNamedVec;
 176     typename XNamedVec::iterator cachePos;
 177 public:
 178     XNamedObjectCollectionHelper( const XNamedVec& sMap ) : mXNamedVec( sMap ), cachePos(mXNamedVec.begin()) {}
 179     // XElementAccess
 180     virtual css::uno::Type SAL_CALL getElementType(  ) override { return cppu::UnoType< OneIfc >::get(); }
 181     virtual sal_Bool SAL_CALL hasElements(  ) override { return ( mXNamedVec.size() > 0 ); }
 182     // XNameAccess
 183     virtual css::uno::Any SAL_CALL getByName( const OUString& aName ) override
 184     {
 185         if ( !hasByName(aName) )
 186             throw css::container::NoSuchElementException();
 187         return css::uno::makeAny( *cachePos );
 188     }
 189     virtual css::uno::Sequence< OUString > SAL_CALL getElementNames(  ) override
 190     {
 191         css::uno::Sequence< OUString > sNames( mXNamedVec.size() );
 192         OUString* pString = sNames.getArray();
 193         typename XNamedVec::iterator it = mXNamedVec.begin();
 194         typename XNamedVec::iterator it_end = mXNamedVec.end();
 195
 196         for ( ; it != it_end; ++it, ++pString )
 197         {
 198             css::uno::Reference< css::container::XNamed > xName( *it, css::uno::UNO_QUERY_THROW );
 199             *pString = xName->getName();
 200         }
 201         return sNames;
 202     }
 203     virtual sal_Bool SAL_CALL hasByName( const OUString& aName ) override
 204     {
 205         cachePos = mXNamedVec.begin();
 206         typename XNamedVec::iterator it_end = mXNamedVec.end();
 207         for ( ; cachePos != it_end; ++cachePos )
 208         {
 209             css::uno::Reference< css::container::XNamed > xName( *cachePos, css::uno::UNO_QUERY_THROW );
 210             if ( aName == xName->getName() )
 211                 break;
 212         }
 213         return ( cachePos != it_end );
 214     }
 215
 216     // XElementAccess
 217     virtual ::sal_Int32 SAL_CALL getCount(  ) override { return mXNamedVec.size(); }
 218     virtual css::uno::Any SAL_CALL getByIndex( ::sal_Int32 Index ) override
 219     {
 220         if ( Index < 0 || Index >= getCount() )
 221             throw css::lang::IndexOutOfBoundsException();
 222
 223         return css::uno::makeAny( mXNamedVec[ Index ] );
 224
 225     }
 226     // XEnumerationAccess
 227     virtual css::uno::Reference< css::container::XEnumeration > SAL_CALL createEnumeration(  ) override
 228     {
 229         return new XNamedEnumerationHelper( mXNamedVec );
 230     }
 231 };
 232
 233 // including a HelperInterface implementation
 234 template< typename... Ifc >
 235 class SAL_DLLPUBLIC_RTTI ScVbaCollectionBase : public InheritedHelperInterfaceImpl< Ifc... >
 236 {
 237 typedef InheritedHelperInterfaceImpl< Ifc... > BaseColBase;
 238 protected:
 239     css::uno::Reference< css::container::XIndexAccess > m_xIndexAccess;
 240     css::uno::Reference< css::container::XNameAccess > m_xNameAccess;
 241     bool mbIgnoreCase;
 242
 243     /// @throws css::uno::RuntimeException
 244     virtual css::uno::Any getItemByStringIndex( const OUString& sIndex )
 245     {
 246         if ( !m_xNameAccess.is() )
 247             throw css::uno::RuntimeException("ScVbaCollectionBase string index access not supported by this object" );
 248
 249         if( mbIgnoreCase )
 250         {
 251             const css::uno::Sequence< OUString > sElementNames = m_xNameAccess->getElementNames();
 252             for( const OUString& rName : sElementNames )
 253             {
 254                 if( rName.equalsIgnoreAsciiCase( sIndex ) )
 255                 {
 256                     return createCollectionObject( m_xNameAccess->getByName( rName ) );
 257                 }
 258             }
 259         }
 260         return createCollectionObject( m_xNameAccess->getByName( sIndex ) );
 261     }
 262
 263     /// @throws css::uno::RuntimeException
 264     /// @throws css::lang::IndexOutOfBoundsException
 265     virtual css::uno::Any getItemByIntIndex( const sal_Int32 nIndex )
 266     {
 267         if ( !m_xIndexAccess.is() )
 268             throw css::uno::RuntimeException("ScVbaCollectionBase numeric index access not supported by this object" );
 269         if ( nIndex <= 0 )
 270         {
 271             throw css::lang::IndexOutOfBoundsException(
 272                 "index is 0 or negative" );
 273         }
 274         // need to adjust for vba index ( for which first element is 1 )
 275         return createCollectionObject( m_xIndexAccess->getByIndex( nIndex - 1 ) );
 276     }
 277
 278     void UpdateCollectionIndex( const css::uno::Reference< css::container::XIndexAccess >& xIndexAccess )
 279     {
 280         css::uno::Reference< css::container::XNameAccess > xNameAccess( xIndexAccess, css::uno::UNO_QUERY_THROW );
 281         m_xIndexAccess = xIndexAccess;
 282         m_xNameAccess = xNameAccess;
 283     }
 284
 285 public:
 286     ScVbaCollectionBase( const css::uno::Reference< ov::XHelperInterface >& xParent,   const css::uno::Reference< css::uno::XComponentContext >& xContext, const css::uno::Reference< css::container::XIndexAccess >& xIndexAccess, bool bIgnoreCase = false ) : BaseColBase( xParent, xContext ), m_xIndexAccess( xIndexAccess ), mbIgnoreCase( bIgnoreCase ) { m_xNameAccess.set(m_xIndexAccess, css::uno::UNO_QUERY); }
 287
 288     //XCollection
 289     virtual ::sal_Int32 SAL_CALL getCount() override
 290     {
 291         return m_xIndexAccess->getCount();
 292     }
 293
 294     virtual css::uno::Any SAL_CALL Item(const css::uno::Any& Index1, const css::uno::Any& /*not processed in this base class*/) override
 295     {
 296         if ( Index1.getValueTypeClass() != css::uno::TypeClass_STRING )
 297         {
 298             sal_Int32 nIndex = 0;
 299
 300             if ( !( Index1 >>= nIndex ) )
 301             {
 302                 throw  css::lang::IndexOutOfBoundsException( "Couldn't convert index to Int32" );
 303             }
 304             return  getItemByIntIndex( nIndex );
 305         }
 306         OUString aStringSheet;
 307
 308         Index1 >>= aStringSheet;
 309         return getItemByStringIndex( aStringSheet );
 310     }
 311
 312     // XDefaultMethod
 313     OUString SAL_CALL getDefaultMethodName(  ) override
 314     {
 315         return "Item";
 316     }
 317     // XEnumerationAccess
 318     virtual css::uno::Reference< css::container::XEnumeration > SAL_CALL createEnumeration() override = 0;
 319
 320     // XElementAccess
 321     virtual css::uno::Type SAL_CALL getElementType() override = 0;
 322     // XElementAccess
 323     virtual sal_Bool SAL_CALL hasElements() override
 324     {
 325         return ( m_xIndexAccess->getCount() > 0 );
 326     }
 327     virtual css::uno::Any createCollectionObject( const css::uno::Any& aSource ) = 0;
 328
 329 };
 330
 331 typedef ScVbaCollectionBase< ::cppu::WeakImplHelper<ov::XCollection> > CollImplBase;
 332 // compatible with the old collections ( pre XHelperInterface base class ) ( some internal objects still use this )
 333 class VBAHELPER_DLLPUBLIC ScVbaCollectionBaseImpl : public CollImplBase
 334 {
 335 public:
 336     /// @throws css::uno::RuntimeException
 337     ScVbaCollectionBaseImpl( const css::uno::Reference< ov::XHelperInterface > & xParent, const css::uno::Reference< css::uno::XComponentContext >& xContext, const css::uno::Reference< css::container::XIndexAccess >& xIndexAccess ) : CollImplBase( xParent, xContext, xIndexAccess){}
 338
 339 };
 340
 341 template < typename... Ifc > // where Ifc must implement XCollectionTest
 342 class SAL_DLLPUBLIC_RTTI CollTestImplHelper :  public ScVbaCollectionBase< ::cppu::WeakImplHelper< Ifc... > >
 343 {
 344 typedef ScVbaCollectionBase< ::cppu::WeakImplHelper< Ifc... >  > ImplBase;
 345
 346 public:
 347     /// @throws css::uno::RuntimeException
 348     CollTestImplHelper( const css::uno::Reference< ov::XHelperInterface >& xParent, const css::uno::Reference< css::uno::XComponentContext >& xContext,  const css::uno::Reference< css::container::XIndexAccess >& xIndexAccess, bool bIgnoreCase = false ) : ImplBase( xParent, xContext, xIndexAccess, bIgnoreCase ) {}
 349 };
 350
 351
 352 #endif //SC_VBA_COLLECTION_IMPL_HXX
 353
 354 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */