control-policy.hpp

Go to the documentation of this file.

/*
  CONTROL-POLICY.hpp  -  detail definition of actual time changing functionality  

  Copyright (C)         Lumiera.org
    2011,               Hermann Vosseler <Ichthyostega@web.de>

  This program 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.

  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
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/


#ifndef LIB_TIME_CONTROL_POLICY_H
#define LIB_TIME_CONTROL_POLICY_H

#include "lib/time/mutation.hpp"
#include "lib/time/timevalue.hpp"

#include <boost/utility/enable_if.hpp>
#include <type_traits>
#include <functional>


namespace lib {
namespace time {
  
namespace mutation {
  
  using boost::disable_if;
  using std::__or_;
  using std::is_same;
  using std::placeholders::_1;
  using std::function;
  using std::bind;
  using std::ref;
  
  
  
  namespace { // metaprogramming helpers to pick a suitable implementation branch...
    
    template<class T>
    inline bool
    isDuration()
    {
      return is_same<T, Duration>::value;
    }
    
    template<class T>
    inline bool
    isTimeSpan()
    {
      return is_same<T, TimeSpan>::value;
    }
    
    template<class T>
    inline T const&
    maybeMaterialise (T const& non_grid_aligned_TimeValue)
    {
      return non_grid_aligned_TimeValue;
    }
    
#ifdef LIB_TIME_TIMEQUANT_H
    inline QuTime
    maybeMaterialise (QuTime const& alignedTime)
    {
      PQuant const& grid(alignedTime);
      return QuTime(grid->materialise(alignedTime), grid);
    }
#endif //--quantised-time-support
  }
  
  
  template<class TI, class TAR>
  struct Builder
    {
      static TI
      buildChangedValue (TAR const& target)
        {
          return TI(target);
        }
    };
  template<class TAR>
  struct Builder<TimeSpan, TAR>
    {
      static TimeSpan
      buildChangedValue (TAR const& target)
        {
          return TimeSpan (target, Duration::NIL);
        }
    };
  template<>
  struct Builder<TimeSpan, Duration>
    {
      static TimeSpan
      buildChangedValue (Duration const& targetDuration)
        {
          return TimeSpan (Time::ZERO, targetDuration);
        }
    };
  template<>
  struct Builder<TimeSpan, TimeSpan>
    {
      static TimeSpan
      buildChangedValue (TimeSpan const& target)
        {
          return target;
        }
    };
#ifdef LIB_TIME_TIMEQUANT_H
  template<class TAR>
  struct Builder<QuTime, TAR>
    {
      static QuTime
      buildChangedValue (TAR const& target)
        {
          return QuTime (target
                        ,getDefaultGridFallback()                                                     
                        );
        }
    };
  template<>
  struct Builder<QuTime, QuTime>
    {
      static QuTime
      buildChangedValue (QuTime const& target)
        {
          return target;
        }
    };
#endif //--quantised-time-support
  
  
  
  
  template<class TI, class TAR>
  struct Link
    : Mutation
    , Builder<TI,TAR>
    {
      
      template<class SRC>
      static TI
      processValueChange (TAR& target, SRC const& change)  
        {
          imposeChange (target, maybeMaterialise(change));
          return Link::buildChangedValue (maybeMaterialise(target));
        }
      
      static TI
      useLengthAsChange (TAR& target, TimeSpan const& change)
        {
          return processValueChange(target, change.duration());
        }
      
      static TI
      mutateLength (TimeSpan& target, Duration const& change)
        {
          imposeChange (target.duration(), change);
          return Builder<TI,TimeSpan>::buildChangedValue(target);
        }
      
      static TimeSpan
      mutateTimeSpan (TimeSpan& target, TimeSpan const& change)
        {
          imposeChange (target.duration(), change.duration());
          imposeChange (target,change.start());
          return Builder<TimeSpan,TimeSpan>::buildChangedValue(target);
        }
      
      static TI
      dontChange (TAR& target)  
        {
          return Link::buildChangedValue(target);
        }
    };
  
  
  
  template<class TI, class SRC, class TAR>
  struct Policy
    {
      static function<TI(SRC const&)>
      buildChangeHandler (TAR& target)
        {
          return bind (Link<TI,TAR>::template processValueChange<SRC>, ref(target), _1 );
        }
    };
  
  
  // special treatment of Durations as target------------------------------------
  
  namespace {
    template<class T>
    struct canMutateDuration
      : __or_< is_same<T,Duration>
             , is_same<T,Offset>
             , is_same<T,int>
             >
      { };
    
    template<class T>
    struct canReceiveDuration
      : __or_< is_same<T,Duration>
             , is_same<T,TimeSpan>
             >
      { };
  }
  
  
  template<class TI, class SRC>
  struct Policy<TI,SRC,                  typename disable_if< canMutateDuration<SRC>, 
                       Duration>::type>
    {
      static function<TI(SRC const&)>
      buildChangeHandler (Duration& target)
        {
          return bind (Link<TI,Duration>::dontChange, ref(target) );
        }
    };
  
  template<class TAR>
  struct Policy<Duration,                typename disable_if< canReceiveDuration<TAR>, 
                   Duration>::type, TAR>
    {
      static function<Duration(Duration const&)>
      buildChangeHandler (TAR&)
        {
          return bind ( ignore_change_and_return_Zero );
        }
      
      static Duration
      ignore_change_and_return_Zero()
        {
          return Duration::NIL;
        }
    };
  
  template<class TI>
  struct Policy<TI,TimeSpan,Duration>
    {
      static function<TI(TimeSpan const&)>
      buildChangeHandler (Duration& target)
        {
          return bind (Link<TI,Duration>::useLengthAsChange, ref(target), _1 );
        }
    };
  
  
  // special treatment for TimeSpan values---------------------------------------
  
  template<class TI>
  struct Policy<TI,Duration,TimeSpan>
    {
      static function<TI(Duration const&)>
      buildChangeHandler (TimeSpan& target)
        {
          return bind (Link<TI,TimeSpan>::mutateLength, ref(target), _1 );
        }
    };
  
  template<>
  struct Policy<TimeSpan,TimeSpan,TimeSpan>
    {
      static function<TimeSpan(TimeSpan const&)>
      buildChangeHandler (TimeSpan& target)
        {
          return bind (Link<TimeSpan,TimeSpan>::mutateTimeSpan, ref(target), _1 );
        }
    };
  
  
  
}}} // namespace lib::time::mutation
#endif