fixarray.h

Go to the documentation of this file.
00001 #ifndef __fixarray_h
00002 #define __fixarray_h
00003 
00004 #include  <stdlib.h> 
00005 #include  <iostream> 
00006 #include  <iterator> 
00007 #include  <algorithm> 
00008 
00009 /*-------------------------------------------------*/
00010 
00011 namespace Gascoigne
00012 {
00013 template<int N, class T>
00014 class fixarray
00015 {
00016 
00017 public:
00018 
00019   typedef  T*        iterator;
00020   typedef  const T*  const_iterator;
00021   
00022  protected:
00023   
00024   T  val[N];
00025   
00026   void array_copy(const_iterator q)
00027     {
00028       iterator       p(begin());
00029       const_iterator pe(end());
00030       while(p!=pe)  *p++ = *q++;
00031     }
00032   
00033  public:
00034   
00035   fixarray<N,T>()      { BasicInit(T());}
00036   fixarray<N,T>(const T& d) { BasicInit(d);}
00037   fixarray<N,T>(const fixarray<N,T>& v)
00038     {
00039       BasicInit(T());
00040       array_copy(v.begin());
00041       //copy(v.begin(),v.end(),begin());
00042     }
00043   fixarray(const_iterator b)
00044     {
00045       BasicInit(T());
00046       array_copy(b);
00047     }
00048   
00049   virtual ~fixarray()
00050     {
00051 //       Destroy(begin(),end());
00052     }
00053   
00054   void BasicInit(const T& d)
00055     {
00056       // Braucht man das wirklich ???
00057 //       for(int i=0;i<N;i++)  construct(&(val[i]),d);
00058       for(int i=0;i<N;i++)  val[i]=d;
00059     }
00060   
00061   const T*  begin() const { return &(val[0]);}
00062   const T*  end  () const { return &(val[0])+N;}
00063   T*        begin()       { return &(val[0]);}
00064   T*        end  ()       { return &(val[0])+N;}
00065   
00066   size_t   size()            const { return N;}
00067   const T& operator[](int i) const { return val[i];}
00068   T&       operator[](int i)       { return val[i];}
00069   
00070   fixarray<N,T>& operator=(const T& d) 
00071     {
00072       iterator  p(end());
00073       while(p>begin()) *--p = d;
00074       return *this;
00075     } 
00076   
00077   fixarray<N,T>& operator=(const fixarray<N,T>& v) 
00078     {
00079       iterator        p(begin());
00080       const_iterator  q(v.begin());
00081       while(p<end()) *p++ = *q++;
00082       return *this;
00083     } 
00084   
00085   bool operator<(const fixarray<N,T>& v) const
00086     {
00087       const_iterator  p(  begin());
00088       const_iterator  q(v.begin());
00089       while(p<end())
00090         {
00091           if (*p<*q) return 1;
00092           if (*q<*p) return 0;
00093           p++; q++;
00094         }
00095       return 0;
00096     }
00097   bool operator!=(const fixarray<N,T>& v) const
00098     {
00099       const_iterator  p(  begin());
00100       const_iterator  q(v.begin());
00101       while(p<end())
00102         {
00103           if (*p!=*q) return 1;
00104           p++; q++;
00105         }
00106       return 0;
00107     }
00108   
00109     
00110   std::ostream& put(std::ostream &s) const
00111     {
00112       copy(begin(),end(),std::ostream_iterator<T>(s," "));
00113       return s;
00114     }  
00115   
00116   std::istream& get(std::istream &s)
00117     {
00118     typename fixarray<N,T>::iterator p;
00119     for(p = begin();p!=end();p++) s >> *p;
00120       return s;
00121     }
00122   
00123   void read_data(std::istream& s)
00124     {
00125       size_t n;
00126       s >> n;
00127       if(size()!=n) 
00128         {
00129           std::cerr << "read_data(): wrong size in fixarray" << N << " " << n << std::endl;
00130           exit(1);
00131         }
00132       s >> *this;
00133     }
00134   
00135   void write_data(std::ostream& s) const
00136     {
00137       s << size() << std::endl;
00138       s << *this;
00139     }
00140 
00141   void BinWrite(std::ostream &s) const
00142   {
00143     int sizeT = sizeof(T);
00144     for (int i=0; i<N; i++)
00145     {
00146       s.write(reinterpret_cast<const char*>(&(operator[](i))),sizeT);
00147     }
00148   }
00149 
00150   void BinRead(std::istream &s)
00151   {
00152     int sizeT = sizeof(T);
00153     for (int i=0; i<N; i++)
00154     {
00155       s.read(reinterpret_cast<char*>(&(operator[](i))),sizeT);
00156     }
00157   }
00158 };
00159 
00160 /*-------------------------------------------------*/
00161 
00162 template<int N, class T>
00163 bool operator==(const fixarray<N,T>& x, const fixarray<N,T>& y) 
00164 {
00165   return std::equal(x.begin(), x.end(), y.begin());
00166 }
00167 
00168 /*-------------------------------------------------*/
00169 
00170 class fixarrayHash
00171 {
00172  public:
00173   template<int N, class T>
00174     int operator()(const fixarray<N,T>& h) const { return static_cast<int>(h[0]);}
00175 };
00176 
00177 template<int N,class T>
00178 std::ostream& operator<<(std::ostream &s, const fixarray<N,T>& A);
00179 template<int N,class T>
00180 std::istream& operator>>(std::istream &s, fixarray<N,T>& A);
00181 }
00182 
00183 
00184 #endif
00185 
00186 

Generated on Thu Sep 14 10:34:35 2006 for Gascoigne by  doxygen 1.4.7