module_model.h

Go to the documentation of this file.

// MIT License
//
// Copyright (c) 2019 Ruhr University Bochum, Chair for Embedded Security. All Rights reserved.
// Copyright (c) 2019 Marc Fyrbiak, Sebastian Wallat, Max Hoffmann ("ORIGINAL AUTHORS"). All rights reserved.
// Copyright (c) 2021 Max Planck Institute for Security and Privacy. All Rights reserved.
// Copyright (c) 2021 Jörn Langheinrich, Julian Speith, Nils Albartus, René Walendy, Simon Klix ("ORIGINAL AUTHORS"). All Rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
 
#pragma once
 
#include "hal_core/defines.h"
#include "gui/gui_utils/sort.h"
#include "hal_core/netlist/module.h"
#include "gui/module_model/module_item.h"
 
 
#include <QAbstractItemModel>
#include <QModelIndex>
#include <QVariant>
#include <set>
#include <array>
#include <vector>
#include <QTextStream>
 
namespace hal
{
 
    class ModuleModel : public BaseTreeModel
    {
        friend class ModuleItem;
        Q_OBJECT
 
        class TempGateAssignment
        {
            int mAccumulate;
        public:
            QHash<u32, Module*> mGateRemove;
            QHash<u32, Module*> mGateAssign;
 
            TempGateAssignment() : mAccumulate(0) {;}
            void removeGateFromModule(u32 gateId, Module* m)
            {
                if (!mGateRemove.contains(gateId))
                    mGateRemove[gateId] = m;
            }
            void assignGateToModule(u32 gateId, Module* m)
            {
                mGateAssign[gateId] = m;
            }
            bool isAccumulate() const { return mAccumulate > 0; }
            void beginAccumulate() { mAccumulate++; }
            void endAccumulate() { mAccumulate--; }
        };
 
    public:
        explicit ModuleModel(QObject* parent = nullptr);
 
        ~ModuleModel();
 
        // === Pure Virtual ===
 
        QVariant data(const QModelIndex& index, int role) const override;
 
        // === Virtual ===
        Qt::ItemFlags flags(const QModelIndex& index) const override;
 
        // === Others ===
 
        ModuleItem* getItem(const QModelIndex& index) const;
 
        ModuleItem* getItem(const u32 id, ModuleItem::TreeItemType type = ModuleItem::TreeItemType::Module) const;
 
        QList<ModuleItem*> getItems(const u32 id, ModuleItem::TreeItemType type = ModuleItem::TreeItemType::Module) const;
 
        void clear() override;
 
        QMimeData* mimeData(const QModelIndexList &indexes) const override;
 
        void populateTree(const QVector<u32>& modIds = {}, const QVector<u32>& gatIds = {}, const QVector<u32>& netIds = {});
 
        void populateFromGatelist(const std::vector<Gate*>& gates);
 
        void setShowNetsOutsideModules(bool enable);
 
        bool showNetsOutsideModules() const;
 
        void addModule(const u32 id, const u32 parentId);
 
        void addGate(const u32 id, const u32 parentId);
 
        void addNet(const u32 id, const u32 parentId);
 
        void addRecursively(const Module* module, BaseTreeItem* parentItem = nullptr);
 
        void removeModule(const u32 id);
 
        void removeGate(const u32 id);
 
        void removeNet(const u32 id);
 
        void moduleAssignGate(const u32 moduleId, const u32 gateId);
 
        void moduleAssignNets(const QList<u32>& gateIds = QList<u32>());
 
        void updateNetParent(const Net* net, const QHash<const Net*,ModuleItem*>* parentAssignment = nullptr);
 
        void updateModuleParent(const Module* module);
 
        void updateModuleName(const u32 id);
 
        void updateModuleType(const u32 id);
 
        void updateGateName(const u32 id);
 
        void updateNetName(const u32 id);
 
        bool isModifying();
 
    private Q_SLOTS:
        void handleModuleNameChanged(Module* mod);
 
        void handleModuleTypeChanged(Module* mod);
 
        void handleModuleRemoved(Module* mod);
 
        void handleModuleCreated(Module* mod);
 
        void handleModuleParentChanged(const Module* mod);
 
        void handleModuleSubmoduleAdded(Module* mod, u32 submodId);
 
        void handleModuleSubmoduleRemoved(Module* mod, u32 submodId);
 
        void handleModuleGateAssigned(Module* mod, u32 gateId);
 
        void handleModuleGateRemoved(Module* mod, u32 gateId);
 
        void handleModuleGatesAssignBegin(Module* mod, u32 numberGates);
 
        void handleModuleGatesAssignEnd(Module* mod, u32 numberGates);
 
        void handleGateCreated(Gate* gat);
 
        void handleGateNameChanged(Gate* gat);
 
        void handleGateRemoved(Gate* gat);
 
        void handleNetCreated(Net* net);
 
        void handleNetNameChanged(Net* net);
 
        void handleNetRemoved(Net* net);
 
        void handleNetUpdated(Net* net, u32 data);
 
        void handleNetGlobalStateChanged(Netlist* netlist, u32 netId);
 
    protected:
        ModuleItem* createChildItem(u32 id, ModuleItem::TreeItemType itemType, BaseTreeItem* parentItem = nullptr);
 
        void removeChildItem(ModuleItem* itemToRemove, BaseTreeItem* parentItem);
 
        void setIsModifying(bool pIsModifying);
 
    private:
        Module* findNetParent(const Net* net) const;
 
        void findNetParentRecursion(BaseTreeItem* parent, QHash<const Net*,ModuleItem*>& parentAssignment, std::unordered_set<Net*>& assignedNets) const;
 
        void updateNetOutsideModules(u32 netId, bool outside);
 
        QMultiMap<u32, ModuleItem*> mModuleMap;
        QMultiMap<u32, ModuleItem*> mGateMap;
        QMultiMap<u32, ModuleItem*> mNetMap;
        QMultiMap<u32, ModuleItem*>* mModuleItemMaps[3] = {&mModuleMap, &mGateMap, &mNetMap};;
 
        bool mIsModifying;
 
        bool mResetInProgress;
 
        bool mShowNetsOutsideModules;
 
        TempGateAssignment mTempGateAssignment;
    };
}    // namespace hal