include/MUtils/Lazy.h

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // MuldeR's Utilities for Qt
   3 // Copyright (C) 2004-2023 LoRd_MuldeR <MuldeR2@GMX.de>
   4 //
   5 // This library is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU Lesser General Public
   7 // License as published by the Free Software Foundation; either
   8 // version 2.1 of the License, or (at your option) any later version.
   9 //
  10 // This library 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 GNU
  13 // Lesser General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU Lesser General Public
  16 // License along with this library; if not, write to the Free Software
  17 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  18 //
  19 // http://www.gnu.org/licenses/lgpl-2.1.txt
  20 //////////////////////////////////////////////////////////////////////////////////
  21
  22 /**
  23 * @file
  24 * @brief This file contains a template class for lazy initialization
  25 */
  26
  27 #pragma once
  28
  29 //MUtils
  30 #include <MUtils/Global.h>
  31 #include <MUtils/Exception.h>
  32
  33 //Qt
  34 #include <QThread>
  35 #include <QAtomicPointer>
  36 #include <QAtomicInt>
  37
  38 //CRT
  39 #include <functional>
  40
  41 namespace MUtils
  42 {
  43         /**
  44         * \brief Lazy initialization template class
  45         *
  46         * The lazy-initialized value of type T can be obtained from a `Lazy<T>` instance by using the `operator*()`. Initialization of the value happens when the `operator*()` is called for the very first time, by invoking the `initializer` lambda-function that was passed to the constructor. The return value of the `initializer` lambda-function is then stored internally, so that any subsequent call to the `operator*()` *immediately* returns the previously created value.
  47         *
  48         * **Note on thread-saftey:** This class is thread-safe in the sense that all calls to `operator*()` on the same `Lazy<T>` instance, regardless from which thread, are guaranteed to return the exactly same value/object. The *first* thread trying to access the value will invoke the `initializer` lambda-function; concurrent threads may need to busy-wait until the initialization is completed. The `initializer` lambda-function is invoked at most once.
  49         */
  50         template<typename T> class Lazy
  51         {
  52         public:
  53                 Lazy(std::function<T*(void)> &&initializer) : m_initializer(initializer) { }
  54
  55                 T& operator*(void)
  56                 {
  57                         return (*getValue());
  58                 }
  59
  60                 T* operator->(void)
  61                 {
  62                         return getValue();
  63                 }
  64
  65                 bool initialized()
  66                 {
  67                         return (m_state > 1);
  68                 }
  69
  70                 ~Lazy(void)
  71                 {
  72                         if(T *const value = m_value)
  73                         {
  74                                 delete value;
  75                         }
  76                 }
  77
  78         protected:
  79                 __forceinline T* getValue()
  80                 {
  81                         T *value;
  82                         while (!(value = m_value))
  83                         {
  84                                 if (m_state.testAndSetOrdered(0, 1))
  85                                 {
  86                                         if (value = m_initializer())
  87                                         {
  88                                                 m_value.fetchAndStoreOrdered(value);
  89                                                 m_state.fetchAndStoreOrdered(2);
  90                                                 break; /*success*/
  91                                         }
  92                                         m_state.fetchAndStoreOrdered(0);
  93                                         MUTILS_THROW("Initializer returned NULL pointer!");
  94                                 }
  95                                 QThread::yieldCurrentThread();
  96                         }
  97                         return value;
  98                 }
  99
 100         private:
 101                 QAtomicPointer<T> m_value;
 102                 QAtomicInt m_state;
 103                 const std::function<T*(void)> m_initializer;
 104         };
 105 }