index_set.h

Go to the documentation of this file.

#ifndef _RHEOLEF_INDEX_SET_H
#define _RHEOLEF_INDEX_SET_H
// wrapper for std::set<size_t>: union as a+b and a += b and others goodies
// motivation: this class is usefull for array<index_set,M> to send/receive variable-sized
// array<index_set,M> is used by the geo class to manage connectivity
#include "rheolef/distributed.h"
#include "rheolef/pretty_name.h"
#include "rheolef/container_traits.h"

#include <boost/serialization/set.hpp>
#include <boost/serialization/base_object.hpp>
namespace rheolef {

class index_set : public std::set<std::size_t> {
public:


  typedef std::set<std::size_t>    base;
  typedef std::size_t              value_type;
  typedef std::size_t              size_type;


  index_set ();
  index_set (const index_set& x);
  index_set& operator= (const index_set& x);
  template <int N>
  index_set& operator= (size_type x[N]);
  void clear ();


  void       insert     (size_type dis_i);    // a := a union {dis_i}
  index_set& operator+= (size_type dis_i);    // idem
  index_set& operator+= (const index_set& b); // a := a union b

  void inplace_union        (const index_set& b);
  void inplace_intersection (const index_set& b);

  friend void set_union        (const index_set& a, const index_set& b, index_set& c);
  friend void set_intersection (const index_set& a, const index_set& b, index_set& c);


  friend std::istream& operator>> (std::istream& is, index_set& x);
  friend std::ostream& operator<< (std::ostream& os, const index_set& x);


  template <class Archive>
  void serialize (Archive& ar, const unsigned int version);
};
@endcode

template <class T>
struct index_set_add_op : std::binary_function<T,T,T> {
    T& operator()(T& x, const T&                      y) const { return x += y; }
    T& operator()(T& x, const typename T::value_type& y) const { return x += y; }
};
// for boost mpi and array<index_set>:
template <> struct default_set_op<index_set> {
  typedef index_set_add_op<index_set> type;
};
template <> struct is_container<index_set> : boost::mpl::true_ {
  typedef boost::mpl::true_ type;
};
#ifdef _RHEOLEF_HAVE_MPI
template <> struct is_container_of_mpi_datatype<index_set> : boost::mpl::true_ {
  typedef boost::mpl::true_ type;
};
#endif // _RHEOLEF_HAVE_MPI
inline
index_set::index_set()
 : base()
{
}
template<int N>
index_set&
index_set::operator= (size_t x[N])
{
  base::clear();
  for (size_t* iter = &(x[0]), *last = &(x[0])+N; iter != last; iter++) {
    base::insert (*iter);
  }
  return *this;
}
inline
void
index_set::clear ()
{
  base::clear();
}
inline
void
index_set::insert (size_type dis_i)
{
  base::insert (dis_i);
}
inline
index_set&
index_set::operator+= (size_type dis_i)
{
  base::insert (dis_i);
  return *this;
}
template <class Archive>
void
index_set::serialize (Archive& ar, const unsigned int version)
{
  ar & boost::serialization::base_object<base>(*this);
}

} // namespace rheolef
#endif // _RHEOLEF_INDEX_SET_H