Download source files:
http://www.jkofsp.net/files/

<SimulationMultiMgr.h>

#pragma once

#include <list>
#include <functional>

Class ICached
{
public:
   virtual void Flush() = 0;
};

Class ManagerCached
{
private:
   std::list<ICached *> m_Cacheds;
public:
   void Add(ICached *pCached);
   void Remove(ICached *pCached);
   void Flush();
};

template <class T> class Cached : public ICached
{
private:
   std::tr1::function<T()> m_fValue;
   T m_Value;
   bool m_bCalculated;
public:
   Cached(ManagerCached *mgr, std::tr1::function<T()> fValue);
   void Remove(ManagerCached *mgr);
   T v();
   virtual void Flush();
};

template <class T> Cached<T>::Cached(ManagerCached *mgr, std::tr1::function<T()> fValue)
{
   m_fValue = fValue;
   m_bCalculated = false;
   mgr->Add(this);
}

template <class T> void Cached<T>::Remove(ManagerCached *mgr)
{
   mgr->Remove(this);
}
   
template <class T> T Cached<T>::v()
{
   if (m_bCalculated)
       return m_Value;
   Else
   {
       m_bCalculated = true;
       return m_Value = m_fValue();
   }
}

template <class T> void Cached<T>::Flush()
{
   m_bCalculated = false;
}

Class IState
{
public:
   virtual void Update() = 0;
   virtual void Flush() = 0;
};

Class ManagerState
{
private:
   std::list<IState *> m_States;
public:
   void Add(IState *pState);
   void Remove(IState *pState);
   void Update();
   void Flush();
};

template <class T> class State : public IState
{
private:
   std::tr1::function<T(T)> m_fState;
   T m_Current, m_Next;
public:
   State(ManagerState *mgr, T defaultValue, std::tr1::function<T(T)> fState);
   void Remove(ManagerState *mgr);
   T v();
   virtual void Update();
   virtual void Flush();
};

template <class T> State<T>::State(ManagerState *mgr, T defaultValue, std::tr1::function<T(T)> fState)
{
   m_fState = fState;
   m_Current = defaultValue;
   mgr->Add(this);
}

template <class T> void State<T>::Remove(ManagerState *mgr)
{
   mgr->Remove(this);
}
   
template <class T> T State<T>::v()
{
   return m_Current;
}

template <class T> void State<T>::Update()
{
   m_Next = m_fState(m_Current);
}

template <class T> void State<T>::Flush()
{
   m_Current = m_Next;
}

Class IDiff
{
public:
   virtual void Update() = 0;
};

Class ManagerDiff
{
private:
   std::list<IDiff *> m_Diffs;
public:
   void Add(IDiff *pDiff);
   void Remove(IDiff *pDiff);
   void Update();
};

template <class T> class Diff : public IDiff
{
/*public:
   static std::tr1::function<T(T, T)> s_fSub;*/
private:
   std::tr1::function<T()> m_fValue;
   T m_Old, m_d;
public:
   Diff(ManagerDiff *mgr, T defaultValue, std::tr1::function<T()> fValue);
   void Remove(ManagerDiff *mgr);
   T d();
   virtual void Update();
};

// template <class T> std::tr1::function<T(T, T)> Diff<T>::s_fSub;

template <class T> Diff<T>::Diff(ManagerDiff *mgr, T defaultValue, std::tr1::function<T()> fValue)
{
   m_Old = defaultValue;
   m_fValue = fValue;
   mgr->Add(this);
}

template <class T> void Diff<T>::Remove(ManagerDiff *mgr)
{
   mgr->Remove(this);
}
   
template <class T> T Diff<T>::d()
{
   return m_d;
}

template <class T> void Diff<T>::Update()
{
   T _new = m_fValue();
   m_d = _new - m_Old; // m_d = s_fSub(_new, m_Old);
   m_Old = _new;
}

Class ISimulationRemovable
{
   virtual void RemoveSimulation() = 0;
};

template <class T> class Bind
{
public:
   std::tr1::function<T()> m_fBind;
public:
   Bind(std::tr1::function<T()> fBind);
   T f();
};

template <class T> Bind<T>::Bind(std::tr1::function<T()> fBind)
{
   m_fBind = fBind;
}

template <class T> T Bind<T>::f()
{
   return m_fBind();
}