Olena-patches

olena-patches@lrde.epita.fr

9625 discussions

proto-1.0 57: Add i/o test suite to configure.ac

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * configure.ac: Add i/o test suite. configure.ac | 1 + 1 files changed, 1 insertion(+) Index: configure.ac --- configure.ac (revision 53) +++ configure.ac (working copy) @@ -103,6 +103,7 @@ # OLN_TESTS defined in oln-local.m4 OLN_TESTS([core]) OLN_TESTS([sanity]) + OLN_TESTS([io]) AC_SUBST([OLN_TESTS_SUBDIRS])

20 years, 1 month

proto-1.0 56: Fix operator== on data types

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * ntg/real/int_u8.hh: Fix operator==. * ntg/real/integer.hh: Likewise. * ntg/enum/enum.hh: Likewise. * ntg/enum/bin.hh: Likewise. * ntg/all.hh: New. * ntg/core/macros.hh: Fix operator==. * ntg/color/rgb_8.hh: Likewise. * ntg/color/color.hh: Likewise. all.hh | 36 ++++++++++++++++++++++++++++++++++ color/color.hh | 12 ++++++----- color/rgb_8.hh | 58 +++++++++----------------------------------------------- core/macros.hh | 2 - enum/bin.hh | 10 ++++----- enum/enum.hh | 20 ++++++++++++------- real/int_u8.hh | 14 ++++++++----- real/integer.hh | 11 +++++++--- 8 files changed, 89 insertions(+), 74 deletions(-) Index: ntg/real/int_u8.hh --- ntg/real/int_u8.hh (revision 53) +++ ntg/real/int_u8.hh (working copy) @@ -83,16 +83,20 @@ return value_; } - template <typename V> - bool impl_eq(const V& rhs) const +// template <typename V> +// bool impl_eq(const V& rhs) const +// { +// return this->value_ == rhs; +// } + + bool impl_eq(int rhs) const { return this->value_ == rhs; } - template <typename V> - bool impl_not_eq(const V& rhs) const + bool impl_eq(const int_u8& rhs) const { - return this->value_ != rhs; + return this->value_ == (unsigned char)rhs; } template <typename V> Index: ntg/real/integer.hh --- ntg/real/integer.hh (revision 53) +++ ntg/real/integer.hh (working copy) @@ -62,16 +62,21 @@ return this->exact().impl_assign(rhs); } - template <typename V> - bool operator==(const V& rhs) const + bool operator==(int rhs) const { return this->exact().impl_eq(rhs); } + template <typename I> + bool operator==(const integer<I>& rhs) const + { + return this->exact().impl_eq(rhs.exact()); + } + template <typename V> bool operator!=(const V& rhs) const { - return this->exact().impl_not_eq(rhs); + return ! this->operator==(rhs); } template <typename V> Index: ntg/enum/enum.hh --- ntg/enum/enum.hh (revision 53) +++ ntg/enum/enum.hh (working copy) @@ -44,6 +44,7 @@ struct default_props < cat::enum_value > { enum { max_val = 0 }; + enum { depth = 1 }; typedef mlc::no_type io_type; protected: @@ -55,25 +56,30 @@ { typedef E exact_type; - template <typename V> - exact_type& operator=(const V& rhs) + bool operator==(int rhs) const { - return this->exact().impl_assign(rhs); + return this->exact().impl_eq(rhs); } - template <typename V> - bool operator==(const V& rhs) const + template <typename I> + bool operator==(const enum_value<I>& rhs) const { - return this->exact().impl_eq(rhs); + return this->exact().impl_eq(rhs.exact()); } template <typename V> bool operator!=(const V& rhs) const { - return this->exact().impl_not_eq(rhs); + return ! this->operator==(rhs); } template <typename V> + exact_type& operator=(const V& rhs) + { + return this->exact().impl_assign(rhs); + } + + template <typename V> exact_type& operator+(const V& rhs) const { return this->exact().impl_add(rhs); Index: ntg/enum/bin.hh --- ntg/enum/bin.hh (revision 53) +++ ntg/enum/bin.hh (working copy) @@ -69,7 +69,7 @@ template <typename V> bin& impl_assign(const V& rhs) { - this->value_ = rhs % 2; + this->value_ = (int)rhs % 2; return *this; } @@ -78,18 +78,18 @@ return value_; } - template <typename V> - bool impl_eq(const V& rhs) const + bool impl_eq(const unsigned char& rhs) const { return this->value_ == rhs; } template <typename V> - bool impl_not_eq(const V& rhs) const + bool impl_eq(const V& rhs) const { - return this->value_ != rhs; + return this->value_ == (unsigned char)rhs; } + template <typename V> bin impl_add(const V& rhs) const { Index: ntg/all.hh --- ntg/all.hh (revision 0) +++ ntg/all.hh (revision 0) @@ -0,0 +1,36 @@ +// Copyright (C) 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 NTG_ALL_HH +# define NTG_ALL_HH + +# include <ntg/core/macros.hh> +# include <ntg/color/rgb_8.hh> +# include <ntg/real/int_u8.hh> +# include <ntg/enum/bin.hh> + +#endif // ! NTG_ALL_HH Index: ntg/core/macros.hh --- ntg/core/macros.hh (revision 53) +++ ntg/core/macros.hh (working copy) @@ -30,7 +30,7 @@ # define ntg_max_val(T) ntg::props<ntg_category_type(T),T>::max_val -# define ntg_nb_comp(T) ntg::props<ntg_category_type(T),T>::nb_comp +# define ntg_depth(T) ntg::props<ntg_category_type(T),T>::depth # define ntg_comp_type(T) typename ntg::props<ntg_category_type(T),T>::comp_type Index: ntg/color/rgb_8.hh --- ntg/color/rgb_8.hh (revision 53) +++ ntg/color/rgb_8.hh (working copy) @@ -45,7 +45,7 @@ struct props<cat::color, rgb_8> : default_props<cat::color> { enum { max_val = 255 }; - enum { nb_comp = 3 }; + enum { depth = 3 }; typedef char io_type; typedef unsigned char comp_type; @@ -84,33 +84,26 @@ rgb_8(const rgb_8& rhs) { - this->value_[rgb_red] = rhs.red(); - this->value_[rgb_green] = rhs.green(); - this->value_[rgb_blue] = rhs.blue(); + this->value_[rgb_red] = rhs[rgb_red]; + this->value_[rgb_green] = rhs[rgb_green]; + this->value_[rgb_blue] = rhs[rgb_blue]; } rgb_8& impl_assign(const rgb_8& rhs) { - this->value_[rgb_red] = rhs.red(); - this->value_[rgb_green] = rhs.green(); - this->value_[rgb_blue] = rhs.blue(); + this->value_[rgb_red] = rhs[rgb_red]; + this->value_[rgb_green] = rhs[rgb_green]; + this->value_[rgb_blue] = rhs[rgb_blue]; return *this; } bool impl_eq(const rgb_8& rhs) const { - return this->value_[rgb_red] == rhs.red() && - this->value_[rgb_green] == rhs.green() && - this->value_[rgb_blue] == rhs.blue(); + return this->value_[rgb_red] == rhs[rgb_red] && + this->value_[rgb_green] == rhs[rgb_green] && + this->value_[rgb_blue] == rhs[rgb_blue]; } - bool impl_not_eq(const rgb_8& rhs) const - { - return this->value_[rgb_red] != rhs.red() || - this->value_[rgb_green] != rhs.green() || - this->value_[rgb_blue] != rhs.blue(); - } - unsigned char& impl_op_sqbr(unsigned int i) { assert(i < 3); @@ -123,37 +116,6 @@ return value_[i]; } - - unsigned char& red() - { - return value_[rgb_red]; - } - - const unsigned char red() const - { - return value_[rgb_red]; - } - - unsigned char& green() - { - return value_[rgb_green]; - } - - const unsigned char green() const - { - return value_[rgb_green]; - } - - unsigned char& blue() - { - return value_[rgb_blue]; - } - - const unsigned char blue() const - { - return value_[rgb_blue]; - } - private: unsigned char value_[3]; Index: ntg/color/color.hh --- ntg/color/color.hh (revision 53) +++ ntg/color/color.hh (working copy) @@ -47,7 +47,7 @@ struct default_props < cat::color > { enum { max_val = 0 }; - enum { nb_comp = 0 }; + enum { depth = 0 }; typedef mlc::undefined_type comp_type; typedef mlc::undefined_type io_type; @@ -67,14 +67,16 @@ return this->exact.impl_assign(rhs); } - bool operator==(const exact_type& rhs) const + template <typename I> + bool operator==(const color<I>& rhs) const { - return this->exact().impl_eq(rhs); + return this->exact().impl_eq(rhs.exact()); } - bool operator!=(const exact_type& rhs) const + template <typename V> + bool operator!=(const V& rhs) const { - return this->exact().impl_not_eq(rhs); + return ! this->operator==(rhs); } comp_type& operator [](const unsigned int &i)

20 years, 1 month

proto-1.0 55: Add all.hh header

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * oln/makefile.src: Add new file. * oln/all.hh: New. all.hh | 38 ++++++++++++++++++++++++++++++++++++++ makefile.src | 1 + 2 files changed, 39 insertions(+) Index: oln/makefile.src --- oln/makefile.src (revision 54) +++ oln/makefile.src (working copy) @@ -4,6 +4,7 @@ ## OLN_DEP = \ + all.hh \ basics.hh \ basics1d.hh \ basics2d.hh \ Index: oln/all.hh --- oln/all.hh (revision 0) +++ oln/all.hh (revision 0) @@ -0,0 +1,38 @@ +// Copyright (C) 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 OLN_ALL_HH +# define OLN_ALL_HH + +# include <oln/core/1d/image1d.hh> +# include <oln/core/2d/image2d.hh> +# include <oln/core/3d/image3d.hh> + +# include <oln/io/write_image.hh> +# include <oln/io/read_image.hh> + +#endif // ! OLN_ALL_HH

20 years, 1 month

proto-1.0 54: Add gzip i/o

by Damien Thivolle

Index: ChangeLog from Damien Thivolle <damien(a)lrde.epita.fr> * tests/io: New. * tests/io/tests: New. * tests/io/tests/2d: New. * tests/io/Makefile.am: New. * tests/io/loadsave.hh: New. * oln/makefile.src: Add new files. * oln/io/write_image_2d_pnm.hh: Modify function prototypes. * oln/io/gz_stream.hh: New. Gz stream classes. * oln/io/read_image_2d_pnm.hh: Modify function prototypes. * oln/io/write_image.hh: Add gz stream support. * oln/io/read_image.hh: Likewise. * oln/io/utils.hh: Modify function prototypes. * oln/core/value_box.hh: Add new operator== for value_box. * oln/core/2d/image2d.hh: Remove debug output. * img/lena.pgm.gz: New. * img/lena.pgm: New. * img/chien.pbm.gz: New. * img/chien.pbm: New. * img/lena.ppm.gz: New. * img/lena.ppm: New. * img/lena.pbm.gz: New. * img/lena.pbm: New. img/lena.pbm | 0 img/lena.pgm | 4 img/lena.ppm | 541 +++++++++++++++++++++++++++++++++++++++++++ oln/core/2d/image2d.hh | 1 oln/core/value_box.hh | 64 ++++- oln/io/gz_stream.hh | 482 ++++++++++++++++++++++++++++++++++++++ oln/io/read_image.hh | 102 +++++++- oln/io/read_image_2d_pnm.hh | 134 ++-------- oln/io/utils.hh | 34 -- oln/io/write_image.hh | 65 ++++- oln/io/write_image_2d_pnm.hh | 39 +-- oln/makefile.src | 1 tests/io/Makefile.am | 9 tests/io/loadsave.hh | 49 +++ tests/io/tests/2d | 52 ++++ 15 files changed, 1399 insertions(+), 178 deletions(-) Index: tests/io/tests/2d --- tests/io/tests/2d (revision 0) +++ tests/io/tests/2d (revision 0) @@ -0,0 +1,52 @@ +// -*- c++ -*- +// Copyright (C) 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. + + +#include "loadsave.hh" + +bool +check(void) +{ + bool fail = false; + + typedef oln::image2d<ntg::int_u8> ima_int_u8; + typedef oln::image2d<ntg::rgb_8> ima_rgb_8; + typedef oln::image2d<ntg::bin> ima_bin; + + fail |= loadsave< ima_int_u8 >(rdata("lena.pgm"), "lena.pgm"); + fail |= loadsave< ima_bin >(rdata("lena.pbm"), "lena.pbm"); + fail |= loadsave< ima_rgb_8 >(rdata("lena.ppm"), "lena.ppm"); + +#if HAVE_ZLIB + fail |= loadsave< ima_bin >(rdata("lena.pbm.gz"), "lena.pbm.gz"); + fail |= loadsave< ima_int_u8 >(rdata("lena.pgm.gz"), "lena.pgm.gz"); + fail |= loadsave< ima_rgb_8 >(rdata("lena.ppm.gz"), "lena.ppm.gz"); +#endif + + return fail; +} Index: tests/io/Makefile.am --- tests/io/Makefile.am (revision 0) +++ tests/io/Makefile.am (revision 0) @@ -0,0 +1,9 @@ +## Process this file through Automake to create Makefile.in -*- Makefile -*- + +include ../check/Makefile.runtests + +noinst_HEADERS = loadsave.hh + +CLEANFILES += \ + lena.ppm lena.pgm lena.pbm \ + lena.ppm.gz lena.pgm.gz lena.pbm.gz Index: tests/io/loadsave.hh --- tests/io/loadsave.hh (revision 0) +++ tests/io/loadsave.hh (revision 0) @@ -0,0 +1,49 @@ +#include <oln/basics1d.hh> +#include <oln/basics2d.hh> +#include <oln/basics3d.hh> +#include <oln/all.hh> + +#include <ntg/all.hh> + +#include "check.hh" +#include "data.hh" + +template<typename E> +bool compare(const oln::abstract::image<E>& a, + const oln::abstract::image<E>& b) +{ + + oln_type_of(E, fwd_piter) it(a.size()); + + if (a.size().nrows() != b.size().nrows() || + a.size().ncols() != b.size().ncols()) + return false; + + for (it.start(); !it.is_valid(); it.next()) + if (a[it] != b[it]) + return false; + + return true; +} + +template< typename T > +bool +loadsave(const std::string& name, const std::string& savename) +{ + bool fail = false; + + T im1, im2; + im1 = oln::io::read(name); + oln::io::write(im1, savename); + + im2 = oln::io::read(savename); + + if (compare(im1, im2)) + std::cout << "OK" << std::endl; + else + { + std::cout << "FAILED" << std::endl; + fail = true; + } + return fail; +} Index: oln/makefile.src --- oln/makefile.src (revision 53) +++ oln/makefile.src (working copy) @@ -40,6 +40,7 @@ core/value_box.hh \ fancy/iota.hh \ fancy/print.hh \ + io/gz_stream.hh \ io/read_image.hh \ io/read_image_2d_pnm.hh \ io/utils.hh \ Index: oln/io/write_image_2d_pnm.hh --- oln/io/write_image_2d_pnm.hh (revision 53) +++ oln/io/write_image_2d_pnm.hh (working copy) @@ -59,9 +59,9 @@ typedef ntg_io_type(value_type) io_type; const I& to_write_; - std::ofstream& ostr_; + std::ostream& ostr_; - write_image_2d_raw(const I& to_write, std::ofstream& ostr): + write_image_2d_raw(const I& to_write, std::ostream& ostr): to_write_(to_write), ostr_(ostr) {} @@ -70,7 +70,7 @@ { point2d p; value_type c; - bool b; + bool b = false; for (p.row() = 0; p.row() < to_write_.size().nrows(); ++p.row()) for (p.col() = 0; p.col() < to_write_.size().ncols(); ++p.col()) @@ -80,21 +80,25 @@ } while (b == false) b = write_value_type(c); - ostr_.close(); } bool write_value_type(const ntg::integer<value_type> &c) { - ostr_ << (io_type)(c.exact()); + io_type v = c.exact(); + ostr_.write((char *)&v, sizeof(io_type)); return true; } bool write_value_type(const ntg::color<value_type> &c) { - assert ((ntg_nb_comp(value_type) == 3)); + assert ((ntg_depth(value_type) == 3)); + io_type v; for (unsigned i = 0; i < 3; i++) - ostr_ << (io_type)(c[i]); + { + v = c[i]; + ostr_.write((char *)(&v), sizeof(io_type)); + } return true; } @@ -107,7 +111,7 @@ if (offset == -1) { - ostr_ << v; + ostr_.write((char *)&v, 1); offset = 7; v = 0; ret = true; @@ -123,15 +127,15 @@ template <typename I, typename T> void write(const abstract::image2d<I>& to_write, const ntg::integer<T>&, - const std::string& name, + std::ostream& ostr, const std::string& ext) { - std::ofstream ostr; + point2d p; size2d s = to_write.size(); if (ext == "pgm") - if (internal::write_pnm_header(ostr, name, "P5", + if (internal::write_pnm_header(ostr, "P5", s.ncols(), s.nrows(), ntg_max_val(T))) { @@ -139,7 +143,7 @@ tmp.run(); } else - std::cerr << "error: unable to write header" << std::endl; + std::cerr << "error: unable to write file header" << std::endl; else std::cerr << "error: image data type (`integer') does not match" << " file extension (`" << ext << "')" << std::endl; @@ -148,15 +152,15 @@ template <typename I, typename T> void write(const abstract::image2d<I>& to_write, const ntg::color<T>&, - const std::string& name, + std::ostream& ostr, const std::string& ext) { - std::ofstream ostr; + point2d p; size2d s = to_write.size(); if (ext == "ppm") - if (internal::write_pnm_header(ostr, name, "P6", + if (internal::write_pnm_header(ostr, "P6", s.ncols(), s.nrows(), ntg_max_val(T))) { @@ -173,15 +177,14 @@ template <typename I, typename T> void write(const abstract::image2d<I>& to_write, const ntg::enum_value<T>&, - const std::string& name, + std::ostream& ostr, const std::string& ext) { - std::ofstream ostr; point2d p; size2d s = to_write.size(); if (ext == "pbm") - if (internal::write_pnm_header(ostr, name, "P4", + if (internal::write_pnm_header(ostr, "P4", s.ncols(), s.nrows(), ntg_max_val(T))) { Index: oln/io/gz_stream.hh --- oln/io/gz_stream.hh (revision 0) +++ oln/io/gz_stream.hh (revision 0) @@ -0,0 +1,482 @@ +// 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 OLN_IO_GZ_STREAM_HH +# define OLN_IO_GZ_STREAM_HH + +# include <oln/config/system.hh> + +#if defined HAVE_ZLIB && HAVE_ZLIB == 1 +# include <cassert> +# include <fstream> +# include <string> +# include <zlib.h> + +namespace oln { + + namespace io { + + /// Functions for gz files + namespace gz { + + + ///Performs operation on compressed files. + class zfilebuf : public std::streambuf + { + public: + + + zfilebuf() : file(0), mode(0), own_file_descriptor(0) + { + inbuf = new char[lenbuf]; + outbuf = new char[lenbuf]; + setg(0, 0, 0); + setp(outbuf, outbuf + lenbuf); + } + + virtual ~zfilebuf() + { + sync(); + delete[] inbuf; + delete[] outbuf; + if (own_file_descriptor) + close(); + } + + + /*! \brief Return a stream on the file \a name regarding + ** the opening mode: \a io_mode. + */ + zfilebuf* + open(const char *name, int io_mode) + { + if (is_open()) + return 0; + + char char_mode[10]; + char *p; + memset(char_mode,'\0',10); + p = char_mode; + + if (io_mode & std::ios::in) + { + mode = std::ios::in; + *p++ = 'r'; + } + else + if (io_mode & std::ios::app) + { + mode = std::ios::app; + *p++ = 'a'; + } + else + { + mode = std::ios::out; + *p++ = 'w'; + } + if (io_mode & std::ios::binary) + { + mode |= std::ios::binary; + *p++ = 'b'; + } + + // Hard code the compression level + if (io_mode & (std::ios::out|std::ios::app)) + *p++ = '9'; + + if ((file = gzopen(name, char_mode)) == 0) + return 0; + + name_ = name; + own_file_descriptor = 1; + return this; + } + + /*! \brief Attach a stream on \a file_descriptor regarding + ** the opening mode: \a io_mode. + */ + zfilebuf* + attach(int file_descriptor, int io_mode) + { + if (is_open()) + return 0; + + char char_mode[10]; + char *p; + memset(char_mode,'\0',10); + p = char_mode; + + if (io_mode & std::ios::in) + { + mode = std::ios::in; + *p++ = 'r'; + } + else + if (io_mode & std::ios::app) + { + mode = std::ios::app; + *p++ = 'a'; + } + else + { + mode = std::ios::out; + *p++ = 'w'; + } + + if (io_mode & std::ios::binary) + { + mode |= std::ios::binary; + *p++ = 'b'; + } + + // Hard code the compression level + if (io_mode & (std::ios::out|std::ios::app)) + *p++ = '9'; + + if ((file = gzdopen(file_descriptor, char_mode)) == 0) + return 0; + + own_file_descriptor = 0; + return this; + } + + /// Close the stream. + zfilebuf* + close() + { + if (is_open()) + { + sync(); + gzclose(file); + file = 0; + } + return this; + } + + + int + setcompressionlevel(short comp_level) + { + return gzsetparams(file, comp_level, -2); + } + + int + setcompressionstrategy(short comp_strategy) + { + return gzsetparams(file, -2, comp_strategy); + } + + /// Return true if the stream is open, false otherwise. + inline int + is_open() const + { return (file != 0); } + + virtual std::streampos + seekoff(std::streamoff off, std::ios::seekdir dir, int) // which) + { + return std::streampos(gzseek(file, off, dir)); + } + + /// Flush the buffer associated to the stream. + virtual int + sync() + { + if (!is_open()) + return EOF; + return flushbuf(); + } + + protected: + + /*! \brief Return the next character in the stream. + ** On failure, \a EOF is returned. + */ + virtual int + underflow() + { + // If the file hasn't been opened for reading, error. + if (!is_open() || !(mode & std::ios::in)) + return EOF; + + if (in_avail()) + return (unsigned char) *gptr(); + + if (flushbuf() == EOF) + return EOF; + + // Attempt to fill the buffer. + if (fillbuf() == EOF) + return EOF; + + assert (eback()); + + return (unsigned char) *gptr(); + } + + /*! \brief Flush the output buffer associated to the stream + ** then write \a c. On failure, \a EOF is returned. + */ + + virtual int + overflow(int c = EOF) + { + if (!is_open() || !(mode & std::ios::out)) + return EOF; + + assert (pbase()); + + if (flushbuf() == EOF) + return EOF; + + if (c != EOF) + { + *pptr() = c; + pbump(1); + } + return 0; + } + + private: + + gzFile file; + short mode; + short own_file_descriptor; + std::string name_; + char *inbuf; + char *outbuf; + static const int lenbuf = 16 * 1024; + + /// Flush the output buffer + int + flushbuf() + { + int n = pptr() - outbuf; + + if (n == 0) + return 0; + + if (gzwrite(file, outbuf, n) < n) + return EOF; + + setp(outbuf, outbuf + lenbuf); + return 0; + } + /// Fill the input buffer. + int + fillbuf() + { + int t = gzread(file, inbuf, lenbuf); + if (t <= 0) return EOF; + setg(inbuf, inbuf, inbuf + t); + return t; + } + + }; + + ///Define an interface for compressed file stream manipulation. + class zfilestream_common : virtual public std::ios + { + friend class zifstream; + friend class zofstream; + friend zofstream &setcompressionlevel(zofstream &, int); + friend zofstream &setcompressionstrategy(zofstream &, int); + + public: + virtual ~zfilestream_common() {} + + /*! \brief Open the stream on the file descriptor: + ** \a fd regarding the opening mode. + */ + void + attach(int fd, int io_mode) + { + if (!buffer.attach(fd, io_mode)) + clear(std::ios::failbit | std::ios::badbit); + else + clear(); + } + + /*! \brief Open the stream on the file named \a name + ** regarding the opening mode. + */ + void + open(const char *name, int io_mode) + { + if (!buffer.open(name, io_mode)) + clear(std::ios::failbit | std::ios::badbit); + else + clear(); + } + + /// Close the current stream. + void + close() + { + if (!buffer.close()) + clear(std::ios::failbit | std::ios::badbit); + } + + bool + is_open() + { + return buffer.is_open(); + } + + + protected: + /// Prevent instantiation. + zfilestream_common() : std::ios(zfilestream_common::rdbuf()) + { } + + + private: + zfilebuf* + rdbuf() + { + return &buffer; + } + + zfilebuf buffer; + }; + + + /// Read only zstream. + class zifstream : public zfilestream_common, public std::istream + { + public: + + zifstream() : std::istream(zfilestream_common::rdbuf()) + { + clear(std::ios::badbit); + } + + /// Open a read only stream on the file named \a name. + zifstream(const char *name, int io_mode = std::ios::in) : + std::istream(zfilestream_common::rdbuf()) + { + zfilestream_common::open(name, io_mode); + } + + /// Open a read only stream on the file descriptor \a fd. + zifstream(int fd, int io_mode = std::ios::in) : + std::istream(zfilestream_common::rdbuf()) + { + zfilestream_common::attach(fd, io_mode); + } + + virtual ~zifstream() {} + }; + + class zofstream : public zfilestream_common, public std::ostream { + + public: + + zofstream() : std::ostream(zfilestream_common::rdbuf()) + { + clear(std::ios::badbit); + } + + /// Open a write only stream on the file named \a name. + zofstream(const char *name, int io_mode = std::ios::out) : + std::ostream(zfilestream_common::rdbuf()) + { + zfilestream_common::open(name, io_mode); + } + + /// Open a write only stream on the file descriptor \a fd. + zofstream(int fd, int io_mode = std::ios::out) : + std::ostream(zfilestream_common::rdbuf()) + { + zfilestream_common::attach(fd, io_mode); + } + + virtual ~zofstream() {} + + }; + + // Forward declaration. + template <class T> + class zomanip; + + /// Apply a function on \a s via the operator <<. + template <class T> + zofstream& + operator<<(zofstream &s, const zomanip<T> &m) { + return (*m.func)(s, m.val); + } + + + /// Define a pair func / val to perform manipulation on zofstream. + template<class T> class zomanip + { + friend zofstream &operator<< <T>(zofstream &, const zomanip<T> &); + public: + zomanip(zofstream &(*f)(zofstream &, T), T v) : func(f), val(v) { } + private: + zofstream &(*func)(zofstream &, T); + T val; + }; + + + /// Set the compression level of \a s to \a l. + inline zofstream& + setcompressionlevel(zofstream &s, int l) { + (s.rdbuf())->setcompressionlevel(l); + return s; + } + + /// Set the compression strategy of \a s to \a l. + inline zofstream& + setcompressionstrategy(zofstream &s, int l) + { + (s.rdbuf())->setcompressionstrategy(l); + return s; + } + + /// Specialized version for zomanip<int> + inline zomanip<int> + setcompressionlevel(int l) + { + return zomanip<int>(&setcompressionlevel,l); + } + + /// Specialized version for zomanip<int> + inline zomanip<int> + setcompressionstrategy(int l) + { + return zomanip<int>(&setcompressionstrategy,l); + } + + } // end of namespace gz + + } // end of namespace io + +} // end of namespace oln + +# endif // ! HAVE_ZLIB + +#endif // ! OLN_IO_GZ_STREAM_HH Index: oln/io/read_image_2d_pnm.hh --- oln/io/read_image_2d_pnm.hh (revision 53) +++ oln/io/read_image_2d_pnm.hh (working copy) @@ -1,3 +1,30 @@ +// Copyright (C) 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 OLN_IO_READ_IMAGE_2D_PNM_HH # define OLN_IO_READ_IMAGE_2D_PNM_HH @@ -59,11 +86,11 @@ typedef ntg_io_type(value_type) io_type; mlc::box<I> image_; - std::ifstream& istr_; + std::istream& istr_; internal::pnm_info& info_; read_image_2d_raw(I& image, - std::ifstream &istr, + std::istream &istr, internal::pnm_info &info) : super_type(image), image_(image), @@ -97,7 +124,6 @@ read_value_type(c); tmp[p] = c; } - istr_.close(); *image_ = tmp; } @@ -110,10 +136,9 @@ void read_value_type(ntg::color<value_type> &c) { - assert((ntg_nb_comp(value_type) == 3)); io_type v; - for (unsigned i = 0; i < 3; i++) + for (unsigned i = 0; i < ntg_depth(value_type); i++) { istr_.read(&v, sizeof (v)); c[i] = v; @@ -135,107 +160,20 @@ else c = 1; } - - }; - template <typename I, typename T> + template <typename I> void read(abstract::image2d<I>& ima, - const ntg::integer<T>&, - const std::string& filename, - const std::string& ext) + std::istream& istr, + internal::pnm_info info) { - std::ifstream istr; - internal::pnm_info info; - - if (internal::read_pnm_header(istr, info, filename)) - if (ext == "pgm") - if (info.type == "P5") - { - read_image_2d_raw<I> tmp(ima.exact(), istr, info); - tmp.run(); - tmp.output(ima.exact()); - } - else if (info.type == "P2") - std::cerr << "error: read_image_2d_pgm_ascii not implemented" - << std::endl; - else - std::cerr << "error: file header (`" << info.type - << "') does not match file extension (`" - << ext << "')" << std::endl; - else - std::cerr << "error: image data type (`integer') does not match" - << " file extension (`" << ext << "')" << std::endl; - else - std::cerr << "error: unable to get a valid header" << std::endl; + read_image_2d_raw<I> tmp(ima.exact(), istr, info); + tmp.run(); + tmp.output(ima.exact()); } - - - template <typename I, typename T> - void read(abstract::image2d<I>& ima, - const ntg::color<T>&, - const std::string& filename, - const std::string& ext) - { - std::ifstream istr; - internal::pnm_info info; - - if (internal::read_pnm_header(istr, info, filename)) - if (ext == "ppm") - if (info.type == "P6") - { - read_image_2d_raw<I> tmp(ima.exact(), istr, info); - tmp.run(); - tmp.output(ima.exact()); - } - else if (info.type == "P3") - std::cerr << "error: read_image_2d_ppm_ascii not implemented" - << std::endl; - else - std::cerr << "error: file header (`" << info.type - << "') does not match file extension (`" - << ext << "')" << std::endl; - else - std::cerr << "error: image data type (`color') does not match" - << " file extension (`" << ext << "')" << std::endl; - else - std::cerr << "error: unable to get a valid header" << std::endl; - } - - template <typename I, typename T> - void read(abstract::image2d<I>& ima, - const ntg::enum_value<T>&, - const std::string& filename, - const std::string& ext) - { - std::ifstream istr; - internal::pnm_info info; - - if (internal::read_pnm_header(istr, info, filename)) - if (ext == "pbm") - if (info.type == "P4") - { - read_image_2d_raw<I> tmp(ima.exact(), istr, info); - tmp.run(); - tmp.output(ima.exact()); - } - else if (info.type == "P1") - std::cerr << "error: read_image_2d_ppm_ascii not implemented" - << std::endl; - else - std::cerr << "error: file header (`" << info.type - << "') does not match file extension (`" - << ext << "')" << std::endl; - else - std::cerr << "error: image data type (`enum_value') does not match" - << " file extension (`" << ext << "')" << std::endl; - else - std::cerr << "error: unable to get a valid header" << std::endl; - } - } } Index: oln/io/write_image.hh --- oln/io/write_image.hh (revision 53) +++ oln/io/write_image.hh (working copy) @@ -30,6 +30,7 @@ # include <string> +# include <oln/io/gz_stream.hh> # include <oln/io/utils.hh> # include <oln/io/write_image_2d_pnm.hh> @@ -38,22 +39,68 @@ namespace io { template <typename I> - void write(const abstract::image<I>& im, const std::string& name) + void do_write(const abstract::image<I>& ima, + std::ostream& ostr, + const std::string& ext) { + typedef oln_type_of(I, value) value_type; + value_type t; + + impl::write(ima.exact(), t, ostr, ext); + } + +#if defined HAVE_ZLIB && HAVE_ZLIB == 1 + template <typename I> + void write_gz(const abstract::image<I>& ima, const std::string& name) + { + gz::zofstream zostr(name.c_str(), std::ios::out); + + if (zostr.is_open() == false) + std::cerr << "error: couldn't open " << name << std::endl; + else + { + std::string ext; + + ext = internal::utils::extension(name.substr(0, name.size() - 3)); + do_write(ima, zostr, ext); + } + zostr.close(); + } + +#endif // ! HAVE_ZLIB + + template <typename I> + void write_non_gz(const abstract::image<I>& ima, + const std::string& name, + const std::string& ext) + { + std::ofstream ostr; + + ostr.open(name.c_str(), std::ifstream::out); + + if (ostr.is_open() == false) + std::cerr << "error: couldn't open " << name << std::endl; + else + do_write(ima, ostr, ext); + ostr.close(); + } + + template <typename I> + void write(const abstract::image<I>& ima, const std::string& name) + { std::string ext; oln_type_of(I, value) t; ext = internal::utils::extension(name); - if (ext == "pgm" || - ext == "ppm" || - ext == "pbm") - impl::write(im.exact(), t, name, ext); +#if defined HAVE_ZLIB && HAVE_ZLIB == 1 + if (ext == "gz") + write_gz(ima, name); else - std::cerr << "error: output method for '" - << name.c_str() - << "' not implemented" - << std::endl; + write_non_gz(ima, name, ext); +# else + write_non_gz(ima, name, ext); +#endif // ! HAVE_ZLIB } } Index: oln/io/read_image.hh --- oln/io/read_image.hh (revision 53) +++ oln/io/read_image.hh (working copy) @@ -33,8 +33,12 @@ # include <mlc/box.hh> +# include <ntg/core/macros.hh> + +# include <oln/core/properties.hh> # include <oln/io/read_image_2d_pnm.hh> # include <oln/io/utils.hh> +# include <oln/io/gz_stream.hh> namespace oln { @@ -59,28 +63,102 @@ return tmp; } + template <typename I> - void do_read(abstract::image<I>& ima, const filename& name) + void read_dispatch_ext(abstract::image<I>& ima, + std::istream& istr, + const std::string& ext) + { - std::string ext; - const oln_type_of(I, value) t; + if (ext == "pgm" || ext == "pbm" || ext == "ppm" || + ext == "pnm") + { + internal::pnm_info info; - ext = internal::utils::extension(name.get()); + if (internal::read_pnm_header(istr, info)) + if ((ext == "ppm" || ext == "pnm") && info.type == "P6") + impl::read(ima.exact(), istr, info); + else if ((ext == "ppm" || ext == "pnm") && info.type == "P3") + std::cerr << "error: read_image_2d_ppm_ascii not implemented" + << std::endl; + else if ((ext == "pbm" || ext == "pnm") && info.type == "P4") + impl::read(ima.exact(), istr, info); + else if ((ext == "pbm" || ext == "pnm") && info.type == "P1") + std::cerr << "error: read_image_2d_ppm_ascii not implemented" + << std::endl; + else if ((ext == "pgm" || ext == "pnm") && info.type == "P5") + impl::read(ima.exact(), istr, info); + else if ((ext == "pgm" || ext == "pnm") && info.type == "P2") + std::cerr << "error: read_image_2d_ppm_ascii not implemented" + << std::endl; + else + std::cerr << "error: file header (`" << info.type + << "') does not match file extension (`" + << ext << "')" << std::endl; + else + std::cerr << "error: unable to get a valid header" << std::endl; + } + else + std::cout << "no input method for '" + << ext << "' file extension" + << std::endl; + } - if (ext == "pgm" || - ext == "pbm" || - ext == "ppm") - impl::read(ima.exact(), t, name.get(), ext); +#if defined HAVE_ZLIB && HAVE_ZLIB == 1 + template <typename I> + void do_read_gz(abstract::image<I>& ima, const std::string& name) + { + gz::zifstream zistr(name.c_str(), std::ios::in); + + if (zistr.is_open() == false) + std::cerr << "error: couldn't open " << name << std::endl; else { - std::cout << "input method for '" - << name.get() - << "' not implemented" - << std::endl; + std::string ext; + + ext = internal::utils::extension(name.substr(0, name.size() - 3)); + read_dispatch_ext(ima, zistr, ext); } + zistr.close(); + } +#endif // ! HAVE_ZLIB + + template <typename I> + void do_read_non_gz(abstract::image<I>& ima, + const std::string& name, + const std::string& ext) + { + std::ifstream istr; + + istr.open(name.c_str(), std::ifstream::in); + + if (istr.is_open() == false) + std::cerr << "error: couldn't open " << name << std::endl; + else + read_dispatch_ext(ima, istr, ext); + istr.close(); } + template <typename I> + void do_read(abstract::image<I>& ima, const filename& name) + { + std::string ext; + + ext = internal::utils::extension(name.get()); + +#if defined HAVE_ZLIB && HAVE_ZLIB == 1 + + if (ext == "gz") + do_read_gz(ima, name.get()); + else + do_read_non_gz(ima, name.get(), ext); +#else + do_read_non_gz(ima, name.get(), ext); +#endif // ! HAVE_ZLIB + } + + } } Index: oln/io/utils.hh --- oln/io/utils.hh (revision 53) +++ oln/io/utils.hh (working copy) @@ -76,17 +76,13 @@ std::string type; }; - bool read_pnm_header(std::ifstream& istr, - internal::pnm_info& info, - const std::string& name) + bool read_pnm_header(std::istream& istr, + internal::pnm_info& info) { - istr.open(name.c_str(), std::ifstream::in); - - if (!istr.is_open()) - return false; - std::getline(istr, info.type); + info.max_val = 1; + // skip comments while (istr.peek() == '#') { @@ -121,11 +117,9 @@ std::getline(istr, line); } - // FIXME: it can be either '\n', 'whitespace', ..., not only '\n'! - - // extract or skip maxvalue if (istr.get() != '\n') return false; + // extract or skip maxvalue if (info.type != "P1" && info.type != "P4") { istr >> info.max_val; @@ -137,29 +131,15 @@ return true; } - bool write_pnm_header(std::ofstream& ostr, - const std::string& name, + bool write_pnm_header(std::ostream& ostr, const std::string& type, int ncols, int nrows, int max_val) { if (max_val > 65535) - { - std::cerr << "error: can't save " << name - << ", data type too large" - << std::endl; - return false; - } + return false; - ostr.open(name.c_str(), std::ofstream::out); - - if (ostr.is_open() == false) - { - std::cerr << "error: couldn't open " << name << std::endl; - return false; - } - ostr << type << std::endl << "# Olena 1.0" << std::endl << ncols << " " << nrows << std::endl; Index: oln/core/value_box.hh --- oln/core/value_box.hh (revision 53) +++ oln/core/value_box.hh (working copy) @@ -79,6 +79,26 @@ typedef oln_type_of(I, point) point_type; + /// op== + + bool operator==(const value_box<I>& value) const + { + return this->value() == value.value(); + } + + template <typename V> + bool operator==(const V& value) const + { + return this->value() == value; + } + + template <typename V> + bool operator!=(const V& value) const + { + return ! this->operator==(value); + } + + /*! \brief op= ** FIXME:... ** \return (*this) @@ -87,7 +107,7 @@ template <typename V> value_box& operator=(const V& value) { - ima_.set(p_, value); + this->ima_->set(this->p_, value); return *this; } @@ -103,7 +123,7 @@ template <typename II> value_box& operator=(const value_box<II>& rhs) { - ima_.set(p_, rhs); // automatic conversion from rhs to value_type + ima_->set(p_, rhs); // automatic conversion from rhs to value_type return *this; } @@ -118,7 +138,7 @@ template <typename A, typename V> value_box& set(void (I::*method)(A), const V& value) { - ima_.set(p_, method, value); + ima_->set(p_, method, value); return *this; } @@ -133,13 +153,13 @@ template <typename V> operator const V() const { - const V value = ima_.get(p_); + const V value = ima_->get(p_); return value; } operator const value_type() const { - return ima_.get(p_); + return ima_->get(p_); } @@ -156,7 +176,7 @@ const value_type value() const { - return ima_.get(p_); + return ima_->get(p_); } @@ -180,7 +200,7 @@ /// Ctor (restricted access). value_box(abstract::image<I>& ima, const point_type& p) : - ima_(ima.exact()), + ima_(&ima.exact()), p_(p) { } @@ -189,7 +209,7 @@ ! attributes ! *------------*/ - I& ima_; + I* ima_; point_type p_; }; @@ -219,7 +239,25 @@ typedef oln_type_of(I, point) point_type; + /// op== + bool operator==(const value_box<const I>& value) const + { + return this->value() == value.value(); + } + template <typename V> + bool operator==(const V& value) const + { + return this->value() == value; + } + + template <typename V> + bool operator!=(const V& value) const + { + return ! this->operator==(value); + } + + /*! \brief Assignment (op=) is declared but undefined. */ @@ -235,13 +273,13 @@ template <typename V> operator const V() const { - const V value = ima_.get(p_); + const V value = ima_->get(p_); return value; } operator const value_type() const { - return ima_.get(p_); + return ima_->get(p_); } @@ -258,7 +296,7 @@ const value_type value() const { - return ima_.get(p_); + return ima_->get(p_); } // IDEA: provide op-> @@ -284,7 +322,7 @@ /// Ctor (restricted access). value_box(const abstract::image<I>& ima, const point_type& p) : - ima_(ima.exact()), + ima_(&ima.exact()), p_(p) { } @@ -293,7 +331,7 @@ ! attributes ! *------------*/ - const I& ima_; + const I* ima_; point_type p_; }; Index: oln/core/2d/image2d.hh --- oln/core/2d/image2d.hh (revision 53) +++ oln/core/2d/image2d.hh (working copy) @@ -140,7 +140,6 @@ { if (&rhs == this) return *this; - std::cout << "shallow copy" << std::endl; super_type::operator=(rhs); return *this; }; Index: img/lena.pgm.gz Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: img/lena.pgm.gz ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Index: img/lena.pgm Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: img/lena.pgm ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Index: img/chien.pbm.gz Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: img/chien.pbm.gz ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Index: img/chien.pbm Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: img/chien.pbm ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Index: img/lena.ppm.gz Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: img/lena.ppm.gz ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Index: img/lena.ppm Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: img/lena.ppm ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Index: img/lena.pbm.gz Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: img/lena.pbm.gz ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Index: img/lena.pbm Cannot display: file marked as a binary type. svn:mime-type = application/octet-stream Property changes on: img/lena.pbm ___________________________________________________________________ Name: svn:mime-type + application/octet-stream

20 years, 1 month

proto-1.0 53: Use the compiler's debug flags in the test suite

by Roland Levillain

(Au passage, je profite de ce patch pour marquer les fichiers générés comme ignorés par Subversion.) https://svn.lrde.epita.fr/svn/oln/prototypes/proto-1.0 ChangeLog | 6 ++++++ tests/check/Makefile.flags | 8 ++++++-- 2 files changed, 12 insertions(+), 2 deletions(-) Index: olena/ChangeLog from Roland Levillain <roland(a)lrde.epita.fr> Use the compiler's debug flags in the test suite. * tests/check/Makefile.flags (AM_CXXFLAGS): Add $(CXXFLAGS_DEBUG). Property changes on: ___________________________________________________________________ Name: svn:ignore - aclocal.m4 autom4te.cache config.hin configure Makefile.in + Makefile Makefile.in aclocal.m4 autom4te.cache config.h config.hin config.log config.status configure diffs.patch stamp-h1 Property changes on: integre ___________________________________________________________________ Name: svn:ignore - Makefile.in + Makefile Makefile.in Property changes on: integre/tests ___________________________________________________________________ Name: svn:ignore - Makefile.in + Makefile Makefile.in Property changes on: integre/tests/sanity ___________________________________________________________________ Name: svn:ignore - Makefile.in + Makefile Makefile.in incltest.cc Property changes on: integre/tests/check ___________________________________________________________________ Name: svn:ignore + defs Property changes on: integre/ntg ___________________________________________________________________ Name: svn:ignore - Makefile.in + Makefile Makefile.in Property changes on: olena ___________________________________________________________________ Name: svn:ignore - Makefile.in + Makefile Makefile.in Property changes on: olena/tests ___________________________________________________________________ Name: svn:ignore - Makefile.in + Makefile Makefile.in incltest.cc Property changes on: olena/tests/sanity ___________________________________________________________________ Name: svn:ignore - Makefile.in + Makefile Makefile.in incltest.cc Property changes on: olena/tests/core ___________________________________________________________________ Name: svn:ignore - Makefile.in + Makefile Makefile.in runs Property changes on: olena/tests/check ___________________________________________________________________ Name: svn:ignore - Makefile.in + .deps Makefile Makefile.in defs libolncheck.a Index: olena/tests/check/Makefile.flags --- olena/tests/check/Makefile.flags (revision 52) +++ olena/tests/check/Makefile.flags (working copy) @@ -1,5 +1,9 @@ # -*- Makefile -*- -AM_CXXFLAGS = $(CXXFLAGS_OPTIMIZE) $(CXXFLAGS_STRICT_ERRORS) $(ZLIB_CXXFLAGS) -AM_CPPFLAGS = -I$(top_srcdir)/metalic/tests/check -I$(top_srcdir)/olena/tests/check +AM_CXXFLAGS = \ + $(CXXFLAGS_DEBUG) $(CXXFLAGS_OPTIMIZE) \ + $(CXXFLAGS_STRICT_ERRORS) $(ZLIB_CXXFLAGS) +AM_CPPFLAGS = \ + -I$(top_srcdir)/metalic/tests/check \ + -I$(top_srcdir)/olena/tests/check AM_LDFLAGS =

20 years, 1 month

proto-1.0 52: Make it pass make check

by Thierry GERAUD

hop --- :from: Thierry Geraud <theo(a)lrde.epita.fr> :server: :subject: "proto-1.0 52: Make it pass make check" :groups: - lrde.olena.patches --- Index: ChangeLog from Thierry Geraud <theo(a)lrde.epita.fr> * oln/core/3d/fwd_piter3d.hh: New. * tests/core/tests/readwrite_image: Fix to pass make check. * tests/core/tests/image_identity: Likewise. * oln/fancy/print.hh: Likewise. * oln/core/1d/array1d.hh: Likewise. * oln/core/1d/fwd_piter1d.hh: Likewise. * oln/core/1d/point1d.hh: Likewise. * oln/core/1d/size1d.hh: Likewise. * oln/core/coord.hh: Likewise. * oln/core/2d/fwd_piter2d.hh: Likewise. * oln/core/2d/point2d.hh: Likewise. * oln/core/2d/size2d.hh: Likewise. * oln/core/3d/size3d.hh: Likewise. * oln/core/3d/array3d.hh: Likewise. * oln/core/3d/image3d.hh: Likewise. * oln/core/3d/point3d.hh: Likewise. oln/core/1d/array1d.hh | 18 ++--- oln/core/1d/fwd_piter1d.hh | 4 - oln/core/1d/point1d.hh | 1 oln/core/1d/size1d.hh | 4 - oln/core/2d/fwd_piter2d.hh | 27 ++++---- oln/core/2d/point2d.hh | 1 oln/core/2d/size2d.hh | 4 - oln/core/3d/array3d.hh | 52 ++++++++------- oln/core/3d/fwd_piter3d.hh | 129 +++++++++++++++++++++++++++++++++++++++ oln/core/3d/image3d.hh | 5 - oln/core/3d/point3d.hh | 6 - oln/core/3d/size3d.hh | 14 +--- oln/core/coord.hh | 4 + oln/fancy/print.hh | 40 +++++------- tests/core/tests/image_identity | 1 tests/core/tests/readwrite_image | 26 ++++--- 16 files changed, 237 insertions(+), 99 deletions(-) Index: tests/core/tests/readwrite_image --- tests/core/tests/readwrite_image (revision 51) +++ tests/core/tests/readwrite_image (working copy) @@ -11,23 +11,26 @@ struct dummy_image; template <> - struct category_type< dummy_image > { typedef cat::image ret; }; + struct set_category< dummy_image > { typedef category::image ret; }; template <> - struct props <cat::image, dummy_image> : - public default_props < cat::image > + struct set_super_type< dummy_image > { + typedef abstract::image_with_data< dummy_image > ret; + }; + + template <> + struct set_props <category::image, dummy_image> : + public props_of < category::image > { - typedef prop_of<abstract::readwrite_image> image_constness; - typedef prop_of<abstract::image2d> image_dimension; + typedef is_a<abstract::readwrite_image> image_constness; + typedef is_a<abstract::image2d> image_dimension_type; typedef size2d size_type; typedef point2d point_type; typedef ntg::int_u8 value_type; - typedef mlc_encoding_type_(value_type) value_storage_type; - typedef array2d<value_storage_type> value_container_type; - - typedef mlc::no_type delegated_type; + typedef value_type value_storage_type; + typedef array2d<value_storage_type> storage_type; }; struct dummy_image : public abstract::image_with_data< dummy_image > @@ -55,7 +58,8 @@ bool check() { oln::dummy_image ima(3, 3); - ima[oln::point2d(0,0)] = 42; - std::cout << ima[oln::point2d(0,0)].value() << std::endl; + oln::point2d p(0,0); + ima[p] = 51; + std::cout << int(ima[p]) << std::endl; return false; } Index: tests/core/tests/image_identity --- tests/core/tests/image_identity (revision 51) +++ tests/core/tests/image_identity (working copy) @@ -1,7 +1,6 @@ #include <oln/core/abstract/image_identity.hh> #include <oln/core/2d/image2d.hh> #include <ntg/real/int_u8.hh> -#include <oln/core/cats.hh> template <typename I> Index: oln/fancy/print.hh --- oln/fancy/print.hh (revision 51) +++ oln/fancy/print.hh (working copy) @@ -38,6 +38,7 @@ # include <oln/core/abstract/image_dimension.hh> # include <oln/core/1d/point1d.hh> # include <oln/core/2d/point2d.hh> +# include <oln/core/3d/point3d.hh> # include <oln/core/coord.hh> @@ -104,18 +105,15 @@ template <typename E> void print(const abstract::image1d<E>& input, std::ostream& ostr) { - // FIXME: lacks cleaning for (coord_t index = 0; index < input.size().nindices(); ++index) - { - ostr << internal::pp<oln_type_of(E, value)>(input[point1d(index)]) << ' '; - } + ostr << internal::pp<oln_type_of(E, value)>(input[point1d(index)]) + << ' '; ostr << std::endl; } template <typename E> void print(const abstract::image2d<E>& input, std::ostream& ostr) { - // FIXME: lacks cleaning for (coord_t row = 0; row < input.size().nrows(); ++row) { for (coord_t col = 0; col < input.size().ncols(); ++col) @@ -124,24 +122,22 @@ } } - // FIXME: remove comments when dpoint3d are available. -// template <typename E> -// void print(const abstract::image3d<E>& input, std::ostream& ostr) -// { -// // FIXME: lacks cleaning -// for (coord_t slice = 0; slice < input.size().nslices(); ++slice) -// { -// for (coord_t row = 0; row < input.size().nrows(); ++row) -// { -// for (coord_t col = 0; col < input.size().ncols(); ++col) -// ostr << internal::pp<oln_value_type(E)>(input[point3d(slice,row,col)]) -// << ' '; -// ostr << ", "; -// } -// ostr << std::endl; -// } -// } + template <typename E> + void print(const abstract::image3d<E>& input, std::ostream& ostr) + { + for (coord_t slice = 0; slice < input.size().nslices(); ++slice) + { + for (coord_t row = 0; row < input.size().nrows(); ++row) + { + for (coord_t col = 0; col < input.size().ncols(); ++col) + ostr << internal::pp<oln_type_of(E, value)>(input[point3d(slice,row,col)]) + << ' '; + ostr << std::endl; + } + ostr << "---" << std::endl; + } + } } // end of namespace impl Index: oln/core/1d/array1d.hh --- oln/core/1d/array1d.hh (revision 51) +++ oln/core/1d/array1d.hh (working copy) @@ -116,7 +116,7 @@ void impl_resize(const size1d& s) { - precondition(s.nindices() > 0 and + precondition(s.nindices() > 0 && s.border() >= 0); invariant_(); this->clear_data(); @@ -134,14 +134,14 @@ bool impl_hold(const point1d& p) const { return - p.index() >= 0 and + p.index() >= 0 && p.index() < size_.nindices(); } bool impl_hold_large(const point1d& p) const { return - p.index() >= - size_.border() and + p.index() >= - size_.border() && p.index() < size_.nindices() + size_.border(); } @@ -173,13 +173,13 @@ void invariant_() const { - invariant((buffer_ != 0 and - size_.nindices() > 0 and + invariant((buffer_ != 0 && + size_.nindices() > 0 && size_.border() >= 0) - or - (buffer_ == 0 and - size_.nindices() == 0 and - size_.border() == 0)); + || + (buffer_ == 0 && + size_.nindices().is_undefined() && + size_.border().is_undefined())); } }; Index: oln/core/1d/fwd_piter1d.hh --- oln/core/1d/fwd_piter1d.hh (revision 51) +++ oln/core/1d/fwd_piter1d.hh (working copy) @@ -88,9 +88,7 @@ void impl_next() { precondition(this->p_.index().is_defined()); - precondition(this->p_.index() >= 0 and this->p_.index() <= this->s_.nindices()); - if (this->p_.index() == this->s_.nindices()) - return; + precondition(this->p_.index() >= 0 && this->p_.index() < this->s_.nindices()); ++this->p_.index(); postcondition(this->p_.index().is_defined()); } Index: oln/core/1d/point1d.hh --- oln/core/1d/point1d.hh (revision 51) +++ oln/core/1d/point1d.hh (working copy) @@ -65,6 +65,7 @@ { point1d() { + // no initialization here so that index_ is 'undef' } point1d(coord_t index_) : Index: oln/core/1d/size1d.hh --- oln/core/1d/size1d.hh (revision 51) +++ oln/core/1d/size1d.hh (working copy) @@ -39,7 +39,9 @@ struct size1d : public abstract::size< size1d > { size1d() - {} + { + // no initialization here so that members are 'undef' + } size1d(coord_t nindices_) : nindices_(nindices_), Index: oln/core/coord.hh --- oln/core/coord.hh (revision 51) +++ oln/core/coord.hh (working copy) @@ -71,6 +71,10 @@ bool operator==(value_type rhs) const { + if (! this->is_defined()) + { + std::cerr << "oops" << std::endl; + } precondition(this->is_defined()); return value_ == rhs; } Index: oln/core/2d/fwd_piter2d.hh --- oln/core/2d/fwd_piter2d.hh (revision 51) +++ oln/core/2d/fwd_piter2d.hh (working copy) @@ -25,8 +25,8 @@ // reasons why the executable file might be covered by the GNU General // Public License. -#ifndef PROTO_OLN_CORE_2D_FWD_PITER2D_HH -# define PROTO_OLN_CORE_2D_FWD_PITER2D_HH +#ifndef OLENA_CORE_2D_FWD_PITER2D_HH +# define OLENA_CORE_2D_FWD_PITER2D_HH # include <mlc/contract.hh> @@ -76,39 +76,42 @@ { this->p_.row() = 0; this->p_.col() = 0; - postcondition(this->p_.row().is_defined() && this->p_.col().is_defined()); + postcondition(this->p_.row().is_defined() && + this->p_.col().is_defined()); } bool impl_is_valid() const { - precondition(this->p_.row().is_defined() && this->p_.col().is_defined()); + precondition(this->p_.row().is_defined() && + this->p_.col().is_defined()); return this->p_.row() < this->s_.nrows(); } void impl_next() { - precondition(this->p_.row().is_defined() && this->p_.col().is_defined()); - precondition(this->p_.row() >= 0 && this->p_.row() <= this->s_.nrows() - && - this->p_.col() >= 0 && this->p_.col() <= this->s_.ncols()); + precondition(this->p_.row().is_defined() && + this->p_.col().is_defined()); + precondition(this->p_.row() >= 0 && this->p_.row() < this->s_.nrows() && + this->p_.col() >= 0 && this->p_.col() < this->s_.ncols()); ++this->p_.col(); if (this->p_.col() != this->s_.ncols()) return; this->p_.col() = 0; - precondition(this->p_.row() != this->s_.nrows()); ++this->p_.row(); - postcondition(this->p_.row().is_defined() && this->p_.col().is_defined()); + postcondition(this->p_.row().is_defined() && + this->p_.col().is_defined()); } void impl_invalidate() { this->p_.row() = this->s_.nrows(); this->p_.col() = this->s_.ncols(); - postcondition(this->p_.row().is_defined() && this->p_.col().is_defined()); + postcondition(this->p_.row().is_defined() && + this->p_.col().is_defined()); } }; } -#endif // ndef PROTO_OLN_CORE_2D_FWD_PITER2D_HH +#endif // ! OLENA_CORE_2D_FWD_PITER2D_HH Index: oln/core/2d/point2d.hh --- oln/core/2d/point2d.hh (revision 51) +++ oln/core/2d/point2d.hh (working copy) @@ -63,6 +63,7 @@ { point2d() { + // no initialization here so that row_ and col_ are 'undef' } point2d(coord_t row_, coord_t col_) : Index: oln/core/2d/size2d.hh --- oln/core/2d/size2d.hh (revision 51) +++ oln/core/2d/size2d.hh (working copy) @@ -39,7 +39,9 @@ struct size2d : public abstract::size< size2d > { size2d() - {} + { + // no initialization here so that members are 'undef' + } size2d(coord_t nrows_, coord_t ncols_) : nrows_(nrows_), Index: oln/core/3d/size3d.hh --- oln/core/3d/size3d.hh (revision 51) +++ oln/core/3d/size3d.hh (working copy) @@ -39,12 +39,10 @@ struct size3d : public abstract::size< size3d > { - size3d() : - nslices_(0), - nrows_(0), - ncols_(0), - border_(0) - {} + size3d() + { + // no initialization here so that members are 'undef' + } size3d(coord_t nslices_, coord_t nrows_, coord_t ncols_) : nslices_(nslices_), @@ -84,8 +82,8 @@ bool impl_eq(const size3d& rhs) const { - return this->nslices_ == rhs.nslices_ and - this->nrows_ == rhs.nrows_ and + return this->nslices_ == rhs.nslices_ && + this->nrows_ == rhs.nrows_ && this->ncols_ == rhs.ncols_; } Index: oln/core/3d/array3d.hh --- oln/core/3d/array3d.hh (revision 51) +++ oln/core/3d/array3d.hh (working copy) @@ -127,9 +127,9 @@ void impl_resize(const size3d& s) { - precondition(s.nslices() > 0 and - s.nrows() > 0 and - s.ncols() > 0 and + precondition(s.nslices() > 0 && + s.nrows() > 0 && + s.ncols() > 0 && s.border() >= 0); invariant_(); this->clear_data(); @@ -167,22 +167,22 @@ bool impl_hold(const point3d& p) const { return - p.slice() >= 0 and - p.slice() < size_.nslices() and - p.row() >= 0 and - p.row() < size_.nrows() and - p.col() >= 0 and + p.slice() >= 0 && + p.slice() < size_.nslices() && + p.row() >= 0 && + p.row() < size_.nrows() && + p.col() >= 0 && p.col() < size_.ncols(); } bool impl_hold_large(const point3d& p) const { return - p.slice() >= - size_.border() and - p.slice() < size_.nslices() + size_.border() and - p.row() >= - size_.border() and - p.row() < size_.nrows() + size_.border() and - p.col() >= - size_.border() and + p.slice() >= - size_.border() && + p.slice() < size_.nslices() + size_.border() && + p.row() >= - size_.border() && + p.row() < size_.nrows() + size_.border() && + p.col() >= - size_.border() && p.col() < size_.ncols() + size_.border(); } @@ -219,19 +219,21 @@ void invariant_() const { - invariant((buffer_ != 0 and - array_ != 0 and - size_.nslices() > 0 and - size_.nrows() > 0 and - size_.ncols() > 0 and + invariant((buffer_ != 0 && + array_ != 0 && + array2_ != 0 && + size_.nslices() > 0 && + size_.nrows() > 0 && + size_.ncols() > 0 && size_.border() >= 0) - or - (buffer_ == 0 and - array_ == 0 and - size_.nslices() == 0 and - size_.nrows() == 0 and - size_.ncols() == 0 and - size_.border() == 0)); + || + (buffer_ == 0 && + array_ == 0 && + array2_ == 0 && + size_.nslices().is_undefined() && + size_.nrows().is_undefined() && + size_.ncols().is_undefined() && + size_.border().is_undefined())); } }; Index: oln/core/3d/image3d.hh --- oln/core/3d/image3d.hh (revision 51) +++ oln/core/3d/image3d.hh (working copy) @@ -32,6 +32,7 @@ # include <oln/core/abstract/image_with_data.hh> # include <oln/core/3d/array3d.hh> +# include <oln/core/3d/fwd_piter3d.hh> /*! \namespace oln ** \brief oln namespace. @@ -67,8 +68,8 @@ typedef point3d point_type; typedef T value_type; -// typedef fwd_piter3d piter_type; -// typedef fwd_piter3d fwd_piter_type; + typedef fwd_piter3d piter_type; + typedef fwd_piter3d fwd_piter_type; // please note that value_storage_type means data_type // since image3d is an image_with_data Index: oln/core/3d/fwd_piter3d.hh --- oln/core/3d/fwd_piter3d.hh (revision 0) +++ oln/core/3d/fwd_piter3d.hh (revision 0) @@ -0,0 +1,129 @@ +// 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_3D_FWD_PITER3D_HH +# define OLENA_CORE_3D_FWD_PITER3D_HH + +# include <mlc/contract.hh> + +# include <oln/core/abstract/piter.hh> +# include <oln/core/3d/point3d.hh> +# include <oln/core/3d/size3d.hh> + + +namespace oln { + + // fwd decl + struct fwd_piter3d; + + // category + template <> + struct set_category<fwd_piter3d> { typedef category::piter ret; }; + + + // props + template <> + struct set_props < category::piter, fwd_piter3d > : public props_of<category::piter> + { + typedef point3d point_type; + typedef size3d size_type; + }; + + + + struct fwd_piter3d : public abstract::piter< fwd_piter3d > + { + + typedef abstract::piter<fwd_piter3d> super_type; + + fwd_piter3d(const size3d& size) : + super_type(size) + { + this->exact_ptr = this; + this->invalidate(); + } + +# if defined __GNUC__ && __GNUC__ >= 3 + friend class abstract::piter< fwd_piter3d >; + protected: +# endif + + void impl_start() + { + this->p_.row() = 0; + this->p_.col() = 0; + this->p_.slice() = 0; + postcondition(this->p_.row().is_defined() && + this->p_.col().is_defined() && + this->p_.slice().is_defined()); + } + + bool impl_is_valid() const + { + precondition(this->p_.row().is_defined() && + this->p_.col().is_defined() && + this->p_.slice().is_defined()); + return this->p_.slice() < this->s_.nslices(); + } + + void impl_next() + { + precondition(this->p_.row().is_defined() && + this->p_.col().is_defined() && + this->p_.slice().is_defined()); + precondition(this->p_.row() >= 0 && this->p_.row() < this->s_.nrows() && + this->p_.col() >= 0 && this->p_.col() < this->s_.ncols() && + this->p_.slice() >= 0 && this->p_.slice() < this->s_.nslices()); + ++this->p_.col(); + if (this->p_.col() != this->s_.ncols()) + return; + this->p_.col() = 0; + ++this->p_.row(); + if (this->p_.row() != this->s_.nrows()) + return; + this->p_.row() = 0; + ++this->p_.slice(); + postcondition(this->p_.row().is_defined() && + this->p_.col().is_defined() && + this->p_.slice().is_defined()); + } + + void impl_invalidate() + { + this->p_.row() = this->s_.nrows(); + this->p_.col() = this->s_.ncols(); + this->p_.slice() = this->s_.nslices(); + postcondition(this->p_.row().is_defined() && + this->p_.col().is_defined() && + this->p_.slice().is_defined()); + } + + }; +} + + +#endif // ! OLENA_CORE_3D_FWD_PITER3D_HH Index: oln/core/3d/point3d.hh --- oln/core/3d/point3d.hh (revision 51) +++ oln/core/3d/point3d.hh (working copy) @@ -57,11 +57,9 @@ struct point3d : public abstract::point< point3d > { - point3d() : - slice_(0), - row_(0), - col_(0) + point3d() { + // no initialization here so that slice_, row_, and col_ are 'undef' } point3d(coord_t slice_, coord_t row_, coord_t col_) :

20 years, 1 month

proto-1.0 51: Add properties mechanism

by Thierry GERAUD

Index: ChangeLog from Thierry Geraud <theo(a)lrde.epita.fr> * oln/core/entry.hh: Move to... * oln/core/abstract/entry.hh: ...here. * oln/core/properties.hh: New. * tests/core/tests/image1d: Adapt to properties management. * tests/core/tests/image2d: Likewise. * tests/core/tests/image3d: Likewise. * tests/core/tests/image_identity: Likewise. * tests/core/tests/setget: Likewise. * oln/fancy/print.hh: Likewise. * oln/fancy/iota.hh: Likewise. * oln/basics.hh: Likewise. * oln/makefile.src: Likewise. * oln/io/write_image_2d_pnm.hh: Likewise. * oln/io/read_image_2d_pnm.hh: Likewise. * oln/io/write_image.hh: Likewise. * oln/io/read_image.hh: Likewise. * oln/core/value_box.hh: Likewise. * oln/core/abstract/image_constness.hh: Likewise. * oln/core/abstract/image.hh: Likewise. * oln/core/abstract/piter.hh: Likewise. * oln/core/abstract/images.hh: Likewise. * oln/core/abstract/image_with_data.hh: Likewise. * oln/core/abstract/point.hh: Likewise. * oln/core/abstract/image_identity.hh: Likewise. * oln/core/abstract/data_storage.hh: Likewise. * oln/core/abstract/internal/image_impl.hh: Likewise. * oln/core/abstract/op.hh: Likewise. * oln/core/1d/array1d.hh: Likewise. * oln/core/1d/image1d.hh: Likewise. * oln/core/1d/fwd_piter1d.hh: Likewise. * oln/core/1d/point1d.hh: Likewise. * oln/core/coord.hh: Likewise. * oln/core/2d/array2d.hh: Likewise. * oln/core/2d/image2d.hh: Likewise. * oln/core/2d/fwd_piter2d.hh: Likewise. * oln/core/2d/point2d.hh: Likewise. * oln/core/3d/array3d.hh: Likewise. * oln/core/3d/image3d.hh: Likewise. * oln/core/3d/point3d.hh: Likewise. * oln/core/cats.hh: Remove because obsolete. * oln/core/props.hh: Likewise. * oln/core/macros.hh: Likewise. oln/basics.hh | 2 oln/core/1d/array1d.hh | 13 ++ oln/core/1d/fwd_piter1d.hh | 13 ++ oln/core/1d/image1d.hh | 47 ++++++---- oln/core/1d/point1d.hh | 16 ++- oln/core/2d/array2d.hh | 15 ++- oln/core/2d/fwd_piter2d.hh | 12 ++ oln/core/2d/image2d.hh | 35 ++++--- oln/core/2d/point2d.hh | 15 ++- oln/core/3d/array3d.hh | 13 ++ oln/core/3d/image3d.hh | 42 ++++----- oln/core/3d/point3d.hh | 13 ++ oln/core/abstract/data_storage.hh | 61 +++++++++++-- oln/core/abstract/entry.hh | 83 ++++++++++++++++++ oln/core/abstract/image.hh | 138 +++++++++++++++++++++---------- oln/core/abstract/image_constness.hh | 17 ++- oln/core/abstract/image_identity.hh | 28 +++++- oln/core/abstract/image_with_data.hh | 54 ++++++++++-- oln/core/abstract/images.hh | 3 oln/core/abstract/internal/image_impl.hh | 7 - oln/core/abstract/op.hh | 22 ++++ oln/core/abstract/piter.hh | 45 +++++++--- oln/core/abstract/point.hh | 41 ++++++--- oln/core/cats.hh | 79 ----------------- oln/core/coord.hh | 8 + oln/core/entry.hh | 66 -------------- oln/core/macros.hh | 86 ------------------- oln/core/properties.hh | 95 +++++++++++++++++++++ oln/core/props.hh | 77 ----------------- oln/core/value_box.hh | 37 ++++---- oln/fancy/iota.hh | 3 oln/fancy/print.hh | 5 - oln/io/read_image.hh | 4 oln/io/read_image_2d_pnm.hh | 27 ++---- oln/io/write_image.hh | 6 - oln/io/write_image_2d_pnm.hh | 3 oln/makefile.src | 6 - tests/core/tests/image1d | 2 tests/core/tests/image2d | 2 tests/core/tests/image3d | 2 tests/core/tests/image_identity | 11 +- tests/core/tests/setget | 6 - 42 files changed, 700 insertions(+), 560 deletions(-) Index: tests/core/tests/image1d --- tests/core/tests/image1d (revision 50) +++ tests/core/tests/image1d (working copy) @@ -13,7 +13,7 @@ template <typename I> -void foo(oln::abstract::image<I>& input, const oln_point_type(I)& p) +void foo(oln::abstract::image<I>& input, const oln_type_of(I, point)& p) { // FIXME: dummy code below // struct dummy {}; Index: tests/core/tests/image2d --- tests/core/tests/image2d (revision 50) +++ tests/core/tests/image2d (working copy) @@ -13,7 +13,7 @@ template <typename I> -void foo(oln::abstract::image<I>& input, const oln_point_type(I)& p) +void foo(oln::abstract::image<I>& input, const oln_type_of(I, point)& p) { // FIXME: dummy code below // struct dummy {}; Index: tests/core/tests/image3d --- tests/core/tests/image3d (revision 50) +++ tests/core/tests/image3d (working copy) @@ -13,7 +13,7 @@ template <typename I> -void foo(oln::abstract::image<I>& input, const oln_point_type(I)& p) +void foo(oln::abstract::image<I>& input, const oln_type_of(I, point)& p) { // FIXME: dummy code below // struct dummy {}; Index: tests/core/tests/image_identity --- tests/core/tests/image_identity (revision 50) +++ tests/core/tests/image_identity (working copy) @@ -10,14 +10,14 @@ namespace oln { template <typename I> - struct category_type< image_identity<I> > + struct set_category< image_identity<I> > { - typedef cat::image ret; + typedef category::image ret; }; template <typename I> - struct props <cat::image, image_identity<I> > - : public props<cat::image, I> + struct set_props < category::image, image_identity<I> > + : public get_props < category::image, I > { typedef I delegated_type; }; @@ -25,8 +25,7 @@ } template <typename I> -struct image_identity: - public oln::abstract::image_identity<I, image_identity<I> > +struct image_identity : public oln::abstract::image_identity<I, image_identity<I> > { typedef oln::abstract::image_identity<I, image_identity<I> > super_type; Index: tests/core/tests/setget --- tests/core/tests/setget (revision 50) +++ tests/core/tests/setget (working copy) @@ -7,13 +7,13 @@ struct dummy_image; template <> - struct category_type< dummy_image > + struct set_category< dummy_image > { - typedef cat::image ret; + typedef category::image ret; }; template <> - struct props <cat::image, dummy_image> + struct set_props < category::image, dummy_image > : public props_of <category::image> { typedef int size_type; typedef int point_type; Index: oln/fancy/print.hh --- oln/fancy/print.hh (revision 50) +++ oln/fancy/print.hh (working copy) @@ -40,6 +40,7 @@ # include <oln/core/2d/point2d.hh> # include <oln/core/coord.hh> + namespace oln { namespace fancy { @@ -106,7 +107,7 @@ // FIXME: lacks cleaning for (coord_t index = 0; index < input.size().nindices(); ++index) { - ostr << internal::pp<oln_value_type(E)>(input[point1d(index)]) << ' '; + ostr << internal::pp<oln_type_of(E, value)>(input[point1d(index)]) << ' '; } ostr << std::endl; } @@ -118,7 +119,7 @@ for (coord_t row = 0; row < input.size().nrows(); ++row) { for (coord_t col = 0; col < input.size().ncols(); ++col) - ostr << internal::pp<oln_value_type(E)>(input[point2d(row,col)]) << ' '; + ostr << internal::pp<oln_type_of(E, value)>(input[point2d(row,col)]) << ' '; ostr << std::endl; } } Index: oln/fancy/iota.hh --- oln/fancy/iota.hh (revision 50) +++ oln/fancy/iota.hh (working copy) @@ -28,7 +28,6 @@ #ifndef OLENA_FANCY_IOTA_HH # define OLENA_FANCY_IOTA_HH -# include <oln/core/macros.hh> # include <oln/core/abstract/image.hh> # include <oln/core/abstract/piter.hh> @@ -43,7 +42,7 @@ void iota(abstract::image<I>& inout) { unsigned counter = 0; - oln_piter_type(I) p(inout.size()); + oln_type_of(I, fwd_piter) p(inout.size()); for_all(p) inout[p] = ++counter; } Index: oln/basics.hh --- oln/basics.hh (revision 50) +++ oln/basics.hh (working copy) @@ -54,7 +54,7 @@ // oln:: # include <oln/core/coord.hh> -# include <oln/core/macros.hh> +# include <oln/core/properties.hh> # include <oln/core/value_box.hh> # include <oln/core/abstract/size.hh> Index: oln/makefile.src --- oln/makefile.src (revision 50) +++ oln/makefile.src (working copy) @@ -24,6 +24,7 @@ core/3d/point3d.hh \ core/3d/size3d.hh \ core/abstract/data_storage.hh \ + core/abstract/entry.hh \ core/abstract/image.hh \ core/abstract/image_constness.hh \ core/abstract/image_identity.hh \ @@ -34,11 +35,8 @@ core/abstract/piter.hh \ core/abstract/point.hh \ core/abstract/size.hh \ - core/cats.hh \ core/coord.hh \ - core/macros.hh \ - core/props.hh \ - core/entry.hh \ + core/properties.hh \ core/value_box.hh \ fancy/iota.hh \ fancy/print.hh \ Index: oln/io/write_image_2d_pnm.hh --- oln/io/write_image_2d_pnm.hh (revision 50) +++ oln/io/write_image_2d_pnm.hh (working copy) @@ -41,7 +41,6 @@ # include <ntg/color/color.hh> # include <oln/core/2d/image2d.hh> -# include <oln/core/macros.hh> # include <oln/core/abstract/op.hh> # include <oln/io/utils.hh> @@ -56,7 +55,7 @@ struct write_image_2d_raw : public oln::abstract::void_op<write_image_2d_raw<I> > { - typedef oln_value_type(I) value_type; + typedef oln_type_of(I, value) value_type; typedef ntg_io_type(value_type) io_type; const I& to_write_; Index: oln/io/read_image_2d_pnm.hh --- oln/io/read_image_2d_pnm.hh (revision 50) +++ oln/io/read_image_2d_pnm.hh (working copy) @@ -13,7 +13,6 @@ # include <ntg/color/color.hh> # include <oln/core/2d/image2d.hh> -# include <oln/core/macros.hh> # include <oln/core/abstract/op.hh> # include <oln/io/utils.hh> @@ -24,43 +23,39 @@ template <typename I> struct image2d; + // fwd decl namespace io { - namespace impl { - - template <typename I> - struct read_image_2d_raw; - + template <typename I> struct read_image_2d_raw; } - } + // category template <typename I> - struct category_type< io::impl::read_image_2d_raw<I> > + struct set_category < io::impl::read_image_2d_raw<I> > { - typedef cat::image ret; + typedef category::image ret; }; + // super_type template <typename I> - struct props <cat::image, io::impl::read_image_2d_raw<I> > - : public props<cat::image, I> + struct set_super_type < io::impl::read_image_2d_raw<I> > { - typedef I delegated_type; + typedef abstract::op<I, io::impl::read_image_2d_raw<I> > ret; }; - namespace io { namespace impl { template <typename I> - struct read_image_2d_raw: - oln::abstract::op<I, read_image_2d_raw<I> > + struct read_image_2d_raw : + public oln::abstract::op<I, read_image_2d_raw<I> > { typedef oln::abstract::op<I, read_image_2d_raw<I> > super_type; - typedef oln_value_type(I) value_type; + typedef oln_type_of(I, value) value_type; typedef ntg_io_type(value_type) io_type; mlc::box<I> image_; Index: oln/io/write_image.hh --- oln/io/write_image.hh (revision 50) +++ oln/io/write_image.hh (working copy) @@ -37,11 +37,11 @@ namespace io { - template <typename E> - void write(const abstract::image<E>& im, const std::string& name) + template <typename I> + void write(const abstract::image<I>& im, const std::string& name) { std::string ext; - oln_value_type(E) t; + oln_type_of(I, value) t; ext = internal::utils::extension(name); Index: oln/io/read_image.hh --- oln/io/read_image.hh (revision 50) +++ oln/io/read_image.hh (working copy) @@ -33,8 +33,6 @@ # include <mlc/box.hh> -# include <oln/core/macros.hh> - # include <oln/io/read_image_2d_pnm.hh> # include <oln/io/utils.hh> @@ -65,7 +63,7 @@ void do_read(abstract::image<I>& ima, const filename& name) { std::string ext; - const oln_value_type(I) t; + const oln_type_of(I, value) t; ext = internal::utils::extension(name.get()); Index: oln/core/entry.hh --- oln/core/entry.hh (revision 50) +++ oln/core/entry.hh (working copy) @@ -1,66 +0,0 @@ -// Copyright (C) 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_ENTRY_HH -# define OLENA_CORE_ENTRY_HH - -# include <oln/core/abstract/image_constness.hh> -# include <oln/core/abstract/image_dimension.hh> - - -namespace oln { - - template <template <typename> class Base> - struct prop_of - { - template <typename E> - struct inherits - { - typedef Base<E> ret; - }; - }; - - namespace abstract { - - template <typename E> - struct image_entry : - public props < cat::image, E >::image_constness - ::template inherits<E>::ret, - public props < cat::image, E >::image_dimension - ::template inherits<E>::ret - // ... - { - protected: - image_entry() {} - }; - - } - -} // end of namespace oln - - -#endif // ! OLENA_CORE_ENTRY_HH Index: oln/core/props.hh --- oln/core/props.hh (revision 50) +++ oln/core/props.hh (working copy) @@ -1,77 +0,0 @@ -// Copyright (C) 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_PROPS_HH -# define OLENA_CORE_PROPS_HH - -# include <mlc/types.hh> - -# include <oln/core/cats.hh> - -/*! \namespace oln -** \brief oln namespace. -*/ -namespace oln { - - - /*! \class default_props - ** - ** \brief Class that defines properties by default, so properties are - ** undefined. // FIXME: this doc should be modified... - ** - ** Practically all typedefs of default_props are thus set to - ** mlc::undefined_type. - ** - ** When props<E> is specialized, the programmer should derive that - ** specialization from another props<E'> or from default_props. - ** That ensures that an undefined property is set to mlc::undefined_type. - ** - ** \see props<E> - */ - template < typename category > - struct default_props; - - - /*! \class props<E> - ** - ** Declaration of the trait class for properties. - ** Parameter E is the targeted type. FIXME: rewrite doc. - */ - template <typename category, typename type> - struct props : public default_props <category> - {}; - - template <typename category, typename type> - struct props <category, const type> : public props <category, type> - {}; - - - -} // end of namespace oln - - -#endif // ! OLENA_CORE_PROPS_HH Index: oln/core/value_box.hh --- oln/core/value_box.hh (revision 50) +++ oln/core/value_box.hh (working copy) @@ -30,16 +30,11 @@ # include <iostream> -# include <oln/core/macros.hh> +# include <oln/core/properties.hh> -// the proper macro: -// for use in 'abstract::image::op[](point)' -# define oln_value_box_type(E) typename oln::value_box<E> - - /*! \namespace oln ** \brief oln namespace. */ @@ -78,7 +73,12 @@ public: + /// typedefs + typedef oln_type_of(I, value) value_type; + typedef oln_type_of(I, point) point_type; + + /*! \brief op= ** FIXME:... ** \return (*this) @@ -103,7 +103,7 @@ template <typename II> value_box& operator=(const value_box<II>& rhs) { - ima_.set(p_, rhs); // automatic conversion from rhs to oln_value_type(I) + ima_.set(p_, rhs); // automatic conversion from rhs to value_type return *this; } @@ -137,7 +137,7 @@ return value; } - operator const oln_value_type(I)() const + operator const value_type() const { return ima_.get(p_); } @@ -154,7 +154,7 @@ ** \return a value (const, temp) */ - const oln_value_type(I) value() const + const value_type value() const { return ima_.get(p_); } @@ -179,7 +179,7 @@ /// Ctor (restricted access). - value_box(abstract::image<I>& ima, const oln_point_type(I)& p) : + value_box(abstract::image<I>& ima, const point_type& p) : ima_(ima.exact()), p_(p) { @@ -190,7 +190,7 @@ *------------*/ I& ima_; - oln_point_type(I) p_; + point_type p_; }; @@ -213,6 +213,13 @@ public: + /// typedefs + + typedef oln_type_of(I, value) value_type; + typedef oln_type_of(I, point) point_type; + + + /*! \brief Assignment (op=) is declared but undefined. */ @@ -232,7 +239,7 @@ return value; } - operator const oln_value_type(I)() const + operator const value_type() const { return ima_.get(p_); } @@ -249,7 +256,7 @@ ** \return a value (const, temp) */ - const oln_value_type(I) value() const + const value_type value() const { return ima_.get(p_); } @@ -276,7 +283,7 @@ /// Ctor (restricted access). - value_box(const abstract::image<I>& ima, const oln_point_type(I)& p) : + value_box(const abstract::image<I>& ima, const point_type& p) : ima_(ima.exact()), p_(p) { @@ -287,7 +294,7 @@ *------------*/ const I& ima_; - oln_point_type(I) p_; + point_type p_; }; Index: oln/core/macros.hh --- oln/core/macros.hh (revision 50) +++ oln/core/macros.hh (working copy) @@ -1,86 +0,0 @@ -// Copyright (C) 2001, 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_MACROS_HH -# define OLENA_CORE_MACROS_HH - -# include <oln/core/cats.hh> -# include <oln/core/props.hh> - - - -// FIXME: some crucial (meta-)work to be done here! -// -// first, introduce a piece of meta-code to get the proper abstraction -// from parameter; e.g., if I is an abstract::image then abstraction -// is abstract::image else etc. -// -// second, in macro below, there should be an exact_type from I somewhere -// cause we cannot be sure that I is an exact type; just think about it... - - - - - -// for oln::abstract::image -//-------------------------- - -// unary macros - -# define oln_delegated_type(T) typename oln::props<oln_category_type(T),T>::delegated_type - -# define oln_size_type(T) typename oln::props<oln_category_type(T),T>::size_type -# define oln_point_type(T) typename oln::props<oln_category_type(T),T>::point_type -# define oln_dpoint_type(T) typename oln::props<oln_category_type(T),T>::dpoint_type -# define oln_value_type(T) typename oln::props<oln_category_type(T),T>::value_type -# define oln_iter_type(T) typename oln::props<oln_category_type(T),T>::iter_type - -# define oln_value_storage_type(T) typename oln::props<oln_category_type(T),T>::value_storage_type -# define oln_value_container_type(T) typename oln::props<oln_category_type(T),T>::value_container_type - -# define oln_piter_type(T) typename oln::props<oln_category_type(T),T>::piter_type -# define oln_fwd_piter_type(T) typename oln::props<oln_category_type(T),T>::fwd_piter_type - -// binary macros - -# define oln_ch_value_type(I,V) typename oln::props<oln_category_type(I),I>::ch_value_type<V>::ret - - -// for oln::abstract::data_storage - -# define oln_data_type(T) typename oln::props<oln_category_type(T),T>::data_type - - - -// generic macros -//---------------- - -# define oln_typeof( FROM_TYPE, WHAT_TYPE ) typename oln::props<oln_category_type(FROM_TYPE),FROM_TYPE>::WHAT_TYPE##_type - - - -#endif // ! OLENA_CORE_MACROS_HH Index: oln/core/abstract/image_constness.hh --- oln/core/abstract/image_constness.hh (revision 50) +++ oln/core/abstract/image_constness.hh (working copy) @@ -87,6 +87,11 @@ */ + /// typedef + + typedef oln_type_of(E, point) point_type; + + /*! \brief Write the value \a v at \a p in the current image. ** This method is used in value_box<I>. Client should not use ** this method but abstract::image<I>::operator[](point) @@ -96,7 +101,7 @@ */ template <typename V> - void set(const oln_point_type(E)& p, const V& v) + void set(const point_type& p, const V& v) { return this->exact().impl_set(p, v); } @@ -104,7 +109,7 @@ // FIXME: NEW: // template <typename A, typename V> -// void& set(const oln_point_type(E)& p, +// void& set(const point_type& p, // void (I::*method)(A), // const V& value) // { @@ -126,10 +131,12 @@ template <typename E> struct set_image_impl < readwrite_image<E>, E> : public virtual image_impl<E> { + /// typedefs typedef typename image_impl<E>::D D; + typedef oln_type_of(D, point) point_type; template <typename V> - void impl_set(const oln_point_type(D)& p, const V& v) + void impl_set(const point_type& p, const V& v) { this->exact().impl_set_ante(p, v); this->delegate().impl_set(p, v); @@ -139,10 +146,10 @@ // extra code; default is 'do nothing': template <typename V> - void impl_set_ante(const oln_point_type(D)&, const V&) {} + void impl_set_ante(const point_type&, const V&) {} template <typename V> - void impl_set_post(const oln_point_type(D)&, const V&) {} + void impl_set_post(const point_type&, const V&) {} }; } // end of namespace oln::abstract::internal Index: oln/core/abstract/entry.hh --- oln/core/abstract/entry.hh (revision 0) +++ oln/core/abstract/entry.hh (revision 0) @@ -0,0 +1,83 @@ +// Copyright (C) 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_ABSTRACT_ENTRY_HH +# define OLENA_CORE_ABSTRACT_ENTRY_HH + +# include <oln/core/abstract/image_constness.hh> +# include <oln/core/abstract/image_dimension.hh> + + +// FIXME: this file should move to oln/core/abstract/ + + +namespace oln { + + + // fwd decl + namespace abstract { + template <typename E> struct image_entry; + } + + // category + template <typename E> + struct set_category < abstract::image_entry<E> > + { + typedef category::image ret; + }; + + + + namespace abstract { + +// namespace internal { + +// template < typename isa, typename E > +// struct inherits +// { +// typedef typename isa::template instantiated_with<E>::ret ret; +// }; + +// } + + template <typename E> + struct image_entry : + // intrusive: + public oln_type_of_(E, image_constness) ::template instantiated_with<E>::ret, + public oln_type_of_(E, image_dimension) ::template instantiated_with<E>::ret + // ... + { + protected: + image_entry() {} + }; + + } + +} // end of namespace oln + + +#endif // ! OLENA_CORE_ABSTRACT_ENTRY_HH Index: oln/core/abstract/image.hh --- oln/core/abstract/image.hh (revision 50) +++ oln/core/abstract/image.hh (working copy) @@ -28,10 +28,10 @@ #ifndef OLENA_CORE_ABSTRACT_IMAGE_HH # define OLENA_CORE_ABSTRACT_IMAGE_HH +# include <mlc/types.hh> + # include <oln/core/abstract/internal/image_impl.hh> -# include <oln/core/cats.hh> -# include <oln/core/props.hh> -# include <oln/core/macros.hh> +# include <oln/core/properties.hh> # include <oln/core/value_box.hh> @@ -41,37 +41,72 @@ namespace oln { + // fwd decl + namespace abstract { + template <typename E> struct image; + template <typename E> struct readonly_image; + } - // FIXME: doc - template <> - struct default_props < cat::image > - { - typedef mlc::undefined_type delegated_type; + // category + template <typename E> + struct set_category< abstract::image<E> > { typedef category::image ret; }; - typedef mlc::undefined_type size_type; - typedef mlc::undefined_type point_type; - typedef mlc::undefined_type value_type; - typedef mlc::undefined_type piter_type; - typedef mlc::undefined_type fwd_piter_type; - typedef mlc::undefined_type value_storage_type; - typedef mlc::undefined_type value_container_type; + /// properties of any type in category::image - // FIXME: etc. + template <typename type> + struct props_of <category::image, type> + { + typedef mlc::true_type user_defined_; + + mlc_decl_prop(category::image, value_type); + mlc_decl_prop(category::image, point_type); + mlc_decl_prop(category::image, size_type); + mlc_decl_prop(category::image, fwd_piter_type); + mlc_decl_prop_with_default(category::image, value_storage_type, mlc::no_type); + mlc_decl_prop_with_default(category::image, storage_type, mlc::no_type); + mlc_decl_prop_with_default(category::image, delegated_type, mlc::no_type); - template <typename T> - struct ch_value_type + mlc_decl_prop_with_default(category::image, image_constness_type, is_a<abstract::readonly_image>); + mlc_decl_prop(category::image, image_dimension_type); + + //... + + static void echo(std::ostream& ostr) { - typedef mlc::undefined_type ret; - }; + ostr << "props_of(" // FIXME: << typeid(oln::category::image).name() + << ", " << typeid(type).name() << ") = {" + << " value_type = " << typeid(value_type).name() + << " point_type = " << typeid(point_type).name() + << " size_type = " << typeid(size_type).name() + << " fwd_piter_type = " << typeid(fwd_piter_type).name() + << " value_storage_type = " << typeid(value_storage_type).name() + << " storage_type = " << typeid(storage_type).name() + << " delegated_type = " << typeid(delegated_type).name() - protected: - default_props() {} + << " image_constness_type = " << typeid(image_constness_type).name() + << " image_dimension_type = " << typeid(image_dimension_type).name() + + << " }" << std::endl; + } + }; + mlc_register_prop(category::image, value_type); + mlc_register_prop(category::image, point_type); + mlc_register_prop(category::image, size_type); + mlc_register_prop(category::image, fwd_piter_type); + mlc_register_prop(category::image, value_storage_type); + mlc_register_prop(category::image, storage_type); + mlc_register_prop(category::image, delegated_type); + mlc_register_prop(category::image, image_constness_type); + mlc_register_prop(category::image, image_dimension_type); + + + /*! \namespace oln::abstract ** \brief oln::abstract namespace. */ @@ -92,20 +127,27 @@ struct image : public internal::get_image_impl < image<E>, E> { + /// typedefs + + typedef oln_type_of(E, size) size_type; + typedef oln_type_of(E, value) value_type; + typedef oln_type_of(E, point) point_type; + + /*------------------* ! abstract methods ! *------------------*/ - /*! \brief Return the size of the current image. Nota bene: this method is abstract-like.it - ** is a pseudo-abstract method. + /*! \brief Return the size of the current image. Nota bene: + ** this method is abstract-like.it is a pseudo-abstract method. ** ** \return An object deriving from abstract::size. Ex: if the ** image is an image2d<something>, the returned object is a ** size2d. */ - const oln_size_type(E)& size() const + const size_type& size() const { return this->exact().impl_size(); } @@ -137,7 +179,7 @@ ** \see hold_large */ - bool hold(const oln_point_type(E)& p) const + bool hold(const point_type& p) const { precondition(this->npoints() != 0); return this->exact().impl_hold(p); @@ -158,7 +200,7 @@ ** \see hold */ - bool hold_large(const oln_point_type(E)& p) const + bool hold_large(const point_type& p) const { precondition(this->npoints() != 0); return this->exact().impl_hold_large(p); @@ -175,7 +217,7 @@ ** \see hold_large */ - bool impl_hold_large(const oln_point_type(E)& p) const + bool impl_hold_large(const point_type& p) const { return this->hold(p); } @@ -196,11 +238,11 @@ ** \see value_box */ - oln_value_box_type(const E) operator[](const oln_point_type(E)& p) const + value_box<const E> operator[](const point_type& p) const { precondition(this->npoints() != 0); precondition(this->hold_large(p)); - oln_value_box_type(const E) tmp(this->exact(), p); + value_box<const E> tmp(this->exact(), p); return tmp; } @@ -214,11 +256,11 @@ ** \see value_box */ - oln_value_box_type(E) operator[](const oln_point_type(E)& p) + value_box<E> operator[](const point_type& p) { precondition(this->npoints() != 0); precondition(this->hold_large(p)); - oln_value_box_type(E) tmp(this->exact(), p); + value_box<E> tmp(this->exact(), p); return tmp; } @@ -251,7 +293,7 @@ ** \see value_box, abstract::image<I>::operator[](point) */ - const oln_value_type(E) get(const oln_point_type(E)& p) const + const value_type get(const point_type& p) const { return this->exact().impl_get(p); } @@ -282,13 +324,21 @@ template <typename E> struct set_image_impl < image<E>, E > : public virtual image_impl<E> { + + /// typedefs + typedef typename image_impl<E>::D D; + typedef oln_type_of(D, size) size_type; + typedef oln_type_of(D, point) point_type; + typedef oln_type_of(D, value) value_type; + + // delegations are "template methods" (Cf. the GOF's book) - const oln_size_type(D)& impl_size() const + const size_type& impl_size() const { - const oln_size_type(D)& s = this->delegate().size(); + const size_type& s = this->delegate().size(); this->exact().impl_size_extra(s); return s; } @@ -300,31 +350,31 @@ return n; } - bool impl_hold(const oln_point_type(D)& p) const + bool impl_hold(const point_type& p) const { this->exact().impl_hold_extra(p); return this->delegate().hold(p); } - bool impl_hold_large(const oln_point_type(D)& p) const + bool impl_hold_large(const point_type& p) const { this->exact().impl_hold_large_extra(p); return this->delegate().hold_large(p); } - oln_value_box_type(D) operator[](const oln_point_type(D)& p) const + value_box<D> operator[](const point_type& p) const { precondition(this->hold_large(p)); return this->delegate().operator[](p); } - oln_value_box_type(const D) operator[](const oln_point_type(D)& p) + value_box<const D> operator[](const point_type& p) { precondition(this->hold_large(p)); return this->delegate().operator[](p); } - const oln_value_type(D) impl_get(const oln_point_type(D)& p) const + const value_type impl_get(const point_type& p) const { this->exact().impl_get_extra(p); return this->delegate().impl_get(p); @@ -332,13 +382,13 @@ // extra code; default is "do nothing" - void impl_size_extra(const oln_size_type(D)& s) const {} + void impl_size_extra(const size_type& s) const {} void impl_npoints_extra(unsigned long n) const {} - void impl_hold_extra(const oln_point_type(D)& p) const {} - void impl_hold_large_extra(const oln_point_type(D)& p) const {} + void impl_hold_extra(const point_type& p) const {} + void impl_hold_large_extra(const point_type& p) const {} - void impl_get_extra(const oln_point_type(D)&) const {} + void impl_get_extra(const point_type&) const {} }; } // end of namespace oln::abstract::internal Index: oln/core/abstract/piter.hh --- oln/core/abstract/piter.hh (revision 50) +++ oln/core/abstract/piter.hh (working copy) @@ -33,9 +33,7 @@ # include <mlc/contract.hh> # include <oln/core/abstract/point.hh> -# include <oln/core/cats.hh> -# include <oln/core/props.hh> -# include <oln/core/macros.hh> +# include <oln/core/properties.hh> @@ -44,34 +42,55 @@ namespace oln { + // fwd decl namespace abstract { - template <typename E> struct piter; - } - + // category template <typename E> - struct category_type<abstract::piter<E> > { typedef cat::piter ret; }; + struct set_category< abstract::piter<E> > { typedef category::piter ret; }; - template <> - struct default_props < cat::piter > + /// properties of any type in category::piter + + template <typename type> + struct props_of < category::piter, type > { - typedef mlc::undefined_type point_type; - typedef mlc::undefined_type size_type; + typedef mlc::true_type user_defined_; + + mlc_decl_prop(category::piter, size_type); + mlc_decl_prop(category::piter, point_type); + + static void echo(std::ostream& ostr) + { + ostr << "props_of( category::piter, " + << typeid(type).name() << ") = {" + << " size_type = " << typeid(size_type).name() + << " point_type = " << typeid(point_type).name() << " }" << std::endl; + } + }; + mlc_register_prop(category::piter, size_type); + mlc_register_prop(category::piter, point_type); + + namespace abstract { template <typename E> struct piter : public mlc::any__best_speed<E> { + + /// typedefs + typedef piter<E> self_type; - typedef oln_point_type(E) point_type; - typedef oln_size_type(E) size_type; + typedef oln_type_of(E, size) size_type; + typedef oln_type_of(E, point) point_type; + + void start() { this->exact().impl_start(); Index: oln/core/abstract/images.hh --- oln/core/abstract/images.hh (revision 50) +++ oln/core/abstract/images.hh (working copy) @@ -36,7 +36,4 @@ # include <oln/core/abstract/image_constness.hh> -# include <oln/core/entry.hh> - - #endif // ! OLENA_CORE_ABSTRACT_IMAGES_HH Index: oln/core/abstract/image_with_data.hh --- oln/core/abstract/image_with_data.hh (revision 50) +++ oln/core/abstract/image_with_data.hh (working copy) @@ -31,15 +31,44 @@ # include <mlc/tracked_ptr.hh> -# include <oln/core/entry.hh> -# include <oln/core/macros.hh> +# include <oln/core/abstract/entry.hh> + /*! \namespace oln ** \brief oln namespace. */ namespace oln { + // fwd decl + namespace abstract { + template <typename E> class image_with_data; + } + + // category + template <typename E> + struct set_category < abstract::image_with_data<E> > + { + typedef category::image ret; + }; + + // super_type + template <typename E> + struct set_super_type < abstract::image_with_data<E> > + { + typedef abstract::image_entry<E> ret; + }; + + // props + template <typename E> + struct set_props < category::image, abstract::image_with_data<E> > : public props_of<category::image> + { + // intrusive property: + typedef is_a<abstract::readwrite_image> image_constness_type; + }; + + + /*! \namespace oln::abstract ** \brief oln::abstract namespace. */ @@ -59,7 +88,14 @@ public: + /// typedefs + typedef oln_type_of(E, size) size_type; + typedef oln_type_of(E, point) point_type; + typedef oln_type_of(E, value) value_type; + typedef oln_type_of(E, storage) storage_type; + + /*! \brief Implement abstract::image<E>::size() so return the ** size of the current image. ** @@ -68,7 +104,7 @@ ** size2d. */ - const oln_size_type(E)& impl_size() const + const size_type& impl_size() const { precondition(this->has_data()); return this->data_->size(); @@ -97,7 +133,7 @@ ** \return True if p belongs to the current image, false otherwise. */ - bool impl_hold(const oln_point_type(E)& p) const + bool impl_hold(const point_type& p) const { precondition(this->has_data()); return this->data_->hold(p); @@ -111,7 +147,7 @@ ** \return True if p belongs to the current image, false otherwise. */ - const oln_value_type(E) impl_get(const oln_point_type(E)& p) const + const value_type impl_get(const point_type& p) const { precondition(this->has_data()); return this->data_->get(p); @@ -123,7 +159,7 @@ */ template <typename V> - void impl_set(const oln_point_type(E)& p, const V& v) + void impl_set(const point_type& p, const V& v) { precondition(this->has_data()); this->data_->set(p, v); @@ -151,8 +187,8 @@ /*! \brief Constructor (protected) with memory allocation for ** data. */ - image_with_data(const oln_size_type(E)& size) : - data_(new oln_value_container_type(E)(size)) + image_with_data(const size_type& size) : + data_(new storage_type(size)) { } @@ -166,7 +202,7 @@ /*! \brief Data storage. */ - mlc::tracked_ptr<oln_value_container_type(E)> data_; + mlc::tracked_ptr<storage_type> data_; }; Index: oln/core/abstract/point.hh --- oln/core/abstract/point.hh (revision 50) +++ oln/core/abstract/point.hh (working copy) @@ -29,10 +29,9 @@ # define OLENA_CORE_ABSTRACT_POINT_HH # include <mlc/any.hh> +# include <mlc/bool.hh> -# include <oln/core/cats.hh> -# include <oln/core/props.hh> -# include <oln/core/macros.hh> +# include <oln/core/properties.hh> /*! \namespace oln @@ -41,24 +40,37 @@ namespace oln { - /// fwd decl + // fwd decl namespace abstract { template <typename E> struct point; } + // category + template <typename E> + struct set_category< abstract::point<E> > { typedef category::point ret; }; - /*! \class default_props< cat::point > - ** - ** Default properties for points. Specialization of - ** default_props<category>. - */ - template <> - struct default_props < cat::point > + + /// properties of any type in category::point + + template <typename type> + struct props_of < category::point, type > { - typedef mlc::undefined_type dpoint_type; + typedef mlc::true_type user_defined_; + + mlc_decl_prop(category::point, dpoint_type); + + static void echo(std::ostream& ostr) + { + ostr << "props_of( category::point, " + << typeid(type).name() << ") = {" + << " dpoint_type = " << typeid(dpoint_type).name() << " }" << std::endl; + } + }; + mlc_register_prop(category::point, dpoint_type); + /*! \namespace oln::abstract ** \brief oln::abstract namespace. */ @@ -95,9 +107,10 @@ return ! this->operator==(rhs); } - typedef oln_dpoint_type(E) dpoint_type; + // FIXME: doc... - // FIXME: doc + typedef oln_type_of(E, dpoint) dpoint_type; + const point operator+(const dpoint_type& dp) const { return this->exact().impl_plus(dp); Index: oln/core/abstract/image_identity.hh --- oln/core/abstract/image_identity.hh (revision 50) +++ oln/core/abstract/image_identity.hh (working copy) @@ -30,14 +30,38 @@ # include <mlc/box.hh> -# include <oln/core/entry.hh> +# include <oln/core/properties.hh> +# include <oln/core/abstract/entry.hh> + namespace oln { + + // fwd decl namespace abstract { + template <typename I, typename E> struct image_identity; + } + // category + template <typename I, typename E> + struct set_category< abstract::image_identity<I,E> > { + typedef category::image ret; + }; + + // props + template <typename I, typename E> + struct set_props < category::image, abstract::image_identity<I,E> > + : public get_props< category::image, I > + { + typedef I delegated_type; + }; + + + + namespace abstract { + template <typename I, typename E> - struct image_identity: public abstract::image_entry<E> + struct image_identity : public abstract::image_entry<E> { protected: Index: oln/core/abstract/data_storage.hh --- oln/core/abstract/data_storage.hh (revision 50) +++ oln/core/abstract/data_storage.hh (working copy) @@ -30,15 +30,57 @@ # include <mlc/any.hh> -# include <oln/core/macros.hh> +# include <oln/core/properties.hh> + namespace oln { + // fwd decl namespace abstract { + template <typename E> struct data_storage; + } + // category + template <typename E> + struct set_category< abstract::data_storage<E> > { typedef category::data_storage ret; }; + + + template <typename type> + struct props_of < category::data_storage, type > + { + typedef mlc::true_type user_defined_; + + mlc_decl_prop(category::data_storage, size_type); + mlc_decl_prop(category::data_storage, point_type); + mlc_decl_prop(category::data_storage, data_type); + + static void echo(std::ostream& ostr) + { + ostr << "props_of( category::data_storage, " + << typeid(type).name() << " ) = {" + << " size_type = " << typeid(size_type).name() + << " point_type = " << typeid(point_type).name() + << " data_type = " << typeid(data_type).name() << " }" << std::endl; + } + + }; + + mlc_register_prop(category::data_storage, size_type); + mlc_register_prop(category::data_storage, point_type); + mlc_register_prop(category::data_storage, data_type); + + + namespace abstract { + template <typename E> struct data_storage : public mlc::any__best_speed<E> { + // typedefs + + typedef oln_type_of(E, size) size_type; + typedef oln_type_of(E, point) point_type; + typedef oln_type_of(E, data) data_type; + // abstract methods bool has_data() const @@ -54,12 +96,12 @@ postcondition(! this->has_data()); } - const oln_size_type(E)& size() const + const size_type& size() const { return this->exact().impl_size(); } - void resize(const oln_size_type(E)& s) + void resize(const size_type& s) { this->exact().impl_resize(s); } @@ -71,29 +113,28 @@ return this->exact().impl_npoints(); } - bool hold(const oln_point_type(E)& p) const + bool hold(const point_type& p) const { if (! this->has_data()) return false; return this->exact().impl_hold(p); } - const oln_data_type(E) get(const oln_point_type(E)& p) const + const data_type get(const point_type& p) const { precondition(this->has_data()); precondition(this->hold_large(p)); return this->exact().impl_get(p); } - void set(const oln_point_type(E)& p, - const oln_data_type(E)& v) + void set(const point_type& p, const data_type& v) { precondition(this->has_data()); precondition(this->hold_large(p)); this->exact().impl_set(p, v); } - void set_data(const oln_data_type(E)& v) + void set_data(const data_type& v) { precondition(this->has_data()); this->exact().impl_set_data(v); @@ -101,14 +142,14 @@ // polymorphic method with default - bool hold_large(const oln_point_type(E)& p) const + bool hold_large(const point_type& p) const { if (! this->has_data()) return false; return this->exact().impl_hold_large(p); } - bool impl_hold_large(const oln_point_type(E)& p) const + bool impl_hold_large(const point_type& p) const { return this->exact().impl_hold(p); } Index: oln/core/abstract/internal/image_impl.hh --- oln/core/abstract/internal/image_impl.hh (revision 50) +++ oln/core/abstract/internal/image_impl.hh (working copy) @@ -30,8 +30,9 @@ # include <mlc/any.hh> -# include <oln/core/macros.hh> +# include <oln/core/properties.hh> + namespace oln { namespace abstract { @@ -45,7 +46,7 @@ // entry point: template <typename A, typename E> - struct get_image_impl : public get_image_impl_helper <A, oln_delegated_type(E), E> + struct get_image_impl : public get_image_impl_helper <A, oln_type_of(E, delegated), E> { }; @@ -67,7 +68,7 @@ template <typename E> struct image_impl : public mlc::any__best_speed<E> { - typedef oln_delegated_type(E) D; + typedef oln_type_of(E, delegated) D; D& delegate() { return this->exact().impl_delegate(); } const D& delegate() const { return this->exact().impl_delegate(); } }; Index: oln/core/abstract/op.hh --- oln/core/abstract/op.hh (revision 50) +++ oln/core/abstract/op.hh (working copy) @@ -32,14 +32,28 @@ namespace oln { + // fwd decl namespace abstract { + template <typename O, typename E> struct op; + } - template <typename I, typename E> - struct op : public oln::abstract::image_identity<I, E> + // category + template <typename O, typename E> + struct set_category< abstract::op<O,E> > { typedef category::image ret; }; + + // super_type + template <typename O, typename E> + struct set_super_type< abstract::op<O,E> > { typedef abstract::image_identity<O, E> ret; }; + + + namespace abstract { + + template <typename O, typename E> + struct op : public image_identity<O, E> { - typedef oln::abstract::image_identity<I, E> super_type; + typedef image_identity<O, E> super_type; - op(I& ref): super_type(ref) + op(O& ref) : super_type(ref) { this->exact_ptr = (E*)(void*)(this); } Index: oln/core/1d/array1d.hh --- oln/core/1d/array1d.hh (revision 50) +++ oln/core/1d/array1d.hh (working copy) @@ -36,13 +36,20 @@ namespace oln { + // fwd decl template <typename T> struct array1d; - template <typename T> - struct category_type< array1d<T> > { typedef cat::data_storage ret; }; + // category + template <typename T> + struct set_category< array1d<T> > { typedef category::data_storage ret; }; + // super_type + template <typename T> + struct set_super_type< array1d<T> > { typedef abstract::data_storage< array1d<T> > ret; }; + + // props template <typename T> - struct props < cat::data_storage, array1d<T> > // FIXME: add inheritance + struct set_props < category::data_storage, array1d<T> > : public props_of<category::data_storage> { typedef size1d size_type; typedef point1d point_type; Index: oln/core/1d/image1d.hh --- oln/core/1d/image1d.hh (revision 50) +++ oln/core/1d/image1d.hh (working copy) @@ -25,41 +25,44 @@ // reasons why the executable file might be covered by the GNU General // Public License. -#ifndef OLENA_CORE_IMAGE1D_HH -# define OLENA_CORE_IMAGE1D_HH +#ifndef OLENA_CORE_1D_IMAGE1D_HH +# define OLENA_CORE_1D_IMAGE1D_HH # include <mlc/traits.hh> # include <oln/core/abstract/image_with_data.hh> # include <oln/core/1d/array1d.hh> +# include <oln/core/1d/fwd_piter1d.hh> + + /*! \namespace oln ** \brief oln namespace. */ namespace oln { + // fwd decl template <typename T> class image1d; - // category decl - template <typename T> struct category_type< image1d<T> > { typedef cat::image ret; }; + // category + template <typename T> + struct set_category< image1d<T> > { typedef category::image ret; }; + // super + template <typename T> + struct set_super_type < image1d<T> > + { + typedef abstract::image_with_data< image1d<T> > ret; + }; - /*! \class props< abstract::image, image1d<T> > - ** - ** Properties of common 1D images. Specialization of props<abstraction,type>. - ** Parameter T is the type of pixel values. - ** - ** \see image1d<T>, props<category,type> - */ template <typename T> - struct props < cat::image, image1d<T> > : public default_props < cat::image > + struct set_props < category::image, image1d<T> > : public props_of<category::image> { - // intrusive properties - typedef prop_of<abstract::readwrite_image> image_constness; - typedef prop_of<abstract::image1d> image_dimension; + // intrusive property: + typedef is_a<abstract::image1d> image_dimension_type; typedef mlc::no_type delegated_type; @@ -67,14 +70,18 @@ typedef point1d point_type; typedef T value_type; + typedef fwd_piter1d piter_type; + typedef fwd_piter1d fwd_piter_type; + // please note that value_storage_type means data_type // since image1d is an image_with_data - typedef mlc_encoding_type(T) value_storage_type; + typedef T value_storage_type; +// typedef mlc_encoding_type(T) value_storage_type; // please note that value_container_type means // data_container_type (or value_storage_container_type) // FIXME: find a better name... - typedef array1d<value_storage_type> value_container_type; + typedef array1d<value_storage_type> storage_type; // functions @@ -83,11 +90,13 @@ { typedef image1d<U> ret; }; - }; + + + /*! \class image1d<T> ** ** Common class for 1D images. Pixels values are stored in memory. @@ -126,4 +135,4 @@ } // end of namespace oln -#endif // ! OLENA_CORE_IMAGE1D_HH +#endif // ! OLENA_CORE_1D_IMAGE1D_HH Index: oln/core/1d/fwd_piter1d.hh --- oln/core/1d/fwd_piter1d.hh (revision 50) +++ oln/core/1d/fwd_piter1d.hh (working copy) @@ -33,22 +33,29 @@ # include <oln/core/abstract/piter.hh> # include <oln/core/1d/point1d.hh> # include <oln/core/1d/size1d.hh> -# include <oln/core/props.hh> namespace oln { + + // fwd decl struct fwd_piter1d; - template <> struct category_type< fwd_piter1d > { typedef cat::piter ret; }; + // category + template <> + struct set_category<fwd_piter1d> { typedef category::piter ret; }; + + // props template <> - struct props < cat::piter, fwd_piter1d > : public default_props< cat::piter > + struct set_props < category::piter, fwd_piter1d > : public props_of<category::piter> { typedef point1d point_type; typedef size1d size_type; }; + + struct fwd_piter1d : public abstract::piter< fwd_piter1d > { Index: oln/core/1d/point1d.hh --- oln/core/1d/point1d.hh (revision 50) +++ oln/core/1d/point1d.hh (working copy) @@ -32,8 +32,7 @@ # include <oln/core/abstract/point.hh> # include <oln/core/coord.hh> -# include <oln/core/cats.hh> -# include <oln/core/props.hh> +# include <oln/core/properties.hh> // FIXME: doc @@ -41,18 +40,27 @@ namespace oln { + struct point1d; struct dpoint1d; + // category template <> - struct category_type< point1d > { typedef cat::point ret; }; + struct set_category< point1d > { typedef category::point ret; }; + // super_type template <> - struct props < cat::point, point1d > : default_props< cat::point > + struct set_super_type< point1d > { typedef abstract::point< point1d > ret; }; + + // props + template <> + struct set_props < category::point, point1d > : public props_of<category::point> { typedef dpoint1d dpoint_type; }; + + struct point1d : public abstract::point< point1d > { point1d() Index: oln/core/coord.hh --- oln/core/coord.hh (revision 50) +++ oln/core/coord.hh (working copy) @@ -44,6 +44,8 @@ public: typedef int value_type; + static const value_type min_value = INT_MIN; + static const value_type max_value = INT_MAX; coord_t() : value_(undef_()) @@ -140,13 +142,13 @@ static const coord_t& infty() { - static coord_t infty_ = INT_MAX; + static coord_t infty_ = max_value; return infty_; } static const coord_t& _infty() { - static coord_t _infty_ = INT_MIN + 1; + static coord_t _infty_ = min_value + 1; return _infty_; } @@ -158,7 +160,7 @@ static const value_type undef_() { - return INT_MIN; + return min_value; } }; Index: oln/core/2d/array2d.hh --- oln/core/2d/array2d.hh (revision 50) +++ oln/core/2d/array2d.hh (working copy) @@ -35,14 +35,20 @@ namespace oln { + // fwd decl + template <typename T> struct array2d; - template <typename T> struct array2d; + // category template <typename T> - struct category_type< array2d<T> > { typedef cat::data_storage ret; }; + struct set_category< array2d<T> > { typedef category::data_storage ret; }; - + // super_type + template <typename T> + struct set_super_type< array2d<T> > { typedef abstract::data_storage< array2d<T> > ret; }; + + // props template <typename T> - struct props < cat::data_storage, array2d<T> > // FIXME: add inheritance + struct set_props < category::data_storage, array2d<T> > : public props_of<category::data_storage> { typedef size2d size_type; typedef point2d point_type; @@ -50,6 +56,7 @@ }; + template <typename T> class array2d : public abstract::data_storage< array2d<T> > { Index: oln/core/2d/image2d.hh --- oln/core/2d/image2d.hh (revision 50) +++ oln/core/2d/image2d.hh (working copy) @@ -35,6 +35,7 @@ # include <oln/core/2d/array2d.hh> # include <oln/core/2d/fwd_piter2d.hh> + /*! \namespace oln ** \brief oln namespace. */ @@ -48,28 +49,28 @@ void do_read(abstract::image<I>&, const filename&); } + + // fwd decl template <typename T> class image2d; - // category decl + // category template <typename T> - struct category_type< image2d<T> > { typedef cat::image ret; }; + struct set_category< image2d<T> > { typedef category::image ret; }; + // super + template <typename T> + struct set_super_type < image2d<T> > + { + typedef abstract::image_with_data< image2d<T> > ret; + }; - /*! \class props< abstract::image, image2d<T> > - ** - ** Properties of common 2D images. Specialization of props<abstraction,type>. - ** Parameter T is the type of pixel values. - ** - ** \see image2d<T>, props<category,type> - */ template <typename T> - struct props < cat::image, image2d<T> > : public default_props < cat::image > + struct set_props < category::image, image2d<T> > : public props_of<category::image> { - // intrusive properties - typedef prop_of<abstract::readwrite_image> image_constness; - typedef prop_of<abstract::image2d> image_dimension; + // intrusive property: + typedef is_a<abstract::image2d> image_dimension_type; typedef mlc::no_type delegated_type; @@ -82,12 +83,13 @@ // please note that value_storage_type means data_type // since image2d is an image_with_data - typedef mlc_encoding_type(T) value_storage_type; + typedef T value_storage_type; +// typedef mlc_encoding_type(T) value_storage_type; // please note that value_container_type means // data_container_type (or value_storage_container_type) // FIXME: find a better name... - typedef array2d<value_storage_type> value_container_type; + typedef array2d<value_storage_type> storage_type; // functions @@ -96,11 +98,12 @@ { typedef image2d<U> ret; }; - }; + + /*! \class image2d<T> ** ** Common class for 2D images. Pixels values are stored in memory. Index: oln/core/2d/fwd_piter2d.hh --- oln/core/2d/fwd_piter2d.hh (revision 50) +++ oln/core/2d/fwd_piter2d.hh (working copy) @@ -33,22 +33,28 @@ # include <oln/core/abstract/piter.hh> # include <oln/core/2d/point2d.hh> # include <oln/core/2d/size2d.hh> -# include <oln/core/props.hh> namespace oln { + // fwd decl struct fwd_piter2d; - template <> struct category_type<fwd_piter2d> { typedef cat::piter ret; }; + // category + template <> + struct set_category<fwd_piter2d> { typedef category::piter ret; }; + + // props template <> - struct props < cat::piter, fwd_piter2d > : public default_props<cat::piter> + struct set_props < category::piter, fwd_piter2d > : public props_of<category::piter> { typedef point2d point_type; typedef size2d size_type; }; + + struct fwd_piter2d : public abstract::piter< fwd_piter2d > { Index: oln/core/2d/point2d.hh --- oln/core/2d/point2d.hh (revision 50) +++ oln/core/2d/point2d.hh (working copy) @@ -30,10 +30,9 @@ # include <iostream> +# include <oln/core/properties.hh> # include <oln/core/abstract/point.hh> # include <oln/core/coord.hh> -# include <oln/core/cats.hh> -# include <oln/core/props.hh> // FIXME: doc! @@ -43,15 +42,23 @@ struct point2d; struct dpoint2d; + // category template <> - struct category_type< point2d > { typedef cat::point ret; }; + struct set_category< point2d > { typedef category::point ret; }; + // super_type template <> - struct props < cat::point, point2d > : default_props< cat::point > + struct set_super_type< point2d > { typedef abstract::point< point2d > ret; }; + + // props + template <> + struct set_props < category::point, point2d > : public props_of<category::point> { typedef dpoint2d dpoint_type; }; + + struct point2d : public abstract::point< point2d > { point2d() Index: oln/core/3d/array3d.hh --- oln/core/3d/array3d.hh (revision 50) +++ oln/core/3d/array3d.hh (working copy) @@ -36,13 +36,20 @@ namespace oln { + // fwd decl template <typename T> struct array3d; + + // category template <typename T> - struct category_type< array3d<T> > { typedef cat::data_storage ret; }; + struct set_category< array3d<T> > { typedef category::data_storage ret; }; - + // super_type + template <typename T> + struct set_super_type< array3d<T> > { typedef abstract::data_storage< array3d<T> > ret; }; + + // props template <typename T> - struct props < cat::data_storage, array3d<T> > // FIXME: add inheritance + struct set_props < category::data_storage, array3d<T> > : public props_of<category::data_storage> { typedef size3d size_type; typedef point3d point_type; Index: oln/core/3d/image3d.hh --- oln/core/3d/image3d.hh (revision 50) +++ oln/core/3d/image3d.hh (working copy) @@ -25,8 +25,8 @@ // reasons why the executable file might be covered by the GNU General // Public License. -#ifndef OLENA_CORE_IMAGE3D_HH -# define OLENA_CORE_IMAGE3D_HH +#ifndef OLENA_CORE_3D_IMAGE3D_HH +# define OLENA_CORE_3D_IMAGE3D_HH # include <mlc/traits.hh> @@ -39,28 +39,27 @@ namespace oln { + // fwd decl template <typename T> class image3d; - // category decl - template <typename T> - struct category_type< image3d<T> > { typedef cat::image ret; }; + // category + template <typename T> + struct set_category< image3d<T> > { typedef category::image ret; }; + // super + template <typename T> + struct set_super_type < image3d<T> > + { + typedef abstract::image_with_data< image3d<T> > ret; + }; - /*! \class props< abstract::image, image3d<T> > - ** - ** Properties of common 3D images. Specialization of props<abstraction,type>. - ** Parameter T is the type of pixel values. - ** - ** \see image3d<T>, props<category,type> - */ template <typename T> - struct props < cat::image, image3d<T> > : public default_props < cat::image > + struct set_props < category::image, image3d<T> > : public props_of<category::image> { - // intrusive properties - typedef prop_of<abstract::readwrite_image> image_constness; - typedef prop_of<abstract::image3d> image_dimension; + // intrusive property: + typedef is_a<abstract::image3d> image_dimension_type; typedef mlc::no_type delegated_type; @@ -68,14 +67,18 @@ typedef point3d point_type; typedef T value_type; +// typedef fwd_piter3d piter_type; +// typedef fwd_piter3d fwd_piter_type; + // please note that value_storage_type means data_type // since image3d is an image_with_data - typedef mlc_encoding_type(T) value_storage_type; + typedef T value_storage_type; +// typedef mlc_encoding_type(T) value_storage_type; // please note that value_container_type means // data_container_type (or value_storage_container_type) // FIXME: find a better name... - typedef array3d<value_storage_type> value_container_type; + typedef array3d<value_storage_type> storage_type; // functions @@ -84,7 +87,6 @@ { typedef image3d<U> ret; }; - }; @@ -127,4 +129,4 @@ } // end of namespace oln -#endif // ! OLENA_CORE_IMAGE3D_HH +#endif // ! OLENA_CORE_3D_IMAGE3D_HH Index: oln/core/3d/point3d.hh --- oln/core/3d/point3d.hh (revision 50) +++ oln/core/3d/point3d.hh (working copy) @@ -35,14 +35,21 @@ namespace oln { - struct dpoint3d; // FIXME: not implemented!! + struct point3d; + struct dpoint3d; + // category template <> - struct category_type< point3d > { typedef cat::point ret; }; + struct set_category< point3d > { typedef category::point ret; }; + // super_type template <> - struct props < cat::point, point3d > : default_props< cat::point > + struct set_super_type< point3d > { typedef abstract::point< point3d > ret; }; + + // props + template <> + struct set_props < category::point, point3d > : public props_of<category::point> { typedef dpoint3d dpoint_type; }; Index: oln/core/cats.hh --- oln/core/cats.hh (revision 50) +++ oln/core/cats.hh (working copy) @@ -1,79 +0,0 @@ -// Copyright (C) 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_CATS_HH -# define OLENA_CORE_CATS_HH - -# include <mlc/types.hh> - - -/*! \macro FIXME:doc -*/ - -# define oln_category_type(T) typename oln::category_type<T>::ret - - - -/*! \namespace oln -** \brief oln namespace. -*/ -namespace oln { - - - /*! \class category_type<T> - ** - ** FIXME: doc - ** - */ - template <typename T> - struct category_type - { - typedef mlc::undefined_type ret; - }; - - - /*! \namespace oln::cat - ** \brief oln::cat namespace. - */ - namespace cat { - - struct image; - struct data_storage; - struct piter; - struct point; - struct size; - // FIXME:... - - } // end of namespace oln::cat - - -} // end of namespace oln - - - - -#endif // ! OLENA_CORE_CATS_HH Index: oln/core/properties.hh --- oln/core/properties.hh (revision 0) +++ oln/core/properties.hh (revision 0) @@ -0,0 +1,95 @@ +// Copyright (C) 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_PROPERTIES_HH +# define OLENA_CORE_PROPERTIES_HH + +# include <mlc/properties.hh> + + +/*! \namespace oln +** \brief oln namespace. +*/ +namespace oln +{ + + namespace category + { + struct data_storage; + struct image; + struct point; + struct size; + struct piter; + struct niter; + // FIXME: ... + } + + namespace target + { + struct data_type; + struct value_type; + struct value_storage_type; + struct storage_type; + struct point_type; + struct dpoint_type; + struct fwd_piter_type; + struct iter_type; + struct delegated_type; + struct size_type; + + struct image_constness_type; + struct image_dimension_type; + // FIXME: ... + } + + mlc_equip_namespace_for_properties(); + + + // FIXME: change name? + template <template <typename> class abstraction> + struct is_a // abstraction + { + template <typename E> + struct instantiated_with // E + { + typedef abstraction<E> ret; + }; + }; + + +} // end of namespace oln + + + +/// macro to retrieve a type (TARGET) from a class (oln::TYPE) + +# define oln_type_of(TYPE, TARGET) mlc_type_of(oln, TYPE, TARGET) +# define oln_type_of_(TYPE, TARGET) mlc_type_of_(oln, TYPE, TARGET) + + + +#endif // ! OLENA_CORE_PROPERTIES_HH

20 years, 1 month

proto-1.0 50: Add properties mechanism

by Thierry GERAUD

dsl... (connection refused!) Index: ChangeLog from Thierry Geraud <theo(a)lrde.epita.fr> * mlc/types.hh (default_type): New. * mlc/properties.hh: New.

20 years, 1 month

proto-1.0 49: Add test suite `main' for integre

by Simon Odou

Index: ChangeLog from Simon Odou <simon(a)lrde.epita.fr> * configure.ac: Add test suite `main' for Integre. configure.ac | 3 ++- 1 files changed, 2 insertions(+), 1 deletion(-) Index: configure.ac --- configure.ac (revision 48) +++ configure.ac (working copy) @@ -164,7 +164,7 @@ metalic/tests/check/defs], [dnl Configuration for the testsuite - MLC_TESTS_SUBDIRS="" + MLC_TESTS_SUBDIRS="main" AC_CACHE_CHECK([for selection of tests], [mlc_cv_tests_selection], @@ -177,6 +177,7 @@ # MLC_TESTS defined in oln-local.m4 + MLC_TESTS([main]) MLC_TESTS([sanity]) AC_SUBST([MLC_TESTS_SUBDIRS])

20 years, 1 month

proto-1.0 48: Add `is_a' with tests

by Simon Odou

Index: ChangeLog from Simon Odou <simon(a)lrde.epita.fr> * mlc/is_a.hh: New. Test inheritance between two classes. * tests/main/tests/is_a1: New. Add test for `is_a'. * tests/main: New. Add new test suite `main'. * tests/main/tests: New. * tests/main/Makefile.am: New. mlc/is_a.hh | 193 +++++++++++++++++++++++++++++++++++++++++++++++++ tests/main/Makefile.am | 3 tests/main/tests/is_a1 | 33 ++++++++ 3 files changed, 229 insertions(+) Index: tests/main/tests/is_a1 --- tests/main/tests/is_a1 (revision 0) +++ tests/main/tests/is_a1 (revision 0) @@ -0,0 +1,33 @@ +#include <mlc/bool.hh> +#include <mlc/is_a.hh> + +using namespace mlc; + +class A {}; +class B : public A {}; +class C : public B {}; + +template <class E> class T_A {}; +template <class T> class T_B : public T_A<T> {}; + +template <class T> +void foo() +{ + is_false<mlc_is_a(int, bool)::ret>::ensure(); + is_true<mlc_is_a(B, A)::ret>::ensure(); + is_true<mlc_is_a(C, A)::ret>::ensure(); + is_false<mlc_is_a(A, B)::ret>::ensure(); +} + +int main() +{ + is_false<mlc_is_a_(int, bool)::ret>::ensure(); + is_true<mlc_is_a_(B, A)::ret>::ensure(); + is_true<mlc_is_a_(C, A)::ret>::ensure(); + is_false<mlc_is_a_(A, B)::ret>::ensure(); + + is_true<mlc_is_a_(T_B<int>, T_A)::ret>::ensure(); + is_false<mlc_is_a_(T_A<int>, T_B)::ret>::ensure(); + + foo<int>(); +} Index: tests/main/Makefile.am --- tests/main/Makefile.am (revision 0) +++ tests/main/Makefile.am (revision 0) @@ -0,0 +1,3 @@ +## Process this file with Automake to produce Makefile.in -*- Makefile -*- + +include ../check/Makefile.runtests Index: mlc/is_a.hh --- mlc/is_a.hh (revision 0) +++ mlc/is_a.hh (revision 0) @@ -0,0 +1,193 @@ +// 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 METALIC_IS_A_HH +# define METALIC_IS_A_HH + +# include <mlc/any.hh> +# include <mlc/bool.hh> + +// private macro so do _not_ use it +# define is_a__check_result_ \ +sizeof(helper<T ,U >::check( (T *) helper<T,U >::makeT() )) \ +== sizeof(mlc::internal::yes_) + + +namespace mlc +{ + + namespace internal + { + + // + // wrap + // + // FIXME: This type is a workaround for g++-2.95 problem with implicit + // typename in <foo<T>::ret::dim>, + // write <wrap<typename foo<T>::ret>::dim instead. + // + + template <class T> struct wrap : public T {}; + + } // internal + + /*-----. + | is_a | + `-----*/ + + // FIXME: form is a namespace to avoid g++-3.2 bug with template function + // overloading in class. + + namespace form + { + enum { + class_ = 1, + template_l_class_g_class_ = 2, + template_l_class_class_g_class_ = 3 + // template_l_unsigned_class_g_class_ = 4 + // ... + }; + + template<unsigned id> + struct desc + { char dummy[id]; }; + + template<class T> + static desc< class_ > get(); + + template<template<class> class T> + static desc< template_l_class_g_class_ > get(); + + template<template<class,class> class T> + static desc< template_l_class_class_g_class_ > get(); + + // template<template<unsigned,class> class T> + // static desc < template_l_unsigned_class_g_class_ > get(); + + // ... + } + + namespace internal + { + + typedef char yes_; + struct no_ { char dummy[2]; }; + + + // dev note : below, is_a_<T,id> is a better factorization + // but g++ 2.95.4 has some trouble with it + + template<unsigned id> + struct is_a_; + + // _class_ + + + template<> + struct is_a_< form::class_ > + { + typedef is_a_< form::class_ > self; + + template<class T, class U> + struct helper + { + static yes_ check(U*); + static no_ check(...); + static T* makeT(); + }; + + template<class T, class U> + struct check + : public mlc::returns_bool_<( is_a__check_result_ )> + { + }; + }; + + // template_l_class_g_class_ + + template<> + struct is_a_< form::template_l_class_g_class_ > + { + typedef is_a_< form::template_l_class_g_class_ > self; + + template<class T, template<class> class U> + struct helper + { + template<class V> + static yes_ check(U<V>*); + static no_ check(...); + static T* makeT(); + }; + + template<class T, template<class> class U> + struct check + : public mlc::returns_bool_<( is_a__check_result_ )> + { + }; + }; + + // templatee_l_class_class_g_class_ + + template<> + struct is_a_< form::template_l_class_class_g_class_ > + { + typedef is_a_< form::template_l_class_class_g_class_ > self; + + template<class T, template<class,class> class U> + struct helper + { + template<class V, class W> + static yes_ check(U<V,W>*); + static no_ check(...); + static T* makeT(); + }; + + template<class T, template<class,class> class U> + struct check + : public mlc::returns_bool_<( is_a__check_result_ )> + {}; + }; + + } // end of internal + +} // end of mlc + +// private macros: do _not_ use them +# define is_a__2nd_is_meta(T,U) mlc::internal::is_a_< id_of_typeform(U) >::check<T, U > + +// client macros + +# define id_of_typeform(T) sizeof(mlc::form::get<T >()) + +template <class T> +struct id_ { typedef T ret; }; + +// FIXME: can we get rid of mlc::wrap ? +# define mlc_is_a(T, U) mlc::internal::wrap<typename mlc::internal::is_a_< id_of_typeform(U) >::check<T, U > > +# define mlc_is_a_(T, U) mlc::internal::wrap<mlc::internal::is_a_< id_of_typeform(U) >::check<T, U > > + +#endif // ndef METALIC_IS_A_HH

20 years, 1 month

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Olena-patches