Bundle.hpp

#ifndef __FIBER_BUNDLE_HPP
#define __FIBER_BUNDLE_HPP "Created 27.02.2001 21:42:27 by werner"
 
#include "BundleAPI.h"
#include <fiber/grid/Grid.hpp>
#include <memcore/Persistencer.hpp>
#include <memcore/Loader.hpp>
#include <list>
#include "GridID.hpp"
#include "Slice.hpp"
#include "ParameterSpace.hpp"
#include "SkeletonInfo.hpp"
#include "Binder.hpp"
 
namespace MemCore
{
 
template <>
struct  BUNDLE_API DeferredInitializationTrait<Fiber::OwnerOf<Fiber::Slice>::reference_domain_t>
{
static  void call(Fiber::OwnerOf<Fiber::Slice>::reference_domain_t*);
};
 
}
 
namespace Fiber
{
        using std::list;
        using std::string;
        using MemCore::SaveRegistry;
 
#ifndef  __FIBER_BUNDLE_STORAGETRANSFORMATIONS_HPP
class   BUNDLE_API StorageTransformations;
#endif
 
using   RefPtrStorageTransformations = RefPtr<StorageTransformations,
                                              MemCore::InterfaceBase>;
 
template <class ObjectLevel>
        class BUNDLE_API EvolutionIterator;
 
struct  BUNDLE_API GridSaveParameters : MemCore::SaveParameters
{
        RefPtr<MemCore::StringList>     SaveableGridNames;
 
        GridSaveParameters(const string&theUrl,
                           const RefPtr<MemCore::StringList>&GridNames)
        : MemCore::SaveParameters(theUrl)
        , SaveableGridNames(GridNames)
        {}
};
 
 
template <>
class   BUNDLE_API EvolutionIterator<Slice>
{
public:
        virtual ~EvolutionIterator();
 
        virtual bool apply(ParameterSet&P, Slice&S) = 0;
};
 
template <>
class   BUNDLE_API EvolutionIterator<Grid>
{
public:
        virtual ~EvolutionIterator();
 
        virtual bool apply(double t, GridID&id, Grid&g) = 0;
 
        using   functor = std::function<bool(double t, GridID&id, Grid&g)>;
};
 
template <>
class   BUNDLE_API EvolutionIterator<Skeleton>
{
public:
        virtual ~EvolutionIterator();
 
        virtual bool apply(double t, const RefPtr<Skeleton>&S) = 0;
};
 
template <>
class   BUNDLE_API EvolutionIterator<Field>
{
public:
        ~EvolutionIterator();
};
 
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 OwnerOf<Slice>
                          , public Intercube
                          , public Attributes
                          , public MemCore::Ageable
{
        ParameterList   AvailableParameters;
        RefPtr<GlobalCharts>    Atlas;
 
        friend class Slice;
 
        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;
 
        RefPtr<GridList>        myGridList;
 
        bool processOwnership(MemCore::Intercube&Output,
                              const MemCore::Intercube&Input) const override;
 
        void x_updateOwnershipAge(const MemCore::Ageable&) override;
 
        RefPtr<Binder>  myBinder;
 
public:
 
        typedef MemCore::LoaderRegistry<Bundle> Loader;
 
        const RefPtr<GridList>&getGridList() const
        {
                return myGridList;
        }
 
        const set<WeakPtr<GridID> >&getGridIdentifiers() const;
 
        struct BUNDLE_API Notifier : public ReferenceBase<Notifier>
        {
                Notifier();
 
        protected:
                virtual ~Notifier();
 
        public:
                virtual void    notifyChange(const Bundle&B) = 0;
        };
 
        std::set<RefPtr<Notifier>>      myNotifiers;
 
        void    announceModification() const;
 
        void    addNotifier(const RefPtr<Notifier>&N);
 
 
        void    bind(const RefPtr<Binder>&theBinder)
        {
                myBinder = theBinder;
        }
 
 
        MemCore::SaveParameters::SaveError
                bindTo(const string&url,
                       const RefPtr<MemCore::InterfaceBase>&A = nullptr,
                       const RefPtr<MemCore::InterfaceBase>&B = nullptr);
 
        MemCore::SaveParameters::SaveError
                bindToNew(const string&url, const RefPtrStorageTransformations&ST);
 
        MemCore::SaveParameters::SaveError
                bindToNew(const string&url);
 
        const RefPtr<Binder>&getBinder() const
        {
                return myBinder;
        }
 
        bool    isBound() const
        {
                return getBinder().valid();
        }
 
        std::string     boundUrl() const
        {
                if (myBinder)
                        return myBinder->getUrl();
 
                return std::string();
        }
 
 
        bool    sync(const RefPtr<MemCore::LoaderProgress>&SaveProgress = nullptr ) const;
 
static  RefPtr<Bundle> load(bool&success, const RefPtr<LoaderParameters>&ld, const RefPtr<Bundle>&B = nullptr );
 
static  RefPtr<Bundle> load(bool&success, const list<string>&urls,
                            const RefPtr<Bundle>&B = nullptr,
                            const RefPtr<LoaderProgress>&Progress = nullptr)
        {
        RefPtr<LoaderParameters> LP = new LoaderParameters( urls );
                if (Progress)
                        LP->setProgressCallbacks( Progress );
 
                return load(success, LP, B);
                        LP->load_failure;
        }
 
static  std::pair<RefPtr<Bundle>, std::string>
                load( const list<string>&urls,
                      const RefPtr<LoaderProgress>&Progress = nullptr)
        {
        RefPtr<LoaderParameters> LP = new LoaderParameters( urls );
                if (Progress)
                        LP->setProgressCallbacks( Progress );
 
        bool    success = false;
        RefPtr<Bundle>  B = load(success, LP);
                if (success)
                        return {B, {} };
                else
                        return {nullptr, LP->load_failure};
        }
 
 
static  RefPtr<Bundle> load(bool&success, const string&url,
                            const RefPtr<Bundle>&B = nullptr,
                            const RefPtr<LoaderProgress>&Progress = nullptr)
        {
                return load(success, list<string>{url}, B, Progress);
        }
 
static  RefPtr<Bundle> load(const string&url, const RefPtr<LoaderProgress>&Progress = nullptr )
        {
        bool    Success = false;
        RefPtr<Bundle> BP = load(Success, url, nullptr, Progress);
                if (Success)
                        return BP;
                return nullptr;
        }
 
 
        bool    merge(const RefPtr<LoaderParameters>&LP);
 
        bool    merge(const string&url);
 
        bool    merge(const list<string>&urls);
 
 
        Bundle();
 
        void    DeferredConstructor();
 
        ~Bundle();
 
        int     save(const string&url,
                     const RefPtr<LoaderProgress>&SaveProgress = nullptr,
                     const RefPtrStorageTransformations&ST = nullptr);
 
        RefPtr<GridID> operator()(const string&gridname) const
        {
                if (myGridList)
                        return (*myGridList)(gridname);
 
                return nullptr;
        }
 
        RefPtr<GridID> operator[](const string&gridname) const
        {
                if (myGridList)
                        return (*myGridList)[gridname];
 
                return nullptr;
        }
 
        int     getGridnames(GridList::stringset_t&Gridnames) const
        {
                if (myGridList)
                        return myGridList->getGridnames(Gridnames);
 
                return 0;
        }
 
        size_t  getNumberOfGrids() const
        {
                if (myGridList)
                        return myGridList->getNumberOfGrids();
 
                return 0;
        }
 
        const RefPtr<GlobalCharts>&getAtlas() const
        {
                return Atlas;
        }
 
        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> operator()(double time, const RefPtr<GridID>&GridID) const
        {
        RefPtr<Slice> S = (*this)(time);
                if (S)
                        return (*S)(GridID);
                return nullptr;
        }
 
        Slice::grids_t::value_type getUniqueGrid(double time);
        RefPtr<Grid> newGrid() const
        {
                return new Grid( getGridList(), Atlas);
        }
 
        Info<Grid>      findFirst(const string&gridname, bool OnlyInspectLoadedSlices = false) const;
 
        Info<Grid>      findLast(const string&gridname, bool OnlyInspectLoadedSlices = false) const;
 
        int     NumberOfGrids(const string&gridname, bool OnlyInspectLoadedSlices) const;
 
        int     NumberOfGrids( double T0, double T1, const string&gridname, bool OnlyInspectLoadedSlices ) const;
 
 
        int     NumberOfGridInstances( double T0, double T1, const string&gridname, bool OnlyInspectLoadedSlices ) const
        {
                return NumberOfGrids( T0, T1, gridname, OnlyInspectLoadedSlices );
        }
 
        int     getNrSlicesOfGridInTimeRange( double time_min, double time_max, const string& grid_name, bool loaded_slices_only ) const;
 
        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;
 
 
        GridInfo_t      findPreviousGrid(double time, const string&gridname) const;
        GridInfo_t      findPreviousGrid(double time, const RefPtr<GridID>&GID) 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<Slice> operator()(const ParameterSet&) const;
 
        int sizeP1D() const
        {
                return int( P1D.size() );
        }
 
 
        const ParameterList&AllParameters() const
        {
                return  AvailableParameters;
        }
 
        int     iterate(const ParameterList&PL, EvolutionIterator<Slice>&SI) const;
 
 
        int     iterate(const string&gridname, EvolutionIterator<Grid>&GEI, bool IterateOnlyLoadedSlices) const;
 
        int     iterate(const string&gridname, const EvolutionIterator<Grid>::functor&GEI, bool IterateOnlyLoadedSlices) const;
 
        using   grid_iterator = std::function<bool(double t, const GridID&id, Grid&g)>;
 
        int     iterate(const RefPtr<GridID>&id, const grid_iterator&gi, bool IterateOnlyLoadedSlices=false) const;
 
 
        template <class Functor>
                int     iterate_timeslices(bool DoLoadAllSlices, const Functor&F) const
        {
        int     N = 0;
                for(const auto&P1 : P1D)
                {
                        if (!P1.second) continue;
                        if (DoLoadAllSlices)
                                P1.second->accessSlice();
 
                        if (F(P1.first, *P1.second))
                                N++;
                        else
                                return N;
                }
                return N;
        }
 
        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;
 
        string  xml() const;
 
        void    extremeUnction() override;
};
 
 
 
class   BUNDLE_API BundlePtr : public RefPtr<Bundle>
{
public:
        using   RefPtr<Bundle>::operator void*;
        using   RefPtr<Bundle>::operator !;
 
        BundlePtr();
 
        BundlePtr(const BundlePtr&) = default;
 
        BundlePtr(const RefPtr<Bundle>&);
 
        BundlePtr(Bundle*);
 
        ~BundlePtr();
 
        BundlePtr&operator=(const BundlePtr&) = default;
 
        Bundle&create();
 
        Bundle& operator*()
        {
                return create();
        }
 
        Bundle& operator*() const
        {
                return RefPtr<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,
                     const RefPtr<LoaderProgress>&SaveProgress = nullptr,
                     const RefPtrStorageTransformations&ST = nullptr);
 
        int     saveGrids(const string&url, const RefPtr<MemCore::StringList>&SaveableGridNames,
                          const RefPtr<LoaderProgress>&SaveProgress = nullptr,
                          const RefPtrStorageTransformations&ST = nullptr );
 
        bool    load(const string&url, const RefPtr<LoaderProgress>&Progress = nullptr );
        bool    load(const list<string>&urls, const RefPtr<LoaderProgress>&Progress = nullptr );
};
 
 
template <>
class   Iterator<Slice> : public EvolutionIterator<Slice>
{
};
 
 
} /* namespace Fiber */
 
#endif /* __FIBER_BUNDLE_HPP */