refactor: reformat type introspection code and remove ObjectProps system.
This commit is contained in:
AndreaRigoni
@@ -14,7 +14,6 @@ library_include_HEADERS = \
|
||||
Macros.h \
|
||||
Mpl.h \
|
||||
Object.h \
|
||||
ObjectProps.h \
|
||||
Options.h \
|
||||
Serializable.h \
|
||||
Signal.h \
|
||||
|
||||
@@ -23,178 +23,126 @@
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////*/
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#include "config.h"
|
||||
|
||||
#include "Object.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_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 {
|
||||
|
||||
|
||||
const char *Version::PackageName = PACKAGE_NAME;
|
||||
const char *Version::PackageName = PACKAGE_NAME;
|
||||
const char *Version::VersionNumber = PACKAGE_VERSION;
|
||||
const char *Version::Release = "x"; //SVN_REVISION;
|
||||
|
||||
const char *Version::Release = "x"; // SVN_REVISION;
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Object Private //
|
||||
|
||||
class ObjectPrivate {
|
||||
public:
|
||||
struct Signal {
|
||||
GenericMFPtr sigptr;
|
||||
std::string sigstr;
|
||||
SignalBase *signal;
|
||||
};
|
||||
|
||||
struct Signal {
|
||||
GenericMFPtr sigptr;
|
||||
std::string sigstr;
|
||||
SignalBase *signal;
|
||||
};
|
||||
struct Slot {
|
||||
GenericMFPtr sloptr;
|
||||
std::string slostr;
|
||||
};
|
||||
|
||||
struct Slot {
|
||||
GenericMFPtr sloptr;
|
||||
std::string slostr;
|
||||
};
|
||||
|
||||
|
||||
Vector<Signal> sigv;
|
||||
Vector<Slot> slov;
|
||||
Vector<Signal> sigv;
|
||||
Vector<Slot> slov;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// OBJECT IMPLEMENTATION
|
||||
|
||||
Object::Object() : d(new ObjectPrivate) {}
|
||||
|
||||
Object::Object(const Object ©) : d(new ObjectPrivate(*copy.d)) {}
|
||||
|
||||
Object::Object() :
|
||||
d(new ObjectPrivate)
|
||||
{}
|
||||
Object::~Object() { delete d; }
|
||||
|
||||
Object::Object(const Object ©) :
|
||||
ObjectPropable(copy),
|
||||
d(new ObjectPrivate(*copy.d))
|
||||
{}
|
||||
|
||||
Object::~Object() {
|
||||
delete d;
|
||||
void Object::DeepCopy(const Object ©) {
|
||||
// should lock to be tread safe //
|
||||
memcpy(d, copy.d, sizeof(ObjectPrivate));
|
||||
// ERROR! does not copy parameters ... <<<< FIXXXXX
|
||||
}
|
||||
|
||||
void Object::DeepCopy(const Object ©)
|
||||
{
|
||||
// should lock to be tread safe //
|
||||
memcpy(d,copy.d,sizeof(ObjectPrivate));
|
||||
// ERROR! does not copy parameters ... <<<< FIXXXXX
|
||||
void Object::SaveXml(std::ostream &os, Object &ob) {
|
||||
Archive::xml_oarchive ar(os);
|
||||
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);
|
||||
}
|
||||
|
||||
void Object::LoadXml(std::istream &is, Object &ob)
|
||||
{
|
||||
Archive::xml_iarchive ar(is);
|
||||
ar >> boost::serialization::make_nvp("Object",ob);
|
||||
}
|
||||
|
||||
|
||||
// FINIRE
|
||||
void Object::SaveConfig(std::ostream &os, int version)
|
||||
{
|
||||
Archive::xml_oarchive ar(os);
|
||||
ObjectPropable::serialize(ar,0);
|
||||
void Object::SaveConfig(std::ostream &os, int version) {
|
||||
Archive::xml_oarchive ar(os);
|
||||
}
|
||||
|
||||
void Object::LoadConfig(std::istream &is, int version)
|
||||
{
|
||||
if(!props()) this->init_properties();
|
||||
Archive::xml_iarchive ar(is);
|
||||
ObjectPropable::serialize(ar,0);
|
||||
void Object::LoadConfig(std::istream &is, int version) {
|
||||
Archive::xml_iarchive ar(is);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
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++)
|
||||
{
|
||||
o << " signal:[ " << itr->sigstr << " ]\n";
|
||||
}
|
||||
o << "--------------------------------------\n\n";
|
||||
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++) {
|
||||
o << " signal:[ " << itr->sigstr << " ]\n";
|
||||
}
|
||||
o << "--------------------------------------\n\n";
|
||||
}
|
||||
|
||||
|
||||
bool Object::addSignalImpl(SignalBase *sig, GenericMFPtr fptr, const char *name)
|
||||
{
|
||||
ObjectPrivate::Signal s = {fptr,std::string(name),sig};
|
||||
d->sigv.push_back(s);
|
||||
bool Object::addSignalImpl(SignalBase *sig, GenericMFPtr fptr,
|
||||
const char *name) {
|
||||
ObjectPrivate::Signal s = {fptr, std::string(name), sig};
|
||||
d->sigv.push_back(s);
|
||||
}
|
||||
|
||||
bool Object::addSlotImpl(GenericMFPtr fptr, const char *name)
|
||||
{
|
||||
ObjectPrivate::Slot s = {fptr,std::string(name)};
|
||||
d->slov.push_back(s);
|
||||
bool Object::addSlotImpl(GenericMFPtr fptr, const char *name) {
|
||||
ObjectPrivate::Slot s = {fptr, std::string(name)};
|
||||
d->slov.push_back(s);
|
||||
}
|
||||
|
||||
SignalBase *Object::findSignalImpl(const GenericMFPtr &fptr) const
|
||||
{
|
||||
for(int i=0; i<d->sigv.size(); ++i)
|
||||
{
|
||||
if(d->sigv[i].sigptr == fptr)
|
||||
return d->sigv[i].signal;
|
||||
}
|
||||
return NULL;
|
||||
SignalBase *Object::findSignalImpl(const GenericMFPtr &fptr) const {
|
||||
for (int i = 0; i < d->sigv.size(); ++i) {
|
||||
if (d->sigv[i].sigptr == fptr)
|
||||
return d->sigv[i].signal;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
SignalBase *Object::findSignalImpl(const char *name) const
|
||||
{
|
||||
std::string in(name);
|
||||
for(int i=0; i<d->sigv.size(); ++i)
|
||||
{
|
||||
if(d->sigv[i].sigstr == in)
|
||||
return d->sigv[i].signal;
|
||||
}
|
||||
return NULL;
|
||||
SignalBase *Object::findSignalImpl(const char *name) const {
|
||||
std::string in(name);
|
||||
for (int i = 0; i < d->sigv.size(); ++i) {
|
||||
if (d->sigv[i].sigstr == in)
|
||||
return d->sigv[i].signal;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
GenericMFPtr *Object::findSlotImpl(const char *name) const
|
||||
{
|
||||
std::string in(name);
|
||||
for(int i=0; i<d->slov.size(); ++i)
|
||||
{
|
||||
if(d->slov[i].slostr == in)
|
||||
return &d->slov[i].sloptr;
|
||||
}
|
||||
return NULL;
|
||||
GenericMFPtr *Object::findSlotImpl(const char *name) const {
|
||||
std::string in(name);
|
||||
for (int i = 0; i < d->slov.size(); ++i) {
|
||||
if (d->slov[i].slostr == in)
|
||||
return &d->slov[i].sloptr;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
// std::ostream &
|
||||
// operator << (std::ostream &os, uLib::Object &ob)
|
||||
// {
|
||||
@@ -218,10 +166,4 @@ GenericMFPtr *Object::findSlotImpl(const char *name) const
|
||||
// return is;
|
||||
// }
|
||||
|
||||
|
||||
|
||||
|
||||
} // uLib
|
||||
|
||||
|
||||
|
||||
} // namespace uLib
|
||||
|
||||
@@ -23,200 +23,183 @@
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////*/
|
||||
|
||||
|
||||
|
||||
#ifndef U_CORE_OBJECT_H
|
||||
#define U_CORE_OBJECT_H
|
||||
|
||||
#include <iostream>
|
||||
|
||||
// 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/Types.h"
|
||||
|
||||
#include "Core/Function.h"
|
||||
#include "Core/Signal.h"
|
||||
|
||||
#include "Core/Mpl.h"
|
||||
#include "Core/Serializable.h"
|
||||
#include "Core/ObjectProps.h"
|
||||
#include "Core/Uuid.h"
|
||||
|
||||
namespace boost {
|
||||
namespace archive {
|
||||
class polymorphic_iarchive;
|
||||
class polymorphic_oarchive;
|
||||
} // archive
|
||||
} // boost
|
||||
|
||||
} // namespace archive
|
||||
} // namespace boost
|
||||
|
||||
namespace uLib {
|
||||
|
||||
|
||||
class Version {
|
||||
public:
|
||||
static const char *PackageName;
|
||||
static const char *VersionNumber;
|
||||
static const char *Release;
|
||||
static const char *PackageName;
|
||||
static const char *VersionNumber;
|
||||
static const char *Release;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
//// OBJECT ////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* @brief Object class is the object base implementation for uLib Framework.
|
||||
*/
|
||||
class Object : public ObjectPropable
|
||||
{
|
||||
|
||||
class Object {
|
||||
|
||||
public:
|
||||
// std::string name;
|
||||
// void PrintName() { std::cout << "Ob name: " << name << "\n"; }
|
||||
// std::string name;
|
||||
// void PrintName() { std::cout << "Ob name: " << name << "\n"; }
|
||||
|
||||
Object();
|
||||
Object(const Object ©);
|
||||
~Object();
|
||||
Object();
|
||||
Object(const Object ©);
|
||||
~Object();
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
// PARAMETERS //
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
// PARAMETERS //
|
||||
|
||||
// FIXX !!!
|
||||
virtual void DeepCopy(const Object ©);
|
||||
// FIXX !!!
|
||||
virtual void DeepCopy(const Object ©);
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
// SERIALIZATION //
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
// SERIALIZATION //
|
||||
template <class ArchiveT>
|
||||
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) {
|
||||
ObjectPropable::serialize(ar,version);
|
||||
void SaveConfig(std::ostream &os, int version = 0);
|
||||
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);
|
||||
void LoadConfig(std::istream &is, int version = 0);
|
||||
inline SignalBase *findSignal(const char *name) const {
|
||||
return findSignalImpl(name);
|
||||
}
|
||||
|
||||
static void SaveXml(std::ostream &os, Object &ob);
|
||||
static void LoadXml(std::istream &is, Object &ob);
|
||||
inline GenericMFPtr *findSlot(const char *name) const {
|
||||
return findSlotImpl(name);
|
||||
}
|
||||
|
||||
void PrintSelf(std::ostream &o) const;
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
// 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");
|
||||
}
|
||||
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 ©)
|
||||
{ this->DeepCopy(copy); return *this; }
|
||||
|
||||
inline const Object &operator=(const Object ©) {
|
||||
this->DeepCopy(copy);
|
||||
return *this;
|
||||
}
|
||||
|
||||
private:
|
||||
bool addSignalImpl(SignalBase *sig, GenericMFPtr fptr, const char *name);
|
||||
bool addSlotImpl(GenericMFPtr fptr, const char *name);
|
||||
SignalBase *findSignalImpl(const GenericMFPtr &fptr) const;
|
||||
SignalBase *findSignalImpl(const char *name) const;
|
||||
GenericMFPtr *findSlotImpl(const char *name) const;
|
||||
bool addSignalImpl(SignalBase *sig, GenericMFPtr fptr, const char *name);
|
||||
bool addSlotImpl(GenericMFPtr fptr, const char *name);
|
||||
SignalBase *findSignalImpl(const GenericMFPtr &fptr) const;
|
||||
SignalBase *findSignalImpl(const char *name) const;
|
||||
GenericMFPtr *findSlotImpl(const char *name) const;
|
||||
|
||||
friend class boost::serialization::access;
|
||||
friend class ObjectPrivate;
|
||||
class ObjectPrivate *d;
|
||||
friend class boost::serialization::access;
|
||||
friend class ObjectPrivate;
|
||||
class ObjectPrivate *d;
|
||||
};
|
||||
|
||||
|
||||
|
||||
} // uLib
|
||||
} // namespace uLib
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
//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::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);
|
||||
|
||||
#endif // U_OBJECT_H
|
||||
|
||||
@@ -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
|
||||
@@ -23,8 +23,6 @@
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////*/
|
||||
|
||||
|
||||
|
||||
#ifndef U_SERIALIZABLE_H
|
||||
#define U_SERIALIZABLE_H
|
||||
|
||||
@@ -38,9 +36,6 @@ TODO:
|
||||
|
||||
*/
|
||||
|
||||
|
||||
|
||||
|
||||
#include <boost/serialization/access.hpp>
|
||||
#include <boost/serialization/export.hpp>
|
||||
|
||||
@@ -48,26 +43,22 @@ TODO:
|
||||
#include <boost/mpl/remove_if.hpp>
|
||||
#include <boost/serialization/nvp.hpp>
|
||||
|
||||
//#include <boost/archive/xml_iarchive.hpp>
|
||||
//#include <boost/archive/xml_oarchive.hpp>
|
||||
//#include <boost/archive/text_iarchive.hpp>
|
||||
//#include <boost/archive/text_oarchive.hpp>
|
||||
//#include "boost/archive/polymorphic_iarchive.hpp"
|
||||
//#include "boost/archive/polymorphic_oarchive.hpp"
|
||||
// #include <boost/archive/xml_iarchive.hpp>
|
||||
// #include <boost/archive/xml_oarchive.hpp>
|
||||
// #include <boost/archive/text_iarchive.hpp>
|
||||
// #include <boost/archive/text_oarchive.hpp>
|
||||
// #include "boost/archive/polymorphic_iarchive.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/comma_if.hpp>
|
||||
#include <boost/preprocessor/inc.hpp>
|
||||
#include <boost/preprocessor/repeat.hpp>
|
||||
#include <boost/preprocessor/tuple/to_seq.hpp>
|
||||
|
||||
|
||||
#include "Core/Mpl.h"
|
||||
#include "Core/ObjectProps.h"
|
||||
#include "Core/Archives.h"
|
||||
#include "Core/Export.h"
|
||||
|
||||
|
||||
#include "Core/Mpl.h"
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
@@ -80,63 +71,47 @@ namespace serialization {
|
||||
// ACCESS 2 //
|
||||
template <class T> struct access2 {};
|
||||
|
||||
|
||||
// NON FUNZIONA ... SISTEMARE !!!! // ------------------------------------------
|
||||
template<class T>
|
||||
class hrp :
|
||||
public wrapper_traits<const hrp< T > >
|
||||
{
|
||||
const char *m_name;
|
||||
T *m_value;
|
||||
std::string *m_str;
|
||||
template <class T> class hrp : public wrapper_traits<const hrp<T>> {
|
||||
const char *m_name;
|
||||
T *m_value;
|
||||
std::string *m_str;
|
||||
|
||||
public:
|
||||
explicit hrp(const char * name_, T &t) :
|
||||
m_str(new std::string),
|
||||
m_name(name_), m_value(&t) {}
|
||||
explicit hrp(const char *name_, T &t)
|
||||
: m_str(new std::string), m_name(name_), m_value(&t) {}
|
||||
|
||||
const char * name() const {
|
||||
return this->m_name;
|
||||
}
|
||||
const char *name() const { return this->m_name; }
|
||||
|
||||
|
||||
template<class Archivex>
|
||||
void save( Archivex & ar, const unsigned int /* file_version */) const {
|
||||
//// ar.operator<<(const_value());
|
||||
// std::stringstream ss;
|
||||
// uLib::Archive::hrt_oarchive har(ss);
|
||||
// har << make_nvp(m_name,*m_value);
|
||||
// // (*m_str) = ss.str();
|
||||
//// ar.operator << (make_nvp(m_name, ss.str());
|
||||
}
|
||||
template<class Archivex>
|
||||
void load( Archivex & ar, const unsigned int /* file_version */) {
|
||||
// ar.operator>>(value());
|
||||
}
|
||||
BOOST_SERIALIZATION_SPLIT_MEMBER()
|
||||
template <class Archivex>
|
||||
void save(Archivex &ar, const unsigned int /* file_version */) const {
|
||||
//// ar.operator<<(const_value());
|
||||
// std::stringstream ss;
|
||||
// uLib::Archive::hrt_oarchive har(ss);
|
||||
// har << make_nvp(m_name,*m_value);
|
||||
// // (*m_str) = ss.str();
|
||||
//// ar.operator << (make_nvp(m_name, ss.str());
|
||||
}
|
||||
template <class Archivex>
|
||||
void load(Archivex &ar, const unsigned int /* file_version */) {
|
||||
// ar.operator>>(value());
|
||||
}
|
||||
BOOST_SERIALIZATION_SPLIT_MEMBER()
|
||||
};
|
||||
|
||||
|
||||
template<class T>
|
||||
template <class T>
|
||||
inline
|
||||
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
|
||||
const
|
||||
const
|
||||
#endif
|
||||
hrp< T > make_hrp(const char * name, T & t){
|
||||
return hrp< T >(name, t);
|
||||
hrp<T> make_hrp(const char *name, T &t) {
|
||||
return hrp<T>(name, t);
|
||||
}
|
||||
|
||||
#define HRP(name) \
|
||||
boost::serialization::make_hrp(BOOST_PP_STRINGIZE(name), name)
|
||||
|
||||
|
||||
} // serialization
|
||||
} // boost
|
||||
|
||||
|
||||
|
||||
|
||||
#define HRP(name) boost::serialization::make_hrp(BOOST_PP_STRINGIZE(name), name)
|
||||
|
||||
} // namespace serialization
|
||||
} // namespace boost
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
@@ -151,9 +126,7 @@ hrp< T > make_hrp(const char * name, T & t){
|
||||
|
||||
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)
|
||||
|
||||
@@ -166,51 +139,53 @@ namespace uLib {
|
||||
// SO LEAVE ULIB_CFG_INTRUSIVE_SERIALIZATION NOT DEFINED
|
||||
|
||||
#ifdef ULIB_CFG_INTRUSIVE_SERIALIZATION_OBJECT
|
||||
# define ULIB_SERIALIZABLE_OBJECT _ULIB_DETAIL_INTRUSIVE_SERIALIZABLE_OBJECT
|
||||
# define ULIB_SERIALIZE_OBJECT(_Ob,...) _ULIB_DETAIL_INTRUSIVE_SERIALIZE_OBJECT(_Ob,__VA_ARGS__)
|
||||
# define _AR_(_name) _ULIB_DETAIL_INTRUSIVE_AR_(_name)
|
||||
#define ULIB_SERIALIZABLE_OBJECT _ULIB_DETAIL_INTRUSIVE_SERIALIZABLE_OBJECT
|
||||
#define ULIB_SERIALIZE_OBJECT(_Ob, ...) \
|
||||
_ULIB_DETAIL_INTRUSIVE_SERIALIZE_OBJECT(_Ob, __VA_ARGS__)
|
||||
#define _AR_(_name) _ULIB_DETAIL_INTRUSIVE_AR_(_name)
|
||||
#else
|
||||
# define ULIB_SERIALIZABLE(_Ob) _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE(_Ob) \
|
||||
ULIB_CLASS_EXPORT_KEY(_Ob)
|
||||
# define ULIB_SERIALIZE(_Ob,...) _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE(_Ob)
|
||||
# define ULIB_SERIALIZE_DERIVED(_Ob,...) _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_DERIVED(_Ob,__VA_ARGS__)
|
||||
# define ULIB_SERIALIZABLE_OBJECT(_Ob) _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE_OBJECT(_Ob) \
|
||||
ULIB_CLASS_EXPORT_OBJECT_KEY(_Ob)
|
||||
# define ULIB_SERIALIZE_OBJECT(_Ob,...) _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_OBJECT(_Ob,__VA_ARGS__)
|
||||
# define ULIB_SERIALIZE_OBJECT_PROPS(_Ob) _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_PROPS(_Ob)
|
||||
# define AR(_name) _ULIB_DETAIL_UNINTRUSIVE_AR_(_name)
|
||||
# define HR(_name) _ULIB_DETAIL_UNINTRUSIVE_AR_(_name)
|
||||
#define ULIB_SERIALIZABLE(_Ob) \
|
||||
_ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE(_Ob) \
|
||||
ULIB_CLASS_EXPORT_KEY(_Ob)
|
||||
#define ULIB_SERIALIZE(_Ob, ...) _ULIB_DETAIL_UNINTRUSIVE_SERIALIZE(_Ob)
|
||||
#define ULIB_SERIALIZE_DERIVED(_Ob, ...) \
|
||||
_ULIB_DETAIL_UNINTRUSIVE_SERIALIZE_DERIVED(_Ob, __VA_ARGS__)
|
||||
#define ULIB_SERIALIZABLE_OBJECT(_Ob) \
|
||||
_ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE_OBJECT(_Ob) \
|
||||
ULIB_CLASS_EXPORT_OBJECT_KEY(_Ob)
|
||||
#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
|
||||
|
||||
#define ULIB_SERIALIZE_ACCESS \
|
||||
friend class boost::serialization::access; \
|
||||
template <class T> friend class boost::serialization::access2;
|
||||
|
||||
#define ULIB_SERIALIZE_ACCESS \
|
||||
friend class boost::serialization::access; \
|
||||
template <class T> friend class boost::serialization::access2;
|
||||
#define ULIB_CLASS_EXPORT_KEY(_FullNamespaceClass) \
|
||||
BOOST_CLASS_EXPORT_KEY(_FullNamespaceClass)
|
||||
|
||||
#define ULIB_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 ULIB_CLASS_EXPORT_OBJECT_KEY(_FullNamespaceClass) \
|
||||
BOOST_CLASS_EXPORT_KEY(_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)
|
||||
|
||||
/** 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_OP(r,data,elem) _ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE(elem,data)
|
||||
|
||||
|
||||
#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_OP(r, data, elem) \
|
||||
_ULIB_DETAIL_SPECIALIZE_IS_VIRTUAL_BASE(elem, data)
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
@@ -220,38 +195,57 @@ namespace uLib {
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// 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) \
|
||||
template void Class::serialize(Archive &ar,const unsigned int);
|
||||
#define _ULIB_DETAIL_INTRUSIVE_SERIALIZE_FUNC(Class, Archive) \
|
||||
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_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_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)
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
@@ -261,152 +255,171 @@ namespace uLib {
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// 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) \
|
||||
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(Class, Archive) \
|
||||
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)
|
||||
|
||||
// NOTE: becouse of BOOST_PP_VARIADIC_SIZE issue of some boost macro has two
|
||||
// different implementation
|
||||
|
||||
#define _ULIB_DETAIL_UNINTRUSIVE_SERIALIZABLE(_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(_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); }; \
|
||||
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_SERIALIZABLE(_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(_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 {
|
||||
|
||||
struct Serializable {
|
||||
|
||||
/**
|
||||
* Serializable trait to check if an object type is serializable.
|
||||
* This only works if UNINTRUSIVE SERIALIZATION is applyed; in intrusive
|
||||
* cases a has_serialize trait should be implemented
|
||||
*/
|
||||
template <class T>
|
||||
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));
|
||||
}
|
||||
};
|
||||
/**
|
||||
* Serializable trait to check if an object type is serializable.
|
||||
* This only works if UNINTRUSIVE SERIALIZATION is applyed; in intrusive
|
||||
* cases a has_serialize trait should be implemented
|
||||
*/
|
||||
template <class T> 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));
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
|
||||
} // detail
|
||||
|
||||
|
||||
|
||||
|
||||
} // namespace detail
|
||||
|
||||
struct Serializable {
|
||||
friend class boost::serialization::access;
|
||||
template <class T> friend class boost::serialization::access2;
|
||||
virtual ~Serializable() {}
|
||||
friend class boost::serialization::access;
|
||||
template <class T> friend class boost::serialization::access2;
|
||||
virtual ~Serializable() {}
|
||||
|
||||
protected:
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
} // uLib
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
} // namespace uLib
|
||||
|
||||
#endif // U_SERIALIZABLE_H
|
||||
|
||||
279
src/Core/Types.h
279
src/Core/Types.h
@@ -23,8 +23,6 @@
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////*/
|
||||
|
||||
|
||||
|
||||
#ifndef U_CORE_TYPES_H
|
||||
#define U_CORE_TYPES_H
|
||||
|
||||
@@ -33,253 +31,182 @@
|
||||
|
||||
#include <boost/preprocessor.hpp>
|
||||
|
||||
//#include <ltk/ltktypes.h>
|
||||
// #include <ltk/ltktypes.h>
|
||||
|
||||
#include "Core/Macros.h"
|
||||
#include "Core/Mpl.h"
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
namespace uLib {
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
namespace detail {
|
||||
|
||||
struct TypeIntrospection {
|
||||
|
||||
// BOOST IMPL //
|
||||
BOOST_MPL_HAS_XXX_TRAIT_DEF(type_info)
|
||||
// BOOST IMPL //
|
||||
BOOST_MPL_HAS_XXX_TRAIT_DEF(type_info)
|
||||
|
||||
// SFINAE IMPL //
|
||||
/*
|
||||
template <typename T>
|
||||
struct has_type_info {
|
||||
typedef char yes[1];
|
||||
typedef char no[2];
|
||||
template <typename U> static yes& test(typename U::type_info::BaseList*);
|
||||
template <typename > static no& test(...);
|
||||
// struct apply {
|
||||
static const bool value = sizeof(test<T>(0)) == sizeof(yes);
|
||||
typedef boost::mpl::bool_<value> type;
|
||||
// };
|
||||
};
|
||||
*/
|
||||
// SFINAE IMPL //
|
||||
/*
|
||||
template <typename T>
|
||||
struct has_type_info {
|
||||
typedef char yes[1];
|
||||
typedef char no[2];
|
||||
template <typename U> static yes& test(typename U::type_info::BaseList*);
|
||||
template <typename > static no& test(...);
|
||||
// struct apply {
|
||||
static const bool value = sizeof(test<T>(0)) == sizeof(yes);
|
||||
typedef boost::mpl::bool_<value> type;
|
||||
// };
|
||||
};
|
||||
*/
|
||||
|
||||
/** IsA Introspectable Object Implementation Template */
|
||||
template <class T>
|
||||
struct IsIntrospectable : has_type_info<T> {};
|
||||
/** IsA Introspectable Object Implementation Template */
|
||||
template <class T> struct IsIntrospectable : has_type_info<T> {};
|
||||
|
||||
template <typename T> struct access {
|
||||
typedef typename T::type_info type_info;
|
||||
template <typename T> struct access {
|
||||
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>
|
||||
struct child_first_impl {
|
||||
|
||||
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_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> {};
|
||||
|
||||
/**
|
||||
* 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 {};
|
||||
/** 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;
|
||||
};
|
||||
|
||||
/**
|
||||
* 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 !!!
|
||||
|
||||
//#define _REPETITION_V(vz,vn,vdata)
|
||||
|
||||
|
||||
//template < class TypeList >
|
||||
//class TypeAdapterInputInterface {
|
||||
// virtual ~TypeAdapterInputInterface() {}
|
||||
//public:
|
||||
|
||||
// #define _REPETITION_V(vz,vn,vdata)
|
||||
|
||||
// template < class TypeList >
|
||||
// class TypeAdapterInputInterface {
|
||||
// virtual ~TypeAdapterInputInterface() {}
|
||||
// public:
|
||||
|
||||
// virtual void operator()(int val) {}
|
||||
// virtual void operator()(std::string val) {}
|
||||
//};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
} // detail ////////////////////////////////////////////////////////////////////
|
||||
|
||||
} // namespace detail
|
||||
|
||||
#define CONSTEXPR BOOST_CONSTEXPR
|
||||
|
||||
|
||||
//typedef ltk::Real_t Real_t;
|
||||
// typedef ltk::Real_t Real_t;
|
||||
#ifndef LTK_DOUBLE_PRECISION
|
||||
typedef float Real_t;
|
||||
typedef float Real_t;
|
||||
#else
|
||||
typedef double Real_t;
|
||||
typedef double Real_t;
|
||||
#endif
|
||||
//typedef ltk::Id_t Id_t;
|
||||
typedef id_t Id_t;
|
||||
// typedef ltk::Id_t Id_t;
|
||||
typedef id_t Id_t;
|
||||
////typedef ltk::Size_t Size_t;
|
||||
//typedef ltk::Pointer_t Pointer_t;
|
||||
typedef void * Pointer_t;
|
||||
typedef bool Bool_t; //Boolean (0=false, 1=true) (bool)
|
||||
|
||||
|
||||
// typedef ltk::Pointer_t Pointer_t;
|
||||
typedef void *Pointer_t;
|
||||
typedef bool Bool_t; // Boolean (0=false, 1=true) (bool)
|
||||
|
||||
//--- bit manipulation ---------------------------------------------------------
|
||||
#ifndef BIT
|
||||
#define BIT(n) (1ULL << (n))
|
||||
#define BIT(n) (1ULL << (n))
|
||||
#endif
|
||||
|
||||
#ifndef SETBIT
|
||||
#define SETBIT(n,i) ((n) |= BIT(i))
|
||||
#define SETBIT(n, i) ((n) |= BIT(i))
|
||||
#endif
|
||||
|
||||
#ifndef CLRBIT
|
||||
#define CLRBIT(n,i) ((n) &= ~BIT(i))
|
||||
#define CLRBIT(n, i) ((n) &= ~BIT(i))
|
||||
#endif
|
||||
|
||||
#ifndef TESTBIT
|
||||
#define TESTBIT(n,i) ((Bool_t)(((n) & BIT(i)) != 0))
|
||||
#define TESTBIT(n, i) ((Bool_t)(((n) & BIT(i)) != 0))
|
||||
#endif
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// TYPE INTROSPECTION FOR OBJECTS //
|
||||
|
||||
|
||||
|
||||
#define uLibTypeMacro(thisClass,...) \
|
||||
\
|
||||
/* 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 */ \
|
||||
struct type_info { \
|
||||
/*WARNING: -std=c++0x required for this! */ \
|
||||
constexpr static const char *name = BOOST_PP_STRINGIZE(thisClass); \
|
||||
typedef BOOST_PP_VARIADIC_ELEM(0,__VA_ARGS__) BaseClass; \
|
||||
typedef thisClass ThisClass; \
|
||||
typedef uLib::mpl::vector<__VA_ARGS__,thisClass> TypeList; \
|
||||
typedef uLib::mpl::vector<__VA_ARGS__> BaseList; \
|
||||
typedef uLib::detail::TypeIntrospection::child_first<ThisClass>::type CFList; \
|
||||
}; \
|
||||
\
|
||||
public: \
|
||||
typedef type_info::BaseClass BaseClass; \
|
||||
virtual const char *type_name() const { return type_info::name; } \
|
||||
/* Object Props fwd declaration*/ \
|
||||
struct ObjectProps; \
|
||||
/**/
|
||||
|
||||
#define uLibTypeMacro(thisClass, ...) \
|
||||
\
|
||||
/* 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 */ \
|
||||
struct type_info { \
|
||||
/*WARNING: -std=c++0x required for this! */ \
|
||||
constexpr static const char *name = BOOST_PP_STRINGIZE(thisClass); \
|
||||
typedef BOOST_PP_VARIADIC_ELEM(0, __VA_ARGS__) BaseClass; \
|
||||
typedef thisClass ThisClass; \
|
||||
typedef uLib::mpl::vector<__VA_ARGS__, thisClass> TypeList; \
|
||||
typedef uLib::mpl::vector<__VA_ARGS__> BaseList; \
|
||||
typedef uLib::detail::TypeIntrospection::child_first<ThisClass>::type \
|
||||
CFList; \
|
||||
}; \
|
||||
\
|
||||
public: \
|
||||
typedef type_info::BaseClass BaseClass; \
|
||||
virtual const char *type_name() const { return type_info::name; } \
|
||||
/**/
|
||||
|
||||
/**
|
||||
* TypeList inheritance introspection
|
||||
*/
|
||||
struct TypeIntrospection {
|
||||
template <typename T>
|
||||
struct child_first : detail::TypeIntrospection::child_first<T> {};
|
||||
|
||||
template <typename T>
|
||||
struct child_first : detail::TypeIntrospection::child_first<T> {};
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
// SISTEMARE //
|
||||
struct PrintTypeId {
|
||||
template <class T>
|
||||
void operator()(T) const
|
||||
{ std::cout << typeid(T).name() << std::endl; }
|
||||
template <class T> void operator()(T) const {
|
||||
std::cout << typeid(T).name() << std::endl;
|
||||
}
|
||||
|
||||
template <typename SeqT>
|
||||
static void PrintMplSeq(SeqT *p = NULL) { boost::mpl::for_each<SeqT>(PrintTypeId()); }
|
||||
template <typename SeqT> static void PrintMplSeq(SeqT *p = NULL) {
|
||||
boost::mpl::for_each<SeqT>(PrintTypeId());
|
||||
}
|
||||
|
||||
template <typename Class>
|
||||
static void PrintType(Class *p = NULL) { std::cout << typeid(Class).name() << std::endl; }
|
||||
template <typename Class> static void PrintType(Class *p = NULL) {
|
||||
std::cout << typeid(Class).name() << std::endl;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
} // uLib
|
||||
} // namespace uLib
|
||||
|
||||
#endif // U_CORE_TYPES_H
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -16,7 +16,6 @@ set( TESTS
|
||||
SerializeTest
|
||||
SerializeDreadDiamondTest
|
||||
DreadDiamondParameters
|
||||
ObjectPropableTest
|
||||
UuidTest
|
||||
TypeIntrospectionTraversal
|
||||
OptionsTest
|
||||
|
||||
@@ -19,7 +19,6 @@ TESTS = SmartPointerTest \
|
||||
SerializeTest \
|
||||
SerializeDreadDiamondTest \
|
||||
DreadDiamondParameters \
|
||||
ObjectPropableTest \
|
||||
TypeIntrospectionTraversal \
|
||||
OptionsTest
|
||||
|
||||
|
||||
@@ -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
216
src/Math/Dense.h
@@ -23,9 +23,6 @@
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////*/
|
||||
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* <one line to give the program's name and a brief idea of what it does.>
|
||||
* Copyright (C) 2012 Andrea Rigoni Garola <andrea@pcimg05>
|
||||
@@ -47,7 +44,6 @@
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
#ifndef ULIB_DENSEMATRIX_H
|
||||
#define ULIB_DENSEMATRIX_H
|
||||
|
||||
@@ -55,27 +51,29 @@
|
||||
|
||||
#include <Eigen/Dense>
|
||||
|
||||
|
||||
//// BOOST SERIALIZATION ///////////////////////////////////////////////////////
|
||||
|
||||
#include <boost/algorithm/string.hpp>
|
||||
#include <boost/algorithm/string/split.hpp>
|
||||
#include <boost/algorithm/string/trim.hpp>
|
||||
#include <boost/lexical_cast.hpp>
|
||||
#include <boost/serialization/string.hpp>
|
||||
#include <boost/serialization/array.hpp>
|
||||
|
||||
#include <boost/serialization/string.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace serialization {
|
||||
|
||||
template<class Archive, class Scalar, int RowsAtCompileTime, int ColsAtCompileTime>
|
||||
void serialize(Archive & ar, ::Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime> & m, const unsigned int /*version*/) {
|
||||
ar & boost::serialization::make_array(m.data(), RowsAtCompileTime * ColsAtCompileTime);
|
||||
template <class Archive, class Scalar, int RowsAtCompileTime,
|
||||
int 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
|
||||
} // boost
|
||||
} // namespace serialization
|
||||
} // 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 ///////////
|
||||
namespace Eigen {
|
||||
template <typename T, int size>
|
||||
std::istream & operator >> (std::istream &is, Eigen::Matrix<T,size,1> &vec) {
|
||||
std::string str;
|
||||
for( unsigned int i=0; i<size; i++) {
|
||||
is >> std::skipws;
|
||||
is >> str;
|
||||
if(is.fail()) vec(i) = 0;
|
||||
else vec(i) = boost::lexical_cast<T>(str);
|
||||
}
|
||||
return is;
|
||||
std::istream &operator>>(std::istream &is, Eigen::Matrix<T, size, 1> &vec) {
|
||||
std::string str;
|
||||
for (unsigned int i = 0; i < size; i++) {
|
||||
is >> std::skipws;
|
||||
is >> str;
|
||||
if (is.fail())
|
||||
vec(i) = 0;
|
||||
else
|
||||
vec(i) = boost::lexical_cast<T>(str);
|
||||
}
|
||||
return is;
|
||||
}
|
||||
template <typename T, int size>
|
||||
std::ostream & operator << (std::ostream &os, const Eigen::Matrix<T,size,1> &vec) {
|
||||
os << vec.transpose();
|
||||
return os;
|
||||
std::ostream &operator<<(std::ostream &os,
|
||||
const Eigen::Matrix<T, size, 1> &vec) {
|
||||
os << vec.transpose();
|
||||
return os;
|
||||
}
|
||||
} // Eigen
|
||||
} // namespace Eigen
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
|
||||
namespace uLib {
|
||||
|
||||
typedef id_t Id_t;
|
||||
typedef id_t Id_t;
|
||||
|
||||
typedef int Scalari;
|
||||
typedef unsigned int Scalarui;
|
||||
typedef long Scalarl;
|
||||
typedef int Scalari;
|
||||
typedef unsigned int Scalarui;
|
||||
typedef long Scalarl;
|
||||
typedef unsigned long Scalarul;
|
||||
typedef float Scalarf;
|
||||
typedef double Scalard;
|
||||
typedef float Scalarf;
|
||||
typedef double Scalard;
|
||||
|
||||
|
||||
|
||||
typedef Eigen::Matrix<int,1,1> Matrix1i;
|
||||
typedef Eigen::Matrix<int, 1, 1> Matrix1i;
|
||||
typedef Eigen::Matrix2i Matrix2i;
|
||||
typedef Eigen::Matrix3i Matrix3i;
|
||||
typedef Eigen::Matrix4i Matrix4i;
|
||||
|
||||
typedef Eigen::Matrix<float,1,1> Matrix1f;
|
||||
typedef Eigen::Matrix<float, 1, 1> Matrix1f;
|
||||
typedef Eigen::Matrix2f Matrix2f;
|
||||
typedef Eigen::Matrix3f Matrix3f;
|
||||
typedef Eigen::Matrix4f Matrix4f;
|
||||
|
||||
typedef Eigen::Matrix<int,1,1> Vector1i;
|
||||
typedef Eigen::Matrix<int, 1, 1> Vector1i;
|
||||
typedef Eigen::Vector2i Vector2i;
|
||||
typedef Eigen::Vector3i Vector3i;
|
||||
typedef Eigen::Vector4i Vector4i;
|
||||
|
||||
typedef Eigen::Matrix<float,1,1> Vector1f;
|
||||
typedef Eigen::Matrix<float, 1, 1> Vector1f;
|
||||
typedef Eigen::Vector2f Vector2f;
|
||||
typedef Eigen::Vector3f Vector3f;
|
||||
typedef Eigen::Vector4f Vector4f;
|
||||
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Vector String interaction ///////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/*! Given a string consisting of a series of doubles with some
|
||||
* delimiter, return an Eigen::Vector populated with those
|
||||
* values, in the same order as they are given in the string.
|
||||
*
|
||||
* \param vec A double vector to be populated with the results
|
||||
* \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
|
||||
*
|
||||
*/
|
||||
* delimiter, return an Eigen::Vector populated with those
|
||||
* values, in the same order as they are given in the string.
|
||||
*
|
||||
* \param vec A double vector to be populated with the results
|
||||
* \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
|
||||
*
|
||||
*/
|
||||
template <typename T, int size>
|
||||
void VectorxT_StringTo(Eigen::Matrix<T,size,1> &vec, std::string str, const char *delim = " ,;\t\n") {
|
||||
std::vector<std::string> strvec;
|
||||
void VectorxT_StringTo(Eigen::Matrix<T, size, 1> &vec, std::string str,
|
||||
const char *delim = " ,;\t\n") {
|
||||
std::vector<std::string> strvec;
|
||||
|
||||
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::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);
|
||||
|
||||
for( unsigned int i=0; i<size; i++) {
|
||||
vec(i) = boost::lexical_cast<T>(strvec[i]);
|
||||
}
|
||||
for (unsigned int i = 0; i < size; i++) {
|
||||
vec(i) = boost::lexical_cast<T>(strvec[i]);
|
||||
}
|
||||
}
|
||||
|
||||
template <typename T, int size>
|
||||
std::string VectorxT_ToString(const Eigen::Matrix<T,size,1> &vec) {
|
||||
std::stringstream sst;
|
||||
sst << vec.transpose();
|
||||
return sst.str();
|
||||
std::string VectorxT_ToString(const Eigen::Matrix<T, size, 1> &vec) {
|
||||
std::stringstream sst;
|
||||
sst << vec.transpose();
|
||||
return sst.str();
|
||||
}
|
||||
|
||||
|
||||
//template <typename T, int size>
|
||||
//Eigen::Matrix<T,size,1> & operator >> (std::istream &is, Eigen::Matrix<T,size,1> &vec) {
|
||||
//}
|
||||
// template <typename T, int size>
|
||||
// Eigen::Matrix<T,size,1> & operator >> (std::istream &is,
|
||||
// Eigen::Matrix<T,size,1> &vec) {
|
||||
// }
|
||||
|
||||
template <typename T, int size>
|
||||
void operator>> (std::string& str, Eigen::Matrix<T,size,1> &vec){
|
||||
VectorxT_StringTo(vec,str);
|
||||
void operator>>(std::string &str, Eigen::Matrix<T, size, 1> &vec) {
|
||||
VectorxT_StringTo(vec, str);
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
////// HOMOGENEOUS VECTORS //////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
template <bool p>
|
||||
class _HPoint3f : public Eigen::Matrix< Scalarf,4,1 > {
|
||||
template <bool p> class _HPoint3f : public Eigen::Matrix<Scalarf, 4, 1> {
|
||||
public:
|
||||
typedef Eigen::Matrix< Scalarf,4,1 > BaseClass;
|
||||
typedef Eigen::Matrix<Scalarf, 4, 1> BaseClass;
|
||||
|
||||
_HPoint3f<p>() : BaseClass(0,0,0,p) {}
|
||||
_HPoint3f<p>(float x,float y,float z) : BaseClass(x,y,z,p) {}
|
||||
_HPoint3f<p>(Vector3f &in) : BaseClass(in.homogeneous()) { this->operator()(3) = p; }
|
||||
_HPoint3f() : BaseClass(0, 0, 0, p) {}
|
||||
_HPoint3f(float x, float y, float z) : BaseClass(x, y, z, 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
|
||||
template<typename OtherDerived>
|
||||
inline _HPoint3f<p>(const Eigen::MatrixBase<OtherDerived>& 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 constructor allows to construct MyVectorType from Eigen expressions
|
||||
template <typename OtherDerived>
|
||||
inline _HPoint3f(const Eigen::MatrixBase<OtherDerived> &other)
|
||||
: BaseClass(other) {}
|
||||
|
||||
// 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<true> HPoint3f;
|
||||
|
||||
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
////// HOMOGENEOUS LINE //////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
struct _HLine3f
|
||||
{
|
||||
HPoint3f origin;
|
||||
HVector3f direction;
|
||||
struct _HLine3f {
|
||||
HPoint3f origin;
|
||||
HVector3f direction;
|
||||
};
|
||||
typedef struct _HLine3f HLine3f;
|
||||
|
||||
inline std::ostream&
|
||||
operator<< (std::ostream& stream, const HLine3f &line) {
|
||||
stream << "HLine3f(" << "pt[" << line.origin.transpose() <<"] , dr[" << line.direction.transpose() << "]) ";
|
||||
return stream;
|
||||
inline std::ostream &operator<<(std::ostream &stream, const HLine3f &line) {
|
||||
stream << "HLine3f(" << "pt[" << line.origin.transpose() << "] , dr["
|
||||
<< line.direction.transpose() << "]) ";
|
||||
return stream;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
struct _HError3f
|
||||
{
|
||||
HVector3f position_error;
|
||||
HVector3f direction_error;
|
||||
struct _HError3f {
|
||||
HVector3f position_error;
|
||||
HVector3f direction_error;
|
||||
};
|
||||
typedef struct _HError3f HError3f;
|
||||
|
||||
inline std::ostream&
|
||||
operator<< (std::ostream& stream, const HError3f &err) {
|
||||
stream << "HError3f(" << "ept[" << err.position_error.transpose() <<"] , edr[" << err.direction_error.transpose() << "]) ";
|
||||
return stream;
|
||||
}
|
||||
|
||||
|
||||
inline std::ostream &operator<<(std::ostream &stream, const HError3f &err) {
|
||||
stream << "HError3f(" << "ept[" << err.position_error.transpose()
|
||||
<< "] , edr[" << err.direction_error.transpose() << "]) ";
|
||||
return stream;
|
||||
}
|
||||
|
||||
} // namespace uLib
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
@@ -268,13 +252,9 @@ ULIB_SERIALIZABLE(uLib::HPoint3f)
|
||||
|
||||
ULIB_SERIALIZABLE(uLib::HVector3f)
|
||||
|
||||
|
||||
ULIB_SERIALIZABLE(uLib::HLine3f)
|
||||
|
||||
ULIB_SERIALIZABLE(uLib::HError3f)
|
||||
#endif // ULIB_SERIALIZATION_ON
|
||||
|
||||
|
||||
|
||||
|
||||
#endif // U_DENSEMATRIX_H
|
||||
#endif // U_DENSEMATRIX_H
|
||||
|
||||
@@ -23,11 +23,10 @@
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////*/
|
||||
|
||||
|
||||
#include <iostream>
|
||||
|
||||
#include "VoxRaytracer.h"
|
||||
#include "Utils.h"
|
||||
#include "VoxRaytracer.h"
|
||||
|
||||
#define unlikely(expr) __builtin_expect(!!(expr), 0)
|
||||
|
||||
@@ -39,215 +38,206 @@ namespace uLib {
|
||||
///// RAY DATA /////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
void VoxRaytracer::RayData::AddElement(Id_t id, float L)
|
||||
{
|
||||
Element el = {id, L};
|
||||
m_Data.push_back(el);
|
||||
m_TotalLength += L;
|
||||
void VoxRaytracer::RayData::AddElement(Id_t id, float L) {
|
||||
Element el = {id, L};
|
||||
m_Data.push_back(el);
|
||||
m_TotalLength += L;
|
||||
}
|
||||
|
||||
|
||||
void VoxRaytracer::RayData::AppendRay(const VoxRaytracer::RayData &in)
|
||||
{
|
||||
if (unlikely(!in.m_Data.size())) {
|
||||
std::cout << "Warinig: PoCA on exit border!\n";
|
||||
return;
|
||||
}
|
||||
else if (unlikely(!m_Data.size())) {
|
||||
m_Data = in.m_Data;
|
||||
std::cout << "Warinig: PoCA on entrance border!\n";
|
||||
return;
|
||||
}
|
||||
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;
|
||||
void VoxRaytracer::RayData::AppendRay(const VoxRaytracer::RayData &in) {
|
||||
if (unlikely(!in.m_Data.size())) {
|
||||
std::cout << "Warinig: PoCA on exit border!\n";
|
||||
return;
|
||||
} else if (unlikely(!m_Data.size())) {
|
||||
m_Data = in.m_Data;
|
||||
std::cout << "Warinig: PoCA on entrance border!\n";
|
||||
return;
|
||||
} else {
|
||||
// Opzione 1) un voxel in piu' //
|
||||
if (in.m_Data.size() > 0) {
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
void VoxRaytracer::RayData::PrintSelf(std::ostream &o)
|
||||
{
|
||||
o << "Ray: total lenght " << m_TotalLength << "\n";
|
||||
std::vector<Element>::iterator it;
|
||||
for(it = m_Data.begin(); it < m_Data.end(); ++it)
|
||||
o << "[ " << (*it).vox_id << ", " << (*it).L << "] \n";
|
||||
void VoxRaytracer::RayData::PrintSelf(std::ostream &o) {
|
||||
o << "Ray: total lenght " << m_TotalLength << "\n";
|
||||
std::vector<Element>::iterator it;
|
||||
for (it = m_Data.begin(); it < m_Data.end(); ++it)
|
||||
o << "[ " << (*it).vox_id << ", " << (*it).L << "] \n";
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
//// 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)
|
||||
{
|
||||
Vector4f s = m_Image->GetLocalPoint(line.direction);
|
||||
pt = m_Image->GetLocalPoint(line.origin);
|
||||
// Considers Structured grid dimensions //
|
||||
Vector4f dims = m_Image->GetDims().homogeneous().cast<float>();
|
||||
pt = pt.cwiseQuotient(dims);
|
||||
s = s.cwiseQuotient(dims);
|
||||
|
||||
// Considers Structured grid dimensions //
|
||||
Vector4f dims = m_Image->GetDims().homogeneous().cast<float>();
|
||||
pt = pt.cwiseQuotient(dims);
|
||||
s = s.cwiseQuotient(dims);
|
||||
float l = s.head(3).norm();
|
||||
Vector3f L(l / s(0), l / s(1), l / s(2));
|
||||
|
||||
float l = s.head(3).norm();
|
||||
Vector3f L(l/s(0), l/s(1), l/s(2));
|
||||
Vector3f offset;
|
||||
for (int i = 0; i < 3; ++i)
|
||||
offset(i) = (s(i) > 0) - (pt(i) - floor(pt(i)));
|
||||
offset = offset.cwiseProduct(L).cwiseAbs();
|
||||
|
||||
Vector3f offset;
|
||||
for(int i=0;i<3;++i)
|
||||
offset(i) = (s(i)>0) - (pt(i)-floor(pt(i))) ;
|
||||
offset = offset.cwiseProduct(L).cwiseAbs();
|
||||
|
||||
int id; float d;
|
||||
for(int loop=0; loop<8; loop++)
|
||||
{
|
||||
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));
|
||||
int id;
|
||||
float d;
|
||||
for (int loop = 0; loop < 8; loop++) {
|
||||
int check_border = 0;
|
||||
for (int i = 0; i < 3; ++i) {
|
||||
check_border += pt(i) > 1;
|
||||
check_border += pt(i) < 0;
|
||||
}
|
||||
for(int i=0;i<3;++i)
|
||||
if (check_border == 0) {
|
||||
for (int i = 0; i < 3; ++i)
|
||||
pt(i) *= (float)dims(i);
|
||||
pt = m_Image->GetWorldPoint(pt);
|
||||
return false;
|
||||
}
|
||||
|
||||
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;
|
||||
pt = m_Image->GetWorldPoint(pt);
|
||||
return true;
|
||||
}
|
||||
|
||||
//---- Otherwise, loop until ray is finished
|
||||
int id; float d;
|
||||
while(l>0){
|
||||
d = offset.minCoeff(&id);
|
||||
for (int i = 0; i < 3; ++i)
|
||||
pt(i) += d / L(i);
|
||||
|
||||
d = offset.minCoeff(&id);
|
||||
pt(id) = rintf(pt(id));
|
||||
|
||||
if(m_Image->IsInsideGrid(vid)){
|
||||
ray.AddElement(m_Image->Map(vid), d * m_scale(id) );
|
||||
}
|
||||
offset.array() -= d;
|
||||
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 //
|
||||
// if(unlikely(!isFinite(d * scale(id)))) {
|
||||
// std:: cout << "NAN in raytracer\n";
|
||||
// exit(1);
|
||||
// }
|
||||
bool VoxRaytracer::GetExitPoint(const HLine3f &line, HPoint3f &pt) {
|
||||
HLine3f out = line;
|
||||
out.direction *= -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;
|
||||
offset.array() -= d;
|
||||
offset(id) = fmin(L(id),l);
|
||||
}
|
||||
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
|
||||
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
|
||||
VoxRaytracer::RayData VoxRaytracer::TraceLine(const HLine3f &line) const
|
||||
{
|
||||
RayData ray;
|
||||
VoxRaytracer::RayData VoxRaytracer::TraceLine(const HLine3f &line) const {
|
||||
RayData ray;
|
||||
|
||||
Vector4f pt = m_Image->GetLocalPoint(line.origin);
|
||||
Vector4f s = m_Image->GetLocalPoint(line.direction);
|
||||
Vector4f pt = m_Image->GetLocalPoint(line.origin);
|
||||
Vector4f s = m_Image->GetLocalPoint(line.direction);
|
||||
|
||||
float l = s.head(3).norm();
|
||||
// intersection between track and grid when spacing is +1
|
||||
Vector3f L(l/s(0), l/s(1), l/s(2));
|
||||
float l = s.head(3).norm();
|
||||
// intersection between track and grid when spacing is +1
|
||||
Vector3f L(l / s(0), l / s(1), l / s(2));
|
||||
|
||||
// RayTracer works with a grid of interspace +1
|
||||
// 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();
|
||||
// RayTracer works with a grid of interspace +1
|
||||
// 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();
|
||||
|
||||
// offset is the fraction of the segment between grid lines when origin is insiede voxel
|
||||
// cwiseAbs for having positive distances
|
||||
Vector3f offset;
|
||||
for(int i=0;i<3;++i)
|
||||
offset(i) = (s(i)>=0) - (pt(i)-floor(pt(i)));
|
||||
offset = offset.cwiseProduct(L).cwiseAbs();
|
||||
L = L.cwiseAbs();
|
||||
// offset is the fraction of the segment between grid lines when origin is
|
||||
// insiede voxel cwiseAbs for having positive distances
|
||||
Vector3f offset;
|
||||
for (int i = 0; i < 3; ++i)
|
||||
offset(i) = (s(i) >= 0) - (pt(i) - floor(pt(i)));
|
||||
offset = offset.cwiseProduct(L).cwiseAbs();
|
||||
L = L.cwiseAbs();
|
||||
|
||||
int id; float d;
|
||||
Vector3i vid = m_Image->Find(line.origin);
|
||||
while(m_Image->IsInsideGrid(vid))
|
||||
{
|
||||
// minimun coefficient of offset: id is the coordinate, d is the value
|
||||
// dependig on which grid line horizontal or vertical it is first intercept
|
||||
d = offset.minCoeff(&id);
|
||||
int id;
|
||||
float d;
|
||||
Vector3i vid = m_Image->Find(line.origin);
|
||||
while (m_Image->IsInsideGrid(vid)) {
|
||||
// minimun coefficient of offset: id is the coordinate, d is the value
|
||||
// dependig on which grid line horizontal or vertical it is first intercept
|
||||
d = offset.minCoeff(&id);
|
||||
|
||||
// add Lij to ray
|
||||
ray.AddElement(m_Image->Map(vid), d * m_scale(id) );
|
||||
// add Lij to ray
|
||||
ray.AddElement(m_Image->Map(vid), d * m_scale(id));
|
||||
|
||||
// move to the next voxel
|
||||
vid(id) += (int)fast_sign(s(id));
|
||||
// move to the next voxel
|
||||
vid(id) += (int)fast_sign(s(id));
|
||||
|
||||
offset.array() -= d;
|
||||
offset(id) = L(id);
|
||||
}
|
||||
return ray;
|
||||
offset.array() -= d;
|
||||
offset(id) = L(id);
|
||||
}
|
||||
return ray;
|
||||
}
|
||||
|
||||
}
|
||||
} // namespace uLib
|
||||
|
||||
@@ -23,8 +23,6 @@
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////*/
|
||||
|
||||
|
||||
|
||||
#ifndef U_ROOT_LINKDEF_H
|
||||
#define U_ROOT_LINKDEF_H
|
||||
|
||||
@@ -35,52 +33,21 @@
|
||||
#pragma link off all functions;
|
||||
#pragma link C++ nestedclasses;
|
||||
|
||||
#pragma link C++ class TestTObject+;
|
||||
|
||||
using namespace ROOT::Mutom;
|
||||
|
||||
#pragma link C++ class ROOT::Math::Cartesian2D<int>+;
|
||||
#pragma link C++ class ROOT::Math::Cartesian2D<float>+;
|
||||
#pragma link C++ class ROOT::Math::Cartesian2D<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 ROOT::Math::Cartesian3D < int> + ;
|
||||
#pragma link C++ class ROOT::Math::Cartesian3D < float> + ;
|
||||
#pragma link C++ class ROOT::Math::Cartesian3D < double> + ;
|
||||
|
||||
// #pragma link C++ class DetectorChamber+;
|
||||
|
||||
#pragma link C++ class HitRaw+;
|
||||
#pragma link C++ function HitRaw::Chm() const;
|
||||
#pragma link C++ function HitRaw::Rob() const;
|
||||
#pragma link C++ function HitRaw::Tdc() const;
|
||||
#pragma link C++ function HitRaw::Ch() const;
|
||||
|
||||
#pragma link C++ class muCastorMCTrack+;
|
||||
#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+;
|
||||
#pragma link C++ class muCastorMCTrack + ;
|
||||
#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__
|
||||
|
||||
|
||||
Reference in New Issue
Block a user