[ci skip] commiting current changes

Huge changes in the model and protocol loading part. Trying to keep Qt
out of these lowlevel parts, so trying to achieve everything with boost
or std.
This commit is contained in:
Marcel M. Otte 2016-11-25 22:43:36 +01:00
parent 160501b7ca
commit b33c0504f6
22 changed files with 340 additions and 305 deletions

1
.gitignore vendored
View File

@ -2,3 +2,4 @@
*.pro.user
build
*.user*
doc

View File

@ -6,7 +6,7 @@ set(SOURCES mainwindow.cpp
add_subdirectory(model)
add_subdirectory(editor)
add_subdirectory(protocol)
add_subdirectory(parser)
add_library(src ${HEADERS} ${SOURCES})
target_link_libraries(src model editor protocol)

View File

@ -2,8 +2,6 @@
set(HEADERS editorelementdata.h
guidededitorelementview.h
flowlayout.h
EditorNode.h
EditorTree.h
EditorElementValue.h
)
@ -11,8 +9,6 @@ set(SOURCES guidededitorelementview.cpp
editorelementdata.cpp
guidededitorview.cpp
flowlayout.cpp
EditorNode.cpp
EditorTree.cpp
EditorElementValue.cpp
)

View File

@ -1,74 +0,0 @@
#ifndef EDITORNODE_H
#define EDITORNODE_H
#include <memory>
#include <functional>
#include <list>
#include "editorelementdata.h"
#include "EditorElementValue.h"
class EditorNode;
enum class TreeWalkStrategy {
depthFirst,
breadthFirst,
mixture
};
class EditorNode
{
public:
explicit EditorNode();
explicit EditorNode(std::shared_ptr<EditorElementData> data);
virtual ~EditorNode();
const std::shared_ptr<EditorNode> nextSibling();
const std::shared_ptr<EditorNode> next(TreeWalkStrategy walkStrategy = TreeWalkStrategy::depthFirst);
const std::shared_ptr<EditorNode> getRoot();
void move(std::shared_ptr<EditorNode> to); //as child
void moveChildren(std::shared_ptr<EditorNode> to); //all
void addChild(std::shared_ptr<EditorNode> child);
bool removeChild(std::shared_ptr<EditorNode> child);
bool remove();
std::shared_ptr<EditorNode> getParent() const;
void setParent(const std::shared_ptr<EditorNode> &value);
std::shared_ptr<EditorElementData> getData() const;
void setData(const std::shared_ptr<EditorElementData> &value);
std::shared_ptr<EditorElementValue> getValue() const;
void setValue(const std::shared_ptr<EditorElementValue> &value);
std::list<std::shared_ptr<EditorNode> > getChildren() const;
void setDataChangedSignal(std::function<void(std::shared_ptr<EditorNode>)> f)
{
nodeDataChanged = f;
}
void setTreeChangedSignal(std::function<void(std::shared_ptr<EditorNode>)> f)
{
treeChanged = f;
}
std::function<void(std::shared_ptr<EditorNode>)> getTreeChangedSignal(){ return treeChanged; }
std::function<void(std::shared_ptr<EditorNode>)> getDataChangedSignal(){ return nodeDataChanged; }
private:
void fireNodeDataChanged();
void fireTreeChanged();
//signal callbacks only set in the root node
std::function<void(std::shared_ptr<EditorNode>)> nodeDataChanged;
std::function<void(std::shared_ptr<EditorNode>)> treeChanged;
std::shared_ptr<EditorNode> nextOnSameLevel();
std::shared_ptr<EditorNode> parent;
std::shared_ptr<EditorElementData> data;
std::shared_ptr<EditorElementValue> value;
std::list<std::shared_ptr<EditorNode>> children;
};
#endif // EDITORNODE_H

View File

@ -1,15 +0,0 @@
#include "EditorTree.h"
#include <memory>
EditorTree::EditorTree(QObject *parent) : QObject(parent)
{
root = std::make_shared<EditorNode>(nullptr);
root->setDataChangedSignal([this](std::shared_ptr<EditorNode> node){ emit this->nodeDataChanged(node);});
root->setTreeChangedSignal([this](std::shared_ptr<EditorNode> node){ emit this->treeChanged(node);});
}
EditorTree::~EditorTree()
{
}

View File

@ -1,25 +0,0 @@
#ifndef EDITORTREE_H
#define EDITORTREE_H
#include <memory>
#include <QObject>
#include "EditorNode.h"
class EditorTree : public QObject
{
Q_OBJECT
public:
explicit EditorTree(QObject *parent = 0);
virtual ~EditorTree();
const std::shared_ptr<EditorNode> getRoot() { return root; }
signals:
void nodeDataChanged(std::shared_ptr<EditorNode> node);
void treeChanged(std::shared_ptr<EditorNode> node);
public slots:
private:
std::shared_ptr<EditorNode> root;
};
#endif // EDITORTREE_H

View File

@ -9,7 +9,7 @@
#include <iostream>
GuidedEditorElementView::GuidedEditorElementView(const std::shared_ptr<EditorNode> &ref, QWidget* parent)
GuidedEditorElementView::GuidedEditorElementView(const std::shared_ptr<TreeNode> &ref, QWidget* parent)
: GuidedEditorElementView(parent)
{
this->setReference(ref);
@ -51,7 +51,7 @@ void GuidedEditorElementView::render()
subContainer = new QWidget(this);
FlowLayout* flayout = new FlowLayout(subContainer);
//create and render subelementviews! this is DEPTH_FIRST!!! TODO: make this breadth first!
for (std::shared_ptr<EditorNode> node : reference->getChildren()) {
for (std::shared_ptr<TreeNode> node : reference->getChildren()) {
GuidedEditorElementView* view = new GuidedEditorElementView(subContainer);
view->setReference(node);
flayout->addWidget(view);
@ -104,12 +104,12 @@ void GuidedEditorElementView::nodeChanged()
this->render();
}
std::shared_ptr<EditorNode> GuidedEditorElementView::getReference() const
std::shared_ptr<TreeNode> GuidedEditorElementView::getReference() const
{
return reference;
}
void GuidedEditorElementView::setReference(const std::shared_ptr<EditorNode>& value)
void GuidedEditorElementView::setReference(const std::shared_ptr<TreeNode>& value)
{
reference = value;
QRegExp r(reference->getData()->getRegex());

View File

@ -16,12 +16,12 @@
class GuidedEditorElementView : public QWidget {
Q_OBJECT
public:
explicit GuidedEditorElementView(const std::shared_ptr<EditorNode> &ref,QWidget* parent = 0);
explicit GuidedEditorElementView(const std::shared_ptr<TreeNode> &ref,QWidget* parent = 0);
explicit GuidedEditorElementView(QWidget* parent = 0);
std::shared_ptr<EditorNode> getReference() const;
void setReference(const std::shared_ptr<EditorNode> &value);
std::shared_ptr<TreeNode> getReference() const;
void setReference(const std::shared_ptr<TreeNode> &value);
signals:
@ -40,7 +40,7 @@ private:
QMap<QString, QWidget*> otherWidgets;
QRegExpValidator* validator;
QWidget* subContainer;
std::shared_ptr<EditorNode> reference;
std::shared_ptr<TreeNode> reference;
};
#endif // GUIDEDEDITORELEMENTVIEW_H

View File

@ -47,7 +47,7 @@ void GuidedEditorView::setTree(EditorTree* tree)
}
void GuidedEditorView::treeDataChangedSlot(std::shared_ptr<EditorNode> node)
void GuidedEditorView::treeDataChangedSlot(std::shared_ptr<TreeNode> node)
{
// get node view
auto view = nodeToViewMap[node];
@ -55,7 +55,7 @@ void GuidedEditorView::treeDataChangedSlot(std::shared_ptr<EditorNode> node)
view->dataChanged();
}
void GuidedEditorView::treeChangedSlot(std::shared_ptr<EditorNode> node)
void GuidedEditorView::treeChangedSlot(std::shared_ptr<TreeNode> node)
{
// get node view
auto view = nodeToViewMap[node];
@ -67,7 +67,7 @@ void GuidedEditorView::render()
{
if(tree != nullptr) {
// root node is invisible!
for(std::shared_ptr<EditorNode> node : tree->getRoot()->getChildren()){
for(std::shared_ptr<TreeNode> node : tree->getRoot()->getChildren()){
auto view = new GuidedEditorElementView(node, this);
this->editorLayout->addWidget(view);
this->nodeToViewMap.insert(node, view);

View File

@ -20,15 +20,15 @@ public slots:
void addElement(EditorElementData* element);
void setTree(EditorTree* tree);
void treeDataChangedSlot(std::shared_ptr<EditorNode> node);
void treeChangedSlot(std::shared_ptr<EditorNode> node);
void treeDataChangedSlot(std::shared_ptr<TreeNode> node);
void treeChangedSlot(std::shared_ptr<TreeNode> node);
void render();
private:
FlowLayout* editorLayout;
EditorTree* tree;
QMap<std::shared_ptr<EditorNode>, GuidedEditorElementView*> nodeToViewMap;
QMap<std::shared_ptr<TreeNode>, GuidedEditorElementView*> nodeToViewMap;
};

View File

@ -1,10 +1,12 @@
set(HEADERS packetmodel.h
packetelement.h
set(HEADERS Protocol.h
Field.h
Tree.h
TreeNode.h
)
set(SOURCES packetmodel.cpp
packetelement.cpp
set(SOURCES Protocol.cpp
Field.cpp
)
add_library(model ${HEADERS} ${SOURCES})

View File

@ -1,17 +1,17 @@
#include "packetelement.h"
#include "field.h"
#include <memory>
PacketElement::PacketElement(std::string name, uint32_t sizeInBit, uint16_t layer): name(name), sizeInBit(sizeInBit), layer(layer)
Field::Field(std::string name, uint32_t sizeInBit, uint16_t layer): name(name), sizeInBit(sizeInBit), layer(layer)
{
}
void PacketElement::setValue(std::string &value, ValueType type)
void Field::setValue(std::string &value, ValueType type)
{
this->value = std::string(value);
this->valueType = type;
}
std::list<uint8_t> PacketElement::getBytes()
std::list<uint8_t> Field::getBytes()
{
std::list<uint8_t> result;
switch(this->valueType) {

121
src/model/Field.h Normal file
View File

@ -0,0 +1,121 @@
#ifndef PACKETELEMENT_H
#define PACKETELEMENT_H
#include <cstdint>
#include <string>
#include <list>
#include <memory>
class Field;
typedef
std::list<std::shared_ptr<Field>>
FieldList_t;
/**
@brief The ValueType enum
*/
enum class ValueType { hexBinary, integer, text };
class FieldSyntax
{
public:
std::string triggerRegex;
std::string completeRegex;
std::string example;
};
class FieldProperties
{
/*
length:
type: integer
reflength:
type: string
data:
type: boolean
field: == name
type: string
desc:
type: string
bitfield:
type: boolean
optional:
type: boolean
repeatable:
type: boolean
nextlayer:
type: boolean
reference:
type: string
subfields:
type: array
*/
public:
std::string protocol;
std::string name;
std::string description;
std::string sizeReferenceField;
std::string protocolReference;
bool data, optional, repeatable, nextLayer;
uint32_t size;
std::list<std::shared_ptr<FieldSyntax>> syntaxes;
};
class FieldData
{
public:
std::string data;
ValueType type;
};
/**
@brief The Field class
*/
class Field
{
public:
Field(std::string name, uint32_t sizeInBit, uint16_t layer);
void setValue(std::string& value) {this->value = value; this->valueType = ValueType::text; }
void setValue(std::string& value, ValueType type);
const std::string getValue() { return value; }
uint32_t getSizeInBit() { return sizeInBit; }
uint16_t getLayer() { return layer; }
const std::string getName() { return name; }
const std::string getDescription() { return description; }
const std::shared_ptr<FieldList_t> getNextLayer() { return nextLayer; }
bool hasNextLayer() { return nextLayer != nullptr && sizeInBit == 0; }
void setNextLayer(std::shared_ptr<FieldList_t>& layerElements) { nextLayer = layerElements; }
void addSyntax(std::string minimalRegex, std::string completeRegex, std::string example)
{
std::shared_ptr<FieldSyntax> syntax = std::make_shared<FieldSyntax>();
syntax->triggerRegex = minimalRegex;
syntax->completeRegex = completeRegex;
syntax->example = example;
syntaxes.push_back(syntax);
}
std::list<uint8_t> getBytes();
private:
std::string name;
uint32_t sizeInBit;
uint16_t layer;
std::string value;
ValueType valueType;
std::shared_ptr<FieldList_t> nextLayer;
//additional data
std::string description;
std::list<std::shared_ptr<FieldSyntax>> syntaxes;
};
#endif // PACKETELEMENT_H

13
src/model/Protocol.cpp Normal file
View File

@ -0,0 +1,13 @@
#include "Protocol.h"
#include "Field.h"
Protocol::Protocol()
{
this->elementList = std::make_shared<FieldList_t>();
}
const std::shared_ptr<FieldList_t> Protocol::getList()
{
return this->elementList;
}

View File

@ -5,18 +5,18 @@
#include <list>
#include <string>
#include "packetelement.h"
#include "Field.h"
class PacketModel
class Protocol
{
public:
PacketModel();
const std::shared_ptr<PacketElementList_t> getList();
Protocol();
const std::shared_ptr<FieldList_t> getList();
bool validate();
private:
std::shared_ptr<PacketElementList_t> elementList;
std::shared_ptr<FieldList_t> elementList;
};
#endif // PACKETMODEL_H

40
src/model/Tree.h Normal file
View File

@ -0,0 +1,40 @@
#ifndef EDITORTREE_H
#define EDITORTREE_H
#include <memory>
#include "TreeNode.h"
template <class T>
class Tree
{
public:
explicit Tree();
virtual ~Tree();
const std::shared_ptr<TreeNode<T>> getRoot() { return root; }
void nodeDataChanged(std::shared_ptr<TreeNode<T>> node);
void treeChanged(std::shared_ptr<TreeNode<T>> node);
private:
std::shared_ptr<TreeNode<T>> root;
};
template <class T>
Tree<T>::Tree()
{
root = std::make_shared<TreeNode<T>>(nullptr);
root->setDataChangedSignal([this](std::shared_ptr<TreeNode<T>> node){ this->nodeDataChanged(node);});
root->setTreeChangedSignal([this](std::shared_ptr<TreeNode<T>> node){ this->treeChanged(node);});
}
template <class T>
Tree<T>::~Tree()
{
}
#endif // EDITORTREE_H

View File

@ -1,27 +1,97 @@
#include "EditorNode.h"
#ifndef EDITORNODE_H
#define EDITORNODE_H
#include <QList>
#include <memory>
#include <functional>
#include <list>
#include <algorithm>
EditorNode::EditorNode()
template <class T>
class TreeNode;
enum class TreeWalkStrategy {
depthFirst,
breadthFirst,
mixture
};
template <class T>
class TreeNode
{
public:
explicit TreeNode();
explicit TreeNode(std::shared_ptr<T> data);
virtual ~TreeNode();
const std::shared_ptr<TreeNode<T>> nextSibling();
const std::shared_ptr<TreeNode<T>> next(TreeWalkStrategy walkStrategy = TreeWalkStrategy::depthFirst);
const std::shared_ptr<TreeNode<T>> getRoot();
void move(std::shared_ptr<TreeNode<T>> to); //as child
void moveChildren(std::shared_ptr<TreeNode<T>> to); //all
void addChild(std::shared_ptr<TreeNode<T>> child);
bool removeChild(std::shared_ptr<TreeNode<T>> child);
bool remove();
uint getDistanceFromRoot();
std::shared_ptr<TreeNode<T>> getParent() const;
void setParent(const std::shared_ptr<TreeNode<T>> &value);
std::shared_ptr<T> getData() const;
void setData(const std::shared_ptr<T> &value);
std::list<std::shared_ptr<TreeNode<T>> > getChildren() const;
void setDataChangedSignal(std::function<void(std::shared_ptr<TreeNode<T>>)> f)
{
nodeDataChanged = f;
}
void setTreeChangedSignal(std::function<void(std::shared_ptr<TreeNode<T>>)> f)
{
treeChanged = f;
}
std::function<void(std::shared_ptr<TreeNode<T>>)> getTreeChangedSignal(){ return treeChanged; }
std::function<void(std::shared_ptr<TreeNode<T>>)> getDataChangedSignal(){ return nodeDataChanged; }
private:
void fireNodeDataChanged();
void fireTreeChanged();
//signal callbacks only set in the root node
std::function<void(std::shared_ptr<TreeNode<T>>)> nodeDataChanged;
std::function<void(std::shared_ptr<TreeNode<T>>)> treeChanged;
std::shared_ptr<TreeNode<T>> nextOnSameLevel();
std::shared_ptr<TreeNode<T>> parent;
std::shared_ptr<T> data;
std::list<std::shared_ptr<TreeNode<T>>> children;
};
template <class T>
TreeNode<T>::TreeNode()
{
}
EditorNode::EditorNode(std::shared_ptr<EditorElementData> data)
template <class T>
TreeNode<T>::TreeNode(std::shared_ptr<T> data)
{
this->data = data;
}
EditorNode::~EditorNode()
template <class T>
TreeNode<T>::~TreeNode()
{
}
const std::shared_ptr<EditorNode> EditorNode::nextSibling()
template <class T>
const std::shared_ptr<TreeNode<T>> TreeNode<T>::nextSibling()
{
if (parent != nullptr) {
auto l = parent->getChildren();
auto it = std::find(l.begin(), l.end(), std::shared_ptr<EditorNode>(this));
auto it = std::find(l.begin(), l.end(), std::shared_ptr<TreeNode<T>>(this));
if (it != l.end() && ++it != l.end())
return *(++it); //next sibling...
else
@ -31,7 +101,8 @@ const std::shared_ptr<EditorNode> EditorNode::nextSibling()
}
const std::shared_ptr<EditorNode> EditorNode::next(TreeWalkStrategy walkStrategy)
template <class T>
const std::shared_ptr<TreeNode<T>> TreeNode<T>::next(TreeWalkStrategy walkStrategy)
{
if (walkStrategy == TreeWalkStrategy::mixture)
// choose node, work through all siblings, choose next node, but don't change branches more than one parent away, except branch is at an end.
@ -69,7 +140,7 @@ const std::shared_ptr<EditorNode> EditorNode::next(TreeWalkStrategy walkStrategy
return getChildren().front();
//return getChildren().first();
else {
auto node = std::shared_ptr<EditorNode>(this);
auto node = std::shared_ptr<TreeNode<T>>(this);
while (node->nextSibling() == nullptr && node->getParent() != nullptr)
node = node->getParent();
return node->nextSibling();
@ -88,39 +159,44 @@ const std::shared_ptr<EditorNode> EditorNode::next(TreeWalkStrategy walkStrategy
return nullptr;
}
const std::shared_ptr<EditorNode> EditorNode::getRoot()
template <class T>
const std::shared_ptr<TreeNode<T>> TreeNode<T>::getRoot()
{
auto node = std::shared_ptr<EditorNode>(this);
auto node = std::shared_ptr<TreeNode<T>>(this);
while (node->getParent() != nullptr)
node = node->getParent();
return node;
}
void EditorNode::move(std::shared_ptr<EditorNode> to)
template <class T>
void TreeNode<T>::move(std::shared_ptr<TreeNode<T>> to)
{
this->getParent()->getChildren().remove(std::shared_ptr<EditorNode>(this));
this->getParent()->getChildren().remove(std::shared_ptr<TreeNode<T>>(this));
//this->getParent()->getChildren().removeOne(std::shared_ptr<EditorNode>(this));
to->getChildren().push_back(std::shared_ptr<EditorNode>(this));
to->getChildren().push_back(std::shared_ptr<TreeNode<T>>(this));
//to->getChildren().append(std::shared_ptr<EditorNode>(this));
fireTreeChanged();
}
void EditorNode::moveChildren(std::shared_ptr<EditorNode> to)
template <class T>
void TreeNode<T>::moveChildren(std::shared_ptr<TreeNode<T>> to)
{
for (auto child : getChildren())
child->move(to);
fireTreeChanged();
}
void EditorNode::addChild(std::shared_ptr<EditorNode> child)
template <class T>
void TreeNode<T>::addChild(std::shared_ptr<TreeNode<T>> child)
{
this->getChildren().push_back(child);
//this->getChildren().append(child);
child->setParent(std::shared_ptr<EditorNode>(this));
child->setParent(std::shared_ptr<TreeNode<T>>(this));
fireTreeChanged();
}
bool EditorNode::removeChild(std::shared_ptr<EditorNode> child)
template <class T>
bool TreeNode<T>::removeChild(std::shared_ptr<TreeNode<T>> child)
{
this->getChildren().remove(child);
bool ret = true; //this->getChildren().removeOne(child);
@ -128,7 +204,8 @@ bool EditorNode::removeChild(std::shared_ptr<EditorNode> child)
return ret;
}
bool EditorNode::remove()
template <class T>
bool TreeNode<T>::remove()
{
bool worked = true;
if (children.size() > 0) {
@ -137,69 +214,66 @@ bool EditorNode::remove()
}
}
if (worked && parent != nullptr) {
parent->getChildren().remove(std::shared_ptr<EditorNode>(this));
parent->getChildren().remove(std::shared_ptr<TreeNode<T>>(this));
//worked &= parent->getChildren().removeOne(std::shared_ptr<EditorNode>(this));
}
if (worked) fireTreeChanged();
return worked;
}
std::shared_ptr<EditorNode> EditorNode::getParent() const
template <class T>
std::shared_ptr<TreeNode<T>> TreeNode<T>::getParent() const
{
return parent;
}
void EditorNode::setParent(const std::shared_ptr<EditorNode> &value)
template <class T>
void TreeNode<T>::setParent(const std::shared_ptr<TreeNode<T>> &value)
{
parent = value;
}
std::shared_ptr<EditorElementData> EditorNode::getData() const
template <class T>
std::shared_ptr<T> TreeNode<T>::getData() const
{
return data;
}
void EditorNode::setData(const std::shared_ptr<EditorElementData> &value)
template <class T>
void TreeNode<T>::setData(const std::shared_ptr<T> &value)
{
fireNodeDataChanged();
data = value;
}
std::shared_ptr<EditorElementValue> EditorNode::getValue() const
{
return value;
}
void EditorNode::setValue(const std::shared_ptr<EditorElementValue> &value)
{
fireNodeDataChanged();
this->value = value;
}
std::list<std::shared_ptr<EditorNode> > EditorNode::getChildren() const
template <class T>
std::list<std::shared_ptr<TreeNode<T>>> TreeNode<T>::getChildren() const
{
return children;
}
void EditorNode::fireNodeDataChanged()
template <class T>
void TreeNode<T>::fireNodeDataChanged()
{
if(this->getRoot()->getDataChangedSignal() != nullptr)
this->getRoot()->getDataChangedSignal()(std::shared_ptr<EditorNode>(this));
this->getRoot()->getDataChangedSignal()(std::shared_ptr<TreeNode<T>>(this));
}
void EditorNode::fireTreeChanged()
template <class T>
void TreeNode<T>::fireTreeChanged()
{
if(this->getRoot()->getTreeChangedSignal() != nullptr)
this->getRoot()->getTreeChangedSignal()(std::shared_ptr<EditorNode>(this));
this->getRoot()->getTreeChangedSignal()(std::shared_ptr<TreeNode<T>>(this));
}
std::shared_ptr<EditorNode> EditorNode::nextOnSameLevel()
template <class T>
std::shared_ptr<TreeNode<T>> TreeNode<T>::nextOnSameLevel()
{
if (nextSibling() != nullptr)
return nextSibling();
uint lvl = 1;
auto node = this->getParent();
auto pnode = std::shared_ptr<EditorNode>(this);
auto pnode = std::shared_ptr<TreeNode<T>>(this);
while (lvl > 0 && node != nullptr) {
if (node != pnode->getParent() && node->getChildren().size() > 0) {
node = node->getChildren().front();
@ -219,3 +293,19 @@ std::shared_ptr<EditorNode> EditorNode::nextOnSameLevel()
}
return node;
}
template <class T>
uint TreeNode<T>::getDistanceFromRoot()
{
std::shared_ptr<TreeNode<T>> node = std::make_shared<TreeNode<T>>(this);
uint lvl = 0;
while(node->getParent() != nullptr)
{
++lvl;
node = node->getParent();
}
return lvl;
}
#endif // EDITORNODE_H

View File

@ -1,101 +0,0 @@
#ifndef PACKETELEMENT_H
#define PACKETELEMENT_H
#include <cstdint>
#include <string>
#include <list>
#include <memory>
class PacketElement;
typedef
std::list<std::shared_ptr<PacketElement>>
PacketElementList_t;
/**
@brief The ValueType enum
*/
enum class ValueType { hexBinary, integer, text };
class ElementSyntax
{
public:
std::string triggerRegex;
std::string completeRegex;
std::string example;
};
/**
@brief The PacketElement class
*/
class PacketElement
{
public:
/**
@brief PacketElement
@param name
@param sizeInBit
@param layer
*/
PacketElement(std::string name, uint32_t sizeInBit, uint16_t layer);
/**
@brief setValue
@param value
*/
void setValue(std::string& value) {this->value = value; this->valueType = ValueType::text; }
/**
@brief setValue
@param value
@param type
*/
void setValue(std::string& value, ValueType type);
const std::string getValue() { return value; }
uint32_t getSizeInBit() { return sizeInBit; }
uint16_t getLayer() { return layer; }
const std::string getName() { return name; }
const std::string getDescription() { return description; }
const std::shared_ptr<PacketElementList_t> getNextLayer() { return nextLayer; }
/**
@brief hasNextLayer
@return
*/
bool hasNextLayer() { return nextLayer != nullptr && sizeInBit == 0; }
/**
@brief setNextLayer
@param layerElements
*/
void setNextLayer(std::shared_ptr<PacketElementList_t>& layerElements) { nextLayer = layerElements; }
void addSyntax(std::string minimalRegex, std::string completeRegex, std::string example)
{
std::shared_ptr<ElementSyntax> syntax = std::make_shared<ElementSyntax>();
syntax->triggerRegex = minimalRegex;
syntax->completeRegex = completeRegex;
syntax->example = example;
syntaxes.push_back(syntax);
}
std::list<uint8_t> getBytes();
private:
std::string name;
uint32_t sizeInBit;
uint16_t layer;
std::string value;
ValueType valueType;
std::shared_ptr<PacketElementList_t> nextLayer;
//additional data
std::string description;
std::list<std::shared_ptr<ElementSyntax>> syntaxes;
};
#endif // PACKETELEMENT_H

View File

@ -1,13 +0,0 @@
#include "packetmodel.h"
#include "packetelement.h"
PacketModel::PacketModel()
{
this->elementList = std::make_shared<PacketElementList_t>();
}
const std::shared_ptr<PacketElementList_t> PacketModel::getList()
{
return this->elementList;
}

View File

@ -6,7 +6,7 @@
#include <string>
#include <list>
#include "../editor/EditorNode.h"
#include "../model/TreeNode.h"
class DataLoader {
@ -18,13 +18,13 @@ public:
void loadSingleProtocol(std::string filename);
std::shared_ptr<EditorNode> generateTree(YAML::Node &node);
std::shared_ptr<TreeNode<T>> generateTree(YAML::Node &node);
bool getProtocolByName(std::string name, YAML::Node &node);
std::list<std::string> getProtocolNames();
private:
std::shared_ptr<EditorNode> genNode(YAML::Node& n, std::shared_ptr<EditorNode> parent = nullptr);
std::shared_ptr<TreeNode<T>> genNode(YAML::Node& n, std::shared_ptr<TreeNode<T>> parent = nullptr);
std::string directory;
std::list<YAML::Node> protocolList;
};