https://svn.lrde.epita.fr/svn/oln/trunk/olena
Index: ChangeLog
from Roland Levillain <roland(a)lrde.epita.fr>
Extend morpher adding a look-up table (oln::morpher::with_lut).
* oln/core/abstract/image/hierarchies.hh
(image_hierarchy_wrt_value_wise_accessibility): New hierarchy.
(image_hybrid_hierarchy_wrt_classical)
(image_hierarchy_wrt_value, image_hierarchy_wrt_data_retrieval):
Adjust numbers.
* oln/core/abstract/image/all.hh
(oln/core/abstract/image/value_wise_accessibility/hierarchy.hh):
Include it.
Adjust.
* oln/core/abstract/image/value_wise_accessibility/hierarchy.hh: New.
* oln/core/automatic/image/image_being_value_wise_random_accessible.hh:
New.
* oln/core/internal/fwd_viter_lut.hh,
* oln/core/gen/fwd_viter_lut.hh: New.
* oln/core/typedefs.hh (fwd_viter_type, mutable_fwd_viter_type)
(lut_type, lut_iter_type): New virtual types declarations.
* oln/core/lookup_table.hh (lookup_table): Rename the first two
parameters to Orig_Value and New_Value.
Add two parameters Orig_Value_Compare and New_Value_Compare,
defaulting to std::less<Orig_Value> and std::less<New_Value>
respectively.
(lookup_table::key_type, lookup_table::data_type): Rename typedefs
as...
(lookup_table::orig_value_type, lookup_table::new_value_type):
...these.
(lookup_table::map_type): Remove typedef.
(lookup_table::orig_value_type, lookup_table::new_value_type)
(lookup_table::const_iterator, lookup_table::iterator): New
typedefs.
Adjust signatures of methods.
(lookup_table::map): Remove method.
(lookup_table::begin, lookup_table::end, lookup_table::find)
(lookup_table::orig_to_new_map, lookup_table::new_to_orig_map):
New methods.
(lookup_table::map_): Remove attributes.
(lookup_table::orig_to_new_map_, lookup_table::new_to_orig_map_):
New attributes.
(lookup_table::add): Adjust method.
* oln/morpher/with_lut.hh: Adjust.
(single_vtype<morpher::with_lut<Image, Lut>, typedef_::fwd_viter_type>)
(single_vtype<morpher::with_lut<Image ,Lut>,
typedef_::mutable_fwd_viter_type>):
New.
(with_lut::lut_t, with_lut::value_t, with_lut::rvalue_t)
(with_lut::psite_t): Rename typedefs as...
(with_lut::lut_type, with_lut::value_type, with_lut::rvalue_type)
(with_lut::psite_type): ...these.
Adjust.
(with_lut::fwd_viter_type, with_lut::mutable_fwd_viter_type):
New typedefs.
(with_lut::impl_value): New methods.
(operator+ (const abstract::image<I>&, const lookup_table<K, D>&)):
Turn into...
(operator+ (const abstract::image<I>&, lookup_table<K, D>&)):
...this.
Adjust.
* tests/morphers/with_lut.cc: Augment this test.
* oln/value/color/rgb.hh
(rgb_<T>::operator==(const rgb_<U>&)): New operator.
* TODO: New.
TODO | 23
oln/core/abstract/image/all.hh | 6
oln/core/abstract/image/hierarchies.hh | 7
oln/core/abstract/image/value_wise_accessibility/hierarchy.hh | 154 +++++
oln/core/automatic/image/image_being_value_wise_random_accessible.hh | 104 +++
oln/core/gen/fwd_viter_lut.hh | 302 ++++++++++
oln/core/internal/fwd_viter_lut.hh | 171 +++++
oln/core/iterator_vtypes.hh | 2
oln/core/lookup_table.hh | 185 ++++--
oln/core/typedefs.hh | 15
oln/morpher/slice.hh | 5
oln/morpher/with_lut.hh | 101 ++-
oln/value/color/rgb.hh | 14
tests/morphers/with_lut.cc | 106 ++-
14 files changed, 1093 insertions(+), 102 deletions(-)
Index: tests/morphers/with_lut.cc
--- tests/morphers/with_lut.cc (revision 684)
+++ tests/morphers/with_lut.cc (working copy)
@@ -34,17 +34,65 @@
#include <oln/debug/print.hh>
-// FIXME: Remove.
-using namespace oln;
-
+// A simple (fake) routine.
template <typename I>
void image_test(const oln::abstract::image<I>&)
{
// Do nothing.
}
+
+/*--------------------------------------------------------------.
+| Equipment of the new value type of the look-up table (rgb8). |
+`--------------------------------------------------------------*/
+
oln::value::color::rgb8 white(255, 255, 255);
oln::value::color::rgb8 blue ( 0, 0, 255);
+oln::value::color::rgb8 red (255, 0, 0);
+
+// We don't want to equip rgb8 with an operator<, nor to specialize
+// std::less, so we pass the functor rgb8_less_t as fourth parameter
+// of the look-up table.
+xtd::lexi_less_t lexi_less;
+struct rgb8_less_t
+{
+ bool operator()(const oln::value::color::rgb8& lhs,
+ const oln::value::color::rgb8& rhs) const
+ {
+ return lexi_less(lhs.to_vec(), rhs.to_vec());
+ }
+};
+
+// FIXME: Move this elsewhere?
+namespace oln
+{
+ std::ostream&
+ operator<< (std::ostream& ostr, value::color::rgb8 val)
+ {
+ // The static_cast are needed because components of rgb8 are
+ // unsigned chars, printed as a classic chars.
+ ostr << "("
+ << static_cast<int>(val.red()) << ", "
+ << static_cast<int>(val.green()) << ", "
+ << static_cast<int>(val.blue())
+ << ")";
+ return ostr;
+ }
+
+} // end of namespace oln
+
+
+/*---------------------.
+| Look-up table type. |
+`---------------------*/
+
+typedef oln::lookup_table< unsigned, oln::value::color::rgb8,
+ std::less<unsigned>, rgb8_less_t > lut_t;
+
+
+/*-------.
+| Test. |
+`-------*/
int main()
{
@@ -52,45 +100,53 @@
unsigned data[] = { 0, 1, 2, 0, 1, 2, 0, 1, 2};
- typedef image2d<unsigned> image_t;
+ typedef oln::image2d<unsigned> image_t;
image_t ima(3, 3);
- level::fill(ima, data);
- debug::print(ima);
+ oln::level::fill(ima, data);
+ oln::debug::print(ima);
- typedef lookup_table<unsigned, rgb8> lut_t;
lut_t lut;
rgb8 c(16, 6, 4);
lut.
add(0, blue).
add(1, white).
add(2, c);
- std::cout << lut << std::endl;
- typedef morpher::with_lut<image_t, lut_t> lutimage_t;
- lutimage_t ima2 = ima + lut;
+ typedef oln::morpher::with_lut<image_t, lut_t> image_with_lut_t;
+ // FIXME: ``ima + lut'' doesn't work. Maybe a `using' statement is
+ // required.
+ image_with_lut_t ima_with_lut(ima, lut);
+
+#if 0
+ // Disable the display to speed up the test.
+ std::cout << "lut = " << std::endl << ima_with_lut.lut()
<< std::endl;
+ oln::debug::print(ima_with_lut);
+ std::cout << std::endl;
+#endif
- // ima2 is an image, and can be as argument to to image routines.
- image_test(ima2);
+ image_test(ima_with_lut);
- // FIXME: To be enabled later.
#if 0
- // it is value-wise accessible:
- ima2.value(c) = red;
+ std::cout << ima_with_lut.value(c) << std::endl;
#endif
- // let's look at it
- debug::print(ima2);
+ // Change a value in the LUT.
+ ima_with_lut.value(c) = red;
+
+#if 0
+ // Disable the display to speed up the test.
+ std::cout << "lut = " << std::endl << ima_with_lut.lut()
<< std::endl;
+ oln::debug::print(ima_with_lut);
std::cout << std::endl;
+#endif
- // it is a 2D image so we have:
- point2d p(1, 1);
- std::cout << "ima2(p) =" << ima2(p) << std::endl;
- // or (likewise):
- std::cout << "ima2.at(1, 1) =" << ima2.at(1, 1) <<
std::endl;
+ oln::point2d p(1, 2);
+ assert(ima_with_lut(p) == red);
+ assert(ima_with_lut.at(1, 2) == red);
- // FIXME: To be enabled later.
+ // FIXME: To be enabled later, when oln::level::fill is specialized
+ // for abstract::mutable_image_being_value_wise_random_accessible.
#if 0
- // FIXME...
- level::apply(ima2, fun); // 3 ops only !!!
+ oln::level::apply(ima_with_lut, fun); // 3 ops only !!!
#endif
}
Index: TODO
--- TODO (revision 0)
+++ TODO (revision 0)
@@ -0,0 +1,23 @@
+* Renaming
+
+** point_accessibility
+
+Rename oln/core/abstract/image/accessibility
+into oln/core/abstract/image/point_wise_accessibility;
+rename structures as well, and adjust clients.
+
+** lvalue vs wvalue
+
+Rename lvalue (``left value'') as wvalue (``writable value'')?
+(Recall that rvalue can stand for either ``right-value'' or ``readable
+value'', even if the latter makes more sense).
+
+Or even, rename rvalue and lvalue as ro_value (read-only) and rw_value
+(read-write).
+
+
+
+Local Variables:
+mode: outline
+ispell-local-dictionary: "american"
+End:
Index: oln/core/typedefs.hh
--- oln/core/typedefs.hh (revision 684)
+++ oln/core/typedefs.hh (working copy)
@@ -90,6 +90,7 @@
// mlc_decl_typedef(iter_type);
// mlc_decl_typedef(fwd_iter_type);
// mlc_decl_typedef(bkd_iter_type);
+// --------------------------------------------------------------------
mlc_decl_typedef(piter_type);
mlc_decl_typedef(fwd_piter_type);
@@ -102,7 +103,11 @@
mlc_decl_typedef(niter_type);
mlc_decl_typedef(fwd_niter_type);
mlc_decl_typedef(bkd_niter_type);
-// --------------------------------------------------------------------
+
+ mlc_decl_typedef(fwd_viter_type);
+ mlc_decl_typedef(mutable_fwd_viter_type);
+ // FIXME: bkd_viter_type.
+ // FIXME: mutable_bkd_viter_type.
/*----------------------.
@@ -189,6 +194,14 @@
mlc_decl_typedef(vec_type);
+ /*-------------------------.
+ | category::lookup_table. |
+ `-------------------------*/
+
+ mlc_decl_typedef(lut_type);
+ mlc_decl_typedef(lut_iter_type);
+
+
/*------------------------------------.
| category::fun1 and category::fun2. |
`------------------------------------*/
Index: oln/core/automatic/image/image_being_value_wise_random_accessible.hh
--- oln/core/automatic/image/image_being_value_wise_random_accessible.hh (revision 0)
+++ oln/core/automatic/image/image_being_value_wise_random_accessible.hh (revision 0)
@@ -0,0 +1,104 @@
+// 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_AUTOMATIC_IMAGE_IMAGE_BEING_VALUE_WISE_RANDOM_ACCESSIBLE_HH
+# define OLN_CORE_AUTOMATIC_IMAGE_IMAGE_BEING_VALUE_WISE_RANDOM_ACCESSIBLE_HH
+
+# include <oln/core/automatic/impl.hh>
+# include <oln/morpher/tags.hh>
+
+
+namespace oln
+{
+
+ // Forward declaration.
+ namespace abstract
+ {
+ template <typename E> class image_being_value_wise_random_accessible;
+ template <typename E> class mutable_image_being_value_wise_random_accessible;
+
+ } // end of namespace oln::abstract
+
+
+ namespace automatic
+ {
+
+ /// Default implementation corresponding to the interface
+ /// oln::abstract::image_being_value_wise_random_accessible.
+ template <typename E, typename M>
+ class set_impl<abstract::image_being_value_wise_random_accessible, M, E> :
+ public virtual stc::any__simple<E>
+ {
+ public:
+ typedef oln_type_of(E, value) value_type;
+ typedef oln_type_of(E, fwd_viter) fwd_viter_type;
+
+ public:
+ fwd_viter_type impl_value(const value_type& v) const;
+ };
+
+
+ /// Default implementation corresponding to the interface
+ /// oln::abstract::mutable_image_being_value_wise_random_accessible.
+ template <typename E, typename M>
+ class set_impl<abstract::mutable_image_being_value_wise_random_accessible,
+ M, E> :
+ public virtual stc::any__simple<E>
+ {
+ public:
+ typedef oln_type_of(E, value) value_type;
+ typedef oln_type_of(E, fwd_viter) fwd_viter_type;
+
+ public:
+ fwd_viter_type impl_value(const value_type& v);
+ };
+
+
+
+# ifndef OLN_INCLUDE_ONLY
+
+ template <typename E, typename M>
+ typename set_impl<abstract::image_being_value_wise_random_accessible, M,
E>::fwd_viter_type
+ set_impl<abstract::image_being_value_wise_random_accessible, M,
E>::impl_value(const typename
set_impl<abstract::image_being_value_wise_random_accessible, M, E>::value_type&
v) const
+ {
+ return this->exact().delegate().value(v);
+ }
+
+ template <typename E, typename M>
+ typename set_impl<abstract::mutable_image_being_value_wise_random_accessible, M,
E>::fwd_viter_type
+ set_impl<abstract::mutable_image_being_value_wise_random_accessible, M,
E>::impl_value(const typename
set_impl<abstract::mutable_image_being_value_wise_random_accessible, M,
E>::value_type& v)
+ {
+ return this->exact().delegate().value(v);
+ }
+
+# endif
+
+ } // end of namespace oln::automatic
+
+} // end of namespace oln
+
+#endif // ! OLN_CORE_AUTOMATIC_IMAGE_IMAGE_BEING_VALUE_WISE_RANDOM_ACCESSIBLE_HH
Index: oln/core/iterator_vtypes.hh
--- oln/core/iterator_vtypes.hh (revision 684)
+++ oln/core/iterator_vtypes.hh (working copy)
@@ -33,7 +33,6 @@
# include <oln/core/1d/aliases.hh>
# include <oln/core/2d/aliases.hh>
# include <oln/core/3d/aliases.hh>
-// # include <oln/core/type_fun/slice.hh>
namespace oln
@@ -272,7 +271,6 @@
};
-
} // end of namespace oln
Index: oln/core/abstract/image/hierarchies.hh
--- oln/core/abstract/image/hierarchies.hh (revision 684)
+++ oln/core/abstract/image/hierarchies.hh (working copy)
@@ -41,13 +41,14 @@
typedef hierarchy<abstract::image, 5> image_hierarchy_wrt_accessibility;
typedef hierarchy<abstract::image, 6> image_hierarchy_wrt_mutability;
typedef hierarchy<abstract::image, 7> image_hierarchy_wrt_computability;
+ typedef hierarchy<abstract::image, 8>
image_hierarchy_wrt_value_wise_accessibility;
- typedef hierarchy<abstract::image, 8> image_hybrid_hierarchy_wrt_classical;
+ typedef hierarchy<abstract::image, 9> image_hybrid_hierarchy_wrt_classical;
// FIXME: To be continued.
#if 0
- typedef hierarchy<abstract::image, 9> image_hierarchy_wrt_value;
- typedef hierarchy<abstract::image, 10> image_hierarchy_wrt_data_retrieval;
+ typedef hierarchy<abstract::image, 10> image_hierarchy_wrt_value;
+ typedef hierarchy<abstract::image, 11> image_hierarchy_wrt_data_retrieval;
// ...
#endif
Index: oln/core/abstract/image/all.hh
--- oln/core/abstract/image/all.hh (revision 684)
+++ oln/core/abstract/image/all.hh (working copy)
@@ -40,14 +40,16 @@
# include <oln/core/abstract/image/neighborhood/hierarchy.hh>
// Hierarchy 4: image w.r.t. bounding box.
# include <oln/core/abstract/image/bbox/hierarchy.hh>
-// Hierarchy 5: image w.r.t. accessibility.
+// Hierarchy 5: image w.r.t. point accessibility.
# include <oln/core/abstract/image/accessibility/hierarchy.hh>
// Hierarchy 6: image w.r.t. data mutability.
# include <oln/core/abstract/image/mutability/hierarchy.hh>
// Hierarchy 7: image w.r.t. computability.
# include <oln/core/abstract/image/computability/hierarchy.hh>
+// Hierarchy 8: image w.r.t. value-wise accessibility.
+# include <oln/core/abstract/image/value_wise_accessibility/hierarchy.hh>
-// Hybrid hierarchy 8: image w.r.t. classical features.
+// (Hybrid) hierarchy 9: image w.r.t. classical features.
# include <oln/core/abstract/image/hybrid/classical.hh>
#endif // ! OLN_CORE_ABSTRACT_IMAGE_ALL_HH
Index: oln/core/abstract/image/value_wise_accessibility/hierarchy.hh
--- oln/core/abstract/image/value_wise_accessibility/hierarchy.hh (revision 0)
+++ oln/core/abstract/image/value_wise_accessibility/hierarchy.hh (revision 0)
@@ -0,0 +1,154 @@
+// 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_ABSTRACT_IMAGE_VALUE_WISE_ACCESSIBILITY_HIERARCHY_HH
+# define OLN_CORE_ABSTRACT_IMAGE_VALUE_WISE_ACCESSIBILITY_HIERARCHY_HH
+
+# include <mlc/logic.hh>
+# include <mlc/cmp.hh>
+
+# include <oln/core/abstract/image.hh>
+# include <oln/core/abstract/image/hierarchies.hh>
+# include <oln/core/automatic/image/image_being_value_wise_random_accessible.hh>
+
+
+namespace oln
+{
+
+ /*----------------------------------------.
+ | Value-wise accessibility abstractions. |
+ `----------------------------------------*/
+
+ namespace abstract
+ {
+
+ /// Image having a value-wise random accessibility.
+ template <typename E>
+ struct image_being_value_wise_random_accessible :
+ public virtual image<E>,
+ public automatic::get_impl< image_being_value_wise_random_accessible, E >
+ {
+ typedef oln_type_of(E, value) value_t;
+ typedef oln_type_of(E, fwd_viter) fwd_viter_t;
+
+
+ public:
+ // Value descriptor (read-only access).
+ fwd_viter_t value(const value_t& v) const;
+
+ protected:
+ /// Constructor (protected, empty).
+ image_being_value_wise_random_accessible();
+ };
+
+ /// Mutable image having a value-wise random accessibility.
+ template <typename E>
+ struct mutable_image_being_value_wise_random_accessible :
+ public virtual image_being_value_wise_random_accessible<E>,
+ public automatic::get_impl< mutable_image_being_value_wise_random_accessible, E
>
+ {
+ typedef oln_type_of(E, value) value_t;
+ typedef oln_type_of(E, mutable_fwd_viter) mutable_fwd_viter_t;
+
+ public:
+ using image_being_value_wise_random_accessible<E>::value;
+ // Value descriptor (read-write access).
+ mutable_fwd_viter_t value(const value_t& v);
+
+ protected:
+ /// Constructor (protected, empty).
+ mutable_image_being_value_wise_random_accessible();
+ };
+
+
+
+# ifndef OLN_INCLUDE_ONLY
+
+ // image_being_value_wise_random_accessible.
+
+ template <typename E>
+ typename image_being_value_wise_random_accessible<E>::fwd_viter_t
+ image_being_value_wise_random_accessible<E>::value(const typename
image_being_value_wise_random_accessible<E>::value_t& v) const
+ {
+ return this->exact().impl_value(v);
+ }
+
+ template <typename E>
+
image_being_value_wise_random_accessible<E>::image_being_value_wise_random_accessible()
+ {
+ }
+
+
+ // mutable_image_being_value_wise_random_accessible.
+
+ template <typename E>
+ typename
mutable_image_being_value_wise_random_accessible<E>::mutable_fwd_viter_t
+ mutable_image_being_value_wise_random_accessible<E>::value(const typename
mutable_image_being_value_wise_random_accessible<E>::value_t& v)
+ {
+ return this->exact().impl_value(v);
+ }
+
+ template <typename E>
+
mutable_image_being_value_wise_random_accessible<E>::mutable_image_being_value_wise_random_accessible()
+ {
+ }
+
+# endif
+
+ } // end of namespace oln::abstract
+
+
+ /*-------------------.
+ | Dimension switch. |
+ `-------------------*/
+
+ /* FIXME: Handle mutability. This is not easy, as, for instance an
+ image with LUT has no lvalue type, but can be perfectly const or
+ mutable. How can we deal with this? By adding a specific
+ vtype? */
+
+ /// With value-wise random accessibility (
+ template <typename E>
+ struct case_< image_hierarchy_wrt_value_wise_accessibility, E, 1 > :
+ where_< mlc_is_ok(oln_type_of(E, fwd_viter)) >
+ {
+ typedef abstract::mutable_image_being_value_wise_random_accessible<E> ret;
+ };
+
+// /// With accessibility.
+// template <typename E>
+// struct case_< image_hierarchy_wrt_value_wise_accessibility, E, 2 > :
+// where_< mlc_and( mlc_is_ok(oln_type_of(E, fwd_viter)),
+// mlc_is_ok(oln_type_of(E, lvalue)) ) >
+// {
+// typedef abstract::mutable_image_being_value_wise_random_accessible<E> ret;
+// };
+
+} // end of namespace oln
+
+
+#endif // ! OLN_CORE_ABSTRACT_IMAGE_VALUE_WISE_ACCESSIBILITY_HIERARCHY_HH
Index: oln/core/gen/fwd_viter_lut.hh
--- oln/core/gen/fwd_viter_lut.hh (revision 0)
+++ oln/core/gen/fwd_viter_lut.hh (revision 0)
@@ -0,0 +1,302 @@
+// 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_FWD_VITER_LUT_HH
+# define OLN_CORE_GEN_FWD_VITER_LUT_HH
+
+# include <oln/core/internal/fwd_viter_lut.hh>
+# include <oln/core/lookup_table.hh>
+
+namespace oln
+{
+
+ /*------------.
+ | fwd_viter. |
+ `------------*/
+
+ // Forward declaration.
+ template <typename Lut> class fwd_viter_lut;
+
+
+ /// Super type declaration.
+ template <typename Lut>
+ struct set_super_type< fwd_viter_lut<Lut> >
+ {
+ typedef fwd_viter_lut<Lut> self_t;
+ typedef internal::fwd_viter_lut<self_t> ret;
+ };
+
+
+ /// Virtual types associated to oln::fwd_viter_lut<Lut>.
+ template <typename Lut>
+ struct vtypes< fwd_viter_lut<Lut> >
+ {
+ // The look-up table is immutable.
+ typedef const Lut lut_type;
+ typedef typename Lut::const_iterator lut_iter_type;
+ typedef typename Lut::new_value_type rvalue_type;
+ };
+
+
+ /// Const forward value iterator on look-up table.
+ template <typename Lut>
+ class fwd_viter_lut :
+ public stc_get_supers(fwd_viter_lut<Lut>)
+ // Check that Lut is a look-up table.
+ // FIXME: an abstract::lookup_table would be useful.
+ {
+ typedef fwd_viter_lut<Lut> self_t;
+ typedef stc_get_super(self_t) super_t;
+
+ public:
+ typedef oln_type_of(self_t, lut) lut_t;
+ typedef oln_type_of(self_t, rvalue) rvalue_type;
+
+ public:
+ // Construct an uninitialized value iterator.
+ fwd_viter_lut(const Lut& lut);
+ // Construct an iterator pointing to value \a val.
+ fwd_viter_lut(const Lut& lut, const rvalue_type& val);
+
+ // Get the value pointed by this iterator (const version).
+ operator rvalue_type() const;
+
+ void print(std::ostream& ostr) const;
+ };
+
+
+ template <typename Lut>
+ std::ostream& operator<<(std::ostream& ostr,
+ const fwd_viter_lut<Lut>& t);
+
+
+
+# ifndef OLN_INCLUDE_ONLY
+
+ template <typename Lut>
+ fwd_viter_lut<Lut>::fwd_viter_lut(const Lut& lut)
+ : super_t(lut)
+ {
+ // Initialize underlying iterator (i.e., \a i_.)
+ this->invalidate();
+ }
+
+ template <typename Lut>
+ fwd_viter_lut<Lut>::fwd_viter_lut(const Lut& lut,
+ const typename fwd_viter_lut<Lut>::rvalue_type& val)
+ : super_t(lut, val)
+ {
+ // The underlying iterator is initialized by the super class.
+ }
+
+ template <typename Lut>
+ fwd_viter_lut<Lut>::operator typename fwd_viter_lut<Lut>::rvalue_type()
const
+ {
+ precondition(this->is_valid());
+ return this->i_->second;
+ }
+
+ template <typename Lut>
+ void fwd_viter_lut<Lut>::print(std::ostream& ostr) const
+ {
+ precondition(this->is_valid());
+ ostr << "fwd_viter_lut<Lut> { value = " <<
this->i_->second << " }";
+ }
+
+
+ template <typename Lut>
+ std::ostream& operator<<(std::ostream& ostr,
+ const fwd_viter_lut<Lut>& t)
+ {
+ t.print(ostr);
+ return ostr;
+ }
+
+# endif
+
+
+
+ /*--------------------.
+ | mutable_fwd_viter. |
+ `--------------------*/
+
+ // Forward declaration.
+ template <typename Lut> class mutable_fwd_viter_lut;
+
+
+ /// Super type declaration.
+ template <typename Lut>
+ struct set_super_type< mutable_fwd_viter_lut<Lut> >
+ {
+ typedef mutable_fwd_viter_lut<Lut> self_t;
+ typedef internal::fwd_viter_lut<self_t> ret;
+ };
+
+
+ /// Virtual types associated to oln::mutable_fwd_viter_lut<Lut>.
+ template <typename Lut>
+ struct vtypes< mutable_fwd_viter_lut<Lut> >
+ {
+ typedef Lut lut_type;
+ typedef typename Lut::iterator lut_iter_type;
+ typedef typename Lut::new_value_type rvalue_type;
+ typedef typename Lut::new_value_type& lvalue_type;
+ };
+
+
+ /// Const forward value iterator on look-up table.
+ template <typename Lut>
+ class mutable_fwd_viter_lut :
+ public stc_get_supers(mutable_fwd_viter_lut<Lut>)
+ // Check that Lut is a look-up table.
+ // FIXME: an abstract::lookup_table would be useful.
+ {
+ typedef mutable_fwd_viter_lut<Lut> self_t;
+ typedef stc_get_super(self_t) super_t;
+ typedef typename Lut::orig_value_type orig_value_t;
+ typedef typename Lut::new_value_type new_value_t;
+
+ public:
+ typedef Lut lut_t;
+ typedef oln_type_of(self_t, rvalue) rvalue_type;
+ typedef oln_type_of(self_t, lvalue) lvalue_type;
+
+ self_t& operator=(const rvalue_type& rhs);
+
+ public:
+ // Construct an uninitialized value iterator.
+ mutable_fwd_viter_lut(Lut& lut);
+ // Construct an iterator pointing to value \a val.
+ mutable_fwd_viter_lut(Lut& lut, const rvalue_type& val);
+
+ // Get the value pointed by this iterator (const version).
+ operator rvalue_type() const;
+ // Get the value pointed by this iterator (mutable version).
+ operator lvalue_type();
+
+ void print(std::ostream& ostr) const;
+ };
+
+
+ template <typename Lut>
+ std::ostream& operator<<(std::ostream& ostr,
+ const mutable_fwd_viter_lut<Lut>& t);
+
+
+
+# ifndef OLN_INCLUDE_ONLY
+
+ template <typename Lut>
+ mutable_fwd_viter_lut<Lut>::mutable_fwd_viter_lut(Lut& lut)
+ : super_t(lut)
+ {
+ // Initialize underlying iterator (i.e., \a i_.)
+ this->invalidate();
+ }
+
+ template <typename Lut>
+ mutable_fwd_viter_lut<Lut>::mutable_fwd_viter_lut(Lut& lut,
+ const typename mutable_fwd_viter_lut<Lut>::rvalue_type& val)
+ : super_t(lut, val)
+ {
+ // The underlying iterator is initialized by the super class.
+ }
+
+ template <typename Lut>
+ mutable_fwd_viter_lut<Lut>::operator typename
mutable_fwd_viter_lut<Lut>::rvalue_type() const
+ {
+ precondition(this->is_valid());
+ return this->i_->second;
+ }
+
+ template <typename Lut>
+ mutable_fwd_viter_lut<Lut>::operator typename
mutable_fwd_viter_lut<Lut>::lvalue_type()
+ {
+ precondition(this->is_valid());
+ return this->i_->second;
+ }
+
+ template <typename Lut>
+ mutable_fwd_viter_lut<Lut>&
+ mutable_fwd_viter_lut<Lut>::operator=(const typename
mutable_fwd_viter_lut<Lut>::rvalue_type& rhs)
+ {
+ precondition(this->is_valid());
+
+ // Current ``new'' value.
+ new_value_t cur_new_val = this->i_->first;
+
+ // Shortcuts.
+ typedef typename Lut::iterator new_iter_t;
+ typedef std::pair<new_iter_t, new_iter_t> new_iter_range_t;
+
+ // Current ``original'' value(s) associated to the next ``new'' value
RHS.
+ new_iter_range_t cur_orig_val_range =
+ this->lut_.new_to_orig_map().equal_range(cur_new_val);
+ // A temporary map where additional bindings will be stored.
+ typename Lut::new_to_orig_map_type additional_bindings;
+
+ for (new_iter_t j = cur_orig_val_range.first;
+ j != cur_orig_val_range.second; ++j)
+ {
+ // Update the orig-to-new map (substitution).
+ orig_value_t orig_val = j->second;
+ this->lut_.orig_to_new_map()[orig_val] = rhs;
+ // Populate the temp map.
+ additional_bindings.insert(std::make_pair(rhs, orig_val));
+ }
+ // Update the new-to-orig map (deletion).
+ this->lut_.new_to_orig_map().erase(cur_orig_val_range.first,
+ cur_orig_val_range.second);
+ // Update the new-to-orig map (insertion).
+ this->lut_.new_to_orig_map().insert(additional_bindings.begin(),
+ additional_bindings.end());
+ return *this;
+ }
+
+ template <typename Lut>
+ void mutable_fwd_viter_lut<Lut>::print(std::ostream& ostr) const
+ {
+ precondition(this->is_valid());
+ ostr
+ << "mutable_fwd_viter_lut<Lut> { value = " <<
this->i_->second << " }";
+ }
+
+
+ template <typename Lut>
+ std::ostream& operator<<(std::ostream& ostr,
+ const mutable_fwd_viter_lut<Lut>& t)
+ {
+ t.print(ostr);
+ return ostr;
+ }
+
+# endif
+
+} // end of namespace oln
+
+
+#endif // ! OLN_CORE_GEN_FWD_VITER_LUT_HH
Index: oln/core/internal/fwd_viter_lut.hh
--- oln/core/internal/fwd_viter_lut.hh (revision 0)
+++ oln/core/internal/fwd_viter_lut.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_INTERNAL_FWD_VITER_LUT_HH
+# define OLN_CORE_INTERNAL_FWD_VITER_LUT_HH
+
+# include <oln/core/abstract/iterator.hh>
+
+
+namespace oln
+{
+
+ namespace internal
+ {
+ // Forward declaration.
+ template <typename Exact> class fwd_viter_lut;
+
+ } // end of namespace oln::internal
+
+
+ /// Super type declaration.
+ template <typename Exact>
+ struct set_super_type< internal::fwd_viter_lut<Exact> >
+ {
+ typedef internal::fwd_viter_lut<Exact> self_t;
+ typedef abstract::iterator<self_t> ret;
+ };
+
+
+ namespace internal
+ {
+ /// Forward value iterator on look-up table (abstract
+ /// factorization class).
+ template <typename Exact>
+ class fwd_viter_lut : public stc_get_supers(fwd_viter_lut<Exact>)
+ // Check that oln_type_of(Exact, lut) is a look-up table.
+ // FIXME: an abstract::lookup_table would be useful.
+ {
+ typedef fwd_viter_lut<Exact> self_t;
+ typedef stc_get_super(self_t) super_t;
+ typedef oln_type_of(Exact, lut_iter) lut_iter_t;
+
+ public:
+ typedef oln_type_of(Exact, lut) lut_type;
+ typedef oln_type_of(Exact, rvalue) rvalue_type;
+
+ public:
+ /// Iterator manipulators.
+ /// \{
+ void start();
+ void next();
+ void invalidate();
+ bool is_valid() const;
+ /// \}
+
+ protected:
+ // Construct an uninitialized value iterator.
+ fwd_viter_lut(lut_type& lut);
+ // Construct an iterator pointing to value \a val.
+ fwd_viter_lut(lut_type& lut, const rvalue_type& val);
+
+ protected:
+ /// Look-up table.
+ lut_type& lut_;
+ /// Iterator on \a lut_.
+ lut_iter_t i_;
+ };
+
+
+ template <typename Exact>
+ std::ostream& operator<<(std::ostream& ostr, const
fwd_viter_lut<Exact>& t);
+
+
+
+# ifndef OLN_INCLUDE_ONLY
+
+ template <typename Exact>
+ fwd_viter_lut<Exact>::fwd_viter_lut(typename
fwd_viter_lut<Exact>::lut_type& lut)
+ : super_t(),
+ lut_(lut),
+ i_()
+ {
+ // Initialize underlying iterator (i.e., \a i_.)
+ this->invalidate();
+ }
+
+ template <typename Exact>
+ fwd_viter_lut<Exact>::fwd_viter_lut(typename
fwd_viter_lut<Exact>::lut_type& lut,
+ const typename fwd_viter_lut<Exact>::rvalue_type& val)
+ : super_t(),
+ lut_(lut),
+ i_()
+ {
+ // Initialize underlying iterator (i.e., \a i_.)
+ i_ = lut_.find(val);
+ assert(i_ != lut_.end());
+ }
+
+ template <typename Exact>
+ void
+ fwd_viter_lut<Exact>::start()
+ {
+ i_ = lut_.begin();
+ }
+
+ template <typename Exact>
+ void
+ fwd_viter_lut<Exact>::next()
+ {
+ /* Iterate until a different key is reached. In fact,
+ std::multimap might not be the best choice to implement
+ new_to_orig_map_. Maybe a std::map binding orig_val to a
+ std::set of new_val's would is better?. */
+ rvalue_type val = i_->first;
+ do
+ ++i_;
+ while (i_ != lut_.end() and i_->first == val);
+ }
+
+ template <typename Exact>
+ void
+ fwd_viter_lut<Exact>::invalidate()
+ {
+ i_ = lut_.end();
+ }
+
+ template <typename Exact>
+ bool
+ fwd_viter_lut<Exact>::is_valid() const
+ {
+ return (i_ != lut_.end());
+ }
+
+ template <typename Exact>
+ std::ostream& operator<<(std::ostream& ostr, const
fwd_viter_lut<Exact>& t)
+ {
+ t.print(ostr);
+ return ostr;
+ }
+
+# endif
+
+ } // end of namespace oln::internal
+
+} // end of namespace oln
+
+#endif // ! OLN_CORE_INTERNAL_FWD_VITER_LUT_HH
Index: oln/core/lookup_table.hh
--- oln/core/lookup_table.hh (revision 684)
+++ oln/core/lookup_table.hh (working copy)
@@ -34,83 +34,196 @@
namespace oln
{
- template <typename Key, typename Data>
+ // FIXME: Document!
+
+ template <typename Orig_Value, typename New_Value,
+ typename Orig_Value_Compare = std::less<Orig_Value>,
+ typename New_Value_Compare = std::less<New_Value> >
class lookup_table
{
- typedef lookup_table<Key, Data> self_t;
+ typedef lookup_table<Orig_Value, New_Value, Orig_Value_Compare,
New_Value_Compare> self_t;
public:
- typedef Key key_type;
- typedef Data data_type;
- typedef std::map<Key, Data> map_type;
+ typedef Orig_Value orig_value_type;
+ typedef New_Value new_value_type;
+ typedef std::map<Orig_Value, New_Value, Orig_Value_Compare>
orig_to_new_map_type;
+ typedef std::multimap<New_Value, Orig_Value, New_Value_Compare>
new_to_orig_map_type;
+
+ typedef typename new_to_orig_map_type::const_iterator const_iterator;
+ typedef typename new_to_orig_map_type::iterator iterator;
public:
lookup_table();
- self_t& add (const key_type& k, const data_type& d);
+ self_t& add (const orig_value_type& orig_value, const new_value_type&
new_value);
- const data_type operator () (const key_type& key) const;
+ const new_value_type operator() (const orig_value_type& orig_value) const;
- const map_type& map() const;
+ /// (Internal) iterators.
+ /// \{
+ const_iterator begin() const;
+ iterator begin();
+
+ const_iterator end() const;
+ iterator end();
+ /// \}
+
+ const_iterator find(const new_value_type& val) const;
+ iterator find(const new_value_type& val);
+
+ /// Accessors.
+ /// \{
+ const orig_to_new_map_type& orig_to_new_map() const;
+ orig_to_new_map_type& orig_to_new_map();
+ const new_to_orig_map_type& new_to_orig_map() const;
+ new_to_orig_map_type& new_to_orig_map();
+ /// \}
private:
- std::map<Key, Data> map_;
+ orig_to_new_map_type orig_to_new_map_;
+ new_to_orig_map_type new_to_orig_map_;
};
# ifndef OLN_INCLUDE_ONLY
- template <typename Key, typename Data>
- lookup_table<Key, Data>::lookup_table() :
- map_()
+ template <typename Orig_Value, typename New_Value,
+ typename Orig_Value_Compare, typename New_Value_Compare>
+ lookup_table<Orig_Value, New_Value,
+ Orig_Value_Compare, New_Value_Compare>::lookup_table() :
+ orig_to_new_map_()
{
}
- template <typename Key, typename Data>
- lookup_table<Key, Data>&
- lookup_table<Key, Data>::add (const Key& k, const Data& d)
+ template <typename Orig_Value, typename New_Value,
+ typename Orig_Value_Compare, typename New_Value_Compare>
+ lookup_table<Orig_Value, New_Value, Orig_Value_Compare, New_Value_Compare>&
+ lookup_table<Orig_Value, New_Value, Orig_Value_Compare, New_Value_Compare>::add
(const Orig_Value& orig_value,
+ const New_Value& new_value)
{
- map_.insert(std::make_pair(k, d));
+ orig_to_new_map_.insert(std::make_pair(orig_value, new_value));
+ new_to_orig_map_.insert(std::make_pair(new_value, orig_value));
return *this;
}
- template <typename Key, typename Data>
- const Data
- lookup_table<Key, Data>::operator () (const Key& key) const
- {
- typedef typename lookup_table<Key, Data>::map_type map_t;
- typename map_t::const_iterator i = map_.find(key);
- // FIXME: Is this the expected behavior when the LUT has no data
- // for \a key.
- assert(i != map_.end());
+ template <typename Orig_Value, typename New_Value,
+ typename Orig_Value_Compare, typename New_Value_Compare>
+ const New_Value
+ lookup_table<Orig_Value, New_Value, Orig_Value_Compare,
New_Value_Compare>::operator () (const Orig_Value& orig_value) const
+ {
+ typedef typename lookup_table<Orig_Value, New_Value, Orig_Value_Compare,
New_Value_Compare>::orig_to_new_map_type orig_to_new_map_t;
+ typename orig_to_new_map_t::const_iterator i = orig_to_new_map_.find(orig_value);
+ // FIXME: Is this the expected behavior when the LUT has no new_value
+ // for \a orig_value?
+ assert(i != orig_to_new_map_.end());
return i->second;
}
- template <typename Key, typename Data>
- const typename lookup_table<Key, Data>::map_type&
- lookup_table<Key, Data>::map() const
+
+ template <typename Orig_Value, typename New_Value,
+ typename Orig_Value_Compare, typename New_Value_Compare>
+ typename lookup_table<Orig_Value, New_Value, Orig_Value_Compare,
New_Value_Compare>::const_iterator
+ lookup_table<Orig_Value, New_Value, Orig_Value_Compare,
New_Value_Compare>::begin() const
+ {
+ return new_to_orig_map_.begin();
+ }
+
+ template <typename Orig_Value, typename New_Value,
+ typename Orig_Value_Compare, typename New_Value_Compare>
+ typename lookup_table<Orig_Value, New_Value, Orig_Value_Compare,
New_Value_Compare>::iterator
+ lookup_table<Orig_Value, New_Value, Orig_Value_Compare,
New_Value_Compare>::begin()
+ {
+ return new_to_orig_map_.begin();
+ }
+
+ template <typename Orig_Value, typename New_Value,
+ typename Orig_Value_Compare, typename New_Value_Compare>
+ typename lookup_table<Orig_Value, New_Value, Orig_Value_Compare,
New_Value_Compare>::const_iterator
+ lookup_table<Orig_Value, New_Value, Orig_Value_Compare, New_Value_Compare>::end()
const
+ {
+ return new_to_orig_map_.end();
+ }
+
+ template <typename Orig_Value, typename New_Value,
+ typename Orig_Value_Compare, typename New_Value_Compare>
+ typename lookup_table<Orig_Value, New_Value, Orig_Value_Compare,
New_Value_Compare>::iterator
+ lookup_table<Orig_Value, New_Value, Orig_Value_Compare,
New_Value_Compare>::end()
+ {
+ return new_to_orig_map_.end();
+ }
+
+
+ template <typename Orig_Value, typename New_Value,
+ typename Orig_Value_Compare, typename New_Value_Compare>
+ typename lookup_table<Orig_Value, New_Value, Orig_Value_Compare,
New_Value_Compare>::const_iterator
+ lookup_table<Orig_Value, New_Value, Orig_Value_Compare,
New_Value_Compare>::find(const New_Value& val) const
+ {
+ return new_to_orig_map_.find(val);
+ }
+
+ template <typename Orig_Value, typename New_Value,
+ typename Orig_Value_Compare, typename New_Value_Compare>
+ typename lookup_table<Orig_Value, New_Value, Orig_Value_Compare,
New_Value_Compare>::iterator
+ lookup_table<Orig_Value, New_Value, Orig_Value_Compare,
New_Value_Compare>::find(const New_Value& val)
+ {
+ return new_to_orig_map_.find(val);
+ }
+
+
+ template <typename Orig_Value, typename New_Value,
+ typename Orig_Value_Compare, typename New_Value_Compare>
+ const typename lookup_table<Orig_Value, New_Value, Orig_Value_Compare,
New_Value_Compare>::orig_to_new_map_type&
+ lookup_table<Orig_Value, New_Value, Orig_Value_Compare,
New_Value_Compare>::orig_to_new_map() const
+ {
+ return orig_to_new_map_;
+ }
+
+ template <typename Orig_Value, typename New_Value,
+ typename Orig_Value_Compare, typename New_Value_Compare>
+ typename lookup_table<Orig_Value, New_Value, Orig_Value_Compare,
New_Value_Compare>::orig_to_new_map_type&
+ lookup_table<Orig_Value, New_Value, Orig_Value_Compare,
New_Value_Compare>::orig_to_new_map()
+ {
+ return orig_to_new_map_;
+ }
+
+ template <typename Orig_Value, typename New_Value,
+ typename Orig_Value_Compare, typename New_Value_Compare>
+ const typename lookup_table<Orig_Value, New_Value, Orig_Value_Compare,
New_Value_Compare>::new_to_orig_map_type&
+ lookup_table<Orig_Value, New_Value, Orig_Value_Compare,
New_Value_Compare>::new_to_orig_map() const
+ {
+ return new_to_orig_map_;
+ }
+
+ template <typename Orig_Value, typename New_Value,
+ typename Orig_Value_Compare, typename New_Value_Compare>
+ typename lookup_table<Orig_Value, New_Value, Orig_Value_Compare,
New_Value_Compare>::new_to_orig_map_type&
+ lookup_table<Orig_Value, New_Value, Orig_Value_Compare,
New_Value_Compare>::new_to_orig_map()
{
- return map_;
+ return new_to_orig_map_;
}
# endif
/// Print a look-up table.
- template <typename Key, typename Data>
+ template <typename Orig_Value, typename New_Value,
+ typename Orig_Value_Compare, typename New_Value_Compare>
std::ostream&
- operator<< (std::ostream& ostr, const lookup_table<Key, Data>&
lut);
+ operator<< (std::ostream& ostr,
+ const lookup_table<Orig_Value, New_Value, Orig_Value_Compare,
New_Value_Compare>& lut);
# ifndef OLN_INCLUDE_ONLY
- template <typename Key, typename Data>
+ template <typename Orig_Value, typename New_Value,
+ typename Orig_Value_Compare, typename New_Value_Compare>
std::ostream&
- operator<< (std::ostream& ostr, const lookup_table<Key, Data>&
lut)
+ operator<< (std::ostream& ostr,
+ const lookup_table<Orig_Value, New_Value, Orig_Value_Compare,
New_Value_Compare>& lut)
{
- typedef lookup_table<Key, Data> lut_t;
- const typename lut_t::map_type& map = lut.map();
- for (typename lut_t::map_type::const_iterator i = map.begin ();
+ typedef lookup_table<Orig_Value, New_Value, Orig_Value_Compare,
New_Value_Compare> lut_t;
+ const typename lut_t::orig_to_new_map_type& map = lut.orig_to_new_map();
+ for (typename lut_t::orig_to_new_map_type::const_iterator i = map.begin ();
i != map.end(); ++i)
ostr << " " << i->first << " -> "
<< i->second << std::endl;
return ostr;
Index: oln/morpher/slice.hh
--- oln/morpher/slice.hh (revision 684)
+++ oln/morpher/slice.hh (working copy)
@@ -86,6 +86,7 @@
typedef oln_type_of(Image, value) value_type;
// rvalue_type: see below.
+ // lvalue_type: see below.
// fwd_piter_type: see oln/core/iterator_vtypes.hh.
// bkd_piter_type: see oln/core/iterator_vtypes.hh.
@@ -140,9 +141,6 @@
/// \}
-
-
-
// piters.
/// fwd_piter vtype of morpher::slice.
@@ -189,6 +187,7 @@
};
+ // FIXME: What about niters on morpher::slice?
Index: oln/morpher/with_lut.hh
--- oln/morpher/with_lut.hh (revision 684)
+++ oln/morpher/with_lut.hh (working copy)
@@ -30,6 +30,7 @@
# include <oln/morpher/internal/image_value_morpher.hh>
# include <oln/core/lookup_table.hh>
+# include <oln/core/gen/fwd_viter_lut.hh>
namespace oln
@@ -61,58 +62,84 @@
public:
typedef mlc::true_ is_computed_type;
// Value type.
- typedef typename Lut::data_type value_type;
+ typedef typename Lut::new_value_type value_type;
// Look-up table type.
typedef Lut lut_type;
+
+ // rvalue_type: see below.
+ // lvalue_type: undefined (see
+ // oln/morpher/internal/image_value_morpher.hh).
+
+ // fwd_viter_type: see below.
+ // mutable_fwd_viter_type: see below.
+
+ // FIXME: implement bkd_viter_type!
+ // FIXME: implement mutable_bkd_viter_type!
};
// Rvalue.
template <typename Image, typename Lut>
struct single_vtype< morpher::with_lut<Image, Lut>, typedef_::rvalue_type
>
{
+ private:
typedef morpher::with_lut<Image, Lut> self_t;
+ public:
typedef oln_value(self_t) ret;
};
- // FIXME: What about lvalue type?
+ /// Const forward viter vtype of morpher::with_lut.
+ template <typename Image, typename Lut>
+ struct single_vtype< morpher::with_lut<Image, Lut>,
+ typedef_::fwd_viter_type >
+ {
+ typedef fwd_viter_lut<Lut> ret;
+ };
-// // Lvalue.
-// template <typename Image>
-// struct single_vtype< morpher::slice<Image>, typedef_::lvalue_type >
-// {
-// typedef oln_type_of(Image, lvalue) ret;
-// };
+ /// Mutable forward viter vtype of morpher::with_lut.
+ template <typename Image, typename Lut>
+ struct single_vtype< morpher::with_lut<Image, Lut>,
+ typedef_::mutable_fwd_viter_type >
+ {
+ typedef mutable_fwd_viter_lut<Lut> ret;
+ };
/// \}
+ // FIXME: What about bkd_viter_type on morpher::with_lut?
+
+
+
namespace morpher
{
/// Look-up table addition morpher.
template <typename Image, typename Lut>
class with_lut : public stc_get_supers(mlc_comma_1(with_lut<Image, Lut>))
- // FIXME: Ensure oln_value(Image) == Lut::data_type? Or just let
+ // FIXME: Ensure oln_value(Image) == Lut::new_value_type? Or just let
// the ctor check this property?
{
- private:
typedef with_lut<Image, Lut> self_t;
typedef stc_get_super(self_t) super_t;
- typedef Lut lut_t;
- typedef oln_type_of(self_t, value) value_t;
- typedef oln_type_of(self_t, rvalue) rvalue_t;
- typedef oln_type_of(self_t, psite) psite_t;
- // FIXME: Useful typedef?
-// typedef oln_type_of(Image, value) orig_value_t;
+
+ public:
+ typedef Lut lut_type;
+ typedef oln_type_of(self_t, value) value_type;
+ typedef oln_type_of(self_t, rvalue) rvalue_type;
+ typedef oln_type_of(self_t, psite) psite_type;
+ typedef oln_type_of(self_t, fwd_viter) fwd_viter_type;
+ typedef oln_type_of(self_t, mutable_fwd_viter) mutable_fwd_viter_type;
public:
with_lut(const Image& image, const Lut& lut);
- const lut_t& lut() const;
+ const lut_type& lut() const;
- rvalue_t impl_op_read(const psite_t& p) const;
+ rvalue_type impl_op_read(const psite_type& p) const;
- // FIXME: Implement impl_op_write() when there is value proxy?
+ // FIXME: Constness of this method?
+ fwd_viter_type impl_value(const value_type& v) const;
+ mutable_fwd_viter_type impl_value(const value_type& v);
protected:
- lut_t lut_;
+ lut_type lut_;
};
@@ -123,13 +150,12 @@
super_t(image),
lut_(lut)
{
- mlc::assert_equal_< oln_value(Image), typename Lut::key_type >::check();
+ mlc::assert_equal_< oln_value(Image), typename Lut::orig_value_type
>::check();
}
template <typename Image, typename Lut>
- typename with_lut<Image, Lut>::rvalue_t
- with_lut<Image, Lut>::
- impl_op_read(const typename with_lut<Image, Lut>::psite_t& p) const
+ typename with_lut<Image, Lut>::rvalue_type
+ with_lut<Image, Lut>::impl_op_read(const typename with_lut<Image,
Lut>::psite_type& p) const
{
// FIXME: What if lut_ has no value for `this->image_(p)'? At
// least, document the behavior of this method (will it abort,
@@ -138,7 +164,21 @@
}
template <typename Image, typename Lut>
- const typename with_lut<Image, Lut>::lut_t&
+ typename with_lut<Image, Lut>::fwd_viter_type
+ with_lut<Image, Lut>::impl_value(const value_type& v) const
+ {
+ return fwd_viter_type(lut_, v);
+ }
+
+ template <typename Image, typename Lut>
+ typename with_lut<Image, Lut>::mutable_fwd_viter_type
+ with_lut<Image, Lut>::impl_value(const value_type& v)
+ {
+ return mutable_fwd_viter_type(lut_, v);
+ }
+
+ template <typename Image, typename Lut>
+ const typename with_lut<Image, Lut>::lut_type&
with_lut<Image, Lut>::lut() const
{
return lut_;
@@ -149,11 +189,12 @@
} // end of namespace oln::morpher
+ // FIXME: Provide a version of op+ where the LUT is const?
template <typename I, typename K, typename D>
morpher::with_lut< I, lookup_table<K, D> >
operator + (const abstract::image<I>& image,
- const lookup_table<K, D>& lut);
+ lookup_table<K, D>& lut);
# ifndef OLN_INCLUDE_ONLY
@@ -161,11 +202,11 @@
template <typename I, typename K, typename D>
morpher::with_lut< I, lookup_table<K, D> >
operator + (const abstract::image<I>& image,
- const lookup_table<K, D>& lut)
+ lookup_table<K, D>& lut)
{
- typedef lookup_table<K, D> lut_t;
- mlc::assert_equal_< oln_value(I), typename lut_t::key_type >::check();
- morpher::with_lut<I, lut_t> tmp(image.exact(), lut);
+ typedef lookup_table<K, D> lut_type;
+ mlc::assert_equal_< oln_value(I), typename lut_type::orig_value_type
>::check();
+ morpher::with_lut<I, lut_type> tmp(image.exact(), lut);
return tmp;
}
Index: oln/value/color/rgb.hh
--- oln/value/color/rgb.hh (revision 684)
+++ oln/value/color/rgb.hh (working copy)
@@ -63,6 +63,10 @@
template <typename U>
rgb_<T>& operator=(const rgb_<U>& rhs);
+ /// Op==.
+ template <typename U>
+ bool operator==(const rgb_<U>& rhs);
+
T red() const;
T& red();
typedef T red_type;
@@ -124,6 +128,16 @@
}
template <typename T>
+ template <typename U>
+ bool rgb_<T>::operator==(const rgb_<U>& rhs)
+ {
+ return
+ val_[0] == rhs.red() and
+ val_[1] == rhs.green() and
+ val_[2] == rhs.blue();
+ }
+
+ template <typename T>
T rgb_<T>::red() const
{
return val_[0];