initial import

1 files changed, 1021 insertions, 0 deletions

diff --git a/connectivity/source/inc/ado/Awrapado.hxx b/connectivity/source/inc/ado/Awrapado.hxx
new file mode 100644
index 000000000000..84e60c600a33
--- /dev/null
+++ b/connectivity/source/inc/ado/Awrapado.hxx
@@ -0,0 +1,1021 @@
+/*************************************************************************
+ *
+ *  $RCSfile: Awrapado.hxx,v $
+ *
+ *  $Revision: 1.1.1.1 $
+ *
+ *  last change: $Author: hr $ $Date: 2000-09-18 16:14:25 $
+ *
+ *  The Contents of this file are made available subject to the terms of
+ *  either of the following licenses
+ *
+ *         - GNU Lesser General Public License Version 2.1
+ *         - Sun Industry Standards Source License Version 1.1
+ *
+ *  Sun Microsystems Inc., October, 2000
+ *
+ *  GNU Lesser General Public License Version 2.1
+ *  =============================================
+ *  Copyright 2000 by Sun Microsystems, Inc.
+ *  901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1, as published by the Free Software Foundation.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *  MA  02111-1307  USA
+ *
+ *
+ *  Sun Industry Standards Source License Version 1.1
+ *  =================================================
+ *  The contents of this file are subject to the Sun Industry Standards
+ *  Source License Version 1.1 (the "License"); You may not use this file
+ *  except in compliance with the License. You may obtain a copy of the
+ *  License at http://www.openoffice.org/license.html.
+ *
+ *  Software provided under this License is provided on an "AS IS" basis,
+ *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+ *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
+ *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
+ *  See the License for the specific provisions governing your rights and
+ *  obligations concerning the Software.
+ *
+ *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
+ *
+ *  Copyright: 2000 by Sun Microsystems, Inc.
+ *
+ *  All Rights Reserved.
+ *
+ *  Contributor(s): _______________________________________
+ *
+ *
+ ************************************************************************/
+#ifndef _CONNECTIVITY_ADO_AWRAPADO_HXX_
+#define _CONNECTIVITY_ADO_AWRAPADO_HXX_
+
+#include <tools/prewin.h>
+// Includes fuer ADO
+#include <oledb.h>
+//#include <objbase.h>
+//#include <initguid.h>
+//#include <mapinls.h>
+#include <ocidl.h>
+
+#ifndef _ADOINT_H_
+#include <adoint.h>
+#endif
+
+#include <tools/postwin.h>
+
+#ifndef _CONNECTIVITY_ADO_ADOIMP_HXX_
+#include "ado/adoimp.hxx"
+#endif
+#ifndef _CONNECTIVITY_ADO_AOLEWRAP_HXX_
+#include "ado/Aolewrap.hxx"
+#endif
+#ifndef _CONNECTIVITY_ADO_AOLEVARIANT_HXX_
+#include "ado/Aolevariant.hxx"
+#endif
+
+namespace connectivity
+{
+    namespace ado
+    {
+        class WpADOConnection;
+        class WpADOCommand;
+        class WpADORecordset;
+        class WpADOField;
+        class WpADOParameter;
+        class WpADOError;
+        class WpADOProperty;
+
+        typedef WpOLEAppendCollection<ADOFields, ADOField, WpADOField> WpADOFields;
+
+        //------------------------------------------------------------------------
+        class WpADOConnection : public WpOLEBase<ADOConnection>
+        {
+            friend class WpADOCommand;
+        public:
+
+            WpADOConnection(ADOConnection* pInt)    :   WpOLEBase<ADOConnection>(pInt){}
+
+            WpADOConnection(const WpADOConnection& rhs){operator=(rhs);}
+
+            inline WpADOConnection& operator=(const WpADOConnection& rhs)
+                {WpOLEBase<ADOConnection>::operator=(rhs); return *this;}
+
+            //////////////////////////////////////////////////////////////////////
+
+            inline ADOProperties* get_Properties() const
+            {
+                ADOProperties* pProps=NULL;
+                pInterface->get_Properties(&pProps);
+                return pProps;
+            }
+
+            inline rtl::OUString GetConnectionString() const
+            {
+                BSTR aBSTR; pInterface->get_ConnectionString(&aBSTR);
+                rtl::OUString sRetStr((sal_Unicode*)aBSTR);
+                SysFreeString(aBSTR);
+                return sRetStr;
+            }
+
+            inline sal_Bool PutConnectionString(const ::rtl::OUString &aCon) const
+            {
+                return SUCCEEDED(pInterface->put_ConnectionString(SysAllocString(aCon.getStr())));
+            }
+
+            inline sal_Int32 GetCommandTimeout() const
+            {
+                sal_Int32 nRet;
+                pInterface->get_CommandTimeout(&nRet);
+                return nRet;
+            }
+
+            inline void PutCommandTimeout(sal_Int32 nRet)
+            {
+                pInterface->put_CommandTimeout(nRet);
+            }
+
+            inline sal_Int32 GetConnectionTimeout() const
+            {
+                sal_Int32 nRet;
+                pInterface->get_ConnectionTimeout(&nRet);
+                return nRet;
+            }
+
+            inline void PutConnectionTimeout(sal_Int32 nRet)
+            {
+                pInterface->put_ConnectionTimeout(nRet);
+            }
+
+            inline sal_Bool Close( )
+            {
+                return (SUCCEEDED(pInterface->Close()));
+            }
+
+            inline sal_Bool Execute(const ::rtl::OUString& _CommandText,OLEVariant& RecordsAffected,long Options, WpADORecordset** ppiRset)
+            {
+                return SUCCEEDED(pInterface->Execute(SysAllocString(_CommandText.getStr()),&RecordsAffected,Options,(_ADORecordset**)ppiRset));
+            }
+
+            inline sal_Bool BeginTrans()
+            {
+                sal_Int32 nIso;
+                return SUCCEEDED(pInterface->BeginTrans(&nIso));
+            }
+
+            inline sal_Bool CommitTrans( )
+            {
+                return SUCCEEDED(pInterface->CommitTrans());
+            }
+
+            inline sal_Bool RollbackTrans( )
+            {
+                return SUCCEEDED(pInterface->RollbackTrans());
+            }
+
+            inline sal_Bool Open(const ::rtl::OUString& ConnectionString, const ::rtl::OUString& UserID,const ::rtl::OUString& Password,long Options)
+            {
+                return SUCCEEDED(pInterface->Open(SysAllocString(ConnectionString.getStr()),SysAllocString(UserID.getStr()),SysAllocString(Password.getStr()),Options));
+            }
+
+            inline sal_Bool GetErrors(ADOErrors** pErrors)
+            {
+                return SUCCEEDED(pInterface->get_Errors(pErrors));
+            }
+
+            inline ::rtl::OUString GetDefaultDatabase() const
+            {
+                BSTR aBSTR; pInterface->get_DefaultDatabase(&aBSTR);
+                ::rtl::OUString sRetStr(aBSTR);
+                SysFreeString(aBSTR); return sRetStr;
+            }
+
+            inline sal_Bool PutDefaultDatabase(const ::rtl::OUString& bstr)
+            {
+                return SUCCEEDED(pInterface->put_DefaultDatabase(SysAllocString(bstr.getStr())));
+            }
+
+            inline IsolationLevelEnum get_IsolationLevel() const
+            {
+                IsolationLevelEnum eNum;
+                pInterface->get_IsolationLevel(&eNum);
+                return eNum;
+            }
+
+            inline sal_Bool put_IsolationLevel(const IsolationLevelEnum& eNum)
+            {
+                return SUCCEEDED(pInterface->put_IsolationLevel(eNum));
+            }
+
+            inline sal_Int32 get_Attributes() const
+            {
+                sal_Int32 nRet;
+                pInterface->get_Attributes(&nRet);
+                return nRet;
+            }
+
+            inline sal_Bool put_Attributes(sal_Int32 nRet)
+            {
+                return SUCCEEDED(pInterface->put_Attributes(nRet));
+            }
+
+            inline CursorLocationEnum get_CursorLocation() const
+            {
+                CursorLocationEnum eNum;
+                pInterface->get_CursorLocation(&eNum);
+                return eNum;
+            }
+
+            inline sal_Bool put_CursorLocation(const CursorLocationEnum &eNum)
+            {
+                return SUCCEEDED(pInterface->put_CursorLocation(eNum));
+            }
+
+            inline ConnectModeEnum get_Mode() const
+            {
+                ConnectModeEnum eNum;
+                pInterface->get_Mode(&eNum);
+                return eNum;
+            }
+
+            inline sal_Bool put_Mode(const ConnectModeEnum &eNum)
+            {
+
+                return SUCCEEDED(pInterface->put_Mode(eNum));
+            }
+
+            inline ::rtl::OUString get_Provider() const
+            {
+                BSTR aBSTR; pInterface->get_Provider(&aBSTR);
+                ::rtl::OUString sRetStr(aBSTR);
+                SysFreeString(aBSTR); return sRetStr;
+            }
+
+            inline sal_Bool put_Provider(const ::rtl::OUString& bstr)
+            {
+                return SUCCEEDED(pInterface->put_Provider(SysAllocString(bstr.getStr())));
+            }
+
+            inline sal_Int32 get_State() const
+            {
+                sal_Int32 nRet;
+                pInterface->get_State(&nRet);
+                return nRet;
+            }
+
+            inline sal_Bool OpenSchema(SchemaEnum eNum,OLEVariant& Restrictions,OLEVariant& SchemaID,ADORecordset**pprset)
+            {
+                return SUCCEEDED(pInterface->OpenSchema(eNum,Restrictions,SchemaID,pprset));
+            }
+
+            inline ::rtl::OUString get_Version() const
+            {
+                BSTR aBSTR;
+                pInterface->get_Version(&aBSTR);
+                ::rtl::OUString sRetStr(aBSTR);
+                SysFreeString(aBSTR); return sRetStr;
+            }
+        };
+
+        //------------------------------------------------------------------------
+        class WpADOCommand : public WpOLEBase<ADOCommand>
+        {
+        public:
+            WpADOCommand(){}
+            // Konstruktoren, operator=
+            // diese rufen nur die Oberklasse
+            WpADOCommand(ADOCommand* pInt)  :   WpOLEBase<ADOCommand>(pInt){}
+
+            WpADOCommand(const WpADOCommand& rhs){operator=(rhs);}
+
+            inline WpADOCommand& operator=(const WpADOCommand& rhs)
+            {
+                WpOLEBase<ADOCommand>::operator=(rhs); return *this;}
+
+            //////////////////////////////////////////////////////////////////////
+
+            sal_Bool putref_ActiveConnection( WpADOConnection *pCon)
+            {
+                return SUCCEEDED(pInterface->putref_ActiveConnection(pCon->pInterface));
+            }
+
+            void put_ActiveConnection(/* [in] */ const OLEVariant& vConn)
+            {
+                pInterface->put_ActiveConnection(vConn);
+            }
+
+            inline void Create()
+            {
+                IClassFactory2* pIUnknown   = NULL;
+                IUnknown        *pOuter     = NULL;
+                HRESULT         hr;
+                hr = CoGetClassObject( ADOS::CLSID_ADOCOMMAND_21,
+                                      CLSCTX_INPROC_SERVER,
+                                      NULL,
+                                      IID_IClassFactory2,
+                                      (void**)&pIUnknown );
+
+                if( !FAILED( hr ) )
+                {
+                    pIUnknown->AddRef();
+                    ADOCommand* pCommand;
+
+                    hr = pIUnknown->CreateInstanceLic(  pOuter,
+                                                        NULL,
+                                                        ADOS::IID_ADOCOMMAND_21,
+                                                        ADOS::GetKeyStr(),
+                                                        (void**) &pCommand);
+
+                    if( !FAILED( hr ) )
+                    {
+                        pInterface = pCommand;
+                        pInterface->AddRef();
+                    }
+                    pIUnknown->Release();
+                }
+            }
+
+            inline sal_Int32 get_State() const
+            {
+                sal_Int32 nRet;
+                pInterface->get_State(&nRet);
+                return nRet;
+            }
+
+            inline ::rtl::OUString get_CommandText() const
+            {
+                BSTR aBSTR; pInterface->get_CommandText(&aBSTR);
+                ::rtl::OUString sRetStr(aBSTR);
+                SysFreeString(aBSTR); return sRetStr;
+            }
+
+            inline sal_Bool put_CommandText(const ::rtl::OUString &aCon)
+            {
+                BSTR bstr = SysAllocString(aCon.getStr());
+                sal_Bool bErg = SUCCEEDED(pInterface->put_CommandText(bstr));
+                SysFreeString(bstr);
+                return bErg;
+            }
+
+            inline sal_Int32 get_CommandTimeout() const
+            {
+                sal_Int32 nRet;
+                pInterface->get_CommandTimeout(&nRet);
+                return nRet;
+            }
+
+            inline void put_CommandTimeout(sal_Int32 nRet)
+            {
+                pInterface->put_CommandTimeout(nRet);
+            }
+
+            inline sal_Bool get_Prepared() const
+            {
+                VARIANT_BOOL bPrepared;
+                pInterface->get_Prepared(&bPrepared);
+                return bPrepared == VARIANT_TRUE;
+            }
+
+            inline sal_Bool put_Prepared(VARIANT_BOOL bPrepared) const
+            {
+                return SUCCEEDED(pInterface->put_Prepared(bPrepared));
+            }
+
+            inline sal_Bool Execute(OLEVariant& RecordsAffected,OLEVariant& Parameters,long Options, ADORecordset** ppiRset)
+            {
+                return SUCCEEDED(pInterface->Execute(&RecordsAffected,&Parameters,Options,ppiRset));
+            }
+
+            inline ADOParameter* CreateParameter(const ::rtl::OUString &bstr,DataTypeEnum Type,ParameterDirectionEnum Direction,long nSize,const OLEVariant &Value)
+            {
+                ADOParameter* pPara = NULL;
+                if(SUCCEEDED(pInterface->CreateParameter(bstr.getLength() ? SysAllocString(bstr.getStr()) : NULL,Type,Direction,nSize,Value,&pPara)))
+                    return pPara;
+                return NULL;
+            }
+
+            inline ADOParameters* get_Parameters() const
+            {
+                ADOParameters* pPara;
+                pInterface->get_Parameters(&pPara);
+                return pPara;
+            }
+
+            inline sal_Bool put_CommandType( /* [in] */ CommandTypeEnum lCmdType)
+            {
+                return SUCCEEDED(pInterface->put_CommandType(lCmdType));
+            }
+
+            inline CommandTypeEnum get_CommandType( ) const
+            {
+                CommandTypeEnum eNum;
+                pInterface->get_CommandType(&eNum);
+                return eNum;
+            }
+
+            // gibt den Namen des Feldes zur"ueck
+            inline ::rtl::OUString GetName() const
+            {
+                BSTR aBSTR; pInterface->get_Name(&aBSTR);
+                ::rtl::OUString sRetStr(aBSTR);
+                SysFreeString(aBSTR); return sRetStr;
+            }
+
+            inline sal_Bool put_Name(const ::rtl::OUString& _Name)
+            {
+                return SUCCEEDED(pInterface->put_Name(SysAllocString(_Name.getStr())));
+            }
+            inline sal_Bool Cancel()
+            {
+                return SUCCEEDED(pInterface->Cancel());
+            }
+        };
+        //------------------------------------------------------------------------
+        class WpADOError:public WpOLEBase<ADOError>
+        {
+        public:
+
+            // Konstruktoren, operator=
+            // diese rufen nur die Oberklasse
+
+            WpADOError(ADOError* pInt):WpOLEBase<ADOError>(pInt){}
+
+            WpADOError(const WpADOError& rhs){operator=(rhs);}
+
+            inline WpADOError& operator=(const WpADOError& rhs)
+                {WpOLEBase<ADOError>::operator=(rhs); return *this;}
+
+            //////////////////////////////////////////////////////////////////////
+
+            inline ::rtl::OUString GetDescription() const
+            {
+                BSTR aBSTR; pInterface->get_Description(&aBSTR);
+                ::rtl::OUString sRetStr(aBSTR);
+                SysFreeString(aBSTR); return sRetStr;
+            }
+
+            inline ::rtl::OUString GetSource() const {BSTR aBSTR; pInterface->get_Source(&aBSTR);
+                                ::rtl::OUString sRetStr(aBSTR);
+                                SysFreeString(aBSTR); return sRetStr;}
+
+            inline sal_Int32 GetNumber() const {sal_Int32 nErrNr; pInterface->get_Number(&nErrNr);
+                                    return nErrNr;}
+
+            inline ::rtl::OUString GetSQLState() const
+            {
+                BSTR aBSTR; pInterface->get_SQLState(&aBSTR);
+                ::rtl::OUString sRetStr(aBSTR);
+                SysFreeString(aBSTR); return sRetStr;
+            }
+
+            inline sal_Int32 GetNativeError() const
+            {
+                sal_Int32 nErrNr; pInterface->get_NativeError(&nErrNr);
+                return nErrNr;
+            }
+        };
+
+
+
+        //------------------------------------------------------------------------
+        class WpADOField : public WpOLEBase<ADOField>
+        {
+            //  friend class WpADOFields;
+        public:
+
+            // Konstruktoren, operator=
+            // diese rufen nur die Oberklasse
+            WpADOField(ADOField* pInt=NULL):WpOLEBase<ADOField>(pInt){}
+            WpADOField(const WpADOField& rhs){operator=(rhs);}
+
+            inline WpADOField& operator=(const WpADOField& rhs)
+                {WpOLEBase<ADOField>::operator=(rhs); return *this;}
+            //////////////////////////////////////////////////////////////////////
+
+            inline ADOProperties* get_Properties()
+            {
+                ADOProperties* pProps = NULL;
+                pInterface->get_Properties(&pProps);
+                return pProps;
+            }
+
+            inline sal_Int32 GetActualSize() const
+            {
+                sal_Int32 nActualSize; pInterface->get_ActualSize(&nActualSize);
+                return nActualSize;
+            }
+
+            inline sal_Int32 GetAttributes() const
+            {
+                sal_Int32 eADOSFieldAttributes; pInterface->get_Attributes(&eADOSFieldAttributes);
+                return eADOSFieldAttributes;
+            }
+
+            inline sal_Int32 GetStatus() const
+            {
+                sal_Int32 eADOSFieldAttributes=0;
+                //  pInterface->get_Status(&eADOSFieldAttributes);
+                return eADOSFieldAttributes;
+            }
+
+            inline sal_Int32 GetDefinedSize() const
+            {
+                sal_Int32 nDefinedSize;
+                pInterface->get_DefinedSize(&nDefinedSize);
+                return nDefinedSize;
+            }
+
+            // gibt den Namen des Feldes zur"ueck
+            inline ::rtl::OUString GetName() const
+            {
+                BSTR aBSTR; pInterface->get_Name(&aBSTR);
+                ::rtl::OUString sRetStr(aBSTR);
+                SysFreeString(aBSTR); return sRetStr;
+            }
+
+            inline DataTypeEnum GetADOType() const
+            {
+                DataTypeEnum eType; pInterface->get_Type(&eType);
+                return eType;
+            }
+
+            inline void get_Value(OLEVariant& aValVar) const
+            {
+                aValVar.setEmpty();
+                pInterface->get_Value(&aValVar);
+            }
+
+            inline OLEVariant get_Value() const
+            {
+                OLEVariant aValVar;
+                pInterface->get_Value(&aValVar);
+                return aValVar;
+            }
+
+            inline sal_Bool PutValue(const OLEVariant& aVariant)
+            {
+                return (SUCCEEDED(pInterface->put_Value(aVariant)));
+            }
+
+            inline sal_Int32 GetPrecision() const
+            {
+                sal_uInt8 eType; pInterface->get_Precision(&eType);
+                return eType;
+            }
+
+            inline sal_Int32 GetNumericScale() const
+            {
+                sal_uInt8 eType; pInterface->get_NumericScale(&eType);
+                return eType;
+            }
+
+            inline sal_Bool AppendChunk(const OLEVariant& _Variant)
+            {
+                return (SUCCEEDED(pInterface->AppendChunk(_Variant)));
+            }
+
+            inline OLEVariant GetChunk(long Length) const
+            {
+                OLEVariant aValVar;
+                pInterface->GetChunk(Length,&aValVar);
+                return aValVar;
+            }
+
+            inline void GetChunk(long Length,OLEVariant &aValVar) const
+            {
+                pInterface->GetChunk(Length,&aValVar);
+            }
+
+            inline OLEVariant GetOriginalValue() const
+            {
+                OLEVariant aValVar;
+                pInterface->get_OriginalValue(&aValVar);
+                return aValVar;
+            }
+
+            inline void GetOriginalValue(OLEVariant &aValVar) const
+            {
+                pInterface->get_OriginalValue(&aValVar);
+            }
+
+            inline OLEVariant GetUnderlyingValue() const
+            {
+                OLEVariant aValVar;
+                pInterface->get_UnderlyingValue(&aValVar);
+                return aValVar;
+            }
+
+            inline void GetUnderlyingValue(OLEVariant &aValVar) const
+            {
+                pInterface->get_UnderlyingValue(&aValVar);
+            }
+
+            inline sal_Bool PutPrecision(sal_Int8 _prec)
+            {
+                return (SUCCEEDED(pInterface->put_Precision(_prec)));
+            }
+
+            inline sal_Bool PutNumericScale(sal_Int8 _prec)
+            {
+                return (SUCCEEDED(pInterface->put_NumericScale(_prec)));
+            }
+
+            inline void PutADOType(DataTypeEnum eType)
+            {
+                pInterface->put_Type(eType);
+            }
+
+            inline sal_Bool PutDefinedSize(sal_Int32 _nDefSize)
+            {
+                return (SUCCEEDED(pInterface->put_DefinedSize(_nDefSize)));
+            }
+
+            inline sal_Bool PutAttributes(sal_Int32 _nDefSize)
+            {
+                return (SUCCEEDED(pInterface->put_Attributes(_nDefSize)));
+            }
+        };
+
+
+
+        //------------------------------------------------------------------------
+        class WpADOProperty: public WpOLEBase<ADOProperty>
+        {
+            friend class WpADOProperties;
+
+        public:
+            // Konstruktoren, operator=
+            // diese rufen nur die Oberklasse
+            WpADOProperty(ADOProperty* pInt):WpOLEBase<ADOProperty>(pInt){}
+            WpADOProperty(const WpADOProperty& rhs){operator=(rhs);}
+            inline WpADOProperty& operator=(const WpADOProperty& rhs)
+                {WpOLEBase<ADOProperty>::operator=(rhs); return *this;}
+            //////////////////////////////////////////////////////////////////////
+
+            inline OLEVariant GetValue() const
+            {
+                OLEVariant aValVar;
+                pInterface->get_Value(&aValVar);
+                return aValVar;
+            }
+
+            inline void GetValue(OLEVariant &aValVar) const
+            {
+                pInterface->get_Value(&aValVar);
+            }
+
+            inline sal_Bool PutValue(const OLEVariant &aValVar)
+            {
+                return (SUCCEEDED(pInterface->put_Value(aValVar)));
+            }
+
+            inline ::rtl::OUString GetName() const
+            {
+                BSTR aBSTR; pInterface->get_Name(&aBSTR);
+                ::rtl::OUString sRetStr(aBSTR);
+                SysFreeString(aBSTR); return sRetStr;
+            }
+
+            inline DataTypeEnum GetADOType() const
+            {
+                DataTypeEnum eType; pInterface->get_Type(&eType);
+                return eType;
+            }
+
+            inline sal_Int32 GetAttributes() const
+            {
+                sal_Int32 eADOSFieldAttributes; pInterface->get_Attributes(&eADOSFieldAttributes);
+                return eADOSFieldAttributes;
+            }
+
+            inline sal_Bool PutAttributes(sal_Int32 _nDefSize)
+            {
+                return (SUCCEEDED(pInterface->put_Attributes(_nDefSize)));
+            }
+        };
+
+
+        class WpADORecordset:public WpOLEBase<ADORecordset>
+        {
+
+        public:
+            // Konstruktoren, operator=
+            // diese rufen nur die Oberklasse
+            WpADORecordset(ADORecordset* pInt=NULL):WpOLEBase<ADORecordset>(pInt){}
+            WpADORecordset(const WpADORecordset& rhs){operator=(rhs);}
+            inline WpADORecordset& operator=(const WpADORecordset& rhs)
+            {
+                WpOLEBase<ADORecordset>::operator=(rhs);
+                return *this;
+            }
+            ~WpADORecordset()
+            {
+                //  if(pInterface && get_State() == adStateOpen)
+                    //  Close();
+            }
+            //////////////////////////////////////////////////////////////////////
+            inline void Create()
+            {
+                IClassFactory2* pIUnknown   = NULL;
+                IUnknown        *pOuter     = NULL;
+                HRESULT         hr;
+                hr = CoGetClassObject( ADOS::CLSID_ADORECORDSET_21,
+                                      CLSCTX_INPROC_SERVER,
+                                      NULL,
+                                      IID_IClassFactory2,
+                                      (void**)&pIUnknown );
+
+                if( !FAILED( hr ) )
+                {
+                    pIUnknown->AddRef();
+
+                    ADORecordset *pRec = NULL;
+                    hr = pIUnknown->CreateInstanceLic(  pOuter,
+                                                        NULL,
+                                                        ADOS::IID_ADORECORDSET_21,
+                                                        ADOS::GetKeyStr(),
+                                                        (void**) &pRec);
+
+                    if( !FAILED( hr ) )
+                    {
+                        pInterface = pRec;
+                        pInterface->AddRef();
+                    }
+                    pIUnknown->Release();
+                }
+            }
+
+            inline sal_Bool Open(
+                    /* [optional][in] */ VARIANT Source,
+                    /* [optional][in] */ VARIANT ActiveConnection,
+                    /* [defaultvalue][in] */ CursorTypeEnum CursorType,
+                    /* [defaultvalue][in] */ LockTypeEnum LockType,
+                    /* [defaultvalue][in] */ sal_Int32 Options)
+            {
+                return (SUCCEEDED(pInterface->Open(Source,ActiveConnection,CursorType,LockType,Options)));
+            }
+
+
+            inline LockTypeEnum GetLockType()
+            {
+                LockTypeEnum eType;
+                pInterface->get_LockType(&eType);
+                return eType;
+            }
+
+            inline void Close()
+            {
+                pInterface->Close();
+            }
+
+            inline sal_Bool Cancel() const
+            {
+                return (SUCCEEDED(pInterface->Cancel()));
+            }
+
+            inline sal_Int32 get_State( )
+            {
+                sal_Int32 nState = 0;
+                pInterface->get_State(&nState);
+                return nState;
+            }
+
+            inline sal_Bool Supports( /* [in] */ CursorOptionEnum CursorOptions)
+            {
+                VARIANT_BOOL bSupports;
+                pInterface->Supports(CursorOptions,&bSupports);
+                return (sal_Bool) bSupports;
+            }
+
+            PositionEnum get_AbsolutePosition()
+            {
+                PositionEnum aTemp;
+                pInterface->get_AbsolutePosition(&aTemp);
+                return aTemp;
+            }
+
+            inline void GetDataSource(IUnknown** pIUnknown) const
+            {
+                pInterface->get_DataSource(pIUnknown);
+            }
+
+            inline void PutRefDataSource(IUnknown* pIUnknown)
+            {
+                pInterface->putref_DataSource(pIUnknown);
+            }
+
+            inline void GetBookmark(VARIANT& var)
+            {
+                pInterface->get_Bookmark(&var);
+            }
+
+            inline OLEVariant GetBookmark()
+            {
+                OLEVariant var;
+                pInterface->get_Bookmark(&var);
+                return var;
+            }
+
+            CompareEnum CompareBookmarks(const OLEVariant& left,const OLEVariant& right)
+            {
+                CompareEnum eNum;
+                pInterface->CompareBookmarks(left,right,&eNum);
+                return eNum;
+            }
+
+            inline sal_Bool SetBookmark(const OLEVariant &pSafeAr)
+            {
+                return SUCCEEDED(pInterface->put_Bookmark(pSafeAr));
+            }
+
+
+            inline ADOFields* GetFields() const
+            {
+                ADOFields* pFields;
+                pInterface->get_Fields(&pFields);
+                return pFields;
+            }
+
+
+            inline sal_Bool Move(sal_Int32 nRows, VARIANT aBmk) {return SUCCEEDED(pInterface->Move(nRows, aBmk));}
+            inline sal_Bool MoveNext() {return SUCCEEDED(pInterface->MoveNext());}
+            inline sal_Bool MovePrevious() {return SUCCEEDED(pInterface->MovePrevious());}
+            inline sal_Bool MoveFirst() {return SUCCEEDED(pInterface->MoveFirst());}
+            inline sal_Bool MoveLast()  {return SUCCEEDED(pInterface->MoveLast());}
+
+            inline sal_Bool IsAtBOF() const
+            {
+                VARIANT_BOOL bIsAtBOF;
+                pInterface->get_BOF(&bIsAtBOF);
+                return (sal_Bool) bIsAtBOF;
+            }
+
+            inline sal_Bool IsAtEOF() const
+            {
+                VARIANT_BOOL bIsAtEOF;
+                pInterface->get_EOF(&bIsAtEOF);
+                return (sal_Bool) bIsAtEOF;
+            }
+
+            inline sal_Bool Delete(AffectEnum eNum)
+            {
+                return SUCCEEDED(pInterface->Delete(eNum));
+            }
+
+            inline sal_Bool AddNew(const OLEVariant &FieldList,const OLEVariant &Values)
+            {
+                return SUCCEEDED(pInterface->AddNew(FieldList,Values));
+            }
+
+            inline sal_Bool Update(const OLEVariant &FieldList,const OLEVariant &Values)
+            {
+                return SUCCEEDED(pInterface->Update(FieldList,Values));
+            }
+
+            inline sal_Bool CancelUpdate()
+            {
+                return SUCCEEDED(pInterface->CancelUpdate());
+            }
+
+            inline ADOProperties* get_Properties() const
+            {
+                ADOProperties* pProps=NULL;
+                pInterface->get_Properties(&pProps);
+                return pProps;
+            }
+
+            inline sal_Bool NextRecordset(OLEVariant& RecordsAffected,ADORecordset** ppiRset)
+            {
+                return SUCCEEDED(pInterface->NextRecordset(&RecordsAffected,ppiRset));
+            }
+
+            inline sal_Bool get_RecordCount(sal_Int32 &_nRet) const
+            {
+                return SUCCEEDED(pInterface->get_RecordCount(&_nRet));
+            }
+
+            inline sal_Bool get_MaxRecords(sal_Int32 &_nRet) const
+            {
+                return SUCCEEDED(pInterface->get_MaxRecords(&_nRet));
+            }
+
+            inline sal_Bool put_MaxRecords(sal_Int32 _nRet)
+            {
+                return SUCCEEDED(pInterface->put_MaxRecords(_nRet));
+            }
+
+            inline sal_Bool get_CursorType(CursorTypeEnum &_nRet) const
+            {
+                return SUCCEEDED(pInterface->get_CursorType(&_nRet));
+            }
+
+            inline sal_Bool put_CursorType(CursorTypeEnum _nRet)
+            {
+                return SUCCEEDED(pInterface->put_CursorType(_nRet));
+            }
+
+            inline sal_Bool get_LockType(LockTypeEnum &_nRet) const
+            {
+                return SUCCEEDED(pInterface->get_LockType(&_nRet));
+            }
+
+            inline sal_Bool put_LockType(LockTypeEnum _nRet)
+            {
+                return SUCCEEDED(pInterface->put_LockType(_nRet));
+            }
+
+            inline sal_Bool get_CacheSize(sal_Int32 &_nRet) const
+            {
+                return SUCCEEDED(pInterface->get_CacheSize(&_nRet));
+            }
+
+            inline sal_Bool put_CacheSize(sal_Int32 _nRet)
+            {
+                return SUCCEEDED(pInterface->put_CacheSize(_nRet));
+            }
+
+            inline sal_Bool UpdateBatch(AffectEnum AffectRecords)
+            {
+                return SUCCEEDED(pInterface->UpdateBatch(AffectRecords));
+            }
+        };
+
+        //------------------------------------------------------------------------
+        class WpADOParameter:public WpOLEBase<ADOParameter>
+        {
+        public:
+            // Konstruktoren, operator=
+            // diese rufen nur die Oberklasse
+            WpADOParameter(ADOParameter* pInt):WpOLEBase<ADOParameter>(pInt){}
+            WpADOParameter(const WpADOParameter& rhs):WpOLEBase<ADOParameter>(rhs){}
+            inline WpADOParameter& operator=(const WpADOParameter& rhs)
+                {WpOLEBase<ADOParameter>::operator=(rhs); return *this;}
+            //////////////////////////////////////////////////////////////////////
+
+            inline ::rtl::OUString GetName() const {BSTR aBSTR; pInterface->get_Name(&aBSTR);
+                                ::rtl::OUString sRetStr(aBSTR);
+                                SysFreeString(aBSTR); return sRetStr;}
+
+            inline DataTypeEnum GetADOType() const
+            {
+                DataTypeEnum eType; pInterface->get_Type(&eType);
+                return eType;
+            }
+
+            inline sal_Int32 GetAttributes() const
+            {
+                sal_Int32 eADOSFieldAttributes; pInterface->get_Attributes(&eADOSFieldAttributes);
+                return eADOSFieldAttributes;
+            }
+
+            inline sal_Int32 GetPrecision() const
+            {
+                sal_uInt8 eType; pInterface->get_Precision(&eType);
+                return eType;
+            }
+
+            inline sal_Int32 GetNumericScale() const
+            {
+                sal_uInt8 eType; pInterface->get_NumericScale(&eType);
+                return eType;
+            }
+
+            inline ParameterDirectionEnum get_Direction() const
+            {
+                ParameterDirectionEnum alParmDirection;
+                pInterface->get_Direction(&alParmDirection);
+                return alParmDirection;
+            }
+
+            inline void GetValue(OLEVariant& aValVar) const
+            {
+                pInterface->get_Value(&aValVar);
+            }
+
+            inline OLEVariant GetValue() const
+            {
+                OLEVariant aValVar;
+                pInterface->get_Value(&aValVar);
+                return aValVar;
+            }
+
+            inline sal_Bool PutValue(const OLEVariant& aVariant)
+            {
+                return (SUCCEEDED(pInterface->put_Value(aVariant)));
+            }
+        };
+    }
+}
+#endif //_CONNECTIVITY_ADO_AWRAPADO_HXX_
+