connectivity/source/inc/ado/Aolewrap.hxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: Aolewrap.hxx,v $
  10  * $Revision: 1.13 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30 #ifndef _CONNECTIVITY_ADO_AOLEWRAP_HXX_
  31 #define _CONNECTIVITY_ADO_AOLEWRAP_HXX_
  32
  33 #include <osl/diagnose.h>
  34 #include <osl/thread.h>
  35 #include <map>
  36 #include <vector>
  37 #include "connectivity/StdTypeDefs.hxx"
  38
  39 namespace rtl
  40 {
  41     class OUString;
  42 }
  43 namespace connectivity
  44 {
  45     namespace ado
  46     {
  47         class OLEVariant;
  48         class WpBase
  49         {
  50         protected:
  51             IDispatch* pIUnknown;
  52
  53             void setIDispatch(IDispatch* _pIUnknown);
  54         public:
  55             WpBase();
  56             WpBase(IDispatch* pInt);
  57             //inline
  58             WpBase& operator=(const WpBase& rhs);
  59             WpBase& operator=(IDispatch* rhs);
  60             WpBase(const WpBase& aWrapper);
  61             virtual ~WpBase();
  62             void clear();
  63
  64
  65             sal_Bool IsValid() const;
  66             operator IDispatch*();
  67
  68         };
  69         //////////////////////////////////////////////////////////////////////////
  70         //
  71         // Template-Klasse WpOLEBase<class T>
  72         // ==================================
  73         //
  74         // Objekte dieser Klasse haelt einen Zeiger auf ein Interface vom Typ T.
  75         // Es gibt Konstruktoren und Zuweisungsoperator die sicherstellen, dass
  76         // AddRef() und Release() entsprechend den COM-Konventionen gerufen werden.
  77         // Ein Objekt kann auch keinen Zeiger halten (Nullzeiger), dann ergibt
  78         // der Aufruf von IsValid() FALSE.
  79         //
  80         // Um effizientes pass-by-value machen zu koennen, ist diese (ebenso wie die
  81         // abgeleiteten Klassen) eine ganz schmale Wrapper-Klasse unter Vermeidung
  82         // virtueller Methoden und mit Inlining.
  83
  84         //------------------------------------------------------------------------
  85         template<class T> class WpOLEBase : public WpBase
  86         {
  87         protected:
  88             T* pInterface;
  89
  90         public:
  91             WpOLEBase(T* pInt = NULL) : WpBase(pInt),pInterface(pInt){}
  92
  93
  94             //inline
  95             WpOLEBase<T>& operator=(const WpOLEBase<T>& rhs)
  96             {
  97                 WpBase::operator=(rhs);
  98                 pInterface = rhs.pInterface;
  99                 return *this;
 100             };
 101
 102             WpOLEBase<T>& operator=(T* rhs)
 103             {
 104                 WpBase::operator=(rhs);
 105                 pInterface = rhs.pInterface;
 106                 return *this;
 107             }
 108
 109             WpOLEBase(const WpOLEBase<T>& aWrapper)
 110             {
 111                 operator=(aWrapper);
 112             }
 113
 114             virtual ~WpOLEBase()
 115             {
 116             }
 117
 118             operator T*() const { return static_cast<T*>(pInterface); }
 119             void setWithOutAddRef(T* _pInterface)
 120             {
 121                 pInterface = _pInterface;
 122                 WpBase::setIDispatch(_pInterface);
 123             }
 124         };
 125
 126
 127         //////////////////////////////////////////////////////////////////////////
 128         //
 129         // Template-Klasse WpOLECollection<class Ts, class T, class WrapT>
 130         // ===============================================================
 131         //
 132         // Diese Klasse, welche sich von WpOLEBase<Ts> ableitet, abstrahiert die
 133         // den DAO-Collections gemeinsamen Eigenschaften:
 134         //
 135         // Sie werden ueber ein Interface Ts (etwa: DAOFields) angesprochen
 136         // und koennen ueber get_Item (hier:GetItem) Items des Typs T (genauer:
 137         // mit Interface T, etwa DAOField) herausgeben.
 138         //
 139         // Diese Wrapperklasse gibt aber nicht ein Interface T heraus,
 140         // sondern ein Objekt der Klasse WrapT. Dieses muss eine Konstruktion
 141         // durch T zulassen, vorzugsweise ist es von WpOLEBase<T> abgeleitet.
 142         //
 143
 144         //------------------------------------------------------------------------
 145         template<class Ts, class T, class WrapT> class WpOLECollection : public WpOLEBase<Ts>
 146         {
 147         public:
 148             using WpOLEBase<Ts>::pInterface;
 149             using WpOLEBase<Ts>::IsValid;
 150             // Konstruktoren, operator=
 151             // diese rufen nur die Oberklasse
 152             WpOLECollection(Ts* pInt=NULL):WpOLEBase<Ts>(pInt){}
 153             WpOLECollection(const WpOLECollection& rhs){operator=(rhs);}
 154             inline WpOLECollection& operator=(const WpOLECollection& rhs)
 155                 {WpOLEBase<Ts>::operator=(rhs); return *this;};
 156
 157             //////////////////////////////////////////////////////////////////////
 158
 159             inline void Refresh(){pInterface->Refresh();}
 160
 161             inline sal_Int32 GetItemCount()     const
 162             {
 163                 sal_Int32 nCount = 0;
 164                 return pInterface ? (SUCCEEDED(pInterface->get_Count(&nCount)) ? nCount : sal_Int32(0)) : sal_Int32(0);
 165             }
 166
 167             inline WrapT GetItem(sal_Int32 index) const
 168             {
 169                 OSL_ENSURE(index >= 0 && index<GetItemCount(),"Wrong index for field!");
 170                 T* pT = NULL;
 171                 WrapT aRet(NULL);
 172                 if(SUCCEEDED(pInterface->get_Item(OLEVariant(index), &pT)))
 173                     aRet.setWithOutAddRef(pT);
 174                 return aRet;
 175             }
 176
 177             inline WrapT GetItem(const OLEVariant& index) const
 178             {
 179                 T* pT = NULL;
 180                 WrapT aRet(NULL);
 181                 if(SUCCEEDED(pInterface->get_Item(index, &pT)))
 182                     aRet.setWithOutAddRef(pT);
 183                 return aRet;
 184             }
 185
 186             inline WrapT GetItem(const ::rtl::OUString& sStr) const
 187             {
 188                 WrapT aRet(NULL);
 189                 T* pT = NULL;
 190                 if (FAILED(pInterface->get_Item(OLEVariant(sStr), &pT)))
 191                 {
 192 #if OSL_DEBUG_LEVEL > 0
 193                     ::rtl::OString sTemp("Unknown Item: ");
 194                     sTemp += ::rtl::OString(sStr.getStr(),sStr.getLength(),osl_getThreadTextEncoding());
 195                     OSL_ENSURE(0,sTemp);
 196 #endif
 197                 }
 198                 else
 199                     aRet.setWithOutAddRef(pT);
 200                 return aRet;
 201             }
 202             inline void fillElementNames(TStringVector& _rVector)
 203             {
 204                 if(IsValid())
 205                 {
 206                     Refresh();
 207                     sal_Int32 nCount = GetItemCount();
 208                     _rVector.reserve(nCount);
 209                     for(sal_Int32 i=0;i< nCount;++i)
 210                     {
 211                         WrapT aElement = GetItem(i);
 212                         if(aElement.IsValid())
 213                             _rVector.push_back(aElement.get_Name());
 214                     }
 215                 }
 216             }
 217         };
 218
 219         template<class Ts, class T, class WrapT> class WpOLEAppendCollection:
 220                 public WpOLECollection<Ts,T,WrapT>
 221         {
 222
 223         public:
 224             // Konstruktoren, operator=
 225             // diese rufen nur die Oberklasse
 226             using WpOLEBase<Ts>::pInterface;
 227             WpOLEAppendCollection(Ts* pInt=NULL):WpOLECollection<Ts,T,WrapT>(pInt){}
 228             WpOLEAppendCollection(const WpOLEAppendCollection& rhs){ operator=(rhs); }
 229             inline WpOLEAppendCollection& operator=(const WpOLEAppendCollection& rhs)
 230                 {WpOLEBase<Ts>::operator=(rhs); return *this;};
 231             //////////////////////////////////////////////////////////////////////
 232
 233             inline sal_Bool Append(const WrapT& aWrapT)
 234             {
 235                 return SUCCEEDED(pInterface->Append(OLEVariant((T*)aWrapT)));
 236             };
 237
 238             inline sal_Bool Delete(const ::rtl::OUString& sName)
 239             {
 240                 return SUCCEEDED(pInterface->Delete(OLEVariant(sName)));
 241             };
 242
 243
 244         };
 245     }
 246 }
 247 #endif // _CONNECTIVITY_ADO_AOLEWRAP_HXX_
 248