初始化仓库

This commit is contained in:
codeboss 2024-03-06 23:09:20 +08:00
commit 532ce2d0ae
17 changed files with 803 additions and 0 deletions

73
.gitignore vendored Normal file
View File

@ -0,0 +1,73 @@
# This file is used to ignore files which are generated
# ----------------------------------------------------------------------------
*~
*.autosave
*.a
*.core
*.moc
*.o
*.obj
*.orig
*.rej
*.so
*.so.*
*_pch.h.cpp
*_resource.rc
*.qm
.#*
*.*#
core
!core/
tags
.DS_Store
.directory
*.debug
Makefile*
*.prl
*.app
moc_*.cpp
ui_*.h
qrc_*.cpp
Thumbs.db
*.res
*.rc
/.qmake.cache
/.qmake.stash
# qtcreator generated files
*.pro.user*
# xemacs temporary files
*.flc
# Vim temporary files
.*.swp
# Visual Studio generated files
*.ib_pdb_index
*.idb
*.ilk
*.pdb
*.sln
*.suo
*.vcproj
*vcproj.*.*.user
*.ncb
*.sdf
*.opensdf
*.vcxproj
*vcxproj.*
# MinGW generated files
*.Debug
*.Release
# Python byte code
*.pyc
# Binaries
# --------
*.dll
*.exe

38
DataStream.pro Normal file
View File

@ -0,0 +1,38 @@
QT += core gui
greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
CONFIG += c++11
# You can make your code fail to compile if it uses deprecated APIs.
# In order to do so, uncomment the following line.
#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000 # disables all the APIs deprecated before Qt 6.0.0
msvc {
QMAKE_CXXFLAGS += /utf-8
QMAKE_CFLAGS += /utf-8
}
SOURCES += \
dataprototype.cpp \
datatypeconfigration.cpp \
main.cpp \
mapcore.cpp \
moduleinterface.cpp \
moduleprototype.cpp \
moduletreeview.cpp \
widget.cpp
HEADERS += \
dataprototype.h \
datatypeconfigration.h \
mapcore.h \
moduleinterface.h \
moduleprototype.h \
moduletreeview.h \
widget.h
# Default rules for deployment.
qnx: target.path = /tmp/$${TARGET}/bin
else: unix:!android: target.path = /opt/$${TARGET}/bin
!isEmpty(target.path): INSTALLS += target

150
dataprototype.cpp Normal file
View File

@ -0,0 +1,150 @@
#include "dataprototype.h"
RuntimeItem::RuntimeItem(AssembleType t) : type_store(t) {}
RuntimeItem::RuntimeItem(const RuntimeItem &other) : RuntimeItem(other.baseType()) {
this->listener_collection.append(other.listener_collection);
}
std::shared_ptr<const RuntimeItem> RuntimeItem::add(std::shared_ptr<ItemListener> inst) const
{
if(this->listener_collection.contains(inst))
return this->shared_from_this();
auto ninst = std::const_pointer_cast<RuntimeItem>(this->clone());
ninst->listener_collection.append(inst);
itemNotify([ninst, this](std::shared_ptr<ItemListener> p) { p->itemHasbeenUpdated(ninst, this->shared_from_this()); });
return ninst;
}
std::shared_ptr<const RuntimeItem> RuntimeItem::del(std::shared_ptr<ItemListener> inst) const
{
if(!this->listener_collection.contains(inst))
return this->shared_from_this();
auto ninst = std::const_pointer_cast<RuntimeItem>(this->clone());
ninst->listener_collection.removeAll(inst);
itemNotify([ninst, this](std::shared_ptr<ItemListener> p) { p->itemHasbeenUpdated(ninst, this->shared_from_this()); });
return ninst;
}
void RuntimeItem::itemNotify(std::function<void (std::shared_ptr<ItemListener>)> proc) const
{
for(auto &lt : listener_collection)
proc(lt);
}
AssembleType RuntimeItem::baseType() const { return type_store; }
qulonglong RuntimeItem::hashCode() const { return (qulonglong)this; }
std::shared_ptr<const RuntimeItem> RuntimeItem::clone() const{
return std::make_shared<RuntimeItem>(*this);
}
TypeTemplate::TypeTemplate() : RuntimeItem(AssembleType::DATAS_ASSEMBLE) {}
TypeTemplate::TypeTemplate(const TypeTemplate &other)
: RuntimeItem(other)
{
this->name_store = other.name_store;
this->type_store = other.type_store;
this->io_type = other.io_type;
this->comps_store = other.comps_store;
}
QString TypeTemplate::name() const { return this->name_store; }
std::shared_ptr<const TypeTemplate> TypeTemplate::setName(const QString &val) const{
auto ninst = std::static_pointer_cast<TypeTemplate>(std::const_pointer_cast<RuntimeItem>(this->clone()));
ninst->name_store = val;
ninst->itemNotify([ninst, this](std::shared_ptr<ItemListener> p) { p->itemHasbeenUpdated(ninst, this->shared_from_this()); });
return ninst;
}
QString TypeTemplate::type() const { return this->type_store; }
std::shared_ptr<const TypeTemplate> TypeTemplate::setType(const QString &val) const
{
auto ninst = std::static_pointer_cast<TypeTemplate>(std::const_pointer_cast<RuntimeItem>(this->clone()));
ninst->name_store = val;
ninst->itemNotify([ninst, this](std::shared_ptr<ItemListener> p) { p->itemHasbeenUpdated(ninst, this->shared_from_this()); });
return ninst;
}
DataOritation TypeTemplate::oritation() const { return io_type; }
std::shared_ptr<const TypeTemplate> TypeTemplate::setOritation(DataOritation t) const
{
auto ninst = std::static_pointer_cast<TypeTemplate>(std::const_pointer_cast<RuntimeItem>(this->clone()));
ninst->io_type = t;
ninst->itemNotify([ninst, this](std::shared_ptr<ItemListener> p) { p->itemHasbeenUpdated(ninst, this->shared_from_this()); });
return ninst;
}
std::shared_ptr<const RuntimeItem> TypeTemplate::clone() const
{
return std::make_shared<TypeTemplate>(*this);
}
DownAccess::DownAccess(std::shared_ptr<const RuntimeItem> peer) : runtime_item(peer) {}
DownAccess::DownAccess(const DownAccess &other)
{
this->runtime_item = other.runtime_item;
this->children_store = other.children_store;
}
std::shared_ptr<const RuntimeItem> DownAccess::itemPeer() const { return this->runtime_item; }
QList<std::shared_ptr<const DownAccess> > DownAccess::members() const { return this->children_store; }
std::shared_ptr<const DownAccess> DownAccess::append(std::shared_ptr<const DownAccess> child_inst) const{
if(this->children_store.contains(child_inst))
return this->shared_from_this();
auto ninst = std::const_pointer_cast<DownAccess>(this->clone());
ninst->children_store.append(child_inst);
itemPeer()->itemNotify(
[this, child_inst](std::shared_ptr<ItemListener> inst) {
inst->memberHasbeenAppended(*this->itemPeer(), child_inst->itemPeer());
});
return ninst;
}
std::shared_ptr<const DownAccess> DownAccess::remove(std::shared_ptr<const DownAccess> child_inst) const {
if(!this->children_store.contains(child_inst))
return this->shared_from_this();
auto ninst = std::const_pointer_cast<DownAccess>(this->clone());
itemPeer()->itemNotify(
[this, child_inst](std::shared_ptr<ItemListener> inst) {
inst->memberAboutToBeRemove(*this->itemPeer(), child_inst->itemPeer());
});
ninst->children_store.removeAll(child_inst);
return ninst;
}
std::shared_ptr<const DownAccess> DownAccess::replace(std::shared_ptr<const DownAccess> current, std::shared_ptr<const DownAccess> previous) const
{
return this->remove(previous)->append(current);
}
std::shared_ptr<const DownAccess> DownAccess::clone() const {
return std::make_shared<DownAccess>(*this);
}
UpAccess::UpAccess(std::shared_ptr<const UpAccess> parent, std::shared_ptr<const DownAccess> down):runtime_downward(down), parent_ptr(parent){}
UpAccess::UpAccess(const UpAccess &other) { runtime_downward = other.runtime_downward; }
std::shared_ptr<const DownAccess> UpAccess::downwardPeers() const
{
return this->runtime_downward;
}
std::shared_ptr<const UpAccess> UpAccess::parent() const { return parent_ptr; }
std::shared_ptr<const UpAccess> UpAccess::clone() const { return std::make_shared<const UpAccess>(*this); }

137
dataprototype.h Normal file
View File

@ -0,0 +1,137 @@
#ifndef DATAPROTOTYPE_H
#define DATAPROTOTYPE_H
#include <QString>
#include <QList>
class RuntimeItem;
/**
* @brief
*/
class ItemListener{
public:
virtual ~ItemListener() = default;
virtual void itemHasbeenUpdated(std::shared_ptr<const RuntimeItem> current, std::shared_ptr<const RuntimeItem> previous) = 0;
virtual void memberHasbeenAppended(const RuntimeItem &parent, std::shared_ptr<const RuntimeItem> inst) = 0;
virtual void memberAboutToBeRemove(const RuntimeItem &parent, std::shared_ptr<const RuntimeItem> inst) = 0;
virtual void memberHasbeenReplaced(const RuntimeItem &parent, std::shared_ptr<const RuntimeItem> current, std::shared_ptr<const RuntimeItem> previous) = 0;
};
/**
* @brief
*/
enum class AssembleType {
DATAS_ASSEMBLE, // 数据聚合体
MODULES_UNIT, // 模块单元
};
/**
* @brief
*/
class RuntimeItem : public std::enable_shared_from_this<RuntimeItem> {
public:
explicit RuntimeItem(AssembleType t);
explicit RuntimeItem(const RuntimeItem & other);
std::shared_ptr<const RuntimeItem> add(std::shared_ptr<ItemListener> inst) const;
std::shared_ptr<const RuntimeItem> del(std::shared_ptr<ItemListener> inst) const;
void itemNotify(std::function<void(std::shared_ptr<ItemListener>)> proc) const;
AssembleType baseType() const;
virtual qulonglong hashCode() const;
virtual std::shared_ptr<const RuntimeItem> clone() const;
private:
AssembleType type_store;
QList<std::shared_ptr<ItemListener>> listener_collection;
};
/**
* @brief 访
*/
class DownAccess : public std::enable_shared_from_this<DownAccess>{
public:
explicit DownAccess(std::shared_ptr<const RuntimeItem> peer);
explicit DownAccess(const DownAccess &other);
template<typename T>
std::shared_ptr<const T> typePeer() const {
return std::dynamic_pointer_cast<const T>(itemPeer());
}
std::shared_ptr<const RuntimeItem> itemPeer() const;
QList<std::shared_ptr<const DownAccess>> members() const;
std::shared_ptr<const DownAccess> append(std::shared_ptr<const DownAccess> child_inst) const;
std::shared_ptr<const DownAccess> remove(std::shared_ptr<const DownAccess> child_inst) const;
std::shared_ptr<const DownAccess> replace(std::shared_ptr<const DownAccess> current, std::shared_ptr<const DownAccess> previous) const;
virtual std::shared_ptr<const DownAccess> clone() const;
private:
std::shared_ptr<const RuntimeItem> runtime_item;
QList<std::shared_ptr<const DownAccess>> children_store;
};
/**
* @brief 访
*/
class UpAccess : public std::enable_shared_from_this<UpAccess> {
public:
explicit UpAccess(std::shared_ptr<const UpAccess> parent, std::shared_ptr<const DownAccess> down);
explicit UpAccess(const UpAccess &other);
template<typename T>
std::shared_ptr<const T> typePeer() const {
return std::dynamic_pointer_cast<const T>(itemPeer());
}
std::shared_ptr<const DownAccess> downwardPeers() const;
std::shared_ptr<const UpAccess> parent() const;
virtual std::shared_ptr<const UpAccess> clone() const;
private:
std::shared_ptr<const DownAccess> runtime_downward;
std::shared_ptr<const UpAccess> parent_ptr;
};
/**
* @brief
*/
enum class DataOritation {
INPUT, // 引入
OUTPUT, // 输出
CONSUME, // 引入消耗
GENERATE, // 引出生成
UNDEFINED, // 未定义
};
/**
* @brief
*/
class TypeTemplate : public RuntimeItem
{
private:
QString name_store = "foo";
QString type_store = "整形";
DataOritation io_type = DataOritation::UNDEFINED;
QHash<qulonglong, std::pair<std::shared_ptr<const TypeTemplate>, QString>> comps_store;
public:
explicit TypeTemplate();
explicit TypeTemplate(const TypeTemplate & other);
QString name() const;
std::shared_ptr<const TypeTemplate> setName(const QString &val) const;
QString type() const;
std::shared_ptr<const TypeTemplate> setType(const QString &val) const;
DataOritation oritation() const;
std::shared_ptr<const TypeTemplate> setOritation(DataOritation t) const;
virtual std::shared_ptr<const RuntimeItem> clone() const;
};
#endif // DATAPROTOTYPE_H

85
datatypeconfigration.cpp Normal file
View File

@ -0,0 +1,85 @@
#include "datatypeconfigration.h"
#include <QSplitter>
#include <QVBoxLayout>
DataConfigration::DataConfigration(MapCore &core, std::shared_ptr<const DownAccess> target, QWidget *parent)
: QWidget(parent),
core_bind(core),
target_bind(target),
member_present(new QTableView(this)),
member_model(new QStandardItemModel(this)),
preview_present(new QTreeView(this)),
preview_model(new QStandardItemModel(this)),
append(new QPushButton("添加", this)),
remove(new QPushButton("删除", this)) {
auto layout = new QVBoxLayout(this);
auto splitter = new QSplitter(this);
layout->addWidget(splitter);
auto widget = new QWidget(this);
splitter->addWidget(widget);
splitter->addWidget(preview_present);
auto xlayout = new QVBoxLayout(widget);
xlayout->addWidget(member_present);
xlayout->addWidget(append);
xlayout->addWidget(remove);
member_present->setModel(member_model);
preview_present->setModel(preview_model);
xlayout->setMargin(2);
layout->setMargin(2);
xlayout->setSpacing(2);
layout->setSpacing(2);
this->member_model->setHorizontalHeaderLabels(QStringList() << "成员名称" << "成员类型");
this->preview_model->setHorizontalHeaderLabels(QStringList() << "成员名称" << "成员类型");
present_member(target);
present_struct(target);
connect(this->append, &QPushButton::clicked, [=](){
auto ninst = std::make_shared<DownAccess>(std::make_shared<TypeTemplate>());
auto target_x = target_bind->append(ninst);
this->core_bind.refreshRoot(target_bind, target_x);
this->target_bind = target_x;
this->member_model->removeRows(0, member_model->rowCount());
this->preview_model->removeRows(0, preview_model->rowCount());
present_member(target_bind);
present_struct(target_bind);
});
}
void DataConfigration::present_member(std::shared_ptr<const DownAccess> base)
{
auto list = base->members();
for(auto &d : list){
QList<QStandardItem*> row;
row << new QStandardItem(d->typePeer<TypeTemplate>()->name());
row << new QStandardItem(d->typePeer<TypeTemplate>()->type());
this->member_model->appendRow(row);
}
}
void DataConfigration::present_struct(std::shared_ptr<const DownAccess> base, QStandardItem *target)
{
auto list = base->members();
for(auto &d : list){
QList<QStandardItem*> row;
row << new QStandardItem(d->typePeer<TypeTemplate>()->name());
row << new QStandardItem(d->typePeer<TypeTemplate>()->type());
if(!target)
this->preview_model->appendRow(row);
else
target->appendRow(row);
row.first()->setEditable(false);
row.last()->setEditable(false);
present_struct(d, row.first());
}
}

32
datatypeconfigration.h Normal file
View File

@ -0,0 +1,32 @@
#ifndef DATATYPECONFIGRATION_H
#define DATATYPECONFIGRATION_H
#include <QPushButton>
#include <QStandardItemModel>
#include <QTableView>
#include <QTreeView>
#include <QWidget>
#include "mapcore.h"
#include "dataprototype.h"
class DataConfigration : public QWidget
{
Q_OBJECT
public:
explicit DataConfigration(MapCore &core, std::shared_ptr<const DownAccess> target, QWidget *parent = nullptr);
private:
MapCore &core_bind;
std::shared_ptr<const DownAccess> target_bind;
QTableView *const member_present;
QStandardItemModel *const member_model;
QTreeView *const preview_present;
QStandardItemModel *const preview_model;
QPushButton *const append, *const remove;
void present_member(std::shared_ptr<const DownAccess> base);
void present_struct(std::shared_ptr<const DownAccess> base, QStandardItem *target = nullptr);
};
#endif // DATATYPECONFIGRATION_H

26
main.cpp Normal file
View File

@ -0,0 +1,26 @@
#include "widget.h"
#include <QApplication>
#include "mapcore.h"
#include "datatypeconfigration.h"
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
// Widget w;
// w.show();
MapCore core;
auto target = std::make_shared<const DownAccess>(std::make_shared<TypeTemplate>());
core.setRoot(target);
auto tnode0 = std::make_shared<const DownAccess>(std::make_shared<TypeTemplate>());
auto tnode1 = std::make_shared<const DownAccess>(std::make_shared<TypeTemplate>());
auto tnode2 = std::make_shared<const DownAccess>(std::make_shared<TypeTemplate>());
tnode0 = tnode0->append(tnode1);
target = target->append(tnode0);
target = target->append(tnode2);
DataConfigration dialog(core, target);
dialog.show();
return a.exec();
}

84
mapcore.cpp Normal file
View File

@ -0,0 +1,84 @@
#include "mapcore.h"
MapCore::MapCore()
{
}
std::shared_ptr<const DownAccess> MapCore::root() const{ return root_bind; }
void MapCore::setRoot(std::shared_ptr<const DownAccess> root) { this->root_bind = root; }
std::shared_ptr<const DownAccess> MapCore::refreshRoot(std::shared_ptr<const DownAccess> old, std::shared_ptr<const DownAccess> _new){
MapVisitor visitor(*this);
auto links = visitor.findLink(old->itemPeer());
std::function<std::shared_ptr<const DownAccess>(std::shared_ptr<const UpAccess>, std::shared_ptr<const DownAccess>)> replace_cascade =
[&replace_cascade, this](std::shared_ptr<const UpAccess> current_up, std::shared_ptr<const DownAccess> current_new) -> std::shared_ptr<const DownAccess> {
auto pinst_up = current_up->parent();
if(!pinst_up)
return current_new;
auto pinst = pinst_up->downwardPeers();
auto new_pinst = pinst->replace(current_up->downwardPeers(), current_new);
return replace_cascade(pinst_up, new_pinst);
};
this->root_bind = replace_cascade(links, _new);
return this->root_bind;
}
MapVisitor::MapVisitor(MapCore &base) : core_bind(base) {}
std::shared_ptr<const DownAccess> MapVisitor::findTarget(std::shared_ptr<const RuntimeItem> node) const{
return find_target(core_bind.root(), node);
}
std::shared_ptr<const UpAccess> MapVisitor::findLink(std::shared_ptr<const RuntimeItem> node) const
{
return this->find_link(nullptr, core_bind.root(), node);
}
QList<std::shared_ptr<const DownAccess> > MapVisitor::collect(std::function<bool (std::shared_ptr<const DownAccess>)> proc) const{
return collect(core_bind.root(), proc);
}
std::shared_ptr<const UpAccess> MapVisitor::find_link(std::shared_ptr<const UpAccess> pinst, std::shared_ptr<const DownAccess> handle, std::shared_ptr<const RuntimeItem> node) const
{
if(handle->itemPeer() == node)
return std::make_shared<UpAccess>(pinst, handle);
auto target_ptr = std::make_shared<UpAccess>(pinst, handle);
for(auto &hc : handle->members()){
auto result = find_link(target_ptr, hc, node);
if(result)
return result;
}
return nullptr;
}
std::shared_ptr<const DownAccess> MapVisitor::find_target(std::shared_ptr<const DownAccess> handle, std::shared_ptr<const RuntimeItem> node) const {
if (handle->itemPeer() == node) {
return handle;
}
for (auto &it : handle->members()) {
auto result = find_target(it, node);
if (result)
return result;
}
return nullptr;
}
QList<std::shared_ptr<const DownAccess> > MapVisitor::collect(std::shared_ptr<const DownAccess> handle, std::function<bool (std::shared_ptr<const DownAccess>)> proc) const {
QList<std::shared_ptr<const DownAccess>> retlist;
if(proc(handle))
retlist.append(handle);
for(auto &c : handle->members())
retlist.append(collect(c, proc));
return retlist;
}

53
mapcore.h Normal file
View File

@ -0,0 +1,53 @@
#ifndef MAPCORE_H
#define MAPCORE_H
#include <QStandardItemModel>
#include "moduleprototype.h"
class MapCore
{
public:
MapCore();
std::shared_ptr<const DownAccess> root() const;
void setRoot(std::shared_ptr<const DownAccess> root);
std::shared_ptr<const DownAccess> refreshRoot(std::shared_ptr<const DownAccess> old, std::shared_ptr<const DownAccess> _new);
QList<std::shared_ptr<const TypeTemplate>> dataTypes() const;
void typeAppend(std::shared_ptr<const TypeTemplate> type);
void typeRemove(std::shared_ptr<const TypeTemplate> type);
void typeUpdate(std::shared_ptr<const TypeTemplate> type);
private:
std::shared_ptr<const DownAccess> root_bind = nullptr;
};
class MapVisitor{
public:
explicit MapVisitor(MapCore &base);
/**
* @brief 访
* @param node
* @return
*/
std::shared_ptr<const DownAccess> findTarget(std::shared_ptr<const RuntimeItem> node) const;
std::shared_ptr<const UpAccess> findLink(std::shared_ptr<const RuntimeItem> node) const;
/**
* @brief
* @param proc
* @return
*/
QList<std::shared_ptr<const DownAccess>> collect(std::function<bool(std::shared_ptr<const DownAccess>)> proc) const;
private:
MapCore &core_bind;
std::shared_ptr<const UpAccess> find_link(std::shared_ptr<const UpAccess> pinst, std::shared_ptr<const DownAccess> handle, std::shared_ptr<const RuntimeItem> node) const;
std::shared_ptr<const DownAccess> find_target(std::shared_ptr<const DownAccess> handle, std::shared_ptr<const RuntimeItem> node) const;
QList<std::shared_ptr<const DownAccess>> collect(std::shared_ptr<const DownAccess> handle, std::function<bool(std::shared_ptr<const DownAccess>)> proc) const;
};
#endif // MAPCORE_H

7
moduleinterface.cpp Normal file
View File

@ -0,0 +1,7 @@
#include "moduleinterface.h"
ModuleInterface::ModuleInterface(MapCore &core, std::shared_ptr<const ModulePrototype> target, QWidget *parent)
: QWidget(parent), core_bind(core), target_bind(target)
{
}

21
moduleinterface.h Normal file
View File

@ -0,0 +1,21 @@
#ifndef MODULEINTERFACE_H
#define MODULEINTERFACE_H
#include <QWidget>
#include "moduleprototype.h"
#include "mapcore.h"
class ModuleInterface : public QWidget
{
Q_OBJECT
public:
explicit ModuleInterface(MapCore &core, std::shared_ptr<const ModulePrototype> target, QWidget *parent = nullptr);
signals:
private:
MapCore &core_bind;
std::shared_ptr<const ModulePrototype> target_bind;
};
#endif // MODULEINTERFACE_H

27
moduleprototype.cpp Normal file
View File

@ -0,0 +1,27 @@
#include "moduleprototype.h"
ModulePrototype::ModulePrototype()
: RuntimeItem(AssembleType::MODULES_UNIT)
{
}
ModulePrototype::ModulePrototype(const ModulePrototype &other)
: RuntimeItem(other.baseType())
{
this->module_name = other.module_name;
}
QString ModulePrototype::name() const { return this->module_name; }
std::shared_ptr<const ModulePrototype> ModulePrototype::setName(const QString &val) const{
auto ninst = std::static_pointer_cast<ModulePrototype>(std::const_pointer_cast<RuntimeItem>(this->clone()));
ninst->module_name = val;
ninst->itemNotify([ninst, this](std::shared_ptr<ItemListener> p) { p->itemHasbeenUpdated(ninst, this->shared_from_this()); });
return ninst;
}
std::shared_ptr<const RuntimeItem> ModulePrototype::clone() const
{
return std::make_shared<ModulePrototype>(*this);
}

28
moduleprototype.h Normal file
View File

@ -0,0 +1,28 @@
#ifndef MODULEPROTOTYPE_H
#define MODULEPROTOTYPE_H
#include <QList>
#include <QHash>
#include <memory>
#include "dataprototype.h"
/**
* @brief
*/
class ModulePrototype : public RuntimeItem
{
private:
QString module_name;
public:
explicit ModulePrototype();
explicit ModulePrototype(const ModulePrototype &other);
QString name() const;
std::shared_ptr<const ModulePrototype> setName(const QString &val) const;
virtual std::shared_ptr<const RuntimeItem> clone() const override;
};
#endif // MODULEPROTOTYPE_H

6
moduletreeview.cpp Normal file
View File

@ -0,0 +1,6 @@
#include "moduletreeview.h"
ModuleTreeView::ModuleTreeView()
{
}

11
moduletreeview.h Normal file
View File

@ -0,0 +1,11 @@
#ifndef MODULETREEVIEW_H
#define MODULETREEVIEW_H
class ModuleTreeView
{
public:
ModuleTreeView();
};
#endif // MODULETREEVIEW_H

11
widget.cpp Normal file
View File

@ -0,0 +1,11 @@
#include "widget.h"
Widget::Widget(QWidget *parent)
: QWidget(parent)
{
}
Widget::~Widget()
{
}

14
widget.h Normal file
View File

@ -0,0 +1,14 @@
#ifndef WIDGET_H
#define WIDGET_H
#include <QWidget>
class Widget : public QWidget
{
Q_OBJECT
public:
Widget(QWidget *parent = nullptr);
~Widget();
};
#endif // WIDGET_H