GenericProcess.h

#pragma once
/*
 * SPDX-FileCopyrightText: 2005,2022 Daniel Barrientos
 * <danivillamanin@gmail.com>
 *
 * SPDX-License-Identifier: MIT
 */
#include <tasking/GenericProcessDefs.h>
#include <tasking/Process.h>
using mel::tasking::Process;
 
#include <functional>
namespace mel
{
    namespace tasking
    {
        class MEL_API GenericProcess : public Process
        {
          public:
            typedef std::function<EGenericProcessResult( uint64_t, Process* )>
                GenericCallback;
 
          private:
            GenericCallback mProcessCallback;
            std::function<bool()> mKillCallback;
            volatile EGenericProcessResult mUpdateResult;
 
          public:
            GenericProcess();
            ~GenericProcess();
 
            template <class F> void setProcessCallback( F&& functor );
            inline const GenericProcess::GenericCallback&
            getProcessCallback() const;
            template <class F> void setKillCallback( F&& functor );
 
          protected:
            void onInit( uint64_t msegs ) override;
            bool onKill() override;
            void onUpdate( uint64_t msegs ) override;
        };
        template <class F>
        void GenericProcess::setProcessCallback( F&& functor )
        {
            mProcessCallback = std::forward<F>( functor );
        }
        const GenericProcess::GenericCallback&
        GenericProcess::getProcessCallback() const
        {
            return mProcessCallback;
        }
        template <class F> void GenericProcess::setKillCallback( F&& functor )
        {
            mKillCallback = std::forward<F>( functor );
        }
    } // namespace tasking
} // namespace mel