/Users/jab/Documents/Teaching/02585/GEL2_and_demos/GEL/src/HMesh/AttributeVector.h

/* ----------------------------------------------------------------------- *
 * This file is part of GEL, www.imm.dtu.dk/GEL
 * Copyright (C) the authors (see AUTHORS.txt) and DTU Informatics
 *
 * Principal authors:
 *  Christian Thode Larsen (thode2d@gmail.com)
 *  J. Andreas Baerentzen (jab@imm.dtu.dk)
 *
 * See LICENSE.txt for licensing information
 * ----------------------------------------------------------------------- */

#ifndef __HMESH_ATTRIBUTEVECTOR_H__
#define __HMESH_ATTRIBUTEVECTOR_H__

#include <cassert>
#include <vector>
#include <map>

namespace HMesh
{
    template<typename ITEM, typename ITEMID>
    class AttributeVector
    {
    public:
        AttributeVector(size_t _size = 0, ITEM item = ITEM());

       // ITEMID add(const ITEM& item);

        const ITEM& get(ITEMID id) const;

        ITEM& get(ITEMID id);

        const ITEM& operator [](ITEMID id) const;

        ITEM& operator [](ITEMID id);

        void resize(size_t _size, ITEM item = ITEM());

        size_t size() const;

        void clear();

        void cleanup(const std::map<ITEMID, ITEMID>& map);

    private:
        std::vector<ITEM> items;
    };

    template<typename ITEM>
    class VertexAttributeVector : public AttributeVector<ITEM, VertexID>
    {
    public:
        VertexAttributeVector(size_t _size = 0, ITEM item = ITEM());
    };

    template<typename ITEM>
    class FaceAttributeVector : public AttributeVector<ITEM, FaceID>
    {
    public:
        FaceAttributeVector(size_t _size = 0, ITEM item = ITEM());
    };

    template<typename ITEM>
    class HalfEdgeAttributeVector : public AttributeVector<ITEM, HalfEdgeID>
    {
    public:
        HalfEdgeAttributeVector(size_t _size = 0, ITEM item = ITEM());
    };

    template<typename ITEM>
    inline VertexAttributeVector<ITEM>::VertexAttributeVector(size_t _size, ITEM item) : AttributeVector<ITEM, VertexID>(_size, item){}

    template<typename ITEM>
    inline FaceAttributeVector<ITEM>::FaceAttributeVector(size_t _size, ITEM item) : AttributeVector<ITEM, FaceID>(_size, item){}

    template<typename ITEM>
    inline HalfEdgeAttributeVector<ITEM>::HalfEdgeAttributeVector(size_t _size, ITEM item) : AttributeVector<ITEM, HalfEdgeID>(_size, item){}


    template<typename ITEM, typename ITEMID>
    inline AttributeVector<ITEM, ITEMID>::AttributeVector(size_t _size, ITEM item) : items(_size, item){}

    template<typename ITEM, typename ITEMID>
    inline void AttributeVector<ITEM, ITEMID>::clear()
    { items.clear(); }

    template<typename ITEM, typename ITEMID>
    inline void AttributeVector<ITEM, ITEMID>::cleanup(const std::map<ITEMID, ITEMID>& remap)
    {
        std::vector<ITEM> new_items(remap.size());
        for(typename std::map<ITEMID, ITEMID>::const_iterator it = remap.begin(); it != remap.end(); ++it){
            assert(it->second.index < remap.size());
            new_items[it->second.index] = items[it->first.index];
        }
        std::swap(items, new_items);
    }


    template<typename ITEM, typename ITEMID>
    inline void AttributeVector<ITEM, ITEMID>::resize(size_t _size, ITEM item)
    { items.resize(_size, item); }

    template<typename ITEM, typename ITEMID>
    inline size_t AttributeVector<ITEM, ITEMID>::size() const
    { return items.size(); }

    // just returning should be ok; manifold and attribs should always be in sync.
    // const context means manifold and attribs should be const, hence in sync.
    template<typename ITEM, typename ITEMID>
    inline const ITEM& AttributeVector<ITEM, ITEMID>::get(ITEMID id) const
    { 
        assert(id.index < items.size());
        return items[id.index]; 
    }

    template<typename ITEM, typename ITEMID>
    inline ITEM& AttributeVector<ITEM, ITEMID>::get(ITEMID id)
    {
        if(id.index >= items.size())
            items.resize(id.index + 1);
        return items[id.index]; 
    }

    template<typename ITEM, typename ITEMID>
    inline const ITEM& AttributeVector<ITEM, ITEMID>::operator [](ITEMID id) const
    { 
        assert(id.index < items.size());
        return items[id.index]; 
    }

    template<typename ITEM, typename ITEMID>
    inline ITEM& AttributeVector<ITEM, ITEMID>::operator [](ITEMID id)
    {
        if(id.index >= items.size())
            items.resize(id.index + 1);
        return items[id.index]; 
    }
}

#endif