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 <algorithm>
# 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() );
  }

  void insert(const size_type& i, const C& c) {
    this->rep().insert(this->rep().begin()+i, c);
  }
  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); }

  C back() const { return rep().back(); }
  void pop_back() { rep().pop_back(); }

  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) 
{
  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);
    }
  }
}
//--------------------------------------------------------------------
} //namespace mmx
//--------------------------------------------------------------------
#ifndef MMX_FOREACH
struct MmxForeachContainerBase {};

template <typename T> class MmxForeachContainer : public MmxForeachContainerBase {
public:
    inline MmxForeachContainer(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 * mmxForeachpointer(const T &) {
    return 0 ;
}

template <typename T>
inline MmxForeachContainer<T>
mmxForeachContainerNew(const T& t) {
    return MmxForeachContainer<T>(t) ;
}

template <typename T> inline const MmxForeachContainer<T> *mmxForeachContainer(const MmxForeachContainerBase *base, const T *) {
    return static_cast<const MmxForeachContainer<T> *>(base) ;
}

# define MMX_FOREACH(variable, container) \
     if(0) {} else for (const MmxForeachContainerBase & _container_ = mmxForeachContainerNew(container); \
          mmxForeachContainer(&_container_, true ? 0 : mmxForeachpointer(container))->condition(); \
          ++mmxForeachContainer(&_container_, true ? 0 : mmxForeachpointer(container))->i) \
         for (variable = *mmxForeachContainer(&_container_, true ? 0 : mmxForeachpointer(container))->i; \
              mmxForeachContainer(&_container_, true ? 0 : mmxForeachpointer(container))->brk; \
              --mmxForeachContainer(&_container_, true ? 0 : mmxForeachpointer(container))->brk)

# endif

#ifndef foreach
# define foreach MMX_FOREACH
#endif

//====================================================================
#endif // MMX_SEQ_HPP