track-profile.hpp

Go to the documentation of this file.

/*
  TRACK-PROFILE.hpp  -  building the 3D profile of tracks for timeline presentation

  Copyright (C)         Lumiera.org
    2019,               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 STAGE_TIMELINE_TRACK_PROFILE_H
#define STAGE_TIMELINE_TRACK_PROFILE_H

#include "stage/gtk-base.hpp"
#include "lib/verb-visitor.hpp"

#include "lib/iter-explorer.hpp"
#include "lib/symbol.hpp"
#include "lib/util.hpp"

//#include <memory>
#include <utility>
#include <vector>



namespace stage  {
namespace timeline {
  
  using lib::Literal;
  using util::isnil;
  using std::forward;
  
  class ProfileInterpreter
    {
      public:
        virtual ~ProfileInterpreter() { }   
        
        virtual void ruler(uint h)   =0;    
        virtual void gap(uint h)     =0;    
        virtual void content(uint h) =0;    
        virtual void open()          =0;    
        virtual void close(uint n)   =0;    
        virtual void prelude()       =0;    
        virtual void coda(uint pad)  =0;    
        
        static const size_t MAX_ARG_SIZE = sizeof(size_t);
    };
  
  class TrackProfile
    {
      using SlopeVerb = lib::VerbPack<ProfileInterpreter, void, ProfileInterpreter::MAX_ARG_SIZE>;
      using Elements =  std::vector<SlopeVerb>;
      
      Elements elements;
      int pinnedPrefixCnt = 0;
      
    public:
      // default constructible, standard copy operations
      
      bool
      empty()  const
        {
          return elements.empty();
        }
      
      void
      clear()  noexcept
        {
          elements.clear();
        }
      
      void
      performWith (ProfileInterpreter& interpreter)
        {
          for (auto& slopeVerb : elements)
              slopeVerb.applyTo (interpreter);
        }
      
      void performWith (ProfileInterpreter& interpreter, bool isRulerSegment);
      
      
      
    private:/* ===== Internals: handling tokens ===== */
      
      template<typename FUN, typename...ARGS>
      void
      append (FUN&& handler, Literal token, ARGS&&... params)
        {
          elements.emplace_back (forward<FUN>(handler), token, forward<ARGS>(params)...);
        }
      
#define TOKEN_BUILDER(_TOK_)          \
      template<typename...ARGS>        \
      void                              \
      append_ ## _TOK_ (ARGS&&... params)\
        {                                 \
          this->append (&ProfileInterpreter::_TOK_, STRINGIFY(_TOK_), forward<ARGS>(params)...); \
        }
      
    public:
      TOKEN_BUILDER (ruler)
      TOKEN_BUILDER (gap)
      TOKEN_BUILDER (content)
      TOKEN_BUILDER (open)
      TOKEN_BUILDER (close)
      TOKEN_BUILDER (prelude)
      TOKEN_BUILDER (coda)
      
      void
      addSlopeDown()
        {
          this->append_open();
        }
      
      void
      addSlopeUp()
        {
          if (lastEntryIs("close"))
            incrementLastCloseSlope();
          else
            append_close (1);
        }
      
      uint
      getPrecedingSlopeUp()
        {
          if (lastEntryIs("close"))
            return elements.back().accessArg<uint>();
          return 0;
        }
      
      void
      markPrefixEnd()
        {
          pinnedPrefixCnt = elements.size();
        }
      
    private:
      bool
      lastEntryIs (Literal expectedToken)
        {
          return not isnil(elements)
             and elements.back()->getID() == expectedToken;
        }
      
      void
      incrementLastCloseSlope()
        {
          REQUIRE (lastEntryIs ("close"));
          uint& slopeDepth = elements.back().accessArg<uint>();
          
          ++ slopeDepth;
        }
      
      auto
      filterSegment(bool selectPrefixPart)
        {
                struct CountingFilter
                  {
                    int cnt;
                    bool selectPrefix;
                    
                    bool
                    operator() (...)
                      {
                        bool isPrefixPart = 0 < cnt--;
                        return selectPrefix? isPrefixPart : not isPrefixPart;
                      }
                  };
          
          
          return lib::explore (elements)
                     .filter (CountingFilter{pinnedPrefixCnt, selectPrefixPart});
        }
    };
  
  
  inline void
  TrackProfile::performWith (ProfileInterpreter& interpreter, bool isRulerSegment)
  {
    for (auto& slopeVerb : filterSegment(isRulerSegment))
      slopeVerb.applyTo (interpreter);
  }
  
  
  
}}// namespace stage::timeline
#endif /*STAGE_TIMELINE_TRACK_PROFILE_H*/