feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

ModelEditor: Introduce newest version of qtserialization framework

Browse Source 
This change unfortunately contains many single changes because it is an
update of the 3rd party component:

* Introduce new Parameter class for better serialization of containers
and other future enhancements
* Delete dead code
* Introduce user data in base archive class
* Fix minor source code issues and typos in comments
* Remove unused and conceptionally broken support of forward refernces
* Fix a memory leak in QXmlInArchive
* prefer load()/save() methods over stream operators
* throw exception on unsuported forward references in QXmlOutArchive
* refactor serialization of pointer types into own header
* remove unneeded specialisation for serialization of free functions
* check for default value of serialization using a getter

Change-Id: Ic197a92b00b22b85dab4a1b88c431cf4da8b3c3b
Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
This commit is contained in:
Jochen Becher
2015-10-09 21:12:53 +02:00
parent f4628dcc8c
commit 0d309fc8c0
18 changed files with 731 additions and 375 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
src/libs/3rdparty/modeling/qtserialization/inc/qark/access.h vendored
View File

@@ -55,12 +55,24 @@ void save(Archive &archive, const T &t)
Access<Archive, T>::save(archive, t);
}
template<class Archive, class T>
void save(Archive &archive, const T &t, const Parameters &)
{
save(archive, t);
}
template<class Archive, class T>
void load(Archive &archive, T &t)
{
Access<Archive, T>::load(archive, t);
}
template<class Archive, class T>
void load(Archive &archive, T &t, const Parameters &)
{
load(archive, t);
}
template<class Archive, class T>
void serialize(Archive &archive, T &t)
{
@@ -92,30 +104,9 @@ void serialize_helper(Archive &archive, T &t)
static inline void serialize(Archive &archive, TYPE &); \
};
#if 0
#define QARK_ACCESS_SPECIALIZE_LOAD_SAVE(INARCHIVE, OUTARCHIVE, TYPE) \
template<> class Access<INARCHIVE, TYPE> { public: static inline void load(INARCHIVE &archive, TYPE &); void serialize(INARCHIVE &, TYPE &); }; \
template<> class Access<OUTARCHIVE, TYPE> { public: static inline void save(OUTARCHIVE &archive, const TYPE &); void serialize(OUTARCHIVE &, TYPE &); }; \
void Access<INARCHIVE, TYPE>::serialize(INARCHIVE &, TYPE &) { } \
void Access<OUTARCHIVE, TYPE>::serialize(OUTARCHIVE &, TYPE &) { } \
template class Access<INARCHIVE, TYPE>; \
template class Access<OUTARCHIVE, TYPE>;
#endif
#define QARK_ACCESS_SPECIALIZE(INARCHIVE, OUTARCHIVE, TYPE) \
template class Access<INARCHIVE, TYPE>; \
template class Access<OUTARCHIVE, TYPE>;
#if 0
#define QARK_SPECIALIZE_SERIALIZE(INARCHIVE, OUTARCHIVE, TYPE) \
QARK_ACCESS_SPECIALIZE(INARCHIVE, OUTARCHIVE, TYPE); \
template void serialize<INARCHIVE, TYPE>(INARCHIVE &, TYPE &); \
template void serialize<OUTARCHIVE, TYPE>(OUTARCHIVE &, TYPE &);
#define QARK_SPECIALIZE_LOAD_SAVE(INARCHIVE, OUTARCHIVE, TYPE) \
template void load<INARCHIVE, TYPE>(INARCHIVE &, TYPE &); \
template void save<OUTARCHIVE, TYPE>(OUTARCHIVE &, const TYPE &);
#endif
#endif // QARK_ACCESS_H

36
src/libs/3rdparty/modeling/qtserialization/inc/qark/archivebasics.h vendored
View File

@@ -33,6 +33,10 @@
#include "flag.h"
#include <QVariant>
#include <QString>
#include <QHash>
namespace qark {
class ArchiveBasics
@@ -48,8 +52,40 @@ public:
bool takeFlag(const Flag &flag) { bool f = (_flags & flag.getMask()) != 0; _flags &= ~flag.getMask(); return f; }
bool hasUserData(const QString &key)
{
return _user_data.contains(key);
}
template<typename T>
T getUserData(const QString &key)
{
return _user_data.value(key).value<T>();
}
template<typename T>
T getUserData(const QString &key, const T &default_value)
{
// gcc 4.8.2 fails to compile if the following 2 statements are written in one expression
//return _user_data.value(key, data).value<T>();
QVariant v = _user_data.value(key, default_value);
return v.value<T>();
}
template<class T>
void setUserData(const QString &key, const T &data)
{
_user_data.insert(key, data);
}
void removeUserData(const QString &key)
{
_user_data.remove(key);
}
private:
Flag::mask_type _flags;
QHash<QString, QVariant> _user_data;
};
}

142
src/libs/3rdparty/modeling/qtserialization/inc/qark/attribute.h vendored
View File

@@ -31,6 +31,8 @@
#ifndef QARK_ATTRIBUTE_H
#define QARK_ATTRIBUTE_H
#include "parameters.h"
#include <QString>
namespace qark {
@@ -38,19 +40,29 @@ namespace qark {
template<typename T>
class Attr {
public:
explicit Attr(const QString &qualified_name, T *value)
Attr(const QString &qualified_name, T *value)
: _qualified_name(qualified_name),
_value(value)
{
}
Attr(const QString &qualified_name, T *value, const Parameters &parameters)
: _qualified_name(qualified_name),
_value(value),
_parameters(parameters)
{
}
const QString &getQualifiedName() const { return _qualified_name; }
T *getValue() const { return _value; }
Parameters getParameters() const { return _parameters; }
private:
QString _qualified_name;
T *_value;
Parameters _parameters;
};
template<typename T>
@@ -59,33 +71,56 @@ Attr<T * const> attr(const QString &qualified_name, T * const &value)
return Attr<T * const>(qualified_name, &value);
}
template<typename T>
Attr<T * const> attr(const QString &qualified_name, T * const &value, const Parameters &parameters)
{
return Attr<T * const>(qualified_name, &value, parameters);
}
template<typename T>
Attr<T> attr(const QString &qualified_name, T &value)
{
return Attr<T>(qualified_name, &value);
}
template<typename T>
Attr<T> attr(const QString &qualified_name, T &value, const Parameters &parameters)
{
return Attr<T>(qualified_name, &value, parameters);
}
template<class U, typename T>
class GetterAttr {
public:
explicit GetterAttr(const QString &qualified_name, const U &u, T (U::*getter)() const)
GetterAttr(const QString &qualified_name, const U &u, T (U::*getter)() const)
: _qualified_name(qualified_name),
_u(u),
_getter(getter)
{
}
GetterAttr(const QString &qualified_name, const U &u, T (U::*getter)() const, const Parameters &parameters)
: _qualified_name(qualified_name),
_u(u),
_getter(getter),
_parameters(parameters)
{
}
const QString &getQualifiedName() const { return _qualified_name; }
const U &getObject() const { return _u; }
T (U::*getGetter() const)() const { return _getter; }
Parameters getParameters() const { return _parameters; }
private:
QString _qualified_name;
const U &_u;
T (U::*_getter)() const;
Parameters _parameters;
};
template<class U, typename T>
@@ -94,27 +129,44 @@ GetterAttr<U, T> attr(const QString &qualified_name, const U &u, T (U::*getter)(
return GetterAttr<U, T>(qualified_name, u, getter);
}
template<class U, typename T>
GetterAttr<U, T> attr(const QString &qualified_name, const U &u, T (U::*getter)() const, const Parameters &parameters)
{
return GetterAttr<U, T>(qualified_name, u, getter, parameters);
}
template<class U, typename T>
class SetterAttr {
public:
explicit SetterAttr(const QString &qualified_name, U &u, void (U::*setter)(T))
SetterAttr(const QString &qualified_name, U &u, void (U::*setter)(T))
: _qualified_name(qualified_name),
_u(u),
_setter(setter)
{
}
SetterAttr(const QString &qualified_name, U &u, void (U::*setter)(T), const Parameters &parameters)
: _qualified_name(qualified_name),
_u(u),
_setter(setter),
_parameters(parameters)
{
}
const QString &getQualifiedName() const { return _qualified_name; }
U &getObject() const { return _u; }
void (U::*getSetter() const)(T) { return _setter; }
Parameters getParameters() const { return _parameters; }
private:
QString _qualified_name;
U &_u;
void (U::*_setter)(T);
Parameters _parameters;
};
template<class U, typename T>
@@ -123,11 +175,17 @@ SetterAttr<U, T> attr(const QString &qualified_name, U &u, void (U::*setter)(T))
return SetterAttr<U, T>(qualified_name, u, setter);
}
template<class U, typename T>
SetterAttr<U, T> attr(const QString &qualified_name, U &u, void (U::*setter)(T), const Parameters &parameters)
{
return SetterAttr<U, T>(qualified_name, u, setter, parameters);
}
template<class U, typename T, typename V>
class GetterSetterAttr {
public:
explicit GetterSetterAttr(const QString &qualified_name, U &u, T (U::*getter)() const, void (U::*setter)(V))
GetterSetterAttr(const QString &qualified_name, U &u, T (U::*getter)() const, void (U::*setter)(V))
: _qualified_name(qualified_name),
_u(u),
_getter(getter),
@@ -135,6 +193,15 @@ public:
{
}
GetterSetterAttr(const QString &qualified_name, U &u, T (U::*getter)() const, void (U::*setter)(V), const Parameters &parameters)
: _qualified_name(qualified_name),
_u(u),
_getter(getter),
_setter(setter),
_parameters(parameters)
{
}
const QString &getQualifiedName() const { return _qualified_name; }
U &getObject() const { return _u; }
@@ -143,11 +210,14 @@ public:
void (U::*getSetter() const)(V) { return _setter; }
Parameters getParameters() const { return _parameters; }
private:
QString _qualified_name;
U &_u;
T (U::*_getter)() const;
void (U::*_setter)(V);
Parameters _parameters;
};
template<class U, typename T, typename V>
@@ -156,27 +226,44 @@ GetterSetterAttr<U, T, V> attr(const QString &qualified_name, U &u, T (U::*gette
return GetterSetterAttr<U, T, V>(qualified_name, u, getter, setter);
}
template<class U, typename T, typename V>
GetterSetterAttr<U, T, V> attr(const QString &qualified_name, U &u, T (U::*getter)() const, void (U::*setter)(V), const Parameters &parameters)
{
return GetterSetterAttr<U, T, V>(qualified_name, u, getter, setter, parameters);
}
template<class U, typename T>
class GetFuncAttr {
public:
explicit GetFuncAttr(const QString &qualified_name, U &u, T (*get_func)(const U &))
GetFuncAttr(const QString &qualified_name, U &u, T (*get_func)(const U &))
: _qualified_name(qualified_name),
_u(u),
_get_func(get_func)
{
}
GetFuncAttr(const QString &qualified_name, U &u, T (*get_func)(const U &), const Parameters &parameters)
: _qualified_name(qualified_name),
_u(u),
_get_func(get_func),
_parameters(parameters)
{
}
const QString &getQualifiedName() const { return _qualified_name; }
U &getObject() const { return _u; }
T (*getGetFunc() const)(const U &) { return _get_func; }
Parameters getParameters() const { return _parameters; }
private:
QString _qualified_name;
U &_u;
T (*_get_func)(const U &);
Parameters _parameters;
};
template<class U, typename T>
@@ -185,27 +272,44 @@ GetFuncAttr<U, T> attr(const QString &qualified_name, const U &u, T (*get_func)(
return GetFuncAttr<U, T>(qualified_name, u, get_func);
}
template<class U, typename T>
GetFuncAttr<U, T> attr(const QString &qualified_name, const U &u, T (*get_func)(const U &), const Parameters &parameters)
{
return GetFuncAttr<U, T>(qualified_name, u, get_func, parameters);
}
template<class U, typename T>
class SetFuncAttr {
public:
explicit SetFuncAttr(const QString &qualified_name, U &u, void (*set_func)(U &, T))
SetFuncAttr(const QString &qualified_name, U &u, void (*set_func)(U &, T))
: _qualified_name(qualified_name),
_u(u),
_set_func(set_func)
{
}
SetFuncAttr(const QString &qualified_name, U &u, void (*set_func)(U &, T), const Parameters &parameters)
: _qualified_name(qualified_name),
_u(u),
_set_func(set_func),
_parameters(parameters)
{
}
const QString &getQualifiedName() const { return _qualified_name; }
U &getObject() const { return _u; }
void (*getSetFunc() const)(U &, T) { return _set_func; }
Parameters getParameters() const { return _parameters; }
private:
QString _qualified_name;
U &_u;
void (*_set_func)(U &, T);
Parameters _parameters;
};
template<class U, typename T>
@@ -214,11 +318,17 @@ SetFuncAttr<U, T> attr(const QString &qualified_name, U &u, void (*set_func)(U &
return SetFuncAttr<U, T>(qualified_name, u, set_func);
}
template<class U, typename T>
SetFuncAttr<U, T> attr(const QString &qualified_name, U &u, void (*set_func)(U &, T), const Parameters &parameters)
{
return SetFuncAttr<U, T>(qualified_name, u, set_func, parameters);
}
template<class U, typename T, typename V>
class GetSetFuncAttr {
public:
explicit GetSetFuncAttr(const QString &qualified_name, U &u, T (*get_func)(const U &), void (*set_func)(U &, V))
GetSetFuncAttr(const QString &qualified_name, U &u, T (*get_func)(const U &), void (*set_func)(U &, V))
: _qualified_name(qualified_name),
_u(u),
_get_func(get_func),
@@ -226,6 +336,15 @@ public:
{
}
GetSetFuncAttr(const QString &qualified_name, U &u, T (*get_func)(const U &), void (*set_func)(U &, V), const Parameters &parameters)
: _qualified_name(qualified_name),
_u(u),
_get_func(get_func),
_set_func(set_func),
_parameters(parameters)
{
}
const QString &getQualifiedName() const { return _qualified_name; }
U &getObject() const { return _u; }
@@ -234,11 +353,14 @@ public:
void (*getSetFunc() const)(U &, V) { return _set_func; }
Parameters getParameters() const { return _parameters; }
private:
QString _qualified_name;
U &_u;
T (*_get_func)(const U &);
void (*_set_func)(U &, V);
Parameters _parameters;
};
template<class U, typename T, typename V>
@@ -247,6 +369,12 @@ GetSetFuncAttr<U, T, V> attr(const QString &qualified_name, U &u, T (*get_func)(
return GetSetFuncAttr<U, T, V>(qualified_name, u, get_func, set_func);
}
template<class U, typename T, typename V>
GetSetFuncAttr<U, T, V> attr(const QString &qualified_name, U &u, T (*get_func)(const U &), void (*set_func)(U &, V), const Parameters &parameters)
{
return GetSetFuncAttr<U, T, V>(qualified_name, u, get_func, set_func, parameters);
}
}
#endif // QARK_ATTRIBUTE_H

31
src/libs/3rdparty/modeling/qtserialization/inc/qark/baseclass.h vendored
View File

@@ -32,6 +32,7 @@
#define QARK_BASECLASS_H
#include "typeregistry.h"
#include "parameters.h"
#include <QString>
@@ -41,21 +42,31 @@ namespace qark {
template<class BASE, class DERIVED>
class Base {
public:
explicit Base(const QString &qualified_name, DERIVED &obj)
Base(const QString &qualified_name, DERIVED &obj)
: _qualified_name(qualified_name),
_base(obj)
{
}
Base(const QString &qualified_name, DERIVED &obj, const Parameters &parameters)
: _qualified_name(qualified_name),
_base(obj),
_parameters(parameters)
{
}
const QString &getQualifiedName() const { return _qualified_name; }
const BASE &getBase() const { return _base; }
BASE &getBase() { return _base; }
Parameters getParameters() const { return _parameters; }
private:
QString _qualified_name;
BASE &_base;
Parameters _parameters;
};
template<class BASE, class DERIVED>
@@ -64,18 +75,36 @@ Base<BASE, DERIVED> base(const QString &qualified_name, DERIVED &obj)
return Base<BASE, DERIVED>(qualified_name, obj);
}
template<class BASE, class DERIVED>
Base<BASE, DERIVED> base(const QString &qualified_name, DERIVED &obj, const Parameters &parameters)
{
return Base<BASE, DERIVED>(qualified_name, obj, parameters);
}
template<class BASE, class DERIVED>
Base<BASE, DERIVED> base(const QString &qualified_name, DERIVED *&obj)
{
return Base<BASE, DERIVED>(qualified_name, *obj);
}
template<class BASE, class DERIVED>
Base<BASE, DERIVED> base(const QString &qualified_name, DERIVED *&obj, const Parameters &parameters)
{
return Base<BASE, DERIVED>(qualified_name, *obj, parameters);
}
template<class BASE, class DERIVED>
Base<BASE, DERIVED> base(DERIVED &obj)
{
return Base<BASE, DERIVED>(QString(QStringLiteral("base-%1")).arg(get_type_uid<BASE>()), obj);
}
template<class BASE, class DERIVED>
Base<BASE, DERIVED> base(DERIVED &obj, const Parameters &parameters)
{
return Base<BASE, DERIVED>(QString(QStringLiteral("base-%1")).arg(get_type_uid<BASE>()), obj, parameters);
}
}
#endif // QARK_BASECLASS_H

4
src/libs/3rdparty/modeling/qtserialization/inc/qark/friend_access.h vendored
View File

@@ -28,8 +28,8 @@
**
****************************************************************************/
#ifndef QMT_FRIEND_ACCESS_H
#define QMT_FRIEND_ACCESS_H
#ifndef QARK_FRIEND_ACCESS_H
#define QARK_FRIEND_ACCESS_H
#define QARK_FRIEND_ACCESS \
template<class Archive, class T> \

71
src/libs/3rdparty/modeling/qtserialization/inc/qark/parameters.h vendored Normal file
View File

@@ -0,0 +1,71 @@
/***************************************************************************
**
** Copyright (C) 2015 Jochen Becher
** Contact: http://www.qt.io/licensing
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms and
** conditions see http://www.qt.io/terms-conditions. For further information
** use the contact form at http://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, The Qt Company gives you certain additional
** rights. These rights are described in The Qt Company LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
****************************************************************************/
#ifndef QARK_PARAMETER_H
#define QARK_PARAMETER_H
#include "flag.h"
namespace qark {
class Parameters
{
public:
Parameters()
: _flags(0)
{
}
Parameters(const Flag &flag)
: _flags(flag.getMask())
{
}
public:
void setFlag(const Flag &flag) { _flags |= flag.getMask(); }
void clearFlag(const Flag &flag) { _flags &= ~flag.getMask(); }
bool hasFlag(const Flag &flag) const { return (_flags & flag.getMask()) != 0; }
bool takeFlag(const Flag &flag) { bool f = (_flags & flag.getMask()) != 0; _flags &= ~flag.getMask(); return f; }
private:
Flag::mask_type _flags;
};
}
#endif // QARK_PARAMETER_H

207
src/libs/3rdparty/modeling/qtserialization/inc/qark/qxmlinarchive.h vendored
View File

@@ -75,7 +75,7 @@ private:
typedef QList<Node *> children_type;
public:
virtual ~Node() { }
virtual ~Node() { qDeleteAll(_children); }
const children_type &getChildren() const { return _children; }
@@ -83,8 +83,6 @@ private:
virtual void accept(QXmlInArchive &visitor, const XmlTag &tag) { visitor.visit(this, tag); }
virtual void acceptForwardRef(QXmlInArchive &visitor, const impl::ObjectId &id) { visitor.visitForwardRef(this, id); }
void append(Node *node) { _children.push_back(node); }
private:
@@ -237,8 +235,6 @@ private:
void accept(QXmlInArchive &visitor, const XmlTag &tag) { visitor.visit(this, tag); }
void acceptForwardRef(QXmlInArchive &visitor, const impl::ObjectId &id) { visitor.visitForwardRef(this, id); }
Ref<T> &getReference() { return _ref; }
private:
@@ -256,8 +252,6 @@ private:
void accept(QXmlInArchive &visitor, const XmlTag &tag) { visitor.visit(this, tag); }
void acceptForwardRef(QXmlInArchive &visitor, const impl::ObjectId &id) { visitor.visitForwardRef(this, id); }
SetterRef<U, T> &getReference() { return _ref; }
private:
@@ -275,8 +269,6 @@ private:
void accept(QXmlInArchive &visitor, const XmlTag &tag) { visitor.visit(this, tag); }
void acceptForwardRef(QXmlInArchive &visitor, const impl::ObjectId &id) { visitor.visitForwardRef(this, id); }
GetterSetterRef<U, T, V> &getReference() { return _ref; }
private:
@@ -294,8 +286,6 @@ private:
void accept(QXmlInArchive &visitor, const XmlTag &tag) { visitor.visit(this, tag); }
void acceptForwardRef(QXmlInArchive &visitor, const impl::ObjectId &id) { visitor.visitForwardRef(this, id); }
SetFuncRef<U, T> &getReference() { return _ref; }
private:
@@ -313,35 +303,23 @@ private:
void accept(QXmlInArchive &visitor, const XmlTag &tag) { visitor.visit(this, tag); }
void acceptForwardRef(QXmlInArchive &visitor, const impl::ObjectId &id) { visitor.visitForwardRef(this, id); }
GetSetFuncRef<U, T, V> &getReference() { return _ref; }
private:
GetSetFuncRef<U, T, V> _ref;
};
struct ForwardReference {
ForwardReference(Node *node, const impl::ObjectId &id) : _node(node), _id(id) { }
Node *_node;
impl::ObjectId _id;
};
public:
explicit QXmlInArchive(QXmlStreamReader &stream)
: _stream(stream),
_end_tag_was_read(false),
_root_node(0),
_current_ref_node(0)
{
}
~QXmlInArchive()
{
foreach(const ForwardReference &forward_ref, _forward_references) {
forward_ref._node->acceptForwardRef(*this, forward_ref._id);
}
}
public:
@@ -387,9 +365,7 @@ public:
void append(const Tag &tag)
{
TagNode *node = new TagNode(tag);
if (_node_stack.empty()) {
_root_node = node;
} else {
if (!_node_stack.empty()) {
_node_stack.top()->append(node);
}
_node_stack.push(node);
@@ -399,9 +375,7 @@ public:
void append(const Object<T> &object)
{
ObjectNode<T> *node = new ObjectNode<T>(object);
if (_node_stack.empty()) {
_root_node = node;
} else {
if (!_node_stack.empty()) {
_node_stack.top()->append(node);
}
_node_stack.push(node);
@@ -409,13 +383,14 @@ public:
void append(const End &)
{
_node_stack.pop();
Node *node = _node_stack.pop();
if (_node_stack.empty()) {
XmlTag xml_tag = readTag();
if (xml_tag._tag_name != _root_node->getQualifiedName() || xml_tag._end_tag) {
if (xml_tag._tag_name != node->getQualifiedName() || xml_tag._end_tag) {
throw FileFormatException();
}
_root_node->accept(*this, xml_tag);
node->accept(*this, xml_tag);
delete node;
}
}
@@ -587,12 +562,7 @@ public:
if (_loading_ref_map.hasObject(id)) {
p = _loading_ref_map.getObject<T *>(id);
} else {
if (_current_ref_node == 0) {
throw UnexpectedForwardReference();
}
_forward_references.append(ForwardReference(_current_ref_node, id));
// node is eaten, also used as flag for forward references
_current_ref_node = 0;
throw UnexpectedForwardReference();
}
}
@@ -634,11 +604,6 @@ private:
throw FileFormatException();
}
void visitForwardRef(Node *, const impl::ObjectId &)
{
throw UnexpectedForwardReference();
}
void visit(TagNode *node, const XmlTag &)
{
readChildren(node);
@@ -656,7 +621,7 @@ private:
template<class T, class U>
void visit(BaseNode<T, U> *node, const XmlTag &)
{
(*this) >> node->getBase().getBase();
load(*this, node->getBase().getBase(), node->getBase().getParameters());
XmlTag xml_tag = readTag();
if (!xml_tag._end_tag || xml_tag._tag_name != node->getBase().getQualifiedName()) {
throw FileFormatException();
@@ -666,7 +631,7 @@ private:
template<class T>
void visit(AttrNode<T> *node, const XmlTag &)
{
(*this) >> *node->getAttribute().getValue();
load(*this, *node->getAttribute().getValue(), node->getAttribute().getParameters());
XmlTag xml_tag = readTag();
if (!xml_tag._end_tag || xml_tag._tag_name != node->getAttribute().getQualifiedName()) {
throw FileFormatException();
@@ -677,7 +642,7 @@ private:
void visit(SetterAttrNode<U, T> *node, const XmlTag &)
{
T value;
(*this) >> value;
load(*this, value, node->getAttribute().getParameters());
(node->getAttribute().getObject().*(node->getAttribute().getSetter()))(value);
XmlTag xml_tag = readTag();
if (!xml_tag._end_tag || xml_tag._tag_name != node->getAttribute().getQualifiedName()) {
@@ -689,7 +654,7 @@ private:
void visit(SetterAttrNode<U, const T &> *node, const XmlTag &)
{
T value;
(*this) >> value;
load(*this, value, node->getAttribute().getParameters());
(node->getAttribute().getObject().*(node->getAttribute().getSetter()))(value);
XmlTag xml_tag = readTag();
if (!xml_tag._end_tag || xml_tag._tag_name != node->getAttribute().getQualifiedName()) {
@@ -701,7 +666,7 @@ private:
void visit(GetterSetterAttrNode<U, T, V> *node, const XmlTag &)
{
V value;
(*this) >> value;
load(*this, value, node->getAttribute().getParameters());
(node->getAttribute().getObject().*(node->getAttribute().getSetter()))(value);
XmlTag xml_tag = readTag();
if (!xml_tag._end_tag || xml_tag._tag_name != node->getAttribute().getQualifiedName()) {
@@ -713,7 +678,7 @@ private:
void visit(GetterSetterAttrNode<U, T, const V &> *node, const XmlTag &)
{
V value;
(*this) >> value;
load(*this, value, node->getAttribute().getParameters());
(node->getAttribute().getObject().*(node->getAttribute().getSetter()))(value);
XmlTag xml_tag = readTag();
if (!xml_tag._end_tag || xml_tag._tag_name != node->getAttribute().getQualifiedName()) {
@@ -725,7 +690,7 @@ private:
void visit(SetFuncAttrNode<U, T> *node, const XmlTag &)
{
T value;
(*this) >> value;
load(*this, value, node->getAttribute().getParameters());
(node->getAttribute().getSetFunc())(node->getAttribute().getObject(), value);
XmlTag xml_tag = readTag();
if (!xml_tag._end_tag || xml_tag._tag_name != node->getAttribute().getQualifiedName()) {
@@ -737,7 +702,7 @@ private:
void visit(SetFuncAttrNode<U, const T &> *node, const XmlTag &)
{
T value;
(*this) >> value;
load(*this, value, node->getAttribute().getParameters());
(node->getAttribute().getSetFunc())(node->getAttribute().getObject(), value);
XmlTag xml_tag = readTag();
if (!xml_tag._end_tag || xml_tag._tag_name != node->getAttribute().getQualifiedName()) {
@@ -749,7 +714,7 @@ private:
void visit(GetSetFuncAttrNode<U, T, V> *node, const XmlTag &)
{
V value;
(*this) >> value;
load(*this, value, node->getAttribute().getParameters());
(node->getAttribute().getSetFunc())(node->getAttribute().getObject(), value);
XmlTag xml_tag = readTag();
if (!xml_tag._end_tag || xml_tag._tag_name != node->getAttribute().getQualifiedName()) {
@@ -761,7 +726,7 @@ private:
void visit(GetSetFuncAttrNode<U, T, const V &> *node, const XmlTag &)
{
V value;
(*this) >> value;
load(*this, value, node->getAttribute().getParameters());
(node->getAttribute().getSetFunc())(node->getAttribute().getObject(), value);
XmlTag xml_tag = readTag();
if (!xml_tag._end_tag || xml_tag._tag_name != node->getAttribute().getQualifiedName()) {
@@ -774,8 +739,8 @@ private:
{
_current_ref_node = node;
T value = T();
(*this) >> value;
if (_current_ref_node != 0) { // ref node was not eaten by forward reference
load(*this, value, node->getReference().getParameters());
if (_current_ref_node != 0) { // ref node was not consumed by forward reference
*node->getReference().getValue() = value;
_current_ref_node = 0;
}
@@ -785,23 +750,13 @@ private:
}
}
template<typename T>
void visitForwardRef(RefNode<T> *node, const impl::ObjectId &id)
{
if (!_loading_ref_map.hasObject(id)) {
throw UnexpectedForwardReference();
}
T value = _loading_ref_map.getObject<T>(id);
*(node->getReference().getValue()) = value;
}
template<class U, typename T>
void visit(SetterRefNode<U, T> *node, const XmlTag &)
{
_current_ref_node = node;
T value;
(*this) >> value;
if (_current_ref_node != 0) { // ref node was not eaten by forward reference
load(*this, value, node->getReference().getParameters());
if (_current_ref_node != 0) { // ref node was not consumed by forward reference
(node->getReference().getObject().*(node->getReference().getSetter()))(value);
_current_ref_node = 0;
}
@@ -816,8 +771,8 @@ private:
{
_current_ref_node = node;
T value;
(*this) >> value;
if (_current_ref_node != 0) { // ref node was not eaten by forward reference
load(*this, value, node->getReference().getParameters());
if (_current_ref_node != 0) { // ref node was not consumed by forward reference
(node->getReference().getObject().*(node->getReference().getSetter()))(value);
_current_ref_node = 0;
}
@@ -827,33 +782,13 @@ private:
}
}
template<class U, typename T>
void visitForwardRef(SetterRefNode<U, T> *node, const impl::ObjectId &id)
{
if (!_loading_ref_map.hasObject(id)) {
throw UnexpectedForwardReference();
}
T value = _loading_ref_map.getObject<T>(id);
(node->getReference().getObject().*(node->getReference().getSetter()))(value);
}
template<class U, typename T>
void visitForwardRef(SetterRefNode<U, T const &> *node, const impl::ObjectId &id)
{
if (!_loading_ref_map.hasObject(id)) {
throw UnexpectedForwardReference();
}
T value = _loading_ref_map.getObject<T>(id);
(node->getReference().getObject().*(node->getReference().getSetter()))(value);
}
template<class U, typename T, typename V>
void visit(GetterSetterRefNode<U, T, V> *node, const XmlTag &)
{
_current_ref_node = node;
V value;
(*this) >> value;
if (_current_ref_node != 0) { // ref node was not eaten by forward reference
load(*this, value, node->getReference().getParameters());
if (_current_ref_node != 0) { // ref node was not consumed by forward reference
(node->getReference().getObject().*(node->getReference().getSetter()))(value);
_current_ref_node = 0;
}
@@ -868,8 +803,8 @@ private:
{
_current_ref_node = node;
V value;
(*this) >> value;
if (_current_ref_node != 0) { // ref node was not eaten by forward reference
load(*this, value, node->getReference().getParameters());
if (_current_ref_node != 0) { // ref node was not consumed by forward reference
(node->getReference().getObject().*(node->getReference().getSetter()))(value);
_current_ref_node = 0;
}
@@ -879,34 +814,14 @@ private:
}
}
template<class U, typename T, typename V>
void visitForwardRef(GetterSetterRefNode<U, T, V> *node, const impl::ObjectId &id)
{
if (!_loading_ref_map.hasObject(id)) {
throw UnexpectedForwardReference();
}
V value = _loading_ref_map.getObject<V>(id);
(node->getReference().getObject().*(node->getReference().getSetter()))(value);
}
template<class U, typename T, typename V>
void visitForwardRef(GetterSetterRefNode<U, T, V const &> *node, const impl::ObjectId &id)
{
if (!_loading_ref_map.hasObject(id)) {
throw UnexpectedForwardReference();
}
V value = _loading_ref_map.getObject<V>(id);
(node->getReference().getObject().*(node->getReference().getSetter()))(value);
}
template<class U, typename T>
void visit(SetFuncRefNode<U, T> *node, const XmlTag &)
{
_current_ref_node = node;
T value;
(*this) >> value;
if (_current_ref_node != 0) { // ref node was not eaten by forward reference
(node->getReference().getObject().*(node->getReference().getSetter()))(value);
load(*this, value, node->getReference().getParameters());
if (_current_ref_node != 0) { // ref node was not consumed by forward reference
(node->getReference().getSetFunc())(node->getReference().getObject(), value);
_current_ref_node = 0;
}
XmlTag xml_tag = readTag();
@@ -920,9 +835,9 @@ private:
{
_current_ref_node = node;
T value;
(*this) >> value;
if (_current_ref_node != 0) { // ref node was not eaten by forward reference
(node->getReference().getObject().*(node->getReference().getSetter()))(value);
load(*this, value, node->getReference().getParameters());
if (_current_ref_node != 0) { // ref node was not consumed by forward reference
(node->getReference().getSetFunc())(node->getReference().getObject(), value);
_current_ref_node = 0;
}
XmlTag xml_tag = readTag();
@@ -931,34 +846,14 @@ private:
}
}
template<class U, typename T>
void visitForwardRef(SetFuncRefNode<U, T> *node, const impl::ObjectId &id)
{
if (!_loading_ref_map.hasObject(id)) {
throw UnexpectedForwardReference();
}
T value = _loading_ref_map.getObject<T>(id);
(node->getReference().getObject().*(node->getReference().getSetter()))(value);
}
template<class U, typename T>
void visitForwardRef(SetFuncRefNode<U, T const &> *node, const impl::ObjectId &id)
{
if (!_loading_ref_map.hasObject(id)) {
throw UnexpectedForwardReference();
}
T value = _loading_ref_map.getObject<T>(id);
(node->getReference().getObject().*(node->getReference().getSetter()))(value);
}
template<class U, typename T, typename V>
void visit(GetSetFuncRefNode<U, T, V> *node, const XmlTag &)
{
_current_ref_node = node;
V value;
(*this) >> value;
if (_current_ref_node != 0) { // ref node was not eaten by forward reference
(node->getReference().getObject().*(node->getReference().getSetter()))(value);
load(*this, value, node->getReference().getParameters());
if (_current_ref_node != 0) { // ref node was not consumed by forward reference
(node->getReference().getSetFunc())(node->getReference().getObject(), value);
_current_ref_node = 0;
}
XmlTag xml_tag = readTag();
@@ -972,9 +867,9 @@ private:
{
_current_ref_node = node;
V value;
(*this) >> value;
if (_current_ref_node != 0) { // ref node was not eaten by forward reference
(node->getReference().getObject().*(node->getReference().getSetter()))(value);
load(*this, value, node->getReference().getParameters());
if (_current_ref_node != 0) { // ref node was not consumed by forward reference
(node->getReference().getSetFunc())(node->getReference().getObject(), value);
_current_ref_node = 0;
}
XmlTag xml_tag = readTag();
@@ -983,26 +878,6 @@ private:
}
}
template<class U, typename T, typename V>
void visitForwardRef(GetSetFuncRefNode<U, T, V> *node, const impl::ObjectId &id)
{
if (!_loading_ref_map.hasObject(id)) {
throw UnexpectedForwardReference();
}
V value = _loading_ref_map.getObject<V>(id);
(node->getReference().getObject().*(node->getReference().getSetter()))(value);
}
template<class U, typename T, typename V>
void visitForwardRef(GetSetFuncRefNode<U, T, V const &> *node, const impl::ObjectId &id)
{
if (!_loading_ref_map.hasObject(id)) {
throw UnexpectedForwardReference();
}
V value = _loading_ref_map.getObject<V>(id);
(node->getReference().getObject().*(node->getReference().getSetter()))(value);
}
private:
inline XmlTag readTag();
@@ -1012,11 +887,9 @@ private:
private:
QXmlStreamReader &_stream;
bool _end_tag_was_read;
Node *_root_node;
QStack<Node *> _node_stack;
impl::LoadingRefMap _loading_ref_map;
Node *_current_ref_node;
QList<ForwardReference> _forward_references;
};

11
src/libs/3rdparty/modeling/qtserialization/inc/qark/qxmloutarchive.h vendored
View File

@@ -49,8 +49,13 @@ class QXmlOutArchive :
{
public:
class UnsupportedForwardReference :
public std::exception
{
};
class DanglingReferences :
public std::exception
public std::exception
{
};
@@ -58,6 +63,7 @@ public:
static const bool out_archive = true;
public:
QXmlOutArchive(QXmlStreamWriter &stream)
: _stream(stream),
_next_pointer_is_reference(false)
@@ -76,6 +82,9 @@ public:
template<typename T>
void write(T *p)
{
if (!_saving_ref_map.hasDefinedRef(p)) {
throw UnsupportedForwardReference();
}
write(_saving_ref_map.getRef(p).get());
}

170
src/libs/3rdparty/modeling/qtserialization/inc/qark/reference.h vendored
View File

@@ -31,6 +31,8 @@
#ifndef QARK_REFERENCE_H
#define QARK_REFERENCE_H
#include "parameters.h"
#include <QString>
namespace qark {
@@ -38,19 +40,29 @@ namespace qark {
template<typename T>
class Ref {
public:
explicit Ref(const QString &qualified_name, T *value)
Ref(const QString &qualified_name, T *value)
: _qualified_name(qualified_name),
_value(value)
{
}
Ref(const QString &qualified_name, T *value, const Parameters &parameters)
: _qualified_name(qualified_name),
_value(value),
_parameters(parameters)
{
}
const QString &getQualifiedName() const { return _qualified_name; }
T *getValue() const { return _value; }
Parameters getParameters() const { return _parameters; }
private:
QString _qualified_name;
T *_value;
Parameters _parameters;
};
template<typename T>
@@ -59,32 +71,56 @@ Ref<T * const> ref(const QString &qualified_name, T * const &value)
return Ref<T * const>(qualified_name, &value);
}
template<typename T>
Ref<T * const> ref(const QString &qualified_name, T * const &value, const Parameters &parameters)
{
return Ref<T * const>(qualified_name, &value, parameters);
}
template<typename T>
Ref<T *> ref(const QString &qualified_name, T *&value)
{
return Ref<T *>(qualified_name, &value);
}
template<typename T>
Ref<T *> ref(const QString &qualified_name, T *&value, const Parameters &parameters)
{
return Ref<T *>(qualified_name, &value, parameters);
}
template<class U, typename T>
class GetterRef {
public:
explicit GetterRef(const QString &qualified_name, const U &u, T (U::*getter)() const)
GetterRef(const QString &qualified_name, const U &u, T (U::*getter)() const)
: _qualified_name(qualified_name),
_u(u),
_getter(getter)
{
}
GetterRef(const QString &qualified_name, const U &u, T (U::*getter)() const, const Parameters &parameters)
: _qualified_name(qualified_name),
_u(u),
_getter(getter),
_parameters(parameters)
{
}
const QString &getQualifiedName() const { return _qualified_name; }
const U &getObject() const { return _u; }
T (U::*getGetter() const)() const { return _getter; }
Parameters getParameters() const { return _parameters; }
private:
QString _qualified_name;
const U &_u;
T (U::*_getter)() const;
Parameters _parameters;
};
template<class U, typename T>
@@ -93,27 +129,44 @@ GetterRef<U, T *> ref(const QString &qualified_name, const U &u, T *(U::*getter)
return GetterRef<U, T *>(qualified_name, u, getter);
}
template<class U, typename T>
GetterRef<U, T *> ref(const QString &qualified_name, const U &u, T *(U::*getter)() const, const Parameters &parameters)
{
return GetterRef<U, T *>(qualified_name, u, getter, parameters);
}
template<class U, typename T>
class SetterRef {
public:
explicit SetterRef(const QString &qualified_name, U &u, void (U::*setter)(T))
SetterRef(const QString &qualified_name, U &u, void (U::*setter)(T))
: _qualified_name(qualified_name),
_u(u),
_setter(setter)
{
}
SetterRef(const QString &qualified_name, U &u, void (U::*setter)(T), const Parameters &parameters)
: _qualified_name(qualified_name),
_u(u),
_setter(setter),
_parameters(parameters)
{
}
const QString &getQualifiedName() const { return _qualified_name; }
U &getObject() const { return _u; }
void (U::*getSetter() const)(T) { return _setter; }
Parameters getParameters() const { return _parameters; }
private:
QString _qualified_name;
U &_u;
void (U::*_setter)(T);
Parameters _parameters;
};
template<class U, class T>
@@ -122,16 +175,29 @@ SetterRef<U, T *> ref(const QString &qualified_name, U &u, void (U::*setter)(T *
return SetterRef<U, T *>(qualified_name, u, setter);
}
template<class U, class T>
SetterRef<U, T *> ref(const QString &qualified_name, U &u, void (U::*setter)(T *), const Parameters &parameters)
{
return SetterRef<U, T *>(qualified_name, u, setter, parameters);
}
template<class U, class T>
SetterRef<U, T * const &> ref(const QString &qualified_name, U &u, void (U::*setter)(T * const &))
{
return SetterRef<U, T * const &>(qualified_name, u, setter);
}
template<class U, class T>
SetterRef<U, T * const &> ref(const QString &qualified_name, U &u, void (U::*setter)(T * const &), const Parameters &parameters)
{
return SetterRef<U, T * const &>(qualified_name, u, setter, parameters);
}
template<class U, typename T, typename V>
class GetterSetterRef {
public:
explicit GetterSetterRef(const QString &qualified_name, U &u, T (U::*getter)() const, void (U::*setter)(V))
GetterSetterRef(const QString &qualified_name, U &u, T (U::*getter)() const, void (U::*setter)(V))
: _qualified_name(qualified_name),
_u(u),
_getter(getter),
@@ -139,6 +205,15 @@ public:
{
}
GetterSetterRef(const QString &qualified_name, U &u, T (U::*getter)() const, void (U::*setter)(V), const Parameters &parameters)
: _qualified_name(qualified_name),
_u(u),
_getter(getter),
_setter(setter),
_parameters(parameters)
{
}
const QString &getQualifiedName() const { return _qualified_name; }
U &getObject() const { return _u; }
@@ -147,11 +222,14 @@ public:
void (U::*getSetter() const)(V) { return _setter; }
Parameters getParameters() const { return _parameters; }
private:
QString _qualified_name;
U &_u;
T (U::*_getter)() const;
void (U::*_setter)(V);
Parameters _parameters;
};
template<class U, typename T, typename V>
@@ -160,32 +238,56 @@ GetterSetterRef<U, T *, V *> ref(const QString &qualified_name, U &u, T *(U::*ge
return GetterSetterRef<U, T *, V *>(qualified_name, u, getter, setter);
}
template<class U, typename T, typename V>
GetterSetterRef<U, T *, V *> ref(const QString &qualified_name, U &u, T *(U::*getter)() const, void (U::*setter)(V *), const Parameters &parameters)
{
return GetterSetterRef<U, T *, V *>(qualified_name, u, getter, setter, parameters);
}
template<class U, typename T, typename V>
GetterSetterRef<U, T *, V * const &> ref(const QString &qualified_name, U &u, T *(U::*getter)() const, void (U::*setter)(V * const &))
{
return GetterSetterRef<U, T *, V * const &>(qualified_name, u, getter, setter);
}
template<class U, typename T, typename V>
GetterSetterRef<U, T *, V * const &> ref(const QString &qualified_name, U &u, T *(U::*getter)() const, void (U::*setter)(V * const &), const Parameters &parameters)
{
return GetterSetterRef<U, T *, V * const &>(qualified_name, u, getter, setter, parameters);
}
template<class U, typename T>
class GetFuncRef {
public:
explicit GetFuncRef(const QString &qualified_name, const U &u, T (*get_func)(const U &))
GetFuncRef(const QString &qualified_name, const U &u, T (*get_func)(const U &))
: _qualified_name(qualified_name),
_u(u),
_get_func(get_func)
{
}
GetFuncRef(const QString &qualified_name, const U &u, T (*get_func)(const U &), const Parameters &parameters)
: _qualified_name(qualified_name),
_u(u),
_get_func(get_func),
_parameters(parameters)
{
}
const QString &getQualifiedName() const { return _qualified_name; }
const U &getObject() const { return _u; }
T (*getGetFunc() const)(const U &) { return _get_func; }
Parameters getParameters() const { return _parameters; }
private:
QString _qualified_name;
const U &_u;
T (*_get_func)(const U &);
Parameters _parameters;
};
template<class U, typename T>
@@ -194,27 +296,44 @@ GetFuncRef<U, T *> ref(const QString &qualified_name, const U &u, T *(*get_func)
return GetFuncRef<U, T *>(qualified_name, u, get_func);
}
template<class U, typename T>
GetFuncRef<U, T *> ref(const QString &qualified_name, const U &u, T *(*get_func)(const U &), const Parameters &parameters)
{
return GetFuncRef<U, T *>(qualified_name, u, get_func, parameters);
}
template<class U, typename T>
class SetFuncRef {
public:
explicit SetFuncRef(const QString &qualified_name, U &u, void (*set_func)(U &, T))
SetFuncRef(const QString &qualified_name, U &u, void (*set_func)(U &, T))
: _qualified_name(qualified_name),
_u(u),
_set_func(set_func)
{
}
SetFuncRef(const QString &qualified_name, U &u, void (*set_func)(U &, T), const Parameters &parameters)
: _qualified_name(qualified_name),
_u(u),
_set_func(set_func),
_parameters(parameters)
{
}
const QString &getQualifiedName() const { return _qualified_name; }
U &getObject() const { return _u; }
void (*getSetFunc() const)(U &, T) { return _set_func; }
Parameters getParameters() const { return _parameters; }
private:
QString _qualified_name;
U &_u;
void (*_set_func)(U &, T);
Parameters _parameters;
};
template<class U, class T>
@@ -223,16 +342,29 @@ SetFuncRef<U, T *> ref(const QString &qualified_name, U &u, void (*set_func)(U &
return SetFuncRef<U, T *>(qualified_name, u, set_func);
}
template<class U, class T>
SetFuncRef<U, T *> ref(const QString &qualified_name, U &u, void (*set_func)(U &, T *), const Parameters &parameters)
{
return SetFuncRef<U, T *>(qualified_name, u, set_func, parameters);
}
template<class U, class T>
SetFuncRef<U, T * const &> ref(const QString &qualified_name, U &u, void (*set_func)(U &, T * const &))
{
return SetFuncRef<U, T * const &>(qualified_name, u, set_func);
}
template<class U, class T>
SetFuncRef<U, T * const &> ref(const QString &qualified_name, U &u, void (*set_func)(U &, T * const &), const Parameters &parameters)
{
return SetFuncRef<U, T * const &>(qualified_name, u, set_func, parameters);
}
template<class U, typename T, typename V>
class GetSetFuncRef {
public:
explicit GetSetFuncRef(const QString &qualified_name, U &u, T (*get_func)(const U &), void (*set_func)(U &, V))
GetSetFuncRef(const QString &qualified_name, U &u, T (*get_func)(const U &), void (*set_func)(U &, V))
: _qualified_name(qualified_name),
_u(u),
_get_func(get_func),
@@ -240,6 +372,15 @@ public:
{
}
GetSetFuncRef(const QString &qualified_name, U &u, T (*get_func)(const U &), void (*set_func)(U &, V), const Parameters &parameters)
: _qualified_name(qualified_name),
_u(u),
_get_func(get_func),
_set_func(set_func),
_parameters(parameters)
{
}
const QString &getQualifiedName() const { return _qualified_name; }
U &getObject() const { return _u; }
@@ -248,11 +389,14 @@ public:
void (*getSetFunc() const)(U &, V) { return _set_func; }
Parameters getParameters() const { return _parameters; }
private:
QString _qualified_name;
U &_u;
T (*_get_func)(const U &);
void (*_set_func)(U &, V);
Parameters _parameters;
};
template<class U, typename T, typename V>
@@ -261,12 +405,24 @@ GetSetFuncRef<U, T *, V *> ref(const QString &qualified_name, U &u, T *(*get_fun
return GetSetFuncRef<U, T *, V *>(qualified_name, u, get_func, set_func);
}
template<class U, typename T, typename V>
GetSetFuncRef<U, T *, V *> ref(const QString &qualified_name, U &u, T *(*get_func)(const U &), void (*set_func)(U &, V *), const Parameters &parameters)
{
return GetSetFuncRef<U, T *, V *>(qualified_name, u, get_func, set_func, parameters);
}
template<class U, typename T, typename V>
GetSetFuncRef<U, T *, V * const &> ref(const QString &qualified_name, U &u, T *(*get_func)(const U &), void (*set_func)(U &, V * const &))
{
return GetSetFuncRef<U, T *, V * const &>(qualified_name, u, get_func, set_func);
}
template<class U, typename T, typename V>
GetSetFuncRef<U, T *, V * const &> ref(const QString &qualified_name, U &u, T *(*get_func)(const U &), void (*set_func)(U &, V * const &), const Parameters &parameters)
{
return GetSetFuncRef<U, T *, V * const &>(qualified_name, u, get_func, set_func, parameters);
}
}
#endif // QARK_REFERENCE_H

151
src/libs/3rdparty/modeling/qtserialization/inc/qark/serialize.h vendored
View File

@@ -38,6 +38,7 @@
#include "access.h"
#include "typeregistry.h"
#include "serialize_pointer.h"
#include "serialize_basic.h"
#include "serialize_container.h"
#include "serialize_enum.h"
@@ -51,102 +52,27 @@ namespace qark {
template<class Archive, class T>
inline Archive &operator<<(Archive &archive, const T &t)
{
save(archive, t);
save(archive, t, Parameters());
return archive;
}
template<class Archive, class T>
inline Archive &operator>>(Archive &archive, T &t)
{
load(archive, t);
load(archive, t, Parameters());
return archive;
}
template<class Archive, class T>
typename std::enable_if<Archive::out_archive, Archive &>::type operator||(Archive &archive, T &t)
{
save(archive, (const T &) t);
return archive;
return archive << t;
}
template<class Archive, class T>
typename std::enable_if<Archive::in_archive, Archive &>::type operator||(Archive &archive, T &t)
{
load(archive, t);
return archive;
}
template<class Archive, class T>
inline Archive &operator<<(Archive &archive, T *p)
{
if (p) {
if (archive.isReference(p)) {
archive.beginPointer();
archive.write(p);
archive.endPointer();
} else {
if (typeid(*p) == typeid(T)) {
archive.beginInstance();
registry::save_pointer<Archive, T, T>(archive, p);
archive.endInstance();
} else {
archive.beginInstance(get_type_uid(*p));
//typename registry::TypeRegistry<Archive, typename qark::non_const<T>::type>::type_info type_data
// = get_type_info<Archive, typename qark::non_const<T>::type>(*p);
typename registry::TypeRegistry<Archive, T>::type_info type_data = get_type_info<Archive, T>(*p);
if (type_data.save_func == 0) {
throw unregistered_type();
} else {
type_data.save_func(archive, p);
}
archive.endInstance();
}
}
} else {
archive.beginNullPointer();
archive.endNullPointer();
}
return archive;
}
template<class Archive, class T>
inline Archive &operator>>(Archive &archive, T *&p)
{
typename Archive::ReferenceTag ref_tag = archive.readReferenceTag();
switch (ref_tag.kind) {
case Archive::NULLPOINTER:
p = 0;
break;
case Archive::POINTER:
archive.read(p);
break;
case Archive::INSTANCE:
if (ref_tag.type_name.isEmpty()) {
registry::load_non_virtual_pointer<Archive,T>(archive, p);
} else {
typename registry::TypeRegistry<Archive, T>::type_info type_data = get_type_info<Archive, T>(ref_tag.type_name);
if (type_data.load_func == 0) {
throw unregistered_type();
} else {
type_data.load_func(archive, p);
}
}
break;
}
archive.readReferenceEndTag(ref_tag.kind);
return archive;
}
template<class Archive, class T>
typename std::enable_if<Archive::out_archive, Archive &>::type operator||(Archive &archive, T *&p)
{
return archive << p;
}
template<class Archive, class T>
typename std::enable_if<Archive::in_archive, Archive &>::type operator||(Archive &archive, T *&p)
{
return archive >> p;
return archive >> t;
}
template<class Archive, class T>
@@ -175,32 +101,6 @@ typename std::enable_if<Archive::in_archive, Archive &>::type operator||(Archive
return archive >> f;
}
template<class Archive>
inline Archive &operator<<(Archive &archive, void (*f)(Archive &))
{
f(archive);
return archive;
}
template<class Archive>
inline Archive &operator>>(Archive &archive, void (*f)(Archive &))
{
f(archive);
return archive;
}
template<class Archive>
typename std::enable_if<Archive::out_archive, Archive &>::type operator||(Archive &archive, void (*f)(Archive &))
{
return archive << f;
}
template<class Archive>
typename std::enable_if<Archive::in_archive, Archive &>::type operator||(Archive &archive, void (*f)(Archive &))
{
return archive >> f;
}
template<class Archive>
inline Archive &operator<<(Archive &archive, const Tag &tag)
{
@@ -311,7 +211,7 @@ template<class Archive, typename T>
Archive &operator<<(Archive &archive, const Attr<T> &attr)
{
archive.beginAttribute(attr);
archive << *attr.getValue();
save(archive, *attr.getValue(), attr.getParameters());
archive.endAttribute(attr);
return archive;
}
@@ -336,10 +236,23 @@ typename std::enable_if<Archive::in_archive, Archive &>::type operator||(Archive
}
template<class Archive, class U, typename T>
Archive &operator<<(Archive &archive, const GetterAttr<U, T> &attr)
typename std::enable_if<!std::is_abstract<U>::value, Archive &>::type
operator<<(Archive &archive, const GetterAttr<U, T> &attr)
{
if (!((attr.getObject().*(attr.getGetter()))() == (U().*(attr.getGetter()))())) {
archive.beginAttribute(attr);
save(archive, (attr.getObject().*(attr.getGetter()))(), attr.getParameters());
archive.endAttribute(attr);
}
return archive;
}
template<class Archive, class U, typename T>
typename std::enable_if<std::is_abstract<U>::value, Archive &>::type
operator<<(Archive &archive, const GetterAttr<U, T> &attr)
{
archive.beginAttribute(attr);
archive << (attr.getObject().*(attr.getGetter()))();
save(archive, (attr.getObject().*(attr.getGetter()))(), attr.getParameters());
archive.endAttribute(attr);
return archive;
}
@@ -358,7 +271,7 @@ operator<<(Archive &archive, const GetterSetterAttr<U, T, V> &attr)
{
if (!((attr.getObject().*(attr.getGetter()))() == (U().*(attr.getGetter()))())) {
archive.beginAttribute(attr);
archive << (attr.getObject().*(attr.getGetter()))();
save(archive, (attr.getObject().*(attr.getGetter()))(), attr.getParameters());
archive.endAttribute(attr);
}
return archive;
@@ -370,7 +283,7 @@ typename std::enable_if<std::is_abstract<U>::value, Archive &>::type
operator<<(Archive &archive, const GetterSetterAttr<U, T, V> &attr)
{
archive.beginAttribute(attr);
archive << (attr.getObject().*(attr.getGetter()))();
save(archive, (attr.getObject().*(attr.getGetter()))(), attr.getParameters());
archive.endAttribute(attr);
return archive;
}
@@ -398,7 +311,7 @@ template<class Archive, class U, typename T>
Archive &operator<<(Archive &archive, const GetFuncAttr<U, T> &attr)
{
archive.beginAttribute(attr);
archive << ((*attr.getGetFunc())(attr.getObject()));
save(archive, ((*attr.getGetFunc())(attr.getObject())), attr.getParameters());
archive.endAttribute(attr);
return archive;
}
@@ -414,7 +327,7 @@ template<class Archive, class U, typename T, typename V>
Archive &operator<<(Archive &archive, const GetSetFuncAttr<U, T, V> &attr)
{
archive.beginAttribute(attr);
archive << ((*attr.getGetFunc())(attr.getObject()));
save(archive, ((*attr.getGetFunc())(attr.getObject())), attr.getParameters());
archive.endAttribute(attr);
return archive;
}
@@ -442,7 +355,7 @@ template<class Archive, typename T>
Archive &operator<<(Archive &archive, const Ref<T *> &ref)
{
archive.beginReference(ref);
archive << *ref.getValue();
save(archive, *ref.getValue(), ref.getParameters());
archive.endReference(ref);
return archive;
}
@@ -451,7 +364,7 @@ template<class Archive, typename T>
Archive &operator<<(Archive &archive, const Ref<T * const> &ref)
{
archive.beginReference(ref);
archive << *ref.getValue();
save(archive, *ref.getValue(), ref.getParameters());
archive.endReference(ref);
return archive;
}
@@ -467,7 +380,7 @@ template<class Archive, typename T>
typename std::enable_if<Archive::out_archive, Archive &>::type operator||(Archive &archive, const Ref<T *> &ref)
{
archive.beginReference(ref);
archive << *ref.getValue();
save(archive, *ref.getValue(), ref.getParameters());
archive.endReference(ref);
return archive;
}
@@ -482,7 +395,7 @@ template<class Archive, class U, typename T>
Archive &operator<<(Archive &archive, const GetterRef<U, T> &ref)
{
archive.beginReference(ref);
archive << (ref.getObject().*(ref.getGetter()))();
save(archive, (ref.getObject().*(ref.getGetter()))(), ref.getParameters());
archive.endReference(ref);
return archive;
}
@@ -498,7 +411,7 @@ template<class Archive, class U, typename T, typename V>
Archive &operator<<(Archive &archive, const GetterSetterRef<U, T, V> &ref)
{
archive.beginReference(ref);
archive << (ref.getObject().*(ref.getGetter()))();
save(archive, (ref.getObject().*(ref.getGetter()))(), ref.getParameters());
archive.endReference(ref);
return archive;
}
@@ -526,7 +439,7 @@ template<class Archive, class U, typename T>
Archive &operator<<(Archive &archive, const GetFuncRef<U, T> &ref)
{
archive.beginReference(ref);
archive << ref.getGetFunc()(ref.getObject());
save(archive, ref.getGetFunc()(ref.getObject()), ref.getParameters());
archive.endReference(ref);
return archive;
}
@@ -542,7 +455,7 @@ template<class Archive, class U, typename T, typename V>
Archive &operator<<(Archive &archive, const GetSetFuncRef<U, T, V> &ref)
{
archive.beginReference(ref);
archive << ref.getGetFunc()(ref.getObject());
save(archive, ref.getGetFunc()(ref.getObject()), ref.getParameters());
archive.endReference(ref);
return archive;
}

17
src/libs/3rdparty/modeling/qtserialization/inc/qark/serialize_basic.h vendored
View File

@@ -31,6 +31,7 @@
#ifndef QARK_SERIALIZE_BASIC_H
#define QARK_SERIALIZE_BASIC_H
#include "parameters.h"
#include "qstringparser/qstringparser.h"
#include <QString>
@@ -42,12 +43,12 @@
#define QARK_BASIC_SAVELOAD(TYPE) \
template<class Archive> \
inline void save(Archive &archive, TYPE v) \
inline void save(Archive &archive, TYPE v, const Parameters &) \
{ \
archive.write(v); \
} \
template<class Archive> \
inline void load(Archive &archive, TYPE &v) \
inline void load(Archive &archive, TYPE &v, const Parameters &) \
{ \
archive.read(&v); \
}
@@ -79,13 +80,13 @@ QARK_BASIC_SAVELOAD(QString)
// QPointF
template<class Archive>
inline void save(Archive &archive, const QPointF &point)
inline void save(Archive &archive, const QPointF &point, const Parameters &)
{
archive.write(QString(QStringLiteral("x:%1;y:%2")).arg(point.x()).arg(point.y()));
}
template<class Archive>
inline void load(Archive &archive, QPointF &point)
inline void load(Archive &archive, QPointF &point, const Parameters &)
{
QString s;
archive.read(&s);
@@ -98,13 +99,13 @@ inline void load(Archive &archive, QPointF &point)
// QRectF
template<class Archive>
inline void save(Archive &archive, const QRectF &rect)
inline void save(Archive &archive, const QRectF &rect, const Parameters &)
{
archive.write(QString(QStringLiteral("x:%1;y:%2;w:%3;h:%4")).arg(rect.x()).arg(rect.y()).arg(rect.width()).arg(rect.height()));
}
template<class Archive>
inline void load(Archive &archive, QRectF &point)
inline void load(Archive &archive, QRectF &point, const Parameters &)
{
QString s;
archive.read(&s);
@@ -117,13 +118,13 @@ inline void load(Archive &archive, QRectF &point)
// QDateTime
template<class Archive>
inline void save(Archive &archive, const QDateTime &date_time)
inline void save(Archive &archive, const QDateTime &date_time, const Parameters &)
{
archive << date_time.toMSecsSinceEpoch();
}
template<class Archive>
inline void load(Archive &archive, QDateTime &date_time)
inline void load(Archive &archive, QDateTime &date_time, const Parameters &)
{
qint64 t;
archive >> t;

46
src/libs/3rdparty/modeling/qtserialization/inc/qark/serialize_container.h vendored
View File

@@ -31,31 +31,22 @@
#ifndef QARK_SERIALIZE_CONTAINER_H
#define QARK_SERIALIZE_CONTAINER_H
#include "flag.h"
#include "parameters.h"
#include <QList>
#include <QHash>
namespace qark {
namespace impl {
static Flag container_item_ref_flag;
}
template<class Archive>
inline void ref_item(Archive &archive)
{
archive.setFlag(impl::container_item_ref_flag);
}
static Flag ENFORCE_REFERENCED_ITEMS;
// QList
template<class Archive, class T>
inline void save(Archive &archive, const QList<T> &list)
inline void save(Archive &archive, const QList<T> &list, const Parameters &)
{
archive << tag("qlist");
archive.clearFlag(impl::container_item_ref_flag);
foreach (const T &t, list) {
archive << attr(QStringLiteral("item"), t);
}
@@ -63,10 +54,10 @@ inline void save(Archive &archive, const QList<T> &list)
}
template<class Archive, class T>
inline void save(Archive &archive, const QList<T *> &list)
inline void save(Archive &archive, const QList<T *> &list, const Parameters &parameters)
{
archive << tag("qlist");
if (archive.takeFlag(impl::container_item_ref_flag)) {
if (parameters.hasFlag(ENFORCE_REFERENCED_ITEMS)) {
foreach (const T *t, list) {
archive << ref(QStringLiteral("item"), t);
}
@@ -79,7 +70,7 @@ inline void save(Archive &archive, const QList<T *> &list)
}
template<class Archive, class T>
inline void load(Archive &archive, QList<T> &list)
inline void load(Archive &archive, QList<T> &list, const Parameters &)
{
archive >> tag(QStringLiteral("qlist"));
archive >> attr<QList<T>, const T &>(QStringLiteral("item"), list, &QList<T>::append);
@@ -87,10 +78,10 @@ inline void load(Archive &archive, QList<T> &list)
}
template<class Archive, class T>
inline void load(Archive &archive, QList<T *> &list)
inline void load(Archive &archive, QList<T *> &list, const Parameters &parameters)
{
archive >> tag(QStringLiteral("qlist"));
if (archive.takeFlag(impl::container_item_ref_flag)) {
if (parameters.hasFlag(ENFORCE_REFERENCED_ITEMS)) {
// why does the following line not compile but the line below selects the correct function?
//archive >> ref<QList<T *>, T * const &>("item", list, &QList<T *>::append);
archive >> ref(QStringLiteral("item"), list, &QList<T *>::append);
@@ -104,10 +95,9 @@ inline void load(Archive &archive, QList<T *> &list)
// QSet
template<class Archive, class T>
inline void save(Archive &archive, const QSet<T> &set)
inline void save(Archive &archive, const QSet<T> &set, const Parameters &)
{
archive << tag("qset");
archive.clearFlag(impl::container_item_ref_flag);
foreach (const T &t, set) {
archive << attr(QStringLiteral("item"), t);
}
@@ -115,10 +105,10 @@ inline void save(Archive &archive, const QSet<T> &set)
}
template<class Archive, class T>
inline void save(Archive &archive, const QSet<T *> &set)
inline void save(Archive &archive, const QSet<T *> &set, const Parameters &parameters)
{
archive << tag("qset");
if (archive.takeFlag(impl::container_item_ref_flag)) {
if (parameters.hasFlag(ENFORCE_REFERENCED_ITEMS)) {
foreach (const T *t, set) {
archive << ref(QStringLiteral("item"), t);
}
@@ -140,7 +130,7 @@ void insertIntoSet(QSet<T> &set, const T &t) {
}
template<class Archive, class T>
inline void load(Archive &archive, QSet<T> &set)
inline void load(Archive &archive, QSet<T> &set, const Parameters &)
{
archive >> tag(QStringLiteral("qset"));
archive >> attr<QSet<T>, const T &>(QStringLiteral("item"), set, &impl::insertIntoSet<T>);
@@ -148,10 +138,10 @@ inline void load(Archive &archive, QSet<T> &set)
}
template<class Archive, class T>
inline void load(Archive &archive, QSet<T *> &set)
inline void load(Archive &archive, QSet<T *> &set, const Parameters &parameters)
{
archive >> tag(QStringLiteral("qset"));
if (archive.takeFlag(impl::container_item_ref_flag)) {
if (parameters.hasFlag(ENFORCE_REFERENCED_ITEMS)) {
archive >> ref(QStringLiteral("item"), set, &impl::insertIntoSet<T *>);
} else {
archive >> attr<QSet<T *>, T * const &>(QStringLiteral("item"), set, &impl::insertIntoSet<T *>);
@@ -177,7 +167,7 @@ public:
}
template<class Archive, class KEY, class VALUE>
inline void save(Archive &archive, const impl::KeyValuePair<KEY, VALUE> &pair)
inline void save(Archive &archive, const impl::KeyValuePair<KEY, VALUE> &pair, const Parameters &)
{
archive << tag(QStringLiteral("pair"))
<< attr(QStringLiteral("key"), pair._key)
@@ -186,7 +176,7 @@ inline void save(Archive &archive, const impl::KeyValuePair<KEY, VALUE> &pair)
}
template<class Archive, class KEY, class VALUE>
inline void load(Archive &archive, impl::KeyValuePair<KEY, VALUE> &pair)
inline void load(Archive &archive, impl::KeyValuePair<KEY, VALUE> &pair, const Parameters &)
{
archive >> tag(QStringLiteral("pair"))
>> attr(QStringLiteral("key"), pair._key)
@@ -195,7 +185,7 @@ inline void load(Archive &archive, impl::KeyValuePair<KEY, VALUE> &pair)
}
template<class Archive, class KEY, class VALUE>
inline void save(Archive &archive, const QHash<KEY, VALUE> &hash)
inline void save(Archive &archive, const QHash<KEY, VALUE> &hash, const Parameters &)
{
archive << tag(QStringLiteral("qhash"));
for (typename QHash<KEY, VALUE>::const_iterator it = hash.begin(); it != hash.end(); ++it) {
@@ -216,7 +206,7 @@ inline void keyValuePairInsert(QHash<KEY, VALUE> &hash, const KeyValuePair<KEY,
}
template<class Archive, class KEY, class VALUE>
inline void load(Archive &archive, QHash<KEY, VALUE> &hash)
inline void load(Archive &archive, QHash<KEY, VALUE> &hash, const Parameters &)
{
archive >> tag(QStringLiteral("qhash"));
archive >> attr(QStringLiteral("item"), hash, &impl::keyValuePairInsert<KEY, VALUE>);

14
src/libs/3rdparty/modeling/qtserialization/inc/qark/serialize_enum.h vendored
View File

@@ -31,6 +31,8 @@
#ifndef QARK_SERIALIZE_ENUM_H
#define QARK_SERIALIZE_ENUM_H
#include "parameters.h"
#include <type_traits>
namespace qark {
@@ -38,13 +40,13 @@ namespace qark {
#if 0 // ambigous with default implementation in access.h
template<class Archive, typename T>
inline typename std::enable_if<std::is_enum<T>::value, void>::type save(Archive &archive, const T &value)
inline typename std::enable_if<std::is_enum<T>::value, void>::type save(Archive &archive, const T &value, const Parameters &)
{
archive.write((int) value);
}
template<class Archive, typename T>
inline typename std::enable_if<std::is_enum<T>::value, void>::type load(Archive &archive, T &value)
inline typename std::enable_if<std::is_enum<T>::value, void>::type load(Archive &archive, T &value, const Parameters &)
{
int i = 0;
archive.read(&i);
@@ -55,12 +57,12 @@ inline typename std::enable_if<std::is_enum<T>::value, void>::type load(Archive
#define QARK_SERIALIZE_ENUM(ENUM) \
template<class Archive> \
inline void save(Archive &archive, const ENUM &e) \
inline void save(Archive &archive, const ENUM &e, const Parameters &) \
{ \
archive.write((int) e); \
} \
template<class Archive> \
inline void load(Archive &archive, ENUM &e) \
inline void load(Archive &archive, ENUM &e, const Parameters &) \
{ \
int i = 0; \
archive.read(&i); \
@@ -68,13 +70,13 @@ inline typename std::enable_if<std::is_enum<T>::value, void>::type load(Archive
}
template<class Archive, typename T>
inline void save(Archive &archive, const QFlags<T> &flags)
inline void save(Archive &archive, const QFlags<T> &flags, const Parameters &)
{
archive.write((typename QFlags<T>::Int) flags);
}
template<class Archive, typename T>
inline void load(Archive &archive, QFlags<T> &flags)
inline void load(Archive &archive, QFlags<T> &flags, const Parameters &)
{
typename QFlags<T>::Int i = 0;
archive.read(&i);

98
src/libs/3rdparty/modeling/qtserialization/inc/qark/serialize_pointer.h vendored Normal file
View File

@@ -0,0 +1,98 @@
/***************************************************************************
**
** Copyright (C) 2015 Jochen Becher
** Contact: http://www.qt.io/licensing
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms and
** conditions see http://www.qt.io/terms-conditions. For further information
** use the contact form at http://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, The Qt Company gives you certain additional
** rights. These rights are described in The Qt Company LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
****************************************************************************/
#ifndef QARK_SERIALIZE_POINTER_H
#define QARK_SERIALIZE_POINTER_H
#include "typeregistry.h"
namespace qark {
template<class Archive, class T>
inline void save(Archive &archive, T *p, const Parameters &)
{
if (p) {
if (archive.isReference(p)) {
archive.beginPointer();
archive.write(p);
archive.endPointer();
} else {
if (typeid(*p) == typeid(T)) {
archive.beginInstance();
registry::save_pointer<Archive, T, T>(archive, p);
archive.endInstance();
} else {
archive.beginInstance(get_type_uid(*p));
typename registry::TypeRegistry<Archive, T>::type_info type_data = get_type_info<Archive, T>(*p);
if (type_data.save_func == 0) {
throw unregistered_type();
} else {
type_data.save_func(archive, p);
}
archive.endInstance();
}
}
} else {
archive.beginNullPointer();
archive.endNullPointer();
}
}
template<class Archive, class T>
void load(Archive &archive, T *&p, const Parameters &)
{
typename Archive::ReferenceTag ref_tag = archive.readReferenceTag();
switch (ref_tag.kind) {
case Archive::NULLPOINTER:
p = 0;
break;
case Archive::POINTER:
archive.read(p);
break;
case Archive::INSTANCE:
if (ref_tag.type_name.isEmpty()) {
registry::load_non_virtual_pointer<Archive,T>(archive, p);
} else {
typename registry::TypeRegistry<Archive, T>::type_info type_data = get_type_info<Archive, T>(ref_tag.type_name);
if (type_data.load_func == 0) {
throw unregistered_type();
} else {
type_data.load_func(archive, p);
}
}
break;
}
archive.readReferenceEndTag(ref_tag.kind);
}
}
#endif // QARK_SERIALIZE_POINTER_H

57
src/libs/3rdparty/modeling/qtserialization/inc/qark/tag.h vendored
View File

@@ -32,6 +32,7 @@
#define QARK_TAG_H
#include "typeregistry.h"
#include "parameters.h"
#include <QString>
@@ -45,10 +46,19 @@ public:
{
}
Tag(const QString &qualified_name, const Parameters &parameters)
: _qualified_name(qualified_name),
_parameters(parameters)
{
}
const QString &getQualifiedName() const { return _qualified_name; }
Parameters getParameters() const { return _parameters; }
private:
QString _qualified_name;
Parameters _parameters;
};
@@ -57,12 +67,18 @@ class Object :
public Tag
{
public:
explicit Object(const QString &qualified_name, T *object)
Object(const QString &qualified_name, T *object)
: Tag(qualified_name),
_object(object)
{
}
Object(const QString &qualified_name, T *object, const Parameters &parameters)
: Tag(qualified_name, parameters),
_object(object)
{
}
T *getObject() const { return _object; }
private:
@@ -75,28 +91,61 @@ inline Tag tag(const QString &qualified_name)
return Tag(qualified_name);
}
inline Tag tag(const QString &qualified_name, const Parameters &parameters)
{
return Tag(qualified_name, parameters);
}
inline Tag tag(const char *qualified_name)
{
return Tag(QLatin1String(qualified_name));
}
inline Tag tag(const char *qualified_name, const Parameters &parameters)
{
return Tag(QLatin1String(qualified_name), parameters);
}
template<class T>
inline Object<T> tag(T &object)
{
return Object<T>(get_type_uid<T>(), &object);
}
template<class T>
inline Object<T> tag(T &object, const Parameters &parameters)
{
return Object<T>(get_type_uid<T>(), &object, parameters);
}
template<class T>
inline Object<T> tag(const QString &qualified_name, T &object)
{
return Object<T>(qualified_name, &object);
}
template<class T>
inline Object<T> tag(const QString &qualified_name, T &object, const Parameters &parameters)
{
return Object<T>(qualified_name, &object, parameters);
}
class End {
public:
explicit End() { }
explicit End()
{
}
explicit End(const Parameters &parameters)
: _parameters(parameters)
{
}
Parameters getParameters() const { return _parameters; }
private:
Parameters _parameters;
};
inline End end()
@@ -104,6 +153,10 @@ inline End end()
return End();
}
inline End end(const Parameters &parameters)
{
return End(parameters);
}
}

14
src/libs/3rdparty/modeling/qtserialization/inc/qark/typeregistry.h vendored
View File

@@ -31,6 +31,8 @@
#ifndef QARK_TYPEREGISTRY_H
#define QARK_TYPEREGISTRY_H
#include "parameters.h"
#include "qmt/infrastructure/qmtassert.h"
#include <exception>
@@ -219,7 +221,7 @@ template<class Archive, class BASE, class DERIVED>
Archive &save_pointer(Archive &ar, BASE * const &p)
{
DERIVED &t = dynamic_cast<DERIVED &>(*p);
ar << t;
save(ar, t, Parameters());
return ar;
}
@@ -227,7 +229,7 @@ template<class Archive, class BASE, class DERIVED>
Archive &load_pointer(Archive &ar, BASE *&p)
{
DERIVED *t = new DERIVED();
ar >> *t;
load(ar, *t, Parameters());
p = t;
return ar;
}
@@ -324,13 +326,13 @@ typename registry::TypeRegistry<Archive,T>::type_info get_type_info(const QStrin
#define QARK_REGISTER_DERIVED_CLASS(INARCHIVE, OUTARCHIVE, DERIVED, BASE) \
template<> \
int qark::registry::DerivedTypeRegistry<INARCHIVE,BASE,DERIVED>::__static_init = \
qark::registry::DerivedTypeRegistry<INARCHIVE, BASE, DERIVED>::__init(0, qark::registry::load_pointer<INARCHIVE, BASE, DERIVED>); \
qark::registry::DerivedTypeRegistry<INARCHIVE, BASE, DERIVED>::__init(0, qark::registry::load_pointer<INARCHIVE, BASE, DERIVED>); \
template<> \
int qark::registry::DerivedTypeRegistry<OUTARCHIVE, BASE, DERIVED>::__static_init = \
qark::registry::DerivedTypeRegistry<OUTARCHIVE, BASE, DERIVED>::__init(qark::registry::save_pointer<OUTARCHIVE, BASE, DERIVED>, 0); \
qark::registry::DerivedTypeRegistry<OUTARCHIVE, BASE, DERIVED>::__init(qark::registry::save_pointer<OUTARCHIVE, BASE, DERIVED>, 0); \
template<> \
int qark::registry::DerivedTypeRegistry<OUTARCHIVE, typename std::add_const<BASE>::type, typename std::add_const<DERIVED>::type>::__static_init = \
qark::registry::DerivedTypeRegistry<OUTARCHIVE, typename std::add_const<BASE>::type, typename std::add_const<DERIVED>::type>:: \
__init(qark::registry::save_pointer<OUTARCHIVE, typename std::add_const<BASE>::type, typename std::add_const<DERIVED>::type>, 0);
qark::registry::DerivedTypeRegistry<OUTARCHIVE, typename std::add_const<BASE>::type, typename std::add_const<DERIVED>::type>:: \
__init(qark::registry::save_pointer<OUTARCHIVE, typename std::add_const<BASE>::type, typename std::add_const<DERIVED>::type>, 0);
#endif // QARK_TYPEREGISTRY_H

2
src/libs/3rdparty/modeling/qtserialization/qtserialization.pri vendored
View File

@@ -6,6 +6,7 @@ HEADERS += \
$$PWD/inc/qark/baseclass.h \
$$PWD/inc/qark/flag.h \
$$PWD/inc/qark/friend_access.h \
$$PWD/inc/qark/parameters.h \
$$PWD/inc/qark/qxmlinarchive.h \
$$PWD/inc/qark/qxmloutarchive.h \
$$PWD/inc/qark/reference.h \
@@ -13,6 +14,7 @@ HEADERS += \
$$PWD/inc/qark/serialize_basic.h \
$$PWD/inc/qark/serialize_container.h \
$$PWD/inc/qark/serialize_enum.h \
$$PWD/inc/qark/serialize_pointer.h \
$$PWD/inc/qark/tag.h \
$$PWD/inc/qark/typeregistry.h \
$$PWD/inc/qark/impl/loadingrefmap.h \

2
src/libs/modelinglib/modelinglib.qbs
View File

@@ -312,6 +312,7 @@ QtcLibrary {
"inc/qark/impl/loadingrefmap.h",
"inc/qark/impl/objectid.h",
"inc/qark/impl/savingrefmap.h",
"inc/qark/parameters.h",
"inc/qark/qxmlinarchive.h",
"inc/qark/qxmloutarchive.h",
"inc/qark/reference.h",
@@ -319,6 +320,7 @@ QtcLibrary {
"inc/qark/serialize_basic.h",
"inc/qark/serialize_container.h",
"inc/qark/serialize_enum.h",
"inc/qark/serialize_pointer.h",
"inc/qark/tag.h",
"inc/qark/typeregistry.h",
"src/flag.cpp",