time-grid.cpp

Go to the documentation of this file.

/*
  TimeGrid  -  reference scale for quantised time

  Copyright (C)         Lumiera.org
    2010,               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.

* *****************************************************/


#include "steam/asset/meta/time-grid.hpp"
#include "steam/asset/struct-scheme.hpp"
#include "steam/assetmanager.hpp"
#include "lib/time/quantiser.hpp"
#include "lib/time/timevalue.hpp"
#include "lib/format-string.hpp"
#include "common/advice.hpp"
#include "lib/util.hpp"

#include <string>

using util::_Fmt;
using util::isnil;
using std::string;


namespace steam {
namespace asset {
namespace meta {
  
  namespace error = lumiera::error;
  
  
 
  TimeGrid::TimeGrid (GridID const& nameID)
    : Meta{nameID}
    { }
  
  
  using lib::time::Time;
  using lib::time::TimeValue;
  using lib::time::TimeSpan;
  using lib::time::Duration;
  using lib::time::Offset;
  using lib::time::FSecs;
  
  using lib::time::PQuant;
  using lib::time::Quantiser;
  using lib::time::FixedFrameQuantiser;
  using std::dynamic_pointer_cast;
  
  namespace advice = lumiera::advice;
  
  namespace {
    
    inline PGrid
    publishWrapped (TimeGrid& newGrid)
    {
    PGrid gridImplementation = AssetManager::instance().wrap (newGrid);
    PQuant quantiser (dynamic_pointer_cast<const Quantiser>(gridImplementation));
    Literal bindingID (cStr(newGrid.ident.name));                            
    
    advice::Provision<PGrid>(bindingID).setAdvice(gridImplementation);
    advice::Provision<PQuant>(bindingID).setAdvice(quantiser);
    return gridImplementation;
    }
    

  }
  
  class SimpleTimeGrid
    : public TimeGrid
    , public FixedFrameQuantiser
    {
      
    public:
      SimpleTimeGrid (Time start, Duration frameDuration, GridID const& name)
        : TimeGrid (name)
        , FixedFrameQuantiser(frameDuration,start)
        { }
      
      SimpleTimeGrid (Time start, FrameRate frames_per_second, GridID const& name)
        : TimeGrid (name)
        , FixedFrameQuantiser(frames_per_second,start)
        { }
    };
  
    
  
  lib::P<TimeGrid>
  Builder<TimeGrid>::commit()
  {
    if (predecessor)
      throw error::Invalid("compound and variable time grids are a planned feature"
                          , error::LUMIERA_ERROR_UNIMPLEMENTED);
    ENSURE (fps, "infinite grid should have been detected by FrameRate ctor");
    
    if (isnil (id))
      {
        _Fmt gridIdFormat("grid(%f_%d)");
        id = string(gridIdFormat % fps % _raw(origin));
      }
    GridID nameID (id);
    
    // build new Meta-Asset, registered with AssetManager, and publish into Advice-System 
    return publishWrapped (*new SimpleTimeGrid(origin, fps, nameID));             
  }
  
  
  /* === TimeGrid shortcut builder functions === */
  
  PGrid
  TimeGrid::build (FrameRate frames_per_second)                   
  {
    return build (Symbol::EMPTY,frames_per_second);
  }
  
  PGrid
  TimeGrid::build (Symbol gridID, FrameRate frames_per_second)    
  {
    return build (gridID,frames_per_second, Time::ZERO);
  }
  
  
  PGrid
  TimeGrid::build (Symbol gridID, FrameRate frames_per_second, Time origin)
  {
    string name(gridID);
    Builder<TimeGrid> spec(name);
    spec.fps = frames_per_second;
    spec.origin = origin;
    
    return spec.commit();
  }
  
  
}}} // namespace asset::meta