synaps/base/Seq.h

/*********************************************************************
*   This file is part of the source code of the SYNAPS kernel.       *
*   Author(s): B. Mourrain, GALAAD, INRIA                            *
**********************************************************************
$Id: Seq.h,v 1.3 2005/09/28 06:40:51 mourrain Exp $
**********************************************************************/
#ifndef SYNAPS_UTIL_SEQ_H
#define SYNAPS_UTIL_SEQ_H
//----------------------------------------------------------------------
#include <synaps/init.h>
#include <vector>
#include <synaps/base/parser.h>
#include <synaps/base/Range.h>
#include <synaps/base/seq1d.h>
#include <synaps/base/shared_object.h>
#include <synaps/arithm/let.h>
//----------------------------------------------------------------------

__BEGIN_NAMESPACE_SYNAPS

template <class C, class R=std::vector<C> >
struct Seq {

  shared_object<R>  data;
  R &       rep()       {return (*data);}
  const R & rep() const {return (*data);}

  typedef typename R::size_type              size_type;
  typedef C                                  value_type;
  typedef typename R::iterator               iterator;
  typedef typename R::const_iterator         const_iterator;
  typedef typename R::reverse_iterator       reverse_iterator;
  typedef typename R::const_reverse_iterator const_reverse_iterator;
  typedef Seq<C,R>                           self_t;

  Seq(): data() {}
  Seq(const R & r):data(r){}
  Seq(size_type s) {rep().resize(s);}
  Seq(size_type s, value_type* t) {rep()=R(t,t+s);}
  Seq(iterator b,iterator e) {rep()=R(b,e);}
  Seq(size_type m, const char * str);
  Seq(char* str);

  // Copy constructor
  Seq(const self_t & r): data(r.data) {}
  template<class X, class S>
  Seq(const Seq<X,S> & P) {let::assign(*this,P);}

  iterator               begin()        {return rep().begin();}
  iterator               end()          {return rep().end();}
  const_iterator         begin()  const {return rep().begin();}
  const_iterator         end()    const {return rep().end();}
  reverse_iterator       rbegin()       {return rep.rbegin();}
  reverse_iterator       rend()         {return rep.rend();}
  const_reverse_iterator rbegin() const {return rep.rbegin();}
  const_reverse_iterator rend  () const {return rep.rbegin();}

  // Assignement
  self_t & operator=(const self_t & V){data=V.data; return *this;}
  template<class X, class S>
  self_t & operator=(const Seq<X,S> & V) {let::assign(*this,V); return *this;}
  //self_t & operator=(const Seq<X,S> & V) {assign(*this,V); return *this;}

  value_type & operator[] (size_type i)       {return rep()[i];}
  value_type   operator[] (size_type i) const {return rep()[i];}

  Seq<value_type, seq1d<value_type,iterator> > operator[](const Range & I)
    {
      typedef seq1d<value_type,iterator>  rep_type;
      return Seq<value_type, rep_type>
        (rep_type(I.i2-I.i1+1,begin()+I.i1,begin()+I.i2+1));
    };

  self_t & push_back(const C& x)  { rep().push_back(x); return *this; }

  size_type size() const {return rep().size();}


  bool  empty()  const {return (rep().size()==0);}
  void resize(size_type i) { rep().resize(i); }

  self_t operator,(const self_t & x) const;

  self_t operator,(const C & x) const;

  self_t operator << (const self_t & s)
  {
    for(const_iterator it=s.begin(); it!=s.end();++it) 
      this->push_back(*it);
    return *this;
  }

  ~Seq () {}

};
//--------------------------------------------------------------------
template<class C, class R>
Seq<C,R> Seq<C,R>::operator,(const Seq<C,R> & x) const
{
  self_t r(rep());
  for(const_iterator it=x.begin(); it!=x.end();++it)
    r.push_back(*it);
  return r;
}
//--------------------------------------------------------------------
template<class C, class R>
Seq<C,R> Seq<C,R>::operator,(const C & x) const
{
  self_t r(rep());
  r.push_back(x);
  return r;
}
//--------------------------------------------------------------------
template <class C, class R>
bool operator==(const Seq<C,R>& a, const Seq<C,R>& b)
   {return a.rep()==b.rep();}
template <class C, class R>
bool operator!=(const Seq<C,R>& a, const Seq<C,R>& b) {return !(a==b);}
//======================================================================
// INPUT OUTPUT
//======================================================================
template<class C, class R>
std::ostream & operator<<(std::ostream & os, const Seq<C,R> & s)
{
  if(s.size()){
    typename Seq<C,R>::const_iterator it=s.begin(); os<<*it; ++it;
    for( ;it!= s.end();++it) os <<", "<<*it;
  }
  return os;
}
//----------------------------------------------------------------------
template<class C,class R>  inline
std::istream & operator>>(std::istream & is, Seq<C,R> & V)
{
   typedef typename R::size_type size_type;
   size_type s;
   is >> s;
   V.rep().resize(s);
   for(size_type i=0; i< s; ++i) is >> V[i];
   return(is);
}
//======================================================================
template<class C,class R>
Seq<C,R> operator+(Seq<C,R> a, const Seq<C,R> & b)
{
  Seq<C,R> r=a;
  for(typename Seq<C,R>::const_iterator it=b.begin();it!= b.end();++it)
      r.push_back(*it);
  return r;
}

//======================================================================
namespace let {
  template<class C,class R, class S>
  void assign(Seq<C,R> & r, const Seq<C,S> & x)
  {
    r = Seq<C,R>();
    for(typename Seq<C,S>::const_iterator it=x.begin();it!= x.end();++it)
      r.push_back(*it);
  }
}
//----------------------------------------------------------------------
template <class C,class R>
Seq<C,R>::Seq (char * s): data()
{
  rep().resize(0);
  synaps_input = s;
  synaps_inputptr = synaps_input;
  synaps_inputlim = s + strlen(s);
  C term;
  bool shift = true;
  int Ask;

  for (;;) {
    Ask = yylex();
    if (shift && Ask == BLIST) {
      shift = false ;
    }
    else if (Ask == ELIST) {
      break;
    }
    else {
      let::assign(term,yylval);
      this->push_back(term);
    }
  }
}

//--------------------------------------------------------------------
__END_NAMESPACE_SYNAPS
/********************************************************************/
#endif // SYNAPS_BASE_SEQ_H