connectivity/source/inc/ado/Aolewrap.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 #ifndef _CONNECTIVITY_ADO_AOLEWRAP_HXX_
  20 #define _CONNECTIVITY_ADO_AOLEWRAP_HXX_
  21
  22 #include <osl/diagnose.h>
  23 #include <osl/thread.h>
  24 #include <map>
  25 #include <vector>
  26 #include "connectivity/StdTypeDefs.hxx"
  27
  28 namespace rtl
  29 {
  30     class OUString;
  31 }
  32 namespace connectivity
  33 {
  34     namespace ado
  35     {
  36         class OLEVariant;
  37         class WpBase
  38         {
  39         protected:
  40             IDispatch* pIUnknown;
  41
  42             void setIDispatch(IDispatch* _pIUnknown);
  43         public:
  44             WpBase();
  45             WpBase(IDispatch* pInt);
  46             //inline
  47             WpBase& operator=(const WpBase& rhs);
  48             WpBase& operator=(IDispatch* rhs);
  49             WpBase(const WpBase& aWrapper);
  50             virtual ~WpBase();
  51             void clear();
  52
  53
  54             sal_Bool IsValid() const;
  55             operator IDispatch*();
  56
  57         };
  58         //////////////////////////////////////////////////////////////////////////
  59         //
  60         // Template class WpOLEBase<class T>
  61         // ==================================
  62         //
  63         // Objects of this class contain a pointer to an interface of the type T.
  64         // The ctors and operator= make sure, that AddRef() and Release() are being
  65         // called adhering to COM conventions.
  66         // An object can also hold no pointer (null pointer), calling IsValid() then
  67         // returns false.
  68         //
  69         // In order to do efficient pass-by-value, this class (as all derived classes)
  70         // is a thin wrapper class, avoiding virtual methods and inlining.
  71         //------------------------------------------------------------------------
  72         template<class T> class WpOLEBase : public WpBase
  73         {
  74         protected:
  75             T* pInterface;
  76
  77         public:
  78             WpOLEBase(T* pInt = NULL) : WpBase(pInt),pInterface(pInt){}
  79
  80
  81             //inline
  82             WpOLEBase<T>& operator=(const WpOLEBase<T>& rhs)
  83             {
  84                 WpBase::operator=(rhs);
  85                 pInterface = rhs.pInterface;
  86                 return *this;
  87             };
  88
  89             WpOLEBase<T>& operator=(T* rhs)
  90             {
  91                 WpBase::operator=(rhs);
  92                 pInterface = rhs.pInterface;
  93                 return *this;
  94             }
  95
  96             WpOLEBase(const WpOLEBase<T>& aWrapper)
  97                 : WpBase( aWrapper )
  98                 , pInterface( aWrapper.pInterface )
  99             {
 100             }
 101
 102             virtual ~WpOLEBase()
 103             {
 104             }
 105
 106             operator T*() const { return static_cast<T*>(pInterface); }
 107             void setWithOutAddRef(T* _pInterface)
 108             {
 109                 pInterface = _pInterface;
 110                 WpBase::setIDispatch(_pInterface);
 111             }
 112         };
 113
 114
 115         //////////////////////////////////////////////////////////////////////////
 116         //
 117         // Template class WpOLECollection<class Ts, class T, class WrapT>
 118         // ===============================================================
 119         //
 120         // This class (derived from WpOLEBase<Ts>), abstracts away the properties
 121         // common to DAO collections:
 122         //
 123         // They are accessed via an interface Ts (e.g. DAOFields) and can return
 124         // Items of the Type T (actually: with the interface T, e.g. DAOField)
 125         // via get_Item (here GetItem).
 126         //
 127         // This wrapper class does not expose an interface T, however,
 128         // it exposes an object of the class WrapT. This must allow a construction
 129         // by T, preferably it is derived from WpOLEBase<T>.
 130         //
 131         //------------------------------------------------------------------------
 132         template<class Ts, class T, class WrapT> class WpOLECollection : public WpOLEBase<Ts>
 133         {
 134         public:
 135             using WpOLEBase<Ts>::pInterface;
 136             using WpOLEBase<Ts>::IsValid;
 137             // Ctors, operator=
 138             // They only call the superclass
 139             WpOLECollection(Ts* pInt=NULL):WpOLEBase<Ts>(pInt){}
 140             WpOLECollection(const WpOLECollection& rhs) : WpOLEBase<Ts>(rhs) {}
 141             inline WpOLECollection& operator=(const WpOLECollection& rhs)
 142                 {WpOLEBase<Ts>::operator=(rhs); return *this;};
 143
 144             //////////////////////////////////////////////////////////////////////
 145
 146             inline void Refresh(){pInterface->Refresh();}
 147
 148             inline sal_Int32 GetItemCount() const
 149             {
 150                 sal_Int32 nCount = 0;
 151                 return pInterface ? (SUCCEEDED(pInterface->get_Count(&nCount)) ? nCount : sal_Int32(0)) : sal_Int32(0);
 152             }
 153
 154             inline WrapT GetItem(sal_Int32 index) const
 155             {
 156                 OSL_ENSURE(index >= 0 && index<GetItemCount(),"Wrong index for field!");
 157                 T* pT = NULL;
 158                 WrapT aRet(NULL);
 159                 if(SUCCEEDED(pInterface->get_Item(OLEVariant(index), &pT)))
 160                     aRet.setWithOutAddRef(pT);
 161                 return aRet;
 162             }
 163
 164             inline WrapT GetItem(const OLEVariant& index) const
 165             {
 166                 T* pT = NULL;
 167                 WrapT aRet(NULL);
 168                 if(SUCCEEDED(pInterface->get_Item(index, &pT)))
 169                     aRet.setWithOutAddRef(pT);
 170                 return aRet;
 171             }
 172
 173             inline WrapT GetItem(const OUString& sStr) const
 174             {
 175                 WrapT aRet(NULL);
 176                 T* pT = NULL;
 177                 if (FAILED(pInterface->get_Item(OLEVariant(sStr), &pT)))
 178                 {
 179 #if OSL_DEBUG_LEVEL > 0
 180                     OString sTemp("Unknown Item: ");
 181                     sTemp += OString(sStr.getStr(),sStr.getLength(),osl_getThreadTextEncoding());
 182                     OSL_FAIL(sTemp.getStr());
 183 #endif
 184                 }
 185                 else
 186                     aRet.setWithOutAddRef(pT);
 187                 return aRet;
 188             }
 189             inline void fillElementNames(TStringVector& _rVector)
 190             {
 191                 if(IsValid())
 192                 {
 193                     Refresh();
 194                     sal_Int32 nCount = GetItemCount();
 195                     _rVector.reserve(nCount);
 196                     for(sal_Int32 i=0;i< nCount;++i)
 197                     {
 198                         WrapT aElement = GetItem(i);
 199                         if(aElement.IsValid())
 200                             _rVector.push_back(aElement.get_Name());
 201                     }
 202                 }
 203             }
 204         };
 205
 206         template<class Ts, class T, class WrapT> class WpOLEAppendCollection:
 207                 public WpOLECollection<Ts,T,WrapT>
 208         {
 209
 210         public:
 211             // Ctors, operator=
 212             // They only call the superclass
 213             using WpOLEBase<Ts>::pInterface;
 214             WpOLEAppendCollection(Ts* pInt=NULL):WpOLECollection<Ts,T,WrapT>(pInt){}
 215             WpOLEAppendCollection(const WpOLEAppendCollection& rhs) : WpOLECollection<Ts, T, WrapT>(rhs) {}
 216             inline WpOLEAppendCollection& operator=(const WpOLEAppendCollection& rhs)
 217                 {WpOLEBase<Ts>::operator=(rhs); return *this;};
 218             //////////////////////////////////////////////////////////////////////
 219
 220             inline sal_Bool Append(const WrapT& aWrapT)
 221             {
 222                 return SUCCEEDED(pInterface->Append(OLEVariant((T*)aWrapT)));
 223             };
 224
 225             inline sal_Bool Delete(const OUString& sName)
 226             {
 227                 return SUCCEEDED(pInterface->Delete(OLEVariant(sName)));
 228             };
 229
 230
 231         };
 232     }
 233 }
 234 #endif // _CONNECTIVITY_ADO_AOLEWRAP_HXX_
 235
 236 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */