FragmentInterfaces.hpp

#ifndef __FIBER_FIBERIO_HDF5_FRAGMENTINTERFACES_HPP
#define __FIBER_FIBERIO_HDF5_FRAGMENTINTERFACES_HPP
 
#include <memcore/Interface.hpp>
#include <field/FragmentID.hpp>
#include <F5/F5Path.h>
#include <F5/F5F.h>
 
namespace Fiber
{
namespace FiberIO
{
namespace HDF5
{
 
using namespace Fiber;
using namespace MemCore;
 
 
template <Dims_t Dims>
bool    loadDimensions(MultiIndex<Dims>&dims, F5Path*field, const char*attribute_name, hid_t id)
{
hsize_t extension[FIBER_MAX_RANK];
        if (F5LAget_dimensions(id, attribute_name, extension) != Dims)
                return false;
 
        F5Tpermute_dimensions(field, Dims, extension, extension);
 
        for(int i=0;i<Dims;i++)
                dims[i] = extension[i];
 
        return true;
}
 
 
template <Dims_t N>
struct  FragmentInterfaces
{
        template <FragmentProperty TheProperty>
static  bool    loadFragmentInfo(const char*AttributeName,
                                 FragmentID&FID,
                                 F5Path*field, hid_t frag_id)
        {
        using FragInfo = FragmentLocation<N, TheProperty>;
 
        Ref<FragInfo> NewFL;
        MultiIndex<N>&V = *NewFL;
        bool    Have = loadDimensions( V, field, AttributeName, frag_id );
                if (!Have)
                {
                        Verbose(30) << "Could not read optional fragment attribute " << AttributeName;
                        return false;
                }
 
                if (RefPtr<FragInfo> CurrentFL = interface_cast<FragInfo>(FID))
                {
                        if (*CurrentFL != *NewFL)
                        {
                                Verbose(0) << "Fragment attribute " << AttributeName
                                           << " with value " << V
                                           << " is INCONSISTENT with previously defined value "
                                           << (const MultiIndex<N>&)(*CurrentFL);
                                return false;
                        }
                }
                else
                        FID.addInterface( NewFL );
 
                return true;
        }
 
static  bool    load(FragmentID&FID, hsize_t dims[FIBER_MAX_RANK], F5Path*field, hid_t frag_id)
        {
        MultiIndex<N>   FragmentSize;
                for(int i=0; i<N; i++)
                        FragmentSize[i] = dims[i];
 
                FID.addInterface( new SizeInterface( FragmentSize ) );
 
                loadFragmentInfo<FragmentProperty::Offset      >(FIBER_FRAGMENT_OFFSET_ATTRIBUTE         , FID, field, frag_id);
                loadFragmentInfo<FragmentProperty::OverlapStart>(FIBER_FRAGMENT_NOOVERLAP_START_ATTRIBUTE, FID, field, frag_id);
                loadFragmentInfo<FragmentProperty::OverlapEnd  >(FIBER_FRAGMENT_NOOVERLAP_END_ATTRIBUTE  , FID, field, frag_id);
 
                return true;
 
        }
 
#if 0
        template <FragmentProperty TheProperty>
static  bool    saveFragmentInfo(const char*AttributeName,
                                 FragmentID&FID,
                                 F5Path*field, hid_t frag_id)
        {
        using FragInfo = FragmentLocation<N, TheProperty>;
 
                if (RefPtr<FragInfo> F3 = interface_cast<FragInfo>(FID) )
                {
                        return saveDimensions( *F3, field, AttributeName, frag_id );
                }
                return false;
        }
 
static  void    save(RefPtr<FragmentID>&FID, F5Path*field, hid_t frag_id)
        {
                if (RefPtr<SizeInterface> SI = interface_cast<SizeInterface>(FID) )
                {
                        // no need do something with it.
                }
 
                saveFragmentInfo<FragmentProperty::Offset      >(FIBER_FRAGMENT_OFFSET_ATTRIBUTE         , FID, field, frag_id);
                saveFragmentInfo<FragmentProperty::OverlapStart>(FIBER_FRAGMENT_NOOVERLAP_START_ATTRIBUTE, FID, field, frag_id);
                saveFragmentInfo<FragmentProperty::OverlapEnd  >(FIBER_FRAGMENT_NOOVERLAP_END_ATTRIBUTE  , FID, field, frag_id);
        }
#endif
};
 
bool    loadFragmentProperties(int rank, FragmentID&FID, hsize_t dims[FIBER_MAX_RANK], F5Path*field, hid_t frag_id);
 
}
}
}
 
#endif //  __FIBER_FIBERIO_HDF5_FRAGMENTINTERFACES_HPP