special-job-fun.hpp

Go to the documentation of this file.

/*
  SPECIAL-JOB-FUN.hpp  -  a one-time render job to do something special

   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 VAULT_GEAR_SPECIAL_JOB_FUN_H
#define VAULT_GEAR_SPECIAL_JOB_FUN_H



#include "lib/handle.hpp"
#include "vault/gear/nop-job-functor.hpp"
#include "lib/time/timevalue.hpp"
#include "lib/format-string.hpp"
#include "lib/format-obj.hpp"
#include "lib/meta/util.hpp"

#include <string>
#include <memory>
#include <utility>


namespace vault{
namespace gear {
  namespace err = lumiera::error;
  
  using util::_Fmt;
  using lib::meta::disable_if_self;
  using std::move;
  using std::forward;
  using std::make_shared;
  
  
  class SpecialFunPrototype
    : public NopJobFunctor
    {
    public:
      virtual uint remainingInvocations()  const  =0;
    };
  
  
  
  
  class SpecialJobFun
    : protected lib::Handle<SpecialFunPrototype>
    {
      using _Handle = lib::Handle<SpecialFunPrototype>;
      
      template<class FUN>
      class SpecialExecutor
        : SpecialFunPrototype
        {
          FUN fun_;
          uint lives_{1};
          _Handle selfHook_;
          
        public:
          explicit
          SpecialExecutor (FUN theFun)
            : fun_{move (theFun)}
            , selfHook_(this)
            { }
          
          friend _Handle&
          selfAttached (SpecialExecutor* instance)
          {
            REQUIRE (instance->selfHook_);
            REQUIRE (instance->remainingInvocations());
            // expose the self-managing handle
            return instance->selfHook_;
          }
          
          
          uint
          remainingInvocations()  const
            {
              return lives_;
            }
          
          
          /* === JobFunctor Interface === */
          
          void
          invokeJobOperation (JobParameter param)  override
            {
              if (not remainingInvocations())
                throw err::Logic{"invoking deceased SpecialJobFun"
                                ,err::LUMIERA_ERROR_LIFECYCLE};
              fun_(param);
              
              if (not --lives_)
                selfHook_.close();
            }          // Suicide.
          
          std::string
          diagnostic()  const override
            {
              return _Fmt{"SpecialJob(%d)-%s"}
                         % lives_
                         % util::showHash(size_t(this), 2);
            }
        };
      
      
      
    public:
      SpecialJobFun()  = default;
      
      template<class FUN,            typename =disable_if_self<SpecialJobFun, FUN>>
      explicit
      SpecialJobFun (FUN&& someFun)
        : _Handle{selfAttached (new SpecialExecutor(forward<FUN> (someFun)))}
        { }
      
      // standard copy operations acceptable
      
      explicit
      operator bool()  const
        {
          return 0 < remainingInvocations();
        }
      
      operator JobClosure&()  const
        {
          REQUIRE (operator bool());
          return _Handle::impl();
        }
      
      uint
      remainingInvocations()  const
        {
          return _Handle::isValid()? _Handle::impl().remainingInvocations()
                                   : 0;
        }
      
      long
      use_count()  const
        {
          return _Handle::smPtr_.use_count();
        }
    };
  
  
}} // namespace vault::gear
#endif /*VAULT_GEAR_SPECIAL_JOB_FUN_H*/