00001
00002
00003
00004
00005
00006
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