source: src/Patterns/Cacheable.hpp@ e3c8b4

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

#ifndef CACHEABLE_HPP_
#define CACHEABLE_HPP_

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

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),
  recalcMethod(_recalcMethod),
  valid(false),
  canBeUsed(true)
{
  owner->signOn(this);
}

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();
  }
}

#endif /* CACHEABLE_HPP_ */