2006-11-07 Thierry GERAUD <theo(a)tegucigalpa.lrde.epita.fr>
Add point-set types based on std containers.
* oln/core/gen/piter_on_std_based_pset.hh: New.
* oln/core/gen/pset_list.hh: New.
* oln/core/gen/pset_vec.hh: New.
* oln/core/gen/pset_.hh: New.
* oln/Makefile.am: Update.
2006-11-06 Thierry GERAUD <theo(a)tegucigalpa.lrde.epita.fr>
Index: oln/core/gen/piter_on_std_based_pset.hh
===================================================================
--- oln/core/gen/piter_on_std_based_pset.hh (revision 0)
+++ oln/core/gen/piter_on_std_based_pset.hh (revision 0)
@@ -0,0 +1,278 @@
+// Copyright (C) 2006 EPITA Research and Development Laboratory
+//
+// This file is part of the Olena Library. This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License version 2 as published by the
+// Free Software Foundation.
+//
+// This library 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 this library; see the file COPYING. If not, write to
+// the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+// Boston, MA 02111-1307, USA.
+//
+// As a special exception, you may use this file as part of a free
+// software library without restriction. Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to
+// produce an executable, this file does not by itself cause the
+// resulting executable to be covered by the GNU General Public
+// License. This exception does not however invalidate any other
+// reasons why the executable file might be covered by the GNU General
+// Public License.
+
+#ifndef OLN_CORE_GEN_PITER_ON_STD_BASED_PSET_HH
+# define OLN_CORE_GEN_PITER_ON_STD_BASED_PSET_HH
+
+# include <oln/core/abstract/point.hh>
+# include <oln/core/abstract/iterator_on_points.hh>
+
+
+namespace oln
+{
+
+
+ // Fwd_piter version.
+ // ------------------
+
+
+ // Forward declaration.
+ template <typename C> class fwd_piter_on_std_based_pset;
+
+
+ // Super.
+ template <typename C>
+ struct set_super_type< fwd_piter_on_std_based_pset<C> >
+ {
+ typedef abstract::iterator_on_points< fwd_piter_on_std_based_pset<C> >
ret;
+ };
+
+
+ // Vtypes.
+ template <typename C>
+ struct vtypes< fwd_piter_on_std_based_pset<C> >
+ {
+ typedef typename C::value_type point_type;
+ };
+
+
+ // Class.
+ template <typename C>
+ class fwd_piter_on_std_based_pset :
+
+ public abstract::iterator_on_points< fwd_piter_on_std_based_pset<C> >,
+ private mlc::assert_< mlc_is_a(typename C::value_type, abstract::point) >
+ {
+ public:
+ fwd_piter_on_std_based_pset(const C& container);
+
+ template <typename point_set>
+ fwd_piter_on_std_based_pset(const point_set& ps);
+
+ void impl_start();
+ void impl_next();
+ void impl_invalidate();
+ bool impl_is_valid() const;
+ typename C::value_type impl_to_point() const;
+ const typename C::value_type* impl_point_adr() const;
+
+ private:
+
+ const C& container_;
+ typename C::const_iterator it_;
+
+ }; // end of class fwd_piter_on_std_based_pset<C>
+
+
+
+ // Bkd_piter version.
+ // ------------------
+
+
+ // Forward declaration.
+ template <typename C> class bkd_piter_on_std_based_pset;
+
+
+ // Super.
+ template <typename C>
+ struct set_super_type< bkd_piter_on_std_based_pset<C> >
+ {
+ typedef abstract::iterator_on_points< bkd_piter_on_std_based_pset<C> >
ret;
+ };
+
+
+ // Vtypes.
+ template <typename C>
+ struct vtypes< bkd_piter_on_std_based_pset<C> >
+ {
+ typedef typename C::value_type point_type;
+ };
+
+
+ // Class.
+ template <typename C>
+ class bkd_piter_on_std_based_pset :
+
+ public abstract::iterator_on_points< bkd_piter_on_std_based_pset<C> >,
+ private mlc::assert_< mlc_is_a(typename C::value_type, abstract::point) >
+ {
+ public:
+ bkd_piter_on_std_based_pset(const C& container);
+
+ template <typename point_set>
+ bkd_piter_on_std_based_pset(const point_set& ps);
+
+ void impl_start();
+ void impl_next();
+ void impl_invalidate();
+ bool impl_is_valid() const;
+ typename C::value_type impl_to_point() const;
+ const typename C::value_type* impl_point_adr() const;
+
+ private:
+
+ const C& container_;
+ typename C::const_reverse_iterator it_;
+
+ }; // end of class bkd_piter_on_std_based_pset<C>
+
+
+
+
+# ifndef OLN_INCLUDE_ONLY
+
+
+ // fwd_piter_on_std_based_pset<C>
+
+
+ template <typename C>
+ fwd_piter_on_std_based_pset<C>::fwd_piter_on_std_based_pset(const C&
container)
+ : container_(container)
+ {
+ this->invalidate();
+ }
+
+ template <typename C>
+ template <typename point_set>
+ fwd_piter_on_std_based_pset<C>::fwd_piter_on_std_based_pset(const point_set&
ps)
+ : container_(ps.exact().container())
+ {
+ this->invalidate();
+ }
+
+ template <typename C>
+ void fwd_piter_on_std_based_pset<C>::impl_start()
+ {
+ it_ = container_.begin();
+ }
+
+ template <typename C>
+ void fwd_piter_on_std_based_pset<C>::impl_next()
+ {
+ ++it_;
+ }
+
+ template <typename C>
+ void fwd_piter_on_std_based_pset<C>::impl_invalidate()
+ {
+ it_ = container_.end();
+ }
+
+ template <typename C>
+ bool fwd_piter_on_std_based_pset<C>::impl_is_valid() const
+ {
+ return it_ != container_.end();
+ }
+
+ template <typename C>
+ typename C::value_type
+ fwd_piter_on_std_based_pset<C>::impl_to_point() const
+ {
+ return *it_;
+ }
+
+ template <typename C>
+ const typename C::value_type*
+ fwd_piter_on_std_based_pset<C>::impl_point_adr() const
+ {
+ return 0;
+ // FIXME: Read below.
+ // "&(*it_)" is not correct because the std does not ensure that
+ // "*it_" is dereferenceable (Cf. std trivial iterator concept).
+ // However, "::point_adr()" is only required so that an iterator
+ // based on another iterator (e.g., a niter constructed from a
+ // piter) can stick to the point location of the latter. This
+ // is not required for iterators on point set so this method should
+ // be optional.
+ }
+
+
+ // bkd_piter_on_std_based_pset<C>
+
+
+ template <typename C>
+ bkd_piter_on_std_based_pset<C>::bkd_piter_on_std_based_pset(const C&
container)
+ : container_(container)
+ {
+ this->invalidate();
+ }
+
+ template <typename C>
+ template <typename point_set>
+ bkd_piter_on_std_based_pset<C>::bkd_piter_on_std_based_pset(const point_set&
ps)
+ : container_(ps.exact().container())
+ {
+ this->invalidate();
+ }
+
+ template <typename C>
+ void bkd_piter_on_std_based_pset<C>::impl_start()
+ {
+ it_ = container_.rbegin();
+ }
+
+ template <typename C>
+ void bkd_piter_on_std_based_pset<C>::impl_next()
+ {
+ ++it_;
+ }
+
+ template <typename C>
+ void bkd_piter_on_std_based_pset<C>::impl_invalidate()
+ {
+ it_ = container_.rend();
+ }
+
+ template <typename C>
+ bool bkd_piter_on_std_based_pset<C>::impl_is_valid() const
+ {
+ return it_ != container_.rend();
+ }
+
+ template <typename C>
+ typename C::value_type
+ bkd_piter_on_std_based_pset<C>::impl_to_point() const
+ {
+ return *it_;
+ }
+
+ template <typename C>
+ const typename C::value_type*
+ bkd_piter_on_std_based_pset<C>::impl_point_adr() const
+ {
+ return 0;
+ // FIXME: Read comments in the fwd version of this method.
+ }
+
+
+# endif
+
+
+} // end of namespace oln
+
+
+#endif // ! OLN_CORE_GEN_PITER_ON_STD_BASED_PSET_HH
Index: oln/core/gen/pset_list.hh
===================================================================
--- oln/core/gen/pset_list.hh (revision 0)
+++ oln/core/gen/pset_list.hh (revision 0)
@@ -0,0 +1,181 @@
+// Copyright (C) 2006 EPITA Research and Development Laboratory
+//
+// This file is part of the Olena Library. This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License version 2 as published by the
+// Free Software Foundation.
+//
+// This library 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 this library; see the file COPYING. If not, write to
+// the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+// Boston, MA 02111-1307, USA.
+//
+// As a special exception, you may use this file as part of a free
+// software library without restriction. Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to
+// produce an executable, this file does not by itself cause the
+// resulting executable to be covered by the GNU General Public
+// License. This exception does not however invalidate any other
+// reasons why the executable file might be covered by the GNU General
+// Public License.
+
+#ifndef OLN_CORE_GEN_PSET_LIST_HH
+# define OLN_CORE_GEN_PSET_LIST_HH
+
+# include <list>
+
+# include <oln/core/point_set_entry.hh>
+# include <oln/core/abstract/point.hh>
+
+
+namespace oln
+{
+
+ // Forward declarations.
+ template <typename point_t> class pset_list;
+ template <typename C> class fwd_piter_on_std_based_pset;
+ template <typename C> class bkd_piter_on_std_based_pset;
+
+
+ // Super type declaration.
+ template <typename point_t>
+ struct set_super_type< pset_list<point_t> >
+ {
+ typedef pset_list<point_t> self_t;
+ typedef point_set_entry<self_t> ret;
+ };
+
+
+ /// Virtual types associated to oln::pset_list<point_t>.
+ template <typename point_t>
+ struct vtypes< pset_list<point_t> >
+ {
+ typedef point_t point_type;
+ typedef fwd_piter_on_std_based_pset< std::list<point_t> >
fwd_piter_type;
+ typedef bkd_piter_on_std_based_pset< std::list<point_t> >
bkd_piter_type;
+
+ typedef mlc::false_ is_random_accessible_type;
+ typedef mlc::true_ has_know_size_type;
+ typedef mlc::false_ is_connected_type;
+ };
+
+
+ /// Bounding box class based on a point class.
+ template <typename point_t>
+ class pset_list : public point_set_entry< pset_list<point_t> >,
+ private mlc::assert_< mlc_is_a(point_t, abstract::point) >
+ {
+ typedef pset_list<point_t> self_type;
+ typedef point_set_entry<self_type> super_t;
+
+ public:
+
+ pset_list();
+ pset_list(const pset_list<point_t>& rhs);
+ pset_list<point_t>& operator=(const pset_list<point_t>& rhs);
+
+ unsigned impl_npoints() const;
+ bool impl_is_valid() const;
+ void impl_print(std::ostream& ostr) const;
+
+ pset_list<point_t>& append(const point_t& p);
+ pset_list<point_t>& prepend(const point_t& p);
+
+ const std::list<point_t>& container() const;
+ std::list<point_t>& container();
+
+ protected:
+
+ std::list<point_t> lp_;
+
+ }; // end of class oln::pset_list<point_t>
+
+
+
+# ifndef OLN_INCLUDE_ONLY
+
+ template <typename point_t>
+ pset_list<point_t>::pset_list()
+ {
+ }
+
+ template <typename point_t>
+ pset_list<point_t>::pset_list(const pset_list<point_t>& rhs)
+ {
+ lp_ = rhs.lp_;
+ }
+
+ template <typename point_t>
+ pset_list<point_t>& pset_list<point_t>::operator=(const
pset_list<point_t>& rhs)
+ {
+ lp_ = rhs.lp_;
+ return *this;
+ }
+
+ template <typename point_t>
+ unsigned pset_list<point_t>::impl_npoints() const
+ {
+ return lp_.size();
+ }
+
+ template <typename point_t>
+ bool pset_list<point_t>::impl_is_valid() const
+ {
+ return true;
+ }
+
+ template <typename point_t>
+ void pset_list<point_t>::impl_print(std::ostream& ostr) const
+ {
+ typename std::list<point_t>::const_iterator it;
+ ostr << "{ ";
+ for (it = lp_.begin(); it != lp_.end(); ++it)
+ ostr << *it << ' ';
+ ostr << "}";
+ }
+
+ template <typename point_t>
+ pset_list<point_t>& pset_list<point_t>::append(const point_t& p)
+ {
+ precondition(std::find(lp_.begin(), lp_.end(), p)
+ == lp_.end());
+ lp_.push_back(p);
+ return *this;
+ }
+
+ template <typename point_t>
+ pset_list<point_t>& pset_list<point_t>::prepend(const point_t& p)
+ {
+ precondition(std::find(lp_.begin(), lp_.end(), p)
+ == lp_.end());
+ lp_.push_front(p);
+ return *this;
+ }
+
+ template <typename point_t>
+ const std::list<point_t>& pset_list<point_t>::container() const
+ {
+ return lp_;
+ }
+
+ template <typename point_t>
+ std::list<point_t>& pset_list<point_t>::container()
+ {
+ return lp_;
+ }
+
+# endif
+
+} // end of namespace oln
+
+
+# include <oln/core/gen/piter_on_std_based_pset.hh>
+
+
+#endif // ! OLN_CORE_GEN_PSET_LIST_HH
Index: oln/core/gen/pset_vec.hh
===================================================================
--- oln/core/gen/pset_vec.hh (revision 0)
+++ oln/core/gen/pset_vec.hh (revision 0)
@@ -0,0 +1,171 @@
+// Copyright (C) 2006 EPITA Research and Development Laboratory
+//
+// This file is part of the Olena Library. This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License version 2 as published by the
+// Free Software Foundation.
+//
+// This library 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 this library; see the file COPYING. If not, write to
+// the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+// Boston, MA 02111-1307, USA.
+//
+// As a special exception, you may use this file as part of a free
+// software library without restriction. Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to
+// produce an executable, this file does not by itself cause the
+// resulting executable to be covered by the GNU General Public
+// License. This exception does not however invalidate any other
+// reasons why the executable file might be covered by the GNU General
+// Public License.
+
+#ifndef OLN_CORE_GEN_PSET_VEC_HH
+# define OLN_CORE_GEN_PSET_VEC_HH
+
+# include <vector>
+
+# include <oln/core/point_set_entry.hh>
+# include <oln/core/abstract/point.hh>
+
+
+namespace oln
+{
+
+ // Forward declarations.
+ template <typename point_t> class pset_vec;
+ template <typename C> class fwd_piter_on_std_based_pset;
+ template <typename C> class bkd_piter_on_std_based_pset;
+
+
+ // Super type declaration.
+ template <typename point_t>
+ struct set_super_type< pset_vec<point_t> >
+ {
+ typedef pset_vec<point_t> self_t;
+ typedef point_set_entry<self_t> ret;
+ };
+
+
+ /// Virtual types associated to oln::pset_vec<point_t>.
+ template <typename point_t>
+ struct vtypes< pset_vec<point_t> >
+ {
+ typedef point_t point_type;
+ typedef fwd_piter_on_std_based_pset< std::vector<point_t> >
fwd_piter_type;
+ typedef bkd_piter_on_std_based_pset< std::vector<point_t> >
bkd_piter_type;
+
+ typedef mlc::false_ is_random_accessible_type;
+ typedef mlc::true_ has_know_size_type;
+ typedef mlc::false_ is_connected_type;
+ };
+
+
+ /// Bounding box class based on a point class.
+ template <typename point_t>
+ class pset_vec : public point_set_entry< pset_vec<point_t> >,
+ private mlc::assert_< mlc_is_a(point_t, abstract::point) >
+ {
+ typedef pset_vec<point_t> self_type;
+ typedef point_set_entry<self_type> super_t;
+
+ public:
+
+ pset_vec();
+ pset_vec(const pset_vec<point_t>& rhs);
+ pset_vec<point_t>& operator=(const pset_vec<point_t>& rhs);
+
+ unsigned impl_npoints() const;
+ bool impl_is_valid() const;
+ void impl_print(std::ostream& ostr) const;
+
+ pset_vec<point_t>& append(const point_t& p);
+
+ const std::vector<point_t>& container() const;
+ std::vector<point_t>& container();
+
+ protected:
+
+ std::vector<point_t> vp_;
+
+ }; // end of class oln::pset_vec<point_t>
+
+
+
+# ifndef OLN_INCLUDE_ONLY
+
+ template <typename point_t>
+ pset_vec<point_t>::pset_vec()
+ {
+ }
+
+ template <typename point_t>
+ pset_vec<point_t>::pset_vec(const pset_vec<point_t>& rhs)
+ {
+ vp_ = rhs.vp_;
+ }
+
+ template <typename point_t>
+ pset_vec<point_t>& pset_vec<point_t>::operator=(const
pset_vec<point_t>& rhs)
+ {
+ vp_ = rhs.vp_;
+ return *this;
+ }
+
+ template <typename point_t>
+ unsigned pset_vec<point_t>::impl_npoints() const
+ {
+ return vp_.size();
+ }
+
+ template <typename point_t>
+ bool pset_vec<point_t>::impl_is_valid() const
+ {
+ return true;
+ }
+
+ template <typename point_t>
+ void pset_vec<point_t>::impl_print(std::ostream& ostr) const
+ {
+ typename std::vector<point_t>::const_iterator it;
+ ostr << "{ ";
+ for (it = vp_.begin(); it != vp_.end(); ++it)
+ ostr << *it << ' ';
+ ostr << "}";
+ }
+
+ template <typename point_t>
+ pset_vec<point_t>& pset_vec<point_t>::append(const point_t& p)
+ {
+ precondition(std::find(vp_.begin(), vp_.end(), p)
+ == vp_.end());
+ vp_.push_back(p);
+ return *this;
+ }
+
+ template <typename point_t>
+ const std::vector<point_t>& pset_vec<point_t>::container() const
+ {
+ return vp_;
+ }
+
+ template <typename point_t>
+ std::vector<point_t>& pset_vec<point_t>::container()
+ {
+ return vp_;
+ }
+
+# endif
+
+} // end of namespace oln
+
+
+# include <oln/core/gen/piter_on_std_based_pset.hh>
+
+
+#endif // ! OLN_CORE_GEN_PSET_VEC_HH
Index: oln/core/gen/pset_.hh
===================================================================
--- oln/core/gen/pset_.hh (revision 0)
+++ oln/core/gen/pset_.hh (revision 0)
@@ -0,0 +1,170 @@
+// Copyright (C) 2006 EPITA Research and Development Laboratory
+//
+// This file is part of the Olena Library. This library is free
+// software; you can redistribute it and/or modify it under the terms
+// of the GNU General Public License version 2 as published by the
+// Free Software Foundation.
+//
+// This library 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 this library; see the file COPYING. If not, write to
+// the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+// Boston, MA 02111-1307, USA.
+//
+// As a special exception, you may use this file as part of a free
+// software library without restriction. Specifically, if other files
+// instantiate templates or use macros or inline functions from this
+// file, or you compile this file and link it with other files to
+// produce an executable, this file does not by itself cause the
+// resulting executable to be covered by the GNU General Public
+// License. This exception does not however invalidate any other
+// reasons why the executable file might be covered by the GNU General
+// Public License.
+
+#ifndef OLN_CORE_GEN_PSET_HH
+# define OLN_CORE_GEN_PSET_HH
+
+# include <set>
+
+# include <oln/core/point_set_entry.hh>
+# include <oln/core/abstract/point.hh>
+
+
+namespace oln
+{
+
+ // Forward declarations.
+ template <typename point_t> class pset_;
+ template <typename C> class fwd_piter_on_std_based_pset;
+ template <typename C> class bkd_piter_on_std_based_pset;
+
+
+ // Super type declaration.
+ template <typename point_t>
+ struct set_super_type< pset_<point_t> >
+ {
+ typedef pset_<point_t> self_t;
+ typedef point_set_entry<self_t> ret;
+ };
+
+
+ /// Virtual types associated to oln::pset_<point_t>.
+ template <typename point_t>
+ struct vtypes< pset_<point_t> >
+ {
+ typedef point_t point_type;
+ typedef fwd_piter_on_std_based_pset< std::set<point_t> > fwd_piter_type;
+ typedef bkd_piter_on_std_based_pset< std::set<point_t> > bkd_piter_type;
+
+ typedef mlc::false_ is_random_accessible_type;
+ typedef mlc::true_ has_know_size_type;
+ typedef mlc::false_ is_connected_type;
+ };
+
+
+ /// Bounding box class based on a point class.
+ template <typename point_t>
+ class pset_ : public point_set_entry< pset_<point_t> >,
+ private mlc::assert_< mlc_is_a(point_t, abstract::point) >
+ {
+ typedef pset_<point_t> self_type;
+ typedef point_set_entry<self_type> super_t;
+
+ public:
+
+ pset_();
+ pset_(const pset_<point_t>& rhs);
+ pset_<point_t>& operator=(const pset_<point_t>& rhs);
+
+ unsigned impl_npoints() const;
+ bool impl_is_valid() const;
+ void impl_print(std::ostream& ostr) const;
+
+ pset_<point_t>& insert(const point_t& p);
+
+ const std::set<point_t>& container() const;
+ std::set<point_t>& container();
+
+ protected:
+
+ std::set<point_t> sp_;
+
+ }; // end of class oln::pset_<point_t>
+
+
+
+# ifndef OLN_INCLUDE_ONLY
+
+ template <typename point_t>
+ pset_<point_t>::pset_()
+ {
+ }
+
+ template <typename point_t>
+ pset_<point_t>::pset_(const pset_<point_t>& rhs)
+ {
+ sp_ = rhs.sp_;
+ }
+
+ template <typename point_t>
+ pset_<point_t>& pset_<point_t>::operator=(const
pset_<point_t>& rhs)
+ {
+ sp_ = rhs.sp_;
+ return *this;
+ }
+
+ template <typename point_t>
+ unsigned pset_<point_t>::impl_npoints() const
+ {
+ return sp_.size();
+ }
+
+ template <typename point_t>
+ bool pset_<point_t>::impl_is_valid() const
+ {
+ return true;
+ }
+
+ template <typename point_t>
+ void pset_<point_t>::impl_print(std::ostream& ostr) const
+ {
+ typename std::set<point_t>::const_iterator it;
+ ostr << "{ ";
+ for (it = sp_.begin(); it != sp_.end(); ++it)
+ ostr << *it << ' ';
+ ostr << "}";
+ }
+
+ template <typename point_t>
+ pset_<point_t>& pset_<point_t>::insert(const point_t& p)
+ {
+ precondition(sp_.find(p) == sp_.end());
+ sp_.insert(p);
+ return *this;
+ }
+
+ template <typename point_t>
+ const std::set<point_t>& pset_<point_t>::container() const
+ {
+ return sp_;
+ }
+
+ template <typename point_t>
+ std::set<point_t>& pset_<point_t>::container()
+ {
+ return sp_;
+ }
+
+# endif
+
+} // end of namespace oln
+
+
+# include <oln/core/gen/piter_on_std_based_pset.hh>
+
+
+#endif // ! OLN_CORE_GEN_PSET_HH
Index: oln/Makefile.am
===================================================================
--- oln/Makefile.am (revision 696)
+++ oln/Makefile.am (working copy)
@@ -128,9 +128,14 @@
core/gen/fwd_qiter_win.hh \
core/gen/fwd_viter_lut.hh \
core/gen/piter_isubset.hh \
+ core/gen/piter_isubset.hh \
+ core/gen/pset_.hh \
+ core/gen/pset_list.hh \
+ core/gen/pset_vec.hh \
core/gen/grid.hh \
core/gen/mapimage.hh \
core/gen/neighb.hh \
+ core/gen/piter_on_std_based_pset.hh \
core/gen/pw_value.hh \
core/gen/topo_add_isubset.hh \
core/gen/topo_add_nbh.hh \