synaps/base/seq1d.h

00001 /*********************************************************************
00002 *      This file is part of the source code of SYNAPS kernel.        *
00003 *   Author(s): B. Mourrain, GALAAD, INRIA                            *
00004 **********************************************************************
00005 History:
00006 $Id: seq1d.h,v 1.2 2005/08/29 14:30:18 mourrain Exp $
00007 *********************************************************************/
00008 #ifndef SYNAPS_UTIL_SEQ1D_H
00009 #define SYNAPS_UTIL_SEQ1D_H
00010 
00011 #include <iterator>
00012 #include <synaps/init.h>
00013 #include <synaps/base/type.h>
00014 #include <synaps/base/shared_object.h>
00015 #include <synaps/base/create_iterator.h>
00016 
00017 
00018 __BEGIN_NAMESPACE_SYNAPS
00019 
00021 template <class C, class I,class N=unsigned int>
00022 struct seq1d {
00023 
00024   typedef C            value_type;
00025   typedef N            size_type;
00026   typedef I            iterator;
00027   typedef iterator     const_iterator;
00028   typedef std::reverse_iterator<const_iterator>  const_reverse_iterator;
00029   typedef std::reverse_iterator<iterator>        reverse_iterator;
00030 
00031   size_type size_;
00032   iterator  begin_, end_;
00033 
00034   seq1d() : size_(0), begin_(), end_() {}
00035   seq1d(const seq1d<C,I,N> & v):
00036     size_(v.size_), begin_(v.begin_), end_(v.end_){}
00037   seq1d(size_type n,  iterator b, iterator e):
00038     size_(n), begin_(b), end_(e){};
00039 
00040   void reserve(size_type n) {
00041     if(n >size_){
00042       C* tmp= new C[n];
00043       size_=n;
00044       begin_= create(I(),tmp,0);
00045       end_  = create(I(),tmp,n);
00046     }else{
00047       size_=n;end_=begin_+n;
00048     }
00049   }
00050   void resize(size_type n) {}
00051 
00052   seq1d<C,I,N> & operator=(const seq1d<C,I,N> & v)
00053     {
00054       size_=v.size_;begin_=v.begin_;end_ =v.end_; return *this;
00055     }
00056 
00057   size_type size() const {return size_;}
00058 
00059   iterator        begin()        { return begin_; }
00060   iterator        begin() const  { return begin_; }
00061 
00062   iterator        end()        { return end_; }
00063   iterator        end() const  { return end_; }
00064 
00065   reverse_iterator       rbegin()       {return reverse_iterator(end_); }
00066   const_reverse_iterator rbegin() const {return const_reverse_iterator(end_);}
00067 
00068   reverse_iterator       rend()       {return reverse_iterator(begin_); }
00069   const_reverse_iterator rend() const {return const_reverse_iterator(begin_);}
00070 
00071   inline       C & operator[] (size_type i)       {return *(begin_+i);}
00072   inline const C & operator[] (size_type i) const {return *(begin_+i);}
00073 };
00074 //----------------------------------------------------------------------
00075 template<class C, class I,class N>
00076 I create(I s,
00077          const seq1d<C,I,N> & a, unsigned int i)
00078 {
00079   return a.begin()+i;
00080 }
00081 //----------------------------------------------------------------------
00082 namespace let 
00083 {
00084   template<class C, class I,class N>
00085   void assign(shared_object<seq1d<C,I,N> > & a,  
00086               const shared_object<seq1d<C,I,N> > & b)
00087   {
00088 
00089     a->resize( b->size() );
00090     typename seq1d<C,I,N>::iterator ia=a->begin(),ea=a->end();
00091     typename seq1d<C,I,N>::const_iterator ib=b->begin();
00092     for ( ; ia != ea; ia ++, ib++  ) assign(*ia,*ib);
00093   }
00094 }
00095 
00096 namespace type 
00097 {
00098   template<class X, class I, class N, class Y>
00099   struct instanceof< seq1d<X,I,N>, Y >
00100   {
00101     typedef seq1d< Y, I, N > T;
00102   };
00103 };
00104 
00105 
00106 //======================================================================
00107 __END_NAMESPACE_SYNAPS
00108 #endif // SYNAPS_UTIL_SEQ1D_H
00109 

SYNAPS DOCUMENTATION
logo