source: src/Patterns/Cacheable.hpp@ e6a9c1

/*
 * Cacheable.hpp
 *
 *  Created on: Feb 2, 2010
 *      Author: crueger
 */

#ifndef CACHEABLE_HPP_
#define CACHEABLE_HPP_

#include "Patterns/Observer.hpp"
#include <boost/function.hpp>

#ifndef NO_CACHING

  template<typename T>
  class Cacheable : public Observer
  {
  public:
    Cacheable(Observable *_owner, boost::function<T()> _recalcMethod);
    virtual ~Cacheable();

    const bool isValid();
    const T& operator*();
    const bool operator==(const T&);
    const bool operator!=(const T&);

    // methods implemented for base-class Observer
    void update(Observable *subject);
    void subjectKilled(Observable *subject);
  private:
    void checkValid();

    T content;
    Observable *owner;
    bool valid;
    bool canBeUsed;
    boost::function<T()> recalcMethod;
  };


  template<typename T>
  Cacheable<T>::Cacheable(Observable *_owner, boost::function<T()> _recalcMethod) :
    owner(_owner),
    valid(false),
    canBeUsed(true),
    recalcMethod(_recalcMethod)
  {
    // we sign on with the best(=lowest) priority, so cached values are recalculated before
    // anybody else might ask for updated values
    owner->signOn(this,-20);
  }

  template<typename T>
  const T& Cacheable<T>::operator*(){
    checkValid();
    return content;
  }

  template<typename T>
  const bool Cacheable<T>::operator==(const T& rval){
    checkValid();
    return (content == rval);
  }

  template<typename T>
  const bool Cacheable<T>::operator!=(const T& rval){
    checkValid();
    return (content != rval);
  }

  template<typename T>
  Cacheable<T>::~Cacheable()
  {
    owner->signOff(this);
  }

  template<typename T>
  const bool Cacheable<T>::isValid(){
    return valid;
  }

  template<typename T>
  void Cacheable<T>::update(Observable *subject) {
    valid = false;
  }

  template<typename T>
  void Cacheable<T>::subjectKilled(Observable *subject) {
    valid = false;
    canBeUsed = false;
  }

  template<typename T>
  void Cacheable<T>::checkValid(){
    assert(canBeUsed && "Cacheable used after owner was deleted");
    if(!isValid()){
      content = recalcMethod();
    }
  }
#else
  template<typename T>
  class Cacheable : public Observer
  {
  public:
    Cacheable(Observable *_owner, boost::function<T()> _recalcMethod);
    virtual ~Cacheable();

    const bool isValid();
    const T& operator*();
    const bool operator==(const T&);
    const bool operator!=(const T&);

    // methods implemented for base-class Observer
    void update(Observable *subject);
    void subjectKilled(Observable *subject);
  private:

    boost::function<T()> recalcMethod;
  };

  template<typename T>
  Cacheable<T>::Cacheable(Observable *_owner, boost::function<T()> _recalcMethod) :
    recalcMethod(_recalcMethod)
  {}

  template<typename T>
  const T& Cacheable<T>::operator*(){
    return recalcMethod();
  }

  template<typename T>
  const bool Cacheable<T>::operator==(const T& rval){
    return (recalcMethod() == rval);
  }

  template<typename T>
  const bool Cacheable<T>::operator!=(const T& rval){
    return (recalcMethod() != rval);
  }

  template<typename T>
  Cacheable<T>::~Cacheable()
  {}

  template<typename T>
  const bool Cacheable<T>::isValid(){
    return true;
  }

  template<typename T>
  void Cacheable<T>::update(Observable *subject) {
    assert(0 && "Cacheable::update should never be called when caching is disabled");
  }

  template<typename T>
  void Cacheable<T>::subjectKilled(Observable *subject) {
    assert(0 && "Cacheable::subjectKilled should never be called when caching is disabled");
  }
#endif

#endif /* CACHEABLE_HPP_ */