Fragment.hpp

#ifndef __FIBER_GRID_FRAGMENT_HPP
#define __FIBER_GRID_FRAGMENT_HPP

#include "Field.hpp"

namespace Fiber
{

typedef std::map<string, RefPtr<CreativeArrayBase> > FragmentMap_t;

typedef map<string, RefPtr<Field> > FieldMap_t; 



class   FIELD_API Fragment : private FragmentMap_t
{
        typedef FragmentMap_t   map_t;

public: 
        Fragment();

        ~Fragment();

        RefPtr<CreativeArrayBase>&operator[](const string&s);
        RefPtr<CreativeArrayBase> operator()(const string&s) const; 

        struct  FIELD_API Iterator
        {
                virtual ~Iterator();

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

        size_t size() const
        {
                return FragmentMap_t::size();
        } 

        int iterate(Iterator&It) const;
};

class   FIELD_API FieldCollection : private FieldMap_t
{
public:
        FieldCollection();
        ~FieldCollection();

        RefPtr<Field>&operator[](const string&s);
        RefPtr<Field> operator()(const string&s) const; 

        bool    FieldsAreOlderThan(const MemCore::Ageable&A) const; 

        void    updateAge(MemCore::Ageable&A) const;

        struct  FIELD_API Iterator
        {
                virtual ~Iterator();
                virtual bool apply(const string&name, const RefPtr<Field>&F) = 0;
        }; 

        int iterate(Iterator&It);
};



class    FIELD_API FragmentCluster : public FragmentIterator
{
        // This SHOULD be using fragmentID's, but this is somewhat more fragile,
        // so we don't do this here, and use strings.
        //typedef map<RefPtr<FragmentID>, Fragment>      fragmentsarray_t; 

        typedef map<string, Fragment>      fragmentsarray_t;

        typedef map<int, fragmentsarray_t> fragmentcluster_t; 

        fragmentcluster_t                  fragmentcluster; 

        int             refinement_level;
        string          datafield_name;
        override bool apply(const RefPtr<FragmentID>&f, const RefPtr<CreativeArrayBase>&F); 

        int     addField(const RefPtr<Field>&F, int RLevel, const string&internal_name);

public: 
        FragmentCluster(); 

        ~FragmentCluster();

        void    clear();

        int     addFields(FieldCollection&Fields, int RLevel);

        struct   FIELD_API  Iterator
        {
                virtual ~Iterator() = 0;

                virtual bool beginLevel(int RefinementLevel);

                virtual bool apply(int RefinementLevel, 
                                   const string&fragment_identifier,
//                                 const RefPtr<FragmentID>&fragment_identifier,
                                   const Fragment&FragmentData);

                virtual bool endLevel(int RefinementLevel);
        }; 

        int     iterate(Iterator&RFI,
                        const RefPtr<FragmentSelector>&FS, 
                        const string&SelectionField = "Positions") const;
};


} /* namespace Fiber */ 

#endif /* __FIBER_GRID_FRAGMENT_HPP */