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 ReferenceBase<Slice>
{
        typedef map<RefPtr<GridID>, RefPtr<Grid> > grids_t;
        grids_t grids;

        // Reference to something that contains grid, which 
        // is basically the entire bundle
        WeakPtr<GridList>       IDList;
        RefPtr<GlobalCharts>    Atlas;

public:

        class   BUNDLE_API Loader : public ReferenceBase<Loader>
        {
        public:
                Loader()
                : ReferenceBase<Loader>(this)
                {}

                ~Loader();

                virtual bool load(const WeakPtr<Slice>&Self) = 0;
        };

        RefPtr<Loader>  DeferredLoader; 

        bool    accessSlice()
        {
                if (DeferredLoader)
                {
                RefPtr<Loader>  DL = DeferredLoader; 
                        DeferredLoader = NullPtr();
                        DL->load( self() );
                }

                return true;    
        }

        bool    isNotYetLoaded() const
        {
                return DeferredLoader;
        }

        bool    isLoaded() const
        {
                return !isNotYetLoaded();
        }

        Slice(const WeakPtr<GridList>&IDList, const RefPtr<GlobalCharts>&Atlas);

        ~Slice(); 

        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); 

        RefPtr<Grid> operator()(const RefPtr<GridID>&gridname); 

        int iterate(GridIterator&GI, 
                    const RefPtr<MemCore::StringList>&TheseGridsOnly = NullPtr() ); 


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


class   BUNDLE_API SliceList
{
        typedef set<WeakPtr<Slice> >    Slices_t;
        Slices_t        Slices;
public: 

        SliceList();

        ~SliceList();

        struct  BUNDLE_API iterator
        {
                virtual ~iterator();

                virtual bool apply(const WeakPtr<Slice>&S) = 0;
        };

static  void addSlice(const WeakPtr<Slice>&S, const RefPtr<GridID>&G); 

        int     iterate(iterator&it); 

static  int     iterate(const RefPtr<GridID>&G, iterator&it);

};

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 */