lazyobject.hpp

/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 
/*
 Copyright (C) 2003 RiskMap srl
 
 This file is part of QuantLib, a free-software/open-source library
 for financial quantitative analysts and developers - http://quantlib.org/
 
 QuantLib is free software: you can redistribute it and/or modify it
 under the terms of the QuantLib license.  You should have received a
 copy of the license along with this program; if not, please email
 <quantlib-dev@lists.sf.net>. The license is also available online at
 <http://quantlib.org/license.shtml>.
 
 This program is distributed in the hope that it will be useful, but WITHOUT
 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 FOR A PARTICULAR PURPOSE.  See the license for more details.
*/
 
#ifndef quantlib_lazy_object_h
#define quantlib_lazy_object_h
 
#include <ql/patterns/observable.hpp>
#include <ql/shared_ptr.hpp>
 
namespace QuantLib {
 
 
    class LazyObject : public virtual Observable,
                       public virtual Observer {
      public:
        LazyObject();
        ~LazyObject() override = default;
 
        void update() override;
 
        bool isCalculated() const;
        void recalculate();
        void freeze();
        void unfreeze();
 
      protected:
        virtual void calculate() const;
        virtual void performCalculations() const = 0;
 
      public:
 
 
        void forwardFirstNotificationOnly();
 
        void alwaysForwardNotifications();
 
      protected:
        mutable bool calculated_ = false, frozen_ = false, alwaysForward_;
      private:
        bool updating_ = false;
        class UpdateChecker {  // NOLINT(cppcoreguidelines-special-member-functions)
            LazyObject* subject_;
          public:
            explicit UpdateChecker(LazyObject* subject) : subject_(subject) {
                subject_->updating_ = true;
            }
            ~UpdateChecker() {
                subject_->updating_ = false;
            }
        };
      public:
        class Defaults;
    };
 
    class LazyObject::Defaults : public Singleton<LazyObject::Defaults> {
        friend class Singleton<LazyObject::Defaults>;
      private:
        Defaults() = default;
 
      public:
        void forwardFirstNotificationOnly() {
            forwardsAllNotifications_ = false;
        }
 
        void alwaysForwardNotifications() {
            forwardsAllNotifications_ = true;
        }
 
        bool forwardsAllNotifications() const {
            return forwardsAllNotifications_;
        }
 
      private:
        #ifdef QL_FASTER_LAZY_OBJECTS
        bool forwardsAllNotifications_ = false;
        #else
        bool forwardsAllNotifications_ = true;
        #endif
    };
 
    // inline definitions
 
    inline LazyObject::LazyObject()
    : alwaysForward_(LazyObject::Defaults::instance().forwardsAllNotifications()) {}
 
    inline void LazyObject::update() {
        if (updating_) {
            #ifdef QL_THROW_IN_CYCLES
            QL_FAIL("recursive notification loop detected; you probably created an object cycle");
            #else
            return;
            #endif
        }
 
        // This sets updating to true (so the above check breaks the
        // infinite loop if we enter this method recursively) and will
        // set it back to false when we exit this scope, either
        // successfully or because of an exception.
        UpdateChecker checker(this);
 
        // forwards notifications only the first time
        if (calculated_ || alwaysForward_) {
            // set to false early
            // 1) to prevent infinite recursion
            // 2) otherways non-lazy observers would be served obsolete
            //    data because of calculated_ being still true
            calculated_ = false;
            // observers don't expect notifications from frozen objects
            if (!frozen_)
                notifyObservers();
                // exiting notifyObservers() calculated_ could be
                // already true because of non-lazy observers
        }
    }
 
    inline void LazyObject::recalculate() {
        bool wasFrozen = frozen_;
        calculated_ = frozen_ = false;
        try {
            calculate();
        } catch (...) {
            frozen_ = wasFrozen;
            notifyObservers();
            throw;
        }
        frozen_ = wasFrozen;
        notifyObservers();
    }
 
    inline void LazyObject::freeze() {
        frozen_ = true;
    }
 
    inline void LazyObject::unfreeze() {
        // send notifications, just in case we lost any,
        // but only once, i.e. if it was frozen
        if (frozen_) {
            frozen_ = false;
            notifyObservers();
        }
    }
 
    inline void LazyObject::forwardFirstNotificationOnly() {
        alwaysForward_ = false;
    }
 
    inline void LazyObject::alwaysForwardNotifications() {
        alwaysForward_ = true;
    }
 
    inline void LazyObject::calculate() const {
        if (!calculated_ && !frozen_) {
            calculated_ = true;   // prevent infinite recursion in
                                  // case of bootstrapping
            try {
                performCalculations();
            } catch (...) {
                calculated_ = false;
                throw;
            }
        }
    }
 
    inline bool LazyObject::isCalculated() const {
        return calculated_;
    }
}
 
#endif