Bundle.hpp

#ifndef __FIBER_BUNDLE_HPP
#define __FIBER_BUNDLE_HPP "Created 27.02.2001 21:42:27 by werner"

#include "BundleAPI.h"
#include <grid/Grid.hpp>
#include <memcore/Persistencer.hpp>
#include <memcore/Loader.hpp>
#include <list>
#include "GridID.hpp"
#include "Slice.hpp"
#include "ParameterSpace.hpp"
#include "FindInfo.hpp"

namespace Fiber
{
        using std::list;
        using std::string;
        using MemCore::SaveRegistry;

template <class ObjectLevel>
        class BUNDLE_API EvolutionIterator;

struct  BUNDLE_API GridSaveParameters : MemCore::SaveParameters
{
        RefPtr<MemCore::StringList>     SaveableGridNames; 

        GridSaveParameters(const string&url,
                           const RefPtr<MemCore::StringList>&GridNames)
        : MemCore::SaveParameters(url)
        , SaveableGridNames(GridNames)
        {}
};


template <>
class   BUNDLE_API EvolutionIterator<Slice>
{
public:
        virtual ~EvolutionIterator<Slice>();

        virtual bool apply(ParameterSet&P, Slice&S) = 0;
};

template <>
class   BUNDLE_API EvolutionIterator<Grid>
{
public:
        virtual ~EvolutionIterator<Grid>();

        virtual bool apply(double t, GridID&id, Grid&g) = 0;
};

template <>
class   BUNDLE_API EvolutionIterator<Skeleton>
{
public:
        virtual ~EvolutionIterator<Skeleton>();

        virtual bool apply(double t, const RefPtr<Skeleton>&S) = 0;
};

template <>
class   BUNDLE_API EvolutionIterator<Field>
{
public:
        ~EvolutionIterator<Field>();
};

class   BUNDLE_API BundleLoaderProgress : public LoaderProgress 
{
public:
        BundleLoaderProgress ();

        virtual bool OpenFile(const string&fname);

        virtual bool CreateSlice(double t);

        virtual bool CreateGrid(const RefPtr<GridID>&gname, Grid&G, double t);

        virtual bool CreateField(const RefPtr<GridID>&gname, Grid&G, double t, const string&fieldname);
};

class   BUNDLE_API Bundle : public GridList, public Intercube, public Attributes
{
        ParameterList   AvailableParameters;
        RefPtr<GlobalCharts>    Atlas;

//public:
        typedef RefPtr<Slice>                   P0D_t;
        typedef map<double, RefPtr<Slice> >             P1D_t;
        typedef map<double, map<double,RefPtr<Slice> > >        P2D_t;

        P0D_t   P0D;
        P1D_t   P1D;
        P2D_t   P2D;

//      map<ParameterSet, ParameterSpace>       ParameterSpaces;

public:
        typedef MemCore::LoaderRegistry<Bundle> Loader;

static  RefPtr<Bundle> load(bool&success, const RefPtr<LoaderParameters>&ld, const RefPtr<Bundle>&B = NullPtr() );

static  RefPtr<Bundle> load(bool&success, const string&url, 
                            const RefPtr<Bundle>&B = NullPtr(),
                            const RefPtr<LoaderProgress>&Progress = NullPtr(),
                            bool detect_sequence = false)
        {
        RefPtr<LoaderParameters> LP = new LoaderParameters( url, detect_sequence ); 
                if (Progress)
                        LP->setProgressCallbacks( Progress ); 

                return load(success, LP, B);
        }


//static        bool loadable(const string&URL);

        bool merge(const RefPtr<LoaderParameters>&LP);

        Bundle();

        void DeferredConstructor();

        ~Bundle();

        using GridList::operator ();
        using GridList::operator []; 
        using GridList::getGridnames;


        double minTime() const;

        double maxTime() const; 

        typedef Info<Slice> SliceInfo_t; 

        typedef Info<Grid> GridInfo_t; 

        typedef Info<Skeleton> SkeletonInfo_t;

        SliceInfo_t firstSlice() const;

        bool    accessFirstSlice() const
        {
        SliceInfo_t SI = firstSlice(); 
                if (SI.second)
                        return SI.second->accessSlice();

                return false;   
        }

        Slice&operator[](double time);

        Slice&operator[](const ParameterSet&);

        SlicePtr operator()(double&time) const;

        SlicePtr findPrev(double&time) const;
        SlicePtr findNext(double&time) const; 

        SliceInfo_t prev(double time) const
        {
        SliceInfo_t retval; 
                retval.first = time; 
                retval.second = findPrev(retval.first); 
                return retval;
        }

        SliceInfo_t next(double time) const
        {
        SliceInfo_t retval; 
                retval.first = time; 
                retval.second = findNext(retval.first); 
                return retval;
        }

        RefPtr<Grid> operator()(double time, const string&gridname) const
        {
        RefPtr<Slice> S = (*this)(time);
                if (S) 
                        return (*S)(gridname);
                return NullPtr();
        } 

        RefPtr<Grid> newGrid() const
        {
                return new Grid( self(), Atlas);
        }

        GridInfo_t findMostRecentGrid(double time, const string&gridname) const;

        GridInfo_t findMostRecentGrid(double time, const RefPtr<GridID>&gridid) const;

        Info<Grid> findPrev(double time, const string&gridname) const; 
        Info<Grid> findPrev(double time, const RefPtr<GridID>&gridname) const;

        Info<Grid> findNext(double time, const string&gridname) const; 
        Info<Grid> findNext(double time, const RefPtr<GridID>&gridname) const;

        int     iterateBackward(double&time, const string&gridname, EvolutionIterator<Grid>&GEI, bool IterateOnlyLoadedSlices) const;

        int     iterateForward (double&time, const string&gridname, 
                                EvolutionIterator<Grid>&GEI, 
                                bool IterateOnlyLoadedSlices) const;

        SkeletonInfo_t findPreviousRefinementLevel(double&T, const string&gridname, int Level,
                                                   EvolutionIterator<Skeleton>*EIS, int IndexDepth);

        SkeletonInfo_t findPreviousRefinementLevel(double&T, const string&gridname, int Level, int IndexDepth = 0)
        {
                return findPreviousRefinementLevel(T,gridname,Level,0,IndexDepth);
        } 

        SkeletonInfo_t findPreviousRefinementLevel(double&T, const string&gridname, int Level,
                                                   EvolutionIterator<Skeleton>&EIS, int IndexDepth=0)
        {
                return findPreviousRefinementLevel(T,gridname,Level,&EIS,IndexDepth);
        }

private:
        SkeletonInfo_t  findNextRefinementLevel(P1D_t::const_iterator&it, const string&gridname, int Level, int IndexDepth);

public:
        SkeletonInfo_t  findNextRefinementLevel(double&T, const string&gridname, int Level, int IndexDepth = 0);


        RefPtr<Grid> operator()(double time, const RefPtr<GridID>&gridname) const
        {
        RefPtr<Slice> S = (*this)(time);
                if (S) 
                        return (*S)(gridname);
                return NullPtr();
        }


        RefPtr<Slice> operator()(const ParameterSet&) const;

        int sizeP1D() const
        {
                return P1D.size();
        }

        const ParameterList&AllParameters() const
        {
                return  AvailableParameters;
        }

        int iterate(const ParameterList&PL, EvolutionIterator<Slice>&SI) const; 

        typedef std::pair<double,double> Range_t; 

        Range_t getTimeRange(const string&Gridname, bool OnlyInspectAlreadyLoadedSlices=false);

        int     getMemoryUsage(memsize_t&UsedMemory, memsize_t&WantedMemory) const;
};

class   BUNDLE_API BundlePtr : public RefPtr<Bundle>
{
public:
        using RefPtr<Bundle>::operator void*;
        using RefPtr<Bundle>::operator !;

        BundlePtr();

        BundlePtr(const RefPtr<Bundle>&);

        BundlePtr(Bundle*);

        ~BundlePtr();

        Bundle& operator*();

        Slice&operator[](double time)
        {
        Bundle&B = (**this);
                return B[time];
        } 

        SlicePtr operator()(double&time)
        {
                if (!*this) return NullPtr(); 
                return (**this)(time);
        }

        int     save(const string&url);

        int     saveGrids(const string&url, const RefPtr<MemCore::StringList>&SaveableGridNames);
};

} /* namespace Fiber */ 

#endif /* __FIBER_BUNDLE_HPP */