mysqlc/source/mysqlc_subcomponent.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 _CONNECTIVITY_OSUBCOMPONENT_HXX_
  21 #define _CONNECTIVITY_OSUBCOMPONENT_HXX_
  22
  23 #include <cppuhelper/weak.hxx>
  24 #include <cppuhelper/interfacecontainer.h>
  25 #include <com/sun/star/lang/DisposedException.hpp>
  26 #include <cppuhelper/propshlp.hxx>
  27 #include <osl/mutex.hxx>
  28 #include <osl/diagnose.h>
  29
  30 namespace cppu {
  31     class IPropertyArrayHelper;
  32 }
  33
  34 namespace com
  35 {
  36     namespace sun
  37     {
  38         namespace star
  39         {
  40             namespace lang
  41             {
  42                 class XComponent;
  43             }
  44         }
  45     }
  46 }
  47 namespace connectivity
  48 {
  49
  50     namespace mysqlc
  51     {
  52         void release(oslInterlockedCount& _refCount,
  53                      ::cppu::OBroadcastHelper& rBHelper,
  54                      ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >& _xInterface,
  55                      ::com::sun::star::lang::XComponent* _pObject);
  56
  57         void checkDisposed(sal_Bool _bThrow) throw (::com::sun::star::lang::DisposedException);
  58         //************************************************************
  59         // OSubComponent
  60         //************************************************************
  61         template <class SELF, class WEAK> class OSubComponent
  62         {
  63         protected:
  64             // the parent must support the tunnel implementation
  65             ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > m_xParent;
  66             SELF*   m_pDerivedImplementation;
  67
  68         public:
  69             OSubComponent(
  70                     const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >& _xParent,
  71                     SELF* _pDerivedImplementation)
  72                 :m_xParent(_xParent)
  73                 ,m_pDerivedImplementation(_pDerivedImplementation)
  74             {
  75             }
  76
  77         protected:
  78             void dispose_ChildImpl()
  79             {
  80                 ::osl::MutexGuard aGuard(m_pDerivedImplementation->rBHelper.rMutex);
  81                 m_xParent = NULL;
  82             }
  83             void relase_ChildImpl()
  84             {
  85                 release(m_pDerivedImplementation->m_refCount,
  86                                         m_pDerivedImplementation->rBHelper,
  87                                         m_xParent,
  88                                         m_pDerivedImplementation);
  89
  90                 m_pDerivedImplementation->WEAK::release();
  91             }
  92         };
  93
  94
  95         template <class TYPE>
  96         class OPropertyArrayUsageHelper
  97         {
  98         protected:
  99             static sal_Int32                        s_nRefCount;
 100             static ::cppu::IPropertyArrayHelper*    s_pProps;
 101             static ::osl::Mutex                     s_aMutex;
 102
 103         public:
 104             OPropertyArrayUsageHelper();
 105             virtual ~OPropertyArrayUsageHelper()
 106             {   // ARGHHHHHHH ..... would like to implement this in proparrhlp_impl.hxx (as we do with all other methods)
 107                 // but SUNPRO 5 compiler (linker) doesn't like this
 108                 ::osl::MutexGuard aGuard(s_aMutex);
 109                 OSL_ENSURE(s_nRefCount > 0, "OPropertyArrayUsageHelper::~OPropertyArrayUsageHelper : suspicious call : have a refcount of 0 !");
 110                 if (!--s_nRefCount)
 111                 {
 112                     delete s_pProps;
 113                     s_pProps = NULL;
 114                 }
 115             }
 116
 117             /** call this in the getInfoHelper method of your derived class. The method returns the array helper of the
 118                 class, which is created if neccessary.
 119             */
 120             ::cppu::IPropertyArrayHelper*   getArrayHelper();
 121
 122         protected:
 123             /** used to implement the creation of the array helper which is shared amongst all instances of the class.
 124                 This method needs to be implemented in derived classes.
 125                 <BR>
 126                 The method gets called with s_aMutex acquired.
 127                 <BR>
 128                 as long as IPropertyArrayHelper has no virtual destructor, the implementation of ~OPropertyArrayUsageHelper
 129                 assumes that you created an ::cppu::OPropertyArrayHelper when deleting s_pProps.
 130                 @return                         an pointer to the newly created array helper. Must not be NULL.
 131             */
 132             virtual ::cppu::IPropertyArrayHelper* createArrayHelper() const = 0;
 133         };
 134
 135         template<class TYPE>
 136         sal_Int32                       OPropertyArrayUsageHelper< TYPE >::s_nRefCount  = 0;
 137
 138         template<class TYPE>
 139         ::cppu::IPropertyArrayHelper*   OPropertyArrayUsageHelper< TYPE >::s_pProps = NULL;
 140
 141         template<class TYPE>
 142         ::osl::Mutex                    OPropertyArrayUsageHelper< TYPE >::s_aMutex;
 143
 144         //------------------------------------------------------------------
 145         template <class TYPE>
 146         OPropertyArrayUsageHelper<TYPE>::OPropertyArrayUsageHelper()
 147         {
 148             ::osl::MutexGuard aGuard(s_aMutex);
 149             ++s_nRefCount;
 150         }
 151
 152         //------------------------------------------------------------------
 153         template <class TYPE>
 154         ::cppu::IPropertyArrayHelper* OPropertyArrayUsageHelper<TYPE>::getArrayHelper()
 155         {
 156             OSL_ENSURE(s_nRefCount, "OPropertyArrayUsageHelper::getArrayHelper : suspicious call : have a refcount of 0 !");
 157             if (!s_pProps) {
 158                 ::osl::MutexGuard aGuard(s_aMutex);
 159                 if (!s_pProps) {
 160                     s_pProps = createArrayHelper();
 161                     OSL_ENSURE(s_pProps, "OPropertyArrayUsageHelper::getArrayHelper : createArrayHelper returned nonsense !");
 162                 }
 163             }
 164             return s_pProps;
 165         }
 166
 167
 168         class OBase_Mutex
 169         {
 170         public:
 171             ::osl::Mutex m_aMutex;
 172         };
 173
 174         namespace internal
 175         {
 176             template <class T>
 177             void implCopySequence(const T* _pSource, T*& _pDest, sal_Int32 _nSourceLen)
 178             {
 179                 for (sal_Int32 i=0; i<_nSourceLen; ++i, ++_pSource, ++_pDest)
 180                     *_pDest = *_pSource;
 181             }
 182         }
 183         //-------------------------------------------------------------------------
 184         /// concat two sequences
 185         template <class T>
 186         ::com::sun::star::uno::Sequence<T> concatSequences(const ::com::sun::star::uno::Sequence<T>& _rLeft, const ::com::sun::star::uno::Sequence<T>& _rRight)
 187         {
 188             sal_Int32 nLeft(_rLeft.getLength()), nRight(_rRight.getLength());
 189             const T* pLeft = _rLeft.getConstArray();
 190             const T* pRight = _rRight.getConstArray();
 191
 192             sal_Int32 nReturnLen(nLeft + nRight);
 193             ::com::sun::star::uno::Sequence<T> aReturn(nReturnLen);
 194             T* pReturn = aReturn.getArray();
 195
 196             internal::implCopySequence(pLeft, pReturn, nLeft);
 197             internal::implCopySequence(pRight, pReturn, nRight);
 198
 199             return aReturn;
 200         }
 201
 202
 203 #define DECLARE_SERVICE_INFO()  \
 204     virtual ::rtl::OUString SAL_CALL getImplementationName() throw (::com::sun::star::uno::RuntimeException);   \
 205     virtual sal_Bool SAL_CALL supportsService(const ::rtl::OUString& ServiceName) throw(::com::sun::star::uno::RuntimeException);   \
 206     virtual ::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL getSupportedServiceNames() throw(::com::sun::star::uno::RuntimeException)   \
 207
 208 #define IMPLEMENT_SERVICE_INFO(classname, implasciiname, serviceasciiname)  \
 209     ::rtl::OUString SAL_CALL classname::getImplementationName() throw (::com::sun::star::uno::RuntimeException) \
 210     {   \
 211         return ::rtl::OUString::createFromAscii(implasciiname); \
 212     }   \
 213     ::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL classname::getSupportedServiceNames() throw(::com::sun::star::uno::RuntimeException)    \
 214     {   \
 215         ::com::sun::star::uno::Sequence< ::rtl::OUString > aSupported(1);   \
 216         aSupported[0] = ::rtl::OUString::createFromAscii(serviceasciiname); \
 217         return aSupported;  \
 218     }   \
 219     sal_Bool SAL_CALL classname::supportsService(const ::rtl::OUString& _rServiceName) throw(::com::sun::star::uno::RuntimeException)   \
 220     {   \
 221         Sequence< ::rtl::OUString > aSupported(getSupportedServiceNames());             \
 222         const ::rtl::OUString* pSupported = aSupported.getConstArray();                 \
 223         const ::rtl::OUString* pEnd = pSupported + aSupported.getLength();              \
 224         for (;pSupported != pEnd && !pSupported->equals(_rServiceName); ++pSupported)   \
 225             ;                                                                           \
 226         return pSupported != pEnd;                                                      \
 227     }   \
 228
 229
 230     }
 231 }
 232 #endif // _CONNECTIVITY_OSUBCOMPONENT_HXX_
 233
 234 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */