chris/OSCAR-code
1
0
Fork 0
mirror of https://gitlab.com/pholy/OSCAR-code.git synced 2025-04-05 10:40:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

Split XML recording/replay into its own files.

Browse Source 
The only code change was to move XmlReplayEvent::s_factories into
a local static variable accessed by XmlReplayEvent::factories() to
ensure that it will be initialized before it is used.

Otherwise there is no guarantee in C++11 that global variables
in different source files (translation units) will be initialized
in any particular order.
This commit is contained in:
sawinglogz 2020-07-10 12:44:15 -04:00
parent 610f6b8188
commit c7db24877c
4 changed files with 855 additions and 815 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

818
oscar/SleepLib/deviceconnection.cpp
View File

@ -7,15 +7,9 @@
* for more details. */ * for more details. */
#include "deviceconnection.h" #include "deviceconnection.h"
#include "xmlreplay.h"
#include "version.h" #include "version.h"
#include <QtSerialPort/QSerialPortInfo> #include <QtSerialPort/QSerialPortInfo>
#include <QFile>
#include <QFileInfo>
#include <QDir>
#include <QBuffer>
#include <QDateTime>
#include <QXmlStreamReader>
#include <QXmlStreamWriter>
#include <QDebug> #include <QDebug>
@ -25,813 +19,6 @@ static QString hex(int i)
} }
// MARK: -
// MARK: XML record/playback base classes
/*
* XML recording base class
*
* While this can be used on its own via the public constructors, it is
* typically used as a base class for a subclasses that handle specific
* events.
*
* A single instance of this class can write a linear sequence of events to
* XML, either to a string (for testing) or to a file (for production use).
*
* Sometimes, however, there is need for certain sequences to be treated as
* separate, either due to multithreading (such recording as multiple
* simultaneous connections), or in order to treat a certain excerpt (such
* as data download that we might wish to archive) separately.
*
* These sequences are handled as "substreams" of the parent stream. The
* parent stream will typically record a substream's open/close or start/
* stop along with its ID. The substream will be written to a separate XML
* stream identified by that ID. Substreams are implemented as subclasses of
* this base class.
*
* TODO: At the moment, only file-based substreams are supported. In theory
* it should be possible to cache string-based substreams and then insert
* them inline into the parent after the substream-close event is recorded.
*/
class XmlRecorder
{
public:
static const QString TAG; // default tag if no subclass
XmlRecorder(class QFile * file, const QString & tag = XmlRecorder::TAG); // record XML to the given file
XmlRecorder(QString & string, const QString & tag = XmlRecorder::TAG); // record XML to the given string
virtual ~XmlRecorder(); // write the epilogue and close the recorder
XmlRecorder* closeSubstream(); // convenience function to close out a substream and return its parent
inline QXmlStreamWriter & xml() { return *m_xml; }
inline void lock() { m_mutex.lock(); }
inline void unlock() { m_mutex.unlock(); }
protected:
XmlRecorder(XmlRecorder* parent, const QString & id, const QString & tag); // constructor used by substreams
QXmlStreamWriter* addSubstream(XmlRecorder* child, const QString & id); // initialize a child substream, used by above constructor
const QString m_tag; // opening/closing tag for this instance
QFile* m_file; // nullptr for non-file recordings
QXmlStreamWriter* m_xml; // XML output stream
QMutex m_mutex; // force one thread at a time to write to m_xml
XmlRecorder* m_parent; // parent instance of a substream
void prologue();
void epilogue();
};
const QString XmlRecorder::TAG = "xmlreplay";
class XmlReplayEvent;
/*
* XML replay base class
*
* A single instance of this class caches events from a previously recorded
* XML stream, either from a string (for testing) or from a file (for
* production use).
*
* Unlike recording, the replay need not be strictly linear. In fact, the
* implementation is designed to allow for limited reordering during replay,
* so that minor changes to code should result in sensible replay until a
* new recording can be made.
*
* There are two aspects to this reordering:
*
* First, events can be retrieved (and consumed) in any order, being
* retrieved by type and ID (and then in order within that type and ID).
*
* Second, events that are flagged as random-access (see randomAccess below)
* will cause the above retrieval to subsequently begin searching on or
* after the random-access event's timestamp (except for other random-access
* events, which are always searched from the beginning.)
*
* This allow non-stateful events to be replayed arbitrarily, and for
* stateful events (such as commands sent to a device) to be approximated
* (where subsequent data received matches the command sent).
*
* Furthermore, when events are triggered in the same order as they were
* during recordering, the above reordering will have no effect, and the
* original ordering will be replayed identically.
*
* See XmlRecorder above for a discussion of substreams.
*/
class XmlReplay
{
public:
XmlReplay(class QFile * file, const QString & tag = XmlRecorder::TAG); // replay XML from the given file
XmlReplay(QXmlStreamReader & xml, const QString & tag = XmlRecorder::TAG); // replay XML from the given stream
virtual ~XmlReplay();
XmlReplay* closeSubstream(); // convenience function to close out a substream and return its parent
//! \brief Retrieve next matching event of the given XmlReplayEvent subclass.
template<class T> inline T* getNextEvent(const QString & id = "")
{
T* event = dynamic_cast<T*>(getNextEvent(T::TAG, id));
return event;
}
protected:
XmlReplay(XmlReplay* parent, const QString & id, const QString & tag = XmlRecorder::TAG); // constructor used by substreams
QXmlStreamReader* findSubstream(XmlReplay* child, const QString & id); // initialize a child substream, used by above constructor
void deserialize(QXmlStreamReader & xml);
void deserializeEvents(QXmlStreamReader & xml);
XmlReplayEvent* getNextEvent(const QString & type, const QString & id = "");
void seekToTime(const QDateTime & time);
const QString m_tag; // opening/closing tag for this instance
QFile* m_file; // nullptr for non-file replay
QHash<QString,QHash<QString,QList<XmlReplayEvent*>>> m_eventIndex; // type and ID-based index into the events, see discussion of reordering above
QHash<QString,QHash<QString,int>> m_indexPosition; // positions at which to begin searching the index, updated by random-access events
QList<XmlReplayEvent*> m_events; // linear list of all events in their original order
XmlReplayEvent* m_pendingSignal; // the signal (if any) that should be replayed as soon as the current event has been processed
QMutex m_lock; // prevent signals from being dispatched while an event is being processed, see XmlReplayLock below
XmlReplay* m_parent; // parent instance of a substream
inline void lock() { m_lock.lock(); }
inline void unlock() { m_lock.unlock(); }
void processPendingSignals(const QObject* target);
friend class XmlReplayLock;
};
/*
* XML replay event base class
*
* This class is used to represent a replayable event. An event is created
* when performing any replayable action, and then recorded (via record())
* when appropriate. During replay, an event is retrieved from the XmlReplay
* instance and its previously recorded result should be returned instead of
* performing the original action.
*
* Subclasses are created as subclasses of the XmlReplayBase template (see
* below), which handles their factory method and tag registration.
*
* Subclasses that should be retrieved by ID as well as type will need to
* override id() to return the ID to use for indexing.
*
* Subclasses that represent signal events (rather than API calls) will need
* to set their m_signal string to the name of the signal to be emitted, and
* additionally override signal() if they need to pass parameters with the
* signal.
*
* Subclasses that represent random-access events (see discussion above)
* will need to override randomAccess() to return true.
*
* Subclasses whose XML contains raw hexadecimal data will need to override
* usesData() to return true. Subclasses whose XML contains other data
* (such as complex data types) will instead need to override read() and
* write().
*/
class XmlReplayEvent
{
public:
XmlReplayEvent();
virtual ~XmlReplayEvent() = default;
//! \brief Add the given key/value to the event. This will be written as an XML attribute in the order it added.
void set(const QString & name, const QString & value);
//! \brief Add the given key/integer to the event. This will be written as an XML attribute in the order it added.
void set(const QString & name, qint64 value);
//! \brief Add the raw data to the event. This will be written in hexadecimal as content of the event's XML tag.
void setData(const char* data, qint64 length);
//! \brief Get the value for the given key.
QString get(const QString & name) const;
//! \brief Get the raw data for this event.
QByteArray getData() const;
//! \brief True if there are no errors in this event, or false if the "error" attribute is set.
inline bool ok() const { return m_values.contains("error") == false; }
//! \brief Copy the result from the retrieved replay event (if any) into the current event.
void copyIf(const XmlReplayEvent* other);
//! \brief Record this event to the given XML recorder, doing nothing if the recorder is null.
void record(XmlRecorder* xml) const;
// Serialize this event to an XML stream.
friend QXmlStreamWriter & operator<<(QXmlStreamWriter & xml, const XmlReplayEvent & event);
// Deserialize this event's contents from an XML stream. The instance is first created via createInstance() based on the tag.
friend QXmlStreamReader & operator>>(QXmlStreamReader & xml, XmlReplayEvent & event);
// Write the tag's attributes and contents.
void writeTag(QXmlStreamWriter & xml) const;
//! \brief Return a string of this event as an XML tag.
operator QString() const;
// Subclassing support
//! \brief Return the XML tag used for this event. Automatically generated for subclasses by template.
virtual const QString & tag() const = 0;
//! \brief Return the ID for this event, if applicable. Subclasses should override this if their events should be retrieved by ID.
virtual const QString id() const { static const QString none(""); return none; }
//! \brief True if this event represents a "random-access" event that should cause subsequent event searches to start after this event's timestamp. Subclasses that represent such a state change should override this method.
virtual bool randomAccess() const { return false; }
// Event subclass registration and instance creation
typedef XmlReplayEvent* (*FactoryMethod)();
static bool registerClass(const QString & tag, FactoryMethod factory);
static XmlReplayEvent* createInstance(const QString & tag);
protected:
static QHash<QString,FactoryMethod> s_factories; // registered subclass factory methods, arranged by XML tag
//! \brief True this event contains raw data. Defaults to false, so subclasses that use raw data must override this.
virtual bool usesData() const { return false; }
//! \brief True if this event represents a signal event. Subclasses representing such events must set m_signal.
inline bool isSignal() const { return m_signal != nullptr; }
//! \brief Send a signal to the target object. Subclasses may override this to send signal arguments.
virtual void signal(QObject* target);
//! \brief Write any attributes or content needed specific to event. Subclasses may override this to support complex data types.
virtual void write(QXmlStreamWriter & xml) const;
//! \brief Read any attributes or content specific to this event. Subclasses may override this to support complex data types.
virtual void read(QXmlStreamReader & xml);
QDateTime m_time; // timestamp of event
XmlReplayEvent* m_next; // next recorded event, used during replay to trigger signals that automatically fire after an event is processed
const char* m_signal; // name of the signal to be emitted for this event, if any
QHash<QString,QString> m_values; // hash of key/value pairs for this event, written as attributes of the XML tag
QList<QString> m_keys; // list of keys so that attributes will be written in the order they were set
QString m_data; // hexademical string representing this event's raw data, written as contents of the XML tag
// Copy the timestamp as well as the attributes. Used when creating substreams.
void copy(const XmlReplayEvent & other);
friend class XmlReplay;
};
QHash<QString,XmlReplayEvent::FactoryMethod> XmlReplayEvent::s_factories;
void XmlReplayEvent::set(const QString & name, const QString & value)
{
if (!m_values.contains(name)) {
m_keys.append(name);
}
m_values[name] = value;
}
void XmlReplayEvent::set(const QString & name, qint64 value)
{
set(name, QString::number(value));
}
void XmlReplayEvent::setData(const char* data, qint64 length)
{
Q_ASSERT(usesData() == true);
QByteArray bytes = QByteArray::fromRawData(data, length);
m_data = bytes.toHex(' ').toUpper();
}
QString XmlReplayEvent::get(const QString & name) const
{
if (!m_values.contains(name)) {
qWarning().noquote() << *this << "missing attribute:" << name;
}
return m_values[name];
}
QByteArray XmlReplayEvent::getData() const
{
Q_ASSERT(usesData() == true);
if (m_data.isEmpty()) {
qWarning().noquote() << "replaying event with missing data" << *this;
QByteArray empty;
return empty; // toUtf8() below crashes with an empty string.
}
return QByteArray::fromHex(m_data.toUtf8());
}
XmlReplayEvent::operator QString() const
{
QString out;
QXmlStreamWriter xml(&out);
xml << *this;
return out;
}
void XmlReplayEvent::copyIf(const XmlReplayEvent* other)
{
// Leave the proposed event alone if there was no replay event.
if (other == nullptr) {
return;
}
// Do not copy timestamp.
m_values = other->m_values;
m_keys = other->m_keys;
m_data = other->m_data;
}
void XmlReplayEvent::copy(const XmlReplayEvent & other)
{
copyIf(&other);
// Copy the timestamp, as it is necessary for replaying substreams that use the timestamp as part of their ID.
m_time = other.m_time;
}
void XmlReplayEvent::signal(QObject* target)
{
// Queue the signal so that it won't be processed before the current event returns to its caller.
// (See XmlReplayLock below.)
QMetaObject::invokeMethod(target, m_signal, Qt::QueuedConnection);
}
void XmlReplayEvent::write(QXmlStreamWriter & xml) const
{
// Write key/value pairs as attributes in the order they were set.
for (auto key : m_keys) {
xml.writeAttribute(key, m_values[key]);
}
if (!m_data.isEmpty()) {
Q_ASSERT(usesData() == true);
xml.writeCharacters(m_data);
}
}
void XmlReplayEvent::read(QXmlStreamReader & xml)
{
QXmlStreamAttributes attribs = xml.attributes();
for (auto & attrib : attribs) {
if (attrib.name() != "time") { // skip outer timestamp, which is decoded by operator>>
set(attrib.name().toString(), attrib.value().toString());
}
}
if (usesData()) {
m_data = xml.readElementText();
} else {
xml.skipCurrentElement();
}
}
/*
* XML replay lock class
*
* An instance of this class should be created on the stack during any replayable
* event. Exiting scope will release the lock, at which point any signals that
* need to be replayed will be queued.
*
* Has no effect if events are not being replayed.
*/
class XmlReplayLock
{
public:
//! \brief Temporarily lock the XML replay (if any) until exiting scope, at which point any pending signals will be sent to the specified object.
XmlReplayLock(const QObject* obj, XmlReplay* replay);
~XmlReplayLock();
protected:
const QObject* m_target; // target object to receive any pending signals
XmlReplay* m_replay; // replay instance, or nullptr if not replaying
};
XmlReplayLock::XmlReplayLock(const QObject* obj, XmlReplay* replay)
: m_target(obj), m_replay(replay)
{
if (m_replay) {
// Prevent any triggered signal events from processing until the triggering lock is released.
m_replay->lock();
}
}
XmlReplayLock::~XmlReplayLock()
{
if (m_replay) {
m_replay->processPendingSignals(m_target);
m_replay->unlock();
}
}
// Derive the filepath for the given substream ID relative to the parent stream.
static QString substreamFilepath(QFile* parent, const QString & id)
{
Q_ASSERT(parent);
QFileInfo info(*parent);
QString path = info.canonicalPath() + QDir::separator() + info.completeBaseName() + "-" + id + ".xml";
return path;
}
XmlRecorder::XmlRecorder(QFile* stream, const QString & tag)
: m_tag(tag), m_file(stream), m_xml(new QXmlStreamWriter(stream)), m_parent(nullptr)
{
prologue();
}
XmlRecorder::XmlRecorder(QString & string, const QString & tag)
: m_tag(tag), m_file(nullptr), m_xml(new QXmlStreamWriter(&string)), m_parent(nullptr)
{
prologue();
}
// Protected constructor for substreams
XmlRecorder::XmlRecorder(XmlRecorder* parent, const QString & id, const QString & tag)
: m_tag(tag), m_file(nullptr), m_xml(nullptr), m_parent(parent)
{
Q_ASSERT(m_parent);
m_xml = m_parent->addSubstream(this, id);
if (m_xml == nullptr) {
qWarning() << "Not recording" << id;
static QString null;
m_xml = new QXmlStreamWriter(&null);
}
prologue();
}
// Initialize a child recording substream.
QXmlStreamWriter* XmlRecorder::addSubstream(XmlRecorder* child, const QString & id)
{
Q_ASSERT(child);
QXmlStreamWriter* xml = nullptr;
if (m_file) {
QString childPath = substreamFilepath(m_file, id);
child->m_file = new QFile(childPath);
if (child->m_file->open(QIODevice::WriteOnly | QIODevice::Append)) {
xml = new QXmlStreamWriter(child->m_file);
qDebug() << "Recording to" << childPath;
} else {
qWarning() << "Unable to open" << childPath << "for writing";
}
} else {
qWarning() << "String-based substreams are not supported";
// Maybe some day support string-based substreams:
// - parent passes string to child
// - on connectionClosed, parent asks recorder to flush string to stream
}
return xml;
}
XmlRecorder::~XmlRecorder()
{
epilogue();
delete m_xml;
// File substreams manage their own file.
if (m_parent && m_file) {
delete m_file;
}
}
// Close out a substream and return its parent.
XmlRecorder* XmlRecorder::closeSubstream()
{
auto parent = m_parent;
delete this;
return parent;
}
void XmlRecorder::prologue()
{
Q_ASSERT(m_xml);
m_xml->setAutoFormatting(true);
m_xml->setAutoFormattingIndent(2);
m_xml->writeStartElement(m_tag); // open enclosing tag
}
void XmlRecorder::epilogue()
{
Q_ASSERT(m_xml);
m_xml->writeEndElement(); // close enclosing tag
}
XmlReplay::XmlReplay(QFile* file, const QString & tag)
: m_tag(tag), m_file(file), m_pendingSignal(nullptr), m_parent(nullptr)
{
Q_ASSERT(file);
QFileInfo info(*file);
qDebug() << "Replaying from" << info.canonicalFilePath();
QXmlStreamReader xml(file);
deserialize(xml);
}
XmlReplay::XmlReplay(QXmlStreamReader & xml, const QString & tag)
: m_tag(tag), m_file(nullptr), m_pendingSignal(nullptr), m_parent(nullptr)
{
deserialize(xml);
}
// Protected constructor for substreams
XmlReplay::XmlReplay(XmlReplay* parent, const QString & id, const QString & tag)
: m_tag(tag), m_file(nullptr), m_pendingSignal(nullptr), m_parent(parent)
{
Q_ASSERT(m_parent);
auto xml = m_parent->findSubstream(this, id);
if (xml) {
deserialize(*xml);
delete xml;
} else {
qWarning() << "Not replaying" << id;
}
}
// Initialize a child replay substream.
QXmlStreamReader* XmlReplay::findSubstream(XmlReplay* child, const QString & id)
{
Q_ASSERT(child);
QXmlStreamReader* xml = nullptr;
if (m_file) {
QString childPath = substreamFilepath(m_file, id);
child->m_file = new QFile(childPath);
if (child->m_file->open(QIODevice::ReadOnly)) {
xml = new QXmlStreamReader(child->m_file);
qDebug() << "Replaying from" << childPath;
} else {
qWarning() << "Unable to open" << childPath << "for reading";
}
} else {
qWarning() << "String-based substreams are not supported";
// Maybe some day support string-based substreams:
// - when deserializing, use e.g. ConnectionEvents to cache the substream strings
// - then return a QXmlStreamReader here using that string
}
return xml;
}
XmlReplay::~XmlReplay()
{
for (auto event : m_events) {
delete event;
}
// File substreams manage their own file.
if (m_parent && m_file) {
delete m_file;
}
}
// Close out a substream and return its parent.
XmlReplay* XmlReplay::closeSubstream()
{
auto parent = m_parent;
delete this;
return parent;
}
void XmlReplay::deserialize(QXmlStreamReader & xml)
{
if (xml.readNextStartElement()) {
if (xml.name() == m_tag) {
deserializeEvents(xml);
} else {
qWarning() << "unexpected payload in replay XML:" << xml.name();
xml.skipCurrentElement();
}
}
}
void XmlReplay::deserializeEvents(QXmlStreamReader & xml)
{
while (xml.readNextStartElement()) {
QString type = xml.name().toString();
XmlReplayEvent* event = XmlReplayEvent::createInstance(type);
if (event) {
xml >> *event;
// Add to list
if (m_events.isEmpty() == false) {
m_events.last()->m_next = event;
}
m_events.append(event);
// Add to index
const QString & id = event->id();
auto & events = m_eventIndex[type][id];
events.append(event);
} else {
xml.skipCurrentElement();
}
}
}
// Queue any pending signals when a replay lock is released.
void XmlReplay::processPendingSignals(const QObject* target)
{
if (m_pendingSignal) {
XmlReplayEvent* pending = m_pendingSignal;
m_pendingSignal = nullptr;
// Dequeue the signal from the index; this may update m_pendingSignal.
XmlReplayEvent* dequeued = getNextEvent(pending->tag(), pending->id());
if (dequeued != pending) {
qWarning() << "triggered signal doesn't match dequeued signal!" << pending << dequeued;
}
// It is safe to re-cast this as non-const because signals are deferred
// and cannot alter the underlying target until the const method holding
// the lock releases it at function exit.
pending->signal(const_cast<QObject*>(target));
}
}
// Update the positions at which to begin searching the index, so that only events on or after the given time are returned by getNextEvent.
void XmlReplay::seekToTime(const QDateTime & time)
{
for (auto & type : m_eventIndex.keys()) {
for (auto & key : m_eventIndex[type].keys()) {
// Find the index of the first event on or after the given time.
auto & events = m_eventIndex[type][key];
int pos;
for (pos = 0; pos < events.size(); pos++) {
auto & event = events.at(pos);
// Random-access events should always start searching from position 0.
if (event->randomAccess() || event->m_time >= time) {
break;
}
}
// If pos == events.size(), that means there are no more events of this type
// after the given time.
m_indexPosition[type][key] = pos;
}
}
}
// Find and return the next event of the given type with the given ID, or nullptr if no more events match.
XmlReplayEvent* XmlReplay::getNextEvent(const QString & type, const QString & id)
{
XmlReplayEvent* event = nullptr;
// Event handlers should always be wrapped in an XmlReplayLock, so warn if that's not the case.
if (m_lock.tryLock()) {
qWarning() << "XML replay" << type << "object not locked by event handler!";
m_lock.unlock();
}
// Search the index for the next matching event (if any).
if (m_eventIndex.contains(type)) {
auto & ids = m_eventIndex[type];
if (ids.contains(id)) {
auto & events = ids[id];
// Start at the position identified by the previous random-access event.
int pos = m_indexPosition[type][id];
if (pos < events.size()) {
event = events.at(pos);
// TODO: if we're simulating the original timing, return nullptr if we haven't reached this event's time yet;
// otherwise:
events.removeAt(pos);
}
}
}
// If this is a random-access event, we need to update the index positions for all non-random-access events.
if (event && event->randomAccess()) {
seekToTime(event->m_time);
}
// If the event following this one is a signal (that replay needs to trigger), save it as pending
// so that it can be emitted when the replay lock for this event is released.
if (event && event->m_next && event->m_next->isSignal()) {
Q_ASSERT(m_pendingSignal == nullptr); // if this ever fails, we may need m_pendingSignal to be a list
m_pendingSignal = event->m_next;
}
return event;
}
// MARK: -
// MARK: XML record/playback event base class
XmlReplayEvent::XmlReplayEvent()
: m_time(QDateTime::currentDateTime()), m_next(nullptr), m_signal(nullptr)
{
}
void XmlReplayEvent::record(XmlRecorder* writer) const
{
// Do nothing if we're not recording.
if (writer != nullptr) {
writer->lock();
writer->xml() << *this;
writer->unlock();
}
}
bool XmlReplayEvent::registerClass(const QString & tag, XmlReplayEvent::FactoryMethod factory)
{
if (s_factories.contains(tag)) {
qWarning() << "Event class already registered for tag" << tag;
return false;
}
s_factories[tag] = factory;
return true;
}
XmlReplayEvent* XmlReplayEvent::createInstance(const QString & tag)
{
XmlReplayEvent* event = nullptr;
XmlReplayEvent::FactoryMethod factory = s_factories.value(tag);
if (factory == nullptr) {
qWarning() << "No event class registered for XML tag" << tag;
} else {
event = factory();
}
return event;
}
void XmlReplayEvent::writeTag(QXmlStreamWriter & xml) const
{
QDateTime time = m_time.toOffsetFromUtc(m_time.offsetFromUtc()); // force display of UTC offset
#if QT_VERSION < QT_VERSION_CHECK(5,9,0)
// TODO: Can we please deprecate support for Qt older than 5.9?
QString timestamp = time.toString(Qt::ISODate);
#else
QString timestamp = time.toString(Qt::ISODateWithMs);
#endif
xml.writeAttribute("time", timestamp);
// Call this event's overridable write method.
write(xml);
}
QXmlStreamWriter & operator<<(QXmlStreamWriter & xml, const XmlReplayEvent & event)
{
xml.writeStartElement(event.tag());
event.writeTag(xml);
xml.writeEndElement();
return xml;
}
QXmlStreamReader & operator>>(QXmlStreamReader & xml, XmlReplayEvent & event)
{
Q_ASSERT(xml.isStartElement() && xml.name() == event.tag());
QDateTime time;
if (xml.attributes().hasAttribute("time")) {
#if QT_VERSION < QT_VERSION_CHECK(5,9,0)
// TODO: Can we please deprecate support for Qt older than 5.9?
time = QDateTime::fromString(xml.attributes().value("time").toString(), Qt::ISODate);
#else
time = QDateTime::fromString(xml.attributes().value("time").toString(), Qt::ISODateWithMs);
#endif
} else {
qWarning() << "Missing timestamp in" << xml.name() << "tag, using current time";
time = QDateTime::currentDateTime();
}
event.m_time = time;
// Call this event's overridable read method.
event.read(xml);
return xml;
}
// Convenience template for serializing QLists to XML
template<typename T> QXmlStreamWriter & operator<<(QXmlStreamWriter & xml, const QList<T> & list)
{
for (auto & item : list) {
xml << item;
}
return xml;
}
// Convenience template for deserializing QLists from XML
template<typename T> QXmlStreamReader & operator>>(QXmlStreamReader & xml, QList<T> & list)
{
list.clear();
while (xml.readNextStartElement()) {
T item;
xml >> item;
list.append(item);
}
return xml;
}
/*
* Intermediate parent class of concrete event subclasses.
*
* We use this extra CRTP templating so that concrete event subclasses
* require as little code as possible:
*
* The subclass's tag and factory method are automatically generated by this
* template.
*/
template <typename Derived>
class XmlReplayBase : public XmlReplayEvent
{
public:
static const QString TAG;
static const bool registered;
virtual const QString & tag() const { return TAG; };
static XmlReplayEvent* createInstance()
{
Derived* instance = new Derived();
return static_cast<XmlReplayEvent*>(instance);
}
};
/*
* Macro to define an XmlReplayEvent subclass's tag and automatically
* register the subclass at global-initialization time, before main()
*/
#define REGISTER_XMLREPLAYEVENT(tag, type) \
template<> const QString XmlReplayBase<type>::TAG = tag; \
template<> const bool XmlReplayBase<type>::registered = XmlReplayEvent::registerClass(XmlReplayBase<type>::TAG, XmlReplayBase<type>::createInstance);
// MARK: - // MARK: -
// MARK: Device connection manager // MARK: Device connection manager
@ -989,6 +176,7 @@ const QString T::TYPE = type; \
const bool T::registered = DeviceConnectionManager::registerClass(T::TYPE, T::createInstance); \ const bool T::registered = DeviceConnectionManager::registerClass(T::TYPE, T::createInstance); \
DeviceConnection* T::createInstance(const QString & name, XmlRecorder* record, XmlReplay* replay) { return static_cast<DeviceConnection*>(new T(name, record, replay)); } DeviceConnection* T::createInstance(const QString & name, XmlRecorder* record, XmlReplay* replay) { return static_cast<DeviceConnection*>(new T(name, record, replay)); }
// MARK: - // MARK: -
// MARK: Device manager events // MARK: Device manager events
@ -1144,7 +332,7 @@ bool SerialPortInfo::operator==(const SerialPortInfo & other) const
// MARK: - // MARK: -
// MARK: Device connection base class // MARK: Device connection base classes and events
/* /*
* Event recorded in the Device Connection Manager XML stream that indicates * Event recorded in the Device Connection Manager XML stream that indicates

527
oscar/SleepLib/xmlreplay.cpp Normal file
View File

@ -0,0 +1,527 @@
/* XML event recording/replay
*
* Copyright (c) 2020 The OSCAR Team
*
* This file is subject to the terms and conditions of the GNU General Public
* License. See the file COPYING in the main directory of the source code
* for more details. */
#include "xmlreplay.h"
#include <QFile>
#include <QFileInfo>
#include <QDir>
#include <QBuffer>
#include <QDateTime>
#include <QXmlStreamReader>
#include <QXmlStreamWriter>
#include <QDebug>
// Derive the filepath for the given substream ID relative to the parent stream.
static QString substreamFilepath(QFile* parent, const QString & id)
{
Q_ASSERT(parent);
QFileInfo info(*parent);
QString path = info.canonicalPath() + QDir::separator() + info.completeBaseName() + "-" + id + ".xml";
return path;
}
// MARK: -
// MARK: XML record/playback base classes
const QString XmlRecorder::TAG = "xmlreplay";
XmlRecorder::XmlRecorder(QFile* stream, const QString & tag)
: m_tag(tag), m_file(stream), m_xml(new QXmlStreamWriter(stream)), m_parent(nullptr)
{
prologue();
}
XmlRecorder::XmlRecorder(QString & string, const QString & tag)
: m_tag(tag), m_file(nullptr), m_xml(new QXmlStreamWriter(&string)), m_parent(nullptr)
{
prologue();
}
// Protected constructor for substreams
XmlRecorder::XmlRecorder(XmlRecorder* parent, const QString & id, const QString & tag)
: m_tag(tag), m_file(nullptr), m_xml(nullptr), m_parent(parent)
{
Q_ASSERT(m_parent);
m_xml = m_parent->addSubstream(this, id);
if (m_xml == nullptr) {
qWarning() << "Not recording" << id;
static QString null;
m_xml = new QXmlStreamWriter(&null);
}
prologue();
}
// Initialize a child recording substream.
QXmlStreamWriter* XmlRecorder::addSubstream(XmlRecorder* child, const QString & id)
{
Q_ASSERT(child);
QXmlStreamWriter* xml = nullptr;
if (m_file) {
QString childPath = substreamFilepath(m_file, id);
child->m_file = new QFile(childPath);
if (child->m_file->open(QIODevice::WriteOnly | QIODevice::Append)) {
xml = new QXmlStreamWriter(child->m_file);
qDebug() << "Recording to" << childPath;
} else {
qWarning() << "Unable to open" << childPath << "for writing";
}
} else {
qWarning() << "String-based substreams are not supported";
// Maybe some day support string-based substreams:
// - parent passes string to child
// - on connectionClosed, parent asks recorder to flush string to stream
}
return xml;
}
XmlRecorder::~XmlRecorder()
{
epilogue();
delete m_xml;
// File substreams manage their own file.
if (m_parent && m_file) {
delete m_file;
}
}
// Close out a substream and return its parent.
XmlRecorder* XmlRecorder::closeSubstream()
{
auto parent = m_parent;
delete this;
return parent;
}
void XmlRecorder::prologue()
{
Q_ASSERT(m_xml);
m_xml->setAutoFormatting(true);
m_xml->setAutoFormattingIndent(2);
m_xml->writeStartElement(m_tag); // open enclosing tag
}
void XmlRecorder::epilogue()
{
Q_ASSERT(m_xml);
m_xml->writeEndElement(); // close enclosing tag
}
XmlReplay::XmlReplay(QFile* file, const QString & tag)
: m_tag(tag), m_file(file), m_pendingSignal(nullptr), m_parent(nullptr)
{
Q_ASSERT(file);
QFileInfo info(*file);
qDebug() << "Replaying from" << info.canonicalFilePath();
QXmlStreamReader xml(file);
deserialize(xml);
}
XmlReplay::XmlReplay(QXmlStreamReader & xml, const QString & tag)
: m_tag(tag), m_file(nullptr), m_pendingSignal(nullptr), m_parent(nullptr)
{
deserialize(xml);
}
// Protected constructor for substreams
XmlReplay::XmlReplay(XmlReplay* parent, const QString & id, const QString & tag)
: m_tag(tag), m_file(nullptr), m_pendingSignal(nullptr), m_parent(parent)
{
Q_ASSERT(m_parent);
auto xml = m_parent->findSubstream(this, id);
if (xml) {
deserialize(*xml);
delete xml;
} else {
qWarning() << "Not replaying" << id;
}
}
// Initialize a child replay substream.
QXmlStreamReader* XmlReplay::findSubstream(XmlReplay* child, const QString & id)
{
Q_ASSERT(child);
QXmlStreamReader* xml = nullptr;
if (m_file) {
QString childPath = substreamFilepath(m_file, id);
child->m_file = new QFile(childPath);
if (child->m_file->open(QIODevice::ReadOnly)) {
xml = new QXmlStreamReader(child->m_file);
qDebug() << "Replaying from" << childPath;
} else {
qWarning() << "Unable to open" << childPath << "for reading";
}
} else {
qWarning() << "String-based substreams are not supported";
// Maybe some day support string-based substreams:
// - when deserializing, use e.g. ConnectionEvents to cache the substream strings
// - then return a QXmlStreamReader here using that string
}
return xml;
}
XmlReplay::~XmlReplay()
{
for (auto event : m_events) {
delete event;
}
// File substreams manage their own file.
if (m_parent && m_file) {
delete m_file;
}
}
// Close out a substream and return its parent.
XmlReplay* XmlReplay::closeSubstream()
{
auto parent = m_parent;
delete this;
return parent;
}
void XmlReplay::deserialize(QXmlStreamReader & xml)
{
if (xml.readNextStartElement()) {
if (xml.name() == m_tag) {
deserializeEvents(xml);
} else {
qWarning() << "unexpected payload in replay XML:" << xml.name();
xml.skipCurrentElement();
}
}
}
void XmlReplay::deserializeEvents(QXmlStreamReader & xml)
{
while (xml.readNextStartElement()) {
QString type = xml.name().toString();
XmlReplayEvent* event = XmlReplayEvent::createInstance(type);
if (event) {
xml >> *event;
// Add to list
if (m_events.isEmpty() == false) {
m_events.last()->m_next = event;
}
m_events.append(event);
// Add to index
const QString & id = event->id();
auto & events = m_eventIndex[type][id];
events.append(event);
} else {
xml.skipCurrentElement();
}
}
}
// Queue any pending signals when a replay lock is released.
void XmlReplay::processPendingSignals(const QObject* target)
{
if (m_pendingSignal) {
XmlReplayEvent* pending = m_pendingSignal;
m_pendingSignal = nullptr;
// Dequeue the signal from the index; this may update m_pendingSignal.
XmlReplayEvent* dequeued = getNextEvent(pending->tag(), pending->id());
if (dequeued != pending) {
qWarning() << "triggered signal doesn't match dequeued signal!" << pending << dequeued;
}
// It is safe to re-cast this as non-const because signals are deferred
// and cannot alter the underlying target until the const method holding
// the lock releases it at function exit.
pending->signal(const_cast<QObject*>(target));
}
}
// Update the positions at which to begin searching the index, so that only events on or after the given time are returned by getNextEvent.
void XmlReplay::seekToTime(const QDateTime & time)
{
for (auto & type : m_eventIndex.keys()) {
for (auto & key : m_eventIndex[type].keys()) {
// Find the index of the first event on or after the given time.
auto & events = m_eventIndex[type][key];
int pos;
for (pos = 0; pos < events.size(); pos++) {
auto & event = events.at(pos);
// Random-access events should always start searching from position 0.
if (event->randomAccess() || event->m_time >= time) {
break;
}
}
// If pos == events.size(), that means there are no more events of this type
// after the given time.
m_indexPosition[type][key] = pos;
}
}
}
// Find and return the next event of the given type with the given ID, or nullptr if no more events match.
XmlReplayEvent* XmlReplay::getNextEvent(const QString & type, const QString & id)
{
XmlReplayEvent* event = nullptr;
// Event handlers should always be wrapped in an XmlReplayLock, so warn if that's not the case.
if (m_lock.tryLock()) {
qWarning() << "XML replay" << type << "object not locked by event handler!";
m_lock.unlock();
}
// Search the index for the next matching event (if any).
if (m_eventIndex.contains(type)) {
auto & ids = m_eventIndex[type];
if (ids.contains(id)) {
auto & events = ids[id];
// Start at the position identified by the previous random-access event.
int pos = m_indexPosition[type][id];
if (pos < events.size()) {
event = events.at(pos);
// TODO: if we're simulating the original timing, return nullptr if we haven't reached this event's time yet;
// otherwise:
events.removeAt(pos);
}
}
}
// If this is a random-access event, we need to update the index positions for all non-random-access events.
if (event && event->randomAccess()) {
seekToTime(event->m_time);
}
// If the event following this one is a signal (that replay needs to trigger), save it as pending
// so that it can be emitted when the replay lock for this event is released.
if (event && event->m_next && event->m_next->isSignal()) {
Q_ASSERT(m_pendingSignal == nullptr); // if this ever fails, we may need m_pendingSignal to be a list
m_pendingSignal = event->m_next;
}
return event;
}
// MARK: -
// MARK: XML record/playback event base class
void XmlReplayEvent::set(const QString & name, const QString & value)
{
if (!m_values.contains(name)) {
m_keys.append(name);
}
m_values[name] = value;
}
void XmlReplayEvent::set(const QString & name, qint64 value)
{
set(name, QString::number(value));
}
void XmlReplayEvent::setData(const char* data, qint64 length)
{
Q_ASSERT(usesData() == true);
QByteArray bytes = QByteArray::fromRawData(data, length);
m_data = bytes.toHex(' ').toUpper();
}
QString XmlReplayEvent::get(const QString & name) const
{
if (!m_values.contains(name)) {
qWarning().noquote() << *this << "missing attribute:" << name;
}
return m_values[name];
}
QByteArray XmlReplayEvent::getData() const
{
Q_ASSERT(usesData() == true);
if (m_data.isEmpty()) {
qWarning().noquote() << "replaying event with missing data" << *this;
QByteArray empty;
return empty; // toUtf8() below crashes with an empty string.
}
return QByteArray::fromHex(m_data.toUtf8());
}
void XmlReplayEvent::copyIf(const XmlReplayEvent* other)
{
// Leave the proposed event alone if there was no replay event.
if (other == nullptr) {
return;
}
// Do not copy timestamp.
m_values = other->m_values;
m_keys = other->m_keys;
m_data = other->m_data;
}
void XmlReplayEvent::copy(const XmlReplayEvent & other)
{
copyIf(&other);
// Copy the timestamp, as it is necessary for replaying substreams that use the timestamp as part of their ID.
m_time = other.m_time;
}
void XmlReplayEvent::signal(QObject* target)
{
// Queue the signal so that it won't be processed before the current event returns to its caller.
// (See XmlReplayLock below.)
QMetaObject::invokeMethod(target, m_signal, Qt::QueuedConnection);
}
void XmlReplayEvent::write(QXmlStreamWriter & xml) const
{
// Write key/value pairs as attributes in the order they were set.
for (auto key : m_keys) {
xml.writeAttribute(key, m_values[key]);
}
if (!m_data.isEmpty()) {
Q_ASSERT(usesData() == true);
xml.writeCharacters(m_data);
}
}
void XmlReplayEvent::read(QXmlStreamReader & xml)
{
QXmlStreamAttributes attribs = xml.attributes();
for (auto & attrib : attribs) {
if (attrib.name() != "time") { // skip outer timestamp, which is decoded by operator>>
set(attrib.name().toString(), attrib.value().toString());
}
}
if (usesData()) {
m_data = xml.readElementText();
} else {
xml.skipCurrentElement();
}
}
void XmlReplayEvent::record(XmlRecorder* writer) const
{
// Do nothing if we're not recording.
if (writer != nullptr) {
writer->lock();
writer->xml() << *this;
writer->unlock();
}
}
XmlReplayEvent::XmlReplayEvent()
: m_time(QDateTime::currentDateTime()), m_next(nullptr), m_signal(nullptr)
{
}
QHash<QString,XmlReplayEvent::FactoryMethod> & XmlReplayEvent::factories()
{
// Use a local static variable so that it is guaranteed to be initialized when registerClass and createInstance are called.
static QHash<QString,FactoryMethod> s_factories;
return s_factories;
}
bool XmlReplayEvent::registerClass(const QString & tag, XmlReplayEvent::FactoryMethod factory)
{
if (factories().contains(tag)) {
qWarning() << "Event class already registered for tag" << tag;
return false;
}
factories()[tag] = factory;
return true;
}
XmlReplayEvent* XmlReplayEvent::createInstance(const QString & tag)
{
XmlReplayEvent* event = nullptr;
XmlReplayEvent::FactoryMethod factory = factories().value(tag);
if (factory == nullptr) {
qWarning() << "No event class registered for XML tag" << tag;
} else {
event = factory();
}
return event;
}
void XmlReplayEvent::writeTag(QXmlStreamWriter & xml) const
{
QDateTime time = m_time.toOffsetFromUtc(m_time.offsetFromUtc()); // force display of UTC offset
#if QT_VERSION < QT_VERSION_CHECK(5,9,0)
// TODO: Can we please deprecate support for Qt older than 5.9?
QString timestamp = time.toString(Qt::ISODate);
#else
QString timestamp = time.toString(Qt::ISODateWithMs);
#endif
xml.writeAttribute("time", timestamp);
// Call this event's overridable write method.
write(xml);
}
QXmlStreamWriter & operator<<(QXmlStreamWriter & xml, const XmlReplayEvent & event)
{
xml.writeStartElement(event.tag());
event.writeTag(xml);
xml.writeEndElement();
return xml;
}
QXmlStreamReader & operator>>(QXmlStreamReader & xml, XmlReplayEvent & event)
{
Q_ASSERT(xml.isStartElement() && xml.name() == event.tag());
QDateTime time;
if (xml.attributes().hasAttribute("time")) {
#if QT_VERSION < QT_VERSION_CHECK(5,9,0)
// TODO: Can we please deprecate support for Qt older than 5.9?
time = QDateTime::fromString(xml.attributes().value("time").toString(), Qt::ISODate);
#else
time = QDateTime::fromString(xml.attributes().value("time").toString(), Qt::ISODateWithMs);
#endif
} else {
qWarning() << "Missing timestamp in" << xml.name() << "tag, using current time";
time = QDateTime::currentDateTime();
}
event.m_time = time;
// Call this event's overridable read method.
event.read(xml);
return xml;
}
XmlReplayEvent::operator QString() const
{
QString out;
QXmlStreamWriter xml(&out);
xml << *this;
return out;
}
XmlReplayLock::XmlReplayLock(const QObject* obj, XmlReplay* replay)
: m_target(obj), m_replay(replay)
{
if (m_replay) {
// Prevent any triggered signal events from processing until the triggering lock is released.
m_replay->lock();
}
}
XmlReplayLock::~XmlReplayLock()
{
if (m_replay) {
m_replay->processPendingSignals(m_target);
m_replay->unlock();
}
}

323
oscar/SleepLib/xmlreplay.h Normal file
View File

@ -0,0 +1,323 @@
/* XML event recording/replay
*
* Copyright (c) 2020 The OSCAR Team
*
* This file is subject to the terms and conditions of the GNU General Public
* License. See the file COPYING in the main directory of the source code
* for more details. */
#ifndef XMLREPLAY_H
#define XMLREPLAY_H
#include <QString>
#include <QDateTime>
#include <QMutex>
#include <QXmlStreamWriter>
#include <QXmlStreamReader>
#include <QObject>
/*
* XML recording base class
*
* While this can be used on its own via the public constructors, it is
* typically used as a base class for a subclasses that handle specific
* events.
*
* A single instance of this class can write a linear sequence of events to
* XML, either to a string (for testing) or to a file (for production use).
*
* Sometimes, however, there is need for certain sequences to be treated as
* separate, either due to multithreading (such recording as multiple
* simultaneous connections), or in order to treat a certain excerpt (such
* as data download that we might wish to archive) separately.
*
* These sequences are handled as "substreams" of the parent stream. The
* parent stream will typically record a substream's open/close or start/
* stop along with its ID. The substream will be written to a separate XML
* stream identified by that ID. Substreams are implemented as subclasses of
* this base class.
*
* TODO: At the moment, only file-based substreams are supported. In theory
* it should be possible to cache string-based substreams and then insert
* them inline into the parent after the substream-close event is recorded.
*/
class XmlRecorder
{
public:
static const QString TAG; // default tag if no subclass
XmlRecorder(class QFile * file, const QString & tag = XmlRecorder::TAG); // record XML to the given file
XmlRecorder(QString & string, const QString & tag = XmlRecorder::TAG); // record XML to the given string
virtual ~XmlRecorder(); // write the epilogue and close the recorder
XmlRecorder* closeSubstream(); // convenience function to close out a substream and return its parent
inline QXmlStreamWriter & xml() { return *m_xml; }
inline void lock() { m_mutex.lock(); }
inline void unlock() { m_mutex.unlock(); }
protected:
XmlRecorder(XmlRecorder* parent, const QString & id, const QString & tag); // constructor used by substreams
QXmlStreamWriter* addSubstream(XmlRecorder* child, const QString & id); // initialize a child substream, used by above constructor
const QString m_tag; // opening/closing tag for this instance
QFile* m_file; // nullptr for non-file recordings
QXmlStreamWriter* m_xml; // XML output stream
QMutex m_mutex; // force one thread at a time to write to m_xml
XmlRecorder* m_parent; // parent instance of a substream
void prologue();
void epilogue();
};
/*
* XML replay base class
*
* A single instance of this class caches events from a previously recorded
* XML stream, either from a string (for testing) or from a file (for
* production use).
*
* Unlike recording, the replay need not be strictly linear. In fact, the
* implementation is designed to allow for limited reordering during replay,
* so that minor changes to code should result in sensible replay until a
* new recording can be made.
*
* There are two aspects to this reordering:
*
* First, events can be retrieved (and consumed) in any order, being
* retrieved by type and ID (and then in order within that type and ID).
*
* Second, events that are flagged as random-access (see randomAccess below)
* will cause the above retrieval to subsequently begin searching on or
* after the random-access event's timestamp (except for other random-access
* events, which are always searched from the beginning.)
*
* This allow non-stateful events to be replayed arbitrarily, and for
* stateful events (such as commands sent to a device) to be approximated
* (where subsequent data received matches the command sent).
*
* Furthermore, when events are triggered in the same order as they were
* during recordering, the above reordering will have no effect, and the
* original ordering will be replayed identically.
*
* See XmlRecorder above for a discussion of substreams.
*/
class XmlReplay
{
public:
XmlReplay(class QFile * file, const QString & tag = XmlRecorder::TAG); // replay XML from the given file
XmlReplay(QXmlStreamReader & xml, const QString & tag = XmlRecorder::TAG); // replay XML from the given stream
virtual ~XmlReplay();
XmlReplay* closeSubstream(); // convenience function to close out a substream and return its parent
//! \brief Retrieve next matching event of the given XmlReplayEvent subclass.
template<class T> inline T* getNextEvent(const QString & id = "")
{
T* event = dynamic_cast<T*>(getNextEvent(T::TAG, id));
return event;
}
protected:
XmlReplay(XmlReplay* parent, const QString & id, const QString & tag = XmlRecorder::TAG); // constructor used by substreams
QXmlStreamReader* findSubstream(XmlReplay* child, const QString & id); // initialize a child substream, used by above constructor
void deserialize(QXmlStreamReader & xml);
void deserializeEvents(QXmlStreamReader & xml);
class XmlReplayEvent* getNextEvent(const QString & type, const QString & id = "");
void seekToTime(const QDateTime & time);
const QString m_tag; // opening/closing tag for this instance
QFile* m_file; // nullptr for non-file replay
QHash<QString,QHash<QString,QList<XmlReplayEvent*>>> m_eventIndex; // type and ID-based index into the events, see discussion of reordering above
QHash<QString,QHash<QString,int>> m_indexPosition; // positions at which to begin searching the index, updated by random-access events
QList<XmlReplayEvent*> m_events; // linear list of all events in their original order
XmlReplayEvent* m_pendingSignal; // the signal (if any) that should be replayed as soon as the current event has been processed
QMutex m_lock; // prevent signals from being dispatched while an event is being processed, see XmlReplayLock below
XmlReplay* m_parent; // parent instance of a substream
inline void lock() { m_lock.lock(); }
inline void unlock() { m_lock.unlock(); }
void processPendingSignals(const QObject* target);
friend class XmlReplayLock;
};
/*
* XML replay event base class
*
* This class is used to represent a replayable event. An event is created
* when performing any replayable action, and then recorded (via record())
* when appropriate. During replay, an event is retrieved from the XmlReplay
* instance and its previously recorded result should be returned instead of
* performing the original action.
*
* Subclasses are created as subclasses of the XmlReplayBase template (see
* below), which handles their factory method and tag registration.
*
* Subclasses that should be retrieved by ID as well as type will need to
* override id() to return the ID to use for indexing.
*
* Subclasses that represent signal events (rather than API calls) will need
* to set their m_signal string to the name of the signal to be emitted, and
* additionally override signal() if they need to pass parameters with the
* signal.
*
* Subclasses that represent random-access events (see discussion above)
* will need to override randomAccess() to return true.
*
* Subclasses whose XML contains raw hexadecimal data will need to override
* usesData() to return true. Subclasses whose XML contains other data
* (such as complex data types) will instead need to override read() and
* write().
*/
class XmlReplayEvent
{
public:
XmlReplayEvent();
virtual ~XmlReplayEvent() = default;
//! \brief Add the given key/value to the event. This will be written as an XML attribute in the order it added.
void set(const QString & name, const QString & value);
//! \brief Add the given key/integer to the event. This will be written as an XML attribute in the order it added.
void set(const QString & name, qint64 value);
//! \brief Add the raw data to the event. This will be written in hexadecimal as content of the event's XML tag.
void setData(const char* data, qint64 length);
//! \brief Get the value for the given key.
QString get(const QString & name) const;
//! \brief Get the raw data for this event.
QByteArray getData() const;
//! \brief True if there are no errors in this event, or false if the "error" attribute is set.
inline bool ok() const { return m_values.contains("error") == false; }
//! \brief Copy the result from the retrieved replay event (if any) into the current event.
void copyIf(const XmlReplayEvent* other);
//! \brief Record this event to the given XML recorder, doing nothing if the recorder is null.
void record(XmlRecorder* xml) const;
// Serialize this event to an XML stream.
friend QXmlStreamWriter & operator<<(QXmlStreamWriter & xml, const XmlReplayEvent & event);
// Deserialize this event's contents from an XML stream. The instance is first created via createInstance() based on the tag.
friend QXmlStreamReader & operator>>(QXmlStreamReader & xml, XmlReplayEvent & event);
// Write the tag's attributes and contents.
void writeTag(QXmlStreamWriter & xml) const;
//! \brief Return a string of this event as an XML tag.
operator QString() const;
// Subclassing support
//! \brief Return the XML tag used for this event. Automatically generated for subclasses by template.
virtual const QString & tag() const = 0;
//! \brief Return the ID for this event, if applicable. Subclasses should override this if their events should be retrieved by ID.
virtual const QString id() const { static const QString none(""); return none; }
//! \brief True if this event represents a "random-access" event that should cause subsequent event searches to start after this event's timestamp. Subclasses that represent such a state change should override this method.
virtual bool randomAccess() const { return false; }
// Event subclass registration and instance creation
typedef XmlReplayEvent* (*FactoryMethod)();
static bool registerClass(const QString & tag, FactoryMethod factory);
static XmlReplayEvent* createInstance(const QString & tag);
protected:
static QHash<QString,FactoryMethod> & factories(); // registered subclass factory methods, arranged by XML tag
//! \brief True this event contains raw data. Defaults to false, so subclasses that use raw data must override this.
virtual bool usesData() const { return false; }
//! \brief True if this event represents a signal event. Subclasses representing such events must set m_signal.
inline bool isSignal() const { return m_signal != nullptr; }
//! \brief Send a signal to the target object. Subclasses may override this to send signal arguments.
virtual void signal(QObject* target);
//! \brief Write any attributes or content needed specific to event. Subclasses may override this to support complex data types.
virtual void write(QXmlStreamWriter & xml) const;
//! \brief Read any attributes or content specific to this event. Subclasses may override this to support complex data types.
virtual void read(QXmlStreamReader & xml);
QDateTime m_time; // timestamp of event
XmlReplayEvent* m_next; // next recorded event, used during replay to trigger signals that automatically fire after an event is processed
const char* m_signal; // name of the signal to be emitted for this event, if any
QHash<QString,QString> m_values; // hash of key/value pairs for this event, written as attributes of the XML tag
QList<QString> m_keys; // list of keys so that attributes will be written in the order they were set
QString m_data; // hexademical string representing this event's raw data, written as contents of the XML tag
// Copy the timestamp as well as the attributes. Used when creating substreams.
void copy(const XmlReplayEvent & other);
friend class XmlReplay;
};
// Convenience template for serializing QLists to XML
template<typename T> QXmlStreamWriter & operator<<(QXmlStreamWriter & xml, const QList<T> & list)
{
for (auto & item : list) {
xml << item;
}
return xml;
}
// Convenience template for deserializing QLists from XML
template<typename T> QXmlStreamReader & operator>>(QXmlStreamReader & xml, QList<T> & list)
{
list.clear();
while (xml.readNextStartElement()) {
T item;
xml >> item;
list.append(item);
}
return xml;
}
/*
* Intermediate parent class of concrete event subclasses.
*
* We use this extra CRTP templating so that concrete event subclasses
* require as little code as possible:
*
* The subclass's tag and factory method are automatically generated by this
* template.
*/
template <typename Derived>
class XmlReplayBase : public XmlReplayEvent
{
public:
static const QString TAG;
static const bool registered;
virtual const QString & tag() const { return TAG; };
static XmlReplayEvent* createInstance()
{
Derived* instance = new Derived();
return static_cast<XmlReplayEvent*>(instance);
}
};
/*
* Macro to define an XmlReplayEvent subclass's tag and automatically
* register the subclass at global-initialization time, before main()
*/
#define REGISTER_XMLREPLAYEVENT(tag, type) \
template<> const QString XmlReplayBase<type>::TAG = tag; \
template<> const bool XmlReplayBase<type>::registered = XmlReplayEvent::registerClass(XmlReplayBase<type>::TAG, XmlReplayBase<type>::createInstance);
/*
* XML replay lock class
*
* An instance of this class should be created on the stack during any replayable
* event. Exiting scope will release the lock, at which point any signals that
* need to be replayed will be queued.
*
* Has no effect if events are not being replayed.
*/
class XmlReplayLock
{
public:
//! \brief Temporarily lock the XML replay (if any) until exiting scope, at which point any pending signals will be sent to the specified object.
XmlReplayLock(const QObject* obj, XmlReplay* replay);
~XmlReplayLock();
protected:
const QObject* m_target; // target object to receive any pending signals
XmlReplay* m_replay; // replay instance, or nullptr if not replaying
};
#endif // XMLREPLAY_H

2
oscar/oscar.pro
View File

@ -305,6 +305,7 @@ SOURCES += \
statistics.cpp \ statistics.cpp \
oximeterimport.cpp \ oximeterimport.cpp \
SleepLib/deviceconnection.cpp \ SleepLib/deviceconnection.cpp \
SleepLib/xmlreplay.cpp \
SleepLib/serialoximeter.cpp \ SleepLib/serialoximeter.cpp \
SleepLib/loader_plugins/md300w1_loader.cpp \ SleepLib/loader_plugins/md300w1_loader.cpp \
Graphs/gSessionTimesChart.cpp \ Graphs/gSessionTimesChart.cpp \
@ -385,6 +386,7 @@ HEADERS += \
statistics.h \ statistics.h \
oximeterimport.h \ oximeterimport.h \
SleepLib/deviceconnection.h \ SleepLib/deviceconnection.h \
SleepLib/xmlreplay.h \
SleepLib/serialoximeter.h \ SleepLib/serialoximeter.h \
SleepLib/loader_plugins/md300w1_loader.h \ SleepLib/loader_plugins/md300w1_loader.h \
Graphs/gSessionTimesChart.h \ Graphs/gSessionTimesChart.h \