/Users/mourrain/Devel/mmx/realroot/include/realroot/Seq.hpp

Go to the documentation of this file.

/*********************************************************************
*   This file is part of the source code of the realroot kernel.       *
*   Author(s): B. Mourrain, GALAAD, INRIA                            *
**********************************************************************
$Id: Seq.hpp,v 1.3 2005/09/28 06:40:51 mourrain Exp $
**********************************************************************/
#ifndef MMX_SEQ_HPP
#define MMX_SEQ_HPP
//----------------------------------------------------------------------
# include <string.h>
# include <vector>
# include <realroot/parser.hpp>
# include <realroot/shared_object.hpp>
# include <realroot/assign.hpp>
# include <realroot/array.hpp>
//----------------------------------------------------------------------

namespace mmx {

// Print operator for std::vector
template<class C>
std::ostream & operator<<(std::ostream & os, const std::vector<C> & V)
{
    return mmx::array::print(os,V);
}

template<class C, class S> struct Seq;

namespace let {
  template<class C,class R, class X, class S>
    void assign(Seq<C,R> & r, const Seq<X,S> & x);
  template<class C,class R, class S>
    void assign(Seq<C,R> & r, const Seq<C,S> & x);
};


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 C                                  value_t;
  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) {using namespace 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) {
      using namespace 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];}
  const value_type &  operator[] (size_type i) const {return rep()[i];}

  const value_type &  front() const { assert(this->size()>0); return rep()[0];}
  self_t & push_back(const C& x)  { rep().push_back(x); return *this; }

  self_t & erase(size_type i)   { 
    //if (i>size_type(-1) && i< this->size() )
      rep().erase(rep().begin()+i);
    return *this; }
  
  self_t & clear()  { rep().clear();
                                        return *this; }

  size_type search(const C& x)  {
                        for (size_type i=0;i< this->size();++i) {
                                        if ( this->rep()[i]== x) 
                                                        return i;
                        }
      //std::cout<<"Seq: "<<x<<" not found"<<std::endl;
                        return (size_type(-1) );  
  }

  bool member(const C& x)  {
                        for (size_type i=0;i< this->size();++i)
                                        if ( this->rep()[i]== x) 
                                                        return true;
      return false;
                        }

    void sort() {
        std::sort( this->rep().begin(), this->rep().end() );
    }

  C min() {
    return *std::min_element( this->rep().begin(), this->rep().end());
  }
  
  C  max() {
    return *std::max_element( this->rep().begin(), this->rep().end());
  }

  template<class Compare>
  void sort(Compare comp) {
   std::sort( this->rep().begin(), this->rep().end(),comp);
  }
  
  template<class Compare>
  C min(Compare comp) {
  return *std::min_element( this->rep().begin(), this->rep().end(),comp);
  }
  
  template<class Compare>
  C  max(Compare comp) {
   return *std::max_element( this->rep().begin(), this->rep().end(),comp);
  }
  
  size_type size() const {return rep().size();}

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

  void   reverse() { std::reverse (rep().begin( ), rep().end( ) );  }
  self_t reversed() const { self_t s(*this); s.reverse(); return s; }

  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> inline 
const C& read(const Seq<C,R>& m, unsigned i) { return m[i]; }

template<class C, class R>
bool eq (const Seq<C,R>& v1, const Seq<C,R>& v2) {return v1==v2;}
template<class C, class R>
bool neq(const Seq<C,R>& v1, const Seq<C,R>& v2) {return v1!=v2;}

template<class C, class R>
unsigned hash (const Seq<C,R>& v) 
{
  register unsigned i, h= 214365, n= v.size();
  for (i=0; i<n; i++)
      h= (h<<1) ^ (h<<5) ^ (h>>27) ^ hash(v[i]);
  return h;
}
template<class C, class R>
unsigned soft_hash (const Seq<C,R>& m) {return hash(m);}

template<class C, class R>
typename Seq<C,R>::const_iterator iterate(const Seq<C,R>& m) {return m.begin();}

//--------------------------------------------------------------------
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>  inline
Seq<C,R>& operator<<(Seq<C,R> & r, const C& x)
{
  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;
}

//======================================================================
template<class C,class R>
Seq<C,R> adds( Seq<C,R> a, const Seq<C,R> & b)
{
  //assert( a.size()==b.size() );
  Seq<C,R> r=a;

  typename Seq<C,R>::const_iterator it2= b.begin();

  for(typename Seq<C,R>::iterator it=r.begin();it!= r.end();++it)
    {
      *it += *it2;
      ++it2;
    }

  return r;
}


//======================================================================
template<class C,class R>
Seq<C,R> mul( C  b,  Seq<C,R> a)
{
  Seq<C,R> r=a;
  for(typename Seq<C,R>::iterator it=r.begin();it!= r.end();++it)
    *it= b * *it ;
  return r;
}

//======================================================================
template<class C,class R>
Seq<C,R> operator/(  Seq<C,R>  a, const C  b)
{
  Seq<C,R> r=a;
  for(typename Seq<C,R>::iterator it=r.begin();it!= r.end();++it)
    *it= *it / b;
  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, class X, class S>
  void assign(Seq<C,R> & r, const Seq<X,S> & x)
  {
    r = Seq<C,R>();
    for(typename Seq<X,S>::const_iterator it=x.begin();it!= x.end();++it)
      {
        C tmp;
        assign(tmp,*it);
        r.push_back(tmp);
      };
  }

}
//----------------------------------------------------------------------
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);
    }
  }
}
//--------------------------------------------------------------------

struct ShapeForeachContainerBase {};

template <typename T> class ShapeForeachContainer : public ShapeForeachContainerBase {
public:
    inline ShapeForeachContainer(const T& t): c(t), brk(0), i(c.begin()), e(c.end()) {} ;
    const T c ;
    mutable int brk ;
    mutable typename T::const_iterator i, e ;
    inline bool condition() const { 
        return (!brk++ && i != e) ; 
    }
} ;

template <typename T> inline T *qForeachpointer(const T &) { 
    return 0 ; 
}

template <typename T> inline ShapeForeachContainer<T> qForeachContainerNew(const T& t) {
    return ShapeForeachContainer<T>(t) ; 
}

template <typename T> inline const ShapeForeachContainer<T> *qForeachContainer(const ShapeForeachContainerBase *base, const T *) { 
    return static_cast<const ShapeForeachContainer<T> *>(base) ;
}
 # ifndef Shape_FOREACH 
 # define Shape_FOREACH(variable, container) \
     for (const ShapeForeachContainerBase &_container_ = qForeachContainerNew(container); \
          qForeachContainer(&_container_, true ? 0 : qForeachpointer(container))->condition(); \
          ++qForeachContainer(&_container_, true ? 0 : qForeachpointer(container))->i) \
         for (variable = *qForeachContainer(&_container_, true ? 0 : qForeachpointer(container))->i; \
              qForeachContainer(&_container_, true ? 0 : qForeachpointer(container))->brk; \
              --qForeachContainer(&_container_, true ? 0 : qForeachpointer(container))->brk) 

// !conflicts with Shapet's "foreach"
//# define ShapeT_NO_KEYWORDS
#ifndef foreach
# define foreach Shape_FOREACH
#endif
#endif

//====================================================================
} //namespace mmx
/********************************************************************/
#endif // MMX_SEQ_HPP