WebSVN – gelsvn – Diff – /trunk/src/HMesh/ItemVector.h

  * ----------------------------------------------------------------------- */
 #ifndef __HMESH_ITEMVECTOR_H__
 #define __HMESH_ITEMVECTOR_H__
-//#include <cassert>
+#include <cassert>
 #include <vector>
-#include "ItemID.h"
 namespace HMesh
+{
     template<typename ITEM>
     class ItemVector
+    {
     public:
         /// default constructor
-        ItemVector(IndexType _size = 0, ITEM i = ITEM());
+        ItemVector(size_t _size = 0, ITEM i = ITEM());
         /// Get a reference to entity i from kernel
-        ITEM& get(IndexType i);
+        ITEM& get(size_t i);
         /// Get a const reference to entity i from kernel
-        const ITEM& get(IndexType i) const;
+        const ITEM& get(size_t i) const;
-        ITEM& operator[](IndexType i);
+        ITEM& operator[](size_t i);
-        const ITEM& operator[](IndexType i) const;
+        const ITEM& operator[](size_t i) const;
         /// Add an entity to the kernel
-        IndexType add(const ITEM& i);
+        size_t add(const ITEM& i);
         /// remove an entity from kernel - entity is NOT erased!
-        void remove(IndexType i);
+        void remove(size_t i);
         /// erase unused entities from the kernel
         void cleanup();
         /// size of vector (default: only active items)
-        IndexType size(bool active = true) const;
+        size_t size(bool active = true) const;
         /// Resize the kernel NOTE: Sets all active flags to true
-        void resize(IndexType _size, ITEM i = ITEM());
+        void resize(size_t _size, ITEM i = ITEM());
         /// Request size change in kernel
-        void reserve(IndexType i);
+        void reserve(size_t i);
         /// Clear the kernel
         void clear();
         /// Check if entity i is used
-        bool in_use(IndexType i) const;
+        bool in_use(size_t i) const;
         /// get starting index (default: skip to first active index)
-        IndexType index_begin(bool skip = true) const;
+        size_t index_begin(bool skip = true) const;
         /// get ending index
-        IndexType index_end() const;
+        size_t index_end() const;
         /// get the next index (default: skip to first active index)
-        IndexType index_next(IndexType index, bool skip = true) const;
+        size_t index_next(size_t index, bool skip = true) const;
         /// get the previous index (default: skip to first active index)
-        IndexType index_prev(IndexType index, bool skip = true) const;
+        size_t index_prev(size_t index, bool skip = true) const;
     private:
-        IndexType size_active;
+        size_t size_active;
         std::vector<ITEM> items;
         /// Memory consideration - objects flagged as unused should be remembered for future use (unless purged)
         std::vector<bool> active_items;
     };
     template<typename ITEM>
-    inline ItemVector<ITEM>::ItemVector(IndexType _size, ITEM i)
+    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(IndexType i)
+    inline ITEM& ItemVector<ITEM>::get(size_t i)
+    {
-        //std::assert(i < items.size());
+        assert(i < items.size());
         return items[i];
+    }
     template<typename ITEM>
-    inline const ITEM& ItemVector<ITEM>::get(IndexType i) const
+    inline const ITEM& ItemVector<ITEM>::get(size_t i) const
+    {
-        //std::assert(i < items.size());
+        assert(i < items.size());
         return items[i];
+    }
     template<typename ITEM>
-    inline ITEM& ItemVector<ITEM>::operator [](IndexType i)
+    inline ITEM& ItemVector<ITEM>::operator [](size_t i)
+    {
-        //std::assert(i < items.size());
+        assert(i < items.size());
         return items[i];
+    }
     template<typename ITEM>
-    inline const ITEM& ItemVector<ITEM>::operator [](IndexType i) const
+    inline const ITEM& ItemVector<ITEM>::operator [](size_t i) const
+    {
-        //std::assert(i < items.size());
+        assert(i < items.size());
         return items[i];
+    }
     template<typename ITEM>
-    inline IndexType ItemVector<ITEM>::add(const ITEM& i)
+    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(IndexType i)
+    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(IndexType i = 0; i < items.size(); ++i){
+        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 IndexType ItemVector<ITEM>::size(bool active = true) const
+    inline size_t ItemVector<ITEM>::size(bool active = true) const
     { return active ? size_active : items.size(); }
     template<typename ITEM>
-    inline void ItemVector<ITEM>::resize(IndexType _size, ITEM i)
+    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(IndexType i)
+    inline void ItemVector<ITEM>::reserve(size_t i)
+    {
         items.reserve(i);
         active_items.reserve(i);
+    }
         active_items.clear();
         size_active = 0;
+    }
     template<typename ITEM>
-    inline bool ItemVector<ITEM>::in_use(IndexType i) const
+    inline bool ItemVector<ITEM>::in_use(size_t i) const
+    {
-        //td::assert(i < active_items.size());
+        assert(i < active_items.size());
         return active_items[i];
+    }
     template<typename ITEM>
-    inline IndexType ItemVector<ITEM>::index_begin(bool skip = true) const
+    inline size_t ItemVector<ITEM>::index_begin(bool skip = true) const
+    {
-        IndexType i = 0;
+        size_t i = 0;
         if(!skip)
             return i;
         while(i < active_items.size() && !active_items[i])
         return i;
+    }
     template<typename ITEM>
-    inline IndexType ItemVector<ITEM>::index_end() const
+    inline size_t ItemVector<ITEM>::index_end() const
     { return items.size(); }
     template<typename ITEM>
-    inline IndexType ItemVector<ITEM>::index_next(IndexType index, bool skip = true) const
+    inline size_t ItemVector<ITEM>::index_next(size_t index, bool skip = true) const
+    {
         if(index < items.size())
             ++index;
         if(!skip)
         return index;
+    }
     template<typename ITEM>
-    inline IndexType ItemVector<ITEM>::index_prev(IndexType index, bool skip = true) const
+    inline size_t ItemVector<ITEM>::index_prev(size_t index, bool skip = true) const
+    {
         if(index > 0)
             --index;
         if(!skip)

Subversion Repositories gelsvn

(root)/trunk/src/HMesh/ItemVector.h @ 689 – Rev 515 → 518