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

andrea-dev #1

Merged
andrea merged 19 commits from andrea-dev into main 2026-03-06 17:17:52 +01:00
Conversation 1 Commits 19 Files Changed 135 +878 -1552
17 changed files with 878 additions and 1552 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit c04722c2bb - Show all commits

2
.gitignore vendored
View File

@@ -1,3 +1,3 @@
CMakeFiles/ CMakeFiles/
build/ build/
.cache/

8
.vscode/settings.json vendored Normal file
View File

@@ -0,0 +1,8 @@
{
"clangd.fallbackFlags": [
"-I${workspaceFolder}/src",
"-I/home/share/micromamba/envs/mutom/include",
"-I/home/rigoni/.conan2/p/eigen5481853932f72/p/include/eigen3"
],
"clangd.semanticHighlighting.enable": true
}

2
CMakeLists.txt
View File

@@ -73,7 +73,7 @@ set(CMAKE_VERBOSE_MAKEFILE FALSE
CACHE STRING "Verbose compile output switch") CACHE STRING "Verbose compile output switch")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_CXX_WARNING_OPTION}") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_CXX_WARNING_OPTION}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -UULIB_SERIALIZATION_ON") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -UULIB_SERIALIZATION_ON -Wno-cpp")
# CTEST framework # CTEST framework
enable_testing() enable_testing()

36
build.log Normal file
View File

@@ -0,0 +1,36 @@
make: Entering directory '/home/rigoni/devel/cmt/ulib/build'
[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/VoxImage.cpp.o
[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/TriangleMesh.cpp.o
[ 30%] Building CXX object src/Core/CMakeFiles/mutomCore.dir/Options.cpp.o
[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/Dense.cpp.o
[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/StructuredGrid.cpp.o
[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/VoxRaytracer.cpp.o
[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/StructuredData.cpp.o
[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/Structured2DGrid.cpp.o
[ 30%] Building CXX object src/Math/CMakeFiles/mutomMath.dir/Structured4DGrid.cpp.o
[ 33%] Linking CXX shared library libmutomCore.so
[ 33%] Built target mutomCore
[ 36%] Linking CXX shared library libmutomMath.so
[ 36%] Built target mutomMath
[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/vtkContainerBox.cpp.o
[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/uLibVtkInterface.cxx.o
[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/vtkStructuredGrid.cpp.o
[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/vtkMuonScatter.cxx.o
[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/uLibVtkViewer.cpp.o
[ 63%] Generating mutomRootDict.cxx, libmutomRootDict_rdict.pcm, libmutomRootDict.rootmap
[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/vtkVoxImage.cpp.o
[ 63%] Building CXX object src/Vtk/CMakeFiles/mutomVtk.dir/vtkVoxRaytracerRepresentation.cpp.o
[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/muCastorSkinHit.cpp.o
[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/muCastorHit.cpp.o
[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/muCastorMCTrack.cpp.o
[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/muCastorInfo.cpp.o
[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/RootMuonScatter.cpp.o
[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/muCastorPrimaryVertex.cpp.o
[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/muCastorMuDetDIGI.cpp.o
[ 90%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/SkinDetectorWriter.cpp.o
[ 93%] Building CXX object src/Root/CMakeFiles/mutomRoot.dir/mutomRootDict.cxx.o
[ 96%] Linking CXX shared library libmutomVtk.so
[ 96%] Built target mutomVtk
[100%] Linking CXX shared library libmutomRoot.so
[100%] Built target mutomRoot
make: Leaving directory '/home/rigoni/devel/cmt/ulib/build'

1
src/Core/Makefile.am
View File

@@ -14,7 +14,6 @@ library_include_HEADERS = \
Macros.h \ Macros.h \
Mpl.h \ Mpl.h \
Object.h \ Object.h \
ObjectProps.h \
Options.h \ Options.h \
Serializable.h \ Serializable.h \
Signal.h \ Signal.h \

198
src/Core/Object.cpp
View File

@@ -23,178 +23,126 @@
//////////////////////////////////////////////////////////////////////////////*/ //////////////////////////////////////////////////////////////////////////////*/
#include "config.h" #include "config.h"
#include "Object.h" #include "Object.h"
#include "Vector.h" #include "Vector.h"
#include "boost/archive/polymorphic_xml_oarchive.hpp"
#include "boost/archive/polymorphic_xml_iarchive.hpp"
#include "boost/archive/polymorphic_text_oarchive.hpp"
#include "boost/archive/polymorphic_text_iarchive.hpp"
#include "boost/archive/polymorphic_binary_oarchive.hpp"
#include "boost/archive/polymorphic_binary_iarchive.hpp" #include "boost/archive/polymorphic_binary_iarchive.hpp"
#include "boost/archive/polymorphic_binary_oarchive.hpp"
#include "boost/archive/polymorphic_text_iarchive.hpp"
#include "boost/archive/polymorphic_text_oarchive.hpp"
#include "boost/archive/polymorphic_xml_iarchive.hpp"
#include "boost/archive/polymorphic_xml_oarchive.hpp"
namespace uLib { namespace uLib {
const char *Version::PackageName = PACKAGE_NAME;
const char *Version::PackageName = PACKAGE_NAME;
const char *Version::VersionNumber = PACKAGE_VERSION; const char *Version::VersionNumber = PACKAGE_VERSION;
const char *Version::Release = "x"; //SVN_REVISION; const char *Version::Release = "x"; // SVN_REVISION;
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// Object Private // // Object Private //
class ObjectPrivate { class ObjectPrivate {
public: public:
struct Signal {
GenericMFPtr sigptr;
std::string sigstr;
SignalBase *signal;
};
struct Signal { struct Slot {
GenericMFPtr sigptr; GenericMFPtr sloptr;
std::string sigstr; std::string slostr;
SignalBase *signal; };
};
struct Slot { Vector<Signal> sigv;
GenericMFPtr sloptr; Vector<Slot> slov;
std::string slostr;
};
Vector<Signal> sigv;
Vector<Slot> slov;
}; };
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// OBJECT IMPLEMENTATION // OBJECT IMPLEMENTATION
Object::Object() : d(new ObjectPrivate) {}
Object::Object(const Object &copy) : d(new ObjectPrivate(*copy.d)) {}
Object::Object() : Object::~Object() { delete d; }
d(new ObjectPrivate)
{}
Object::Object(const Object &copy) : void Object::DeepCopy(const Object &copy) {
ObjectPropable(copy), // should lock to be tread safe //
d(new ObjectPrivate(*copy.d)) memcpy(d, copy.d, sizeof(ObjectPrivate));
{} // ERROR! does not copy parameters ... <<<< FIXXXXX
Object::~Object() {
delete d;
} }
void Object::DeepCopy(const Object &copy) void Object::SaveXml(std::ostream &os, Object &ob) {
{ Archive::xml_oarchive ar(os);
// should lock to be tread safe // ar << boost::serialization::make_nvp("Object", ob);
memcpy(d,copy.d,sizeof(ObjectPrivate));
// ERROR! does not copy parameters ... <<<< FIXXXXX
} }
void Object::LoadXml(std::istream &is, Object &ob) {
Archive::xml_iarchive ar(is);
ar >> boost::serialization::make_nvp("Object", ob);
void Object::SaveXml(std::ostream &os, Object &ob)
{
Archive::xml_oarchive ar(os);
ar << boost::serialization::make_nvp("Object",ob);
} }
void Object::LoadXml(std::istream &is, Object &ob)
{
Archive::xml_iarchive ar(is);
ar >> boost::serialization::make_nvp("Object",ob);
}
// FINIRE // FINIRE
void Object::SaveConfig(std::ostream &os, int version) void Object::SaveConfig(std::ostream &os, int version) {
{ Archive::xml_oarchive ar(os);
Archive::xml_oarchive ar(os);
ObjectPropable::serialize(ar,0);
} }
void Object::LoadConfig(std::istream &is, int version) void Object::LoadConfig(std::istream &is, int version) {
{ Archive::xml_iarchive ar(is);
if(!props()) this->init_properties();
Archive::xml_iarchive ar(is);
ObjectPropable::serialize(ar,0);
} }
void Object::PrintSelf(std::ostream &o) const {
o << "OBJECT signals: ------------------\n";
Vector<ObjectPrivate::Signal>::Iterator itr;
for (itr = d->sigv.begin(); itr < d->sigv.end(); itr++) {
void Object::PrintSelf(std::ostream &o) const o << " signal:[ " << itr->sigstr << " ]\n";
{ }
o << "OBJECT signals: ------------------\n"; o << "--------------------------------------\n\n";
Vector<ObjectPrivate::Signal>::Iterator itr;
for(itr = d->sigv.begin(); itr<d->sigv.end(); itr++)
{
o << " signal:[ " << itr->sigstr << " ]\n";
}
o << "--------------------------------------\n\n";
} }
bool Object::addSignalImpl(SignalBase *sig, GenericMFPtr fptr,
bool Object::addSignalImpl(SignalBase *sig, GenericMFPtr fptr, const char *name) const char *name) {
{ ObjectPrivate::Signal s = {fptr, std::string(name), sig};
ObjectPrivate::Signal s = {fptr,std::string(name),sig}; d->sigv.push_back(s);
d->sigv.push_back(s);
} }
bool Object::addSlotImpl(GenericMFPtr fptr, const char *name) bool Object::addSlotImpl(GenericMFPtr fptr, const char *name) {
{ ObjectPrivate::Slot s = {fptr, std::string(name)};
ObjectPrivate::Slot s = {fptr,std::string(name)}; d->slov.push_back(s);
d->slov.push_back(s);
} }
SignalBase *Object::findSignalImpl(const GenericMFPtr &fptr) const SignalBase *Object::findSignalImpl(const GenericMFPtr &fptr) const {
{ for (int i = 0; i < d->sigv.size(); ++i) {
for(int i=0; i<d->sigv.size(); ++i) if (d->sigv[i].sigptr == fptr)
{ return d->sigv[i].signal;
if(d->sigv[i].sigptr == fptr) }
return d->sigv[i].signal; return NULL;
}
return NULL;
} }
SignalBase *Object::findSignalImpl(const char *name) const SignalBase *Object::findSignalImpl(const char *name) const {
{ std::string in(name);
std::string in(name); for (int i = 0; i < d->sigv.size(); ++i) {
for(int i=0; i<d->sigv.size(); ++i) if (d->sigv[i].sigstr == in)
{ return d->sigv[i].signal;
if(d->sigv[i].sigstr == in) }
return d->sigv[i].signal; return NULL;
}
return NULL;
} }
GenericMFPtr *Object::findSlotImpl(const char *name) const GenericMFPtr *Object::findSlotImpl(const char *name) const {
{ std::string in(name);
std::string in(name); for (int i = 0; i < d->slov.size(); ++i) {
for(int i=0; i<d->slov.size(); ++i) if (d->slov[i].slostr == in)
{ return &d->slov[i].sloptr;
if(d->slov[i].slostr == in) }
return &d->slov[i].sloptr; return NULL;
}
return NULL;
} }
// std::ostream & // std::ostream &
// operator << (std::ostream &os, uLib::Object &ob) // operator << (std::ostream &os, uLib::Object &ob)
// { // {
@@ -218,10 +166,4 @@ GenericMFPtr *Object::findSlotImpl(const char *name) const
// return is; // return is;
// } // }
} // namespace uLib
} // uLib

263
src/Core/Object.h
View File

@@ -23,200 +23,183 @@
//////////////////////////////////////////////////////////////////////////////*/ //////////////////////////////////////////////////////////////////////////////*/
#ifndef U_CORE_OBJECT_H #ifndef U_CORE_OBJECT_H
#define U_CORE_OBJECT_H #define U_CORE_OBJECT_H
#include <iostream> #include <iostream>
// WARNING: COPILE ERROR if this goes after mpl/vector // // WARNING: COPILE ERROR if this goes after mpl/vector //
//#include "Core/Vector.h" // #include "Core/Vector.h"
#include "Core/Types.h"
#include "Core/Debug.h" #include "Core/Debug.h"
#include "Core/Types.h"
#include "Core/Function.h" #include "Core/Function.h"
#include "Core/Signal.h" #include "Core/Signal.h"
#include "Core/Mpl.h" #include "Core/Mpl.h"
#include "Core/Serializable.h" #include "Core/Serializable.h"
#include "Core/ObjectProps.h"
#include "Core/Uuid.h" #include "Core/Uuid.h"
namespace boost { namespace boost {
namespace archive { namespace archive {
class polymorphic_iarchive; class polymorphic_iarchive;
class polymorphic_oarchive; class polymorphic_oarchive;
} // archive } // namespace archive
} // boost } // namespace boost
namespace uLib { namespace uLib {
class Version { class Version {
public: public:
static const char *PackageName; static const char *PackageName;
static const char *VersionNumber; static const char *VersionNumber;
static const char *Release; static const char *Release;
}; };
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//// OBJECT //////////////////////////////////////////////////////////////////// //// OBJECT ////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
/** /**
* @brief Object class is the object base implementation for uLib Framework. * @brief Object class is the object base implementation for uLib Framework.
*/ */
class Object : public ObjectPropable class Object {
{
public: public:
// std::string name; // std::string name;
// void PrintName() { std::cout << "Ob name: " << name << "\n"; } // void PrintName() { std::cout << "Ob name: " << name << "\n"; }
Object(); Object();
Object(const Object &copy); Object(const Object &copy);
~Object(); ~Object();
//////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////
// PARAMETERS // // PARAMETERS //
// FIXX !!! // FIXX !!!
virtual void DeepCopy(const Object &copy); virtual void DeepCopy(const Object &copy);
////////////////////////////////////////////////////////////////////////////
// SERIALIZATION //
//////////////////////////////////////////////////////////////////////////// template <class ArchiveT>
// SERIALIZATION // void serialize(ArchiveT &ar, const unsigned int version) {}
template <class ArchiveT>
void save_override(ArchiveT &ar, const unsigned int version) {}
template <class ArchiveT> void serialize(ArchiveT &ar, const unsigned int version) { void SaveConfig(std::ostream &os, int version = 0);
ObjectPropable::serialize(ar,version); void LoadConfig(std::istream &is, int version = 0);
static void SaveXml(std::ostream &os, Object &ob);
static void LoadXml(std::istream &is, Object &ob);
////////////////////////////////////////////////////////////////////////////
// SIGNALS //
// Qt4 style connector //
static bool connect(const Object *ob1, const char *signal_name,
const Object *receiver, const char *slot_name) {
// // NOT WORKING YET //
// 1) find slot pointer from name
// SignalBase *sig = ob1->findSignal(signal_name);
// GenericMFPtr *slo = receiver->findSlot(slot_name);
// if(sig && slo)
// return Object::connect(sig,slo->operator ()(),receiver);
// else return false;
}
// Qt5 style connector //
template <typename Func1, typename Func2>
static bool
connect(typename FunctionPointer<Func1>::Object *sender, Func1 sigf,
typename FunctionPointer<Func2>::Object *receiver, Func2 slof) {
SignalBase *sigb = sender->findOrAddSignal(sigf);
typedef boost::signals2::signal<
typename FunctionPointer<Func2>::SignalSignature>
SigT;
ConnectSignal(sigb, slof, receiver);
}
template <typename FuncT>
static inline bool connect(SignalBase *sigb, FuncT slof, Object *receiver) {
ConnectSignal(sigb, slof, receiver);
}
template <typename FuncT>
inline
typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type *
addSignal(FuncT fun, const char *name) {
typedef
typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
SigT;
SignalBase *sig = NewSignal(fun);
addSignalImpl(sig, fun, name);
return (SigT *)sig;
}
template <typename FuncT> inline bool addSlot(FuncT fun, const char *name) {
this->addSlotImpl(GenericMFPtr(fun), name);
}
template <typename FuncT>
inline
typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type *
findSignal(FuncT fptr) {
typedef
typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
SigT;
return (SigT *)findSignalImpl(GenericMFPtr(fptr));
}
template <typename FuncT>
inline
typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type *
findOrAddSignal(FuncT fptr) {
typedef
typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type
SigT;
SignalBase *sig = findSignalImpl(GenericMFPtr(fptr));
if (!sig) {
sig = NewSignal(fptr);
addSignalImpl(sig, fptr, "signal_name_to_be_implemented");
} }
template <class ArchiveT> void save_override(ArchiveT &ar,const unsigned int version) {} return (SigT *)sig;
}
void SaveConfig(std::ostream &os, int version = 0); inline SignalBase *findSignal(const char *name) const {
void LoadConfig(std::istream &is, int version = 0); return findSignalImpl(name);
}
static void SaveXml(std::ostream &os, Object &ob); inline GenericMFPtr *findSlot(const char *name) const {
static void LoadXml(std::istream &is, Object &ob); return findSlotImpl(name);
}
void PrintSelf(std::ostream &o) const;
inline const Object &operator=(const Object &copy) {
//////////////////////////////////////////////////////////////////////////// this->DeepCopy(copy);
// SIGNALS // return *this;
}
// Qt4 style connector //
static bool connect(const Object *ob1, const char *signal_name, const Object *receiver, const char *slot_name) {
// // NOT WORKING YET //
// 1) find slot pointer from name
// SignalBase *sig = ob1->findSignal(signal_name);
// GenericMFPtr *slo = receiver->findSlot(slot_name);
// if(sig && slo)
// return Object::connect(sig,slo->operator ()(),receiver);
// else return false;
}
// Qt5 style connector //
template <typename Func1, typename Func2>
static bool connect( typename FunctionPointer<Func1>::Object *sender, Func1 sigf,
typename FunctionPointer<Func2>::Object *receiver, Func2 slof)
{
SignalBase *sigb = sender->findOrAddSignal(sigf);
typedef boost::signals2::signal<typename FunctionPointer<Func2>::SignalSignature> SigT;
ConnectSignal(sigb,slof,receiver);
}
template <typename FuncT>
static inline bool connect(SignalBase *sigb, FuncT slof, Object *receiver) {
ConnectSignal(sigb,slof,receiver);
}
template< typename FuncT >
inline typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type *
addSignal(FuncT fun, const char *name) {
typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
SignalBase *sig = NewSignal(fun);
addSignalImpl(sig,fun,name);
return (SigT *)sig;
}
template< typename FuncT>
inline bool addSlot(FuncT fun, const char *name) {
this->addSlotImpl(GenericMFPtr(fun),name);
}
template < typename FuncT >
inline typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type *
findSignal(FuncT fptr)
{
typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
return (SigT *)findSignalImpl(GenericMFPtr(fptr));
}
template < typename FuncT >
inline typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type *
findOrAddSignal(FuncT fptr)
{
typedef typename Signal<typename FunctionPointer<FuncT>::SignalSignature>::type SigT;
SignalBase *sig = findSignalImpl(GenericMFPtr(fptr));
if(!sig) {
sig = NewSignal(fptr);
addSignalImpl(sig,fptr,"signal_name_to_be_implemented");
}
return (SigT *)sig;
}
inline SignalBase *
findSignal(const char *name) const
{
return findSignalImpl(name);
}
inline GenericMFPtr *
findSlot(const char *name) const
{
return findSlotImpl(name);
}
void PrintSelf(std::ostream &o) const;
inline const Object& operator = (const Object &copy)
{ this->DeepCopy(copy); return *this; }
private: private:
bool addSignalImpl(SignalBase *sig, GenericMFPtr fptr, const char *name); bool addSignalImpl(SignalBase *sig, GenericMFPtr fptr, const char *name);
bool addSlotImpl(GenericMFPtr fptr, const char *name); bool addSlotImpl(GenericMFPtr fptr, const char *name);
SignalBase *findSignalImpl(const GenericMFPtr &fptr) const; SignalBase *findSignalImpl(const GenericMFPtr &fptr) const;
SignalBase *findSignalImpl(const char *name) const; SignalBase *findSignalImpl(const char *name) const;
GenericMFPtr *findSlotImpl(const char *name) const; GenericMFPtr *findSlotImpl(const char *name) const;
friend class boost::serialization::access; friend class boost::serialization::access;
friend class ObjectPrivate; friend class ObjectPrivate;
class ObjectPrivate *d; class ObjectPrivate *d;
}; };
} // namespace uLib
} // uLib
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//std::ostream & operator << (std::ostream &os, uLib::Object &ob); // std::ostream & operator << (std::ostream &os, uLib::Object &ob);
//std::ostream & operator << (std::ostream &os, uLib::Object *ob); // std::ostream & operator << (std::ostream &os, uLib::Object *ob);
//std::istream & operator >> (std::istream &is, uLib::Object &ob); // std::istream & operator >> (std::istream &is, uLib::Object &ob);
#endif // U_OBJECT_H #endif // U_OBJECT_H

278
src/Core/ObjectProps.h
View File

@@ -1,278 +0,0 @@
/*//////////////////////////////////////////////////////////////////////////////
// CMT Cosmic Muon Tomography project //////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
All rights reserved
Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
------------------------------------------------------------------
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 3.0 of the License, or (at your option) any later version.
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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library.
//////////////////////////////////////////////////////////////////////////////*/
#ifndef U_OBJECTPROPS_H
#define U_OBJECTPROPS_H
#include <boost/algorithm/string/replace.hpp>
#include <Core/Mpl.h>
#include <Core/Types.h>
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// MACROS //
#define ULIB_props() \
public: struct ObjectProps; \
virtual void init_properties(); \
inline struct ObjectProps &p() { /* static const unsigned int offset = props_offset(this); */ \
/* NON FUNZIA! return * (struct ObjectProps *)(reinterpret_cast<char*>(props())+offset); */ \
return *props()->ptr<ObjectProps>(); } \
typedef uLib::mpl::bool_<true>::type propable_trait; \
public: struct DLL_PUBLIC ObjectProps
#define properties() ULIB_props()
#define default(vlaue)
#define $$ p()
#define $(_name) props_ref<_name>()
#define $_init() \
if(props(this)) return; \
props_new(this); \
uLib::detail::ObjectProps::initializer::init_object_baselist(this);
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
namespace boost {
namespace serialization {
class access;
}
}
namespace uLib {
namespace detail {
struct ObjectProps {
/** Define a trait has_member to find if an Object is Propable*/
BOOST_MPL_HAS_XXX_TRAIT_DEF(propable_trait)
/** IsA ProbapleObject Implementation Template */
template <class T>
struct IsA : has_propable_trait<T> {};
/** Lambda to get Props member type */
template <class T>
struct props_type {
typedef typename T::ObjectProps type;
};
template <typename T>
struct get_props {
/** CFList has result but this method check for has BaseList */
typedef typename detail::TypeIntrospection::child_first<T>::type CFTypeList;
/** Filter List items that have not Propable feature */
typedef typename mpl::filter_view< CFTypeList, IsA<mpl::_> >::type FilteredCFTypeList;
/** Get Props from each Parent in Seq */
typedef typename mpl::transform_view< FilteredCFTypeList, props_type<mpl::_> >::type type;
// qui sotto ho un problema che ho temporaneamente tamponato //
// ovvero ho usato child_first_impl per ottenere la lista delle basi //
// vorrei farlo facendo un pop_back ma non va forse perche il tipo //
// non e' corretto. //
/** Get Parent list from CFTypeList */
typedef typename detail::TypeIntrospection::child_first_impl<T>::Childs CFBaseList;
/** Filter Parents that have not Propable feature */
typedef typename mpl::filter_view< CFBaseList, IsA<mpl::_> >::type FilteredCFBaseList;
};
// TODO: convert to pp const value,
// (non so se sia possibile con il dinamic casting intanto funziona cosi' )
template <typename T1, typename T2>
static unsigned int measure_offset(T1 base, T2 derived) {
return reinterpret_cast<char*>(derived) - reinterpret_cast<char*>(base);
}
struct initializer {
template <class _ObjectT>
struct lambda_init_object {
_ObjectT *o;
lambda_init_object(_ObjectT *o) : o(o) {}
template<class T> void operator()(T) {
o->T::init_properties();
}
};
/**
* This calls the internal init_properties() virtual function for each
* object parent defined in BaseList only if it is propable
*/
template <class T>
static void init_object_baselist(T *o) {
typedef typename uLib::detail::ObjectProps::get_props<T>::FilteredCFBaseList CFBaseList;
mpl::for_each<CFBaseList>(lambda_init_object<T>(o));
}
/**
* This calls the internal init_properties() virtual function only if
* object is propable ( implementation if not propable )
*/
template <class T>
static
typename boost::enable_if<mpl::not_<IsA<T> >,void>::type
init_object(T *o) {
; // do nothing //
}
/**
* This calls the internal init_properties() virtual function only if
* object is propable ( implementation if propable )
*/
template <class T>
static
typename boost::enable_if<IsA<T>,void>::type
init_object(T *o) {
o->init_properties();
}
};
template <class ThisClass, class Archive>
struct serialize_baselist {
ThisClass & m_object;
Archive & m_ar;
serialize_baselist(ThisClass &o, Archive &ar) : m_object(o), m_ar(ar) {}
template <class T> void operator()(T &o) {
// T is taken fron get_props<BaseList>::FilteredPList types to get
// type_info_name that is the type name defined by Type macro
typedef typename props_type<T>::type PType;
std::string name(TypeIntrospection::access<T>::type_info::name);
boost::algorithm::replace_all(name,"::","_");
m_ar & boost::serialization::make_nvp(
name.c_str() ,
boost::serialization::base_object<PType>(m_object));
}
};
};
} // detail
struct ObjectPropsBase {
virtual ~ObjectPropsBase() {}
virtual ObjectPropsBase *copy() = 0;
template <class T> inline T *ptr() { return dynamic_cast<T*>(this); }
template<class ArchiveT> void serialize(ArchiveT &ar, const unsigned int version) {}
};
template <class T>
struct ObjectPropsImpl :
ObjectPropsBase,
ULIB_MPL_INHERIT_NOFOLD_SEQ(typename uLib::detail::ObjectProps::get_props<T>::type)
{
typedef ObjectPropsImpl<T> ThisClass;
typedef typename uLib::detail::ObjectProps::get_props<T>::type CFList;
typedef typename uLib::detail::ObjectProps::get_props<T>::FilteredCFTypeList FilteredCFTypeList;
ObjectPropsBase *copy() { return new ThisClass(*this); }
template<class ArchiveT> void serialize(ArchiveT &ar, const unsigned int version) {
boost::serialization::void_cast_register<ThisClass,ObjectPropsBase>();
mpl::for_each<FilteredCFTypeList>(detail::ObjectProps::serialize_baselist<ThisClass,ArchiveT>(*this,ar));
}
};
class ObjectPropable {
ObjectPropsBase *m_props;
friend class uLib::detail::ObjectProps;
friend class boost::serialization::access;
public:
ObjectPropable() : m_props(NULL) {}
ObjectPropable(const ObjectPropable &c) { if(c.m_props) m_props = c.m_props->copy(); else m_props = NULL; }
~ObjectPropable() { if(m_props) delete m_props; }
template <class T> inline typename T::ObjectProps& props_ref() const { if(m_props) return *m_props->ptr<typename T::ObjectProps>(); else exit(1); }
template <class T> inline typename T::ObjectProps* props(T *ptr = NULL) const { if(m_props) return m_props->ptr<typename T::ObjectProps>(); else return NULL; }
protected:
ObjectPropsBase *props() const { return m_props; }
template <class T> inline void props_new(T* ptr = NULL) { if(!m_props) m_props = new ObjectPropsImpl<T>; }
/** NOT working dynamic cache casting */
template <class T> inline unsigned int props_offset(T *ptr) const
{ if(m_props) return detail::ObjectProps::measure_offset(m_props,m_props->ptr<T>()); else return -1; }
template<class ArchiveT> void serialize(ArchiveT &ar, const unsigned int version) {
if(m_props) ar & boost::serialization::make_nvp("properties",m_props);
}
public:
/**
* ObjectPropable is not directly propable itself to prevent Basclass
* duplication in inherit_nofold. And for the same reason ANY VIRTUAL BASE
* SHOULD NOT BE PROPABLE
*/
virtual void init_properties() {}
};
} // uLib
#endif // U_OBJECTPROPS_H

511
src/Core/Serializable.h
View File

@@ -23,8 +23,6 @@
//////////////////////////////////////////////////////////////////////////////*/ //////////////////////////////////////////////////////////////////////////////*/
#ifndef U_SERIALIZABLE_H #ifndef U_SERIALIZABLE_H
#define U_SERIALIZABLE_H #define U_SERIALIZABLE_H
@@ -38,9 +36,6 @@ TODO:
*/ */
#include <boost/serialization/access.hpp> #include <boost/serialization/access.hpp>
#include <boost/serialization/export.hpp> #include <boost/serialization/export.hpp>
@@ -48,26 +43,22 @@ TODO:
#include <boost/mpl/remove_if.hpp> #include <boost/mpl/remove_if.hpp>
#include <boost/serialization/nvp.hpp> #include <boost/serialization/nvp.hpp>
//#include <boost/archive/xml_iarchive.hpp> // #include <boost/archive/xml_iarchive.hpp>
//#include <boost/archive/xml_oarchive.hpp> // #include <boost/archive/xml_oarchive.hpp>
//#include <boost/archive/text_iarchive.hpp> // #include <boost/archive/text_iarchive.hpp>
//#include <boost/archive/text_oarchive.hpp> // #include <boost/archive/text_oarchive.hpp>
//#include "boost/archive/polymorphic_iarchive.hpp" // #include "boost/archive/polymorphic_iarchive.hpp"
//#include "boost/archive/polymorphic_oarchive.hpp" // #include "boost/archive/polymorphic_oarchive.hpp"
#include <boost/preprocessor/comma_if.hpp>
#include <boost/preprocessor/repeat.hpp>
#include <boost/preprocessor/inc.hpp>
#include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/comma_if.hpp>
#include <boost/preprocessor/inc.hpp>
#include <boost/preprocessor/repeat.hpp>
#include <boost/preprocessor/tuple/to_seq.hpp> #include <boost/preprocessor/tuple/to_seq.hpp>
#include "Core/Mpl.h"
#include "Core/ObjectProps.h"
#include "Core/Archives.h" #include "Core/Archives.h"
#include "Core/Export.h" #include "Core/Export.h"
#include "Core/Mpl.h"
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
@@ -80,63 +71,47 @@ namespace serialization {
// ACCESS 2 // // ACCESS 2 //
template <class T> struct access2 {}; template <class T> struct access2 {};
// NON FUNZIONA ... SISTEMARE !!!! // ------------------------------------------ // NON FUNZIONA ... SISTEMARE !!!! // ------------------------------------------
template<class T> template <class T> class hrp : public wrapper_traits<const hrp<T>> {
class hrp : const char *m_name;
public wrapper_traits<const hrp< T > > T *m_value;
{ std::string *m_str;
const char *m_name;
T *m_value;
std::string *m_str;
public: public:
explicit hrp(const char * name_, T &t) : explicit hrp(const char *name_, T &t)
m_str(new std::string), : m_str(new std::string), m_name(name_), m_value(&t) {}
m_name(name_), m_value(&t) {}
const char * name() const { const char *name() const { return this->m_name; }
return this->m_name;
}
template <class Archivex>
template<class Archivex> void save(Archivex &ar, const unsigned int /* file_version */) const {
void save( Archivex & ar, const unsigned int /* file_version */) const { //// ar.operator<<(const_value());
//// ar.operator<<(const_value()); // std::stringstream ss;
// std::stringstream ss; // uLib::Archive::hrt_oarchive har(ss);
// uLib::Archive::hrt_oarchive har(ss); // har << make_nvp(m_name,*m_value);
// har << make_nvp(m_name,*m_value); // // (*m_str) = ss.str();
// // (*m_str) = ss.str(); //// ar.operator << (make_nvp(m_name, ss.str());
//// ar.operator << (make_nvp(m_name, ss.str()); }
} template <class Archivex>
template<class Archivex> void load(Archivex &ar, const unsigned int /* file_version */) {
void load( Archivex & ar, const unsigned int /* file_version */) { // ar.operator>>(value());
// ar.operator>>(value()); }
} BOOST_SERIALIZATION_SPLIT_MEMBER()
BOOST_SERIALIZATION_SPLIT_MEMBER()
}; };
template <class T>
template<class T>
inline inline
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
const const
#endif #endif
hrp< T > make_hrp(const char * name, T & t){ hrp<T> make_hrp(const char *name, T &t) {
return hrp< T >(name, t); return hrp<T>(name, t);
} }
#define HRP(name) \ #define HRP(name) boost::serialization::make_hrp(BOOST_PP_STRINGIZE(name), name)
boost::serialization::make_hrp(BOOST_PP_STRINGIZE(name), name)
} // serialization
} // boost
} // namespace serialization
} // namespace boost
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
@@ -151,9 +126,7 @@ hrp< T > make_hrp(const char * name, T & t){
namespace uLib { namespace uLib {
#define _AR_OP(r, data, elem) data &BOOST_SERIALIZATION_BASE_OBJECT_NVP(elem);
#define _AR_OP(r,data,elem) data&BOOST_SERIALIZATION_BASE_OBJECT_NVP(elem);
#define NVP(data) BOOST_SERIALIZATION_NVP(data) #define NVP(data) BOOST_SERIALIZATION_NVP(data)
@@ -166,51 +139,53 @@ namespace uLib {
// SO LEAVE ULIB_CFG_INTRUSIVE_SERIALIZATION NOT DEFINED // SO LEAVE ULIB_CFG_INTRUSIVE_SERIALIZATION NOT DEFINED
#ifdef ULIB_CFG_INTRUSIVE_SERIALIZATION_OBJECT #ifdef ULIB_CFG_INTRUSIVE_SERIALIZATION_OBJECT
# define ULIB_SERIALIZABLE_OBJECT _ULIB_DETAIL_INTRUSIVE_SERIALIZABLE_OBJECT #define ULIB_SERIALIZABLE_OBJECT _ULIB_DETAIL_INTRUSIVE_SERIALIZABLE_OBJECT
# define ULIB_SERIALIZE_OBJECT(_Ob,...) _ULIB_DETAIL_INTRUSIVE_SERIALIZE_OBJECT(_Ob,__VA_ARGS__) #define ULIB_SERIALIZE_OBJECT(_Ob, ...) \
# define _AR_(_name) _ULIB_DETAIL_INTRUSIVE_AR_(_name) _ULIB_DETAIL_INTRUSIVE_SERIALIZE_OBJECT(_Ob, __VA_ARGS__)
#define _AR_(_name) _ULIB_DETAIL_INTRUSIVE_AR_(_name)
#else #else
# define ULIB_SERIALIZABLE(_Ob) _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE(_Ob) \ #define ULIB_SERIALIZABLE(_Ob) \
ULIB_CLASS_EXPORT_KEY(_Ob) _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE(_Ob) \
# define ULIB_SERIALIZE(_Ob,...) _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE(_Ob) ULIB_CLASS_EXPORT_KEY(_Ob)
# define ULIB_SERIALIZE_DERIVED(_Ob,...) _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_DERIVED(_Ob,__VA_ARGS__) #define ULIB_SERIALIZE(_Ob, ...) _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE(_Ob)
# define ULIB_SERIALIZABLE_OBJECT(_Ob) _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE_OBJECT(_Ob) \ #define ULIB_SERIALIZE_DERIVED(_Ob, ...) \
ULIB_CLASS_EXPORT_OBJECT_KEY(_Ob) _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_DERIVED(_Ob, __VA_ARGS__)
# define ULIB_SERIALIZE_OBJECT(_Ob,...) _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_OBJECT(_Ob,__VA_ARGS__) #define ULIB_SERIALIZABLE_OBJECT(_Ob) \
# define ULIB_SERIALIZE_OBJECT_PROPS(_Ob) _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_PROPS(_Ob) _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE_OBJECT(_Ob) \
# define AR(_name) _ULIB_DETAIL_UNINTRUSIVE_AR_(_name) ULIB_CLASS_EXPORT_OBJECT_KEY(_Ob)
# define HR(_name) _ULIB_DETAIL_UNINTRUSIVE_AR_(_name) #define ULIB_SERIALIZE_OBJECT(_Ob, ...) \
_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_OBJECT(_Ob, __VA_ARGS__)
#define AR(_name) _ULIB_DETAIL_UNINTRUSIVE_AR_(_name)
#define HR(_name) _ULIB_DETAIL_UNINTRUSIVE_AR_(_name)
#endif #endif
#define ULIB_SERIALIZE_ACCESS \
friend class boost::serialization::access; \
template <class T> friend class boost::serialization::access2;
#define ULIB_SERIALIZE_ACCESS \ #define ULIB_CLASS_EXPORT_KEY(_FullNamespaceClass) \
friend class boost::serialization::access; \ BOOST_CLASS_EXPORT_KEY(_FullNamespaceClass)
template <class T> friend class boost::serialization::access2;
#define ULIB_CLASS_EXPORT_KEY(_FullNamespaceClass) \ #define ULIB_CLASS_EXPORT_OBJECT_KEY(_FullNamespaceClass) \
BOOST_CLASS_EXPORT_KEY(_FullNamespaceClass) BOOST_CLASS_EXPORT_KEY(_FullNamespaceClass)
#define ULIB_CLASS_EXPORT_OBJECT_KEY(_FullNamespaceClass) \
BOOST_CLASS_EXPORT_KEY(_FullNamespaceClass) \
BOOST_CLASS_EXPORT_KEY(_FullNamespaceClass::ObjectProps) \
BOOST_CLASS_EXPORT_KEY(uLib::ObjectPropsImpl<_FullNamespaceClass>)
#define _SERIALIZE_IMPL_SEQ \
(uLib::Archive::text_iarchive) \
(uLib::Archive::text_oarchive) \
(uLib::Archive::hrt_iarchive) \
(uLib::Archive::hrt_oarchive) \
(uLib::Archive::xml_iarchive) \
(uLib::Archive::xml_oarchive) \
(uLib::Archive::log_archive)
#define _SERIALIZE_IMPL_SEQ \
(uLib::Archive::text_iarchive)(uLib::Archive::text_oarchive)( \
uLib::Archive:: \
hrt_iarchive)(uLib::Archive:: \
hrt_oarchive)(uLib::Archive:: \
xml_iarchive)(uLib::Archive:: \
xml_oarchive)(uLib::Archive:: \
log_archive)
/** Solving virtual class check problem */ /** Solving virtual class check problem */
#define _ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE(_Base,_Derived) namespace boost{ template<> struct is_virtual_base_of<_Base,_Derived>: public boost::mpl::true_ {}; } #define _ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE(_Base, _Derived) \
#define _ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE_OP(r,data,elem) _ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE(elem,data) namespace boost { \
template <> \
struct is_virtual_base_of<_Base, _Derived> : public boost::mpl::true_ {}; \
}
#define _ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE_OP(r, data, elem) \
_ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE(elem, data)
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
@@ -220,38 +195,57 @@ namespace uLib {
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// INTRUSIVE SERIALIZATION ( NOT WORKING YET !! ) // // INTRUSIVE SERIALIZATION ( NOT WORKING YET !! ) //
#define _ULIB_DETAIL_INTRUSIVE_AR_(name) ar & BOOST_SERIALIZATION_NVP(name); #define _ULIB_DETAIL_INTRUSIVE_AR_(name) ar &BOOST_SERIALIZATION_NVP(name);
#define _ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC(Class,Archive) \ #define _ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC(Class, Archive) \
template void Class::serialize(Archive &ar,const unsigned int); template void Class::serialize(Archive &ar, const unsigned int);
#define _ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC_OP(r,data,elem) _ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC(data,elem); #define _ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC_OP(r, data, elem) \
_ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC(data, elem);
#define _ULIB_DETAIL_INTRUSIVE_SERIALIZABLE_OBJECT \
typedef boost::mpl::bool_<true> serializable; \
typedef boost::mpl::remove_if< TypeList, IsUnSerializable >::type SerilizableTypeList; \
void PrintSerializableListId() { boost::mpl::for_each<SerilizableTypeList>(PrintTypeId()); } \
template <class ArchiveT> void serialize(ArchiveT &ar,const unsigned int version); \
template <class ArchiveT> void serialize_parents(ArchiveT &ar,const unsigned int version); \
template <class ArchiveT> void save_override(ArchiveT &ar,const unsigned int version);
#define _ULIB_DETAIL_INTRUSIVE_SERIALIZE_OBJECT(_Ob,...) \
template <class ArchiveT> void _Ob::serialize(ArchiveT &ar, const unsigned int version) { \
boost::serialization::void_cast_register<_Ob,_Ob::BaseClass>(static_cast<_Ob *>(NULL),static_cast<_Ob::BaseClass *>(NULL)); \
_Ob::serialize_parents(ar,version); \
_Ob::save_override(ar,version); }\
template <class ArchiveT> void _Ob::serialize_parents(ArchiveT &ar, const unsigned int v) { \
BOOST_PP_SEQ_FOR_EACH(_AR_OP,ar,BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__))); } \
BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC_OP,_Ob,_SERIALIZE_IMPL_SEQ)\
BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE_OP,_Ob,BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__))) \
ULIB_CLASS_EXPORT_IMPLEMENT(_Ob) \
namespace boost { \
namespace serialization { \
template<class ArchiveT> inline void load_construct_data(ArchiveT & ar, _Ob *o, const unsigned int file_version) \
{ ::new(o)_Ob(); o->init_parameters(); } }}\
template <class ArchiveT> void _Ob::save_override(ArchiveT &ar, const unsigned int version)
#define _ULIB_DETAIL_INTRUSIVE_SERIALIZABLE_OBJECT \
typedef boost::mpl::bool_<true> serializable; \
typedef boost::mpl::remove_if<TypeList, IsUnSerializable>::type \
SerilizableTypeList; \
void PrintSerializableListId() { \
boost::mpl::for_each<SerilizableTypeList>(PrintTypeId()); \
} \
template <class ArchiveT> \
void serialize(ArchiveT &ar, const unsigned int version); \
template <class ArchiveT> \
void serialize_parents(ArchiveT &ar, const unsigned int version); \
template <class ArchiveT> \
void save_override(ArchiveT &ar, const unsigned int version);
#define _ULIB_DETAIL_INTRUSIVE_SERIALIZE_OBJECT(_Ob, ...) \
template <class ArchiveT> \
void _Ob::serialize(ArchiveT &ar, const unsigned int version) { \
boost::serialization::void_cast_register<_Ob, _Ob::BaseClass>( \
static_cast<_Ob *>(NULL), static_cast<_Ob::BaseClass *>(NULL)); \
_Ob::serialize_parents(ar, version); \
_Ob::save_override(ar, version); \
} \
template <class ArchiveT> \
void _Ob::serialize_parents(ArchiveT &ar, const unsigned int v) { \
BOOST_PP_SEQ_FOR_EACH(_AR_OP, ar, BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__))); \
} \
BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC_OP, _Ob, \
_SERIALIZE_IMPL_SEQ) \
BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE_OP, _Ob, \
BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__))) \
ULIB_CLASS_EXPORT_IMPLEMENT(_Ob) \
namespace boost { \
namespace serialization { \
template <class ArchiveT> \
inline void load_construct_data(ArchiveT &ar, _Ob *o, \
const unsigned int file_version) { \
::new (o) _Ob(); \
o->init_parameters(); \
} \
} \
} \
template <class ArchiveT> \
void _Ob::save_override(ArchiveT &ar, const unsigned int version)
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
@@ -261,152 +255,171 @@ namespace uLib {
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// UNINTRUSIVE SERIALIZATION // UNINTRUSIVE SERIALIZATION
#define _UNAR_OP(r,data,elem) ar&boost::serialization::make_nvp(BOOST_PP_STRINGIZE(elem),boost::serialization::base_object<elem>(ob)); #define _UNAR_OP(r, data, elem) \
ar &boost::serialization::make_nvp( \
BOOST_PP_STRINGIZE(elem), boost::serialization::base_object<elem>(ob));
#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC(Class,Archive) \ #define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC(Class, Archive) \
template void boost::serialization::serialize(Archive &ar, Class &ob, const unsigned int i); template void boost::serialization::serialize(Archive &ar, Class &ob, \
const unsigned int i);
#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP(r,data,elem) _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC(data,elem)
#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP(r, data, elem) \
_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC(data, elem)
// NOTE: becouse of BOOST_PP_VARIADIC_SIZE issue of some boost macro has two // NOTE: becouse of BOOST_PP_VARIADIC_SIZE issue of some boost macro has two
// different implementation // different implementation
#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE(_Ob) \ #define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE(_Ob) \
namespace boost { namespace serialization { \ namespace boost { \
template <class ArchiveT> void serialize (ArchiveT &ar, _Ob &ob, const unsigned int version); \ namespace serialization { \
template <class ArchiveT> void serialize_parents (ArchiveT &ar, _Ob &ob, const unsigned int version); \ template <class ArchiveT> \
template <> struct access2< _Ob > { template <class ArchiveT> static void save_override (ArchiveT &ar, _Ob &ob, const unsigned int version); }; }} void serialize(ArchiveT &ar, _Ob &ob, const unsigned int version); \
template <class ArchiveT> \
#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE(_Ob) \ void serialize_parents(ArchiveT &ar, _Ob &ob, const unsigned int version); \
namespace boost { namespace serialization { \ template <> struct access2<_Ob> { \
template <class ArchiveT> void serialize_parents(ArchiveT &ar, _Ob &ob, const unsigned int v) {} \ template <class ArchiveT> \
template <class ArchiveT> void serialize (ArchiveT &ar, _Ob &ob, const unsigned int version) { \ static void save_override(ArchiveT &ar, _Ob &ob, \
serialize_parents(ar,ob,version); \ const unsigned int version); \
access2< _Ob >::save_override(ar,ob,version); } }}\ }; \
ULIB_CLASS_EXPORT_IMPLEMENT(_Ob) \ } \
BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP,_Ob,_SERIALIZE_IMPL_SEQ)\ }
template <class ArchiveT> void boost::serialization::access2< _Ob >::save_override(ArchiveT &ar, _Ob &ob, const unsigned int version)
#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_DERIVED(_Ob,...) \
namespace boost { namespace serialization { \
template <class ArchiveT> void serialize_parents(ArchiveT &ar, _Ob &ob, const unsigned int v) { \
BOOST_PP_IF(BOOST_PP_VARIADIC_SIZE((__VA_ARGS__)),BOOST_PP_SEQ_FOR_EACH(_UNAR_OP,ob,BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__)));,) } \
template <class ArchiveT> void serialize (ArchiveT &ar, _Ob &ob, const unsigned int version) { \
serialize_parents(ar,ob,version); \
access2< _Ob >::save_override (ar,ob,version); } }}\
ULIB_CLASS_EXPORT_IMPLEMENT(_Ob) \
BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP,_Ob,_SERIALIZE_IMPL_SEQ) \
BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE_OP,_Ob,BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__))) \
template <class ArchiveT> void boost::serialization::access2< _Ob >::save_override(ArchiveT &ar, _Ob &ob, const unsigned int version)
#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE_OBJECT(_Ob) \
namespace boost { namespace serialization { \
template <class ArchiveT> void serialize (ArchiveT &ar, _Ob &ob, const unsigned int version); \
template <class ArchiveT> void serialize_parents (ArchiveT &ar, _Ob &ob, const unsigned int version); \
template <> struct access2< _Ob > { template <class ArchiveT> static void save_override (ArchiveT &ar, _Ob &ob, const unsigned int version); }; \
template <class ArchiveT> void serialize (ArchiveT &ar, class _Ob::ObjectProps &ob, const unsigned int version); \
template <class ArchiveT> void save_override (ArchiveT &ar, class _Ob::ObjectProps &ob, const unsigned int version); }}
#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_OBJECT(_Ob,...) \
namespace boost { namespace serialization { \
template <class ArchiveT> void serialize_parents(ArchiveT &ar, _Ob &ob, const unsigned int v) { \
/* PP serialize */ BOOST_PP_SEQ_FOR_EACH(_UNAR_OP,ob,BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__))); \
/* MPL serialize */ /*uLib::mpl::for_each<_Ob::BaseList>(uLib::detail::Serializable::serialize_baseobject<_Ob,ArchiveT>(ob,ar) );*/ } \
template<class ArchiveT> inline void load_construct_data(ArchiveT & ar, _Ob *ob, const unsigned int file_version) { \
::new(ob)_Ob(); uLib::detail::ObjectProps::initializer::init_object(ob); } \
template <class ArchiveT> void serialize (ArchiveT &ar, _Ob &ob, const unsigned int version) { \
void_cast_register<_Ob,_Ob::BaseClass>(static_cast<_Ob *>(NULL),static_cast<_Ob::BaseClass *>(NULL)); /*fix*/ \
serialize_parents(ar,ob,version); \
access2< _Ob >::save_override (ar,ob,version); } }}\
ULIB_CLASS_EXPORT_IMPLEMENT(_Ob) \
BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE_OP,_Ob,BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__))) \
BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP,_Ob,_SERIALIZE_IMPL_SEQ)\
template <class ArchiveT> void boost::serialization::access2< _Ob >::save_override(ArchiveT &ar, _Ob &ob, const unsigned int version)
#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_PROPS(_Ob) \
namespace boost { namespace serialization { \
template <class ArchiveT> void serialize (ArchiveT &ar, _Ob::ObjectProps &ob, const unsigned int version) { \
save_override (ar,ob,version); } }}\
BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP,_Ob::ObjectProps,_SERIALIZE_IMPL_SEQ)\
ULIB_CLASS_EXPORT_IMPLEMENT(_Ob::ObjectProps) \
ULIB_CLASS_EXPORT_IMPLEMENT(uLib::ObjectPropsImpl<_Ob>) \
template <class ArchiveT> void boost::serialization::save_override(ArchiveT &ar, _Ob::ObjectProps &ob, const unsigned int version)
#define _ULIB_DETAIL_UNINTRUSIVE_AR_(name) boost::serialization::make_nvp(BOOST_PP_STRINGIZE(name),ob.name)
#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE(_Ob) \
namespace boost { \
namespace serialization { \
template <class ArchiveT> \
void serialize_parents(ArchiveT &ar, _Ob &ob, const unsigned int v) {} \
template <class ArchiveT> \
void serialize(ArchiveT &ar, _Ob &ob, const unsigned int version) { \
serialize_parents(ar, ob, version); \
access2<_Ob>::save_override(ar, ob, version); \
} \
} \
} \
ULIB_CLASS_EXPORT_IMPLEMENT(_Ob) \
BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP, _Ob, \
_SERIALIZE_IMPL_SEQ) \
template <class ArchiveT> \
void boost::serialization::access2<_Ob>::save_override( \
ArchiveT &ar, _Ob &ob, const unsigned int version)
#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_DERIVED(_Ob, ...) \
namespace boost { \
namespace serialization { \
template <class ArchiveT> \
void serialize_parents(ArchiveT &ar, _Ob &ob, const unsigned int v) { \
BOOST_PP_IF(BOOST_PP_VARIADIC_SIZE((__VA_ARGS__)), \
BOOST_PP_SEQ_FOR_EACH(_UNAR_OP, ob, \
BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__))); \
, ) \
} \
template <class ArchiveT> \
void serialize(ArchiveT &ar, _Ob &ob, const unsigned int version) { \
serialize_parents(ar, ob, version); \
access2<_Ob>::save_override(ar, ob, version); \
} \
} \
} \
ULIB_CLASS_EXPORT_IMPLEMENT(_Ob) \
BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP, _Ob, \
_SERIALIZE_IMPL_SEQ) \
BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE_OP, _Ob, \
BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__))) \
template <class ArchiveT> \
void boost::serialization::access2<_Ob>::save_override( \
ArchiveT &ar, _Ob &ob, const unsigned int version)
#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE_OBJECT(_Ob) \
namespace boost { \
namespace serialization { \
template <class ArchiveT> \
void serialize(ArchiveT &ar, _Ob &ob, const unsigned int version); \
template <class ArchiveT> \
void serialize_parents(ArchiveT &ar, _Ob &ob, const unsigned int version); \
template <> struct access2<_Ob> { \
template <class ArchiveT> \
static void save_override(ArchiveT &ar, _Ob &ob, \
const unsigned int version); \
}; \
} \
}
#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_OBJECT(_Ob, ...) \
namespace boost { \
namespace serialization { \
template <class ArchiveT> \
void serialize_parents(ArchiveT &ar, _Ob &ob, const unsigned int v) { \
/* PP serialize */ BOOST_PP_SEQ_FOR_EACH( \
_UNAR_OP, ob, BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__))); \
/* MPL serialize */ /*uLib::mpl::for_each<_Ob::BaseList>(uLib::detail::Serializable::serialize_baseobject<_Ob,ArchiveT>(ob,ar) );*/ } \
template <class ArchiveT> \
inline void load_construct_data(ArchiveT &ar, _Ob *ob, \
const unsigned int file_version) { \
::new (ob) _Ob(); \
} \
template <class ArchiveT> \
void serialize(ArchiveT &ar, _Ob &ob, const unsigned int version) { \
void_cast_register<_Ob, _Ob::BaseClass>( \
static_cast<_Ob *>(NULL), \
static_cast<_Ob::BaseClass *>(NULL)); /*fix*/ \
serialize_parents(ar, ob, version); \
access2<_Ob>::save_override(ar, ob, version); \
} \
} \
} \
ULIB_CLASS_EXPORT_IMPLEMENT(_Ob) \
BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE_OP, _Ob, \
BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__))) \
BOOST_PP_SEQ_FOR_EACH(_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_FUNC_OP, _Ob, \
_SERIALIZE_IMPL_SEQ) \
template <class ArchiveT> \
void boost::serialization::access2<_Ob>::save_override( \
ArchiveT &ar, _Ob &ob, const unsigned int version)
#define _ULIB_DETAIL_UNINTRUSIVE_AR_(name) \
boost::serialization::make_nvp(BOOST_PP_STRINGIZE(name), ob.name)
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
namespace detail { namespace detail {
struct Serializable { struct Serializable {
/** /**
* Serializable trait to check if an object type is serializable. * Serializable trait to check if an object type is serializable.
* This only works if UNINTRUSIVE SERIALIZATION is applyed; in intrusive * This only works if UNINTRUSIVE SERIALIZATION is applyed; in intrusive
* cases a has_serialize trait should be implemented * cases a has_serialize trait should be implemented
*/ */
template <class T> template <class T> struct serializable_trait : mpl::bool_<false> {};
struct serializable_trait : mpl::bool_<false> {};
/**
* IsA Serializable Implementation Template
*/
template <class T>
struct IsA : serializable_trait<T> {};
template <class ThisClass, class Archive>
struct serialize_baseobject {
ThisClass & m_object;
Archive & m_ar;
serialize_baseobject(ThisClass &o, Archive &ar) : m_object(o), m_ar(ar) {}
template <class T> void operator()(T &o) {
m_ar & boost::serialization::make_nvp(
typeid(T).name() ,
boost::serialization::base_object<T>(m_object));
}
};
/**
* IsA Serializable Implementation Template
*/
template <class T> struct IsA : serializable_trait<T> {};
template <class ThisClass, class Archive> struct serialize_baseobject {
ThisClass &m_object;
Archive &m_ar;
serialize_baseobject(ThisClass &o, Archive &ar) : m_object(o), m_ar(ar) {}
template <class T> void operator()(T &o) {
m_ar &boost::serialization::make_nvp(
typeid(T).name(), boost::serialization::base_object<T>(m_object));
}
};
}; };
} // namespace detail
} // detail
struct Serializable { struct Serializable {
friend class boost::serialization::access; friend class boost::serialization::access;
template <class T> friend class boost::serialization::access2; template <class T> friend class boost::serialization::access2;
virtual ~Serializable() {} virtual ~Serializable() {}
protected: protected:
}; };
} // namespace uLib
} // uLib
#endif // U_SERIALIZABLE_H #endif // U_SERIALIZABLE_H

279
src/Core/Types.h
View File

@@ -23,8 +23,6 @@
//////////////////////////////////////////////////////////////////////////////*/ //////////////////////////////////////////////////////////////////////////////*/
#ifndef U_CORE_TYPES_H #ifndef U_CORE_TYPES_H
#define U_CORE_TYPES_H #define U_CORE_TYPES_H
@@ -33,253 +31,182 @@
#include <boost/preprocessor.hpp> #include <boost/preprocessor.hpp>
//#include <ltk/ltktypes.h> // #include <ltk/ltktypes.h>
#include "Core/Macros.h" #include "Core/Macros.h"
#include "Core/Mpl.h" #include "Core/Mpl.h"
namespace uLib { namespace uLib {
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
namespace detail { namespace detail {
struct TypeIntrospection { struct TypeIntrospection {
// BOOST IMPL // // BOOST IMPL //
BOOST_MPL_HAS_XXX_TRAIT_DEF(type_info) BOOST_MPL_HAS_XXX_TRAIT_DEF(type_info)
// SFINAE IMPL // // SFINAE IMPL //
/* /*
template <typename T> template <typename T>
struct has_type_info { struct has_type_info {
typedef char yes[1]; typedef char yes[1];
typedef char no[2]; typedef char no[2];
template <typename U> static yes& test(typename U::type_info::BaseList*); template <typename U> static yes& test(typename U::type_info::BaseList*);
template <typename > static no& test(...); template <typename > static no& test(...);
// struct apply { // struct apply {
static const bool value = sizeof(test<T>(0)) == sizeof(yes); static const bool value = sizeof(test<T>(0)) == sizeof(yes);
typedef boost::mpl::bool_<value> type; typedef boost::mpl::bool_<value> type;
// }; // };
}; };
*/ */
/** IsA Introspectable Object Implementation Template */ /** IsA Introspectable Object Implementation Template */
template <class T> template <class T> struct IsIntrospectable : has_type_info<T> {};
struct IsIntrospectable : has_type_info<T> {};
template <typename T> struct access { template <typename T> struct access {
typedef typename T::type_info type_info; typedef typename T::type_info type_info;
};
template <typename T> struct child_first_impl {
template <class T1, bool cond> struct lambda_CFList_f {
typedef mpl::vector<T1> type;
}; };
template <typename T> template <class T1> struct lambda_CFList_f<T1, true> {
struct child_first_impl { // typedef typename T1::type_info::CFList type;
typedef typename access<T1>::type_info::CFList type;
template <class T1, bool cond>
struct lambda_CFList_f {
typedef mpl::vector<T1> type;
};
template <class T1>
struct lambda_CFList_f<T1,true> {
// typedef typename T1::type_info::CFList type;
typedef typename access<T1>::type_info::CFList type;
};
template <class T1>
struct lambda_CFList : lambda_CFList_f<T1, has_type_info<T1>::value> {};
/** Transforms all Base Type into proper CFList */
typedef typename mpl::transform_view < typename access<T>::type_info::BaseList
, lambda_CFList<mpl::_>
>::type CFListSeq;
/** Folds each CFList into a new sequence */
typedef typename mpl::fold< CFListSeq
, mpl::vector<>
, mpl::copy< mpl::_1
, mpl::back_inserter<mpl::_2>
>
>::type Childs;
/** Add This Class to final CFList sequence */
typedef typename mpl::copy< Childs
, mpl::back_inserter< mpl::vector<T> >
>::type type;
}; };
template <class T1>
struct lambda_CFList : lambda_CFList_f<T1, has_type_info<T1>::value> {};
/** /** Transforms all Base Type into proper CFList */
* Tests if T has a member called type_info then compile type CFList typedef
*/ typename mpl::transform_view<typename access<T>::type_info::BaseList,
template <typename T> lambda_CFList<mpl::_>>::type CFListSeq;
struct child_first : mpl::if_< has_type_info<T>
, child_first_impl<T>
, mpl::vector<>
>::type {};
/** Folds each CFList into a new sequence */
typedef typename mpl::fold<
CFListSeq, mpl::vector<>,
mpl::copy<mpl::_1, mpl::back_inserter<mpl::_2>>>::type Childs;
/** Add This Class to final CFList sequence */
typedef typename mpl::copy<Childs, mpl::back_inserter<mpl::vector<T>>>::type
type;
};
/**
* Tests if T has a member called type_info then compile type CFList
*/
template <typename T>
struct child_first
: mpl::if_<has_type_info<T>, child_first_impl<T>, mpl::vector<>>::type {};
}; };
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// TYPE ADAPTERS // FINIRE !!! // TYPE ADAPTERS // FINIRE !!!
//#define _REPETITION_V(vz,vn,vdata) // #define _REPETITION_V(vz,vn,vdata)
//template < class TypeList >
//class TypeAdapterInputInterface {
// virtual ~TypeAdapterInputInterface() {}
//public:
// template < class TypeList >
// class TypeAdapterInputInterface {
// virtual ~TypeAdapterInputInterface() {}
// public:
// virtual void operator()(int val) {} // virtual void operator()(int val) {}
// virtual void operator()(std::string val) {} // virtual void operator()(std::string val) {}
//}; //};
} // namespace detail
} // detail ////////////////////////////////////////////////////////////////////
#define CONSTEXPR BOOST_CONSTEXPR #define CONSTEXPR BOOST_CONSTEXPR
// typedef ltk::Real_t Real_t;
//typedef ltk::Real_t Real_t;
#ifndef LTK_DOUBLE_PRECISION #ifndef LTK_DOUBLE_PRECISION
typedef float Real_t; typedef float Real_t;
#else #else
typedef double Real_t; typedef double Real_t;
#endif #endif
//typedef ltk::Id_t Id_t; // typedef ltk::Id_t Id_t;
typedef id_t Id_t; typedef id_t Id_t;
////typedef ltk::Size_t Size_t; ////typedef ltk::Size_t Size_t;
//typedef ltk::Pointer_t Pointer_t; // typedef ltk::Pointer_t Pointer_t;
typedef void * Pointer_t; typedef void *Pointer_t;
typedef bool Bool_t; //Boolean (0=false, 1=true) (bool) typedef bool Bool_t; // Boolean (0=false, 1=true) (bool)
//--- bit manipulation --------------------------------------------------------- //--- bit manipulation ---------------------------------------------------------
#ifndef BIT #ifndef BIT
#define BIT(n) (1ULL << (n)) #define BIT(n) (1ULL << (n))
#endif #endif
#ifndef SETBIT #ifndef SETBIT
#define SETBIT(n,i) ((n) |= BIT(i)) #define SETBIT(n, i) ((n) |= BIT(i))
#endif #endif
#ifndef CLRBIT #ifndef CLRBIT
#define CLRBIT(n,i) ((n) &= ~BIT(i)) #define CLRBIT(n, i) ((n) &= ~BIT(i))
#endif #endif
#ifndef TESTBIT #ifndef TESTBIT
#define TESTBIT(n,i) ((Bool_t)(((n) & BIT(i)) != 0)) #define TESTBIT(n, i) ((Bool_t)(((n) & BIT(i)) != 0))
#endif #endif
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// TYPE INTROSPECTION FOR OBJECTS // // TYPE INTROSPECTION FOR OBJECTS //
#define uLibTypeMacro(thisClass, ...) \
\
#define uLibTypeMacro(thisClass,...) \ /* Friendship detail for accessing introspection */ \
\ template <typename> friend class uLib::detail::TypeIntrospection::access; \
/* Friendship detail for accessing introspection */ \ \
template <typename> friend class uLib::detail::TypeIntrospection::access; \ /* type info structure*/ public: \
\ /* in GCC 4.8 must be public or dynamic_cast wont work */ \
/* type info structure*/ public: \ struct type_info { \
/* in GCC 4.8 must be public or dynamic_cast wont work */ \ /*WARNING: -std=c++0x required for this! */ \
struct type_info { \ constexpr static const char *name = BOOST_PP_STRINGIZE(thisClass); \
/*WARNING: -std=c++0x required for this! */ \ typedef BOOST_PP_VARIADIC_ELEM(0, __VA_ARGS__) BaseClass; \
constexpr static const char *name = BOOST_PP_STRINGIZE(thisClass); \ typedef thisClass ThisClass; \
typedef BOOST_PP_VARIADIC_ELEM(0,__VA_ARGS__) BaseClass; \ typedef uLib::mpl::vector<__VA_ARGS__, thisClass> TypeList; \
typedef thisClass ThisClass; \ typedef uLib::mpl::vector<__VA_ARGS__> BaseList; \
typedef uLib::mpl::vector<__VA_ARGS__,thisClass> TypeList; \ typedef uLib::detail::TypeIntrospection::child_first<ThisClass>::type \
typedef uLib::mpl::vector<__VA_ARGS__> BaseList; \ CFList; \
typedef uLib::detail::TypeIntrospection::child_first<ThisClass>::type CFList; \ }; \
}; \ \
\ public: \
public: \ typedef type_info::BaseClass BaseClass; \
typedef type_info::BaseClass BaseClass; \ virtual const char *type_name() const { return type_info::name; } \
virtual const char *type_name() const { return type_info::name; } \ /**/
/* Object Props fwd declaration*/ \
struct ObjectProps; \
/**/
/** /**
* TypeList inheritance introspection * TypeList inheritance introspection
*/ */
struct TypeIntrospection { struct TypeIntrospection {
template <typename T> template <typename T>
struct child_first : detail::TypeIntrospection::child_first<T> {}; struct child_first : detail::TypeIntrospection::child_first<T> {};
}; };
// SISTEMARE // // SISTEMARE //
struct PrintTypeId { struct PrintTypeId {
template <class T> template <class T> void operator()(T) const {
void operator()(T) const std::cout << typeid(T).name() << std::endl;
{ std::cout << typeid(T).name() << std::endl; } }
template <typename SeqT> template <typename SeqT> static void PrintMplSeq(SeqT *p = NULL) {
static void PrintMplSeq(SeqT *p = NULL) { boost::mpl::for_each<SeqT>(PrintTypeId()); } boost::mpl::for_each<SeqT>(PrintTypeId());
}
template <typename Class> template <typename Class> static void PrintType(Class *p = NULL) {
static void PrintType(Class *p = NULL) { std::cout << typeid(Class).name() << std::endl; } std::cout << typeid(Class).name() << std::endl;
}
}; };
} // namespace uLib
} // uLib
#endif // U_CORE_TYPES_H #endif // U_CORE_TYPES_H

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

@@ -16,7 +16,6 @@ set( TESTS
SerializeTest SerializeTest
SerializeDreadDiamondTest SerializeDreadDiamondTest
DreadDiamondParameters DreadDiamondParameters
ObjectPropableTest
UuidTest UuidTest
TypeIntrospectionTraversal TypeIntrospectionTraversal
OptionsTest OptionsTest

1
src/Core/testing/Makefile.am
View File

@@ -19,7 +19,6 @@ TESTS = SmartPointerTest \
SerializeTest \ SerializeTest \
SerializeDreadDiamondTest \ SerializeDreadDiamondTest \
DreadDiamondParameters \ DreadDiamondParameters \
ObjectPropableTest \
TypeIntrospectionTraversal \ TypeIntrospectionTraversal \
OptionsTest OptionsTest

237
src/Core/testing/ObjectPropableTest.cpp
View File

@@ -1,237 +0,0 @@
/*//////////////////////////////////////////////////////////////////////////////
// CMT Cosmic Muon Tomography project //////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
All rights reserved
Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
------------------------------------------------------------------
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 3.0 of the License, or (at your option) any later version.
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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library.
//////////////////////////////////////////////////////////////////////////////*/
#include <iostream>
#include <fstream>
#include <typeinfo>
#include <string>
#include "Core/Types.h"
#include "Core/Object.h"
#include "Core/ObjectProps.h"
#include "Core/StringReader.h"
#include "Math/Dense.h"
#include "boost/archive/text_oarchive.hpp"
#include "boost/archive/text_iarchive.hpp"
#include "testing-prototype.h"
using namespace uLib;
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// STRUCTURES //
struct A : virtual Object {
uLibTypeMacro(A, Object)
properties() {
int p_a;
Vector3f p_3f;
};
int m_a;
};
void A::init_properties() {
$_init();
$$.p_a = 0;
$$.p_3f << 1,2,3;
}
ULIB_SERIALIZABLE_OBJECT(A)
ULIB_SERIALIZE_OBJECT(A, Object) { ar & AR(m_a); }
ULIB_SERIALIZE_OBJECT_PROPS(A) { ar & AR(p_a) & AR(p_3f); }
struct B : A {
uLibTypeMacro(B,A)
properties() {
std::string p;
};
B() : m_b(324) {}
int m_b;
};
void B::init_properties() {
$_init();
$$.p = "ciao";
}
ULIB_SERIALIZABLE_OBJECT(B)
ULIB_SERIALIZE_OBJECT(B,A) { ar & AR(m_b); }
ULIB_SERIALIZE_OBJECT_PROPS(B) { ar & AR(p); }
struct C {
int m_c;
std::string m_str;
};
ULIB_SERIALIZABLE(C)
ULIB_SERIALIZE(C) { ar & AR(m_c) & AR(m_str); }
struct D : virtual Object, B {
uLibTypeMacro(D,Object,B)
properties() {
C p_c;
};
};
void D::init_properties() {
$_init();
$$.p_c.m_c = 1234;
}
ULIB_SERIALIZABLE_OBJECT(D)
ULIB_SERIALIZE_OBJECT(D,Object) {}
ULIB_SERIALIZE_OBJECT_PROPS(D) {
ar & AR(p_c);
}
class E : public C, public D {
uLibTypeMacro(E,D,C)
public:
E() : m_Ea(5552368) {}
int m_Ea;
};
ULIB_SERIALIZABLE_OBJECT(E)
ULIB_SERIALIZE_OBJECT(E,C,D) {
ar & AR(m_Ea);
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// TESTS //
int test_xml_direct() {
// TEST ARCHIVE SAVE AND LOAD direct //
E o; o.init_properties();
o.$$.p_c.m_str = "works";
{
std::ofstream file("test.xml");
Archive::xml_oarchive ar(file);
ar << NVP(o);
}
o.$$.p_c.m_str = "hola";
{
std::ifstream file("test.xml");
Archive::xml_iarchive ar(file);
ar >> NVP(o);
}
std::cout << o.$$.p_c.m_str << "\n";
return ( o.$$.p_c.m_str == "works" );
}
int test_xml_pointer() {
// TEST ARCHIVE SAVE AND LOAD from pointer //
E *o = new E; o->init_properties();
o->$$.p_c.m_str = "works";
{
std::ofstream file("test.xml");
Archive::xml_oarchive ar(file);
ar << NVP(o);
}
o->$$.p_c.m_str = "hola";
{
std::ifstream file("test.xml");
Archive::xml_iarchive ar(file);
ar >> NVP(o);
}
std::cout << o->$$.p_c.m_str << "\n";
return ( o->$$.p_c.m_str == "works" );
}
int test_xml_objsave() {
// TEST SELF SAVE
E o; o.init_properties();
o.$(B).p = "works";
{
std::ofstream file("test.xml");
Object::SaveXml(file,o);
}
o.$(B).p = "hola";
{
std::ifstream file("test.xml");
Object::LoadXml(file,o);
}
std::cout << o.$(B).p << "\n";
return ( o.$(B).p == "works" );
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// MAIN //
int main()
{
BEGIN_TESTING(PropableTest);
TEST1( test_xml_direct() );
TEST1( test_xml_pointer() );
TEST1( test_xml_objsave() );
END_TESTING;
}

216
src/Math/Dense.h
View File

@@ -23,9 +23,6 @@
//////////////////////////////////////////////////////////////////////////////*/ //////////////////////////////////////////////////////////////////////////////*/
/* /*
* <one line to give the program's name and a brief idea of what it does.> * <one line to give the program's name and a brief idea of what it does.>
* Copyright (C) 2012 Andrea Rigoni Garola <andrea@pcimg05> * Copyright (C) 2012 Andrea Rigoni Garola <andrea@pcimg05>
@@ -47,7 +44,6 @@
* *
*/ */
#ifndef ULIB_DENSEMATRIX_H #ifndef ULIB_DENSEMATRIX_H
#define ULIB_DENSEMATRIX_H #define ULIB_DENSEMATRIX_H
@@ -55,27 +51,29 @@
#include <Eigen/Dense> #include <Eigen/Dense>
//// BOOST SERIALIZATION /////////////////////////////////////////////////////// //// BOOST SERIALIZATION ///////////////////////////////////////////////////////
#include <boost/algorithm/string.hpp> #include <boost/algorithm/string.hpp>
#include <boost/algorithm/string/split.hpp> #include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/trim.hpp> #include <boost/algorithm/string/trim.hpp>
#include <boost/lexical_cast.hpp> #include <boost/lexical_cast.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/array.hpp> #include <boost/serialization/array.hpp>
#include <boost/serialization/string.hpp>
namespace boost { namespace boost {
namespace serialization { namespace serialization {
template<class Archive, class Scalar, int RowsAtCompileTime, int ColsAtCompileTime> template <class Archive, class Scalar, int RowsAtCompileTime,
void serialize(Archive & ar, ::Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime> & m, const unsigned int /*version*/) { int ColsAtCompileTime>
ar & boost::serialization::make_array(m.data(), RowsAtCompileTime * ColsAtCompileTime); void serialize(Archive &ar,
::Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime> &m,
const unsigned int /*version*/) {
ar &boost::serialization::make_array(m.data(),
RowsAtCompileTime * ColsAtCompileTime);
} }
} // serialization } // namespace serialization
} // boost } // namespace boost
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
@@ -84,177 +82,163 @@ void serialize(Archive & ar, ::Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCo
// this is needed by boost::lexical_cast to cope with Eigens Vectors /////////// // this is needed by boost::lexical_cast to cope with Eigens Vectors ///////////
namespace Eigen { namespace Eigen {
template <typename T, int size> template <typename T, int size>
std::istream & operator >> (std::istream &is, Eigen::Matrix<T,size,1> &vec) { std::istream &operator>>(std::istream &is, Eigen::Matrix<T, size, 1> &vec) {
std::string str; std::string str;
for( unsigned int i=0; i<size; i++) { for (unsigned int i = 0; i < size; i++) {
is >> std::skipws; is >> std::skipws;
is >> str; is >> str;
if(is.fail()) vec(i) = 0; if (is.fail())
else vec(i) = boost::lexical_cast<T>(str); vec(i) = 0;
} else
return is; vec(i) = boost::lexical_cast<T>(str);
}
return is;
} }
template <typename T, int size> template <typename T, int size>
std::ostream & operator << (std::ostream &os, const Eigen::Matrix<T,size,1> &vec) { std::ostream &operator<<(std::ostream &os,
os << vec.transpose(); const Eigen::Matrix<T, size, 1> &vec) {
return os; os << vec.transpose();
return os;
} }
} // Eigen } // namespace Eigen
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
namespace uLib { namespace uLib {
typedef id_t Id_t; typedef id_t Id_t;
typedef int Scalari; typedef int Scalari;
typedef unsigned int Scalarui; typedef unsigned int Scalarui;
typedef long Scalarl; typedef long Scalarl;
typedef unsigned long Scalarul; typedef unsigned long Scalarul;
typedef float Scalarf; typedef float Scalarf;
typedef double Scalard; typedef double Scalard;
typedef Eigen::Matrix<int, 1, 1> Matrix1i;
typedef Eigen::Matrix<int,1,1> Matrix1i;
typedef Eigen::Matrix2i Matrix2i; typedef Eigen::Matrix2i Matrix2i;
typedef Eigen::Matrix3i Matrix3i; typedef Eigen::Matrix3i Matrix3i;
typedef Eigen::Matrix4i Matrix4i; typedef Eigen::Matrix4i Matrix4i;
typedef Eigen::Matrix<float,1,1> Matrix1f; typedef Eigen::Matrix<float, 1, 1> Matrix1f;
typedef Eigen::Matrix2f Matrix2f; typedef Eigen::Matrix2f Matrix2f;
typedef Eigen::Matrix3f Matrix3f; typedef Eigen::Matrix3f Matrix3f;
typedef Eigen::Matrix4f Matrix4f; typedef Eigen::Matrix4f Matrix4f;
typedef Eigen::Matrix<int,1,1> Vector1i; typedef Eigen::Matrix<int, 1, 1> Vector1i;
typedef Eigen::Vector2i Vector2i; typedef Eigen::Vector2i Vector2i;
typedef Eigen::Vector3i Vector3i; typedef Eigen::Vector3i Vector3i;
typedef Eigen::Vector4i Vector4i; typedef Eigen::Vector4i Vector4i;
typedef Eigen::Matrix<float,1,1> Vector1f; typedef Eigen::Matrix<float, 1, 1> Vector1f;
typedef Eigen::Vector2f Vector2f; typedef Eigen::Vector2f Vector2f;
typedef Eigen::Vector3f Vector3f; typedef Eigen::Vector3f Vector3f;
typedef Eigen::Vector4f Vector4f; typedef Eigen::Vector4f Vector4f;
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// Vector String interaction /////////////////////////////////////////////////// // Vector String interaction ///////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
/*! Given a string consisting of a series of doubles with some /*! Given a string consisting of a series of doubles with some
* delimiter, return an Eigen::Vector populated with those * delimiter, return an Eigen::Vector populated with those
* values, in the same order as they are given in the string. * values, in the same order as they are given in the string.
* *
* \param vec A double vector to be populated with the results * \param vec A double vector to be populated with the results
* \param str A string to be parsed as a series of doubles. * \param str A string to be parsed as a series of doubles.
* \param delim Delimiters of the text (a typical default is " ," for comma and space-delimited text * \param delim Delimiters of the text (a typical default is " ," for comma and
* * space-delimited text
*/ *
*/
template <typename T, int size> template <typename T, int size>
void VectorxT_StringTo(Eigen::Matrix<T,size,1> &vec, std::string str, const char *delim = " ,;\t\n") { void VectorxT_StringTo(Eigen::Matrix<T, size, 1> &vec, std::string str,
std::vector<std::string> strvec; const char *delim = " ,;\t\n") {
std::vector<std::string> strvec;
boost::algorithm::trim_if( str, boost::algorithm::is_any_of(delim)); boost::algorithm::trim_if(str, boost::algorithm::is_any_of(delim));
boost::algorithm::split(strvec,str,boost::algorithm::is_any_of(delim), boost::algorithm::token_compress_on); boost::algorithm::split(strvec, str, boost::algorithm::is_any_of(delim),
boost::algorithm::token_compress_on);
for( unsigned int i=0; i<size; i++) { for (unsigned int i = 0; i < size; i++) {
vec(i) = boost::lexical_cast<T>(strvec[i]); vec(i) = boost::lexical_cast<T>(strvec[i]);
} }
} }
template <typename T, int size> template <typename T, int size>
std::string VectorxT_ToString(const Eigen::Matrix<T,size,1> &vec) { std::string VectorxT_ToString(const Eigen::Matrix<T, size, 1> &vec) {
std::stringstream sst; std::stringstream sst;
sst << vec.transpose(); sst << vec.transpose();
return sst.str(); return sst.str();
} }
// template <typename T, int size>
//template <typename T, int size> // Eigen::Matrix<T,size,1> & operator >> (std::istream &is,
//Eigen::Matrix<T,size,1> & operator >> (std::istream &is, Eigen::Matrix<T,size,1> &vec) { // Eigen::Matrix<T,size,1> &vec) {
//} // }
template <typename T, int size> template <typename T, int size>
void operator>> (std::string& str, Eigen::Matrix<T,size,1> &vec){ void operator>>(std::string &str, Eigen::Matrix<T, size, 1> &vec) {
VectorxT_StringTo(vec,str); VectorxT_StringTo(vec, str);
} }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
////// HOMOGENEOUS VECTORS ////////////////////////////////////////////////// ////// HOMOGENEOUS VECTORS //////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
template <bool p> template <bool p> class _HPoint3f : public Eigen::Matrix<Scalarf, 4, 1> {
class _HPoint3f : public Eigen::Matrix< Scalarf,4,1 > {
public: public:
typedef Eigen::Matrix< Scalarf,4,1 > BaseClass; typedef Eigen::Matrix<Scalarf, 4, 1> BaseClass;
_HPoint3f<p>() : BaseClass(0,0,0,p) {} _HPoint3f() : BaseClass(0, 0, 0, p) {}
_HPoint3f<p>(float x,float y,float z) : BaseClass(x,y,z,p) {} _HPoint3f(float x, float y, float z) : BaseClass(x, y, z, p) {}
_HPoint3f<p>(Vector3f &in) : BaseClass(in.homogeneous()) { this->operator()(3) = p; } _HPoint3f(Vector3f &in) : BaseClass(in.homogeneous()) {
this->operator()(3) = p;
}
void operator delete(void* _p, size_t _s) {} void operator delete(void *_p, size_t _s) {}
// This constructor allows to construct MyVectorType from Eigen expressions // This constructor allows to construct MyVectorType from Eigen expressions
template<typename OtherDerived> template <typename OtherDerived>
inline _HPoint3f<p>(const Eigen::MatrixBase<OtherDerived>& other) inline _HPoint3f(const Eigen::MatrixBase<OtherDerived> &other)
: BaseClass(other) : BaseClass(other) {}
{ }
// This method allows to assign Eigen expressions to Vector3H
template<typename OtherDerived>
inline _HPoint3f<p> & operator= (const Eigen::MatrixBase <OtherDerived>& other)
{
this->BaseClass::operator=(other);
return *this;
}
// This method allows to assign Eigen expressions to Vector3H
template <typename OtherDerived>
inline _HPoint3f &operator=(const Eigen::MatrixBase<OtherDerived> &other) {
this->BaseClass::operator=(other);
return *this;
}
}; };
typedef _HPoint3f<false> HVector3f; typedef _HPoint3f<false> HVector3f;
typedef _HPoint3f<true> HPoint3f; typedef _HPoint3f<true> HPoint3f;
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
////// HOMOGENEOUS LINE ////////////////////////////////////////////////// ////// HOMOGENEOUS LINE //////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
struct _HLine3f {
struct _HLine3f HPoint3f origin;
{ HVector3f direction;
HPoint3f origin;
HVector3f direction;
}; };
typedef struct _HLine3f HLine3f; typedef struct _HLine3f HLine3f;
inline std::ostream& inline std::ostream &operator<<(std::ostream &stream, const HLine3f &line) {
operator<< (std::ostream& stream, const HLine3f &line) { stream << "HLine3f(" << "pt[" << line.origin.transpose() << "] , dr["
stream << "HLine3f(" << "pt[" << line.origin.transpose() <<"] , dr[" << line.direction.transpose() << "]) "; << line.direction.transpose() << "]) ";
return stream; return stream;
} }
struct _HError3f {
HVector3f position_error;
HVector3f direction_error;
struct _HError3f
{
HVector3f position_error;
HVector3f direction_error;
}; };
typedef struct _HError3f HError3f; typedef struct _HError3f HError3f;
inline std::ostream& inline std::ostream &operator<<(std::ostream &stream, const HError3f &err) {
operator<< (std::ostream& stream, const HError3f &err) { stream << "HError3f(" << "ept[" << err.position_error.transpose()
stream << "HError3f(" << "ept[" << err.position_error.transpose() <<"] , edr[" << err.direction_error.transpose() << "]) "; << "] , edr[" << err.direction_error.transpose() << "]) ";
return stream; return stream;
}
} }
} // namespace uLib
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
@@ -268,13 +252,9 @@ ULIB_SERIALIZABLE(uLib::HPoint3f)
ULIB_SERIALIZABLE(uLib::HVector3f) ULIB_SERIALIZABLE(uLib::HVector3f)
ULIB_SERIALIZABLE(uLib::HLine3f) ULIB_SERIALIZABLE(uLib::HLine3f)
ULIB_SERIALIZABLE(uLib::HError3f) ULIB_SERIALIZABLE(uLib::HError3f)
#endif // ULIB_SERIALIZATION_ON #endif // ULIB_SERIALIZATION_ON
#endif // U_DENSEMATRIX_H
#endif // U_DENSEMATRIX_H

342
src/Math/VoxRaytracer.cpp
View File

@@ -23,11 +23,10 @@
//////////////////////////////////////////////////////////////////////////////*/ //////////////////////////////////////////////////////////////////////////////*/
#include <iostream> #include <iostream>
#include "VoxRaytracer.h"
#include "Utils.h" #include "Utils.h"
#include "VoxRaytracer.h"
#define unlikely(expr) __builtin_expect(!!(expr), 0) #define unlikely(expr) __builtin_expect(!!(expr), 0)
@@ -39,215 +38,206 @@ namespace uLib {
///// RAY DATA ///////////////////////////////////////////////////////////////// ///// RAY DATA /////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
void VoxRaytracer::RayData::AddElement(Id_t id, float L) void VoxRaytracer::RayData::AddElement(Id_t id, float L) {
{ Element el = {id, L};
Element el = {id, L}; m_Data.push_back(el);
m_Data.push_back(el); m_TotalLength += L;
m_TotalLength += L;
} }
void VoxRaytracer::RayData::AppendRay(const VoxRaytracer::RayData &in) {
void VoxRaytracer::RayData::AppendRay(const VoxRaytracer::RayData &in) if (unlikely(!in.m_Data.size())) {
{ std::cout << "Warinig: PoCA on exit border!\n";
if (unlikely(!in.m_Data.size())) { return;
std::cout << "Warinig: PoCA on exit border!\n"; } else if (unlikely(!m_Data.size())) {
return; m_Data = in.m_Data;
} std::cout << "Warinig: PoCA on entrance border!\n";
else if (unlikely(!m_Data.size())) { return;
m_Data = in.m_Data; } else {
std::cout << "Warinig: PoCA on entrance border!\n"; // Opzione 1) un voxel in piu' //
return; if (in.m_Data.size() > 0) {
} m_Data.insert(m_Data.end(), in.m_Data.begin(), in.m_Data.end());
else {
// Opzione 1) un voxel in piu' //
m_Data.reserve(m_Data.size() + in.m_Data.size());
m_Data.insert(m_Data.end(), in.m_Data.begin(), in.m_Data.end());
// Opzione 2) merge dei voxel nel poca.
// RayData::Element &e1 = m_Data.back();
// const RayData::Element &e2 = in.m_Data.front();
// if(e1.vox_id == e2.vox_id)
// {
// m_Data.reserve(m_Data.size() + in.m_Data.size() - 1);
// e1.L += e2.L; //fix//
// m_Data.insert(m_Data.end(), in.m_Data.begin()+1, in.m_Data.end());
// }
// else {
// m_Data.reserve(m_Data.size() + in.m_Data.size());
// m_Data.insert(m_Data.end(), in.m_Data.begin(), in.m_Data.end());
// }
m_TotalLength += in.m_TotalLength;
} }
// Opzione 2) merge dei voxel nel poca.
// RayData::Element &e1 = m_Data.back();
// const RayData::Element &e2 = in.m_Data.front();
// if(e1.vox_id == e2.vox_id)
// {
// m_Data.reserve(m_Data.size() + in.m_Data.size() - 1);
// e1.L += e2.L; //fix//
// m_Data.insert(m_Data.end(), in.m_Data.begin()+1,
// in.m_Data.end());
// }
// else {
// m_Data.reserve(m_Data.size() + in.m_Data.size());
// m_Data.insert(m_Data.end(), in.m_Data.begin(),
// in.m_Data.end());
// }
m_TotalLength += in.m_TotalLength;
}
} }
void VoxRaytracer::RayData::PrintSelf(std::ostream &o) void VoxRaytracer::RayData::PrintSelf(std::ostream &o) {
{ o << "Ray: total lenght " << m_TotalLength << "\n";
o << "Ray: total lenght " << m_TotalLength << "\n"; std::vector<Element>::iterator it;
std::vector<Element>::iterator it; for (it = m_Data.begin(); it < m_Data.end(); ++it)
for(it = m_Data.begin(); it < m_Data.end(); ++it) o << "[ " << (*it).vox_id << ", " << (*it).L << "] \n";
o << "[ " << (*it).vox_id << ", " << (*it).L << "] \n";
} }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
//// RAY TRACER //////////////////////////////////////////////////////////////// //// RAY TRACER ////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
bool VoxRaytracer::GetEntryPoint(const HLine3f &line, HPoint3f &pt) {
Vector4f s = m_Image->GetLocalPoint(line.direction);
pt = m_Image->GetLocalPoint(line.origin);
bool VoxRaytracer::GetEntryPoint(const HLine3f &line, HPoint3f &pt) // Considers Structured grid dimensions //
{ Vector4f dims = m_Image->GetDims().homogeneous().cast<float>();
Vector4f s = m_Image->GetLocalPoint(line.direction); pt = pt.cwiseQuotient(dims);
pt = m_Image->GetLocalPoint(line.origin); s = s.cwiseQuotient(dims);
// Considers Structured grid dimensions // float l = s.head(3).norm();
Vector4f dims = m_Image->GetDims().homogeneous().cast<float>(); Vector3f L(l / s(0), l / s(1), l / s(2));
pt = pt.cwiseQuotient(dims);
s = s.cwiseQuotient(dims);
float l = s.head(3).norm(); Vector3f offset;
Vector3f L(l/s(0), l/s(1), l/s(2)); for (int i = 0; i < 3; ++i)
offset(i) = (s(i) > 0) - (pt(i) - floor(pt(i)));
offset = offset.cwiseProduct(L).cwiseAbs();
Vector3f offset; int id;
for(int i=0;i<3;++i) float d;
offset(i) = (s(i)>0) - (pt(i)-floor(pt(i))) ; for (int loop = 0; loop < 8; loop++) {
offset = offset.cwiseProduct(L).cwiseAbs(); int check_border = 0;
for (int i = 0; i < 3; ++i) {
int id; float d; check_border += pt(i) > 1;
for(int loop=0; loop<8; loop++) check_border += pt(i) < 0;
{
int check_border = 0;
for ( int i=0; i<3 ;++i) {
check_border += pt(i) > 1;
check_border += pt(i) < 0;
}
if(check_border == 0) {
for(int i=0;i<3;++i)
pt(i) *= (float)dims(i);
pt = m_Image->GetWorldPoint(pt);
return true;
}
d = offset.minCoeff(&id);
for(int i=0; i<3; ++i)
pt(i) += d / L(i);
pt(id) = rintf(pt(id));
offset.array() -= d;
offset(id) = fabs(L(id));
} }
for(int i=0;i<3;++i) if (check_border == 0) {
for (int i = 0; i < 3; ++i)
pt(i) *= (float)dims(i); pt(i) *= (float)dims(i);
pt = m_Image->GetWorldPoint(pt); pt = m_Image->GetWorldPoint(pt);
return false; return true;
}
bool VoxRaytracer::GetExitPoint(const HLine3f &line, HPoint3f &pt)
{
HLine3f out = line;
out.direction *= -1;
return GetEntryPoint(out,pt);
}
VoxRaytracer::RayData VoxRaytracer::TraceBetweenPoints(const HPoint3f &in,
const HPoint3f &out)
const
{
RayData ray;
Vector4f pt1 = m_Image->GetLocalPoint(in);
Vector4f pt2 = m_Image->GetLocalPoint(out);
Vector4f s = pt2 - pt1;
float l = s.head(3).norm();
Vector3f L(l/s(0), l/s(1), l/s(2));
// Vector3f scale; // FIXXX
// scale << (m_Image->GetWorldMatrix() * Vector4f(1,0,0,0)).norm(),
// (m_Image->GetWorldMatrix() * Vector4f(0,1,0,0)).norm(),
// (m_Image->GetWorldMatrix() * Vector4f(0,0,1,0)).norm();
Vector3f offset;
for(int i=0;i<3;++i) offset(i) = (s(i)>=0) - (pt1(i)-floor(pt1(i))) ;
offset = offset.cwiseProduct(L).cwiseAbs();
L = L.cwiseAbs();
//---- Check if the ray only crosses one voxel
Vector3i vid = m_Image->Find(in);
if(vid == m_Image->Find(out)){
ray.AddElement(m_Image->Map(vid),s.norm());
return ray;
} }
//---- Otherwise, loop until ray is finished d = offset.minCoeff(&id);
int id; float d; for (int i = 0; i < 3; ++i)
while(l>0){ pt(i) += d / L(i);
d = offset.minCoeff(&id); pt(id) = rintf(pt(id));
if(m_Image->IsInsideGrid(vid)){ offset.array() -= d;
ray.AddElement(m_Image->Map(vid), d * m_scale(id) ); offset(id) = fabs(L(id));
} }
for (int i = 0; i < 3; ++i)
pt(i) *= (float)dims(i);
pt = m_Image->GetWorldPoint(pt);
return false;
}
// nan check // bool VoxRaytracer::GetExitPoint(const HLine3f &line, HPoint3f &pt) {
// if(unlikely(!isFinite(d * scale(id)))) { HLine3f out = line;
// std:: cout << "NAN in raytracer\n"; out.direction *= -1;
// exit(1); return GetEntryPoint(out, pt);
// } }
vid(id) += (int)fast_sign(s(id)); VoxRaytracer::RayData
VoxRaytracer::TraceBetweenPoints(const HPoint3f &in,
const HPoint3f &out) const {
RayData ray;
Vector4f pt1 = m_Image->GetLocalPoint(in);
Vector4f pt2 = m_Image->GetLocalPoint(out);
Vector4f s = pt2 - pt1;
l -= d; float l = s.head(3).norm();
offset.array() -= d; Vector3f L(l / s(0), l / s(1), l / s(2));
offset(id) = fmin(L(id),l);
} // Vector3f scale; // FIXXX
// scale << (m_Image->GetWorldMatrix() * Vector4f(1,0,0,0)).norm(),
// (m_Image->GetWorldMatrix() * Vector4f(0,1,0,0)).norm(),
// (m_Image->GetWorldMatrix() * Vector4f(0,0,1,0)).norm();
Vector3f offset;
for (int i = 0; i < 3; ++i)
offset(i) = (s(i) >= 0) - (pt1(i) - floor(pt1(i)));
offset = offset.cwiseProduct(L).cwiseAbs();
L = L.cwiseAbs();
//---- Check if the ray only crosses one voxel
Vector3i vid = m_Image->Find(in);
if (vid == m_Image->Find(out)) {
ray.AddElement(m_Image->Map(vid), s.norm());
return ray; return ray;
}
//---- Otherwise, loop until ray is finished
int id;
float d;
while (l > 0) {
d = offset.minCoeff(&id);
if (m_Image->IsInsideGrid(vid)) {
ray.AddElement(m_Image->Map(vid), d * m_scale(id));
}
// nan check //
// if(unlikely(!isFinite(d * scale(id)))) {
// std:: cout << "NAN in raytracer\n";
// exit(1);
// }
vid(id) += (int)fast_sign(s(id));
l -= d;
offset.array() -= d;
offset(id) = fmin(L(id), l);
}
return ray;
} }
// 20150528 SV for absorbed muons // 20150528 SV for absorbed muons
VoxRaytracer::RayData VoxRaytracer::TraceLine(const HLine3f &line) const VoxRaytracer::RayData VoxRaytracer::TraceLine(const HLine3f &line) const {
{ RayData ray;
RayData ray;
Vector4f pt = m_Image->GetLocalPoint(line.origin); Vector4f pt = m_Image->GetLocalPoint(line.origin);
Vector4f s = m_Image->GetLocalPoint(line.direction); Vector4f s = m_Image->GetLocalPoint(line.direction);
float l = s.head(3).norm(); float l = s.head(3).norm();
// intersection between track and grid when spacing is +1 // intersection between track and grid when spacing is +1
Vector3f L(l/s(0), l/s(1), l/s(2)); Vector3f L(l / s(0), l / s(1), l / s(2));
// RayTracer works with a grid of interspace +1 // RayTracer works with a grid of interspace +1
// Vector3f scale; // FIXXX // Vector3f scale; // FIXXX
// scale << (m_Image->GetWorldMatrix() * Vector4f(1,0,0,0)).norm(), // scale << (m_Image->GetWorldMatrix() * Vector4f(1,0,0,0)).norm(),
// (m_Image->GetWorldMatrix() * Vector4f(0,1,0,0)).norm(), // (m_Image->GetWorldMatrix() * Vector4f(0,1,0,0)).norm(),
// (m_Image->GetWorldMatrix() * Vector4f(0,0,1,0)).norm(); // (m_Image->GetWorldMatrix() * Vector4f(0,0,1,0)).norm();
// offset is the fraction of the segment between grid lines when origin is insiede voxel // offset is the fraction of the segment between grid lines when origin is
// cwiseAbs for having positive distances // insiede voxel cwiseAbs for having positive distances
Vector3f offset; Vector3f offset;
for(int i=0;i<3;++i) for (int i = 0; i < 3; ++i)
offset(i) = (s(i)>=0) - (pt(i)-floor(pt(i))); offset(i) = (s(i) >= 0) - (pt(i) - floor(pt(i)));
offset = offset.cwiseProduct(L).cwiseAbs(); offset = offset.cwiseProduct(L).cwiseAbs();
L = L.cwiseAbs(); L = L.cwiseAbs();
int id; float d; int id;
Vector3i vid = m_Image->Find(line.origin); float d;
while(m_Image->IsInsideGrid(vid)) Vector3i vid = m_Image->Find(line.origin);
{ while (m_Image->IsInsideGrid(vid)) {
// minimun coefficient of offset: id is the coordinate, d is the value // minimun coefficient of offset: id is the coordinate, d is the value
// dependig on which grid line horizontal or vertical it is first intercept // dependig on which grid line horizontal or vertical it is first intercept
d = offset.minCoeff(&id); d = offset.minCoeff(&id);
// add Lij to ray // add Lij to ray
ray.AddElement(m_Image->Map(vid), d * m_scale(id) ); ray.AddElement(m_Image->Map(vid), d * m_scale(id));
// move to the next voxel // move to the next voxel
vid(id) += (int)fast_sign(s(id)); vid(id) += (int)fast_sign(s(id));
offset.array() -= d; offset.array() -= d;
offset(id) = L(id); offset(id) = L(id);
} }
return ray; return ray;
} }
} } // namespace uLib

53
src/Root/Linkdef.h
View File

@@ -23,8 +23,6 @@
//////////////////////////////////////////////////////////////////////////////*/ //////////////////////////////////////////////////////////////////////////////*/
#ifndef U_ROOT_LINKDEF_H #ifndef U_ROOT_LINKDEF_H
#define U_ROOT_LINKDEF_H #define U_ROOT_LINKDEF_H
@@ -35,52 +33,21 @@
#pragma link off all functions; #pragma link off all functions;
#pragma link C++ nestedclasses; #pragma link C++ nestedclasses;
#pragma link C++ class TestTObject+;
using namespace ROOT::Mutom; using namespace ROOT::Mutom;
#pragma link C++ class ROOT::Math::Cartesian2D<int>+; #pragma link C++ class ROOT::Math::Cartesian3D < int> + ;
#pragma link C++ class ROOT::Math::Cartesian2D<float>+; #pragma link C++ class ROOT::Math::Cartesian3D < float> + ;
#pragma link C++ class ROOT::Math::Cartesian2D<double>+; #pragma link C++ class ROOT::Math::Cartesian3D < double> + ;
#pragma link C++ class ROOT::Math::Cartesian3D<int>+;
#pragma link C++ class ROOT::Math::Cartesian3D<float>+;
#pragma link C++ class ROOT::Math::Cartesian3D<double>+;
#pragma link C++ class Vector2i+;
#pragma link C++ class Vector2f+;
#pragma link C++ class Vector2d+;
#pragma link C++ class Vector3i+;
#pragma link C++ class Vector3f+;
#pragma link C++ class Vector3d+;
#pragma link C++ typedef Matrix3i;
#pragma link C++ typedef Matrix3f;
#pragma link C++ typedef Matrix3d;
#pragma link C++ class Line3f+;
#pragma link C++ class Line3d+;
#pragma link C++ class MuonTrack+;
#pragma link C++ class MuonScatter+;
#pragma link C++ function MuonScatter::p_mean() const;
// #pragma link C++ class DetectorChamber+; // #pragma link C++ class DetectorChamber+;
#pragma link C++ class HitRaw+; #pragma link C++ class muCastorMCTrack + ;
#pragma link C++ function HitRaw::Chm() const; #pragma link C++ class muCastorHit + ;
#pragma link C++ function HitRaw::Rob() const; #pragma link C++ class muCastorInfo + ;
#pragma link C++ function HitRaw::Tdc() const; #pragma link C++ class muCastorSkinHit + ;
#pragma link C++ function HitRaw::Ch() const; #pragma link C++ class muCastorPrimaryVertex + ;
#pragma link C++ class muCastorMuDetDIGI + ;
#pragma link C++ class muCastorMCTrack+; #pragma link C++ class SkinDetectorWriter + ;
#pragma link C++ class muCastorHit+;
#pragma link C++ class muCastorInfo+;
#pragma link C++ class muCastorSkinHit+;
#pragma link C++ class muCastorPrimaryVertex+;
#pragma link C++ class muCastorMuDetDIGI+;
#pragma link C++ class SkinDetectorWriter+;
#endif // __CINT__ #endif // __CINT__

2
uLib.files
View File

@@ -30,7 +30,6 @@ src/Core/testing/Flags.h
src/Core/testing/ObjectCopyTest.cpp src/Core/testing/ObjectCopyTest.cpp
src/Core/testing/ObjectFlagsTest.cpp src/Core/testing/ObjectFlagsTest.cpp
src/Core/testing/ObjectParametersTest.cpp src/Core/testing/ObjectParametersTest.cpp
src/Core/testing/ObjectPropableTest.cpp
src/Core/testing/OptionsTest.cpp src/Core/testing/OptionsTest.cpp
src/Core/testing/PropertiesTest.cpp src/Core/testing/PropertiesTest.cpp
src/Core/testing/SerializeDreadDiamondTest.cpp src/Core/testing/SerializeDreadDiamondTest.cpp
@@ -59,7 +58,6 @@ src/Core/Macros.h
src/Core/Mpl.h src/Core/Mpl.h
src/Core/Object.cpp src/Core/Object.cpp
src/Core/Object.h src/Core/Object.h
src/Core/ObjectProps.h
src/Core/Options.cpp src/Core/Options.cpp
src/Core/Options.h src/Core/Options.h
src/Core/Serializable.cpp src/Core/Serializable.cpp