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 poiner 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 initialzed 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 ODynmaicLoader 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 = 0;
 112     }
 113
 114     /** Constructor, loads the library if necessary otherwise the refernece 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 tha last instance.
 147     ~ODynamicLoader()
 148     {
 149         if( m_pLoader )
 150             m_pLoader->release();
 151     }
 152
 153     /// Assign operator
 154     ODynamicLoader<API>& SAL_CALL operator = (const ODynamicLoader<API>& toAssign)
 155     {
 156         if( m_pLoader != toAssign.m_pLoader )
 157         {
 158             if( toAssign.m_pLoader )
 159             {
 160                 toAssign.m_pLoader->acquire();
 161             }
 162             if( m_pLoader )
 163             {
 164                 m_pLoader->release();
 165             }
 166             m_pLoader = toAssign.m_pLoader;
 167         }
 168
 169         return (*this);
 170     }
 171
 172     /// returns a poiner to the initialized API function structure.
 173     API* SAL_CALL getApi() const
 174     {
 175         return static_cast<API*>(m_pLoader->getApi());
 176     }
 177
 178     /// cast operator, which cast to a poiner with the initialized API function structure.
 179     API* SAL_CALL operator->() const
 180     {
 181         return static_cast<API*>(m_pLoader->getApi());
 182     }
 183
 184     /// checks if the loader works on a loaded and initialized library.
 185     bool SAL_CALL isLoaded() const
 186     {
 187         return (m_pLoader != NULL);
 188     }
 189
 190 protected:
 191     /// stores the real loader helper instance
 192     static ORealDynamicLoader*  m_pStaticLoader;
 193     ORealDynamicLoader*         m_pLoader;
 194 };
 195
 196
 197 template<class API>
 198 ORealDynamicLoader* ODynamicLoader<API>::m_pStaticLoader = NULL;
 199
 200 }
 201
 202 #endif
 203
 204 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */