HDF5CreatorBase.hpp

#ifndef __FIBER_HDF5CREATORBASE_HPP
#define __FIBER_HDF5CREATORBASE_HPP
 
#include <F5/F5R.h>
#include <F5/F5private.h>
#include <field/MemArray.hpp>
#include <field/CreativeArray.hpp>
#include <field/Field.hpp>
#include <queue>
#include <memory>
#include "TypeRegistry.hpp"
#include "F5Fragment.hpp"
 
#include <memcore/Loader.hpp>
#include <memcore/AlzheimerCreator.hpp>
 
#include <future>
#include <mutex>
 
namespace Fiber
{
 
//class FiberIOHDF5_API HDF5CreatorBase : public CreativeArray
 
class FiberIOHDF5_API HDF5CreatorBase : public AlzheimerCreator<MemBase, CreativeArrayBase>
                                      , public F5Fragment
{
protected:
        using F5Fragment::myGroup;
 
        typedef AlzheimerCreator<MemBase, CreativeArrayBase> Base_t;
 
        DynamicSize     mySize;
        unsigned        ElementSize = 0; // is filled in after setup()
 
        std::atomic<long>       NumberOfLoadingOperations = 0;
 
        std::atomic<bool>       isLoading = false;
 
        mutable std::mutex      CreationMutex;
//      mutable std::mutex      LoadingFlagMutex;
 
        virtual HDF5CreatorBase::DataPtr_t load_data() = 0;
 
        void    setup(const RefPtr<FiberTypeBase>&MyFiberType);
 
        std::future<bool>       AsynchroneouslyComputedData;
 
public:
static  bool    loadHDF5Data(const RefPtr<HDF5CreatorBase>&TheHDF5Creator, const result&R);
 
        /* WorkQueue
        template<class T>
        using Queue = std::queue<T>;
 
        std::shared_ptr<WorkerQueue<Queue>> _WorkQueue;
 
        static std::shared_ptr<WorkerQueue<Queue>> getWorkQueue();
        */
 
public:
        string  path_info;
 
        WeakPtr<LoaderProgress> LP;
        WeakPtr<StorageTransformations::IOPerformance> LoadPerformance;
 
        int             FragmentNumber = 1;
        WeakPtr<Field>  MyLoaderField;
 
        Timer           Stats;
 
 
        HDF5CreatorBase(const RefPtr<LoaderProgress>&BLP,
                        const F5Fragment&HC,
                        const DynamicSize&theSize,
                        const RefPtr<MemBase>&Data,
                        const WeakPtr<Cache>&theCache);
 
 
        ~HDF5CreatorBase();
 
        string  makeInfoString() const;
 
        const type_info&getType() override;
        const type_info&const_getType() const;
 
        size_t  getMemSize() const
        {
                return  mySize.getNumberOfElements()*ElementSize;
        }
 
        RefPtr<MemBase> produce() override;
 
        bool    request(const result&R) override;
 
        bool    isUnderCreation() const override;
 
        bool    discardCreation() override;
 
        Creature::ReasonForReleasal release() override;
};
 
 
} // namespace Fiber
 
 
#endif // __FIBER_HDF5CREATORBASE_HPP