mutation.hpp

Go to the documentation of this file.

/*
  MUTATION.hpp  -  changing and adjusting time values

  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_MUTATION_H
#define LIB_TIME_MUTATION_H

#include "lib/error.hpp"
#include "lib/nocopy.hpp"
#include "lib/time/timevalue.hpp"
#include "lib/polymorphic-value.hpp"
#include "lib/symbol.hpp"



namespace lib {
namespace time {
  
  using lib::Symbol;
  
  LUMIERA_ERROR_DECLARE (INVALID_MUTATION); 
  
  class QuTime;
  class Mutation;
  
  
  /* The following typedefs allow to hand out
   * "unspecific" mutation value objects from 
   * factory functions, without disclosing any
   * implementation details here in this header.
   */
  enum{ MUTATION_IMPL_SIZE = sizeof(TimeValue) };
  
  typedef lib::polyvalue::CloneValueSupport<Mutation> ClonableMutation;
  typedef lib::PolymorphicValue<Mutation, MUTATION_IMPL_SIZE, ClonableMutation> EncapsulatedMutation;
  
  class Mutation
    {
    public:
      virtual ~Mutation();
      
      virtual void change (Duration&)  const  =0;
      virtual void change (TimeSpan&)  const  =0;
      virtual void change (QuTime&)    const  =0;
      
      /* === convenience shortcuts for simple cases === */
      
      static EncapsulatedMutation changeTime (Time);
      static EncapsulatedMutation changeDuration (Duration);
      static EncapsulatedMutation adjust (Offset);
      static EncapsulatedMutation materialise (QuTime const&);
      static EncapsulatedMutation nudge (int adjustment);
      static EncapsulatedMutation nudge (int adjustment, Symbol gridID);      
#ifdef LIB_TIME_TIMEQUANT_H
      static EncapsulatedMutation nudge (int adjustment, PQuant const& grid);
#endif
      
    protected:
      static TimeValue& imposeChange (TimeValue&, TimeValue const&);
      static TimeValue& imposeChange (TimeValue&, Offset const&);
      static TimeValue& imposeChange (TimeValue&, int);
      static TimeValue& imposeChange (QuTime&, int);
    };
  
  
  /* === defining the visitation responses === */
  
  inline void Duration::accept (Mutation const& muta) { muta.change (*this); }
  inline void TimeSpan::accept (Mutation const& muta) { muta.change (*this); }
  
#ifdef LIB_TIME_TIMEQUANT_H
  inline void QuTime::accept   (Mutation const& muta) { muta.change (*this); }
#endif
  
  
  
  /* === implementing the actual changes === */
  
  inline TimeValue&
  Mutation::imposeChange (TimeValue& target, TimeValue const& valueToSet)
  {
    return target = valueToSet; 
  }
  
  inline TimeValue&
  Mutation::imposeChange (TimeValue& target, Offset const& offset)
  {
    return imposeChange (target, TimeVar(target) += offset); 
  }
  
  inline TimeValue&
  Mutation::imposeChange (TimeValue& target, int steps)
  {
    return imposeChange (target, TimeVar(target) += Time(FSecs(steps)));
  }
  
#ifdef LIB_TIME_TIMEQUANT_H

  inline TimeValue&
  Mutation::imposeChange (QuTime& target, int steps)
  {
    PQuant const& grid (target);
    FrameCnt originalGridPoint = grid->gridPoint(target);
    FrameCnt adjustedGridPoint = originalGridPoint + steps;
    return imposeChange (target, grid->timeOf (adjustedGridPoint));
  }
#endif
  
  
  
}} // lib::time
#endif