exit-node.hpp

Go to the documentation of this file.

/*
  EXIT-NODE.hpp  -  top-level node of the render network to pull generated media
 
   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 ENGINE_EXIT_NODE_H
#define ENGINE_EXIT_NODE_H
 
#include "lib/error.hpp"
#include "lib/nocopy.hpp"
#include "lib/hash-value.h"
#include "lib/iter-adapter-stl.hpp"
#include "lib/time/timevalue.hpp"
#include "vault/gear/job.h"              
 
#include <utility>
#include <deque>
 
using lib::HashVal;
using lib::time::FSecs;        
using lib::time::Duration;
 
 
namespace steam {
namespace engine {
 
  class ExitNode;
  using ExitNodes = std::deque<engine::ExitNode>;
  
  using vault::gear::JobFunctor;
  
  namespace {// hard wired placeholder config....
    const Duration DUMMY_JOB_RUNTIME{FSecs{1,50}};
  }
  
  
  class ExitNode
    : util::NonAssign
    {
      HashVal   pipelineIdentity_;                 
      Duration  runtimeBound_;                    
      ExitNodes prerequisites_;                  
      JobFunctor* action_{nullptr};             
      
    public:
      ExitNode()
        : pipelineIdentity_{0}
        , runtimeBound_{DUMMY_JOB_RUNTIME}
        , prerequisites_{}
      { }
      
      ExitNode (HashVal id
               ,Duration jobRuntime
               ,ExitNodes&& prereq  =ExitNodes{}
               ,JobFunctor* functor =nullptr)
        : pipelineIdentity_{id}
        , runtimeBound_{jobRuntime}
        , prerequisites_{std::move (prereq)}
        , action_{functor}
      { }
      
      explicit
      ExitNode (HashVal id
               ,ExitNodes&& prereq  =ExitNodes{})
        : ExitNode{id, DUMMY_JOB_RUNTIME, std::move(prereq)}
      { }
      
      static ExitNode NIL;
      
      
      bool
      empty()  const
        {
          return 0 == pipelineIdentity_
              or not action_;
        }
      
      bool
      isValid()  const
        {
          return true;                
        }
      
      
      HashVal
      getPipelineIdentity()  const
        {
          return pipelineIdentity_;
        }
      
      auto
      getPrerequisites()  const
        {
          return lib::iter_stl::eachElm (prerequisites_);
        }
      
      JobFunctor&
      getInvocationFunctor()  const
        {
          REQUIRE (action_);
          return *action_;            
        }
      
      Duration
      getUpperBoundRuntime()  const
        {
          return runtimeBound_;
        }
    };
  
  
}} // namespace steam::engine
#endif /*ENGINE_EXIT_NODE_H*/