include/MUtils/Lazy.h

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // MuldeR's Utilities for Qt
   3 // Copyright (C) 2004-2017 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 <QAtomicPointer>
  35
  36 //CRT
  37 #include <functional>
  38
  39 namespace MUtils
  40 {
  41         /**
  42         * \brief Lazy initialization template class
  43         *
  44         * 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.
  45         *
  46         * **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. Still, if the value has *not* been initialized yet **and** if multiple threads happen to call `operator*()` at the same time, then the `initializer` lambda-function *may* be invoked more than once (concurrently and by different threads). In that case, all but one return value of the `initializer` lambda-function are discarded, and all threads eventually obtain the same value/object.
  47         */
  48         template<typename T> class Lazy
  49         {
  50         public:
  51                 Lazy(std::function<T*(void)> &&initializer) : m_initializer(initializer) { }
  52
  53                 T& operator*(void)
  54                 {
  55                         while (!m_value)
  56                         {
  57                                 if (T *const value = m_initializer())
  58                                 {
  59                                         if (!m_value.testAndSetOrdered(NULL, value))
  60                                         {
  61                                                 delete value; /*too late*/
  62                                         }
  63                                 }
  64                                 else
  65                                 {
  66                                         MUTILS_THROW("Initializer returned NULL!");
  67                                 }
  68                         }
  69                         return *m_value;
  70                 }
  71
  72         private:
  73                 QAtomicPointer<T> m_value;
  74                 const std::function<T*(void)> m_initializer;
  75         };
  76 }