toolbox/set.hh

Go to the documentation of this file.

/* Set with operations, output operator, and method of the
   particular element types.
 */

#ifndef set_hh
#define set_hh

#include <set>
#include <algorithm>
#include <iterator>
#include <stdarg.h>
#include <basics/debug.hh>
#include <basics/outputOperator.hh>
#include <basics/exceptions.hh>
#include <basics/pointerOutput.hh>
#include "array.hh"

#define SetInput_D 0

namespace concepts {

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

  // ******************************************************************* Set **

  template<class F>
  class Set : public BaseSet<F> {
  public:
    Set() : BaseSet<F>() {}
    Set(const F& val) : BaseSet<F>() { insert(val); }
    template<class G>
    Set(const G& set) : BaseSet<F>(set) {}
    virtual ~Set() {}
  };

 // *************************************************************** BaseSet **

  template<class F>
  class BaseSet : public std::set<F>, public OutputOperator {
  public:
    BaseSet() : std::set<F>() {}
    BaseSet(const std::string& str);
    BaseSet(const concepts::Array<F>& a);
    template<class G>
    BaseSet(const G& set) : std::set<F>(set) {}
    virtual ~BaseSet() {}

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

    // Return set union
    inline Set<F> operator||(const Set<F>& set) const;
    inline Set<F> operator||(Set<F>& set) const;
    // Return set intersection
    inline Set<F> operator&&(const Set<F>& set) const;
    inline Set<F> operator&&(Set<F>& set) const;
    // Return set difference
    inline Set<F> operator-(const Set<F>& set) const;
    inline Set<F> operator-(Set<F>& set) const;
    inline Set<uint> operator==(const F val) const;
    inline Set<F> operator()(const Set<uint>& set) const;

    // Return set union
    inline BaseSet<F>& operator|=(const Set<F>& set);

    inline bool exist(F val) const;
    inline bool isempty() const { return this->begin() == this->end(); }
  protected:
    virtual std::ostream& info(std::ostream& os) const;

    typedef typename std::set<F>::const_iterator const_iterator_;
    typedef typename std::insert_iterator<std::set<F> > insert_iterator_;
    virtual void union_(const_iterator_ first, const_iterator_ last,
                        insert_iterator_ i) const;
    virtual void intersection_(const_iterator_ first, const_iterator_ last,
                               insert_iterator_ i) const;
    virtual void difference_(const_iterator_ first, const_iterator_ last,
                             insert_iterator_ i) const;
  };

  template<class F>
  void operator>>(std::istream& is, BaseSet<F>& set) {
    F val;
    while(!is.eof()) {
      is >> val;
      DEBUGL(SetInput_D, "val = " << val);
      if (!is.fail())
        set.insert(val);
    }
  }

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

  template<class F>
  BaseSet<F>::BaseSet(const concepts::Array<F>& a) {
    const F* e = (const F*)a;
    for(uint i = a.size(); i--;) this->insert(*e++);
  }

  // e.g. Key::key()
  template<class F>
  template<class G, class H>
  Set<G> BaseSet<F>::operator()(G (H::*fun)() const) const {
    std::set<G> set;
    for(const_iterator_ i = this->begin(); i != this->end(); ++i) {
      G val = ((*i)->*fun)();
      set.insert(val);
    }
    return set;
  }
  // e.g. Connector1::key()
  template<class F>
  template<class G, class H>
  Set<G*> BaseSet<F>::operator()(G& (H::*fun)() const) const {
    std::set<G*> set;
    for(const_iterator_ i = this->begin(); i != this->end();++i) {
      G* val = &((*i)->*fun)();
      set.insert(val);
    }
    return set;
  }
  // e.g. Connector1::vertex(uint i)
  template<class F>
  template<class G, class H, class I, class J>
  Set<G> BaseSet<F>::operator()(G (H::*fun)(I) const, J i) const {
    std::set<G> set;
    for(const_iterator_ is = this->begin(); is != this->end();++is) {
      G val = ((*is)->*fun)(i);
      set.insert(val);
    }
    return set;
  }

  template<class F>
  Set<F> BaseSet<F>::operator||(const Set<F>& set) const {
    std::set<F> result;
    union_(set.begin(), set.end(), inserter(result, result.begin()));
    return result;
  }

  template<class F>
  Set<F> BaseSet<F>::operator||(Set<F>& set) const {
    std::set<F> result;
    union_(set.begin(), set.end(), inserter(result, result.begin()));
    return result;
  }

  template<class F>
  Set<F> BaseSet<F>::operator&&(const Set<F>& set) const {
    std::set<F> result;
    intersection_(set.begin(), set.end(), inserter(result, result.begin()));
    return result;
  }

  template<class F>
  Set<F> BaseSet<F>::operator&&(Set<F>& set) const {
    std::set<F> result;
    intersection_(set.begin(), set.end(), inserter(result, result.begin()));
    return result;
  }

  template<class F>
  void BaseSet<F>::intersection_
  (const_iterator_ first, const_iterator_ last, insert_iterator_ i) const {
    set_intersection(this->begin(), this->end(), first, last, i);
  }

  template<class F>
  void BaseSet<F>::union_
  (const_iterator_ first, const_iterator_ last, insert_iterator_ i) const {
    set_union(this->begin(), this->end(), first, last, i);
  }

  template<class F>
  void BaseSet<F>::difference_
  (const_iterator_ first, const_iterator_ last, insert_iterator_ i) const {
    set_difference(this->begin(), this->end(), first, last, i);
  }
    
  template<class F>
  Set<F> BaseSet<F>::operator-(const Set<F>& set) const {
    std::set<F> result;
    difference_(set.begin(), set.end(), inserter(result, result.begin()));
    return result;
  }

  template<class F>
  Set<F> BaseSet<F>::operator-(Set<F>& set) const {
    std::set<F> result;
    difference_(set.begin(), set.end(), inserter(result, result.begin()));
    return result;
  }

  template<class F>
  Set<uint> BaseSet<F>::operator==(const F val) const {
    std::set<uint> result;
    uint i = 0;
    for(const_iterator_ is = this->begin(); is != this->end(); ++is, ++i)
      if (*is == val) result.insert(i);
    return result;
  }

  template<class F>
  Set<F> BaseSet<F>::operator()(const Set<uint>& set) const {
    std::set<F> result;
    uint i = 0;
    typename std::set<uint>::const_iterator it = set.begin();
    const_iterator_ is = this->begin();
    while(it != set.end() && is != this->end()) {
      if (i == *it) {
        result.insert(*is);
        ++it;
      }
      ++is; ++i;
    }
    conceptsAssert(it == set.end(), Assertion());
    return result;
  }

  template<class F>
  BaseSet<F>& BaseSet<F>::operator|=(const Set<F>& set) {
    set_union(this->begin(), this->end(),
              set.begin(), set.end(),
              inserter(*this, this->begin())); 
    return *this;
  }

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

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

  // *************************************************************** makeSet **

  template<class F>
  Set<F> makeSet(uint n, const F& first, ...) {
    Set<F> data;
    data.insert(first);

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


} // namespace concepts

#endif // set_hh