gui_def.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 "hal_core/utilities/log.h"
#include <QDebug>
#include <QPoint>
#include <QHash>
#include <QSet>
#include <QMetaType>
 
namespace hal
{
    enum class ItemType
    {
        None, Module, Gate, Net
    };
 
    class Node
    {
    public:
        enum NodeType {None, Module, Gate};
 
        Node(u32 i=0, NodeType t=None) : mId(i), mType(t) {;}
 
        NodeType type() const { return mType; }
 
        u32 id() const { return mId; }
 
        bool isNull()   const { return mType == None; }
 
        bool isGate()   const { return mType == Gate; }
 
        bool isModule() const { return mType == Module; }
 
        bool operator<(const Node& rhs) const
        {
            if (mType < rhs.mType)
                return true;
            if (mType > rhs.mType)
                return false;
            return mId < rhs.mId;
        }
 
        bool operator==(const Node& rhs) const
        {
            return mType == rhs.mType && mId == rhs.mId;
        }
 
        bool operator!=(const Node& rhs) const
        {
            return !(*this == rhs);
        }
 
    private:
 
        u32 mId;
        NodeType mType;
    };
 
 
    uint qHash(const Node &n);
 
    class GridPlacement : public QHash<Node,QPoint>
    {
    public:
        GridPlacement() {;}
        GridPlacement(const QHash<hal::Node,QPoint>& data) : QHash<hal::Node,QPoint>(data) {;}
 
        void setGatePosition(u32 gateId, std::pair<int,int>p, bool swap = false) {
            std::pair<int,int>* posPtr = gatePosition(gateId);
            if (!posPtr)
            {
                log_warning("gui", "Gate id {} cannot be moved, not found in current placement", gateId);
                return;
            }
            QPoint pos = QPoint(posPtr->first, posPtr->second); //position of current gate to move
            hal::Node nd = key(QPoint(p.first, p.second)); //find the node in the destination
 
            if(!nd.isNull() && !swap) //if the destination placement is not available
                log_warning("gui", "Target position is already occupied");
            else if (!nd.isNull() && swap)
            {
                operator[](hal::Node(gateId,hal::Node::Gate)) = QPoint(p.first,p.second);//set the position of the first node to the destination
                if(nd.isGate())
                    operator[](hal::Node(nd.id(), hal::Node::Gate)) = pos;//set the position of the destination node to the position of the first node
                else operator[](hal::Node(nd.id(), hal::Node::Module)) = pos;
            }
            else
                operator[](hal::Node(gateId,hal::Node::Gate)) = QPoint(p.first,p.second);
        }
 
        void setModulePosition(u32 moduleId, std::pair<int,int>p, bool swap = false){
            std::pair<int,int>* posPtr = modulePosition(moduleId);
            if (!posPtr)
            {
                log_warning("gui", "Module id {} cannot be moved, not found in current placement", moduleId);
                return;
            }
            QPoint pos = QPoint(posPtr->first, posPtr->second); //position of current module to move
            hal::Node nd = key(QPoint(p.first, p.second));
 
            if(!nd.isNull() && !swap)
                log_warning("gui", "Target position is already occupied");
            else if (!nd.isNull() && swap)
            {
                operator[](hal::Node(moduleId,hal::Node::Module)) = QPoint(p.first,p.second);
                if(nd.isGate())
                    operator[](hal::Node(nd.id(), hal::Node::Gate)) = pos;
                else operator[](hal::Node(nd.id(), hal::Node::Module)) = pos;
            }
            else
                operator[](hal::Node(moduleId,hal::Node::Module)) = QPoint(p.first,p.second);};
 
        std::pair<int,int>* gatePosition(u32 gateId) const
        {
            auto it = constFind(hal::Node(gateId,hal::Node::Gate));
            return (it == constEnd() ? nullptr : new std::pair<int,int>(it->x(),it->y()));
        }
 
        std::pair<int,int>* modulePosition(u32 moduleId) const
        {
            auto it = constFind(hal::Node(moduleId,hal::Node::Module));
            return (it == constEnd() ? nullptr : new std::pair(it->x(),it->y()));
        }
    };
 
    class PlacementHint
    {
    public:
        enum PlacementModeType {Standard = 0, PreferLeft = 1, PreferRight = 2, GridPosition = 3};
 
        PlacementHint(PlacementModeType mod = Standard, const Node& orign=Node())
            : mMode(mod), mPreferredOrigin(orign) {;}
 
        PlacementHint(const GridPlacement& gridPlc)
            : mMode(GridPosition), mPreferredOrigin(Node()), mGridPos(gridPlc) {;}
 
        PlacementModeType mode() const { return mMode; }
 
        Node preferredOrigin() const { return mPreferredOrigin; }
 
        bool operator<(const PlacementHint& rhs) const
        {
            if (mMode < rhs.mMode)
                return true;
            if (mMode > rhs.mMode)
                return false;
            return mPreferredOrigin < rhs.mPreferredOrigin;
        }
 
        bool operator==(const PlacementHint& rhs) const
        {
            return mMode == rhs.mMode && mPreferredOrigin == rhs.mPreferredOrigin;
        }
 
        void addGridPosition(const Node& nd, const QPoint& p)
        {
            mGridPos.insert(nd,p);
        }
 
        const QHash<Node,QPoint>& gridPosition() const { return mGridPos; }
    private:
        PlacementModeType mMode;
        Node mPreferredOrigin;
        GridPlacement mGridPos;
    };
 
    class PlacementEntry {
    public:
        PlacementHint mPlacementHint;
        QSet<u32> mModules;
        QSet<u32> mGates;
        PlacementEntry(const PlacementHint& plc, const QSet<u32>& mods, const QSet<u32>& gats)
            : mPlacementHint(plc), mModules(mods), mGates(gats) {;}
    };
 
}
// must stand globally at the end
Q_DECLARE_METATYPE(hal::Node);