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