handle.hpp

/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 
/*
 Copyright (C) 2000, 2001, 2002, 2003 RiskMap srl
 Copyright (C) 2003, 2004, 2005, 2006, 2007 StatPro Italia 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_handle_hpp
#define quantlib_handle_hpp
 
#include <ql/patterns/observable.hpp>
 
namespace QuantLib {
 
 
    template <class T>
    class Handle {
      protected:
        class Link : public Observable, public Observer {
          public:
            explicit Link(const ext::shared_ptr<T>& h,
                          bool registerAsObserver);
            void linkTo(const ext::shared_ptr<T>&,
                        bool registerAsObserver);
            bool empty() const { return !h_; }
            const ext::shared_ptr<T>& currentLink() const { return h_; }
            void update() override { notifyObservers(); }
 
          private:
            ext::shared_ptr<T> h_;
            bool isObserver_ = false;
        };
        ext::shared_ptr<Link> link_;
      public:
        Handle()
        : Handle(ext::shared_ptr<T>()) {}
        explicit Handle(const ext::shared_ptr<T>& p,
                        bool registerAsObserver = true)
        : link_(new Link(p,registerAsObserver)) {}
 
        const ext::shared_ptr<T>& currentLink() const;
        const ext::shared_ptr<T>& operator->() const;
        const ext::shared_ptr<T>& operator*() const;
        bool empty() const;
        operator ext::shared_ptr<Observable>() const;
        template <class U>
        bool operator==(const Handle<U>& other) const { return link_==other.link_; }
        template <class U>
        bool operator!=(const Handle<U>& other) const { return link_!=other.link_; }
        template <class U>
        bool operator<(const Handle<U>& other) const { return link_ < other.link_; }
    };
 
 
    template <class T>
    class RelinkableHandle : public Handle<T> {
      public:
        explicit RelinkableHandle(
                       const ext::shared_ptr<T>& p = ext::shared_ptr<T>(),
                       bool registerAsObserver = true);
        explicit RelinkableHandle(
                       T* p,
                       bool registerAsObserver = true);
        void linkTo(const ext::shared_ptr<T>&,
                    bool registerAsObserver = true);
    };
 
 
    // inline definitions
 
    template <class T>
    inline Handle<T>::Link::Link(const ext::shared_ptr<T>& h, bool registerAsObserver) {
        linkTo(h,registerAsObserver);
    }
 
    template <class T>
    inline void Handle<T>::Link::linkTo(const ext::shared_ptr<T>& h,
                                        bool registerAsObserver) {
        if ((h != h_) || (isObserver_ != registerAsObserver)) {
            if (h_ && isObserver_)
                unregisterWith(h_);
            h_ = h;
            isObserver_ = registerAsObserver;
            if (h_ && isObserver_)
                registerWith(h_);
            notifyObservers();
        }
    }
 
 
    template <class T>
    inline const ext::shared_ptr<T>& Handle<T>::currentLink() const {
        QL_REQUIRE(!empty(), "empty Handle cannot be dereferenced");
        return link_->currentLink();
    }
 
    template <class T>
    inline const ext::shared_ptr<T>& Handle<T>::operator->() const {
        QL_REQUIRE(!empty(), "empty Handle cannot be dereferenced");
        return link_->currentLink();
    }
 
    template <class T>
    inline const ext::shared_ptr<T>& Handle<T>::operator*() const {
        QL_REQUIRE(!empty(), "empty Handle cannot be dereferenced");
        return link_->currentLink();
    }
 
    template <class T>
    inline bool Handle<T>::empty() const {
        return link_->empty();
    }
 
    template <class T>
    inline Handle<T>::operator ext::shared_ptr<Observable>() const {
        return link_;
    }
 
 
    template <class T>
    inline RelinkableHandle<T>::RelinkableHandle(const ext::shared_ptr<T>& p,
                                                 bool registerAsObserver)
    : Handle<T>(p,registerAsObserver) {}
 
    template <class T>
    inline RelinkableHandle<T>::RelinkableHandle(T* p,
                                                 bool registerAsObserver)
    : Handle<T>(p,registerAsObserver) {}
 
    template <class T>
    inline void RelinkableHandle<T>::linkTo(const ext::shared_ptr<T>& h,
                                            bool registerAsObserver) {
        this->link_->linkTo(h,registerAsObserver);
    }
 
}
 
#endif