Occurrence.hpp

#ifndef __FIBER__BUNDLE_OCCURRENCE_HPP
#define __FIBER__BUNDLE_OCCURRENCE_HPP
 
#include "Bundle.hpp"
 
namespace Fiber
{
 
template <class T> class Occurrence;
 
 
template <> class BUNDLE_API Occurrence<Slice>
{
public:
        double          time;
 
        Occurrence(double t=0)
        : time(t)
        {}
 
        ~Occurrence();
};
 
template <> class BUNDLE_API Occurrence<Grid> : public Occurrence<Slice>
{
public:
        WeakPtr<GridID> TheGrid;
 
        Occurrence(const Occurrence<Slice>&OS, const WeakPtr<GridID>&Gid)
        : Occurrence<Slice>(OS)
        , TheGrid(Gid)
        {}
 
        Occurrence()
        {}
 
        ~Occurrence();
};
 
template <> class BUNDLE_API Occurrence<Skeleton> : public Occurrence<Grid>
{
public:
        SkeletonID      TheSkeleton;
 
        Occurrence(const Occurrence<Grid>&OG, const SkeletonID&SID)
        : Occurrence<Grid>(OG)
        , TheSkeleton(SID)
        {}
 
        Occurrence()
        : TheSkeleton(0)
        {}
 
        ~Occurrence();
};
 
template <> class BUNDLE_API Occurrence<Representation> : public Occurrence<Skeleton>
{
public:
        Representer     theRepresenter;
 
        Occurrence(const Occurrence<Skeleton>&OS, const Representer&Rep)
        : Occurrence<Skeleton>(OS)
        , theRepresenter(Rep)
        {}
 
        Occurrence()
        {}
 
        ~Occurrence();
};
 
template <> class BUNDLE_API Occurrence<Bundle>
{
        struct OccurrenceMap;
        OccurrenceMap*ROM;
 
public:
        Occurrence(const Bundle&, const RefPtr<StringList>&DoTheseGridsOnly = NullPtr() );
 
        ~Occurrence();
 
        const Occurrence<Representation>*operator()(const Representer&Rep) const;
 
        const Occurrence<Skeleton>*operator()(const WeakPtr<Skeleton>&Rep) const;
 
 
        string RepresenterName(const Representer&) const;
};
 
 
} // namespace Fiber
 
#endif // __FIBER__BUNDLE_OCCURENCE_HPP