Slice.hpp

#ifndef __SLICE_HPP
#define __SLICE_HPP  "Created 25.08.2004"
 
#include "GridID.hpp"
#include "GridList.hpp"
#include <memcore/stringlist.hpp>
 
namespace Fiber
{
 
class   BUNDLE_API GridIterator
{
public:
        virtual ~GridIterator();
 
 
        virtual bool apply(GridID&id, Grid&g) = 0;
};
 
class   BUNDLE_API Slice : public OwnerOf<Grid>
                         , public Ownable<Slice>
                         , public Intercube
                         , public SaveableAttributes
{
public:
        typedef map<RefPtr<GridID>, RefPtr<Grid> > grids_t;
 
private:
        grids_t grids;
 
        RefPtr<GlobalCharts>    Atlas;
 
public:
        auto    getNumberOfGrids() const noexcept
        {
                return grids.size();
        }
 
 
        enum LoaderPriority {HDF5, COMPUTED_GRID};
 
 
        class   BUNDLE_API Loader : public ReferenceBase<Loader>
        {
        public:
                Loader()
                : ReferenceBase<Loader>(this)
                {}
 
                ~Loader();
 
                virtual bool load(const WeakPtr<Slice>&Self) = 0;
        };
 
 
        typedef std::multimap<LoaderPriority, RefPtr<Loader> > DeferredLoader_t;
 
        mutable DeferredLoader_t DeferredLoader;
 
        // Reference to something that contains grid, which
        // is basically the entire bundle
        RefPtr<GridList>        getIDList() const;
 
        bool    accessSlice() const;
 
        bool    isNotYetLoaded() const
        {
                return DeferredLoader.size() > 0;
        }
 
        bool    isLoaded() const
        {
                return !isNotYetLoaded();
        }
 
        Slice(const OwnerOf<Slice>&SliceOwner, const RefPtr<GlobalCharts>&Atlas);
 
        ~Slice();
 
        void    extremeUnction() override;
 
        Grid&newGrid(const string&gridname);
 
        Grid&newGrid(const string&gridname, const string&ParentGridName);
 
        bool    insert(const string&gridname, const RefPtr<Grid>&G);
 
        Grid&operator[](const string&gridname);
 
        Grid&operator[](const RefPtr<GridID>&gridname);
 
        RefPtr<GridID> makeGridID(const string&gridname);
 
        RefPtr<GridID> findGridID(const string&gridname);
 
        RefPtr<Grid> operator()(const string&gridname);
 
        grids_t::value_type getUniqueGrid();
 
        RefPtr<Grid> operator()(const RefPtr<GridID>&gridname);
 
        int iterate(GridIterator&GI,
                    const RefPtr<MemCore::StringList>&TheseGridsOnly = NullPtr() );
 
        typedef GridIterator Iterator;
 
        template <class Functor>
        int     iterate_grids(const Functor&F) const
        {
        int     N = 0;
                this->accessSlice();
                for(const auto&g : grids)
                {
                        if (!g.first) continue;
                        if (!g.second) continue;
 
                        if (F(*g.first, *g.second))
                                N++;
                        else
                                return N;
                }
                return N;
        }
 
        int     getMemoryUsage(memsize_t&UsedMemory, memsize_t&WantedMemory) const;
 
        string  xml() const;
};
 
template <>
class   Iterator<Grid> : public Slice::Iterator
{
};
 
 
class   BUNDLE_API SlicePtr : public RefPtr<Slice>
{
public:
        SlicePtr(const RefPtr<Slice>&RS)
        : RefPtr<Slice>(RS)
        {}
 
        SlicePtr(const MemCore::NullPtr&)
        : RefPtr<Slice>(MemCore::NullPtr() )
        {}
 
        RefPtr<Grid> operator()(const string&gridname) const
        {
                if (!*this) return NullPtr();
                return (**this)(gridname);
        }
 
        RefPtr<Grid> operator()(const RefPtr<GridID>&gridname) const
        {
                if (!*this) return NullPtr();
                return (**this)(gridname);
        }
};
 
 
} /* namespace Fiber */
 
#endif /* __SLICE_HPP */