Changeset 2105 for trunk/source/container_classes.h

Timestamp:

06/10/08 15:01:26 (5 months ago)

Author:

rjrw

Message:

Remove some superfluous template parameters from the inner workings of
multi_arr.

Files:

• trunk/source/container_classes.h (modified) (8 diffs)

trunk/source/container_classes.h

@@ -32 +32 @@
 //! basic_pntr - base class for generalization of normal pointers that enables bounds checking
 //! it comes with the full set of operators that you would expect for a random access pointer
-template<class T, int d, mem_layout ALLOC, bool lgBC>
+template<class T, bool lgBC>
 class basic_pntr
 {
@@ -126 +126 @@
 
 //! pntr - interface class to replace normal pointers
-template<class T, int d, mem_layout ALLOC, bool lgBC>
-class pntr : public basic_pntr<T,d,ALLOC,lgBC>
+template<class T, bool lgBC>
+class pntr : public basic_pntr<T,lgBC>
 {
 public:
         // constructors are not inherited, so define them again
-        pntr( T* p0 ) : basic_pntr<T,d,ALLOC,lgBC>( p0 ) {}
-        pntr( T* p0, T* p1, T* p2 ) : basic_pntr<T,d,ALLOC,lgBC>( p0, p1, p2 ) {}
+        pntr( T* p0 ) : basic_pntr<T,lgBC>( p0 ) {}
+        pntr( T* p0, T* p1, T* p2 ) : basic_pntr<T,lgBC>( p0, p1, p2 ) {}
         pntr() {}
         // the increment / decrement operators need to be recast...
         // otherwise expressions like p = ++q would be illegal for iterators...
-        pntr& operator++ () { return static_cast<pntr&>(basic_pntr<T,d,ALLOC,lgBC>::operator++()); }
+        pntr& operator++ () { return static_cast<pntr&>(basic_pntr<T,lgBC>::operator++()); }
         const pntr operator++ (int) { pntr t = *this; ++(*this); return t; }
-        pntr& operator-- () { return static_cast<pntr&>(basic_pntr<T,d,ALLOC,lgBC>::operator--()); }
+        pntr& operator-- () { return static_cast<pntr&>(basic_pntr<T,lgBC>::operator--()); }
         const pntr operator-- (int) { pntr t = *this; --(*this); return t; }
         // define p+n, p-n, p-q
@@ -147 +147 @@
 
 // this defines n+p
-template<class T, int d, mem_layout ALLOC, bool lgBC>
-inline const pntr<T,d,ALLOC,lgBC> operator+ ( const ptrdiff_t n, const pntr<T,d,ALLOC,lgBC>& t )
-{
-        pntr<T,d,ALLOC,lgBC> s = t;
+template<class T, bool lgBC>
+inline const pntr<T,lgBC> operator+ ( const ptrdiff_t n, const pntr<T,lgBC>& t )
+{
+        pntr<T,lgBC> s = t;
         s += n;
         return s;
@@ -156 +156 @@
 
 //! const_pntr - same as pntr, except that it replaces const pointers rather than normal pointers
-template<class T, int d, mem_layout ALLOC, bool lgBC>
-class const_pntr : public basic_pntr<T,d,ALLOC,lgBC>
+template<class T, bool lgBC>
+class const_pntr : public basic_pntr<T,lgBC>
 {
 public:
         // constructors are not inherited, so define them again
-        const_pntr( T* p0 ) : basic_pntr<T,d,ALLOC,lgBC>( p0 ) {}
-        const_pntr( T* p0, T* p1, T* p2 ) : basic_pntr<T,d,ALLOC,lgBC>( p0, p1, p2 ) {}
+        const_pntr( T* p0 ) : basic_pntr<T,lgBC>( p0 ) {}
+        const_pntr( T* p0, T* p1, T* p2 ) : basic_pntr<T,lgBC>( p0, p1, p2 ) {}
         const_pntr() {}
         // make sure we can assign a pntr to a const_pntr by creating an implicit conversion to const_pntr
-        const_pntr( const pntr<T,d,ALLOC,lgBC>& t ) : basic_pntr<T,d,ALLOC,lgBC>( t ) {}
+        const_pntr( const pntr<T,lgBC>& t ) : basic_pntr<T,lgBC>( t ) {}
         // the increment / decrement operators need to be recast...
         // otherwise expressions like *p++ = 1. would be legal for const_iterators...
-        const_pntr& operator++ () { return static_cast<const_pntr&>(basic_pntr<T,d,ALLOC,lgBC>::operator++()); }
+        const_pntr& operator++ () { return static_cast<const_pntr&>(basic_pntr<T,lgBC>::operator++()); }
         const const_pntr operator++ (int) { const_pntr t = *this; ++(*this); return t; }
-        const_pntr& operator-- () { return static_cast<const_pntr&>(basic_pntr<T,d,ALLOC,lgBC>::operator--()); }
+        const_pntr& operator-- () { return static_cast<const_pntr&>(basic_pntr<T,lgBC>::operator--()); }
         const const_pntr operator-- (int) { const_pntr t = *this; --(*this); return t; }
         const_pntr& operator+= ( const ptrdiff_t n )
         {
-                return static_cast<const_pntr&>(basic_pntr<T,d,ALLOC,lgBC>::operator+=(n));
+                return static_cast<const_pntr&>(basic_pntr<T,lgBC>::operator+=(n));
         }
         const_pntr& operator-= ( const ptrdiff_t n )
         {
-                return static_cast<const_pntr&>(basic_pntr<T,d,ALLOC,lgBC>::operator-=(n));
+                return static_cast<const_pntr&>(basic_pntr<T,lgBC>::operator-=(n));
         }
         // the dereference operators need to be recast...
-        const T& operator* () const { return static_cast<const T&>(basic_pntr<T,d,ALLOC,lgBC>::operator*()); }
-        const T* operator-> () const { return static_cast<const T*>(basic_pntr<T,d,ALLOC,lgBC>::operator->()); }
+        const T& operator* () const { return static_cast<const T&>(basic_pntr<T,lgBC>::operator*()); }
+        const T* operator-> () const { return static_cast<const T*>(basic_pntr<T,lgBC>::operator->()); }
         const T& operator[] ( const ptrdiff_t n ) const
         {
-                return static_cast<const T&>(basic_pntr<T,d,ALLOC,lgBC>::operator[](n));
+                return static_cast<const T&>(basic_pntr<T,lgBC>::operator[](n));
         }
         // define p+n, p-n, p-q
@@ -194 +194 @@
 
 // this defines n+p
-template<class T, int d, mem_layout ALLOC, bool lgBC>
-inline const const_pntr<T,d,ALLOC,lgBC> operator+ ( const ptrdiff_t n, const const_pntr<T,d,ALLOC,lgBC>& t )
-{
-        const_pntr<T,d,ALLOC,lgBC> s = t;
+template<class T, bool lgBC>
+inline const const_pntr<T,lgBC> operator+ ( const ptrdiff_t n, const const_pntr<T,lgBC>& t )
+{
+        const_pntr<T,lgBC> s = t;
         s += n;
         return s;
@@ -921 +921 @@
         typedef size_t       size_type;
         typedef ptrdiff_t    difference_type;
-        typedef pntr<T,d,ALLOC,lgBC>       iterator;
-        typedef const_pntr<T,d,ALLOC,lgBC> const_iterator;
+        typedef pntr<T,lgBC>       iterator;
+        typedef const_pntr<T,lgBC> const_iterator;
 
 private:
@@ -1719 +1719 @@
 
 // on Mac systems these instantiations need to be extern in order to avoid duplicate symbols
-#define INSTANTIATE_MULTI_ARR( TYPE, LAYOUT, BC ) \
-INST_EXTERN template class pntr<TYPE,2,LAYOUT,BC>; \
-INST_EXTERN template class pntr<TYPE,3,LAYOUT,BC>; \
-INST_EXTERN template class pntr<TYPE,4,LAYOUT,BC>; \
-INST_EXTERN template class pntr<TYPE,5,LAYOUT,BC>; \
-INST_EXTERN template class pntr<TYPE,6,LAYOUT,BC>; \
-INST_EXTERN template class const_pntr<TYPE,2,LAYOUT,BC>; \
-INST_EXTERN template class const_pntr<TYPE,3,LAYOUT,BC>; \
-INST_EXTERN template class const_pntr<TYPE,4,LAYOUT,BC>; \
-INST_EXTERN template class const_pntr<TYPE,5,LAYOUT,BC>; \
-INST_EXTERN template class const_pntr<TYPE,6,LAYOUT,BC>
-
-INSTANTIATE_MULTI_ARR( bool, MEM_LAYOUT_VAL, lgBOUNDSCHECKVAL );
-INSTANTIATE_MULTI_ARR( long, MEM_LAYOUT_VAL, lgBOUNDSCHECKVAL );
-INSTANTIATE_MULTI_ARR( realnum, MEM_LAYOUT_VAL, lgBOUNDSCHECKVAL );
-INSTANTIATE_MULTI_ARR( double, MEM_LAYOUT_VAL, lgBOUNDSCHECKVAL );
-INSTANTIATE_MULTI_ARR( double, C_TYPE, lgBOUNDSCHECKVAL );
+#define INSTANTIATE_MULTI_ARR( TYPE, BC ) \
+INST_EXTERN template class pntr<TYPE,BC>; \
+INST_EXTERN template class const_pntr<TYPE,BC>;
+
+INSTANTIATE_MULTI_ARR( bool, lgBOUNDSCHECKVAL );
+INSTANTIATE_MULTI_ARR( long, lgBOUNDSCHECKVAL );
+INSTANTIATE_MULTI_ARR( realnum,lgBOUNDSCHECKVAL );
+INSTANTIATE_MULTI_ARR( double, lgBOUNDSCHECKVAL );
 
 
@@ -1758 +1749 @@
         typedef long         size_type;
         typedef ptrdiff_t    difference_type;
-        typedef pntr<T,1,FLX_TYPE,lgBC>       iterator;
-        typedef const_pntr<T,1,FLX_TYPE,lgBC> const_iterator;
+        typedef pntr<T,lgBC>       iterator;
+        typedef const_pntr<T,lgBC> const_iterator;
 
 private: