FragmentIDContainer.hpp

#ifndef __FIBER_FIELD_FRAGMENTIDCONTAINER_HPP
#define __FIBER_FIELD_FRAGMENTIDCONTAINER_HPP
 
#include "FragmentID.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;
 
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;
class [[deprecated("Use FragmentIDCollection instead")]]
FragmentIDContainer;
 
 
 
class   FragmentIDContainer
{
        typedef std::set<RefPtr<FragmentID>, CompareFragmentIDs> FragmentIDset_t;
 
        FragmentIDset_t FragmentIDset;
 
public:
        FragmentIDContainer();
 
        FragmentIDContainer(const FragmentIDContainer&);
 
        FragmentIDContainer&operator=(const FragmentIDContainer&);
 
        ~FragmentIDContainer();
 
        size_t  nFragments() const;
 
        RefPtr<FragmentID>      getFirst() const;
 
        void    insert(const RefPtr<FragmentID>&Fid)
        {
                FragmentIDset.insert( Fid );
        }
 
//      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;
};
 
 
 
template<>
inline  std::string     element_to_string(const FragmentIDContainer&fID)
{
        return "[{???}]";
}
 
 
} /* namespace Fiber */
 
#endif /* __FIBER_FIELD__FRAGMENTID_HPP */