/Users/jab/Documents/Teaching/02585/GEL2_and_demos/GEL/src/HMesh/ItemVector.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_ITEMVECTOR_H__
#define __HMESH_ITEMVECTOR_H__

#include <cassert>
#include <vector>

namespace HMesh
{
    template<typename ITEM>
    class ItemVector
    {
    public:
        ItemVector(size_t _size = 0, ITEM i = ITEM()); 
        
        ITEM& get(size_t i);
        const ITEM& get(size_t i) const;
        ITEM& operator[](size_t i);
        const ITEM& operator[](size_t i) const;

        size_t add(const ITEM& i);

        void remove(size_t i);

        void cleanup();

        size_t active_size() const;

        size_t total_size() const;

        void resize(size_t _size, ITEM i = ITEM());
        void reserve(size_t i);

        void clear();

        bool in_use(size_t i) const;

        size_t index_begin(bool skip = true) const;

        size_t index_end() const;

        size_t index_next(size_t index, bool skip = true) const;

        size_t index_prev(size_t index, bool skip = true) const;

    private:

        size_t size_active;
        std::vector<ITEM> items;

        std::vector<bool> active_items;
    };

    template<typename ITEM>
    inline ItemVector<ITEM>::ItemVector(size_t _size, ITEM i) 
        :   size_active(_size), 
            items(_size, i), 
            active_items(_size, true){}

    template<typename ITEM>
    inline ITEM& ItemVector<ITEM>::get(size_t i)
    {
        assert(i < items.size());
        return items[i];
    }

    template<typename ITEM>
    inline const ITEM& ItemVector<ITEM>::get(size_t i) const
    {
        assert(i < items.size());
        return items[i];
    }

    template<typename ITEM>
    inline ITEM& ItemVector<ITEM>::operator [](size_t i)
    {
        assert(i < items.size());
        return items[i];
    } 

    template<typename ITEM>
    inline const ITEM& ItemVector<ITEM>::operator [](size_t i) const
    {
        assert(i < items.size());
        return items[i];
    }

    template<typename ITEM>
    inline size_t ItemVector<ITEM>::add(const ITEM& i)
    {
        items.push_back(i);
        active_items.push_back(true);
        ++size_active;
        return items.size() - 1;
    }

    template<typename ITEM>
    inline void ItemVector<ITEM>::remove(size_t i)
    {
        if(active_items[i]){ 
            --size_active;
            active_items[i] = false;
        }
    }

    template<typename ITEM>
    inline void ItemVector<ITEM>::cleanup()
    {
        std::vector<ITEM> new_items;
        for(size_t i = 0; i < items.size(); ++i){
            if(active_items[i]) 
                new_items.push_back(items[i]);          
        }
        std::swap(items, new_items);
        active_items = std::vector<bool>(items.size(), true);
        size_active = items.size();
    }

    template<typename ITEM>
    inline size_t ItemVector<ITEM>::active_size() const
    { return size_active; }

    template<typename ITEM>
    inline size_t ItemVector<ITEM>::total_size() const
    { return items.size(); }

    template<typename ITEM>
    inline void ItemVector<ITEM>::resize(size_t _size, ITEM i)
    {
        items.resize(_size, i);
        active_items.resize(_size, true);
        size_active = _size;
    }

    template<typename ITEM>
    inline void ItemVector<ITEM>::reserve(size_t i)
    {
        items.reserve(i);
        active_items.reserve(i);
    }

    template<typename ITEM>
    inline void ItemVector<ITEM>::clear()
    {
        items.clear();
        active_items.clear();
        size_active = 0;
    }

    template<typename ITEM>
    inline bool ItemVector<ITEM>::in_use(size_t i) const
    {
        if(i < active_items.size())
                        return active_items[i];
                return false;
    }

    template<typename ITEM>
    inline size_t ItemVector<ITEM>::index_begin(bool skip) const
    {
        size_t i = 0;

        if(!skip)
            return i;
        
        while(i < active_items.size() && !active_items[i])
            ++i;


        return i;
    }

    template<typename ITEM>
    inline size_t ItemVector<ITEM>::index_end() const
    { return items.size(); }

    template<typename ITEM>
    inline size_t ItemVector<ITEM>::index_next(size_t index, bool skip) const
    {
        if(index < items.size())
            ++index;

        if(!skip)
            return index;

        while(index < items.size() && !active_items[index])
           ++index;

        return index;
    }

    template<typename ITEM>
    inline size_t ItemVector<ITEM>::index_prev(size_t index, bool skip) const
    {
        if(index > 0)
            --index;

        if(!skip)
            return index;

        while(!active_items[index] && index > 0)
            --index;

        return index;
    }

}

#endif