Occurence.hpp

#ifndef __FIBER__BUNDLE_OCCURENCE_HPP
#define __FIBER__BUNDLE_OCCURENCE_HPP

#include "Bundle.hpp"

namespace Fiber
{

template <class T> struct Occurence;


template <> struct BUNDLE_API Occurence<Slice>
{
        double          time;

        Occurence(double t=0)
        : time(t)
        {}

        ~Occurence();
};

template <> struct BUNDLE_API Occurence<Grid> : public Occurence<Slice>
{
        RefPtr<GridID>  TheGrid;

        Occurence(const Occurence<Slice>&OS, const RefPtr<GridID>&Gid)
        : Occurence<Slice>(OS)
        , TheGrid(Gid)
        {}

        Occurence()
        {}

        ~Occurence();
};

template <> struct BUNDLE_API Occurence<Skeleton> : public Occurence<Grid>
{
        SkeletonID      TheSkeleton;

        Occurence(const Occurence<Grid>&OG, const SkeletonID&SID)
        : Occurence<Grid>(OG)
        , TheSkeleton(SID)
        {}

        Occurence()
        : TheSkeleton(0)
        {}

        ~Occurence();
};

template <> struct BUNDLE_API Occurence<Representation> : public Occurence<Skeleton>
{
        Representer     theRepresenter;

        Occurence(const Occurence<Skeleton>&OS, const Representer&Rep)
        : Occurence<Skeleton>(OS)
        , theRepresenter(Rep)
        {}

        Occurence()
        {}

        ~Occurence();
};

template <> class BUNDLE_API Occurence<Bundle>
{
        struct OccurenceMap; 
        OccurenceMap*ROM;

public: 
        Occurence(const BundlePtr&, const RefPtr<StringList>&DoTheseGridsOnly = NullPtr() );    

        Occurence(const Bundle&, const RefPtr<StringList>&DoTheseGridsOnly = NullPtr() );

        ~Occurence();

        const Occurence<Representation>*operator()(const Representer&Rep) const;

        const Occurence<Skeleton>*operator()(const WeakPtr<Skeleton>&Rep) const;
};


} // namespace Fiber

#endif // __FIBER__BUNDLE_OCCURENCE_HPP