OpenCMT/uLib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: Update CMake build system and streamline Core object serialization and property handling.

Browse Source
This commit is contained in:
AndreaRigoni
2026-02-21 16:16:28 +00:00
parent 7ded15d596
commit d56758d0b3
24 changed files with 830 additions and 1056 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
CMake/uLibTargetMacros.cmake
View File

@@ -82,7 +82,7 @@ ENDMACRO(uLib_add_target)
# TESTS and LIBRARIES must be defined
macro(uLib_add_tests name)
foreach(tn ${TESTS})
add_executable(${tn} EXCLUDE_FROM_ALL ${tn}.cpp)
add_executable(${tn} ${tn}.cpp)
add_test(NAME ${tn} COMMAND ${tn})
target_link_libraries(${tn} ${LIBRARIES})

3
CMakeLists.txt
View File

@@ -76,6 +76,7 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_CXX_WARNING_OPTION}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -UULIB_SERIALIZATION_ON -Wno-cpp")
# CTEST framework
include(CTest)
enable_testing()
@@ -85,7 +86,7 @@ set(Boost_USE_STATIC_LIBS OFF)
set(Boost_USE_MULTITHREADED ON)
set(Boost_USE_STATIC_RUNTIME OFF)
message(STATUS "CMAKE_PREFIX_PATH is ${CMAKE_PREFIX_PATH}")
find_package(Boost 1.45.0 COMPONENTS program_options REQUIRED)
find_package(Boost 1.45.0 COMPONENTS program_options serialization unit_test_framework REQUIRED)
include_directories(${Boost_INCLUDE_DIRS})
find_package(Eigen3 CONFIG REQUIRED)

541
src/Core/Archives.h
View File

@@ -23,14 +23,12 @@
//////////////////////////////////////////////////////////////////////////////*/
#ifndef U_CORE_ARCHIVES_H
#define U_CORE_ARCHIVES_H
#include <boost/archive/detail/basic_pointer_iserializer.hpp>
#include <boost/archive/detail/basic_pointer_oserializer.hpp>
#include <iostream>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
@@ -40,25 +38,20 @@
#include <boost/archive/detail/register_archive.hpp>
#include <boost/archive/polymorphic_iarchive.hpp>
#include <boost/archive/polymorphic_oarchive.hpp>
#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
#include <boost/archive/polymorphic_iarchive.hpp>
#include <boost/archive/polymorphic_oarchive.hpp>
#include <boost/archive/polymorphic_text_oarchive.hpp>
#include "StringReader.h"
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// FWD DECLARATIONS OF ARCHIVES //
namespace uLib {
namespace Archive {
@@ -68,40 +61,36 @@ class text_iarchive;
class text_oarchive;
class log_archive;
}
}
} // namespace Archive
} // namespace uLib
namespace boost {
namespace archive {
namespace detail {
template<class ArchiveImplementation> class polymorphic_oarchive_route;
template<class ArchiveImplementation> class polymorphic_iarchive_route;
}
}
}
template <class ArchiveImplementation> class polymorphic_oarchive_route;
template <class ArchiveImplementation> class polymorphic_iarchive_route;
} // namespace detail
} // namespace archive
} // namespace boost
namespace boost {
namespace serialization {
template <typename T> struct hrp;
template <typename T> struct hrp;
}
}
} // namespace boost
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// ARCHIVES REGISTRATION //
namespace uLib {
namespace Archive {
namespace detail {
struct adl_tag {};
}
}
}
} // namespace detail
} // namespace Archive
} // namespace uLib
namespace boost {
namespace archive {
@@ -110,34 +99,36 @@ namespace detail {
// in overload resolution with the functions declared by
// BOOST_SERIALIZATION_REGISTER_ARCHIVE, below.
template <class Serializable>
void instantiate_ptr_serialization(Serializable*, int, uLib::Archive::detail::adl_tag ) {}
}
}
}
void instantiate_ptr_serialization(Serializable *, int,
uLib::Archive::detail::adl_tag) {}
} // namespace detail
} // namespace archive
} // namespace boost
// The function declaration generated by this macro never actually
// gets called, but its return type gets instantiated, and that's
// enough to cause registration of serialization functions between
// Archive and any exported Serializable type. See also:
// boost/serialization/export.hpp
# define ULIB_SERIALIZATION_REGISTER_ARCHIVE(_Archive) \
namespace boost { namespace archive { namespace detail { \
#define ULIB_SERIALIZATION_REGISTER_ARCHIVE(_Archive) \
namespace boost { \
namespace archive { \
namespace detail { \
\
template <class Serializable> \
BOOST_DEDUCED_TYPENAME _ptr_serialization_support<_Archive, Serializable>::type \
instantiate_ptr_serialization( Serializable*, _Archive*, uLib::Archive::detail::adl_tag ); }}}
template <class Serializable> \
BOOST_DEDUCED_TYPENAME \
_ptr_serialization_support<_Archive, Serializable>::type \
instantiate_ptr_serialization(Serializable *, _Archive *, \
uLib::Archive::detail::adl_tag); \
} \
} \
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// ARCHIVES IO INTERFACES //
namespace boost {
namespace archive {
namespace detail {
@@ -145,11 +136,10 @@ namespace detail {
/**
* Custom implementation of boost interface_iarchive to add new operators
*/
template<class Archive>
class uLib_interface_iarchive
{
template <class Archive> class uLib_interface_iarchive {
protected:
uLib_interface_iarchive(){};
uLib_interface_iarchive() {};
public:
/////////////////////////////////////////////////////////
// archive public interface
@@ -157,54 +147,40 @@ public:
typedef mpl::bool_<false> is_saving;
// return a pointer to the most derived class
Archive * This(){
return static_cast<Archive *>(this);
}
Archive *This() { return static_cast<Archive *>(this); }
template<class T>
const basic_pointer_iserializer *
register_type(T * = NULL){
const basic_pointer_iserializer & bpis =
boost::serialization::singleton<
pointer_iserializer<Archive, T>
>::get_const_instance();
template <class T>
const basic_pointer_iserializer *register_type(T * = NULL) {
const basic_pointer_iserializer &bpis = boost::serialization::singleton<
pointer_iserializer<Archive, T>>::get_const_instance();
this->This()->register_basic_serializer(bpis.get_basic_serializer());
return & bpis;
return &bpis;
}
template<class T>
Archive & operator>>(T & t){
this->This()->load_override(t, 0);
return * this->This();
template <class T> Archive &operator>>(T &t) {
this->This()->load_override(t);
return *this->This();
}
// the & operator
template<class T>
Archive & operator&(T & t){
return *(this->This()) >> t;
}
template <class T> Archive &operator&(T &t) { return *(this->This()) >> t; }
// the == operator
template <class T>
Archive & operator == (T & t) {
return this->operator &(t);
}
template <class T> Archive &operator==(T &t) { return this->operator&(t); }
// the != operator for human readable access
template <class T>
Archive & operator != (T & t) {
template <class T> Archive &operator!=(T &t) {
std::cerr << std::flush << "cauch string: " << t << "\n"; // REMOVE THIS !
return * this->This();
return *this->This();
}
};
/**
* Custom implementation of boost interface_oarchive to add new operators
*/
template <class Archive>
class uLib_interface_oarchive {
template <class Archive> class uLib_interface_oarchive {
protected:
uLib_interface_oarchive(){};
uLib_interface_oarchive() {};
public:
/////////////////////////////////////////////////////////
// archive public interface
@@ -212,109 +188,82 @@ public:
typedef mpl::bool_<true> is_saving;
// return a pointer to the most derived class
Archive * This(){
return static_cast<Archive *>(this);
}
Archive *This() { return static_cast<Archive *>(this); }
template<class T>
const basic_pointer_oserializer *
register_type(const T * = NULL){
const basic_pointer_oserializer & bpos =
boost::serialization::singleton<
pointer_oserializer<Archive, T>
>::get_const_instance();
template <class T>
const basic_pointer_oserializer *register_type(const T * = NULL) {
const basic_pointer_oserializer &bpos = boost::serialization::singleton<
pointer_oserializer<Archive, T>>::get_const_instance();
this->This()->register_basic_serializer(bpos.get_basic_serializer());
return & bpos;
return &bpos;
}
template<class T>
Archive & operator<<(T & t){
template <class T> Archive &operator<<(T &t) {
// to get access you must redefine save_override by typing
// "using save_override" in archive impl
this->This()->save_override(t, 0);
return * this->This();
this->This()->save_override(t);
return *this->This();
}
// the & operator
template<class T>
Archive & operator&(T & t){
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
return * this->This() << const_cast<const T &>(t);
#else
return * this->This() << t;
#endif
template <class T> Archive &operator&(T &t) {
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
return *this->This() << const_cast<const T &>(t);
#else
return *this->This() << t;
#endif
}
// the == operator
template <class T>
Archive & operator == (T & t) {
return this->operator &(t);
}
template <class T> Archive &operator==(T &t) { return this->operator&(t); }
// the != operator for human readable access
template <class T>
Archive & operator != (T & t) {
template <class T> Archive &operator!=(T &t) {
std::cerr << std::flush << "cauch string: " << t << "\n"; // REMOVE THIS !
return * this->This();
return *this->This();
}
};
// DECLARE INTERFACE SPECIALIZATIONS ///////////////////////////////////////////
// With this declarations all uLib archive Implementation will use their own
// extended interface //
template <>
class interface_iarchive <uLib::Archive::xml_iarchive> : public
uLib_interface_iarchive <uLib::Archive::xml_iarchive> {};
class interface_iarchive<uLib::Archive::xml_iarchive>
: public uLib_interface_iarchive<uLib::Archive::xml_iarchive> {};
template <>
class interface_oarchive <uLib::Archive::xml_oarchive> : public
uLib_interface_oarchive <uLib::Archive::xml_oarchive> {};
class interface_oarchive<uLib::Archive::xml_oarchive>
: public uLib_interface_oarchive<uLib::Archive::xml_oarchive> {};
template <>
class interface_iarchive <uLib::Archive::text_iarchive> : public
uLib_interface_iarchive <uLib::Archive::text_iarchive> {};
class interface_iarchive<uLib::Archive::text_iarchive>
: public uLib_interface_iarchive<uLib::Archive::text_iarchive> {};
template <>
class interface_oarchive <uLib::Archive::text_oarchive> : public
uLib_interface_oarchive <uLib::Archive::text_oarchive> {};
class interface_oarchive<uLib::Archive::text_oarchive>
: public uLib_interface_oarchive<uLib::Archive::text_oarchive> {};
template <>
class interface_oarchive <uLib::Archive::log_archive> : public
uLib_interface_oarchive <uLib::Archive::log_archive> {};
class interface_oarchive<uLib::Archive::log_archive>
: public uLib_interface_oarchive<uLib::Archive::log_archive> {};
//// Veritical repetition macro // FINIRE !!!!!!!!!!!!!!!!!!!!!!!!!
//#define _DECL_INTERFACE_ARCHIVE_V(vz,vn,vdata) \
// #define _DECL_INTERFACE_ARCHIVE_V(vz,vn,vdata) \
// template <class TypeSeq> \
// struct inherit_nofold<TypeSeq,BOOST_PP_INC(vn)> : \
// BOOST_PP_REPEAT(BOOST_PP_INC(vn),_INERIT_NOFOLD_H,~) \
// {};
//// Multiple size declaration //
//BOOST_PP_REPEAT(ULIB_CFG_MPL_INERIT_NOFOLD_MAXSIZE,_INERIT_NOFOLD_V,~)
//#undef _INERIT_NOFOLD_H
//#undef _INERIT_NOFOLD_V
} // detail
} // archive
} // boost
// BOOST_PP_REPEAT(ULIB_CFG_MPL_INERIT_NOFOLD_MAXSIZE,_INERIT_NOFOLD_V,~)
// #undef _INERIT_NOFOLD_H
// #undef _INERIT_NOFOLD_V
} // namespace detail
} // namespace archive
} // namespace boost
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
@@ -330,14 +279,14 @@ class interface_oarchive <uLib::Archive::log_archive> : public
namespace boost {
namespace archive {
//template<class Archive>
//inline void load_const_override(Archive & ar, const char *t ){
// typedef typename mpl::identity<detail::load_non_pointer_type<Archive> >::type typex;
// typex::invoke(ar, t);
//}
// template<class Archive>
// inline void load_const_override(Archive & ar, const char *t ){
// typedef typename mpl::identity<detail::load_non_pointer_type<Archive>
// >::type typex; typex::invoke(ar, t);
// }
//template<class Archive, class T>
//inline void load(Archive & ar, T &t){
// template<class Archive, class T>
// inline void load(Archive & ar, T &t){
// // if this assertion trips. It means we're trying to load a
// // const object with a compiler that doesn't have correct
// // funtion template ordering. On other compilers, this is
@@ -358,47 +307,38 @@ namespace archive {
// >
// >::type typex;
// typex::invoke(ar, t);
//}
}
}
// }
} // namespace archive
} // namespace boost
namespace uLib {
namespace Archive {
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// POLYMORPHIC //
//class polymorphic_iarchive :
// class polymorphic_iarchive :
// public boost::archive::polymorphic_iarchive {
//public:
// public:
// void load_override(const char *t, BOOST_PFTO int)
// {
// boost::archive::load_const_override(* this->This(), const_cast<char*>(t));
// boost::archive::load_const_override(* this->This(),
// const_cast<char*>(t));
// }
//};
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// XML //
class xml_iarchive :
public boost::archive::xml_iarchive_impl<xml_iarchive>
{
class xml_iarchive : public boost::archive::xml_iarchive_impl<xml_iarchive> {
typedef xml_iarchive Archive;
typedef boost::archive::xml_iarchive_impl<Archive> base;
@@ -406,75 +346,63 @@ class xml_iarchive :
friend class boost::archive::detail::interface_iarchive<Archive>;
friend class boost::archive::basic_xml_iarchive<Archive>;
friend class boost::archive::load_access;
public:
xml_iarchive(std::istream & is, unsigned int flags = 0) :
xml_iarchive_impl<xml_iarchive>(is, flags)
{}
xml_iarchive(std::istream &is, unsigned int flags = 0)
: xml_iarchive_impl<xml_iarchive>(is, flags) {}
using basic_xml_iarchive::load_override;
// Anything not an attribute should be a name value pair as nvp or hrp
typedef boost::archive::detail::common_iarchive<Archive> detail_common_iarchive;
template<class T>
typedef boost::archive::detail::common_iarchive<Archive>
detail_common_iarchive;
template <class T>
void load_override(
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
const
#endif
boost::serialization::hrp< T > & t,
int v
){
#endif
boost::serialization::hrp<T> &t) {
this->This()->load_start(t.name());
this->detail_common_iarchive::load_override(t.value(), 0);
// t.stov();
this->detail_common_iarchive::load_override(t.value());
// t.stov();
this->This()->load_end(t.name());
}
// class_name_type can't be handled here as it depends upon the
// char type used by the stream. So require the derived implementation.
// derived in this case is xml_iarchive_impl or base ..
using base::load_override;
void load_override(const char *str, int v) {
void load_override(const char *str) {
// StringReader sr(basic_text_iprimitive::is);
// sr >> str;
}
~xml_iarchive(){};
~xml_iarchive() {};
};
//typedef boost::archive::detail::polymorphic_iarchive_route<
//boost::archive::xml_iarchive_impl<xml_iarchive>
// typedef boost::archive::detail::polymorphic_iarchive_route<
// boost::archive::xml_iarchive_impl<xml_iarchive>
//> polymorphic_xml_iarchive;
template <class ArchiveImpl>
struct polymorphic_iarchive_route :
boost::archive::detail::polymorphic_iarchive_route<ArchiveImpl>
{
virtual void load(const char * t){
ArchiveImpl::load(t);
}
struct polymorphic_iarchive_route
: boost::archive::detail::polymorphic_iarchive_route<ArchiveImpl> {
virtual void load(const char *t) { ArchiveImpl::load(t); }
};
class polymorphic_xml_iarchive :
public polymorphic_iarchive_route< boost::archive::xml_iarchive_impl<xml_iarchive> >
{
class polymorphic_xml_iarchive
: public polymorphic_iarchive_route<
boost::archive::xml_iarchive_impl<xml_iarchive>> {
// give serialization implementation access to this class
// friend class boost::archive::detail::interface_iarchive<Archive>;
// friend class boost::archive::basic_xml_iarchive<Archive>;
// friend class boost::archive::load_access;
// friend class boost::archive::detail::interface_iarchive<Archive>;
// friend class boost::archive::basic_xml_iarchive<Archive>;
// friend class boost::archive::load_access;
public:
virtual void load_override(const char *str, int v) {
;
}
virtual void load_override(const char *str) { ; }
};
class xml_oarchive :
public boost::archive::xml_oarchive_impl<xml_oarchive>
{
class xml_oarchive : public boost::archive::xml_oarchive_impl<xml_oarchive> {
typedef xml_oarchive Archive;
typedef boost::archive::xml_oarchive_impl<Archive> base;
@@ -482,10 +410,10 @@ class xml_oarchive :
friend class boost::archive::detail::interface_oarchive<Archive>;
friend class boost::archive::basic_xml_oarchive<Archive>;
friend class boost::archive::save_access;
public:
xml_oarchive(std::ostream & os, unsigned int flags = 0) :
boost::archive::xml_oarchive_impl<xml_oarchive>(os, flags)
{}
xml_oarchive(std::ostream &os, unsigned int flags = 0)
: boost::archive::xml_oarchive_impl<xml_oarchive>(os, flags) {}
// example of implementing save_override for const char* //
// void save_override(const char *t, int) {
@@ -495,31 +423,30 @@ public:
using basic_xml_oarchive::save_override;
// special treatment for name-value pairs.
typedef boost::archive::detail::common_oarchive<Archive> detail_common_oarchive;
template<class T>
typedef boost::archive::detail::common_oarchive<Archive>
detail_common_oarchive;
template <class T>
void save_override(
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
const
#endif
::boost::serialization::hrp< T > & t,
int v
){
#endif
::boost::serialization::hrp<T> &t) {
this->This()->save_start(t.name());
// t.vtos();
// this->detail_common_oarchive::save_override(t.const_value(), 0);
// t.vtos();
// this->detail_common_oarchive::save_override(t.const_value());
this->This()->save_end(t.name());
}
void save_override(const char *str, int v) {
void save_override(const char *str) {
// Do not save any human decoration string //
// basic_text_oprimitive::save(str);
}
~xml_oarchive(){}
~xml_oarchive() {}
};
//typedef boost::archive::detail::polymorphic_oarchive_route<
//boost::archive::xml_oarchive_impl<xml_oarchive>
// typedef boost::archive::detail::polymorphic_oarchive_route<
// boost::archive::xml_oarchive_impl<xml_oarchive>
//> polymorphic_xml_oarchive;
////////////////////////////////////////////////////////////////////////////////
@@ -527,9 +454,7 @@ public:
////////////////////////////////////////////////////////////////////////////////
// TEXT //
class text_iarchive :
public boost::archive::text_iarchive_impl<text_iarchive>
{
class text_iarchive : public boost::archive::text_iarchive_impl<text_iarchive> {
typedef text_iarchive Archive;
typedef boost::archive::text_iarchive_impl<Archive> base;
@@ -537,21 +462,21 @@ class text_iarchive :
friend class boost::archive::detail::interface_iarchive<Archive>;
friend class boost::archive::basic_text_iarchive<Archive>;
friend class boost::archive::load_access;
public:
text_iarchive(std::istream & is, unsigned int flags = 0) :
text_iarchive_impl<Archive>(is, flags)
{}
text_iarchive(std::istream &is, unsigned int flags = 0)
: text_iarchive_impl<Archive>(is, flags) {}
using basic_text_iarchive::load_override;
void load_override(boost::archive::object_id_type & t, int) {}
void load_override(boost::archive::object_id_type &t) {}
// class_name_type can't be handled here as it depends upon the
// char type used by the stream. So require the derived implementation.
// derived in this case is xml_iarchive_impl or base ..
using base::load_override;
void load_override(const char *str, int v) {
void load_override(const char *str) {
StringReader sr(basic_text_iprimitive::is);
sr >> str;
}
@@ -561,15 +486,11 @@ public:
typedef text_iarchive naked_text_iarchive;
//typedef boost::archive::detail::polymorphic_iarchive_route<
//naked_text_iarchive
// typedef boost::archive::detail::polymorphic_iarchive_route<
// naked_text_iarchive
//> polymorphic_text_iarchive;
class text_oarchive :
public boost::archive::text_oarchive_impl<text_oarchive>
{
class text_oarchive : public boost::archive::text_oarchive_impl<text_oarchive> {
typedef text_oarchive Archive;
typedef boost::archive::text_oarchive_impl<Archive> base;
@@ -577,33 +498,28 @@ class text_oarchive :
friend class boost::archive::detail::interface_oarchive<Archive>;
friend class boost::archive::basic_text_oarchive<Archive>;
friend class boost::archive::save_access;
public:
text_oarchive(std::ostream & os, unsigned int flags = 0) :
boost::archive::text_oarchive_impl<Archive>(os, flags)
{}
text_oarchive(std::ostream &os, unsigned int flags = 0)
: boost::archive::text_oarchive_impl<Archive>(os, flags) {}
using basic_text_oarchive::save_override;
void save_override(const char *str, int v) {
basic_text_oprimitive::save(str);
}
void save_override(const char *str) { basic_text_oprimitive::save(str); }
~text_oarchive(){}
~text_oarchive() {}
};
//typedef boost::archive::detail::polymorphic_oarchive_route<
//boost::archive::text_oarchive_impl<text_oarchive>
// typedef boost::archive::detail::polymorphic_oarchive_route<
// boost::archive::text_oarchive_impl<text_oarchive>
//> polymorphic_text_oarchive;
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// SIMPLE HUMAN READABLE TEXT //
class hrt_iarchive :
public boost::archive::text_iarchive_impl<hrt_iarchive>
{
class hrt_iarchive : public boost::archive::text_iarchive_impl<hrt_iarchive> {
typedef hrt_iarchive Archive;
typedef boost::archive::text_iarchive_impl<Archive> base;
@@ -611,29 +527,29 @@ class hrt_iarchive :
friend class boost::archive::detail::interface_iarchive<Archive>;
friend class boost::archive::basic_text_iarchive<Archive>;
friend class boost::archive::load_access;
public:
hrt_iarchive(std::istream & is, unsigned int flags = 0) :
base(is, flags | boost::archive::no_header )
{}
hrt_iarchive(std::istream &is, unsigned int flags = 0)
: base(is, flags | boost::archive::no_header) {}
using basic_text_iarchive::load_override;
// hide all archive props //
void load_override( boost::archive::object_id_type & t, int) {}
void load_override( boost::archive::object_reference_type & t, int) {}
void load_override( boost::archive::version_type & t, int) {}
void load_override( boost::archive::class_id_type & t, int) {}
void load_override( boost::archive::class_id_optional_type & t, int) {}
void load_override( boost::archive::class_id_reference_type & t, int){}
void load_override( boost::archive::class_name_type & t, int) {}
void load_override( boost::archive::tracking_type & t, int) {}
void load_override(boost::archive::object_id_type &t) {}
void load_override(boost::archive::object_reference_type &t) {}
void load_override(boost::archive::version_type &t) {}
void load_override(boost::archive::class_id_type &t) {}
void load_override(boost::archive::class_id_optional_type &t) {}
void load_override(boost::archive::class_id_reference_type &t) {}
void load_override(boost::archive::class_name_type &t) {}
void load_override(boost::archive::tracking_type &t) {}
// class_name_type can't be handled here as it depends upon the
// char type used by the stream. So require the derived implementation.
// derived in this case is xml_iarchive_impl or base ..
using base::load_override;
void load_override(const char *str, int v) {
void load_override(const char *str) {
StringReader sr(basic_text_iprimitive::is);
sr >> str;
}
@@ -641,10 +557,7 @@ public:
~hrt_iarchive() {};
};
class hrt_oarchive :
public boost::archive::text_oarchive_impl<hrt_oarchive>
{
class hrt_oarchive : public boost::archive::text_oarchive_impl<hrt_oarchive> {
typedef hrt_oarchive Archive;
typedef boost::archive::text_oarchive_impl<Archive> base;
@@ -652,32 +565,26 @@ class hrt_oarchive :
friend class boost::archive::detail::interface_oarchive<Archive>;
friend class boost::archive::basic_text_oarchive<Archive>;
friend class boost::archive::save_access;
public:
hrt_oarchive(std::ostream & os, unsigned int flags = 0) :
base(os, flags | boost::archive::no_header )
{}
public:
hrt_oarchive(std::ostream &os, unsigned int flags = 0)
: base(os, flags | boost::archive::no_header) {}
using basic_text_oarchive::save_override;
void save_override(const boost::archive::object_id_type & t, int) {}
void save_override(const boost::archive::object_reference_type & t, int) {}
void save_override(const boost::archive::version_type & t, int) {}
void save_override(const boost::archive::class_id_type & t, int) {}
void save_override(const boost::archive::class_id_optional_type & t, int) {}
void save_override(const boost::archive::class_id_reference_type & t, int){}
void save_override(const boost::archive::class_name_type & t, int) {}
void save_override(const boost::archive::tracking_type & t, int) {}
void save_override(const char *str, int v) {
basic_text_oprimitive::save(str);
}
~hrt_oarchive(){}
};
void save_override(const boost::archive::object_id_type &t) {}
void save_override(const boost::archive::object_reference_type &t) {}
void save_override(const boost::archive::version_type &t) {}
void save_override(const boost::archive::class_id_type &t) {}
void save_override(const boost::archive::class_id_optional_type &t) {}
void save_override(const boost::archive::class_id_reference_type &t) {}
void save_override(const boost::archive::class_name_type &t) {}
void save_override(const boost::archive::tracking_type &t) {}
void save_override(const char *str) { basic_text_oprimitive::save(str); }
~hrt_oarchive() {}
};
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
@@ -690,8 +597,7 @@ class hrt_oarchive :
// any serializable class. Intended to be useful as a debugging aid.
class log_archive :
/* protected ? */
public boost::archive::xml_oarchive_impl<log_archive>
{
public boost::archive::xml_oarchive_impl<log_archive> {
typedef boost::archive::xml_oarchive_impl<log_archive> base;
typedef log_archive Archive;
// give serialization implementation access to this clas
@@ -700,66 +606,52 @@ class log_archive :
friend class boost::archive::save_access;
public:
void save_override(const char *str, int v) {
void save_override(const char *str) {
// Do not save any human decoration string //
// basic_text_oprimitive::save(str);
}
template<class T>
void save_override(T & t, BOOST_PFTO int){
base::save_override(boost::serialization::make_nvp(NULL, t), 0);
template <class T> void save_override(T &t) {
base::save_override(boost::serialization::make_nvp(NULL, t));
}
// activate this if you want to trap non nvp objects //
// template<class T>
// void save_override(T & t, BOOST_PFTO int)
// void save_override(T & t)
// {
// BOOST_MPL_ASSERT((boost::serialization::is_wrapper< T >));
// // this->detail_common_oarchive::save_override(t, 0);
// // this->detail_common_oarchive::save_override(t);
// }
template<class T>
void save_override(const boost::serialization::nvp<T> & t, int){
base::save_override(t, 0);
template <class T> void save_override(const boost::serialization::nvp<T> &t) {
base::save_override(t);
}
// specific overrides for attributes - not name value pairs so we
// want to trap them before the above "fall through"
// since we don't want to see these in the output - make them no-ops.
void save_override(const boost::archive::object_id_type & t, int) {}
void save_override(const boost::archive::object_reference_type & t, int) {}
void save_override(const boost::archive::version_type & t, int) {}
void save_override(const boost::archive::class_id_type & t, int) {}
void save_override(const boost::archive::class_id_optional_type & t, int) {}
void save_override(const boost::archive::class_id_reference_type & t, int){}
void save_override(const boost::archive::class_name_type & t, int) {}
void save_override(const boost::archive::tracking_type & t, int) {}
void save_override(const boost::archive::object_id_type &t) {}
void save_override(const boost::archive::object_reference_type &t) {}
void save_override(const boost::archive::version_type &t) {}
void save_override(const boost::archive::class_id_type &t) {}
void save_override(const boost::archive::class_id_optional_type &t) {}
void save_override(const boost::archive::class_id_reference_type &t) {}
void save_override(const boost::archive::class_name_type &t) {}
void save_override(const boost::archive::tracking_type &t) {}
public:
log_archive(std::ostream & os, unsigned int flags = 0) :
boost::archive::xml_oarchive_impl<log_archive>(
os,
flags | boost::archive::no_header
)
{}
log_archive(std::ostream &os, unsigned int flags = 0)
: boost::archive::xml_oarchive_impl<log_archive>(
os, flags | boost::archive::no_header) {}
};
//typedef boost::archive::detail::polymorphic_oarchive_route<
//boost::archive::xml_oarchive_impl<log_archive>
// typedef boost::archive::detail::polymorphic_oarchive_route<
// boost::archive::xml_oarchive_impl<log_archive>
//> polymorphic_log_archive;
} // namespace Archive
} // Archive
} // uLib
} // namespace uLib
ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::xml_iarchive)
ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::xml_oarchive)
@@ -769,13 +661,10 @@ ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::hrt_iarchive)
ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::hrt_oarchive)
ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::log_archive)
//ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_xml_iarchive)
//ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_xml_oarchive)
//ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_text_iarchive)
//ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_text_oarchive)
//ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_log_archive)
// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_xml_iarchive)
// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_xml_oarchive)
// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_text_iarchive)
// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_text_oarchive)
// ULIB_SERIALIZATION_REGISTER_ARCHIVE(uLib::Archive::polymorphic_log_archive)
#endif // U_CORE_ARCHIVES_H

13
src/Core/CMakeLists.txt
View File

@@ -1,10 +1,9 @@
set(HEADERS Options.h
StaticInterface.h)
set(HEADERS Archives.h Array.h Collection.h Debug.h Export.h Function.h Macros.h Mpl.h Object.h Options.h Serializable.h Signal.h Singleton.h SmartPointer.h StaticInterface.h StringReader.h Types.h Uuid.h Vector.h)
set(SOURCES Options.cpp)
set(SOURCES Archives.cpp Debug.cpp Object.cpp Options.cpp Serializable.cpp Signal.cpp Uuid.cpp)
set(LIBRARIES ${Boost_PROGRAM_OPTIONS_LIBRARY})
set(LIBRARIES Boost::program_options)
set(libname ${PACKAGE_LIBPREFIX}Core)
set(ULIB_SHARED_LIBRARIES ${ULIB_SHARED_LIBRARIES} ${libname} PARENT_SCOPE)
@@ -23,5 +22,7 @@ install(TARGETS ${libname}
install(FILES ${HEADERS} DESTINATION ${INSTALL_INC_DIR}/Core)
if(BUILD_TESTING)
include(uLibTargetMacros)
add_subdirectory(testing)
endif()

64
src/Core/Export.h
View File

@@ -23,95 +23,85 @@
//////////////////////////////////////////////////////////////////////////////*/
#ifndef U_CORE_EXPORT_H
#define U_CORE_EXPORT_H
#include <utility>
#include <cstddef> // NULL
#include <iostream>
#include <utility>
#include <boost/config.hpp>
#include <boost/static_assert.hpp>
#include <boost/preprocessor/stringize.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_polymorphic.hpp>
#include <boost/mpl/assert.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/not.hpp>
#include <boost/mpl/assert.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/not.hpp>
#include <boost/serialization/extended_type_info.hpp> // for guid_defined only
#include <boost/serialization/static_warning.hpp>
#include <boost/serialization/assume_abstract.hpp>
#include <boost/serialization/extended_type_info.hpp> // for guid_defined only
#include <boost/serialization/force_include.hpp>
#include <boost/serialization/singleton.hpp>
#include <boost/serialization/static_warning.hpp>
#include <boost/archive/detail/register_archive.hpp>
#include "Core/Archives.h"
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
namespace uLib {
namespace Archive {
namespace detail {
namespace extra_detail {
template<class T>
struct guid_initializer
{
void export_guid(mpl::false_) const {
template <class T> struct guid_initializer {
void export_guid(boost::mpl::false_) const {
// generates the statically-initialized objects whose constructors
// register the information allowing serialization of T objects
// through pointers to their base classes.
boost::archive::detail::
instantiate_ptr_serialization((T*)0, 0,
uLib::Archive::detail::adl_tag());
boost::archive::detail::instantiate_ptr_serialization(
(T *)0, 0, uLib::Archive::detail::adl_tag());
}
void export_guid(mpl::true_) const {
}
guid_initializer const & export_guid() const {
BOOST_STATIC_WARNING(boost::is_polymorphic< T >::value);
void export_guid(boost::mpl::true_) const {}
guid_initializer const &export_guid() const {
BOOST_STATIC_WARNING(boost::is_polymorphic<T>::value);
// note: exporting an abstract base class will have no effect
// and cannot be used to instantitiate serialization code
// (one might be using this in a DLL to instantiate code)
//BOOST_STATIC_WARNING(! boost::serialization::is_abstract< T >::value);
export_guid(boost::serialization::is_abstract< T >());
// BOOST_STATIC_WARNING(! boost::serialization::is_abstract< T >::value);
export_guid(boost::serialization::is_abstract<T>());
return *this;
}
};
template<typename T>
struct init_guid;
template <typename T> struct init_guid;
} // anonymous
} // namespace extra_detail
} // namespace detail
} // namespace Archive
} // namespace uLib
#define ULIB_CLASS_EXPORT_IMPLEMENT(T) \
namespace uLib { \
namespace Archive { \
namespace detail { \
namespace extra_detail { \
template<> \
struct init_guid< T > { \
static guid_initializer< T > const & g; \
template <> struct init_guid<T> { \
static guid_initializer<T> const &g; \
}; \
guid_initializer< T > const & init_guid< T >::g = \
guid_initializer<T> const &init_guid<T>::g = \
::boost::serialization::singleton< \
guid_initializer< T > \
>::get_mutable_instance().export_guid(); \
}}}} \
/**/
guid_initializer<T>>::get_mutable_instance() \
.export_guid(); \
} \
} \
} \
} \
/**/
#endif // EXPORT_H

2
src/Core/Object.cpp
View File

@@ -110,11 +110,13 @@ bool Object::addSignalImpl(SignalBase *sig, GenericMFPtr fptr,
const char *name) {
ObjectPrivate::Signal s = {fptr, std::string(name), sig};
d->sigv.push_back(s);
return true;
}
bool Object::addSlotImpl(GenericMFPtr fptr, const char *name) {
ObjectPrivate::Slot s = {fptr, std::string(name)};
d->slov.push_back(s);
return true;
}
SignalBase *Object::findSignalImpl(const GenericMFPtr &fptr) const {

5
src/Core/Object.h
View File

@@ -107,6 +107,7 @@ public:
// if(sig && slo)
// return Object::connect(sig,slo->operator ()(),receiver);
// else return false;
return false;
}
// Qt5 style connector //
@@ -119,11 +120,13 @@ public:
typename FunctionPointer<Func2>::SignalSignature>
SigT;
ConnectSignal(sigb, slof, receiver);
return true;
}
template <typename FuncT>
static inline bool connect(SignalBase *sigb, FuncT slof, Object *receiver) {
ConnectSignal(sigb, slof, receiver);
return true;
}
template <typename FuncT>
@@ -139,7 +142,7 @@ public:
}
template <typename FuncT> inline bool addSlot(FuncT fun, const char *name) {
this->addSlotImpl(GenericMFPtr(fun), name);
return this->addSlotImpl(GenericMFPtr(fun), name);
}
template <typename FuncT>

124
src/Core/Signal.h
View File

@@ -23,21 +23,19 @@
//////////////////////////////////////////////////////////////////////////////*/
#ifndef U_CORE_SIGNAL_H
#define U_CORE_SIGNAL_H
#include <boost/typeof/typeof.hpp>
#include <boost/signals2/signal.hpp>
#include <boost/signals2/slot.hpp>
#include <boost/signals2/signal_type.hpp>
#include <boost/signals2/slot.hpp>
#include "Function.h"
#include <boost/bind/bind.hpp>
using namespace boost::placeholders;
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
@@ -51,8 +49,8 @@
#define SLOT(a) BOOST_STRINGIZE(a)
#define SIGNAL(a) BOOST_STRINGIZE(a)
#define _ULIB_DETAIL_SIGNAL_EMIT(_name,...) \
static BOOST_AUTO(sig,this->findOrAddSignal(&_name)); \
#define _ULIB_DETAIL_SIGNAL_EMIT(_name, ...) \
static BOOST_AUTO(sig, this->findOrAddSignal(&_name)); \
sig->operator()(__VA_ARGS__);
/**
@@ -66,103 +64,105 @@
* // cast automatico //
* static BOOST_AUTO(sig,this->findOrAddSignal(&Ob1::V0));
* sig->operator()();
*/
#define ULIB_SIGNAL_EMIT(_name,...) _ULIB_DETAIL_SIGNAL_EMIT(_name,__VA_ARGS__)
*/
#define ULIB_SIGNAL_EMIT(_name, ...) \
_ULIB_DETAIL_SIGNAL_EMIT(_name, __VA_ARGS__)
namespace uLib {
// A boost::signal wrapper structure ///////////////////////////////////////////
// TODO ...
typedef boost::signals2::signal_base SignalBase;
template <typename T>
struct Signal {
template <typename T> struct Signal {
typedef boost::signals2::signal<T> type;
};
////////////////////////////////////////////////////////////////////////////////
namespace detail {
template <typename FuncT, int arity> struct ConnectSignal {};
template <typename FuncT, int arity>
struct ConnectSignal {};
template <typename FuncT>
struct ConnectSignal< FuncT, 0 > {
static void connect(SignalBase *sigb, FuncT slof, typename FunctionPointer<FuncT>::Object *receiver) {
typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
reinterpret_cast<SigT*>(sigb)->connect(slof);
template <typename FuncT> struct ConnectSignal<FuncT, 0> {
static void connect(SignalBase *sigb, FuncT slof,
typename FunctionPointer<FuncT>::Object *receiver) {
typedef
typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
SigT;
reinterpret_cast<SigT *>(sigb)->connect(slof);
}
};
template <typename FuncT>
struct ConnectSignal< FuncT, 1 > {
static void connect(SignalBase *sigb, FuncT slof, typename FunctionPointer<FuncT>::Object *receiver) {
typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
reinterpret_cast<SigT*>(sigb)->connect(boost::bind(slof,receiver));
template <typename FuncT> struct ConnectSignal<FuncT, 1> {
static void connect(SignalBase *sigb, FuncT slof,
typename FunctionPointer<FuncT>::Object *receiver) {
typedef
typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
SigT;
reinterpret_cast<SigT *>(sigb)->connect(boost::bind(slof, receiver));
}
};
template <typename FuncT>
struct ConnectSignal< FuncT, 2 > {
static void connect(SignalBase *sigb, FuncT slof, typename FunctionPointer<FuncT>::Object *receiver) {
typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
reinterpret_cast<SigT*>(sigb)->connect(boost::bind(slof,receiver,_1));
template <typename FuncT> struct ConnectSignal<FuncT, 2> {
static void connect(SignalBase *sigb, FuncT slof,
typename FunctionPointer<FuncT>::Object *receiver) {
typedef
typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
SigT;
reinterpret_cast<SigT *>(sigb)->connect(boost::bind(slof, receiver, _1));
}
};
template <typename FuncT>
struct ConnectSignal< FuncT, 3 > {
static void connect(SignalBase *sigb, FuncT slof, typename FunctionPointer<FuncT>::Object *receiver) {
typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
reinterpret_cast<SigT*>(sigb)->connect(boost::bind(slof,receiver,_1,_2));
template <typename FuncT> struct ConnectSignal<FuncT, 3> {
static void connect(SignalBase *sigb, FuncT slof,
typename FunctionPointer<FuncT>::Object *receiver) {
typedef
typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
SigT;
reinterpret_cast<SigT *>(sigb)->connect(
boost::bind(slof, receiver, _1, _2));
}
};
template <typename FuncT>
struct ConnectSignal< FuncT, 4 > {
static void connect(SignalBase *sigb, FuncT slof, typename FunctionPointer<FuncT>::Object *receiver) {
typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
reinterpret_cast<SigT*>(sigb)->connect(boost::bind(slof,receiver,_1,_2,_3));
template <typename FuncT> struct ConnectSignal<FuncT, 4> {
static void connect(SignalBase *sigb, FuncT slof,
typename FunctionPointer<FuncT>::Object *receiver) {
typedef
typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
SigT;
reinterpret_cast<SigT *>(sigb)->connect(
boost::bind(slof, receiver, _1, _2, _3));
}
};
template <typename FuncT>
struct ConnectSignal< FuncT, 5 > {
static void connect(SignalBase *sigb, FuncT slof, typename FunctionPointer<FuncT>::Object *receiver) {
typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
reinterpret_cast<SigT*>(sigb)->connect(boost::bind(slof,receiver,_1,_2,_3,_4));
template <typename FuncT> struct ConnectSignal<FuncT, 5> {
static void connect(SignalBase *sigb, FuncT slof,
typename FunctionPointer<FuncT>::Object *receiver) {
typedef
typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
SigT;
reinterpret_cast<SigT *>(sigb)->connect(
boost::bind(slof, receiver, _1, _2, _3, _4));
}
};
} // namespace detail
} // detail
template <typename FuncT>
SignalBase *NewSignal(FuncT f) {
template <typename FuncT> SignalBase *NewSignal(FuncT f) {
// seems to work wow !
return new Signal<void()>::type;
}
template <typename FuncT>
void ConnectSignal(SignalBase *sigb, FuncT slof, typename FunctionPointer<FuncT>::Object *receiver)
{
detail::ConnectSignal< FuncT, FunctionPointer<FuncT>::arity >::connect(sigb,slof,receiver);
void ConnectSignal(SignalBase *sigb, FuncT slof,
typename FunctionPointer<FuncT>::Object *receiver) {
detail::ConnectSignal<FuncT, FunctionPointer<FuncT>::arity>::connect(
sigb, slof, receiver);
}
} // uLib
} // namespace uLib
#endif // SIGNAL_H

7
src/Core/testing/CMakeLists.txt
View File

@@ -24,9 +24,8 @@ set( TESTS
set(LIBRARIES
${PACKAGE_LIBPREFIX}Core
${PACKAGE_LIBPREFIX}Math
${Boost_SERIALIZATION_LIBRARY}
${Boost_SIGNALS_LIBRARY}
${Boost_PROGRAM_OPTIONS_LIBRARY}
Boost::serialization
Boost::program_options
${ROOT_LIBRARIES}
)
uLib_add_tests(${uLib-module})
uLib_add_tests(Core)

68
src/Core/testing/SerializeDreadDiamondTest.cpp
View File

@@ -23,13 +23,10 @@
//////////////////////////////////////////////////////////////////////////////*/
#include <iostream>
#include <fstream>
#include <typeinfo>
#include <iostream>
#include <string>
#include <typeinfo>
#include "Core/Object.h"
@@ -37,78 +34,43 @@
using namespace uLib;
struct A : Object {
uLibTypeMacro(A,Object)
A() : numa(5552368) {}
uLibTypeMacro(A, Object) A() : numa(5552368) {}
int numa;
};
ULIB_SERIALIZABLE_OBJECT(A)
ULIB_SERIALIZE_OBJECT(A,Object) {
ar & AR(numa);
}
ULIB_SERIALIZE_OBJECT(A, Object) { ar &AR(numa); }
struct B : virtual Object {
uLibTypeMacro(B,Object)
B() : numb(5552369) {}
uLibTypeMacro(B, Object) B() : numb(5552369) {}
int numb;
};
ULIB_SERIALIZABLE_OBJECT(B)
ULIB_SERIALIZE_OBJECT(B,Object) { ar & AR(numb); }
ULIB_SERIALIZE_OBJECT(B, Object) { ar &AR(numb); }
struct C : B {
uLibTypeMacro(C,B)
C() : numc(5552370) {}
uLibTypeMacro(C, B) C() : numc(5552370) {}
int numc;
};
ULIB_SERIALIZABLE_OBJECT(C)
ULIB_SERIALIZE_OBJECT(C,B) { ar & AR(numc); }
ULIB_SERIALIZE_OBJECT(C, B) { ar &AR(numc); }
struct D : A,B {
uLibTypeMacro(D,A,B)
struct D : A, B {
uLibTypeMacro(D, A, B)
D() : numd(5552371) {}
D()
: numd(5552371) {}
int numd;
};
ULIB_SERIALIZABLE_OBJECT(D)
ULIB_SERIALIZE_OBJECT(D,A,B) { ar & AR(numd); }
ULIB_SERIALIZE_OBJECT(D, A, B) { ar &AR(numd); }
main() {
A o; o.init_properties();
int main() {
A o;
Archive::xml_oarchive(std::cout) << NVP(o);
}

112
src/Core/testing/SerializeTest.cpp
View File

@@ -23,20 +23,16 @@
//////////////////////////////////////////////////////////////////////////////*/
#include <iostream>
#include <fstream>
#include <iostream>
#include "Core/Object.h"
#include "Core/Archives.h"
#include "Core/Object.h"
#include "testing-prototype.h"
using namespace uLib;
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
@@ -45,49 +41,41 @@ using namespace uLib;
struct V3f {
float x,y,z;
V3f()
{ x = y = z =0; }
float x, y, z;
V3f() { x = y = z = 0; }
V3f(float x, float y, float z) :
x(x), y(y), z(z) {}
V3f(float x, float y, float z) : x(x), y(y), z(z) {}
template <class Archive>
void serialize (Archive &ar,unsigned int v) {
ar
& "<" & NVP(x) & NVP(y) & NVP(z) & ">";
template <class Archive> void serialize(Archive &ar, unsigned int v) {
ar & "<" & NVP(x) & NVP(y) & NVP(z) & ">";
}
};
ULIB_CLASS_EXPORT_KEY(V3f);
ULIB_CLASS_EXPORT_IMPLEMENT(V3f);
inline std::ostream &
operator <<(std::ostream &o, const V3f &v) {
inline std::ostream &operator<<(std::ostream &o, const V3f &v) {
Archive::hrt_oarchive(o) << v;
return o;
}
inline std::istream &
operator >>(std::istream &is, V3f &v) {
inline std::istream &operator>>(std::istream &is, V3f &v) {
Archive::hrt_iarchive(is) >> v;
return is;
}
int test_V3f() {
// testing human readble archive with simple serializable structure //
V3f v1(1,2,3),v2,v3,v4;
V3f v1(1, 2, 3), v2, v3, v4;
std::cout << "v --> " << v1 << "\n";
std::stringstream ss; ss << v1;
std::stringstream ss;
ss << v1;
std::cout << "ss.v --> " << ss.str() << "\n";
Archive::hrt_iarchive ar(ss); ar >> v2;
Archive::hrt_iarchive ar(ss);
ar >> v2;
std::cout << "v2 --> " << v2 << "\n";
std::stringstream("<2 3 4>") >> v3;
@@ -98,10 +86,6 @@ int test_V3f() {
return (1);
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
@@ -109,70 +93,56 @@ int test_V3f() {
// OBJECT SERIALIZATION //
class A : public virtual Object {
uLibTypeMacro(A,Object)
ULIB_SERIALIZE_ACCESS
public:
A() : m_a(5552368) {}
uLibTypeMacro(A, Object) ULIB_SERIALIZE_ACCESS public : A() : m_a(5552368) {}
properties() {
void init_properties();
std::string p_a;
};
uLibRefMacro (a,int);
uLibRefMacro(a, int);
private:
int m_a;
};
void A::init_properties() {
$_init();
$$.p_a = "A property string";
}
void A::init_properties() { p_a = "A property string"; }
ULIB_SERIALIZABLE_OBJECT(A)
ULIB_SERIALIZE_OBJECT(A,Object) {
ar
& "Object A : "
& "--> m_a = " & AR(m_a)
& "\n";
ULIB_SERIALIZE_OBJECT(A, Object) {
ar & "Object A : " & "--> m_a = " & AR(m_a) & "\n" & "Object A properties: " &
"---> p_a = " & AR(p_a) & "\n";
}
ULIB_SERIALIZE_OBJECT_PROPS(A) {
ar
& "Object A properties: "
& "---> p_a = " & AR(p_a) & "\n";
}
int testing_xml_class() {
A a; a.init_properties();
A a;
a.init_properties();
{
std::ofstream file("test.xml");
Archive::xml_oarchive(file) << NVP(a);
}
a.a() = 0;
a.$$.p_a = "zero string";
a.p_a = "zero string";
{
std::ifstream file("test.xml");
Archive::xml_iarchive(file) >> NVP(a);
}
Archive::xml_oarchive(std::cout) << NVP(a);
return ( a.a() == 5552368 && a.$$.p_a == "A property string" );
return (a.a() == 5552368 && a.p_a == "A property string");
}
int testing_hrt_class() {
A a; a.init_properties();
A a;
a.init_properties();
{
std::ofstream file("test.xml");
Archive::hrt_oarchive(file) << NVP(a);
}
a.a() = 0;
a.$$.p_a = "zero string";
a.p_a = "zero string";
{
// ERRORE FIX !
// std::ifstream file("test.xml");
@@ -180,33 +150,15 @@ int testing_hrt_class() {
}
Archive::hrt_oarchive(std::cout) << NVP(a);
return ( a.a() == 5552368 && a.$$.p_a == "A property string" );
return (a.a() == 5552368 && a.p_a == "A property string");
}
int main() {
BEGIN_TESTING(Serialize Test);
TEST1( test_V3f() );
TEST1( testing_xml_class() );
TEST1(test_V3f());
TEST1(testing_xml_class());
// testing_hrt_class(); ///// << ERRORE in HRT with properties
END_TESTING;
}

53
src/Core/testing/StaticInterfaceTest.cpp
View File

@@ -23,16 +23,11 @@
//////////////////////////////////////////////////////////////////////////////*/
#include <iostream>
#include "testing-prototype.h"
#include <Core/StaticInterface.h>
namespace uLib {
//// INTERFACE TO COMPLEX CLASS /////
@@ -40,73 +35,61 @@ namespace uLib {
namespace Interface {
struct Test {
MAKE_TRAITS
template<class Self> void check_structural() {
uLibCheckFunction(Self,test,bool,int,float);
uLibCheckMember(Self,testmemb,int);
template <class Self> void check_structural() {
uLibCheckFunction(Self, test, bool, int, float);
uLibCheckMember(Self, testmemb, int);
}
};
}
} // namespace Interface
struct Test {
bool test(int i, float f){}
bool test(int i, float f) { return true; }
int testmemb;
};
//// INTERFAC TO SIMPLE CLASS ///////////
namespace Interface {
struct Simple {
MAKE_TRAITS
template<class Self> void check_structural() {
uLibCheckMember(Self,memb1,int);
uLibCheckMember(Self,memb2,float);
template <class Self> void check_structural() {
uLibCheckMember(Self, memb1, int);
uLibCheckMember(Self, memb2, float);
}
};
}
} // namespace Interface
struct Simple {
int memb1;
float memb2;
};
/////////////////////////
template <class T>
class UseTest {
template <class T> class UseTest {
public:
UseTest() {
Interface::IsA<T,Interface::Test>();
Interface::IsA<T, Interface::Test>();
T t;
int i; float f;
t.test(i,f);
int i;
float f;
t.test(i, f);
}
};
template <class T>
class UseSimple {
template <class T> class UseSimple {
public:
UseSimple() {
Interface::IsA<T,Interface::Simple>();
}
UseSimple() { Interface::IsA<T, Interface::Simple>(); }
};
} // namespace uLib
}
int main()
{
int main() {
BEGIN_TESTING(Static Interface);
uLib::UseTest<uLib::Test> u;
uLib::UseSimple<uLib::Simple> s;
END_TESTING;
}

5
src/Detectors/CMakeLists.txt
View File

@@ -5,3 +5,8 @@ set(ULIB_SELECTED_MODULES ${ULIB_SELECTED_MODULES} Detectors PARENT_SCOPE)
install(FILES ${HEADERS}
DESTINATION ${INSTALL_INC_DIR}/Detectors)
if(BUILD_TESTING)
include(uLibTargetMacros)
add_subdirectory(testing)
endif()

23
src/Detectors/testing/CMakeLists.txt
View File

@@ -1,18 +1,15 @@
# TESTS
set( TESTS
GDMLSolidTest
# GDMLSolidTest
HierarchicalEncodingTest
)
#set(LIBRARIES
# ${PACKAGE_LIBPREFIX}Core
# ${PACKAGE_LIBPREFIX}Math
# ${PACKAGE_LIBPREFIX}Detectors
# ${Boost_SERIALIZATION_LIBRARY}
# ${Boost_SIGNALS_LIBRARY}
# ${Boost_PROGRAM_OPTIONS_LIBRARY}
# ${Eigen_LIBRARY}
# ${Geant4_LIBRARIES}
# ${ROOT_LIBRARIES}
#)
uLib_add_tests(${uLib-module})
set(LIBRARIES
${PACKAGE_LIBPREFIX}Core
${PACKAGE_LIBPREFIX}Math
Boost::serialization
Boost::program_options
Eigen3::Eigen
${ROOT_LIBRARIES}
)
uLib_add_tests(Detectors)

7
src/Math/CMakeLists.txt
View File

@@ -54,7 +54,8 @@ install(TARGETS ${libname}
install(FILES ${HEADERS} DESTINATION ${INSTALL_INC_DIR}/Math)
# TESTING
# include(uLibTargetMacros)
# add_subdirectory(testing)
if(BUILD_TESTING)
include(uLibTargetMacros)
add_subdirectory(testing)
endif()

62
src/Math/testing/AccumulatorTest.cpp
View File

@@ -23,18 +23,16 @@
//////////////////////////////////////////////////////////////////////////////*/
#include "Math/Accumulator.h"
#include "testing-prototype.h"
#include <TRandom.h>
#include <iostream>
#include <vector>
//#include <boost/accumulators/framework/accumulator_set.hpp>
//#include <boost/accumulators/statistics/count.hpp>
//#include <boost/accumulators/accumulators.hpp>
// #include <boost/accumulators/framework/accumulator_set.hpp>
// #include <boost/accumulators/statistics/count.hpp>
// #include <boost/accumulators/accumulators.hpp>
using namespace uLib;
@@ -42,68 +40,72 @@ int test_ABTrim() {
Accumulator_ABTrim<float> acc;
acc.SetABTrim(1,1);
acc.SetABTrim(1, 1);
std::vector<float> v;
for(float tmpf : {1,5,5,5,300}) v.push_back(tmpf);
//v << 1,5,5,5,300;
for (float tmpf : {1, 5, 5, 5, 300})
v.push_back(tmpf);
// v << 1,5,5,5,300;
for(std::vector<float>::iterator itr=v.begin(); itr<v.end(); itr++)
for (std::vector<float>::iterator itr = v.begin(); itr < v.end(); itr++)
acc += *itr;
// TODO missing operator <<
//std::cout << "Accumulating Trim(1,1) vector: "
// std::cout << "Accumulating Trim(1,1) vector: "
// << v << " ... out = " << acc() << "\n";
return( acc() == 15.0 );
return (acc() == 15.0);
}
int test_Mean() {
Accumulator_Mean<float> mean;
TRandom rnd;
const int c = 10000000;
std::vector<float> v;
v.reserve(c);
for(int i=0;i<c;++i) v.push_back( rnd.Gaus(2000,5) );
for (int i = 0; i < c; ++i)
v.push_back(rnd.Gaus(2000, 5));
float m = 0;
for(int i=0;i<c;++i) m += v[i];
for (int i = 0; i < c; ++i)
m += v[i];
m /= c;
std::cout << "simple mean: " << m << "\n";
for(int i=0;i<c;++i) mean(v[i]);
for (int i = 0; i < c; ++i)
mean(v[i]);
std::cout << "mean pass: " << mean() << "\n";
mean.AddPass();
for(int i=0;i<c;++i) mean(v[i]);
for (int i = 0; i < c; ++i)
mean(v[i]);
std::cout << "mean pass: " << mean() << "\n";
mean.AddPass();
for(int i=0;i<c;++i) mean(v[i]);
for (int i = 0; i < c; ++i)
mean(v[i]);
std::cout << "mean pass: " << mean() << "\n";
mean.AddPass();
for(int i=0;i<c;++i) mean(v[i]);
for (int i = 0; i < c; ++i)
mean(v[i]);
std::cout << "mean pass: " << mean() << "\n";
mean.AddPass();
for(int i=0;i<c;++i) mean(v[i]);
for (int i = 0; i < c; ++i)
mean(v[i]);
std::cout << "mean pass: " << mean() << "\n";
mean.AddPass();
for(int i=0;i<c;++i) mean(v[i]);
for (int i = 0; i < c; ++i)
mean(v[i]);
std::cout << "mean pass: " << mean() << "\n";
mean.AddPass();
for(int i=0;i<c;++i) mean(v[i]);
for (int i = 0; i < c; ++i)
mean(v[i]);
std::cout << "mean pass: " << mean() << "\n";
return 1;
}
int main(void) {
BEGIN_TESTING(Accumulator);
//TEST1( test_ABTrim() );
// TEST1( test_ABTrim() );
test_Mean();
END_TESTING;

2
src/Math/testing/CMakeLists.txt
View File

@@ -17,6 +17,8 @@ set(TESTS
set(LIBRARIES
${PACKAGE_LIBPREFIX}Core
${PACKAGE_LIBPREFIX}Math
Boost::serialization
Eigen3::Eigen
)
uLib_add_tests(Math)

17
src/Math/testing/TriangleMeshTest.cpp
View File

@@ -23,28 +23,23 @@
//////////////////////////////////////////////////////////////////////////////*/
#include "testing-prototype.h"
#include "Math/TriangleMesh.h"
#include <iostream>
using namespace uLib;
int main()
{
int main() {
BEGIN_TESTING(Triangle Mesh);
TriangleMesh mesh;
mesh.AddPoint(Vector3f(0,0,0));
mesh.AddPoint(Vector3f(0,1,0));
mesh.AddPoint(Vector3f(1,0,0));
mesh.AddTriangle(Vector3i(0,1,2));
mesh.AddPoint(Vector3f(0, 0, 0));
mesh.AddPoint(Vector3f(0, 1, 0));
mesh.AddPoint(Vector3f(1, 0, 0));
mesh.AddTriangle(Vector3i(0, 1, 2));
mesh.PrintSelf(std::cout);

105
src/Math/testing/VoxRaytracerTest.cpp
View File

@@ -23,129 +23,114 @@
//////////////////////////////////////////////////////////////////////////////*/
#include "Math/StructuredGrid.h"
#include "Math/VoxRaytracer.h"
#include "Math/StructuredGrid.h"
#include "testing-prototype.h"
#include <iostream>
using namespace uLib;
int Vector4f0(Vector4f c)
{
int Vector4f0(Vector4f c) {
c(3) = 0;
if ( fabs(c(0)) < 0.001 && fabs(c(1)) < 0.001 && fabs(c(2)) < 0.001 )
if (fabs(c(0)) < 0.001 && fabs(c(1)) < 0.001 && fabs(c(2)) < 0.001)
return 0;
else
return 1;
}
//bool Comapare(const &t1, const T2 &t2)
// bool Comapare(const &t1, const T2 &t2)
//{
// int out = 0;
// out += t1.vox_id != t2.vox_id;
// out += (fabs(t1.L) - fabs(t2.L)) > 0.001;
// return out == 0;
//}
// }
typedef VoxRaytracer Raytracer;
int main()
{
int main() {
BEGIN_TESTING(Math VoxRaytracer);
StructuredGrid img(Vector3i(2,2,2));
img.SetSpacing(Vector3f(2,2,2));
img.SetPosition(Vector3f(-2,0,-2));
StructuredGrid img(Vector3i(2, 2, 2));
img.SetSpacing(Vector3f(2, 2, 2));
img.SetPosition(Vector3f(-2, 0, -2));
{
HLine3f line;
line.origin << 0.1, 4.1, 0.1, 1;
line.direction << 0.1, -0.1, 0.1,0;
line.direction << 0.1, -0.1, 0.1, 0;
Raytracer rt(img);
HPoint3f pt;
TEST1( rt.GetEntryPoint(line,pt) );
TEST0( Vector4f0( pt - HPoint3f(0.2,4,0.2) ) );
TEST1(rt.GetEntryPoint(line, pt));
TEST0(Vector4f0(pt - HPoint3f(0.2, 4, 0.2)));
}
{
HLine3f line;
line.origin << 4,0,4, 1;
line.origin << 4, 0, 4, 1;
line.direction << -0.1, 0.1, -0.1, 0;
Raytracer rt(img);
HPoint3f pt;
TEST1( rt.GetEntryPoint(line,pt) );
TEST0( Vector4f0( pt - HPoint3f(2,2,2) ) );
TEST1(rt.GetEntryPoint(line, pt));
TEST0(Vector4f0(pt - HPoint3f(2, 2, 2)));
}
{ // Test a point inside image //
StructuredGrid img(Vector3i(4,4,4));
img.SetSpacing(Vector3f(2,2,2));
img.SetPosition(Vector3f(-4,-4,-4));
StructuredGrid img(Vector3i(4, 4, 4));
img.SetSpacing(Vector3f(2, 2, 2));
img.SetPosition(Vector3f(-4, -4, -4));
Raytracer ray(img);
HPoint3f pt;
HLine3f line;
line.origin = HPoint3f(-3,-3,-3);
line.origin = HPoint3f(-3, -3, -3);
// line.direction = HVector3f(1,1,1); //
TEST1( ray.GetEntryPoint(line,pt) );
TEST1( pt == HPoint3f(-3,-3,-3) );
TEST1(ray.GetEntryPoint(line, pt));
TEST1(pt == HPoint3f(-3, -3, -3));
Raytracer::RayData rdata = ray.TraceBetweenPoints(HPoint3f(-3,-3,-3), HPoint3f(3,3,3));
for(const Raytracer::RayData::Element &el : rdata.Data())
{
Raytracer::RayData rdata =
ray.TraceBetweenPoints(HPoint3f(-3, -3, -3), HPoint3f(3, 3, 3));
for (const Raytracer::RayData::Element &el : rdata.Data()) {
std::cout << " " << el.vox_id << " , " << el.L << "\n";
}
}
{
HPoint3f pt1(1,-0.5,1);
HPoint3f pt2(1,4.5,1);
HPoint3f pt1(1, -0.5, 1);
HPoint3f pt2(1, 4.5, 1);
Raytracer rt(img);
Raytracer::RayData ray = rt.TraceBetweenPoints(pt1,pt2);
TEST1( ray.Data().size() == 2 );
TEST1( ray.Data().at(0).vox_id == 6 );
TEST1( ray.Data().at(1).vox_id == 7 );
Raytracer::RayData ray = rt.TraceBetweenPoints(pt1, pt2);
TEST1(ray.Data().size() == 2);
TEST1(ray.Data().at(0).vox_id == 6);
TEST1(ray.Data().at(1).vox_id == 7);
ray.PrintSelf(std::cout);
}
{
HPoint3f pt1(5,1,1);
HPoint3f pt2(-3,1,1);
HPoint3f pt1(5, 1, 1);
HPoint3f pt2(-3, 1, 1);
Raytracer rt(img);
Raytracer::RayData ray = rt.TraceBetweenPoints(pt1,pt2);
TEST1( ray.Data().size() == 2 );
TEST1( ray.Data().at(0).vox_id == 6 );
TEST1( ray.Data().at(1).vox_id == 4 );
Raytracer::RayData ray = rt.TraceBetweenPoints(pt1, pt2);
TEST1(ray.Data().size() == 2);
TEST1(ray.Data().at(0).vox_id == 6);
TEST1(ray.Data().at(1).vox_id == 4);
ray.PrintSelf(std::cout);
}
{
HPoint3f pt1(1,1,1);
HPoint3f pt2(-1,3,-1);
HPoint3f pt1(1, 1, 1);
HPoint3f pt2(-1, 3, -1);
Raytracer rt(img);
Raytracer::RayData ray = rt.TraceBetweenPoints(pt1,pt2);
TEST1( ray.Data().size() == 4 );
TEST1( ray.Data().at(0).vox_id == 6 );
TEST1( ray.Data().at(1).vox_id == 4 );
TEST1( ray.Data().at(2).vox_id == 5 );
TEST1( ray.Data().at(3).vox_id == 1 );
Raytracer::RayData ray = rt.TraceBetweenPoints(pt1, pt2);
TEST1(ray.Data().size() == 4);
TEST1(ray.Data().at(0).vox_id == 6);
TEST1(ray.Data().at(1).vox_id == 4);
TEST1(ray.Data().at(2).vox_id == 5);
TEST1(ray.Data().at(3).vox_id == 1);
ray.PrintSelf(std::cout);
}
END_TESTING
}

5
src/Root/CMakeLists.txt
View File

@@ -62,4 +62,7 @@ install(TARGETS ${libname}
install(FILES ${HEADERS} DESTINATION ${INSTALL_INC_DIR}/Root)
if(BUILD_TESTING)
include(uLibTargetMacros)
add_subdirectory(testing)
endif()

7
src/Root/testing/CMakeLists.txt
View File

@@ -8,9 +8,8 @@ set(LIBRARIES
${PACKAGE_LIBPREFIX}Core
${PACKAGE_LIBPREFIX}Math
${PACKAGE_LIBPREFIX}Root
${Boost_SERIALIZATION_LIBRARY}
${Boost_SIGNALS_LIBRARY}
${Boost_PROGRAM_OPTIONS_LIBRARY}
Boost::serialization
Boost::program_options
${ROOT_LIBRARIES}
)
uLib_add_tests(${uLib-module})
uLib_add_tests(Root)

4
src/Vtk/CMakeLists.txt
View File

@@ -36,3 +36,7 @@ install(TARGETS ${libname}
install(FILES ${HEADERS} DESTINATION ${INSTALL_INC_DIR}/Vtk)
if(BUILD_TESTING)
include(uLibTargetMacros)
add_subdirectory(testing)
endif()

4
src/Vtk/testing/CMakeLists.txt
View File

@@ -14,5 +14,5 @@ set(LIBRARIES
${PACKAGE_LIBPREFIX}Vtk
)
include(${VTK_USE_FILE})
uLib_add_tests(${uLib-module})
# include(${VTK_USE_FILE})
uLib_add_tests(Vtk)

5
src/utils/make_recipe/src/CMakeLists.txt
View File

@@ -67,9 +67,8 @@ if(ULIB_FOUND)
############################################################################
# MANUAL INLCLUDE EXTERNAL DEPENDENCIES
# ${Boost_SERIALIZATION_LIBRARY}
# ${Boost_SIGNALS_LIBRARY}
# ${Boost_PROGRAM_OPTIONS_LIBRARY}
# Boost::serialization
# Boost::program_options
# ${Geant4_LIBRARIES}
# ${ROOT_LIBRARIES}
# ${VTK_LIBRARIES} # all VTK libs