[Toon-members] TooN/internal vbase.hh vector.hh

[Tom Drummond]

CVSROOT:        /cvsroot/toon
Module name:    TooN
Changes by:     Tom Drummond <twd20>    09/03/04 14:46:44

Modified files:
        internal       : vbase.hh vector.hh 

Log message:
        inserted Layout delegate

CVSWeb URLs:
http://cvs.savannah.gnu.org/viewcvs/TooN/internal/vbase.hh?cvsroot=toon&r1=1.13&r2=1.14
http://cvs.savannah.gnu.org/viewcvs/TooN/internal/vector.hh?cvsroot=toon&r1=1.16&r2=1.17

Patches:
Index: vbase.hh
===================================================================
RCS file: /cvsroot/toon/TooN/internal/vbase.hh,v
retrieving revision 1.13
retrieving revision 1.14
diff -u -b -r1.13 -r1.14
--- vbase.hh    4 Mar 2009 13:31:24 -0000       1.13
+++ vbase.hh    4 Mar 2009 14:46:43 -0000       1.14
@@ -8,16 +8,23 @@
 // Slice holding class
 //
 
-template<int Size, int Stride, class Precision> struct SliceVBase: public 
GenericVBase<Size, Precision, Stride, VectorSlice<Size, Precision> >{
+template<int Stride>
+struct SliceVBase {
        
+       // this class is really just a typedef
+       template<int Size, typename Precision>
+       struct Layout
+               : public GenericVBase<Size, Precision, Stride, 
VectorSlice<Size, Precision> > {
 
-       SliceVBase(Precision* d, int stride)
+
+               Layout(Precision* d, int stride)
        :GenericVBase<Size, Precision, Stride, VectorSlice<Size, Precision> 
>(d, stride){
        }
 
-       SliceVBase(Precision* d, int length, int stride)
+               Layout(Precision* d, int length, int stride)
        :GenericVBase<Size, Precision, Stride, VectorSlice<Size, Precision> 
>(d, length, stride){
        }
+       };
 
 };
 
@@ -26,16 +33,19 @@
 // Classes for Vectors owning memory
 //
 
-// this class is really just a typedef
-template<int Size, class Precision> struct VBase : public GenericVBase<Size, 
Precision, 1, VectorAlloc<Size, Precision> >{
-       //Optional 
+struct VBase {
+
+       // this class is really just a typedef
+       template<int Size, class Precision>
+       struct Layout 
+               : public GenericVBase<Size, Precision, 1, VectorAlloc<Size, 
Precision> > {
        
        VBase(){}
 
        VBase(int s)
        :GenericVBase<Size, Precision, 1, VectorAlloc<Size, Precision> >(s)
-       {
-       }
+               {}
+       };
 };
 
 
////////////////////////////////////////////////////////////////////////////////
@@ -81,23 +91,23 @@
        template<int Start, int Length> 
        Vector<Length, Precision, SliceVBase<Length, Stride, Precision> > 
slice(){
                Internal::CheckStaticSlice<Size, Start, Length>::check(size());
-               return Vector<Length, Precision, SliceVBase<Length, Stride, 
Precision> >(my_data + stride()*Start, stride(), Slicing());
+               return Vector<Length, Precision, SliceVBase<Stride> >(my_data + 
stride()*Start, stride(), Slicing());
        }
 
        template<int Start, int Length> 
        const Vector<Length, Precision, SliceVBase<Length, Stride, Precision> > 
slice() const {
                Internal::CheckStaticSlice<Size, Start, Length>::check(size());
-               return Vector<Length, Precision, SliceVBase<Length, Stride, 
Precision> >(const_cast<Precision*>(my_data + stride()*Start), stride(), 
Slicing());
+               return Vector<Length, Precision, SliceVBase<Stride> 
>(const_cast<Precision*>(my_data + stride()*Start), stride(), Slicing());
        }
 
        Vector<-1, Precision, SliceVBase<-1, Stride, Precision> > slice(int 
start, int length){
                Internal::CheckDynamicSlice::check(size(), start, length);
-               return Vector<-1, Precision, SliceVBase<-1, Stride, Precision> 
>(my_data + stride()*start, length, stride(), Slicing());
+               return Vector<-1, Precision, SliceVBase<Stride> >(my_data + 
stride()*start, length, stride(), Slicing());
        }
 
        const Vector<-1, Precision, SliceVBase<-1, Stride, Precision> > 
slice(int start, int length) const {
                Internal::CheckDynamicSlice::check(size(), start, length);
-               return Vector<-1, Precision, SliceVBase<-1, Stride, Precision> 
>(const_cast<Precision*>(my_data + stride()*start), length, stride(), 
Slicing());
+               return Vector<-1, Precision, SliceVBase<Stride> 
>(const_cast<Precision*>(my_data + stride()*start), length, stride(), 
Slicing());
        }
 
        const Matrix<1, Size, Precision, typename Slice<Stride>::ColMajor> 
as_row() const{

Index: vector.hh
===================================================================
RCS file: /cvsroot/toon/TooN/internal/vector.hh,v
retrieving revision 1.16
retrieving revision 1.17
diff -u -b -r1.16 -r1.17
--- vector.hh   18 Feb 2009 16:49:09 -0000      1.16
+++ vector.hh   4 Mar 2009 14:46:43 -0000       1.17
@@ -1,28 +1,28 @@
 //-*- c++ -*-
-template<int Size=-1, typename Precision=double, typename Base=VBase<Size, 
Precision> >
-class Vector : public Base {
+template<int Size=-1, typename Precision=double, typename Base=VBase>
+class Vector : public Base::Layout<Size,Precision> {
 public:
   // sneaky hack: only one of these constructors will work with any given base
   // class but they don't generate errors unless the user tries to use one of 
them
   // although the error message may be less than helpful - maybe this can be 
changed?
   inline Vector(){}
-  inline Vector(Precision* data) : Base (data) {}
-  inline Vector(int size_in) : Base(size_in) {}
-  inline Vector(Precision* data_in, int size_in, int stride_in, Slicing) : 
Base(data_in, size_in, stride_in) {}
-  inline Vector(Precision* data_in, int stride_in, Slicing) : Base(data_in, 
stride_in) {}
+       inline Vector(Precision* data) : Base::Layout (data) {}
+       inline Vector(int size_in) : Base::Layout(size_in) {}
+       inline Vector(Precision* data_in, int size_in, int stride_in, Slicing) 
: Base::Layout(data_in, size_in, stride_in) {}
+       inline Vector(Precision* data_in, int stride_in, Slicing) : 
Base::Layout(data_in, stride_in) {}
 
 
   // constructors to allow return value optimisations
   // construction from 1-ary operator
   template <class T, class Op>
-  inline Vector(const T& arg, const Operator<Op>&, int size) : Base(size) {
+       inline Vector(const T& arg, const Operator<Op>&, int size) : 
Base::Layout(size) {
     Op::eval(*this,arg);
   }
 
   // constructor from 2-ary operator
   template <class LHS, class RHS, class Op>
   inline Vector(const LHS& lhs, const RHS& rhs, const Operator<Op>&, int size)
-    : Base(size) {
+               : Base::Layout(size) {
     Op::eval(*this,lhs,rhs);
   }
 
@@ -38,7 +38,7 @@
   // constructor from arbitrary vector
   template<int Size2, typename Precision2, typename Base2>
   inline Vector(const Vector<Size2,Precision2,Base2>& from):
-    Base(from.size()) {
+               Base::Layout(from.size()) {
     operator=(from);
   }