gate_type.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/netlist/boolean_function.h"
#include "hal_core/netlist/gate_library/enums/gate_type_property.h"
#include "hal_core/netlist/gate_library/gate_type_component/gate_type_component.h"
#include "hal_core/netlist/pins/gate_pin.h"
#include "hal_core/netlist/pins/pin_group.h"
#include "hal_core/utilities/enums.h"
 
#include <map>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
 
namespace hal
{
    class GateLibrary;
 
 
    class NETLIST_API GateType
    {
    public:
        ssize_t get_hash() const;
 
        std::vector<GateTypeComponent*> get_components(const std::function<bool(const GateTypeComponent*)>& filter = nullptr) const;
 
        GateTypeComponent* get_component(const std::function<bool(const GateTypeComponent*)>& filter = nullptr) const;
 
        template<typename T>
        T* get_component_as(const std::function<bool(const GateTypeComponent*)>& filter = nullptr) const
        {
            GateTypeComponent* component = this->get_component(filter);
            if (component != nullptr)
            {
                return component->convert_to<T>();
            }
 
            return nullptr;
        }
 
        bool has_component_of_type(const GateTypeComponent::ComponentType type) const;
 
        u32 get_id() const;
 
        const std::string& get_name() const;
 
        void assign_property(const GateTypeProperty property);
 
        std::set<GateTypeProperty> get_properties() const;
 
        std::vector<GateTypeProperty> get_property_list() const;
 
        bool has_property(GateTypeProperty property) const;
 
        GateLibrary* get_gate_library() const;
 
        std::string to_string() const;
 
        friend std::ostream& operator<<(std::ostream& os, const GateType& gate_type);
 
        bool operator==(const GateType& other) const;
 
        bool operator!=(const GateType& other) const;
 
        u32 get_unique_pin_id();
 
        u32 get_unique_pin_group_id();
 
        Result<GatePin*> create_pin(const u32 id, const std::string& name, PinDirection direction, PinType type = PinType::none, bool create_group = true);
 
        Result<GatePin*> create_pin(const std::string& name, PinDirection direction, PinType type = PinType::none, bool create_group = true);
 
        std::vector<GatePin*> get_pins(const std::function<bool(GatePin*)>& filter = nullptr) const;
 
        std::vector<std::string> get_pin_names(const std::function<bool(GatePin*)>& filter = nullptr) const;
 
        std::vector<GatePin*> get_input_pins() const;
 
        std::vector<std::string> get_input_pin_names() const;
 
        std::vector<GatePin*> get_output_pins() const;
 
        std::vector<std::string> get_output_pin_names() const;
 
        GatePin* get_pin_by_id(const u32 id) const;
 
        GatePin* get_pin_by_name(const std::string& name) const;
 
        Result<PinGroup<GatePin>*> create_pin_group(const u32 id,
                                                    const std::string& name,
                                                    const std::vector<GatePin*> pins = {},
                                                    PinDirection direction           = PinDirection::none,
                                                    PinType type                     = PinType::none,
                                                    bool ascending                   = true,
                                                    i32 start_index                  = 0,
                                                    bool delete_empty_groups         = true);
 
        Result<PinGroup<GatePin>*> create_pin_group(const std::string& name,
                                                    const std::vector<GatePin*> pins = {},
                                                    PinDirection direction           = PinDirection::none,
                                                    PinType type                     = PinType::none,
                                                    bool ascending                   = true,
                                                    i32 start_index                  = 0,
                                                    bool delete_empty_groups         = true);
 
        std::vector<PinGroup<GatePin>*> get_pin_groups(const std::function<bool(PinGroup<GatePin>*)>& filter = nullptr) const;
 
        PinGroup<GatePin>* get_pin_group_by_id(const u32 id) const;
 
        PinGroup<GatePin>* get_pin_group_by_name(const std::string& name) const;
 
        bool delete_pin_group(PinGroup<GatePin>* pin_group);
 
        Result<std::monostate> assign_pin_to_group(PinGroup<GatePin>* pin_group, GatePin* pin, bool delete_empty_groups = true);
 
        bool set_pin_group_name(PinGroup<GatePin>* pin_group, const std::string& new_name);
 
        bool set_pin_group_type(PinGroup<GatePin>* pin_group, PinType new_type);
 
        bool set_pin_group_direction(PinGroup<GatePin>* pin_group, PinDirection new_direction);
 
        void add_boolean_function(const std::string& name, const BooleanFunction& function);
 
        void add_boolean_functions(const std::unordered_map<std::string, BooleanFunction>& functions);
 
        const std::unordered_map<std::string, BooleanFunction>& get_boolean_functions() const;
 
        BooleanFunction get_boolean_function(const std::string& name) const;
 
        BooleanFunction get_boolean_function(const GatePin* pin = nullptr) const;
 
    private:
        friend class GateLibrary;
 
        GateLibrary* m_gate_library;
        u32 m_id;
        std::string m_name;
        std::set<GateTypeProperty> m_properties;
        std::unique_ptr<GateTypeComponent> m_component;
 
        // pins
        u32 m_next_pin_id;
        std::set<u32> m_used_pin_ids;
        std::set<u32> m_free_pin_ids;
        u32 m_next_pin_group_id;
        std::set<u32> m_used_pin_group_ids;
        std::set<u32> m_free_pin_group_ids;
 
        std::vector<std::unique_ptr<GatePin>> m_pins;
        std::unordered_map<u32, GatePin*> m_pins_map;
        std::unordered_map<std::string, GatePin*> m_pin_names_map;
        std::vector<std::unique_ptr<PinGroup<GatePin>>> m_pin_groups;
        std::unordered_map<u32, PinGroup<GatePin>*> m_pin_groups_map;
        std::unordered_map<std::string, PinGroup<GatePin>*> m_pin_group_names_map;
        std::list<PinGroup<GatePin>*> m_pin_groups_ordered;
 
        // Boolean functions
        std::unordered_map<std::string, BooleanFunction> m_functions;
 
        GateType(GateLibrary* gate_library, u32 id, const std::string& name, std::set<GateTypeProperty> properties, std::unique_ptr<GateTypeComponent> component = nullptr);
 
        GateType(const GateType&)            = delete;
        GateType& operator=(const GateType&) = delete;
 
        Result<PinGroup<GatePin>*> create_pin_group_internal(const u32 id, const std::string& name, PinDirection direction, PinType type, bool ascending, u32 start_index);
        bool delete_pin_group_internal(PinGroup<GatePin>* pin_group);
    };
}    // namespace hal