mutation.cpp

Go to the documentation of this file.

/*
  Mutation  -  changing and adjusting time values
 
   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.
 
* *****************************************************************/
 
 
#include "lib/error.hpp"
#include "lib/time/timevalue.hpp"
#include "lib/time/timequant.hpp"
#include "lib/time/timecode.hpp"
#include "lib/time/mutation.hpp"
#include "lib/util-quant.hpp"
 
 
namespace error = lumiera::error;
 
namespace lib {
namespace time {
  
  
  LUMIERA_ERROR_DEFINE (INVALID_MUTATION, "Changing a time value in this way was not designated");
  
  
  Mutation::~Mutation()   { }  // emit VTable here....
  
  
  
  
  
  /* Warning: all the classes defined here must be of size below MUTATION_IMPL_SIZE */
  
  class SetNewStartTimeMutation
    : public ClonableMutation
    {
      TimeValue newTime_;
      
      virtual void
      change (Duration&)  const
        {
          throw error::Logic ("mutating the start point of a pure Duration doesn't make sense"
                             , LUMIERA_ERROR_INVALID_MUTATION);
        }
      
      
      virtual void
      change (TimeSpan& target)  const
        {
          imposeChange (target, newTime_);
        }
      
      
      virtual void
      change (QuTime& target)    const
        {
          imposeChange (target, newTime_);
        }
      
      
    public:
      explicit
      SetNewStartTimeMutation (TimeValue t)
        : newTime_(t)
        { }
    };
  
  
  class SetNewDuration
    : public ClonableMutation
    {
      Duration changedDuration_;
      
      virtual void
      change (Duration& target)  const
        {
          imposeChange (target, changedDuration_);
        }
      
      
      virtual void
      change (TimeSpan& target)  const
        {
          imposeChange (target.duration(), changedDuration_);
        }
      
      
      virtual void
      change (QuTime&)    const
        {
          throw error::Logic ("mutating the duration of a (quantised) time point doesn't make sense"
                             , LUMIERA_ERROR_INVALID_MUTATION);
        }
      
      
    public:
      explicit
      SetNewDuration (Duration dur)
        : changedDuration_(dur)
        { }
    };
  
  
  class ImposeOffsetMutation
    : public ClonableMutation
    {
      Offset adjustment_;
      
      virtual void
      change (Duration& target) const
        {
          imposeChange (target, adjustment_);
        }
      
      
      virtual void
      change (TimeSpan& target) const
        {
          imposeChange (target, adjustment_);
        }
      
      
      virtual void
      change (QuTime& target)   const
        {
          imposeChange (target, adjustment_);
        }
      
      
    public:
      explicit
      ImposeOffsetMutation (Offset adj)
        : adjustment_(adj)
        { }
    };
  
  
  class MaterialiseIntoTarget
    : public SetNewStartTimeMutation
    {
    public:
      explicit
      MaterialiseIntoTarget (QuTime const& quant)
        : SetNewStartTimeMutation (PQuant(quant)->materialise(quant))
        { }
    };
  
  
  class NudgeMutation
    : public ImposeOffsetMutation
    {
      
      static Offset
      materialiseGridPoint (PQuant const& grid, int steps)
        {
          REQUIRE (grid);
          return Offset(grid->timeOf(0), grid->timeOf(steps));
        }
      
    public:
      NudgeMutation (int relativeSteps, PQuant const& grid)
        : ImposeOffsetMutation(materialiseGridPoint (grid,relativeSteps))
        { }
    };
  
  
  class NaturalNudgeMutation
    : public ClonableMutation
    {
      int steps_;
      
      virtual void
      change (Duration& target) const
        {
          imposeChange (target, steps_);
        }
      
      
      virtual void
      change (TimeSpan& target) const
        {
          imposeChange (target, steps_);
        }
      
      
      virtual void
      change (QuTime& target)   const
        {
          imposeChange (target, steps_);
        }
      
   
    public:
      explicit
      NaturalNudgeMutation (int relativeSteps)
        : steps_(relativeSteps)
        { }
    };
  
  
  
  
  
  
  EncapsulatedMutation
  Mutation::changeTime (Time newStartTime)
  {
    return EncapsulatedMutation::build<SetNewStartTimeMutation> (newStartTime);
  }
  
  
  EncapsulatedMutation
  Mutation::changeDuration (Duration changedDur)
  {
    return EncapsulatedMutation::build<SetNewDuration> (changedDur);
  }
  
  
  EncapsulatedMutation
  Mutation::adjust (Offset change)
  {
    return EncapsulatedMutation::build<ImposeOffsetMutation> (change);
  }
  
  
  EncapsulatedMutation
  Mutation::materialise (QuTime const& gridAlignedTime)
  {
    return EncapsulatedMutation::build<MaterialiseIntoTarget> (gridAlignedTime);
  }
  
  
  EncapsulatedMutation
  Mutation::nudge (int adjustment)
  {
    return EncapsulatedMutation::build<NaturalNudgeMutation> (adjustment);
  }
  
  
  EncapsulatedMutation
  Mutation::nudge (int adjustment, PQuant const& grid)
  {
    return EncapsulatedMutation::build<NudgeMutation> (adjustment, grid);
  }
  
  
  
  
}} // lib::time