FragmentIO.hpp

#ifndef __FIBERIO_HDF5_SAVE_FRAGMENTS_HPP
#define __FIBERIO_HDF5_SAVE_FRAGMENTS_HPP
 
#include <hdf5.h>
#include <F5/F5defs.h>
#include <F5/F5Path.h>
#include <fiber/field/FragmentID.hpp>
#include <fiber/field/TypedArray.hpp>
#include <fiber/grid/SkeletonID.hpp>
#include <fiber/grid/Grid.hpp>
 
namespace Fiber
{
namespace FiberIO
{
namespace HDF5
{
 
using namespace Fiber;
using namespace std;
 
 
struct  F5FragmentAttributes
{
        hsize_t data_start   [FIBER_MAX_RANK];
        hsize_t*start_border = 0;
        hsize_t*end_border   = 0;
 
        hsize_t overlap_start[FIBER_MAX_RANK];
        hsize_t overlap_end  [FIBER_MAX_RANK];
 
        F5FragmentAttributes(const MemCore::RefPtr<Fiber::FragmentID>&fID);
};
 
bool    SaveFragmentArray(const RefPtr<Fiber::Grid>&theGrid, const TypedArray<RefPtr<FragmentID> >&Array, F5Path*myPath,
                          const string&name, int rank, hsize_t dims[],
                          const MemCore::RefPtr<Fiber::FragmentID>&fID,
                          const SkeletonID&TargetSkeletonID);
 
RefPtr<MemBase>
        loadFragmentArray(int skel_dims,
                          F5Path*Context,
                          hid_t FragmentRepresentationPositions_id,
                          RefPtr<FragmentIDCollection>&TopologicalFragmentIDCollection);
 
 
bool    SaveVectorFragmentArray(const TypedArray<vector<RefPtr<FragmentID>> >&Array,
                                F5Path*myPath,
                                const SkeletonID&TargetSkeletonID,
                                const string&name, int rank, hsize_t dims[],
                                const MemCore::RefPtr<Fiber::FragmentID>&fID);
 
RefPtr<TypedArray<vector<RefPtr<FragmentID>> > >
        loadVectorFragmentArray(hid_t DatasetID, const DynamicSize&theSize, Skeleton&TargetSkeleton,
                                const MemBase::Creator_t&C = nullptr);
 
        
SkeletonID      identifyFragmentIDSkeleton(hid_t type_id);
 
 
class   FragmentIDBuffer : std::vector<char>
{
        bool    CheckZeros = false;
        size_t  max_str_len = 0;
        size_t  nFragments = 0;
 
public:
        int     rank = 0;
        hsize_t dims[FIBER_MAX_RANK] = {0,0,0,0,0};
 
        FragmentIDBuffer() = delete;
        FragmentIDBuffer(const FragmentIDBuffer&) = delete;
        
        FragmentIDBuffer(hid_t DatasetID, F5Path*IndexPermutationContext);
 
        size_t  NumberOfFragments() const
        {
                return nFragments;
        }
 
private:
        void    createVectorOfString(std::vector<string>&FragmentNameVector) const;
 
public:
        RefPtr<TypedArray<string>> createFragmentNames() const;
 
        [[deprecated("use createFragmentNames() instead")]]
        void    createIDs(std::vector<RefPtr<FragmentID> >&FragmentVector,
                          FragmentIDCollection&TopologicalFragmentIDCollection);
 
        DynamicSize getSize() const
        {
                return DynamicSize(rank, dims);
        }
};
 
}
}
}
 
#endif // __FIBERIO_HDF5_SAVE_FRAGMENTS_HPP