1*b1cdbd2cSJim Jagielski /************************************************************** 2*b1cdbd2cSJim Jagielski * 3*b1cdbd2cSJim Jagielski * Licensed to the Apache Software Foundation (ASF) under one 4*b1cdbd2cSJim Jagielski * or more contributor license agreements. See the NOTICE file 5*b1cdbd2cSJim Jagielski * distributed with this work for additional information 6*b1cdbd2cSJim Jagielski * regarding copyright ownership. The ASF licenses this file 7*b1cdbd2cSJim Jagielski * to you under the Apache License, Version 2.0 (the 8*b1cdbd2cSJim Jagielski * "License"); you may not use this file except in compliance 9*b1cdbd2cSJim Jagielski * with the License. You may obtain a copy of the License at 10*b1cdbd2cSJim Jagielski * 11*b1cdbd2cSJim Jagielski * http://www.apache.org/licenses/LICENSE-2.0 12*b1cdbd2cSJim Jagielski * 13*b1cdbd2cSJim Jagielski * Unless required by applicable law or agreed to in writing, 14*b1cdbd2cSJim Jagielski * software distributed under the License is distributed on an 15*b1cdbd2cSJim Jagielski * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16*b1cdbd2cSJim Jagielski * KIND, either express or implied. See the License for the 17*b1cdbd2cSJim Jagielski * specific language governing permissions and limitations 18*b1cdbd2cSJim Jagielski * under the License. 19*b1cdbd2cSJim Jagielski * 20*b1cdbd2cSJim Jagielski *************************************************************/ 21*b1cdbd2cSJim Jagielski 22*b1cdbd2cSJim Jagielski 23*b1cdbd2cSJim Jagielski #ifndef _CONNECTIVITY_ADO_AOLEWRAP_HXX_ 24*b1cdbd2cSJim Jagielski #define _CONNECTIVITY_ADO_AOLEWRAP_HXX_ 25*b1cdbd2cSJim Jagielski 26*b1cdbd2cSJim Jagielski #include <osl/diagnose.h> 27*b1cdbd2cSJim Jagielski #include <osl/thread.h> 28*b1cdbd2cSJim Jagielski #include <map> 29*b1cdbd2cSJim Jagielski #include <vector> 30*b1cdbd2cSJim Jagielski #include "connectivity/StdTypeDefs.hxx" 31*b1cdbd2cSJim Jagielski 32*b1cdbd2cSJim Jagielski namespace rtl 33*b1cdbd2cSJim Jagielski { 34*b1cdbd2cSJim Jagielski class OUString; 35*b1cdbd2cSJim Jagielski } 36*b1cdbd2cSJim Jagielski namespace connectivity 37*b1cdbd2cSJim Jagielski { 38*b1cdbd2cSJim Jagielski namespace ado 39*b1cdbd2cSJim Jagielski { 40*b1cdbd2cSJim Jagielski class OLEVariant; 41*b1cdbd2cSJim Jagielski class WpBase 42*b1cdbd2cSJim Jagielski { 43*b1cdbd2cSJim Jagielski protected: 44*b1cdbd2cSJim Jagielski IDispatch* pIUnknown; 45*b1cdbd2cSJim Jagielski 46*b1cdbd2cSJim Jagielski void setIDispatch(IDispatch* _pIUnknown); 47*b1cdbd2cSJim Jagielski public: 48*b1cdbd2cSJim Jagielski WpBase(); 49*b1cdbd2cSJim Jagielski WpBase(IDispatch* pInt); 50*b1cdbd2cSJim Jagielski //inline 51*b1cdbd2cSJim Jagielski WpBase& operator=(const WpBase& rhs); 52*b1cdbd2cSJim Jagielski WpBase& operator=(IDispatch* rhs); 53*b1cdbd2cSJim Jagielski WpBase(const WpBase& aWrapper); 54*b1cdbd2cSJim Jagielski virtual ~WpBase(); 55*b1cdbd2cSJim Jagielski void clear(); 56*b1cdbd2cSJim Jagielski 57*b1cdbd2cSJim Jagielski 58*b1cdbd2cSJim Jagielski sal_Bool IsValid() const; 59*b1cdbd2cSJim Jagielski operator IDispatch*(); 60*b1cdbd2cSJim Jagielski 61*b1cdbd2cSJim Jagielski }; 62*b1cdbd2cSJim Jagielski ////////////////////////////////////////////////////////////////////////// 63*b1cdbd2cSJim Jagielski // 64*b1cdbd2cSJim Jagielski // Template-Klasse WpOLEBase<class T> 65*b1cdbd2cSJim Jagielski // ================================== 66*b1cdbd2cSJim Jagielski // 67*b1cdbd2cSJim Jagielski // Objekte dieser Klasse haelt einen Zeiger auf ein Interface vom Typ T. 68*b1cdbd2cSJim Jagielski // Es gibt Konstruktoren und Zuweisungsoperator die sicherstellen, dass 69*b1cdbd2cSJim Jagielski // AddRef() und Release() entsprechend den COM-Konventionen gerufen werden. 70*b1cdbd2cSJim Jagielski // Ein Objekt kann auch keinen Zeiger halten (Nullzeiger), dann ergibt 71*b1cdbd2cSJim Jagielski // der Aufruf von IsValid() FALSE. 72*b1cdbd2cSJim Jagielski // 73*b1cdbd2cSJim Jagielski // Um effizientes pass-by-value machen zu koennen, ist diese (ebenso wie die 74*b1cdbd2cSJim Jagielski // abgeleiteten Klassen) eine ganz schmale Wrapper-Klasse unter Vermeidung 75*b1cdbd2cSJim Jagielski // virtueller Methoden und mit Inlining. 76*b1cdbd2cSJim Jagielski 77*b1cdbd2cSJim Jagielski //------------------------------------------------------------------------ 78*b1cdbd2cSJim Jagielski template<class T> class WpOLEBase : public WpBase 79*b1cdbd2cSJim Jagielski { 80*b1cdbd2cSJim Jagielski protected: 81*b1cdbd2cSJim Jagielski T* pInterface; 82*b1cdbd2cSJim Jagielski 83*b1cdbd2cSJim Jagielski public: WpOLEBase(T * pInt=NULL)84*b1cdbd2cSJim Jagielski WpOLEBase(T* pInt = NULL) : WpBase(pInt),pInterface(pInt){} 85*b1cdbd2cSJim Jagielski 86*b1cdbd2cSJim Jagielski 87*b1cdbd2cSJim Jagielski //inline operator =(const WpOLEBase<T> & rhs)88*b1cdbd2cSJim Jagielski WpOLEBase<T>& operator=(const WpOLEBase<T>& rhs) 89*b1cdbd2cSJim Jagielski { 90*b1cdbd2cSJim Jagielski WpBase::operator=(rhs); 91*b1cdbd2cSJim Jagielski pInterface = rhs.pInterface; 92*b1cdbd2cSJim Jagielski return *this; 93*b1cdbd2cSJim Jagielski }; 94*b1cdbd2cSJim Jagielski operator =(T * rhs)95*b1cdbd2cSJim Jagielski WpOLEBase<T>& operator=(T* rhs) 96*b1cdbd2cSJim Jagielski { 97*b1cdbd2cSJim Jagielski WpBase::operator=(rhs); 98*b1cdbd2cSJim Jagielski pInterface = rhs.pInterface; 99*b1cdbd2cSJim Jagielski return *this; 100*b1cdbd2cSJim Jagielski } 101*b1cdbd2cSJim Jagielski WpOLEBase(const WpOLEBase<T> & aWrapper)102*b1cdbd2cSJim Jagielski WpOLEBase(const WpOLEBase<T>& aWrapper) 103*b1cdbd2cSJim Jagielski { 104*b1cdbd2cSJim Jagielski operator=(aWrapper); 105*b1cdbd2cSJim Jagielski } 106*b1cdbd2cSJim Jagielski ~WpOLEBase()107*b1cdbd2cSJim Jagielski virtual ~WpOLEBase() 108*b1cdbd2cSJim Jagielski { 109*b1cdbd2cSJim Jagielski } 110*b1cdbd2cSJim Jagielski operator T*() const111*b1cdbd2cSJim Jagielski operator T*() const { return static_cast<T*>(pInterface); } setWithOutAddRef(T * _pInterface)112*b1cdbd2cSJim Jagielski void setWithOutAddRef(T* _pInterface) 113*b1cdbd2cSJim Jagielski { 114*b1cdbd2cSJim Jagielski pInterface = _pInterface; 115*b1cdbd2cSJim Jagielski WpBase::setIDispatch(_pInterface); 116*b1cdbd2cSJim Jagielski } 117*b1cdbd2cSJim Jagielski }; 118*b1cdbd2cSJim Jagielski 119*b1cdbd2cSJim Jagielski 120*b1cdbd2cSJim Jagielski ////////////////////////////////////////////////////////////////////////// 121*b1cdbd2cSJim Jagielski // 122*b1cdbd2cSJim Jagielski // Template-Klasse WpOLECollection<class Ts, class T, class WrapT> 123*b1cdbd2cSJim Jagielski // =============================================================== 124*b1cdbd2cSJim Jagielski // 125*b1cdbd2cSJim Jagielski // Diese Klasse, welche sich von WpOLEBase<Ts> ableitet, abstrahiert die 126*b1cdbd2cSJim Jagielski // den DAO-Collections gemeinsamen Eigenschaften: 127*b1cdbd2cSJim Jagielski // 128*b1cdbd2cSJim Jagielski // Sie werden ueber ein Interface Ts (etwa: DAOFields) angesprochen 129*b1cdbd2cSJim Jagielski // und koennen ueber get_Item (hier:GetItem) Items des Typs T (genauer: 130*b1cdbd2cSJim Jagielski // mit Interface T, etwa DAOField) herausgeben. 131*b1cdbd2cSJim Jagielski // 132*b1cdbd2cSJim Jagielski // Diese Wrapperklasse gibt aber nicht ein Interface T heraus, 133*b1cdbd2cSJim Jagielski // sondern ein Objekt der Klasse WrapT. Dieses muss eine Konstruktion 134*b1cdbd2cSJim Jagielski // durch T zulassen, vorzugsweise ist es von WpOLEBase<T> abgeleitet. 135*b1cdbd2cSJim Jagielski // 136*b1cdbd2cSJim Jagielski 137*b1cdbd2cSJim Jagielski //------------------------------------------------------------------------ 138*b1cdbd2cSJim Jagielski template<class Ts, class T, class WrapT> class WpOLECollection : public WpOLEBase<Ts> 139*b1cdbd2cSJim Jagielski { 140*b1cdbd2cSJim Jagielski public: 141*b1cdbd2cSJim Jagielski using WpOLEBase<Ts>::pInterface; 142*b1cdbd2cSJim Jagielski using WpOLEBase<Ts>::IsValid; 143*b1cdbd2cSJim Jagielski // Konstruktoren, operator= 144*b1cdbd2cSJim Jagielski // diese rufen nur die Oberklasse WpOLECollection(Ts * pInt=NULL)145*b1cdbd2cSJim Jagielski WpOLECollection(Ts* pInt=NULL):WpOLEBase<Ts>(pInt){} WpOLECollection(const WpOLECollection & rhs)146*b1cdbd2cSJim Jagielski WpOLECollection(const WpOLECollection& rhs){operator=(rhs);} operator =(const WpOLECollection & rhs)147*b1cdbd2cSJim Jagielski inline WpOLECollection& operator=(const WpOLECollection& rhs) 148*b1cdbd2cSJim Jagielski {WpOLEBase<Ts>::operator=(rhs); return *this;}; 149*b1cdbd2cSJim Jagielski 150*b1cdbd2cSJim Jagielski ////////////////////////////////////////////////////////////////////// 151*b1cdbd2cSJim Jagielski Refresh()152*b1cdbd2cSJim Jagielski inline void Refresh(){pInterface->Refresh();} 153*b1cdbd2cSJim Jagielski GetItemCount() const154*b1cdbd2cSJim Jagielski inline sal_Int32 GetItemCount() const 155*b1cdbd2cSJim Jagielski { 156*b1cdbd2cSJim Jagielski sal_Int32 nCount = 0; 157*b1cdbd2cSJim Jagielski return pInterface ? (SUCCEEDED(pInterface->get_Count(&nCount)) ? nCount : sal_Int32(0)) : sal_Int32(0); 158*b1cdbd2cSJim Jagielski } 159*b1cdbd2cSJim Jagielski GetItem(sal_Int32 index) const160*b1cdbd2cSJim Jagielski inline WrapT GetItem(sal_Int32 index) const 161*b1cdbd2cSJim Jagielski { 162*b1cdbd2cSJim Jagielski OSL_ENSURE(index >= 0 && index<GetItemCount(),"Wrong index for field!"); 163*b1cdbd2cSJim Jagielski T* pT = NULL; 164*b1cdbd2cSJim Jagielski WrapT aRet(NULL); 165*b1cdbd2cSJim Jagielski if(SUCCEEDED(pInterface->get_Item(OLEVariant(index), &pT))) 166*b1cdbd2cSJim Jagielski aRet.setWithOutAddRef(pT); 167*b1cdbd2cSJim Jagielski return aRet; 168*b1cdbd2cSJim Jagielski } 169*b1cdbd2cSJim Jagielski GetItem(const OLEVariant & index) const170*b1cdbd2cSJim Jagielski inline WrapT GetItem(const OLEVariant& index) const 171*b1cdbd2cSJim Jagielski { 172*b1cdbd2cSJim Jagielski T* pT = NULL; 173*b1cdbd2cSJim Jagielski WrapT aRet(NULL); 174*b1cdbd2cSJim Jagielski if(SUCCEEDED(pInterface->get_Item(index, &pT))) 175*b1cdbd2cSJim Jagielski aRet.setWithOutAddRef(pT); 176*b1cdbd2cSJim Jagielski return aRet; 177*b1cdbd2cSJim Jagielski } 178*b1cdbd2cSJim Jagielski GetItem(const::rtl::OUString & sStr) const179*b1cdbd2cSJim Jagielski inline WrapT GetItem(const ::rtl::OUString& sStr) const 180*b1cdbd2cSJim Jagielski { 181*b1cdbd2cSJim Jagielski WrapT aRet(NULL); 182*b1cdbd2cSJim Jagielski T* pT = NULL; 183*b1cdbd2cSJim Jagielski if (FAILED(pInterface->get_Item(OLEVariant(sStr), &pT))) 184*b1cdbd2cSJim Jagielski { 185*b1cdbd2cSJim Jagielski #if OSL_DEBUG_LEVEL > 0 186*b1cdbd2cSJim Jagielski ::rtl::OString sTemp("Unknown Item: "); 187*b1cdbd2cSJim Jagielski sTemp += ::rtl::OString(sStr.getStr(),sStr.getLength(),osl_getThreadTextEncoding()); 188*b1cdbd2cSJim Jagielski OSL_ENSURE(0,sTemp); 189*b1cdbd2cSJim Jagielski #endif 190*b1cdbd2cSJim Jagielski } 191*b1cdbd2cSJim Jagielski else 192*b1cdbd2cSJim Jagielski aRet.setWithOutAddRef(pT); 193*b1cdbd2cSJim Jagielski return aRet; 194*b1cdbd2cSJim Jagielski } fillElementNames(TStringVector & _rVector)195*b1cdbd2cSJim Jagielski inline void fillElementNames(TStringVector& _rVector) 196*b1cdbd2cSJim Jagielski { 197*b1cdbd2cSJim Jagielski if(IsValid()) 198*b1cdbd2cSJim Jagielski { 199*b1cdbd2cSJim Jagielski Refresh(); 200*b1cdbd2cSJim Jagielski sal_Int32 nCount = GetItemCount(); 201*b1cdbd2cSJim Jagielski _rVector.reserve(nCount); 202*b1cdbd2cSJim Jagielski for(sal_Int32 i=0;i< nCount;++i) 203*b1cdbd2cSJim Jagielski { 204*b1cdbd2cSJim Jagielski WrapT aElement = GetItem(i); 205*b1cdbd2cSJim Jagielski if(aElement.IsValid()) 206*b1cdbd2cSJim Jagielski _rVector.push_back(aElement.get_Name()); 207*b1cdbd2cSJim Jagielski } 208*b1cdbd2cSJim Jagielski } 209*b1cdbd2cSJim Jagielski } 210*b1cdbd2cSJim Jagielski }; 211*b1cdbd2cSJim Jagielski 212*b1cdbd2cSJim Jagielski template<class Ts, class T, class WrapT> class WpOLEAppendCollection: 213*b1cdbd2cSJim Jagielski public WpOLECollection<Ts,T,WrapT> 214*b1cdbd2cSJim Jagielski { 215*b1cdbd2cSJim Jagielski 216*b1cdbd2cSJim Jagielski public: 217*b1cdbd2cSJim Jagielski // Konstruktoren, operator= 218*b1cdbd2cSJim Jagielski // diese rufen nur die Oberklasse 219*b1cdbd2cSJim Jagielski using WpOLEBase<Ts>::pInterface; WpOLEAppendCollection(Ts * pInt=NULL)220*b1cdbd2cSJim Jagielski WpOLEAppendCollection(Ts* pInt=NULL):WpOLECollection<Ts,T,WrapT>(pInt){} WpOLEAppendCollection(const WpOLEAppendCollection & rhs)221*b1cdbd2cSJim Jagielski WpOLEAppendCollection(const WpOLEAppendCollection& rhs){ operator=(rhs); } operator =(const WpOLEAppendCollection & rhs)222*b1cdbd2cSJim Jagielski inline WpOLEAppendCollection& operator=(const WpOLEAppendCollection& rhs) 223*b1cdbd2cSJim Jagielski {WpOLEBase<Ts>::operator=(rhs); return *this;}; 224*b1cdbd2cSJim Jagielski ////////////////////////////////////////////////////////////////////// 225*b1cdbd2cSJim Jagielski Append(const WrapT & aWrapT)226*b1cdbd2cSJim Jagielski inline sal_Bool Append(const WrapT& aWrapT) 227*b1cdbd2cSJim Jagielski { 228*b1cdbd2cSJim Jagielski return SUCCEEDED(pInterface->Append(OLEVariant((T*)aWrapT))); 229*b1cdbd2cSJim Jagielski }; 230*b1cdbd2cSJim Jagielski Delete(const::rtl::OUString & sName)231*b1cdbd2cSJim Jagielski inline sal_Bool Delete(const ::rtl::OUString& sName) 232*b1cdbd2cSJim Jagielski { 233*b1cdbd2cSJim Jagielski return SUCCEEDED(pInterface->Delete(OLEVariant(sName))); 234*b1cdbd2cSJim Jagielski }; 235*b1cdbd2cSJim Jagielski 236*b1cdbd2cSJim Jagielski 237*b1cdbd2cSJim Jagielski }; 238*b1cdbd2cSJim Jagielski } 239*b1cdbd2cSJim Jagielski } 240*b1cdbd2cSJim Jagielski #endif // _CONNECTIVITY_ADO_AOLEWRAP_HXX_ 241*b1cdbd2cSJim Jagielski 242