← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/blender/gutsy-security

« back to all changes in this revision

Viewing changes to extern/bFTGL/include/FTVector.h

  • Committer: Bazaar Package Importer
  • Author(s): Florian Ernst
  • Date: 2005-11-06 12:40:03 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20051106124003-3pgs7tcg5rox96xg
Tags: 2.37a-1.1
http://bugs.debian.org/333958
* Non-maintainer upload.
* Split out parts of 01_SConstruct_debian.dpatch again: root_build_dir
  really needs to get adjusted before the clean target runs - closes: #333958,
  see #288882 for reference

Show diffs side-by-side

added added

removed removed

Lines of Context:
extern/bFTGL/include/FTVector.h
 
1
#ifndef    __FTVector__
 
2
#define    __FTVector__
 
3
 
 
4
#include "FTGL.h"
 
5
 
 
6
/**
 
7
 * Provides a non-STL alternative to the STL vector
 
8
 */
 
9
template <typename FT_VECTOR_ITEM_TYPE>
 
10
class FTGL_EXPORT FTVector
 
11
{
 
12
    public:
 
13
        typedef FT_VECTOR_ITEM_TYPE value_type;
 
14
        typedef value_type& reference;
 
15
        typedef const value_type& const_reference;
 
16
        typedef value_type* iterator;
 
17
        typedef const value_type* const_iterator;
 
18
        typedef size_t size_type;
 
19
        
 
20
        FTVector()
 
21
        {
 
22
            Capacity = Size = 0;
 
23
            Items = 0;
 
24
        }
 
25
 
 
26
        
 
27
        virtual ~FTVector()
 
28
        {
 
29
            clear();
 
30
        }
 
31
        
 
32
        FTVector& operator =(const FTVector& v)
 
33
        {
 
34
            reserve(v.capacity());
 
35
            
 
36
            iterator ptr = begin();
 
37
            const_iterator vbegin = v.begin();
 
38
            const_iterator vend = v.end();
 
39
            
 
40
            while( vbegin != vend)
 
41
            {
 
42
                *ptr++ = *vbegin++;
 
43
            }
 
44
            
 
45
            Size = v.size();
 
46
            return *this;
 
47
        }
 
48
        
 
49
        size_type size() const
 
50
        {
 
51
            return Size;
 
52
        }
 
53
        
 
54
        size_type capacity() const
 
55
        {
 
56
            return Capacity;
 
57
        }
 
58
        
 
59
        iterator begin()
 
60
        {
 
61
            return Items;
 
62
        }
 
63
        
 
64
        const_iterator begin() const
 
65
        {
 
66
            return Items;
 
67
        }
 
68
        
 
69
        iterator end()
 
70
        {
 
71
            return begin() + size(); 
 
72
        }
 
73
        
 
74
        const_iterator end() const
 
75
        {
 
76
            return begin() + size(); 
 
77
        }
 
78
        
 
79
        bool empty() const 
 
80
        { 
 
81
            return size() == 0; 
 
82
        }
 
83
 
 
84
        reference operator [](size_type pos) 
 
85
        { 
 
86
            return( *(begin() + pos)); 
 
87
        }
 
88
 
 
89
        const_reference operator []( size_type pos) const 
 
90
        { 
 
91
            return( *(begin() + pos)); 
 
92
        }
 
93
        
 
94
        void clear()
 
95
        {
 
96
            if( Capacity)
 
97
            {
 
98
                delete [] Items;
 
99
                Capacity = Size = 0;
 
100
                Items = 0;
 
101
            }
 
102
        }
 
103
 
 
104
        void reserve( size_type n)
 
105
        {
 
106
            if( capacity() < n)
 
107
            {
 
108
                expand(n);
 
109
            }
 
110
        }
 
111
 
 
112
        void push_back(const value_type& x)
 
113
        {
 
114
            if( size() == capacity())
 
115
            {
 
116
                expand();
 
117
            }
 
118
           
 
119
           ( *this)[size()] = x;
 
120
            ++Size;
 
121
        }
 
122
 
 
123
        void resize(size_type n, value_type x)
 
124
        {
 
125
            if( n == size())
 
126
            {
 
127
                return;
 
128
            }
 
129
            
 
130
            reserve(n);
 
131
            iterator begin, end;
 
132
            
 
133
            if( n >= Size)
 
134
            {
 
135
                begin = this->end();
 
136
                end = this->begin() + n;
 
137
            }
 
138
            else
 
139
            {
 
140
                begin = this->begin() + n;
 
141
                end = this->end();
 
142
            }
 
143
        
 
144
            while( begin != end)
 
145
            {
 
146
                *begin++ = x;
 
147
            }
 
148
        
 
149
            Size = n;
 
150
        }
 
151
 
 
152
        
 
153
    private:
 
154
        void expand(size_type capacity_hint = 0)
 
155
        {
 
156
            size_type new_capacity =( capacity() == 0) ? 256 : capacity()* 2;
 
157
            if( capacity_hint)
 
158
            {
 
159
                while( new_capacity < capacity_hint)
 
160
                {
 
161
                    new_capacity *= 2;
 
162
                }
 
163
            }
 
164
            
 
165
            value_type *new_items = new value_type[new_capacity];
 
166
            
 
167
            iterator begin = this->begin();
 
168
            iterator end = this->end();
 
169
            value_type *ptr = new_items;
 
170
            
 
171
            while( begin != end)
 
172
            {
 
173
                *ptr++ = *begin++;
 
174
            }
 
175
            
 
176
            if( Capacity)
 
177
            {
 
178
                delete [] Items;
 
179
            }
 
180
        
 
181
            Items = new_items;
 
182
            Capacity = new_capacity;
 
183
        }
 
184
 
 
185
        size_type Capacity;
 
186
        size_type Size;
 
187
        value_type* Items;
 
188
};
 
189
 
 
190
#endif  //  __FTVector__