SaveGrid.hpp

#ifndef __FIBER_FIBERIO_HDF5_GRIDSAVER_HPP
#define __FIBER_FIBERIO_HDF5_GRIDSAVER_HPP
 
#include "F5Skeleton.hpp"
#include "HDF5Binder.hpp"
#include "HDF5Saver.hpp"
#include <bundle/Occurrence.hpp>
 
 
namespace Fiber
{
 
namespace FiberIO
{
 
namespace HDF5
{
 
using namespace MemCore;
using namespace Fiber;
 
template <>
struct  HDF5Saver<Representation> : Skeleton::RepresentationMap::Iterator
{
        RefPtr<H5File>          myFile;
        RefPtr<Bundle>          myBundle;
        const   GridID          &Gid;
        WeakPtr<Grid>           myGrid;
        const   SkeletonID      &Sid;
        const   Skeleton        &S;
        double                  time;
        const Occurrence<Bundle>&OB;
        const RefPtr<Fiber::Binder> myBinder;
        const RefPtr<StorageTransformations> myST;
 
 
        HDF5Saver(const RefPtr<H5File>&theFile, const RefPtr<Bundle>&B,
                  const GridID&Id,
                  const WeakPtr<Grid>&theGrid,
                  const SkeletonID&id, const Skeleton&Skel,
                  double T, const Occurrence<Bundle> &pOB,
                  const RefPtr<Fiber::Binder>&theBinder,
                  const RefPtr<StorageTransformations>&theST)
        : myFile ( theFile )
        , myBundle(B)
        , Gid(Id)
        , myGrid ( theGrid )
        , Sid(id), S(Skel)
        , time(T)
        , OB(pOB)
        , myBinder(theBinder)
        , myST(theST)
        {}
 
        bool    apply(const Representer&d, Representation&R) override;
};
 
template <>
struct  HDF5Saver<Skeleton> : SkeletonIterator, Occurrence<Grid>
{
        RefPtr<H5File>           myFile;
        RefPtr<Bundle>           myBundle;
        const WeakPtr<Grid>      myGrid;
        const Occurrence<Bundle> &OB;
        const RefPtr<Fiber::Binder> myBinder;
        const RefPtr<StorageTransformations> myST;
 
        HDF5Saver(const RefPtr<H5File>&theFile, const RefPtr<Bundle>&B,
                  const GridID&Id,
                  const WeakPtr<Grid>&theGrid,
                  const Occurrence<Slice>&T, const Occurrence<Bundle> &pOB,
                  const RefPtr<Fiber::Binder>&theBinder,
                  const RefPtr<StorageTransformations>&theST)
        : Occurrence<Grid>(T, Id.self() )
        , myFile ( theFile )
        , myBundle(B)
        , myGrid( theGrid )
        , OB(pOB)
        , myBinder(theBinder)
        , myST( theST )
        {}
 
        bool    apply(const SkeletonID&id, Skeleton&S) override;
};
 
template <>
struct  HDF5Saver<Grid> : GridIterator,  Occurrence<Slice>
{
        double                          time;
        const ParameterSet&             Params;
        RefPtr<H5File>                  myFile;
        RefPtr<Bundle>                  myBundle;
        const Occurrence<Bundle>        &OB;
        const RefPtr<Fiber::Binder>     myBinder;
        const RefPtr<StorageTransformations> myST;
 
        HDF5Saver(const RefPtr<H5File>&theFile, const RefPtr<Bundle>&B,
                  ParameterSet&P, double T, const Occurrence<Bundle> &pOB,
                  const RefPtr<Fiber::Binder>&theBinder,
                  const RefPtr<StorageTransformations>&theST)
        : Occurrence<Slice>(T)
        , time(T)
        , Params(P)
        , myFile ( theFile )
        , myBundle(B)
        , OB(pOB)
        , myBinder(theBinder)
        , myST( theST )
        {}
 
        bool    apply(GridID&id, Grid&g) override;
 
        void    renameGridSkeletons(GridID&id, Grid&g) const;
};
 
}}} // namespace
 
#endif // __FIBER_FIBERIO_HDF5_GRIDSAVER_HPP