Subversion Repositories gelsvn

Rev

Rev 578 | Rev 587 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 578 Rev 586
Line 11... Line 11...
11 
#ifndef __HMESH_ITEMVECTOR_H__
 11 
#ifndef __HMESH_ITEMVECTOR_H__
12 
#define __HMESH_ITEMVECTOR_H__
 12 
#define __HMESH_ITEMVECTOR_H__
13 
 
 13 
 
14 
#include <cassert>
 14 
#include <cassert>
15 
#include <vector>
 15 
#include <vector>
- 
 
 16 
#include "ItemID.h"
16 
 
 17 
 
17 
namespace HMesh
 18 
namespace HMesh
18 
{
 19 
{
- 
 
 20 
    /** The ItemVector is a vector of mesh entities. */
19 
    template<typename ITEM>
 21 
    template<typename ITEM>
20 
    class ItemVector
 22 
    class ItemVector
21 
    {
 23 
    {
22 
    public:
 24 
    public:
- 
 
 25 
        typedef ItemID<ITEM> IDType;
- 
 
 26
- 
 
 27
23 
        /// default constructor
28 
        /// default constructor
24 
        ItemVector(size_t _size = 0, ITEM i = ITEM());
29 
        ItemVector(size_t _size = 0, ITEM i = ITEM());
25
30
26 
        /// Get a reference to item i from kernel
31 
        /// Get a reference to item i from kernel
27 
        ITEM& get(size_t i);
 32 
        ITEM& get(IDType i);
28 
        /// Get a const reference to item i from kernel
33 
        /// Get a const reference to item i from kernel
29 
        const ITEM& get(size_t i) const;
 34 
        const ITEM& get(IDType i) const;
30 
        /// Get a reference to item i from kernel
35 
        /// Get a reference to item i from kernel
31 
        ITEM& operator[](size_t i);
 36 
        ITEM& operator[](IDType i);
32 
        /// Get a const reference to item i from kernel
37 
        /// Get a const reference to item i from kernel
33 
        const ITEM& operator[](size_t i) const;
 38 
        const ITEM& operator[](IDType i) const;
34 
 
 39 
 
35 
        /// Add an entity to the kernel
40 
        /// Add an entity to the kernel
36 
        size_t add(const ITEM& i);
 41 
        IDType add(const ITEM& i);
37 
 
 42 
 
38 
        /// remove an entity from kernel - entity is NOT erased!
43 
        /// remove an entity from kernel - entity is NOT erased!
39 
        void remove(size_t i);
 44 
        void remove(IDType i);
40 
 
 45 
 
41 
        /// erase unused entities from the kernel
46 
        /// erase unused entities from the kernel
42 
        void cleanup();
 47 
        void cleanup();
43 
 
 48 
 
44 
        /// active size of vector
49 
        /// active size of vector
45 
        size_t active_size() const;
 50 
        size_t size() const;
46 
 
 51 
 
47 
        /// total size of vector
52 
        /// total size of vector
48 
        size_t total_size() const;
 53 
        size_t allocated_size() const;
49 
 
 54 
 
50 
        /// Resize the kernel NOTE: Sets all active flags to true
55 
        /// Resize the kernel NOTE: Sets all active flags to true
51 
        void resize(size_t _size, ITEM i = ITEM());
 56 
        void resize(size_t _size, ITEM i = ITEM());
52 
        /// Request size change in kernel
57 
        /// Request size change in kernel
53 
        void reserve(size_t i);
 58 
        void reserve(size_t i);
54 
 
 59 
 
55 
        /// Clear the kernel
60 
        /// Clear the kernel
56 
        void clear();
 61 
        void clear();
57 
 
 62 
 
58 
        /// Check if entity i is used
63 
        /// Check if entity i is used
59 
        bool in_use(size_t i) const;
 64 
        bool in_use(IDType i) const;
60 
 
 65 
 
61 
        /// get starting index (default: skip to first active index)
66 
        /// get starting index (default: skip to first active index)
62 
        size_t index_begin(bool skip = true) const;
 67 
        IDType index_begin(bool skip = true) const;
63 
 
 68 
 
64 
        /// get one past the end index of vector
69 
        /// get one past the end index of vector
65 
        size_t index_end() const;
 70 
        IDType index_end() const;
66 
 
 71 
 
67 
        /// get the next index (default: skip to first active index)
72 
        /// get the next index (default: skip to first active index)
68 
        size_t index_next(size_t index, bool skip = true) const;
 73 
        IDType index_next(IDType index, bool skip = true) const;
69 
 
 74 
 
70 
        /// get the previous index (default: skip to first active index)
75 
        /// get the previous index (default: skip to first active index)
71 
        size_t index_prev(size_t index, bool skip = true) const;
 76 
        IDType index_prev(IDType index, bool skip = true) const;
72 
 
 77 
 
73 
    private:
 78 
    private:
74 
 
 79 
 
75 
        size_t size_active;
 80 
        size_t size_active;
76 
        std::vector<ITEM> items;
 81 
        std::vector<ITEM> items;
Line 84... Line 89...
84 
        :   size_active(_size),
89 
        :   size_active(_size),
85 
            items(_size, i),
90 
            items(_size, i),
86 
            active_items(_size, true){}
 91 
            active_items(_size, true){}
87 
 
 92 
 
88 
    template<typename ITEM>
 93 
    template<typename ITEM>
89 
    inline ITEM& ItemVector<ITEM>::get(size_t i)
 94 
    inline ITEM& ItemVector<ITEM>::get(IDType id)
90 
    {
 95 
    {
91 
        assert(i < items.size());
 96 
        assert(id.index < items.size());
92 
        return items[i];
 97 
        return items[id.index];
93 
    }
 98 
    }
94 
 
 99 
 
95 
    template<typename ITEM>
 100 
    template<typename ITEM>
96 
    inline const ITEM& ItemVector<ITEM>::get(size_t i) const
 101 
    inline const ITEM& ItemVector<ITEM>::get(IDType id) const
97 
    {
 102 
    {
98 
        assert(i < items.size());
 103 
        assert(id.index < items.size());
99 
        return items[i];
 104 
        return items[id.index];
100 
    }
 105 
    }
101 
 
 106 
 
102 
    template<typename ITEM>
 107 
    template<typename ITEM>
103 
    inline ITEM& ItemVector<ITEM>::operator [](size_t i)
 108 
    inline ITEM& ItemVector<ITEM>::operator [](IDType id)
104 
    {
 109 
    {
105 
        assert(i < items.size());
 110 
        assert(id.index < items.size());
106 
        return items[i];
 111 
        return items[id.index];
107 
    }
112 
    }
108 
 
 113 
 
109 
    template<typename ITEM>
 114 
    template<typename ITEM>
110 
    inline const ITEM& ItemVector<ITEM>::operator [](size_t i) const
 115 
    inline const ITEM& ItemVector<ITEM>::operator [](IDType id) const
111 
    {
 116 
    {
112 
        assert(i < items.size());
 117 
        assert(id.index < items.size());
113 
        return items[i];
 118 
        return items[id.index];
114 
    }
 119 
    }
115 
 
 120 
 
116 
    template<typename ITEM>
 121 
    template<typename ITEM>
117 
    inline size_t ItemVector<ITEM>::add(const ITEM& i)
 122 
    inline typename ItemVector<ITEM>::IDType ItemVector<ITEM>::add(const ITEM& item)
118 
    {
 123 
    {
119 
        items.push_back(i);
 124 
        items.push_back(item);
120 
        active_items.push_back(true);
 125 
        active_items.push_back(true);
121 
        ++size_active;
 126 
        ++size_active;
122 
        return items.size() - 1;
 127 
        return IDType(items.size() - 1);
123 
    }
 128 
    }
124 
 
 129 
 
125 
    template<typename ITEM>
 130 
    template<typename ITEM>
126 
    inline void ItemVector<ITEM>::remove(size_t i)
 131 
    inline void ItemVector<ITEM>::remove(ItemVector<ITEM>::IDType id)
127 
    {
 132 
    {
128 
        if(active_items[i]){
133 
        if(active_items[id.index]){
129 
            --size_active;
 134 
            --size_active;
130 
            active_items[i] = false;
 135 
            active_items[id.index] = false;
131 
        }
 136 
        }
132 
    }
 137 
    }
133 
 
 138 
 
134 
    template<typename ITEM>
 139 
    template<typename ITEM>
135 
    inline void ItemVector<ITEM>::cleanup()
 140 
    inline void ItemVector<ITEM>::cleanup()
Line 143... Line 148...
143 
        active_items = std::vector<bool>(items.size(), true);
 148 
        active_items = std::vector<bool>(items.size(), true);
144 
        size_active = items.size();
 149 
        size_active = items.size();
145 
    }
 150 
    }
146 
 
 151 
 
147 
    template<typename ITEM>
 152 
    template<typename ITEM>
148 
    inline size_t ItemVector<ITEM>::active_size() const
 153 
    inline size_t ItemVector<ITEM>::size() const
149 
    { return size_active; }
 154 
    { return size_active; }
150 
 
 155 
 
151 
    template<typename ITEM>
 156 
    template<typename ITEM>
152 
    inline size_t ItemVector<ITEM>::total_size() const
 157 
    inline size_t ItemVector<ITEM>::allocated_size() const
153 
    { return items.size(); }
 158 
    { return items.size(); }
154 
 
 159 
 
155 
    template<typename ITEM>
 160 
    template<typename ITEM>
156 
    inline void ItemVector<ITEM>::resize(size_t _size, ITEM i)
 161 
    inline void ItemVector<ITEM>::resize(size_t _size, ITEM i)
157 
    {
 162 
    {
Line 174... Line 179...
174 
        active_items.clear();
 179 
        active_items.clear();
175 
        size_active = 0;
 180 
        size_active = 0;
176 
    }
 181 
    }
177 
 
 182 
 
178 
    template<typename ITEM>
 183 
    template<typename ITEM>
179 
    inline bool ItemVector<ITEM>::in_use(size_t i) const
 184 
    inline bool ItemVector<ITEM>::in_use(ItemVector<ITEM>::IDType id) const
180 
    {
 185 
    {
181 
        if(i < active_items.size())
 186 
        if(id.index < active_items.size())
182 
			return active_items[i];
 187 
			return active_items[id.index];
183 
		return false;
 188 
		return false;
184 
    }
 189 
    }
185 
 
 190 
 
186 
    template<typename ITEM>
 191 
    template<typename ITEM>
187 
    inline size_t ItemVector<ITEM>::index_begin(bool skip) const
 192 
    inline typename ItemVector<ITEM>::IDType ItemVector<ITEM>::index_begin(bool skip) const
188 
    {
 193 
    {
189 
        size_t i = 0;
 194 
        size_t i = 0;
190 
 
 195 
 
191 
        if(!skip)
 196 
        if(!skip)
192 
            return i;
 197 
            return IDType(i);
193
198
194 
        while(i < active_items.size() && !active_items[i])
 199 
        while(i < active_items.size() && !active_items[i])
195 
            ++i;
 200 
            ++i;
196 
 
 201 
 
197 
 
 202 
 
198 
        return i;
 203 
        return IDType(i);
199 
    }
 204 
    }
200 
 
 205 
 
201 
    template<typename ITEM>
 206 
    template<typename ITEM>
202 
    inline size_t ItemVector<ITEM>::index_end() const
 207 
    inline typename ItemVector<ITEM>::IDType ItemVector<ITEM>::index_end() const
203 
    { return items.size(); }
 208 
    { return IDType(items.size()); }
204 
 
 209 
 
205 
    template<typename ITEM>
 210 
    template<typename ITEM>
206 
    inline size_t ItemVector<ITEM>::index_next(size_t index, bool skip) const
 211 
    inline typename ItemVector<ITEM>::IDType ItemVector<ITEM>::index_next(ItemVector<ITEM>::IDType id, bool skip) const
207 
    {
 212 
    {
208 
        if(index < items.size())
 213 
        if(id.index < items.size())
209 
            ++index;
 214 
            ++id.index;
210 
 
 215 
 
211 
        if(!skip)
 216 
        if(!skip)
212 
            return index;
 217 
            return IDType(id);
213 
 
 218 
 
214 
        while(index < items.size() && !active_items[index])
 219 
        while(id.index < items.size() && !active_items[id.index])
215 
           ++index;
 220 
           ++id.index;
216 
 
 221 
 
217 
        return index;
 222 
        return id;
218 
    }
 223 
    }
219 
 
 224 
 
220 
    template<typename ITEM>
 225 
    template<typename ITEM>
221 
    inline size_t ItemVector<ITEM>::index_prev(size_t index, bool skip) const
 226 
    inline typename ItemVector<ITEM>::IDType ItemVector<ITEM>::index_prev(ItemVector<ITEM>::IDType id, bool skip) const
222 
    {
 227 
    {
223 
        if(index > 0)
 228 
        if(id.index > 0)
224 
            --index;
 229 
            --id.index;
225 
 
 230 
 
226 
        if(!skip)
 231 
        if(!skip)
227 
            return index;
 232 
            return id;
228 
 
 233 
 
229 
        while(!active_items[index] && index > 0)
 234 
        while(!active_items[id.index] && id.index > 0)
230 
            --index;
 235 
            --id.index;
231 
 
 236 
 
232 
        return index;
 237 
        return id;
233 
    }
 238 
    }
234 
 
 239 
 
235 
}
 240 
}
236 
 
 241 
 
237 
#endif
242 
#endif