FragmentID.hpp

#ifndef __FIBER_FIELD_FRAGMENTID_HPP
#define __FIBER_FIELD_FRAGMENTID_HPP

#include "FieldAPI.h"
#include <memcore/Interface.hpp>
#include <string>
#include "CreativeArray.hpp"
#include "FragmentSelector.hpp"

namespace Fiber
{
        using MemCore::ReferenceBase;
        using MemCore::Intercube;
        using MemCore::Interface;
        using MemCore::interface_cast;
        using MemCore::StrongPtr;
        using MemCore::NullPtr;
        using std::string;
        using std::map;


class   FIELD_API FragmentIDContainer;


class   FIELD_API FragmentID : public ReferenceBase<FragmentID>, public Intercube
{

        string  name;

public:

        FragmentID(const string&Name);

        ~FragmentID();

        const string&Name() const
        {
                return name;
        } 

        typedef FragmentIDContainer Container;

};

template <int Dims>
class FragmentLocation : public Interface<FragmentLocation<Dims> >
{
public:
        MultiIndex<Dims> Offset,
                         OverlapStart,
                         OverlapEnd;
};

class   FIELD_API FragmentIterator
{
public:
        virtual ~FragmentIterator();

        virtual bool apply(const RefPtr<FragmentID>&, const RefPtr<CreativeArrayBase>&) = 0;
};

typedef FragmentIterator FieldFragmentIterator;

struct  CompareFragmentIDs
{
        bool operator()(const RefPtr<FragmentID>&A, const RefPtr<FragmentID>&B) const
        {
                if (A == B) return false;
                if (!A) return false;
                if (!B) return true;

                return A->Name() < B->Name();
        }
};


class   FIELD_API FragmentIDContainer
{
        typedef std::set<RefPtr<FragmentID>, CompareFragmentIDs> FragmentIDset_t; 

        FragmentIDset_t FragmentIDset;

public: 
        FragmentIDContainer();

        FragmentIDContainer(const FragmentIDContainer&);

        FragmentIDContainer&operator=(const FragmentIDContainer&);

        ~FragmentIDContainer(); 

        RefPtr<FragmentID>      findFragmentID(const string&name) const;

        RefPtr<FragmentID>      createFragmentID(const string&name); 

        bool                    removeFragmentID(const string&name);

        struct  Iterator
        {
                virtual ~Iterator();

                virtual bool apply(const RefPtr<FragmentID>&) = 0;
        }; 

        int iterate(Iterator&) const;
};


} /* namespace Fiber */ 

#endif /* __FIBER_FIELD__FRAGMENTID_HPP */