formats.hpp

Go to the documentation of this file.

/*
  FORMATS.hpp  -  formats for displaying and specifying time

   Copyright (C)
     2010,            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_FORMATS_H
#define LIB_TIME_FORMATS_H

#include "lib/time/timevalue.hpp"
#include "lib/meta/no-instance.hpp"
#include "lib/meta/typelist.hpp"
#include "lib/meta/generator.hpp"
#include "lib/typed-counter.hpp"

#include <memory>
#include <string>
#include <bitset>

namespace lumiera {
namespace error {
  LUMIERA_ERROR_DECLARE (INVALID_TIMECODE); 
}}


namespace lib {
namespace time {
  
  
  // ====== forward declarations of concrete Timecode types
  
  class FrameNr;
  class SmpteTC;
  class HmsTC;
  class Secs;
  
  
  class Quantiser; // API for grid aligning
  using QuantR = Quantiser const&;
  using PQuant = std::shared_ptr<const Quantiser>;
  
  
  namespace format {
    
    using std::string;
    using lib::meta::NoInstance; // the following types are for metaprogramming only...
    
    
    struct Frames
      : NoInstance<Frames>
      {
        static TimeValue    parse (string const&, QuantR);
        static void       rebuild (FrameNr&, QuantR, TimeValue const&);
        static TimeValue evaluate (FrameNr const&, QuantR);
      };
    
    
    struct Smpte
      : NoInstance<Smpte>
      {
        static TimeValue    parse (string const&, QuantR);
        static void       rebuild (SmpteTC&, QuantR, TimeValue const&);
        static TimeValue evaluate (SmpteTC const&, QuantR);
        static uint  getFramerate (QuantR, TimeValue const&);
        static void applyRangeLimitStrategy (SmpteTC&);
      };
    
    
    struct Hms
      : NoInstance<Hms>
      {
        static TimeValue    parse (string const&, QuantR);
        static void       rebuild (HmsTC&, QuantR, TimeValue const&);
        static TimeValue evaluate (HmsTC const&, QuantR);
      };
    
    
    struct Seconds
      : NoInstance<Seconds>
      {
        static TimeValue    parse (string const&, QuantR);
        static void       rebuild (Secs&, QuantR, TimeValue const&);
        static TimeValue evaluate (Secs const&, QuantR);
      };
    
    
    
    
    
    template<class FMT>
    struct Traits;
    
    template<>
    struct Traits<Frames>
      {
        using TimeCode = FrameNr;
      };
    
    template<>
    struct Traits<Smpte>
      {
        using TimeCode = SmpteTC;
      };
    
    template<>
    struct Traits<Hms>
      {
        using TimeCode = HmsTC;
      };
    
    template<>
    struct Traits<Seconds>
      {
        using TimeCode = Secs;
      };
    
    
    
    /* == Descriptor to define Support for specific formats == */
    
    using lib::meta::Types;
    using lib::meta::Node;
    using lib::meta::NullType;
    
    class Supported
      {
        enum { MAXID = 8 };
        
        std::bitset<MAXID> flags_;
        
        template<class F>
        IxID
        typeID()  const
          {
            return TypedContext<Supported>::ID<F>::get();
          }
        
        template<class F, class FS>
        Supported
        define(Node<F,FS>) 
          {
            flags_.set (typeID<F>());
            return define(FS());
          }
        Supported define(NullType) { return *this;} 
        
        Supported() { } 
        
        
      public:
        template<typename TY>
        static Supported
        formats()
          {
            typedef typename TY::List SupportedFormats;
            return Supported().define(SupportedFormats());
          }
        
        template<class F>
        bool
        check()  const
          {
            return flags_[typeID<F>()];
          }
      };
    
    struct SupportStandardTimecode
      : Supported
      {
        SupportStandardTimecode()
          : Supported(formats< Types<Hms,Smpte,Frames,Seconds> >())
          { }
      };
    
    
}}} // lib::time::format
#endif