/usr/include/rheolef/index_set.h is in librheolef-dev 6.7-6.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 | #ifndef _RHEOLEF_INDEX_SET_H
#define _RHEOLEF_INDEX_SET_H
///
/// This file is part of Rheolef.
///
/// Copyright (C) 2000-2009 Pierre Saramito <Pierre.Saramito@imag.fr>
///
/// Rheolef is free software; you can redistribute it and/or modify
/// it under the terms of the GNU General Public License as published by
/// the Free Software Foundation; either version 2 of the License, or
/// (at your option) any later version.
///
/// Rheolef is distributed in the hope that it will be useful,
/// but WITHOUT ANY WARRANTY; without even the implied warranty of
/// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
/// GNU General Public License for more details.
///
/// You should have received a copy of the GNU General Public License
/// along with Rheolef; if not, write to the Free Software
/// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
///
/// =========================================================================
// wrapper for std::set<size_t>: union as a+b and a += b and others goodies
//
// motivation: this class is usefull for disarray<index_set,M> to send/receive variable-sized
// lists via MPI correctly
// disarray<index_set,M> is used by the geo class to manage connectivity
// and compute neighbours
//
// author: Pierre.Saramito@imag.fr
//
// date: 19 mai 2012
//
#include "rheolef/distributed.h"
#include "rheolef/pretty_name.h"
#include "rheolef/container_traits.h"
#ifdef _RHEOLEF_HAVE_MPI
#include <boost/serialization/set.hpp>
#include <boost/serialization/base_object.hpp>
#endif // _RHEOLEF_HAVE_MPI
namespace rheolef {
/*Class:index_set
NAME: index_set - a set of indexes (@PACKAGE@-@VERSION@)
SYNOPSYS:
A class for: l = @{1,3,...9@} i.e. a wrapper for STL @code{set<size_t>} with
some assignment operators, such as l1 += l2.
This class is suitable for use with the @code{disarray<T>} class, as @code{disarray<index_set>}
(@pxref{disarray class}).
AUTHOR: Pierre.Saramito@imag.fr
DATE: date: 23 march 2011
End:
*/
//<verbatim:
class index_set : public std::set<std::size_t> {
public:
// typedefs:
typedef std::set<std::size_t> base;
typedef std::size_t value_type;
typedef std::size_t size_type;
// allocators:
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 ();
// basic algebra:
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
// a := a union b
void inplace_union (const index_set& b);
void inplace_intersection (const index_set& b);
// c := a union 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);
// io:
friend std::istream& operator>> (std::istream& is, index_set& x);
friend std::ostream& operator<< (std::ostream& os, const index_set& x);
// boost mpi:
#ifdef _RHEOLEF_HAVE_MPI
template <class Archive>
void serialize (Archive& ar, const unsigned int version);
#endif // _RHEOLEF_HAVE_MPI
};
//>verbatim:
// operator += for disarray::assembly
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 disarray<index_set>:
template <> struct default_set_op<index_set> {
typedef index_set_add_op<index_set> type;
};
template <> struct is_container<index_set> : std::true_type {
typedef std::true_type type;
};
#ifdef _RHEOLEF_HAVE_MPI
template <> struct is_container_of_mpi_datatype<index_set> : std::true_type {
typedef std::true_type type;
};
#endif // _RHEOLEF_HAVE_MPI
// -------------------------------------------------------------------
// inlined
// -------------------------------------------------------------------
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;
}
#ifdef _RHEOLEF_HAVE_MPI
template <class Archive>
void
index_set::serialize (Archive& ar, const unsigned int version)
{
ar & boost::serialization::base_object<base>(*this);
}
#endif // _RHEOLEF_HAVE_MPI
} // namespace rheolef
#endif // _RHEOLEF_INDEX_SET_H
|