Cleanup: remove redundant doxygen \file argument
[blender.git] / intern / smoke / intern / tnt / tnt_i_refvec.h
1 /** \file \ingroup smoke
2  */
3 /*
4 *
5 * Template Numerical Toolkit (TNT)
6 *
7 * Mathematical and Computational Sciences Division
8 * National Institute of Technology,
9 * Gaithersburg, MD USA
10 *
11 *
12 * This software was developed at the National Institute of Standards and
13 * Technology (NIST) by employees of the Federal Government in the course
14 * of their official duties. Pursuant to title 17 Section 105 of the
15 * United States Code, this software is not subject to copyright protection
16 * and is in the public domain. NIST assumes no responsibility whatsoever for
17 * its use by other parties, and makes no guarantees, expressed or implied,
18 * about its quality, reliability, or any other characteristic.
19 *
20 */
21
22
23
24 #ifndef TNT_I_REFVEC_H
25 #define TNT_I_REFVEC_H
26
27 #include <cstdlib>
28 #include <iostream>
29
30 #ifdef TNT_BOUNDS_CHECK
31 #include <assert.h>
32 #endif
33
34 #ifndef NULL
35 #define NULL 0
36 #endif
37
38 namespace TNT
39 {
40 /*
41         Internal representation of ref-counted array.  The TNT
42         arrays all use this building block.
43
44         <p>
45         If an array block is created by TNT, then every time 
46         an assignment is made, the left-hand-side reference 
47         is decreased by one, and the right-hand-side refernce
48         count is increased by one.  If the array block was
49         external to TNT, the refernce count is a NULL pointer
50         regardless of how many references are made, since the 
51         memory is not freed by TNT.
52
53
54         
55 */
56 template <class T>
57 class i_refvec
58 {
59
60
61   private:
62     T* data_;                  
63     int *ref_count_;
64
65
66   public:
67
68                          i_refvec();
69         explicit i_refvec(int n);
70         inline   i_refvec(T* data);
71         inline   i_refvec(const i_refvec &v);
72         inline   T*              begin();
73         inline const T* begin() const;
74         inline  T& operator[](int i);
75         inline const T& operator[](int i) const;
76         inline  i_refvec<T> & operator=(const i_refvec<T> &V);
77                     void copy_(T* p, const T* q, const T* e); 
78                     void set_(T* p, const T* b, const T* e); 
79         inline  int      ref_count() const;
80         inline  int is_null() const;
81         inline  void destroy();
82                          ~i_refvec();
83                         
84 };
85
86 template <class T>
87 void i_refvec<T>::copy_(T* p, const T* q, const T* e)
88 {
89         for (T* t=p; q<e; t++, q++)
90                 *t= *q;
91 }
92
93 template <class T>
94 i_refvec<T>::i_refvec() : data_(NULL), ref_count_(NULL) {}
95
96 /**
97         In case n is 0 or negative, it does NOT call new. 
98 */
99 template <class T>
100 i_refvec<T>::i_refvec(int n) : data_(NULL), ref_count_(NULL)
101 {
102         if (n >= 1)
103         {
104 #ifdef TNT_DEBUG
105                 std::cout  << "new data storage.\n";
106 #endif
107                 data_ = new T[n];
108                 ref_count_ = new int;
109                 *ref_count_ = 1;
110         }
111 }
112
113 template <class T>
114 inline   i_refvec<T>::i_refvec(const i_refvec<T> &V): data_(V.data_),
115         ref_count_(V.ref_count_)
116 {
117         if (V.ref_count_ != NULL)
118             (*(V.ref_count_))++;
119 }
120
121
122 template <class T>
123 i_refvec<T>::i_refvec(T* data) : data_(data), ref_count_(NULL) {}
124
125 template <class T>
126 inline T* i_refvec<T>::begin()
127 {
128         return data_;
129 }
130
131 template <class T>
132 inline const T& i_refvec<T>::operator[](int i) const
133 {
134         return data_[i];
135 }
136
137 template <class T>
138 inline T& i_refvec<T>::operator[](int i)
139 {
140         return data_[i];
141 }
142
143
144 template <class T>
145 inline const T* i_refvec<T>::begin() const
146 {
147         return data_;
148 }
149
150
151
152 template <class T>
153 i_refvec<T> & i_refvec<T>::operator=(const i_refvec<T> &V)
154 {
155         if (this == &V)
156                 return *this;
157
158
159         if (ref_count_ != NULL)
160         {
161                 (*ref_count_) --;
162                 if ((*ref_count_) == 0)
163                         destroy();
164         }
165
166         data_ = V.data_;
167         ref_count_ = V.ref_count_;
168
169         if (V.ref_count_ != NULL)
170             (*(V.ref_count_))++;
171
172         return *this;
173 }
174
175 template <class T>
176 void i_refvec<T>::destroy()
177 {
178         if (ref_count_ != NULL)
179         {
180 #ifdef TNT_DEBUG
181                 std::cout << "destorying data... \n";
182 #endif
183                 delete ref_count_;
184
185 #ifdef TNT_DEBUG
186                 std::cout << "deleted ref_count_ ...\n";
187 #endif
188                 if (data_ != NULL)
189                         delete []data_;
190 #ifdef TNT_DEBUG
191                 std::cout << "deleted data_[] ...\n";
192 #endif
193                 data_ = NULL;
194         }
195 }
196
197 /*
198 * return 1 is vector is empty, 0 otherwise
199 *
200 * if is_null() is false and ref_count() is 0, then
201
202 */
203 template<class T>
204 int i_refvec<T>::is_null() const
205 {
206         return (data_ == NULL ? 1 : 0);
207 }
208
209 /*
210 *  returns -1 if data is external, 
211 *  returns 0 if a is NULL array,
212 *  otherwise returns the positive number of vectors sharing
213 *               this data space.
214 */
215 template <class T>
216 int i_refvec<T>::ref_count() const
217 {
218         if (data_ == NULL)
219                 return 0;
220         else
221                 return (ref_count_ != NULL ? *ref_count_ : -1) ; 
222 }
223
224 template <class T>
225 i_refvec<T>::~i_refvec()
226 {
227         if (ref_count_ != NULL)
228         {
229                 (*ref_count_)--;
230
231                 if (*ref_count_ == 0)
232                 destroy();
233         }
234 }
235
236
237 } /* namespace TNT */
238
239
240
241
242
243 #endif
244 /* TNT_I_REFVEC_H */
245