[seiscomp, scanloc] Install, add .gitignore
This commit is contained in:
903
include/seiscomp/core/archive.inl
Normal file
903
include/seiscomp/core/archive.inl
Normal file
@ -0,0 +1,903 @@
|
||||
/***************************************************************************
|
||||
* Copyright (C) gempa GmbH *
|
||||
* All rights reserved. *
|
||||
* Contact: gempa GmbH (seiscomp-dev@gempa.de) *
|
||||
* *
|
||||
* GNU Affero General Public License Usage *
|
||||
* This file may be used under the terms of the GNU Affero *
|
||||
* Public License version 3.0 as published by the Free Software Foundation *
|
||||
* and appearing in the file LICENSE included in the packaging of this *
|
||||
* file. Please review the following information to ensure the GNU Affero *
|
||||
* Public License version 3.0 requirements will be met: *
|
||||
* https://www.gnu.org/licenses/agpl-3.0.html. *
|
||||
* *
|
||||
* Other Usage *
|
||||
* Alternatively, this file may be used in accordance with the terms and *
|
||||
* conditions contained in a signed written agreement between you and *
|
||||
* gempa GmbH. *
|
||||
***************************************************************************/
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE, typename T, int CLASS_TYPE>
|
||||
struct VectorReader {};
|
||||
|
||||
template <typename ROOT_TYPE, typename T, int CLASS_TYPE>
|
||||
struct VectorWriter {};
|
||||
|
||||
template <typename ROOT_TYPE, typename T, int CLASS_TYPE>
|
||||
struct ListReader {};
|
||||
|
||||
template <typename ROOT_TYPE, typename T, int CLASS_TYPE>
|
||||
struct ListWriter {};
|
||||
|
||||
template <typename ROOT_TYPE, typename T, int CLASS_TYPE>
|
||||
struct ContainerReader {};
|
||||
|
||||
template <typename ROOT_TYPE, typename T, int CLASS_TYPE>
|
||||
struct ContainerWriter {};
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
namespace {
|
||||
|
||||
template <typename DERIVEDCLASS, typename BASECLASS>
|
||||
class IsTypeOf {
|
||||
class No { };
|
||||
class Yes { No no[2]; };
|
||||
|
||||
static Yes Test(BASECLASS*); // declared, but not defined
|
||||
static No Test(...); // declared, but not defined
|
||||
|
||||
public:
|
||||
enum { Value = sizeof(Test(static_cast<DERIVEDCLASS*>(0))) == sizeof(Yes) };
|
||||
};
|
||||
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE, typename TYPE>
|
||||
inline bool checkRootType(TYPE*&) {
|
||||
return IsTypeOf<TYPE, ROOT_TYPE>::Value;
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE, typename TYPE>
|
||||
inline bool checkRootType(::boost::intrusive_ptr<TYPE>&) {
|
||||
return IsTypeOf<TYPE, ROOT_TYPE>::Value;
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE, typename TYPE>
|
||||
inline bool checkRootType(TYPE&) {
|
||||
return IsTypeOf<TYPE, ROOT_TYPE>::Value;
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE, typename TYPE>
|
||||
inline const char *checkClassName(const ROOT_TYPE**, const TYPE*) {
|
||||
return TYPE::ClassName();
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE, typename TYPE>
|
||||
inline const char *checkClassName(const ROOT_TYPE*, const TYPE&) {
|
||||
return TYPE::ClassName();
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE, typename TYPE>
|
||||
inline const char *checkClassName(const ::boost::intrusive_ptr<TYPE>*, const ::boost::intrusive_ptr<TYPE>&) {
|
||||
return TYPE::ClassName();
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE, typename TYPE>
|
||||
inline const char *checkClassName(const void**, const TYPE*) {
|
||||
return nullptr;
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE, typename TYPE>
|
||||
inline const char *checkClassName(const void*, const TYPE&) {
|
||||
return nullptr;
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename T, int CLASS_TYPE>
|
||||
struct ClassQuery {};
|
||||
|
||||
template <typename T>
|
||||
struct ClassQuery<T,0> {
|
||||
const char *operator()() const { return nullptr; }
|
||||
};
|
||||
template <typename T>
|
||||
struct ClassQuery<T,1> {
|
||||
const char *operator()() const { return T::ClassName(); }
|
||||
};
|
||||
|
||||
template <typename ROOT_TYPE, typename TYPE>
|
||||
const char *checkClassName(const ::boost::optional<TYPE>*, const ::boost::optional<TYPE>&) {
|
||||
ClassQuery<TYPE, boost::is_base_of<ROOT_TYPE, TYPE>::value> query;
|
||||
return query();
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE>
|
||||
template <typename T>
|
||||
inline Archive<ROOT_TYPE>& Archive<ROOT_TYPE>::operator<<(T*& object) {
|
||||
write(nullptr, object, T::ClassName());
|
||||
return *this;
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE>
|
||||
template <typename T>
|
||||
inline Archive<ROOT_TYPE>& Archive<ROOT_TYPE>::operator<<(::boost::intrusive_ptr<T>& object) {
|
||||
write(nullptr, object.get(), T::ClassName());
|
||||
return *this;
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE, typename T>
|
||||
struct ContainerWriter<ROOT_TYPE, T,1> {
|
||||
void operator()(Archive<ROOT_TYPE>& ar, const ObjectNamer<T>& namedObject) {
|
||||
ar << ObjectNamer<typename T::ContainerType>(namedObject.name(), namedObject.object().container(), namedObject.hint());
|
||||
/*
|
||||
namedObject.object().reset();
|
||||
while ( namedObject.object().next() )
|
||||
ar.write(namedObject.name(), namedObject.object().get(), checkClassName<ROOT_TYPE>(&namedObject.object().get(), namedObject.object().get()));
|
||||
*/
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template <typename ROOT_TYPE, typename T>
|
||||
struct ContainerWriter<ROOT_TYPE, T,0> {
|
||||
void operator()(Archive<ROOT_TYPE>& ar, const ObjectNamer<T>& namedObject) {
|
||||
ar.write(namedObject.name(), namedObject.object(), checkClassName<ROOT_TYPE>(&namedObject.object(), namedObject.object()));
|
||||
}
|
||||
};
|
||||
|
||||
template <typename ROOT_TYPE>
|
||||
template <typename T>
|
||||
inline Archive<ROOT_TYPE>& Archive<ROOT_TYPE>::operator<<(const ObjectNamer<T>& namedObject) {
|
||||
int h = setChildHint(namedObject.hint());
|
||||
//setHint(h | namedObject.hint());
|
||||
ContainerWriter<ROOT_TYPE, T,boost::is_const<T>::value?1:0> writer;
|
||||
writer(*this, namedObject);
|
||||
setHint(h);
|
||||
return *this;
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE, typename T>
|
||||
struct VectorWriter<ROOT_TYPE, T,1> {
|
||||
void operator()(Archive<ROOT_TYPE>& ar, const ObjectNamer<std::vector<T> >& namedObject) {
|
||||
typename std::vector<T>::iterator it;
|
||||
|
||||
ar.writeSequence(namedObject.object().size());
|
||||
|
||||
ar._first = true;
|
||||
for ( it = namedObject.object().begin(); it != namedObject.object().end(); ++it ) {
|
||||
ar.write(namedObject.name(), *it, checkClassName<ROOT_TYPE>(&(*it), *it));
|
||||
ar._first = false;
|
||||
}
|
||||
ar._first = true;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template <typename ROOT_TYPE, typename T>
|
||||
struct VectorWriter<ROOT_TYPE, T,0> {
|
||||
void operator()(Archive<ROOT_TYPE>& ar, const ObjectNamer<std::vector<T> >& namedObject) {
|
||||
if ( ar.locateObjectByName(namedObject.name(), nullptr, false) )
|
||||
ar.write(namedObject.object());
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template <typename ROOT_TYPE>
|
||||
template <typename T>
|
||||
inline Archive<ROOT_TYPE>& Archive<ROOT_TYPE>::operator<<(const ObjectNamer<std::vector<T> >& namedObject) {
|
||||
int h = setChildHint(namedObject.hint());
|
||||
|
||||
typedef typename boost::remove_pointer<T>::type RAW_T;
|
||||
|
||||
VectorWriter<ROOT_TYPE,T,
|
||||
boost::is_class<RAW_T>::value?
|
||||
(
|
||||
boost::is_same<std::complex<double>,T>::value?
|
||||
0
|
||||
:
|
||||
(
|
||||
boost::is_same<std::string,T>::value?
|
||||
0
|
||||
:
|
||||
(
|
||||
boost::is_same<Seiscomp::Core::Time,T>::value?
|
||||
0
|
||||
:
|
||||
1
|
||||
)
|
||||
)
|
||||
)
|
||||
:
|
||||
0
|
||||
> writer;
|
||||
|
||||
writer(*this, namedObject);
|
||||
|
||||
setHint(h);
|
||||
|
||||
return *this;
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE, typename T>
|
||||
struct ListWriter<ROOT_TYPE, T,1> {
|
||||
void operator()(Archive<ROOT_TYPE>& ar, const ObjectNamer<std::list<T> >& namedObject) {
|
||||
typename std::list<T>::iterator it;
|
||||
|
||||
ar.writeSequence(namedObject.object().size());
|
||||
|
||||
ar._first = true;
|
||||
for ( it = namedObject.object().begin(); it != namedObject.object().end(); ++it ) {
|
||||
ar.write(namedObject.name(), *it, checkClassName<ROOT_TYPE>(&(*it), *it));
|
||||
ar._first = false;
|
||||
}
|
||||
ar._first = true;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template <typename ROOT_TYPE, typename T>
|
||||
struct ListWriter<ROOT_TYPE, T,0> {
|
||||
void operator()(Archive<ROOT_TYPE>& ar, const ObjectNamer<std::list<T> >& namedObject) {
|
||||
if ( ar.locateObjectByName(namedObject.name(), nullptr, false) )
|
||||
ar.write(namedObject.object());
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template <typename ROOT_TYPE>
|
||||
template <typename T>
|
||||
inline Archive<ROOT_TYPE>& Archive<ROOT_TYPE>::operator<<(const ObjectNamer<std::list<T> >& namedObject) {
|
||||
int h = setChildHint(namedObject.hint());
|
||||
|
||||
typedef typename boost::remove_pointer<T>::type RAW_T;
|
||||
|
||||
ListWriter<ROOT_TYPE,T,
|
||||
boost::is_class<RAW_T>::value?
|
||||
(
|
||||
boost::is_same<std::complex<double>,T>::value
|
||||
?
|
||||
0
|
||||
:
|
||||
(
|
||||
boost::is_same<std::string,T>::value?
|
||||
0
|
||||
:
|
||||
(
|
||||
boost::is_same<Time,T>::value?
|
||||
0
|
||||
:
|
||||
1
|
||||
)
|
||||
)
|
||||
)
|
||||
:
|
||||
0
|
||||
> writer;
|
||||
writer(*this, namedObject);
|
||||
|
||||
setHint(h);
|
||||
|
||||
return *this;
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE>
|
||||
template <typename T>
|
||||
inline Archive<ROOT_TYPE>& Archive<ROOT_TYPE>::operator>>(T*& object) {
|
||||
const char *classname = T::ClassName();
|
||||
if ( !classname )
|
||||
return *this;
|
||||
|
||||
//_validObject = true;
|
||||
|
||||
read(classname, object, classname);
|
||||
|
||||
return *this;
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE>
|
||||
template <typename T>
|
||||
inline Archive<ROOT_TYPE>& Archive<ROOT_TYPE>::operator>>(::boost::intrusive_ptr<T>& object) {
|
||||
//_validObject = true;
|
||||
const char *classname = T::ClassName();
|
||||
if ( !classname )
|
||||
return *this;
|
||||
|
||||
read(classname, object, classname);
|
||||
|
||||
return *this;
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE, typename T>
|
||||
struct ContainerReader<ROOT_TYPE, T,1> {
|
||||
void operator()(Archive<ROOT_TYPE>& ar, const ObjectNamer<T>& namedObject) {
|
||||
const char *objectName = namedObject.name();
|
||||
typename T::Type value;
|
||||
|
||||
bool oldState = ar.success();
|
||||
|
||||
ar.readSequence();
|
||||
|
||||
ObjectNamer<typename T::Type> namedItem = nameObject(objectName, value, namedObject.hint());
|
||||
|
||||
ar._first = true;
|
||||
|
||||
ar >> namedItem;
|
||||
while ( ar._found ) {
|
||||
if ( ar.success() )
|
||||
namedObject.object().add(value);
|
||||
ar._first = false;
|
||||
ar._validObject = true;
|
||||
ar >> namedItem;
|
||||
}
|
||||
|
||||
ar._first = true;
|
||||
|
||||
// Restore old state if not in strict mode otherwise pass it through
|
||||
if ( !ar._strict )
|
||||
ar._validObject = oldState;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template <typename ROOT_TYPE, typename T>
|
||||
struct ContainerReader<ROOT_TYPE,T,0> {
|
||||
void operator()(Archive<ROOT_TYPE>& ar, const ObjectNamer<T>& namedObject) {
|
||||
// goto the object location in the archive
|
||||
const char *classname = checkClassName<ROOT_TYPE>(&namedObject.object(), namedObject.object());
|
||||
ar.read(namedObject.name(), namedObject.object(), classname);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template <typename ROOT_TYPE>
|
||||
template <typename T>
|
||||
inline Archive<ROOT_TYPE>& Archive<ROOT_TYPE>::operator>>(const ObjectIterator<T>& it) {
|
||||
//_validObject = true;
|
||||
_first = it.first();
|
||||
*this >> it.object();
|
||||
_first = true;
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
template <typename ROOT_TYPE>
|
||||
template <typename T>
|
||||
inline Archive<ROOT_TYPE>& Archive<ROOT_TYPE>::operator>>(const ObjectNamer<T>& namedObject) {
|
||||
int h = setChildHint(namedObject.hint());
|
||||
//setHint(h | namedObject.hint());
|
||||
|
||||
//_validObject = true;
|
||||
ContainerReader<ROOT_TYPE,T,boost::is_const<T>::value?1:0> reader;
|
||||
reader(*this, namedObject);
|
||||
|
||||
setHint(h);
|
||||
|
||||
return *this;
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE, typename T>
|
||||
struct VectorReader<ROOT_TYPE, T,1> {
|
||||
void operator()(Archive<ROOT_TYPE>& ar, const ObjectNamer<std::vector<T> >& namedObject) {
|
||||
const char *objectName = namedObject.name();
|
||||
T value;
|
||||
|
||||
bool oldState = ar.success();
|
||||
|
||||
ar.readSequence();
|
||||
ar._first = true;
|
||||
|
||||
ObjectNamer<T> namedItem = nameObject(objectName, value, namedObject.hint());
|
||||
|
||||
ar >> namedItem;
|
||||
while ( ar._found ) {
|
||||
if ( ar.success() )
|
||||
namedObject.object().push_back(value);
|
||||
ar._first = false;
|
||||
ar._validObject = true;
|
||||
ar >> namedItem;
|
||||
}
|
||||
|
||||
ar._first = true;
|
||||
|
||||
// Restore old state if not in strict mode otherwise pass it through
|
||||
if ( !ar._strict )
|
||||
ar._validObject = oldState;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template <typename ROOT_TYPE, typename T>
|
||||
struct VectorReader<ROOT_TYPE,T,0> {
|
||||
void operator()(Archive<ROOT_TYPE>& ar, const ObjectNamer<std::vector<T> >& namedObject) {
|
||||
if ( ar.locateObjectByName(namedObject.name(), nullptr, false) )
|
||||
ar.read(namedObject.object());
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template <typename ROOT_TYPE>
|
||||
template <typename T>
|
||||
inline Archive<ROOT_TYPE>& Archive<ROOT_TYPE>::operator>>(const ObjectNamer<std::vector<T> >& namedObject) {
|
||||
int h = setChildHint(namedObject.hint());
|
||||
//setHint(h | namedObject.hint());
|
||||
|
||||
typedef typename boost::remove_pointer<T>::type RAW_T;
|
||||
|
||||
//_validObject = true;
|
||||
|
||||
VectorReader<ROOT_TYPE,T,
|
||||
boost::is_class<RAW_T>::value?
|
||||
(
|
||||
boost::is_same<std::complex<double>,T>::value?
|
||||
0
|
||||
:
|
||||
(
|
||||
boost::is_same<std::string,T>::value?
|
||||
0
|
||||
:
|
||||
(
|
||||
boost::is_same<Seiscomp::Core::Time,T>::value?
|
||||
0
|
||||
:
|
||||
1
|
||||
)
|
||||
)
|
||||
)
|
||||
:
|
||||
0
|
||||
> reader;
|
||||
|
||||
reader(*this, namedObject);
|
||||
|
||||
setHint(h);
|
||||
|
||||
return *this;
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE, typename T>
|
||||
struct ListReader<ROOT_TYPE, T,1> {
|
||||
void operator()(Archive<ROOT_TYPE>& ar, const ObjectNamer<std::list<T> >& namedObject) {
|
||||
const char *objectName = namedObject.name();
|
||||
T value;
|
||||
|
||||
bool oldState = ar.success();
|
||||
|
||||
ar.readSequence();
|
||||
ar._first = true;
|
||||
|
||||
ObjectNamer<T> namedItem = nameObject(objectName, value, namedObject.hint());
|
||||
|
||||
ar >> namedItem;
|
||||
while ( ar._found ) {
|
||||
if ( ar.success() )
|
||||
namedObject.object().push_back(value);
|
||||
ar._first = false;
|
||||
ar._validObject = true;
|
||||
ar >> namedItem;
|
||||
}
|
||||
|
||||
ar._first = true;
|
||||
|
||||
// Restore old state if not in strict mode otherwise pass it through
|
||||
if ( !ar._strict )
|
||||
ar._validObject = oldState;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template <typename ROOT_TYPE, typename T>
|
||||
struct ListReader<ROOT_TYPE,T,0> {
|
||||
void operator()(Archive<ROOT_TYPE>& ar, const ObjectNamer<std::list<T> >& namedObject) {
|
||||
if ( ar.locateObjectByName(namedObject.name(), nullptr, false) )
|
||||
ar.read(namedObject.object());
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template <typename ROOT_TYPE>
|
||||
template <typename T>
|
||||
inline Archive<ROOT_TYPE>& Archive<ROOT_TYPE>::operator>>(const ObjectNamer<std::list<T> >& namedObject) {
|
||||
int h = setChildHint(namedObject.hint());
|
||||
//setHint(h | namedObject.hint());
|
||||
|
||||
typedef typename boost::remove_pointer<T>::type RAW_T;
|
||||
|
||||
//_validObject = true;
|
||||
ListReader<ROOT_TYPE,T,
|
||||
boost::is_class<RAW_T>::value?
|
||||
(
|
||||
boost::is_same<std::complex<double>,T>::value?
|
||||
0
|
||||
:
|
||||
(
|
||||
boost::is_same<std::string,T>::value?
|
||||
0
|
||||
:
|
||||
(
|
||||
boost::is_same<Seiscomp::Core::Time,T>::value?
|
||||
0
|
||||
:
|
||||
1
|
||||
)
|
||||
)
|
||||
)
|
||||
:
|
||||
0
|
||||
> reader;
|
||||
reader(*this, namedObject);
|
||||
|
||||
setHint(h);
|
||||
|
||||
return *this;
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE>
|
||||
template <typename T>
|
||||
inline Archive<ROOT_TYPE>& Archive<ROOT_TYPE>::operator&(ObjectNamer<T> namedObject) {
|
||||
isReading() ? *this >> namedObject : *this << namedObject;
|
||||
return *this;
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE>
|
||||
template <typename T>
|
||||
inline void Archive<ROOT_TYPE>::read(T*& object) {
|
||||
readPtr(object, object);
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE>
|
||||
template <typename T>
|
||||
inline void Archive<ROOT_TYPE>::read(::boost::intrusive_ptr<T>& object) {
|
||||
T *ref = nullptr;
|
||||
read(ref);
|
||||
object = ref;
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE>
|
||||
template <typename T>
|
||||
inline void Archive<ROOT_TYPE>::read(::boost::optional<T>& object) {
|
||||
bool oldState = success();
|
||||
|
||||
object = T();
|
||||
|
||||
read(*object);
|
||||
if ( !success() )
|
||||
object = boost::none;
|
||||
|
||||
// Restore old state if not in strict mode otherwise pass it through
|
||||
if ( !_strict )
|
||||
_validObject = oldState;
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE>
|
||||
template <typename T>
|
||||
inline void Archive<ROOT_TYPE>::readPtr(ROOT_TYPE*, T*& object) {
|
||||
if ( (hint() & STATIC_TYPE) == 0 ) {
|
||||
std::string className = determineClassName();
|
||||
if ( className.empty() ) return;
|
||||
|
||||
if ( !ClassFactoryInterface<ROOT_TYPE>::IsTypeOf(T::ClassName(), className.c_str()) ) {
|
||||
_validObject = false;
|
||||
return;
|
||||
}
|
||||
object = static_cast<T*>(ClassFactoryInterface<ROOT_TYPE>::Create(className.c_str()));
|
||||
if ( !object )
|
||||
throw ClassNotFound(className);
|
||||
}
|
||||
else {
|
||||
object = static_cast<T*>(ClassFactoryInterface<ROOT_TYPE>::Create(T::ClassName()));
|
||||
if ( !object )
|
||||
throw ClassNotFound(T::ClassName());
|
||||
}
|
||||
|
||||
if ( object )
|
||||
read(*object);
|
||||
else
|
||||
_validObject = false;
|
||||
|
||||
if ( !success() && object ) {
|
||||
delete object;
|
||||
object = nullptr;
|
||||
}
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE>
|
||||
template <typename T>
|
||||
inline void Archive<ROOT_TYPE>::readPtr(void*, T*& object) {
|
||||
object = new T;
|
||||
read(*object);
|
||||
if ( !success() ) {
|
||||
delete object;
|
||||
object = nullptr;
|
||||
}
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE>
|
||||
template <typename T>
|
||||
inline void Archive<ROOT_TYPE>::read(T& object) {
|
||||
typename boost::mpl::if_c<boost::is_base_of<ROOT_TYPE, T>::value,
|
||||
ROOT_TYPE*,
|
||||
TypedSerializeDispatcher<T> >::type t;
|
||||
t = &object;
|
||||
serialize(t);
|
||||
//_validObject = true;
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE>
|
||||
template <typename T>
|
||||
inline void Archive<ROOT_TYPE>::read(const char *name, T &object, const char *targetClass) {
|
||||
if ( findObject(name, targetClass, false) )
|
||||
read(object);
|
||||
else if ( !(boost::is_base_of<std::string, T>::value || boost::is_same<std::string, T>::value) )
|
||||
_validObject = false;
|
||||
else
|
||||
object = T();
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE>
|
||||
template <typename T>
|
||||
inline void Archive<ROOT_TYPE>::read(const char *name, T *&object, const char *targetClass) {
|
||||
if ( findObject(name, targetClass, true) )
|
||||
read(object);
|
||||
else {
|
||||
//_validObject = false;
|
||||
object = nullptr;
|
||||
}
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE>
|
||||
template <typename T>
|
||||
inline void Archive<ROOT_TYPE>::read(const char *name, ::boost::intrusive_ptr<T> &object, const char *targetClass) {
|
||||
if ( findObject(name, targetClass, true) )
|
||||
read(object);
|
||||
else {
|
||||
//_validObject = false;
|
||||
object = nullptr;
|
||||
}
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE>
|
||||
template <typename T>
|
||||
inline void Archive<ROOT_TYPE>::read(const char *name, ::boost::optional<T> &object, const char *targetClass) {
|
||||
if ( findObject(name, targetClass, true) )
|
||||
read(object);
|
||||
else {
|
||||
//_validObject = false;
|
||||
object = boost::none;
|
||||
}
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE>
|
||||
template <typename T>
|
||||
inline void Archive<ROOT_TYPE>::write(T& object) {
|
||||
typename boost::mpl::if_c<boost::is_base_of<ROOT_TYPE, T>::value,
|
||||
ROOT_TYPE*,
|
||||
TypedSerializeDispatcher<T> >::type t;
|
||||
|
||||
t = &object;
|
||||
setClassName(hint() & STATIC_TYPE?nullptr:t->className());
|
||||
serialize(t);
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE>
|
||||
template <typename T>
|
||||
inline void Archive<ROOT_TYPE>::write(T *object) {
|
||||
write(*object);
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE>
|
||||
template <typename T>
|
||||
inline void Archive<ROOT_TYPE>::write(const char *name, T &object, const char *targetClass) {
|
||||
// goto the object location in the archive
|
||||
findObject(name, targetClass, false);
|
||||
// write the object data
|
||||
write(object);
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE>
|
||||
template <typename T>
|
||||
inline void Archive<ROOT_TYPE>::write(const char *name, T *object, const char *targetClass) {
|
||||
if ( !object ) {
|
||||
locateNullObjectByName(name, targetClass, _first);
|
||||
return;
|
||||
}
|
||||
findObject(name, targetClass, true);
|
||||
// write the object data
|
||||
write(*object);
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE>
|
||||
template <typename T>
|
||||
inline void Archive<ROOT_TYPE>::write(const char *name, ::boost::intrusive_ptr<T> &object, const char *targetClass) {
|
||||
write(name, object.get(), targetClass);
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
|
||||
|
||||
|
||||
|
||||
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
|
||||
template <typename ROOT_TYPE>
|
||||
template <typename T>
|
||||
inline void Archive<ROOT_TYPE>::write(const char *name, ::boost::optional<T> &object, const char *targetClass) {
|
||||
write(name, object.get_ptr(), targetClass);
|
||||
}
|
||||
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
||||
Reference in New Issue
Block a user