shared-array.hpp
Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040 #include <cstdarg>
00041 #include <iostream>
00042 #include <sstream>
00043
00044 namespace Gecode {
00045
00053 template<class T>
00054 class SharedArray : public SharedHandle {
00055 protected:
00057 class SAO : public SharedHandle::Object {
00058 private:
00060 T* a;
00062 int n;
00063 public:
00065 SAO(int n);
00067 virtual ~SAO(void);
00068
00070 T& operator [](int i);
00072 const T& operator [](int i) const;
00073
00075 int size(void) const;
00076
00078 T* begin(void);
00080 const T* begin(void) const;
00082 T* end(void);
00084 const T* end(void) const;
00085 };
00086 public:
00088
00089
00090 typedef T value_type;
00092 typedef T& reference;
00094 typedef const T& const_reference;
00096 typedef T* pointer;
00098 typedef const T* const_pointer;
00100 typedef T* iterator;
00102 typedef const T* const_iterator;
00104 typedef std::reverse_iterator<T*> reverse_iterator;
00106 typedef std::reverse_iterator<const T*> const_reverse_iterator;
00108
00116 SharedArray(void);
00118 SharedArray(int n);
00126 void init(int n);
00128 SharedArray(const SharedArray& a);
00130 SharedArray(const ArgArrayBase<T>& a);
00131
00133 T& operator [](int i);
00135 const T& operator [](int i) const;
00136
00138 int size(void) const;
00139
00141
00142
00143 iterator begin(void);
00145 const_iterator begin(void) const;
00147 iterator end(void);
00149 const_iterator end(void) const;
00151 reverse_iterator rbegin(void);
00153 const_reverse_iterator rbegin(void) const;
00155 reverse_iterator rend(void);
00157 const_reverse_iterator rend(void) const;
00159 };
00160
00165 template<class Char, class Traits, class T>
00166 std::basic_ostream<Char,Traits>&
00167 operator <<(std::basic_ostream<Char,Traits>& os,
00168 const SharedArray<T>& x);
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180 template<class T>
00181 forceinline
00182 SharedArray<T>::SAO::SAO(int n0) : n(n0) {
00183 a = (n>0) ? heap.alloc<T>(n) : NULL;
00184 }
00185
00186 template<class T>
00187 SharedArray<T>::SAO::~SAO(void) {
00188 if (n>0) {
00189 heap.free<T>(a,n);
00190 }
00191 }
00192
00193 template<class T>
00194 forceinline T&
00195 SharedArray<T>::SAO::operator [](int i) {
00196 assert((i>=0) && (i<n));
00197 return a[i];
00198 }
00199
00200 template<class T>
00201 forceinline const T&
00202 SharedArray<T>::SAO::operator [](int i) const {
00203 assert((i>=0) && (i<n));
00204 return a[i];
00205 }
00206
00207 template<class T>
00208 forceinline int
00209 SharedArray<T>::SAO::size(void) const {
00210 return n;
00211 }
00212
00213 template<class T>
00214 forceinline T*
00215 SharedArray<T>::SAO::begin(void) {
00216 return a;
00217 }
00218
00219 template<class T>
00220 forceinline const T*
00221 SharedArray<T>::SAO::begin(void) const {
00222 return a;
00223 }
00224
00225 template<class T>
00226 forceinline T*
00227 SharedArray<T>::SAO::end(void) {
00228 return a+n;
00229 }
00230
00231 template<class T>
00232 forceinline const T*
00233 SharedArray<T>::SAO::end(void) const {
00234 return a+n;
00235 }
00236
00237
00238 template<class T>
00239 forceinline
00240 SharedArray<T>::SharedArray(void) {}
00241
00242 template<class T>
00243 forceinline
00244 SharedArray<T>::SharedArray(int n)
00245 : SharedHandle(new SAO(n)) {}
00246
00247 template<class T>
00248 forceinline
00249 SharedArray<T>::SharedArray(const SharedArray<T>& sa)
00250 : SharedHandle(sa) {}
00251
00252 template<class T>
00253 forceinline void
00254 SharedArray<T>::init(int n) {
00255 assert(object() == NULL);
00256 object(new SAO(n));
00257 }
00258
00259 template<class T>
00260 forceinline T&
00261 SharedArray<T>::operator [](int i) {
00262 assert(object() != NULL);
00263 return (*static_cast<SAO*>(object()))[i];
00264 }
00265
00266 template<class T>
00267 forceinline const T&
00268 SharedArray<T>::operator [](int i) const {
00269 assert(object() != NULL);
00270 return (*static_cast<SAO*>(object()))[i];
00271 }
00272
00273 template<class T>
00274 forceinline
00275 SharedArray<T>::SharedArray(const ArgArrayBase<T>& a)
00276 : SharedHandle(new SAO(a.size())) {
00277 for (int i=a.size(); i--; )
00278 operator [](i)=a[i];
00279 }
00280
00281 template<class T>
00282 forceinline int
00283 SharedArray<T>::size(void) const {
00284 assert(object() != NULL);
00285 return static_cast<SAO*>(object())->size();
00286 }
00287
00288 template<class T>
00289 forceinline typename SharedArray<T>::iterator
00290 SharedArray<T>::begin(void) {
00291 assert(object() != NULL);
00292 return static_cast<SAO*>(object())->begin();
00293 }
00294
00295 template<class T>
00296 forceinline typename SharedArray<T>::const_iterator
00297 SharedArray<T>::begin(void) const {
00298 assert(object() != NULL);
00299 return static_cast<SAO*>(object())->begin();
00300 }
00301
00302 template<class T>
00303 forceinline typename SharedArray<T>::iterator
00304 SharedArray<T>::end(void) {
00305 assert(object() != NULL);
00306 return static_cast<SAO*>(object())->end();
00307 }
00308
00309 template<class T>
00310 forceinline typename SharedArray<T>::const_iterator
00311 SharedArray<T>::end(void) const {
00312 assert(object() != NULL);
00313 return static_cast<SAO*>(object())->end();
00314 }
00315
00316 template<class T>
00317 forceinline typename SharedArray<T>::reverse_iterator
00318 SharedArray<T>::rbegin(void) {
00319 assert(object() != NULL);
00320 return reverse_iterator(static_cast<SAO*>(object())->end());
00321 }
00322
00323 template<class T>
00324 forceinline typename SharedArray<T>::const_reverse_iterator
00325 SharedArray<T>::rbegin(void) const {
00326 assert(object() != NULL);
00327 return const_reverse_iterator(static_cast<SAO*>(object())->end());
00328 }
00329
00330 template<class T>
00331 forceinline typename SharedArray<T>::reverse_iterator
00332 SharedArray<T>::rend(void) {
00333 assert(object() != NULL);
00334 return reverse_iterator(static_cast<SAO*>(object())->begin());
00335 }
00336
00337 template<class T>
00338 forceinline typename SharedArray<T>::const_reverse_iterator
00339 SharedArray<T>::rend(void) const {
00340 assert(object() != NULL);
00341 return const_reverse_iterator(static_cast<SAO*>(object())->begin());
00342 }
00343
00344 template<class Char, class Traits, class T>
00345 std::basic_ostream<Char,Traits>&
00346 operator <<(std::basic_ostream<Char,Traits>& os,
00347 const SharedArray<T>& x) {
00348 std::basic_ostringstream<Char,Traits> s;
00349 s.copyfmt(os); s.width(0);
00350 s << '{';
00351 if (x.size() > 0) {
00352 s << x[0];
00353 for (int i=1; i<x.size(); i++)
00354 s << ", " << x[i];
00355 }
00356 s << '}';
00357 return os << s.str();
00358 }
00359
00360 }
00361
00362