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                      css::uno::Reference< css::uno::XInterface >& _xInterface,
  56                      css::lang::XComponent* _pObject);
  57
  58         void checkDisposed(bool _bThrow) throw (css::lang::DisposedException);
  59
  60         template <class SELF, class WEAK> class OSubComponent
  61         {
  62         protected:
  63             // the parent must support the tunnel implementation
  64             css::uno::Reference< css::uno::XInterface > m_xParent;
  65             SELF*   m_pDerivedImplementation;
  66
  67         public:
  68             OSubComponent(
  69                     const css::uno::Reference< css::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 = nullptr;
  81             }
  82             void release_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
 105             /** call this in the getInfoHelper method of your derived class. The method returns the array helper of the
 106                 class, which is created if necessary.
 107             */
 108             ::cppu::IPropertyArrayHelper*   getArrayHelper();
 109
 110         protected:
 111             /** used to implement the creation of the array helper which is shared amongst all instances of the class.
 112                 This method needs to be implemented in derived classes.
 113                 <BR>
 114                 The method gets called with s_aMutex acquired.
 115                 @return                         an pointer to the newly created array helper. Must not be NULL.
 116             */
 117             virtual ::cppu::IPropertyArrayHelper* createArrayHelper() const = 0;
 118         };
 119
 120         template<class TYPE>
 121         sal_Int32                       OPropertyArrayUsageHelper< TYPE >::s_nRefCount  = 0;
 122
 123         template<class TYPE>
 124         ::cppu::IPropertyArrayHelper*   OPropertyArrayUsageHelper< TYPE >::s_pProps = nullptr;
 125
 126         template<class TYPE>
 127         ::osl::Mutex                    OPropertyArrayUsageHelper< TYPE >::s_aMutex;
 128
 129         template <class TYPE>
 130         OPropertyArrayUsageHelper<TYPE>::OPropertyArrayUsageHelper()
 131         {
 132             ::osl::MutexGuard aGuard(s_aMutex);
 133             ++s_nRefCount;
 134         }
 135
 136         template <class TYPE>
 137         OPropertyArrayUsageHelper<TYPE>::~OPropertyArrayUsageHelper()
 138         {
 139             ::osl::MutexGuard aGuard(s_aMutex);
 140             OSL_ENSURE(s_nRefCount > 0, "OPropertyArrayUsageHelper::~OPropertyArrayUsageHelper : suspicious call : have a refcount of 0 !");
 141             if (!--s_nRefCount)
 142             {
 143                 delete s_pProps;
 144                 s_pProps = nullptr;
 145             }
 146         }
 147
 148         template <class TYPE>
 149         ::cppu::IPropertyArrayHelper* OPropertyArrayUsageHelper<TYPE>::getArrayHelper()
 150         {
 151             OSL_ENSURE(s_nRefCount, "OPropertyArrayUsageHelper::getArrayHelper : suspicious call : have a refcount of 0 !");
 152             if (!s_pProps) {
 153                 ::osl::MutexGuard aGuard(s_aMutex);
 154                 if (!s_pProps) {
 155                     s_pProps = createArrayHelper();
 156                     OSL_ENSURE(s_pProps, "OPropertyArrayUsageHelper::getArrayHelper : createArrayHelper returned nonsense !");
 157                 }
 158             }
 159             return s_pProps;
 160         }
 161
 162         class OBase_Mutex
 163         {
 164         public:
 165             ::osl::Mutex m_aMutex;
 166         };
 167
 168         namespace internal
 169         {
 170             template <class T>
 171             void implCopySequence(const T* _pSource, T*& _pDest, sal_Int32 _nSourceLen)
 172             {
 173                 for (sal_Int32 i=0; i<_nSourceLen; ++i, ++_pSource, ++_pDest)
 174                     *_pDest = *_pSource;
 175             }
 176         }
 177
 178         /// concat two sequences
 179         template <class T>
 180         css::uno::Sequence<T> concatSequences(const css::uno::Sequence<T>& _rLeft, const css::uno::Sequence<T>& _rRight)
 181         {
 182             sal_Int32 nLeft(_rLeft.getLength()), nRight(_rRight.getLength());
 183             const T* pLeft = _rLeft.getConstArray();
 184             const T* pRight = _rRight.getConstArray();
 185
 186             sal_Int32 nReturnLen(nLeft + nRight);
 187             css::uno::Sequence<T> aReturn(nReturnLen);
 188             T* pReturn = aReturn.getArray();
 189
 190             internal::implCopySequence(pLeft, pReturn, nLeft);
 191             internal::implCopySequence(pRight, pReturn, nRight);
 192
 193             return aReturn;
 194         }
 195     }
 196 }
 197
 198 #endif // INCLUDED_MYSQLC_SOURCE_MYSQLC_SUBCOMPONENT_HXX
 199
 200 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */