toolbox/sequence.hh

Go to the documentation of this file.

/* Sequence of elements, like array, based on std::vector with
   operations, output operator, and method of the particular element
   types.
 */

#ifndef sequence_hh
#define sequence_hh

#include <vector>
#include <algorithm>
#include <set>
#include <stdarg.h>
#include <basics/outputOperator.hh>
#include <basics/exceptions.hh>
#include <basics/pointerOutput.hh>

#define SeqInput_D 0

namespace concepts {

  // forward declaration
  template<class F>
  class BaseSequence;

  // ************************************************************** Sequence **

  template<class F>
  class Sequence : public BaseSequence<F> {
  public:
    Sequence() : BaseSequence<F>() {}

    template<class G>
    Sequence(const G& seq) : BaseSequence<F>(seq) {}
    virtual ~Sequence() {}
  };

  template<>
  class Sequence<bool>;


 // *********************************************************** BaseSequence **

  template<class F>
  class BaseSequence : public std::vector<F>, public concepts::OutputOperator {
  public:
    BaseSequence() : std::vector<F>() {}
    BaseSequence(const std::string& str);

    template<class G>
    BaseSequence(const G& seq) 
      : std::vector<F>(seq) {}
    virtual ~BaseSequence() {}

    inline operator Sequence<F>() const { return *this; }

    inline operator std::set<F>() const {
      std::set<F> set;
      for(typename std::vector<F>::
      const_iterator i = this->begin(); i != this->end(); ++i)
  set.insert(*i);
      return set;
    }

    template<class G, class H>
    inline Sequence<G> operator()(G (H::*fun)() const) const;
    template<class G, class H>
    inline Sequence<G*> operator()(G& (H::*fun)() const) const;
    template<class G, class H, class I, class J>
    inline Sequence<G> operator()(G (H::*fun)(I) const, J i) const;

    // Return set union
    inline std::vector<bool> operator||(const Sequence<F>& set) const;
    // Return set intersection
    inline std::vector<bool> operator&&(const Sequence<F>& set) const;


    // Return a sequence with appended \c seq
    inline Sequence<F> operator+(const Sequence<F>& seq) const;
    // Return sequence, where are elements of \c set are not inside
    inline Sequence<F> operator-(const F& val) const;
    // Return sequence, where are elements of \c set are not inside
    inline Sequence<F> operator-(const Sequence<F>& set) const; 
    inline std::vector<bool> operator==(const F val) const;
    inline Sequence<F> operator()(const BaseSequence<bool>& seq) const;

    inline bool exist(F val) const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  };

  template<class F>
  void operator>>(std::istream& is, BaseSequence<F>& seq) {
    F val;
    while(!is.eof()) {
      is >> val;
      DEBUGL(SeqInput_D, "val = " << val);
      if (!is.fail())
  seq.push_back(val);
    }
  }

  template<class F>
  BaseSequence<F>::BaseSequence(const std::string& str) {
    if (str.size() > 0) {
      std::stringstream s;
      s << str;
      s >> *this;
    }
  }

  // e.g. concepts::Key::key()
  template<class F>
  template<class G, class H>
  Sequence<G> BaseSequence<F>::operator()(G (H::*fun)() const) const {
    std::vector<G> seq;
    for(typename std::vector<F>::
    const_iterator i = this->begin(); i != this->end(); ++i) {
      G val = ((*i)->*fun)();
      seq.push_back(val);
    }
    return seq;
  }
  // e.g. concepts::Connector1::key()
  template<class F>
  template<class G, class H>
  Sequence<G*> BaseSequence<F>::operator()(G& (H::*fun)() const) const {
    std::vector<G*> seq;
    for(typename std::vector<F>::
    const_iterator i = this->begin(); i != this->end();++i) {
      G* val = &((*i)->*fun)();
      seq.push_back(val);
    }
    return seq;
  }
  // e.g. concepts::Connector1::vertex(uint i)
  template<class F>
  template<class G, class H, class I, class J>
  Sequence<G> BaseSequence<F>::operator()(G (H::*fun)(I) const, J i) const {
    std::vector<G> seq;
    for(typename std::vector<F>::
    const_iterator is = this->begin(); is != this->end();++is) {
      G val = ((*is)->*fun)(i);
      seq.push_back(val);
    }
    return seq;
  }

  template<class F>
  std::vector<bool> BaseSequence<F>::operator||(const Sequence<F>& seq) const 
  {
    conceptsAssert(this->size() == seq.size(), Assertion());
    std::vector<bool> result(this->size(), false);

    std::vector<bool>::iterator i = result.begin();
    typename std::vector<F>::
      const_iterator it = this->begin(), is = seq.begin();
    for(; it != this->end(); ++it, ++is, ++i) 
      *i = *it || *is;
    return result;
  }

  template<class F>
  std::vector<bool> BaseSequence<F>::operator&&(const Sequence<F>& seq) const 
  {
    conceptsAssert(this->size() == seq.size(), Assertion());
    std::vector<bool> result(this->size(), false);

    std::vector<bool>::iterator i = result.begin();
    typename std::vector<F>::
      const_iterator it = this->begin(), is = seq.begin();
    for(; it != this->end(); ++it, ++is, ++i) 
      *i = *it && *is;
    return result;
  }

  template<class F>
  Sequence<F> BaseSequence<F>::operator-(const Sequence<F>& seq) const {
    std::set<F> set = seq;
    std::vector<F> result;
    result.reserve(this->size());
    for(typename std::vector<F>::
    const_iterator i = this->begin(); i != this->end(); ++i)
      if (set.find(*i) == set.end()) result.push_back(*i);
    return result;
  }

  template<class F>
  Sequence<F> BaseSequence<F>::operator-(const F& val) const {
    std::vector<F> result;
    result.reserve(this->size());
    for(typename std::vector<F>::
    const_iterator i = this->begin(); i != this->end(); ++i)
      if (!(*i == val)) result.push_back(*i);
    return result;    
  }

  template<class F>
  Sequence<F> BaseSequence<F>::operator+(const Sequence<F>& seq) const {
    std::vector<F> result(this->size() + seq.size());
    typename std::vector<F>::iterator i = result.begin();
    typename std::vector<F>::
      const_iterator it = this->begin(), is = seq.begin();
    for(; it != this->end(); ++it, ++i) *i = *it;
    for(; is != seq.end(); ++is, ++i) *i = *is;
    return result;
  }

  template<class F>
  std::vector<bool> BaseSequence<F>::operator==(const F val) const {
    std::vector<bool> result(this->size());
//     uint i = 0;
//     for(typename std::vector<F>::
//    const_iterator is = this->begin(); is != this->end(); ++is, ++i)
//       if (*is == val) result.push_back(i);
    std::vector<bool>::iterator i = result.begin();
    for(typename std::vector<F>::
    const_iterator it = this->begin(); it != this->end(); ++it, ++i)
      *i = *it == val;
    return result;
  }

//   template<class F>
//   Sequence<F> BaseSequence<F>::operator()(const Sequence<uint>& seq) const {
//     std::vector<F> result(seq.size());
//     std::vector<uint> sortedIdx = seq;
//     sort(sortedIdx.begin(), sortedIdx.end());
//     sortedIdx.erase(unique(sortedIdx.begin(), sortedIdx.end()), 
//        sortedIdx.end());

//     uint i = 0;
//     std::vector<uint>::const_iterator is = sortedIdx.begin();
//     typename std::vector<F>::const_iterator it = this->begin();
//     typename std::vector<F>::iterator ir = result.begin();
//     while(is != sortedIdx.end() && it != this->end()) {
//       if (i == *is) {
//  *ir = *it;
//  ++ir;
//  ++is;
//       }
//       ++it; ++i;
//     }
//     conceptsAssert(is == sortedIdx.end(), Assertion());
//     return result;
//   }

  template<class F>
  Sequence<F> BaseSequence<F>::operator()(const BaseSequence<bool>& seq) const {
    conceptsAssert(this->size() == seq.size(), Assertion());

    std::vector<F> result(count(seq.begin(), seq.end(), true));
    if (result.size() > 0) {
      std::vector<bool>::const_iterator is = seq.begin();
      typename std::vector<F>::const_iterator it = this->begin();
      typename std::vector<F>::iterator i = result.begin();
      for(; it != this->end(); ++it, ++is)
        if (*is) {
          *i = *it;
          ++i;
        }
    }
    return result;
  }

  template<class F>
    bool BaseSequence<F>::exist(F val) const {
      return this->find(val) != this->end();
    }

  template<class F>
    std::ostream& BaseSequence<F>::info(std::ostream& os) const {
      os << "Sequence(";
      for(typename std::vector<F>::
          const_iterator i = this->begin(); i != this->end();) {
        pointerOutput(os, *i);
        if (++i != this->end()) os << ", ";
      }
      return os << ")";
    }

  // ******************************************************** Sequence<bool> **

  template<>
    class Sequence<bool> : public BaseSequence<bool> {
      public:
        Sequence() : BaseSequence<bool>() {}
        template<class F>
          Sequence(const F& seq) : BaseSequence<bool>(seq) {}
        virtual ~Sequence() {}

        Sequence<bool> operator&(const Sequence<bool>& seq) const;
        Sequence<bool> operator|(const Sequence<bool>& seq) const;
        Sequence<bool> operator~() const;
    };

  // ************************************************************ makeSequence **

  template<class F>
  Sequence<F> makeSequence(uint n, const F& first, ...) {
    Sequence<F> data(n);
    data[0] = first;

    va_list param;
    va_start(param, first);
    for(uint i = 1; i < n; ++i)
      data[i] = va_arg(param, F);
    va_end(param);  
    return data;
  }

} // namespace concepts

#endif // sequence_hh