AsynchronCreator.hpp

#ifndef __FISH_BONE_ASYNCHRON_CREATOR_HPP
#define __FISH_BONE_ASYNCHRON_CREATOR_HPP

#include "fishboneDllApi.h"

#include <ocean/plankton/VCreator.hpp>
#include <ocean/plankton/VTime.hpp>
#include <ocean/plankton/VThread.hpp>
#include <ocean/plankton/VCotask.hpp>
#include <bundle/Bundle.hpp>

namespace Wizt
{
//using namespace Fiber;


class   fishbone_API AsynchronCreator : public Fiber::CreativeArrayBase
{
        RefPtr<Fiber::MemBase>  result;

public: 
        typedef Fiber::CreativeArrayBase CreativeArrayBase; 
        typedef Fiber::MemBase           MemBase;

        RefPtr<VValueParameter<VThreadManager> >  ThreadManagerParam; 

        bool    do_async; 

        AsynchronCreator(RefPtr<VValueParameter<VThreadManager> >&TMPar, const RefPtr<Cache>&theCache = Cache::MemCache() );

        AsynchronCreator(VCotask*CoTask, const RefPtr<Cache>&theCache = Cache::MemCache() );

        ~AsynchronCreator();

        override bool release(); 

        virtual RefPtr<Fiber::MemBase> compute() = 0;

        struct  fishbone_API ComputationTask : VTask
        {
                RefPtr<CreativeArrayBase>       Input;
                WeakPtr<AsynchronCreator>       Output;

                ComputationTask(const WeakPtr<VParameter>&Owner, 
                                const RefPtr<AsynchronCreator>&AC);

                ~ComputationTask(); 

                override void run();

                override void valueChanged(const RefPtr<VValueBase>&value,
                                           const ValueNotifierList*DoNotBroadcast,
                                           const ValueMap*VP=0);
        };

        RefPtr<ComputationTask> CT; 

        bool    isRunning() const; 

        override RefPtr<MemBase> create();

        override RefPtr<MemBase> get() const
        {
                return result;
        }
};

template <class Type>
class   fishbone_API TypedAsynchronCreator : public AsynchronCreator 
{
public:
        TypedAsynchronCreator( RefPtr<VValueParameter<VThreadManager> >&TMPar)
        : AsynchronCreator()
        {}

        const type_info&getType()
        {
                return typeid(Type);
        }
};

} // namespace Wizt

#endif // ASYNCHRON_CREATOR_HPP