AsynchronCreator.hpp

#ifndef __FISH_BONE_ASYNCHRON_CREATOR_HPP
#define __FISH_BONE_ASYNCHRON_CREATOR_HPP
 
#include <field/MemBase.hpp>
#include <field/CreativeArrayBase.hpp>
#include <memcore/AlzheimerCreator.hpp>
#include <future>
 
 
namespace Fiber
{
 
 
class   [[deprecated("Use FunctionalCreator instead")]]
        FIELD_API  AsynchronCreator : public MemCore::AlzheimerCreator<MemBase, CreativeArrayBase>
{
protected:
        typedef AlzheimerCreator<MemBase, CreativeArrayBase> Base_t;
 
        volatile long NumberOfLoadingOperations { 0 };
        std::atomic<bool>       isLoading { false };
 
        std::atomic<bool>       discardCreationFlag { false };
 
        mutable std::mutex      CreationMutex;
        mutable std::mutex      LoadingFlagMutex;
 
        std::function< DataPtr_t(const std::atomic<bool>&Stop) > myDataCreator;
 
        DataPtr_t create_data() const;
 
mutable std::future<bool>       AsynchroneouslyComputedData;
 
static  bool    createData(const MemCore::WeakPtr<AsynchronCreator>&TheCreator, const result&R);
 
public:
        AsynchronCreator(const std::function< DataPtr_t(const std::atomic<bool>&) >&CreationFunctor,
                         const RefPtr<MemCore::Cache>&theCache = MemCore::Cache::MemCache() );
 
        ~AsynchronCreator();
 
        void    setup(const DynamicSize&theSize, const RefPtr<FiberTypeBase>&MyFiberType);
 
        const type_info&getType() override;
 
        RefPtr<MemBase> produce()  override;
 
        bool    request(const result&R) override;
 
        bool    isUnderCreation() const override;
 
        bool    discardCreation() override;
 
        Creature::ReasonForReleasal release() override;
 
#if     0
        Creature::ReasonForReleasal release() override;
 
        virtual RefPtr<Fiber::MemBase> compute() const = 0;
 
        struct  fishbone_API ComputationTask : VTask
        {
                RefPtr<CreativeArrayBase>       Input;
                WeakPtr<AsynchronCreator>       Output;
 
                ComputationTask(const WeakPtr<VParameter>&Owner,
                                const RefPtr<AsynchronCreator>&AC);
 
                ~ComputationTask();
 
                void run() override;
 
                void valueChanged(const RefPtr<VValueBase>&value,
                                           const ValuePoolPtr&Context,
                                           const ValueNotifierList*DoNotBroadcast,
                                           const ValueMap*VP=0) override;
        };
 
        RefPtr<ComputationTask> CT;
 
        bool    isRunning() const;
 
        RefPtr<MemBase> produce() override;
 
        CacheablePtr getCacheable() const override
        {
                return result;
        }
 
        RefPtr<MemBase> get() const override
        {
                return result;
        }
 
/*
TODO: Implement these functions:
 
        virtual bool isUnderCreation();
        virtual bool discardCreation();
*/
#endif
};
 
template <class Type>
class   TypedAsynchronCreator : public AsynchronCreator
{
public:
        TypedAsynchronCreator()
        {}
 
        const type_info&getType()
        {
                return typeid(Type);
        }
};
 
} // namespace Wizt
 
#endif // ASYNCHRON_CREATOR_HPP