activity-lang.hpp

Go to the documentation of this file.

/*
  ACTIVITY-LANG.hpp  -  definition language framework for scheduler activities

   Copyright (C)
     2023,            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 SRC_VAULT_GEAR_ACTIVITY_LANG_H_
#define SRC_VAULT_GEAR_ACTIVITY_LANG_H_


#include "vault/gear/activity.hpp"
#include "vault/gear/block-flow.hpp"
#include "vault/gear/activity-term.hpp"


namespace vault{
namespace gear {
  
  using BlockFlowAlloc = BlockFlow<blockFlow::RenderConfig>;
  
  
  
  /*************************************************************************************/
  class ActivityLang
    {
      BlockFlowAlloc& mem_;
      
    public:
      explicit
      ActivityLang (BlockFlowAlloc& memManager)
        : mem_{memManager}
        { }
      
      // using default copy/assignment
      
      
      activity::Term
      buildCalculationJob (Job job, Time start, Time deadline)
        {
          return setupActivityScheme (activity::Term::CALC_JOB, job, start, deadline);
        }
      
      activity::Term
      buildAsyncLoadJob (Job job, Time start, Time deadline)
        {
          return setupActivityScheme (activity::Term::LOAD_JOB, job, start, deadline);
        }
      
      activity::Term
      buildMetaJob (Job job, Time start, Time deadline)
        {
          return setupActivityScheme (activity::Term::META_JOB, job, start, deadline);
        }
      
      
      Activity& createTick (Time deadline){ return mem_.until(deadline).create (Activity::TICK); }
      
      void discardBefore (Time deadline)  { mem_.discardBefore (deadline); }
      
      void announceLoad (FrameRate fps)   { mem_.announceAdditionalFlow(fps); }
      
      
      template<class EXE>
      static activity::Proc
      dispatchChain (Activity* chain, EXE& executionCtx)
        {
          if (!chain) return activity::PASS;
          activity::Proc res = chain->dispatch (executionCtx.getSchedTime(), executionCtx);
          if (activity::PASS == res)
            res = activateChain (chain->next, executionCtx);
          else if (activity::SKIP == res)
            res = activity::PASS;
          return res;
        }
      
      template<class EXE>
      static activity::Proc
      activateChain (Activity* chain, EXE& executionCtx)
        {
          activity::Proc res{activity::PASS};
          while (chain and activity::PASS == res)
            {
              res = chain->activate (executionCtx.getSchedTime(), executionCtx);
              chain = chain->next;
            }
          if (activity::SKIP == res)// SKIP has been handled
            res = activity::PASS;  //  just by aborting the loop
          return res;
        }
      
    private:
      activity::Term
      setupActivityScheme (activity::Term::Template schemeKind, Job job, Time start, Time dead)
        {
          return activity::Term{ mem_.until(dead)
                               , schemeKind
                               , start
                               , dead
                               , job
                               };
        }
    };
  
  
}} // namespace vault::gear
#endif /*SRC_VAULT_GEAR_ACTIVITY_LANG_H_*/