control-impl.hpp

Go to the documentation of this file.

/*
  CONTROL-IMPL.hpp  -  time::control implementation building blocks
 
   Copyright (C)
     2011,            Hermann Vosseler <Ichthyostega@web.de>
 
 **Lumiera** is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 Free Software Foundation; either version 2 of the License, or (at your
 option) any later version. See the file COPYING for further details.
 
*/
 
 
#ifndef LIB_TIME_CONTROL_IMPL_H
#define LIB_TIME_CONTROL_IMPL_H
 
#include "lib/error.hpp"
#include "lib/time/mutation.hpp"
#include "lib/time/timevalue.hpp"
 
#include <functional>
#include <vector>
 
 
namespace lib {
namespace time {
namespace mutation {
  
  using std::function;
  
  
  
  
  template<class TI>
  class Mutator
    : public Mutation
    {
      typedef function<TI(TI const&)>     ValueSetter;
      typedef function<TI(Offset const&)> Ofsetter;
      typedef function<TI(int)>           Nudger;
      
    protected:
      mutable ValueSetter setVal_;
      mutable Ofsetter    offset_;
      mutable Nudger      nudge_;
      
      void
      ensure_isArmed()  const
        {
          if (!setVal_)
            throw error::State("feeding time/value change "
                               "while not (yet) connected to any target to change"
                              ,error::LUMIERA_ERROR_UNCONNECTED);
        }
      
      
      template<class TAR>
      void bind_to (TAR& target)  const;
      
      void unbind();
      
      // using default construction and copy
    };
  
  
  
  template<class TI>
  class Propagator
    {
      typedef function<void(TI const&)> ChangeSignal;
      typedef std::vector<ChangeSignal> ListenerList;
      
      ListenerList listeners_;
      
    public:
      template<class SIG>
      void
      attach (SIG const& toNotify)
        {
          ChangeSignal newListener (std::ref(toNotify));
          listeners_.push_back (newListener);
        }
      
      void
      disconnect()
        {
          listeners_.clear();
        }
      
      TI
      operator() (TI const& changedVal)  const
        {
          using Iter = ListenerList::const_iterator;
          Iter p = listeners_.begin();
          Iter e = listeners_.end();
          
          for ( ; p!=e; ++p )
            (*p) (changedVal);
          return changedVal;
        }
      
      // using default construction and copy
    };
}}} // lib::time::mutation
 
 
/* ===== Definition of actual operations ===== */
#include "lib/time/control-policy.hpp"
 
 
 
 
template<class TI>
template<class TAR>
void
lib::time::mutation::Mutator<TI>::bind_to (TAR& target)  const
{
  using lib::time::mutation::Policy;
  
  setVal_ = Policy<TI,TI,    TAR>::buildChangeHandler (target);
  offset_ = Policy<TI,Offset,TAR>::buildChangeHandler (target);
  nudge_  = Policy<TI,int,   TAR>::buildChangeHandler (target);
}
 
template<class TI>
void
lib::time::mutation::Mutator<TI>::unbind()
{
  setVal_ = ValueSetter();
  offset_ = Ofsetter();
  nudge_  = Nudger();
}
 
 
#endif