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 <QScopedPointer>
  35 #include <QAtomicPointer>
  36
  37 namespace MUtils
  38 {
  39         /**
  40         * \brief Lazy initialization template class
  41         *
  42         * In order to create your own "lazy" initializer, inherit from the `Lazy<T>` class an implement the create() function. The lazy-initialized value 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 concrete create() function. The return value of create() is then stored internally, so that any subsequent call to the `operator*()` immediately returns the previously created value.
  43         *
  44         * **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 concrete create() function *may* be invoked more than once (concurrently and by different threads). In that case, all but one return value of create() are discarded, and all threads eventually receive the same value/object.
  45         */
  46         template<typename T> class Lazy
  47         {
  48         public:
  49                 T& operator*(void)
  50                 {
  51                         while (!m_data)
  52                         {
  53                                 if (T *const initializer = create())
  54                                 {
  55                                         if (!m_data.testAndSetOrdered(NULL, initializer))
  56                                         {
  57                                                 delete initializer;
  58                                         }
  59                                 }
  60                                 else
  61                                 {
  62                                         MUTILS_THROW("Initializer function returned NULL!");
  63                                 }
  64                         }
  65                         return *m_data;
  66                 }
  67
  68         protected:
  69                 virtual T *create() = 0;
  70
  71         private:
  72                 QAtomicPointer<T> m_data;
  73         };
  74 }