Index: ChangeLog
from Simon Odou <simon(a)lrde.epita.fr>
* tests/core/tests/window2d: New.
* oln/core/abstract/struct_elt.hh: New.
* oln/core/2d/window2d.hh: New.
* oln/core/properties.hh: Add `struct_elt' category.
oln/core/2d/window2d.hh | 172 ++++++++++++++++++++++++++++++++++++
oln/core/abstract/struct_elt.hh | 189 ++++++++++++++++++++++++++++++++++++++++
oln/core/properties.hh | 1
tests/core/tests/window2d | 17 +++
4 files changed, 379 insertions(+)
Index: tests/core/tests/window2d
--- tests/core/tests/window2d (revision 0)
+++ tests/core/tests/window2d (revision 0)
@@ -0,0 +1,17 @@
+#include <oln/core/2d/window2d.hh>
+
+#include <ntg/all.hh>
+
+#include <cassert>
+
+using namespace oln;
+using namespace ntg;
+
+int main()
+{
+ window2d w1;
+ w1.add(dpoint2d(0, 5));
+ w1.add(dpoint2d(0, 5));
+ window2d w2 = win_c8p();
+ return 0;
+}
Index: oln/core/abstract/struct_elt.hh
--- oln/core/abstract/struct_elt.hh (revision 0)
+++ oln/core/abstract/struct_elt.hh (revision 0)
@@ -0,0 +1,189 @@
+// Copyright (C) 2001, 2002, 2003, 2004, 2005 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, 59 Temple Place - Suite 330, 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 OLENA_CORE_STRUCT_ELT_HH
+# define OLENA_CORE_STRUCT_ELT_HH
+
+# include <mlc/types.hh>
+# include <oln/core/properties.hh>
+# include <oln/core/coord.hh>
+# include <oln/core/abstract/dpoint.hh>
+# include <vector>
+# include <utility>
+# include <iostream>
+
+namespace oln {
+
+ // fwd decl
+ namespace abstract {
+ template<class Exact>
+ struct struct_elt;
+ }
+
+ // category
+ template <typename E>
+ struct set_category< abstract::struct_elt<E> >
+ {
+ typedef category::struct_elt ret;
+ };
+
+ /// properties of any type in category::struct_elt
+
+ template <typename type>
+ struct props_of <category::struct_elt, type>
+ {
+ typedef mlc::true_type user_defined_;
+
+ mlc_decl_prop(category::struct_elt, dpoint_type);
+ mlc_decl_prop(category::struct_elt, size_type);
+
+ static void echo(std::ostream& ostr)
+ {
+ ostr << "props_of( category::struct_elt, "
+ << typeid(type).name() << ") = {"
+ << " size_type = " << typeid(size_type).name() << "," << std::endl
+ << " dpoint_type = " << typeid(dpoint_type).name() << " }" << std::endl;
+ }
+
+ };
+
+ mlc_register_prop(category::struct_elt, dpoint_type);
+ mlc_register_prop(category::struct_elt, size_type);
+
+
+ namespace abstract {
+
+ /*!
+ ** Structuring elements (set of dpoints).
+ **
+ ** This abstract class defines several virtual methods for its
+ ** subclasses. Its goal is to deal with a set of 'move' points.
+ */
+ template<class E>
+ class struct_elt : public mlc::any__best_memory<E>
+ {
+
+ public:
+
+ typedef oln_type_of(E, dpoint) dpoint_type;
+
+ typedef E exact_type;
+
+ static std::string
+ name()
+ {
+ return std::string("struct_elt<") + exact_type::name() + ">";
+ }
+
+ bool
+ has(const abstract::dpoint<dpoint_type>& dp) const
+ {
+ return this->exact().impl_has(dp.exact());
+ }
+
+ unsigned
+ card() const
+ {
+ return this->exact().impl_card();
+ }
+
+ exact_type&
+ add(const dpoint_type& dp)
+ {
+ return this->exact().impl_add(dp);
+ }
+
+ dpoint_type
+ dp(unsigned i) const
+ {
+ return this->exact().impl_at(i);
+ }
+
+ const dpoint_type
+ operator[](unsigned i) const
+ {
+ return this->exact().impl_at(i);
+ }
+
+ protected:
+
+ bool
+ impl_has(const dpoint_type& dp) const
+ {
+ return std::find(dp_.begin(), dp_.end(), dp) != dp_.end();
+ }
+
+ exact_type&
+ impl_add(const dpoint_type& dp)
+ {
+ if (!(impl_has(dp)))
+ this->dp_.push_back(dp);
+ return this->exact();
+ }
+
+ unsigned
+ impl_card() const
+ {
+ return dp_.size();
+ }
+
+ const dpoint_type
+ impl_at(unsigned i) const
+ {
+ precondition(i < this->card());
+ return dp_[i];
+ }
+
+ struct_elt() : dp_()
+ {};
+
+ struct_elt(unsigned size) : dp_()
+ {
+ dp_.reserve(size);
+ };
+
+ std::vector<dpoint_type> dp_;
+
+ };
+ } // end of abstract
+
+} // end of oln
+
+template<class E>
+std::ostream&
+operator<<(std::ostream& o, const oln::abstract::struct_elt<E>& se)
+{
+ unsigned c = se.card();
+ o << "[";
+ for (unsigned i = 0; i < c; ++i)
+ o << se.dp(i);
+ o << "]";
+ return o;
+}
+
+
+#endif // ! OLENA_CORE_STRUCT_ELT_HH
Index: oln/core/2d/window2d.hh
--- oln/core/2d/window2d.hh (revision 0)
+++ oln/core/2d/window2d.hh (revision 0)
@@ -0,0 +1,172 @@
+// Copyright (C) 2001, 2002, 2003, 2004, 2005 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, 59 Temple Place - Suite 330, 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 OLENA_CORE_WINDOW2D_HH
+# define OLENA_CORE_WINDOW2D_HH
+
+# include <oln/core/2d/dpoint2d.hh>
+# include <oln/core/2d/size2d.hh>
+# include <oln/core/coord.hh>
+# include <oln/core/abstract/struct_elt.hh>
+
+namespace oln {
+
+ class window2d; // forward declaration
+
+ // category
+ template <>
+ struct set_category< window2d > { typedef category::struct_elt ret; };
+
+ // super_type
+ template <>
+ struct set_super_type< window2d >
+ {
+ typedef abstract::struct_elt< window2d > ret;
+ };
+
+ template <>
+ struct set_props< category::struct_elt, window2d >
+ : public props_of<category::struct_elt>
+ {
+ typedef dpoint2d dpoint_type;
+ typedef size2d size_type;
+ };
+
+ class window2d : public abstract::struct_elt<window2d>
+ {
+
+ public:
+
+ typedef abstract::struct_elt<window2d> super_type;
+
+ /*!
+ ** \brief Construct a window of 2 dimensions.
+ */
+ window2d() : super_type()
+ {}
+
+ /*!
+ ** \brief Construct a window of 2 dimensions.
+ ** \arg size The number of element.
+ */
+ window2d(unsigned size) : super_type(size)
+ {}
+
+ /*!
+ ** \brief Construct a window of 2 dimensions from several points.
+ ** \arg n The number of element.
+ ** \arg crd The coordinates of the elements
+ */
+ window2d(unsigned n, const coord_t crd[]) : super_type(n)
+ {
+ for (unsigned i = 0; i < 2 * n; i += 2)
+ this->add(dpoint_type(crd[i], crd[i+1]));
+ }
+
+ window2d&
+ add(const dpoint_type& dp)
+ {
+ return this->exact().impl_add(dp);
+ }
+
+ window2d&
+ add(coord_t row, coord_t col)
+ {
+ dpoint_type dp(row, col);
+ return add(dp);
+ }
+
+
+ /// Return the name of the type.
+ static std::string
+ name()
+ {
+ return std::string("window2d");
+ }
+
+ protected:
+
+ };
+
+
+ // std win
+
+ /*!
+ ** \brief Create a window (2 dimensions) of 4 elements.
+ ** \return The new window.
+ */
+ inline const window2d&
+ win_c4_only()
+ {
+ static const coord_t crd[] = { -1,0, 0,-1, 0,1, 1,0 };
+ static const window2d win(4, crd);
+ return win;
+ }
+
+ /*!
+ ** \brief Create a window (2 dimensions) of 5 elements.
+ ** \return The new window.
+ **
+ ** It's the same than win_c4_only() plus the 0,0 point.
+ */
+ inline const window2d&
+ win_c4p()
+ {
+ static const coord_t crd[] = { -1,0, 0,-1, 0,0, 0,1, 1,0 };
+ static const window2d win(5, crd);
+ return win;
+ }
+
+ /*!
+ ** \brief Create a window (2 dimensions) of 8 elements.
+ ** \return The new window.
+ */
+ inline const window2d&
+ win_c8_only()
+ {
+ static const coord_t crd[] = { -1,-1, -1,0, -1,1, 0,-1, 0,1, 1,-1, 1,0, 1,1 };
+ static const window2d win(8, crd);
+ return win;
+ }
+
+ /*!
+ ** \brief Create a window (2 dimensions) of 9 elements.
+ ** \return The new window.
+ **
+ ** It's the same than win_c8_only more the 0,0 point.
+ */
+ inline const window2d&
+ win_c8p()
+ {
+ static const coord_t crd[] = { -1,-1, -1,0, -1,1, 0,-1, 0,0, 0,1, 1,-1, 1,0, 1,1 };
+ static const window2d win(9, crd);
+ return win;
+ }
+
+} // end of oln
+
+#endif // OLENA_CORE_WINDOW2D_HH
Index: oln/core/properties.hh
--- oln/core/properties.hh (revision 73)
+++ oln/core/properties.hh (working copy)
@@ -41,6 +41,7 @@
{
struct data_storage;
struct image;
+ struct struct_elt;
struct point;
struct size;
struct piter;
