source/utils/CarlaLibCounter.hpp

   1 /*
   2  * Carla library counter
   3  * Copyright (C) 2013-2014 Filipe Coelho <falktx@falktx.com>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of
   8  * the License, or any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  * GNU General Public License for more details.
  14  *
  15  * For a full copy of the GNU General Public License see the doc/GPL.txt file.
  16  */
  17
  18 #ifndef CARLA_LIB_COUNTER_HPP_INCLUDED
  19 #define CARLA_LIB_COUNTER_HPP_INCLUDED
  20
  21 #include "CarlaLibUtils.hpp"
  22 #include "CarlaMutex.hpp"
  23 #include "LinkedList.hpp"
  24
  25 // -----------------------------------------------------------------------
  26
  27 class LibCounter
  28 {
  29 public:
  30     LibCounter() noexcept
  31         : fMutex(),
  32           fLibs() {}
  33
  34     ~LibCounter() noexcept
  35     {
  36         // might have some leftovers
  37         for (LinkedList<Lib>::Itenerator it = fLibs.begin2(); it.valid(); it.next())
  38         {
  39             static Lib libFallback = { nullptr, nullptr, 0, false };
  40
  41             Lib& lib(it.getValue(libFallback));
  42             CARLA_SAFE_ASSERT_CONTINUE(lib.count > 0);
  43             CARLA_SAFE_ASSERT_CONTINUE(lib.lib != nullptr);
  44
  45             // all libs should be closed by now except those explicitly marked non-delete
  46             CARLA_SAFE_ASSERT(! lib.canDelete);
  47
  48             if (! lib_close(lib.lib))
  49                 carla_stderr("LibCounter cleanup failed, reason:\n%s", lib_error(lib.filename));
  50
  51             lib.lib = nullptr;
  52
  53             if (lib.filename != nullptr)
  54             {
  55                 delete[] lib.filename;
  56                 lib.filename = nullptr;
  57             }
  58         }
  59
  60         fLibs.clear();
  61     }
  62
  63     lib_t open(const char* const filename, const bool canDelete = true) noexcept
  64     {
  65         CARLA_SAFE_ASSERT_RETURN(filename != nullptr && filename[0] != '\0', nullptr);
  66
  67         // try duplicating filename first, it can throw
  68         const char* dfilename = nullptr;
  69
  70         try {
  71             dfilename = carla_strdup(filename);
  72         } CARLA_SAFE_EXCEPTION_RETURN("LibCounter::open", nullptr);
  73
  74         const CarlaMutexLocker cml(fMutex);
  75
  76         for (LinkedList<Lib>::Itenerator it = fLibs.begin2(); it.valid(); it.next())
  77         {
  78             static Lib libFallback = { nullptr, nullptr, 0, false };
  79
  80             Lib& lib(it.getValue(libFallback));
  81             CARLA_SAFE_ASSERT_CONTINUE(lib.count > 0);
  82             CARLA_SAFE_ASSERT_CONTINUE(lib.filename != nullptr);
  83
  84             if (std::strcmp(lib.filename, filename) == 0)
  85             {
  86                 // will not be needed
  87                 delete[] dfilename;
  88
  89                 ++lib.count;
  90                 return lib.lib;
  91             }
  92         }
  93
  94         const lib_t libPtr = lib_open(filename);
  95
  96         if (libPtr == nullptr)
  97         {
  98             delete[] dfilename;
  99             return nullptr;
 100         }
 101
 102         Lib lib;
 103         lib.lib       = libPtr;
 104         lib.filename  = dfilename;
 105         lib.count     = 1;
 106         lib.canDelete = canDelete;
 107 #ifdef BUILD_BRIDGE
 108         lib.canDelete = true;
 109 #endif
 110
 111         if (fLibs.append(lib))
 112             return libPtr;
 113
 114         delete[] dfilename;
 115         return nullptr;
 116     }
 117
 118     bool close(const lib_t libPtr) noexcept
 119     {
 120         CARLA_SAFE_ASSERT_RETURN(libPtr != nullptr, false);
 121
 122         const CarlaMutexLocker cml(fMutex);
 123
 124         for (LinkedList<Lib>::Itenerator it = fLibs.begin2(); it.valid(); it.next())
 125         {
 126             static Lib libFallback = { nullptr, nullptr, 0, false };
 127
 128             Lib& lib(it.getValue(libFallback));
 129             CARLA_SAFE_ASSERT_CONTINUE(lib.count > 0);
 130             CARLA_SAFE_ASSERT_CONTINUE(lib.lib != nullptr);
 131
 132             if (lib.lib != libPtr)
 133                 continue;
 134
 135             if (lib.count == 1 && ! lib.canDelete)
 136                 return true;
 137
 138             if (--lib.count == 0)
 139             {
 140                 if (! lib_close(lib.lib))
 141                     carla_stderr("LibCounter::close() failed, reason:\n%s", lib_error(lib.filename));
 142
 143                 lib.lib = nullptr;
 144
 145                 if (lib.filename != nullptr)
 146                 {
 147                     delete[] lib.filename;
 148                     lib.filename = nullptr;
 149                 }
 150
 151                 fLibs.remove(it);
 152             }
 153
 154             return true;
 155         }
 156
 157         carla_safe_assert("invalid lib pointer", __FILE__, __LINE__);
 158         return false;
 159     }
 160
 161     void setCanDelete(const lib_t libPtr, const bool canDelete)
 162     {
 163         CARLA_SAFE_ASSERT_RETURN(libPtr != nullptr,);
 164
 165         const CarlaMutexLocker cml(fMutex);
 166
 167         for (LinkedList<Lib>::Itenerator it = fLibs.begin2(); it.valid(); it.next())
 168         {
 169             static Lib libFallback = { nullptr, nullptr, 0, false };
 170
 171             Lib& lib(it.getValue(libFallback));
 172             CARLA_SAFE_ASSERT_CONTINUE(lib.lib != nullptr);
 173
 174             if (lib.lib != libPtr)
 175                 continue;
 176
 177             lib.canDelete = canDelete;
 178             return;
 179         }
 180     }
 181
 182 private:
 183     struct Lib {
 184         lib_t lib;
 185         const char* filename;
 186         int count;
 187         bool canDelete;
 188     };
 189
 190     CarlaMutex fMutex;
 191     LinkedList<Lib> fLibs;
 192 };
 193
 194 // -----------------------------------------------------------------------
 195
 196 #endif // CARLA_LIB_COUNTER_HPP_INCLUDED