GridID.hpp

#ifndef __FIBER_GRIDID_HPP
#define __FIBER_GRIDID_HPP "Created 27.02.2001 21:42:27 by werner"
 
#include "BundleAPI.h"
#include <fiber/grid/Grid.hpp>
#include <memcore/Persistencer.hpp>
#include <list>
#include <fiber/grid/FieldID.hpp>
#include <fiber/grid/SkeletonID.hpp>
#include "SliceInfo.hpp"
 
 
namespace Fiber
{
        using std::list;
        using std::string;
        using MemCore::SaveRegistry;
 
class   BUNDLE_API GridList;
class   BUNDLE_API SliceMap;
class   BUNDLE_API Slice;
 
class   BUNDLE_API GridID : public ReferenceBase<GridID>, public Intercube
{
        string  name;
        SliceMap*SL;
 
        GridID(const string&s);
 
        GridID(const GridID&);
        void operator=(const GridID&);
 
        WeakPtr<GridID>                 ParentGrid;
 
        typedef set<WeakPtr<GridID> >   ChildGrids_t;
        ChildGrids_t                    ChildGrids;
 
public:
        friend class GridList;
        friend class SliceList;
 
        typedef std::set< Info<Slice> > SliceList_t;
 
        typedef std::map<SkeletonID, SliceList_t>       IndexDepthSkeletons_t;
 
        typedef std::map<int, IndexDepthSkeletons_t>    SkeletonsOnGrid_t;
 
        SkeletonsOnGrid_t SkeletonsOnGrid;
 
        typedef std::set< WeakPtr<FieldID> > FieldList_t;
 
        FieldList_t     FieldList;
 
        ~GridID();
 
        void    insert(double T, const WeakPtrSlice&S);
 
 
        WeakPtrSlice    prev(double&T) const;
        WeakPtrSlice    next(double&T) const;
 
 
        bool insertChild(const WeakPtr<GridID>&ChildGrid);
 
        bool isParentOf(const WeakPtr<GridID>&PossibleChildGrid);
 
        bool isChildOf(const WeakPtr<GridID>&PossibleParentGrid);
 
        const WeakPtr<GridID>&getParent() const
        {
                return ParentGrid;
        }
 
        struct  BUNDLE_API Iterator
        {
                virtual bool apply(const WeakPtr<GridID>&ChildGrid) = 0;
 
                virtual ~Iterator();
        };
 
        int iterate(Iterator&It) const;
 
        const string&Name() const
        {
                return name;
        }
 
        void setName(const string&NewName)
        {
                name = NewName;
        }
 
        bool equal(const string&s);
};
 
} /* namespace Fiber */
 
#endif /* __FIBER_GRIDID_HPP */