初始化仓库

.gitignore

@@ -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
+

DataStream.pro

@@ -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

dataprototype.cpp

@@ -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); }

dataprototype.h

@@ -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

datatypeconfigration.cpp

@@ -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());
+    }
+}

datatypeconfigration.h

@@ -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

main.cpp

@@ -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();
+}

mapcore.cpp

@@ -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;
+}

mapcore.h

@@ -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

moduleinterface.cpp

@@ -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)
+{
+    
+}

moduleinterface.h

@@ -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

moduleprototype.cpp

@@ -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);
+}

moduleprototype.h

@@ -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

moduletreeview.cpp

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

moduletreeview.h

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

widget.cpp

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

widget.h

@@ -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