include/salhelper/dynload.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_SALHELPER_DYNLOAD_HXX
  21 #define INCLUDED_SALHELPER_DYNLOAD_HXX
  22
  23 #include "sal/types.h"
  24 #include "rtl/ustring.hxx"
  25 #include "osl/module.h"
  26 #include "salhelper/salhelperdllapi.h"
  27
  28 namespace salhelper
  29 {
  30
  31 /** The ORealDynamicLoader is an implementation helper class for the template loader ODynamicLoader.
  32  */
  33 class SALHELPER_DLLPUBLIC ORealDynamicLoader
  34 {
  35 public:
  36     /** initializes the loader, loads the library and call the initialization function.
  37
  38         @param ppSetToZeroInDestructor points to the loader instance which must be set to NULL
  39                                        if the loader will be destroyed.
  40         @param strModuleName specifies the library name.
  41         @param strInitFunction specifies the name of the initialization function.
  42      */
  43     static ORealDynamicLoader* SAL_CALL newInstance(
  44             ORealDynamicLoader ** ppSetToZeroInDestructor,
  45             const ::rtl::OUString& strModuleName,
  46             const ::rtl::OUString& strInitFunction );
  47
  48     /// increase the reference count.
  49     sal_uInt32 SAL_CALL acquire();
  50     /// decrease the reference count and delete the last instance.
  51     sal_uInt32 SAL_CALL release();
  52
  53     /// returns a pointer to the initialized API function structure.
  54     void* SAL_CALL getApi() const;
  55
  56 protected:
  57     /** Constructor.
  58
  59         @param ppSetToZeroInDestructor points to the loader instance which must be set to NULL
  60                                        if the loader will be destroyed.
  61         @param strModuleName specifies the library name.
  62         @param strInitFunction specifies the name of the initialization function.
  63         @param pApi points to a structure with the initialized API function pointers.
  64         @param pModule points to the loaded library handle.
  65      */
  66     ORealDynamicLoader( ORealDynamicLoader ** ppSetToZeroInDestructor,
  67                         const ::rtl::OUString& strModuleName,
  68                         const ::rtl::OUString& strInitFunction,
  69                         void* pApi,
  70                         oslModule pModule );
  71
  72     /// Destructor, try to unload the library.
  73     virtual ~ORealDynamicLoader();
  74
  75     /// points to  the structure with the initialized API function pointers.
  76     void*                   m_pApi;
  77     /// stores the reference count.
  78     sal_uInt32              m_refCount;
  79     /// stores the library handle.
  80     oslModule               m_pModule;
  81     /// stores the library name.
  82     ::rtl::OUString         m_strModuleName;
  83     /// stores the name of the initialization function.
  84     ::rtl::OUString         m_strInitFunction;
  85     /** stores a pointer to itself, which must be reset in the destructor to signal
  86         that the loader is invalid.
  87     */
  88     ORealDynamicLoader **   ppSetToZeroInDestructor;
  89 };
  90
  91
  92 /** The ODynamicLoader provides a special load on call mechanism for dynamic libraries
  93     which support a C-API.
  94
  95     The libraries must provide a struct with function pointers for all supported C functions.
  96     The loader loads the specified library and call the specified initialization function
  97     to initialize the function pointers with the real functions. Furthermore provides the
  98     loader a reference counter for the library. When the last instance of the laoder will
  99     be destroyed the loader will unload the library.
 100
 101     @deprecated
 102     Do not use.
 103  */
 104 template<class API>
 105 class ODynamicLoader
 106 {
 107 public:
 108     /// Default constructor
 109     ODynamicLoader()
 110     {
 111         m_pLoader = NULL;
 112     }
 113
 114     /** Constructor, loads the library if necessary otherwise the reference count will
 115         be increased.
 116
 117         @param strModuleName specifies the library name.
 118         @param strInitFunction specifies the name of the initialization function.
 119      */
 120     ODynamicLoader( const ::rtl::OUString& strModuleName,
 121                        const ::rtl::OUString& strInitFunction )
 122     {
 123         if (!m_pStaticLoader)
 124         {
 125             m_pStaticLoader = ORealDynamicLoader::newInstance(
 126                &m_pStaticLoader,
 127                strModuleName,
 128                strInitFunction);
 129         }
 130         else
 131         {
 132             m_pStaticLoader->acquire();
 133         }
 134
 135         m_pLoader = m_pStaticLoader;
 136     }
 137
 138     /// Copy constructor
 139     ODynamicLoader(const ODynamicLoader<API>& toCopy)
 140     {
 141         m_pLoader = toCopy.m_pLoader;
 142         if( m_pLoader )
 143             m_pLoader->acquire();
 144     }
 145
 146     /// Destructor, decrease the reference count and unload the library if it is the last instance.
 147     ~ODynamicLoader()
 148     {
 149         if( m_pLoader )
 150             if (m_pLoader->release()==0)
 151                 m_pStaticLoader = NULL;
 152     }
 153
 154     /// Assign operator
 155     ODynamicLoader<API>& SAL_CALL operator = (const ODynamicLoader<API>& toAssign)
 156     {
 157         if( m_pLoader != toAssign.m_pLoader )
 158         {
 159             if( toAssign.m_pLoader )
 160             {
 161                 toAssign.m_pLoader->acquire();
 162             }
 163             if( m_pLoader )
 164             {
 165                 m_pLoader->release();
 166             }
 167             m_pLoader = toAssign.m_pLoader;
 168         }
 169
 170         return (*this);
 171     }
 172
 173     /// returns a pointer to the initialized API function structure.
 174     API* SAL_CALL getApi() const
 175     {
 176         return static_cast<API*>(m_pLoader->getApi());
 177     }
 178
 179     /// cast operator, which cast to a pointer with the initialized API function structure.
 180     API* SAL_CALL operator->() const
 181     {
 182         return static_cast<API*>(m_pLoader->getApi());
 183     }
 184
 185     /// checks if the loader works on a loaded and initialized library.
 186     bool SAL_CALL isLoaded() const
 187     {
 188         return (m_pLoader != NULL);
 189     }
 190
 191 protected:
 192     /// stores the real loader helper instance
 193     static ORealDynamicLoader*  m_pStaticLoader;
 194     ORealDynamicLoader*         m_pLoader;
 195 };
 196
 197
 198 template<class API>
 199 ORealDynamicLoader* ODynamicLoader<API>::m_pStaticLoader = NULL;
 200
 201 }
 202
 203 #endif
 204
 205 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */