https://svn.lrde.epita.fr/svn/oln/trunk/olena
Index: ChangeLog
from Thierry Geraud <thierry.geraud(a)lrde.epita.fr>
Add the notion of image plus neighborhood and the underlying
mechanism.
* oln/debug/print_nbh.hh,
* oln/debug/iota.hh,
* oln/core/concept/image_identity.hh,
* oln/core/gen/op.hh,
* oln/core/internal/op_image_plus_nbh.hh,
* oln/core/internal/special_op.hh: New.
* oln/core/concept/image.hh (fwd_niter, bkd_niter, niter): New.
* oln/core/concept/neighborhood.hh (category): New.
(include): Add op_image_plus_nbh.hh.
(oln_decl_op_plus): New. Handle "Image + Neighborhood".
* oln/core/equipment.hh (left, right, oper, tag): New.
* oln/core/gen/single_value_image.hh: Fix.
* oln/core/internal/neighborhood_base.hh (category): New.
(neighborhood_base_): Fix inheritance.
* oln/core/internal/image_base.hh (image_extension_): New.
(image_base_): Add dpoint.
* oln/stc/scoop.hxx (vtypes, super_trait_): Add specialization
for const types.
(super_trait_): Handle error when not user-defined.
core/concept/image.hh | 5
core/concept/image_identity.hh | 292 +++++++++++++++++++++++++++++++++++++
core/concept/neighborhood.hh | 6
core/equipment.hh | 6
core/gen/op.hh | 162 ++++++++++++++++++++
core/gen/single_value_image.hh | 5
core/internal/image_base.hh | 35 ++++
core/internal/neighborhood_base.hh | 3
core/internal/op_image_plus_nbh.hh | 102 ++++++++++++
core/internal/special_op.hh | 76 +++++++++
debug/iota.hh | 56 +++++++
debug/print_nbh.hh | 101 ++++++++++++
stc/scoop.hxx | 21 ++
13 files changed, 863 insertions(+), 7 deletions(-)
Index: oln/debug/print_nbh.hh
--- oln/debug/print_nbh.hh (revision 0)
+++ oln/debug/print_nbh.hh (revision 0)
@@ -0,0 +1,101 @@
+// Copyright (C) 2007 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_DEBUG_PRINT_NBH_HH
+# define OLN_DEBUG_PRINT_NBH_HH
+
+# include <iostream>
+# include <oln/core/concept/image.hh>
+
+
+namespace oln
+{
+
+ namespace debug
+ {
+
+ // fwd decl
+ template <typename I>
+ void print_nbh(const Image_with_Nbh<I>& input, std::ostream& ostr =
std::cout);
+
+
+ namespace impl
+ {
+
+ // Image
+
+ template <typename I>
+ void print_nbh(const Image<I>&, const I& input, std::ostream&
ostr)
+ {
+ typename I::fwd_piter p(input.points());
+ typename I::fwd_niter n(p, input.nbhood());
+ for_all(p)
+ {
+ ostr << input(p) << ": ";
+ for_all(n)
+ if (input.owns_(n))
+ ostr << input(n) << " ";
+ ostr << std::endl;
+ }
+ }
+
+
+ // Point_Wise_Accessible_Image
+
+ template <typename I>
+ void print_nbh(const Point_Wise_Accessible_Image<I>&,const I& input,
std::ostream& ostr)
+ {
+ typename I::fwd_piter p(input.points());
+ typename I::fwd_niter n(p, input.nbhood());
+ for_all(p)
+ {
+ ostr << input(p) << ": ";
+ for_all(n)
+ if (input.has(n))
+ ostr << input(n) << " ";
+ ostr << std::endl;
+ }
+ }
+
+ } // end of namespace oln::debug::impl
+
+
+ // facade
+ template <typename I>
+ void print_nbh(const Image_with_Nbh<I>& input, std::ostream& ostr)
+ {
+ impl::print_nbh(exact(input), exact(input), ostr);
+ }
+
+
+
+ } // end of namespace oln::debug
+
+} // end of namespace oln
+
+
+#endif // ! OLN_DEBUG_PRINT_NBH_HH
Index: oln/debug/iota.hh
--- oln/debug/iota.hh (revision 0)
+++ oln/debug/iota.hh (revision 0)
@@ -0,0 +1,56 @@
+// Copyright (C) 2007 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_DEBUG_IOTA_HH
+# define OLN_DEBUG_IOTA_HH
+
+# include <oln/core/concept/image.hh>
+
+
+namespace oln
+{
+
+ namespace debug
+ {
+
+
+ template <typename I>
+ void iota(Mutable_Image<I>& in_out)
+ {
+ typename I::value v = 0;
+ typename I::fwd_piter p(in_out.points());
+ for_all(p)
+ in_out(p) = v++;
+ }
+
+
+ } // end of namespace oln::debug
+
+} // end of namespace oln
+
+
+#endif // ! OLN_DEBUG_IOTA_HH
Index: oln/core/concept/image.hh
--- oln/core/concept/image.hh (revision 858)
+++ oln/core/concept/image.hh (working copy)
@@ -142,6 +142,11 @@
public automatic::get_impl<Image_with_Nbh, Exact>
{
stc_typename(nbh);
+
+ stc_typename(fwd_niter);
+ stc_typename(bkd_niter);
+ typedef fwd_niter niter;
+
nbh nbhood() const;
protected:
Index: oln/core/concept/neighborhood.hh
--- oln/core/concept/neighborhood.hh (revision 858)
+++ oln/core/concept/neighborhood.hh (working copy)
@@ -29,6 +29,9 @@
# define OLN_CORE_CONCEPT_NEIGHBORHOOD_HH
# include <oln/core/equipment.hh>
+# include <oln/core/internal/op_image_plus_nbh.hh>
+
+
namespace oln
@@ -41,6 +44,7 @@
{
stc_typename(grid);
stc_typename(point);
+ stc_typename(category);
protected:
Neighborhood();
@@ -48,6 +52,8 @@
}; // end of oln::Neighborhood<Exact>
+ oln_decl_op_plus(Image, Neighborhood);
+
# ifndef OLN_INCLUDE_ONLY
Index: oln/core/concept/image_identity.hh
--- oln/core/concept/image_identity.hh (revision 0)
+++ oln/core/concept/image_identity.hh (revision 0)
@@ -0,0 +1,292 @@
+// Copyright (C) 2007 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_CONCEPT_IMAGE_IDENTITY_HH
+# define OLN_CORE_CONCEPT_IMAGE_IDENTITY_HH
+
+# include <oln/core/concept/image.hh>
+
+
+
+namespace oln
+{
+
+ namespace behavior { struct identity; }
+
+
+ namespace automatic
+ {
+
+
+ /// Concept-class "Image".
+
+ template <typename Exact>
+ struct set_impl< Image, behavior::identity, Exact > : public virtual
Any<Exact>
+ {
+ stc_typename(psite);
+ stc_typename(rvalue);
+ stc_typename(box);
+ stc_typename(pset);
+
+ bool impl_owns_(const psite& p) const;
+ rvalue impl_read(const psite& p) const;
+ box impl_bbox() const;
+ pset impl_points() const;
+ };
+
+
+ /// Concept-class "Image_with_Nbh".
+
+ template <typename Exact>
+ struct set_impl< Image_with_Nbh, behavior::identity, Exact > : public virtual
Any<Exact>
+ {
+ stc_typename(nbh);
+ nbh impl_nbhood() const;
+ };
+
+
+ /// Concept-class "Mutable_Image".
+
+ template <typename Exact>
+ struct set_impl< Mutable_Image, behavior::identity, Exact > : public virtual
Any<Exact>
+ {
+ stc_typename(psite);
+ stc_typename(lvalue);
+ lvalue impl_read_write(const psite& p);
+ };
+
+
+ /// Concept-class "Fast_Image".
+
+ template <typename Exact>
+ struct set_impl< Fast_Image, behavior::identity, Exact > : public virtual
Any<Exact>
+ {
+ stc_typename(rvalue);
+ stc_typename(lvalue);
+ stc_typename(index);
+
+ rvalue impl_index_read(index i) const;
+ lvalue impl_index_read_write(index i);
+ std::size_t impl_npoints() const;
+ };
+
+
+ /// Concept-class "Point_Wise_Accessible_Image".
+
+ template <typename Exact>
+ struct set_impl< Point_Wise_Accessible_Image, behavior::identity, Exact > :
public virtual Any<Exact>
+ {
+ stc_typename(point);
+ bool impl_has(const point& p) const;
+ };
+
+
+ /// Concept-class "Value_Wise_Accessible_Image".
+
+ template <typename Exact>
+ struct set_impl< Value_Wise_Accessible_Image, behavior::identity, Exact > :
public virtual Any<Exact>
+ {
+ stc_typename(vsite);
+ stc_typename(rvaluep);
+ rvaluep impl_value_read(const vsite& v) const;
+ };
+
+
+ /// Concept-class "Value_Wise_Mutable_Image".
+
+ template <typename Exact>
+ struct set_impl< Value_Wise_Mutable_Image, behavior::identity, Exact > : public
virtual Any<Exact>
+ {
+ stc_typename(vsite);
+ stc_typename(lvaluep);
+ lvaluep impl_value_read_write(const vsite& v);
+ };
+
+
+ /// Concept-class "Image_1D".
+
+ template <typename Exact>
+ struct set_impl< Image_1D, behavior::identity, Exact > : public virtual
Any<Exact>
+ {
+ };
+
+
+ /// Concept-class "Image_2D".
+
+ template <typename Exact>
+ struct set_impl< Image_2D, behavior::identity, Exact > : public virtual
Any<Exact>
+ {
+ };
+
+
+ /// Concept-class "Image_3D".
+
+ template <typename Exact>
+ struct set_impl< Image_3D, behavior::identity, Exact > : public virtual
Any<Exact>
+ {
+ };
+
+
+ /// Concept-class "Point_Wise_Accessible_Image_2D".
+
+ template <typename Exact>
+ struct set_impl< Point_Wise_Accessible_Image_2D, behavior::identity, Exact > :
public virtual Any<Exact>
+ {
+ // default code is provided in Point_Wise_Accessible_Image_2D<Exact>
+ };
+
+
+ /// Concept-class "Point_Wise_Mutable_Image_2D".
+
+ template <typename Exact>
+ struct set_impl< Point_Wise_Mutable_Image_2D, behavior::identity, Exact > :
public virtual Any<Exact>
+ {
+ // default code is provided in Point_Wise_Mutable_Image_2D<Exact>
+ };
+
+
+
+
+
+
+# ifndef OLN_INCLUDE_ONLY
+
+
+ /// Concept-class "Image".
+
+ template <typename Exact>
+ bool
+ set_impl< Image, behavior::identity, Exact >::impl_owns_(const typename
set_impl< Image, behavior::identity, Exact >::psite& p) const
+ {
+ return exact(this)->image().owns_(p);
+ }
+
+ template <typename Exact>
+ typename set_impl< Image, behavior::identity, Exact >::rvalue
+ set_impl< Image, behavior::identity, Exact >::impl_read(const typename
set_impl< Image, behavior::identity, Exact >::psite& p) const
+ {
+ return exact(this)->image()(p);
+ }
+
+ template <typename Exact>
+ typename set_impl< Image, behavior::identity, Exact >::box
+ set_impl< Image, behavior::identity, Exact >::impl_bbox() const
+ {
+ return exact(this)->image().bbox();
+ }
+
+ template <typename Exact>
+ typename set_impl< Image, behavior::identity, Exact >::pset
+ set_impl< Image, behavior::identity, Exact >::impl_points() const
+ {
+ return exact(this)->image().points();
+ }
+
+
+ /// Concept-class "Image_with_Nbh".
+
+ template <typename Exact>
+ typename set_impl< Image_with_Nbh, behavior::identity, Exact >::nbh
+ set_impl< Image_with_Nbh, behavior::identity, Exact >::impl_nbhood() const
+ {
+ return exact(this)->image().nbhood();
+ }
+
+
+ /// Concept-class "Mutable_Image".
+
+ template <typename Exact>
+ typename set_impl< Mutable_Image, behavior::identity, Exact >::lvalue
+ set_impl< Mutable_Image, behavior::identity, Exact >::impl_read_write(const
typename set_impl< Mutable_Image, behavior::identity, Exact >::psite& p)
+ {
+ return exact(this)->image().operator()(p);
+ }
+
+
+ /// Concept-class "Fast_Image".
+
+ template <typename Exact>
+ typename set_impl< Fast_Image, behavior::identity, Exact >::rvalue
+ set_impl< Fast_Image, behavior::identity, Exact >::impl_index_read(typename
set_impl< Fast_Image, behavior::identity, Exact >::index i) const
+ {
+ return exact(this)->image()[i];
+ }
+
+ template <typename Exact>
+ typename set_impl< Fast_Image, behavior::identity, Exact >::lvalue
+ set_impl< Fast_Image, behavior::identity, Exact
>::impl_index_read_write(typename set_impl< Fast_Image, behavior::identity, Exact
>::index i)
+ {
+ return exact(this)->image()[i];
+ }
+
+ template <typename Exact>
+ std::size_t
+ set_impl< Fast_Image, behavior::identity, Exact >::impl_npoints() const
+ {
+ return exact(this)->image().npoints();
+ }
+
+
+ /// Concept-class "Point_Wise_Accessible_Image".
+
+ template <typename Exact>
+ bool
+ set_impl< Point_Wise_Accessible_Image, behavior::identity, Exact
>::impl_has(const typename set_impl< Point_Wise_Accessible_Image,
behavior::identity, Exact >::point& p) const
+ {
+ return exact(this)->image().has(p);
+ }
+
+
+ /// Concept-class "Value_Wise_Accessible_Image".
+
+ template <typename Exact>
+ typename set_impl< Value_Wise_Accessible_Image, behavior::identity, Exact
>::rvaluep
+ set_impl< Value_Wise_Accessible_Image, behavior::identity, Exact
>::impl_value_read(const typename set_impl< Value_Wise_Accessible_Image,
behavior::identity, Exact >::vsite& v) const
+ {
+ return exact(this)->image().value(v);
+ }
+
+
+ /// Concept-class "Value_Wise_Mutable_Image".
+
+ template <typename Exact>
+ typename set_impl< Value_Wise_Mutable_Image, behavior::identity, Exact
>::lvaluep
+ set_impl< Value_Wise_Mutable_Image, behavior::identity, Exact
>::impl_value_read_write(const typename set_impl< Value_Wise_Mutable_Image,
behavior::identity, Exact >::vsite& v)
+ {
+ return exact(this)->image().value(v);
+ }
+
+
+# endif
+
+
+ } // end of namespace oln::automatic
+
+} // end of namespace oln
+
+
+#endif // ! OLN_CORE_CONCEPT_IMAGE_IDENTITY_HH
Index: oln/core/equipment.hh
--- oln/core/equipment.hh (revision 858)
+++ oln/core/equipment.hh (working copy)
@@ -66,6 +66,7 @@
stc_decl_associated_type( index );
// l
+ stc_decl_associated_type( left );
stc_decl_associated_type( lvalue );
stc_decl_associated_type( lvaluep );
@@ -75,6 +76,7 @@
stc_decl_associated_type( niter );
// o
+ stc_decl_associated_type( oper );
stc_decl_associated_type( output );
// p
@@ -87,12 +89,16 @@
stc_decl_associated_type( qiter );
// r
+ stc_decl_associated_type( right );
stc_decl_associated_type( rvalue );
stc_decl_associated_type( rvaluep );
// s
stc_decl_associated_type( std_container );
+ // t
+ stc_decl_associated_type( tag );
+
// v
stc_decl_associated_type( value );
stc_decl_associated_type( vsite );
Index: oln/core/gen/op.hh
--- oln/core/gen/op.hh (revision 0)
+++ oln/core/gen/op.hh (revision 0)
@@ -0,0 +1,162 @@
+// Copyright (C) 2007 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_OP_HH
+# define OLN_CORE_GEN_OP_HH
+
+# include <oln/core/internal/special_op.hh>
+
+
+
+// Macro.
+
+# define oln_decl_op_(OpName, Lconcept, OpSym, Rconcept) \
+ \
+ template <typename L, typename R> \
+ op_<L, OpName, R> \
+ operator OpSym (Lconcept<L>& lhs, Rconcept<R>& rhs) \
+ { \
+ op_<L, OpName, R> tmp(exact(lhs), exact(rhs)); \
+ return tmp; \
+ } \
+ \
+ template <typename L, typename R> \
+ op_<L, OpName, const R> \
+ operator OpSym (Lconcept<L>& lhs, const Rconcept<R>& rhs) \
+ { \
+ op_<L, OpName, const R> tmp(exact(lhs), exact(rhs)); \
+ return tmp; \
+ } \
+ \
+ template <typename L, typename R> \
+ op_<const L, OpName, R> \
+ operator OpSym (const Lconcept<L>& lhs, Rconcept<R>& rhs) \
+ { \
+ op_<const L, OpName, R> tmp(exact(lhs), exact(rhs)); \
+ return tmp; \
+ } \
+ \
+ template <typename L, typename R> \
+ op_<const L, OpName, const R> \
+ operator OpSym (const Lconcept<L>& lhs, const Rconcept<R>& rhs) \
+ { \
+ op_<const L, OpName, const R> tmp(exact(lhs), exact(rhs)); \
+ return tmp; \
+ } \
+ \
+ struct e_n_d___w_i_t_h___a___s_e_m_i___c_o_l_u_m_n
+
+
+# define oln_decl_op_plus(Lconcept, Rconcept) oln_decl_op_(plus, Lconcept, +,
Rconcept)
+# define oln_decl_op_such_as(Lconcept, Rconcept) oln_decl_op_(such_as, Lconcept, |,
Rconcept)
+// ...
+
+
+
+
+# define oln_category_of_(Type) typename oln::internal::category_of_<Type>::ret
+
+
+namespace oln
+{
+
+
+ namespace internal
+ {
+ template <typename T>
+ struct category_of_
+ {
+ typedef stc_type(T, category) ret;
+ };
+
+ // ...
+
+ } // end of namespace oln::internal
+
+
+
+ /// \{
+ /// Operator Names.
+
+ struct plus;
+ struct such_as;
+
+ /// \}
+
+
+
+ // Fwd decl.
+ template <typename L, typename OpName, typename R> class op_;
+
+
+ /// Virtual types.
+ template <typename L, typename OpName, typename R>
+ struct vtypes< op_<L, OpName, R> >
+ {
+ };
+
+
+ /// Super type.
+
+# define super \
+ internal::special_op_< oln_category_of_(L), L, OpName, oln_category_of_(R), R >
+
+ template <typename L, typename OpName, typename R>
+ struct super_trait_< op_<L, OpName, R> >
+ {
+ typedef super ret;
+ };
+
+
+ /// Class for result of "L op R".
+
+ template <typename L, typename OpName, typename R>
+ class op_ : public super
+ {
+ public:
+ op_(L& l, R& r);
+
+ }; // end of op_<L, OpName, R>
+
+
+
+# ifndef OLN_INCLUDE_ONLY
+
+ template <typename L, typename OpName, typename R>
+ op_<L, OpName, R>::op_(L& l, R& r)
+ : super (l, r)
+ {
+ }
+
+# endif
+
+# undef super
+
+} // end of namespace oln
+
+
+#endif // ! OLN_CORE_GEN_OP_HH
Index: oln/core/gen/single_value_image.hh
--- oln/core/gen/single_value_image.hh (revision 858)
+++ oln/core/gen/single_value_image.hh (working copy)
@@ -54,11 +54,6 @@
typedef const T& rvalue;
typedef internal::pair<Ps, T> data;
-
- // FIXME: To be defined...
- typedef mlc::none qiter;
- typedef mlc::none fwd_qiter;
- typedef mlc::none bkd_qiter;
};
Index: oln/core/internal/neighborhood_base.hh
--- oln/core/internal/neighborhood_base.hh (revision 858)
+++ oln/core/internal/neighborhood_base.hh (working copy)
@@ -56,6 +56,7 @@
typedef stc_deferred(point) point__;
typedef stc::final< stc_type(point__, grid) > grid;
+ typedef stc::final< stc::is<Neighborhood> > category;
};
@@ -65,7 +66,7 @@
/// Base class for implementation of neighborhoods class.
template <typename Exact>
- class neighborhood_base_ : public Neighborhood< neighb_<Exact> >
+ class neighborhood_base_ : public Neighborhood<Exact>
{
protected:
neighborhood_base_();
Index: oln/core/internal/op_image_plus_nbh.hh
--- oln/core/internal/op_image_plus_nbh.hh (revision 0)
+++ oln/core/internal/op_image_plus_nbh.hh (revision 0)
@@ -0,0 +1,102 @@
+// Copyright (C) 2007 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_INTERNAL_OP_IMAGE_PLUS_NBH_HH
+# define OLN_CORE_INTERNAL_OP_IMAGE_PLUS_NBH_HH
+
+# include <oln/core/gen/op.hh>
+# include <oln/core/gen/dpoints_piter.hh>
+# include <oln/core/internal/image_base.hh>
+
+
+namespace oln
+{
+
+ /// Fwd decls.
+ template <typename Exact> struct Image;
+ template <typename Exact> struct Neighborhood;
+
+
+ /// Super type.
+ template <typename I, typename N>
+ struct super_trait_< internal::special_op_<stc::is<Image>, I, plus,
stc::is<Neighborhood>, N> >
+ {
+ typedef internal::image_extension_< op_<I, plus, N> > ret;
+ };
+
+
+ /// Virtual types.
+ template <typename I, typename N>
+ struct vtypes< internal::special_op_<stc::is<Image>, I, plus,
stc::is<Neighborhood>, N> >
+ {
+ typedef op_<I, plus, N> Exact;
+ typedef stc_type(I, point) point__;
+
+ typedef I delegatee;
+ typedef internal::pair<I,N> data;
+
+ typedef N nbh;
+ typedef dpoints_fwd_piter_<point__> fwd_niter;
+ typedef dpoints_bkd_piter_<point__> bkd_niter;
+ };
+
+
+ namespace internal
+ {
+
+ /// Implementation class the result of "Image I + Neighborhood N".
+
+ template <typename I, typename N>
+ class special_op_< stc::is<Image>, I, plus, stc::is<Neighborhood>, N
>
+ :
+ public internal::image_extension_< op_<I, plus, N> >
+ {
+ typedef internal::image_extension_< op_<I, plus, N> > super;
+ public:
+ stc_using(nbh);
+ stc_using(data);
+ stc_using(delegatee);
+
+ delegatee& impl_image() { assert(this->has_data()); return
this->data_->value1; }
+ const delegatee& impl_image() const { assert(this->has_data()); return
this->data_->value1; }
+
+ nbh impl_nbhood() const { assert(this->has_data()); return
this->data_->value2; }
+
+ protected:
+ special_op_(I& ima, N& n)
+ {
+ this->data_ = new data(ima, n);
+ }
+ };
+
+
+ } // end of namespace oln::internal
+
+} // end of namespace oln
+
+
+#endif // ! OLN_CORE_INTERNAL_OP_IMAGE_PLUS_NBH_HH
Index: oln/core/internal/image_base.hh
--- oln/core/internal/image_base.hh (revision 858)
+++ oln/core/internal/image_base.hh (working copy)
@@ -29,10 +29,11 @@
# define OLN_CORE_INTERNAL_IMAGE_BASE_HH
# include <oln/core/internal/image_selectors.hh>
+# include <oln/core/concept/image_identity.hh>
+
# include <oln/core/internal/tracked_ptr.hh>
# include <oln/core/internal/utils.hh>
# include <oln/core/gen/box.hh>
-# include <oln/core/gen/image_pset_piter.hh>
@@ -50,6 +51,7 @@
template <typename Exact> struct image_morpher_;
template <typename Exact> struct single_image_morpher_;
+ template <typename Exact> struct image_extension_;
template <typename Exact> struct multiple_image_morpher_;
}
@@ -87,6 +89,12 @@
};
template <typename Exact>
+ struct super_trait_< internal::image_extension_<Exact> >
+ {
+ typedef internal::single_image_morpher_<Exact> ret;
+ };
+
+ template <typename Exact>
struct super_trait_< internal::multiple_image_morpher_<Exact> >
{
typedef internal::image_morpher_<Exact> ret;
@@ -122,6 +130,7 @@
typedef stc::final< stc::is<Image> > category;
typedef stc::final< box_<point__> > box;
typedef stc::final< stc_type(point__, grid) > grid;
+ typedef stc::final< stc_type(point__, dpoint) > dpoint;
typedef stc::final< typename pset__::fwd_piter > fwd_piter;
typedef stc::final< typename pset__::bkd_piter > bkd_piter;
typedef fwd_piter piter;
@@ -145,6 +154,7 @@
struct vtypes< internal::image_morpher_<Exact> >
{
typedef stc::abstract delegatee;
+ typedef stc::abstract behavior;
typedef stc::not_delegated data;
};
@@ -154,6 +164,12 @@
};
template <typename Exact>
+ struct vtypes< internal::image_extension_<Exact> >
+ {
+ typedef stc::final< behavior::identity > behavior;
+ };
+
+ template <typename Exact>
struct vtypes< internal::multiple_image_morpher_<Exact> >
{
typedef stc::abstract n;
@@ -239,6 +255,16 @@
};
+ /// image_extension_<Exact>
+
+ template <typename Exact>
+ class image_extension_ : public single_image_morpher_<Exact>
+ {
+ protected:
+ image_extension_();
+ };
+
+
/// multiple_image_morpher_<Exact>
template <typename Exact>
@@ -320,6 +346,13 @@
{
}
+ // image_extension_<Exact>
+
+ template <typename Exact>
+ image_extension_<Exact>::image_extension_()
+ {
+ }
+
// multiple_image_morpher_<Exact>
template <typename Exact>
Index: oln/core/internal/special_op.hh
--- oln/core/internal/special_op.hh (revision 0)
+++ oln/core/internal/special_op.hh (revision 0)
@@ -0,0 +1,76 @@
+// Copyright (C) 2007 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_INTERNAL_SPECIAL_OP_HH
+# define OLN_CORE_INTERNAL_SPECIAL_OP_HH
+
+# include <oln/core/internal/image_base.hh>
+
+
+namespace oln
+{
+
+
+ // Fwd decls.
+ namespace internal {
+ template <typename Lcat, typename L, typename OpName, typename Rcat, typename
R>
+ class special_op_;
+ }
+ template <typename L, typename OpName, typename R> class op_;
+
+
+ /// Virtual types.
+ template <typename Lcat, typename L, typename OpName, typename Rcat, typename R>
+ struct vtypes< internal::special_op_<Lcat, L, OpName, Rcat, R> >
+ /* undefined; to be specialized... */
+ ;
+
+
+ /// Super type.
+ template <typename Lcat, typename L, typename OpName, typename Rcat, typename R>
+ struct super_trait_< internal::special_op_<Lcat, L, OpName, Rcat, R> >
+ /* undefined; to be specialized... */
+ ;
+
+
+ namespace internal
+ {
+
+ /// Class for result of "L op R".
+
+ template <typename Lcat, typename L, typename OpName, typename Rcat, typename
R>
+ class special_op_;
+ /* undefined; to be specialized... */
+
+
+ } // end of namespace oln::internal
+
+
+} // end of namespace oln
+
+
+#endif // ! OLN_CORE_INTERNAL_SPECIAL_OP_HH
Index: oln/stc/scoop.hxx
--- oln/stc/scoop.hxx (revision 858)
+++ oln/stc/scoop.hxx (working copy)
@@ -56,6 +56,9 @@
struct no_delegatee_declared_;
+ template <typename T>
+ struct super_trait_not_defined_for_;
+
} /* end of namespace ERROR */
@@ -69,6 +72,11 @@
{
};
+template <typename from_type>
+struct vtypes <const from_type> : public vtypes <from_type>
+{
+};
+
template <typename from_type, typename type>
struct single_vtype
{
@@ -77,17 +85,30 @@
+/* super_trait_ */
template <typename from_type>
struct super_trait_;
+template <typename from_type>
+struct super_trait_ <const from_type> : super_trait_<from_type>
+{
+};
+
template <template <class> class abstraction, typename Exact>
struct super_trait_< abstraction<Exact> >
{
typedef mlc::none ret;
};
+template <typename from_type>
+struct super_trait_ :
+ mlc::abort_< ERROR::super_trait_not_defined_for_<from_type> >
+{
+ typedef mlc::none ret;
+};
+