FragmentID.hpp

#ifndef __FIBER_FIELD_FRAGMENTID_HPP
#define __FIBER_FIELD_FRAGMENTID_HPP
 
#include "FieldAPI.h"
#include <memcore/Interface.hpp>
#include <string>
#include "CreativeArray.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 FragmentIDCollection;
 
typedef WeakPtr<FragmentIDCollection, FragmentIDCollection> FragmentIDCollectionWeakPtr;
 
using   FragmentIndex_t = unsigned;
 
 
class   FIELD_API FragmentID : public ReferenceBase<FragmentID>, public Intercube
{
        string  name;
 
        FragmentIDCollectionWeakPtr myFragmentIDCollection;
        FragmentIndex_t             ID;
 
        friend class FragmentIDCollection;
 
protected:
        ~FragmentID();
 
public:
 
        explicit FragmentID(const string&Name);
 
        FragmentID(const string&Name,
                   FragmentIndex_t ID,
                   const FragmentIDCollectionWeakPtr&theFragmentIDCollection);
 
        const string&Name() const
        {
                return name;
        }
 
static  string  Name(const RefPtr<FragmentID>&fid, const string&UnfragmentedName = "")
        {
                if (fid)
                        return fid->Name();
 
                return UnfragmentedName;
        }
 
static  string  getName(const RefPtr<FragmentID>&fid, const string&UnfragmentedName = "")
        {
                return Name(fid, UnfragmentedName);
        }
 
        FragmentIndex_t getNumericalID() const
        {
                return ID;
        }
 
        const FragmentIDCollectionWeakPtr&getFragmentIDCollection() const
        {
                return myFragmentIDCollection;
        }
 
        string  xml() const;
};
 
 
struct  CompareFragmentIDsNumerically
{
        bool operator()(const WeakPtr<FragmentID>&A, const WeakPtr<FragmentID>&B) const
        {
                if (A == B) return false;
                if (!A) return false;
                if (!B) return true;
 
                return A->getNumericalID() < B->getNumericalID();
        }
};
 
enum class FragmentProperty
{
        Undefined    = 0,
        Offset       = 1,
        OverlapStart = 2,
        OverlapEnd   = 3
};
 
template <Dims_t Dims, FragmentProperty TheProperty>
class FragmentLocation : public Interface<FragmentLocation<Dims, TheProperty> >
                       , public MultiIndex<Dims>
{
protected:
        ~FragmentLocation()
        {}
 
public:
 
static  MultiIndex<Dims>&make(FragmentID&FID)
        {
                if (RefPtr<FragmentLocation> FL = interface_cast<FragmentLocation>(FID) )
                        return *FL;
 
        RefPtr<FragmentLocation> FL = new FragmentLocation();
                FID.addInterface( FL );
                return *FL;
        }
 
static  RefPtr<FragmentLocation> get(FragmentID&FID)
        {
                return interface_cast<FragmentLocation>(FID);
        }
 
static  bool    get(FragmentID&FID, MultiIndex<Dims>&Value)
        {
                if (RefPtr<FragmentLocation> FL = interface_cast<FragmentLocation>(FID) )
                {
                        Value = *FL;
                        return true;
                }
                return false;
        }
 
static  void    set(FragmentID&FID, MultiIndex<Dims>&Value)
        {
                make(FID) = Value;
        }
};
 
template <Dims_t Dims>
inline void     setFragmentOverlap(FragmentID&FID,
                                   const MultiIndex<Dims>&OverlapStart,
                                   const MultiIndex<Dims>&OverlapEnd)
{
        FragmentLocation<Dims, FragmentProperty::OverlapStart>::make(FID) = OverlapStart;
        FragmentLocation<Dims, FragmentProperty::OverlapEnd  >::make(FID) = OverlapEnd  ;
}
 
template <Dims_t Dims>
inline void     setFragmentOverlapStart(FragmentID&FID,
                                        const MultiIndex<Dims>&OverlapStart)
{
        FragmentLocation<Dims, FragmentProperty::OverlapStart>::make(FID) = OverlapStart;
}
 
template <Dims_t Dims>
inline void     setFragmentOverlapEnd(FragmentID&FID,
                                      const MultiIndex<Dims>&OverlapEnd)
{
        FragmentLocation<Dims, FragmentProperty::OverlapEnd>::make(FID) = OverlapEnd;
}
 
template <Dims_t Dims>
inline MultiIndex<Dims>&setFragmentOffset(FragmentID&FID, const MultiIndex<Dims>&Offset)
{
        return
        FragmentLocation<Dims, FragmentProperty::Offset>::make(FID) = Offset;
}
 
template <Dims_t Dims>
inline bool getFragmentOffset(FragmentID&FID, MultiIndex<Dims>&Offset)
{
        return FragmentLocation<Dims, FragmentProperty::Offset>::get(FID, Offset);
}
 
template <Dims_t Dims>
inline bool getFragmentOverlapStart(FragmentID&FID, MultiIndex<Dims>&Value)
{
        return FragmentLocation<Dims, FragmentProperty::OverlapStart>::get(FID, Value);
}
 
template <Dims_t Dims>
inline bool getFragmentOverlapEnd(FragmentID&FID, MultiIndex<Dims>&Value)
{
        return FragmentLocation<Dims, FragmentProperty::OverlapEnd>::get(FID, Value);
}
 
 
class   FIELD_API FragmentIterator
{
public:
        virtual ~FragmentIterator();
 
        virtual bool apply(const RefPtr<FragmentID>&, const RefPtr<CreativeArrayBase>&) = 0;
};
 
template <class T>
struct  FragmentFunctor : FragmentIterator
{
        T       myFunctor;
 
        FragmentFunctor(const T&theFunctor)
        : myFunctor(theFunctor)
        {}
 
        bool    apply(const RefPtr<FragmentID>&Fid, const RefPtr<CreativeArrayBase>&CAB)
        {
                return myFunctor(Fid, CAB);
        }
};
 
typedef FragmentIterator FieldFragmentIterator;
 
 
 
template<>
inline  std::string     element_to_string(const RefPtr<FragmentID>&fID)
{
        return "[\"" + FragmentID::Name(fID) + "\"]";
}
 
template<>
inline  std::string     element_to_string(const std::vector<RefPtr<FragmentID>>&fIDs)
{
std::string     retval = "{(" + std::to_string(fIDs.size()) + ") ";
 
        if (fIDs.size()>0)
                retval += element_to_string(fIDs[0]);
 
        for(size_t i = 1; i<fIDs.size(); i++)
        {
                retval += ", " + element_to_string(fIDs[i]);
        }
 
        return retval + " }";
}
 
/*
template<>
inline  std::string     element_to_string(const std::vector<RefPtr<FragmentID>>&FIDs)
{
string  retval = "{(" + std::to_string(FIDs.size()) + ") ";
 
        if (FIDs.size()>0)
                retval += "\"" + FragmentID::Name(FIDs[0]) + "\"";
 
        for(size_t i = 1; i<FIDs.size(); i++)
        {
                retval += ", \"" + FragmentID::Name(FIDs[i]) + "\"";
        }
 
        return retval + " }";
}
*/
 
 
} /* namespace Fiber */
 
#endif /* __FIBER_FIELD__FRAGMENTID_HPP */