gate_type_components.cpp

Go to the documentation of this file.

#include "hal_core/netlist/gate_library/gate_type_component/ff_component.h"
#include "hal_core/netlist/gate_library/gate_type_component/gate_type_component.h"
#include "hal_core/netlist/gate_library/gate_type_component/init_component.h"
#include "hal_core/netlist/gate_library/gate_type_component/latch_component.h"
#include "hal_core/netlist/gate_library/gate_type_component/lut_component.h"
#include "hal_core/netlist/gate_library/gate_type_component/mac_component.h"
#include "hal_core/netlist/gate_library/gate_type_component/ram_component.h"
#include "hal_core/netlist/gate_library/gate_type_component/ram_port_component.h"
#include "hal_core/netlist/gate_library/gate_type_component/state_component.h"
#include "hal_core/python_bindings/python_bindings.h"
 
namespace hal
{
    void gate_type_components_init(py::module& m)
    {
        py::class_<GateTypeComponent, RawPtrWrapper<GateTypeComponent>> py_gate_type_component(m, "GateTypeComponent", R"(
            A component defining additional functionality of a gate type.
        )");
 
        py::enum_<GateTypeComponent::ComponentType>(py_gate_type_component, "ComponentType", R"(
            The type of a gate type component.
        )")
            .value("lut", GateTypeComponent::ComponentType::lut, R"(LUT component type.)")
            .value("ff", GateTypeComponent::ComponentType::ff, R"(Flip-flop component type.)")
            .value("latch", GateTypeComponent::ComponentType::latch, R"(Latch component type.)")
            .value("ram", GateTypeComponent::ComponentType::ram, R"(RAM component type.)")
            .value("mac", GateTypeComponent::ComponentType::mac, R"(MAC component type.)")
            .value("init", GateTypeComponent::ComponentType::init, R"(Initializiation component type.)")
            .value("state", GateTypeComponent::ComponentType::state, R"(State component type.)")
            .value("ram_port", GateTypeComponent::ComponentType::ram_port, R"(RAM port component type.)")
            .export_values();
 
        py_gate_type_component.def_property_readonly("type", &GateTypeComponent::get_type, R"(
            The type of the gate type component.
 
            :type: hal_py.GateTypeComponent.ComponentType
        )");
 
        py_gate_type_component.def("get_type", &GateTypeComponent::get_type, R"(
            Get the type of the gate type component.
 
            :returns: The type of the gate type component.
            :rtype: hal_py.GateTypeComponent.ComponentType
        )");
 
        py_gate_type_component.def_property_readonly("components", &GateTypeComponent::get_components, R"(
            All components of the gate type component as a list.
 
            :type: list[hal_py.GateTypeComponent]
        )");
 
        py_gate_type_component.def("get_components", &GateTypeComponent::get_components, py::arg("filter") = nullptr, R"(
            Get all components matching the filter condition (if provided) as a list. 
            Returns an empty list if (i) the gate type does not contain any components or (ii) no component matches the filter condition.
 
            :param lambda filter: The filter applied to all candidate components, disabled by default.
            :returns: The components.
            :rtype: list[hal_py.GateTypeComponent]
        )");
 
        py_gate_type_component.def("get_component", &GateTypeComponent::get_component, py::arg("filter") = nullptr, R"(
            Get a single component matching the filter condition (if provided).
            Returns ``None`` if (i) the gate type does not contain any components, (ii) multiple components match the filter condition, or (iii) no component matches the filter condition.
 
            :param lambda filter: The filter applied to all candidate components.
            :returns: The component or ``None``.
            :rtype: hal_py.GateTypeComponent or None
        )");
 
        py::class_<LUTComponent, GateTypeComponent, RawPtrWrapper<LUTComponent>> py_lut_component(m, "LUTComponent", R"(
            A LUT component specifying the LUT gate type's functionality.
        )");
 
        py_lut_component.def_static("is_class_of", &LUTComponent::is_class_of, py::arg("component"), R"(
            Check whether a component is a LUTComponent.
 
            :param hal_py.GateTypeComponent component: The component to check.
            :returns: ``True`` if component is a LUTComponent, ``False`` otherwise.
            :rtype: bool
        )");
 
        py_lut_component.def_property("init_ascending", &LUTComponent::is_init_ascending, &LUTComponent::set_init_ascending, R"(
            The bit-order of the initialization string. 
            ``True`` if ascending, ``False`` otherwise.
 
            :type: bool
        )");
 
        py_lut_component.def("is_init_ascending", &LUTComponent::is_init_ascending, R"(
            Get the bit-order of the initialization string.
         
            :returns: ``True`` if ascending bit-order, ``False`` otherwise.
            :rtype: bool
        )");
 
        py_lut_component.def("set_init_ascending", &LUTComponent::set_init_ascending, py::arg("init_ascending") = true, R"(
            Set the bit-order of the initialization string.
         
            :param bool init_ascending: ``True`` if ascending bit-order, ``False`` otherwise.
        )");
 
        py::class_<FFComponent, GateTypeComponent, RawPtrWrapper<FFComponent>> py_ff_component(m, "FFComponent", R"(
            A FF component specifying the FF gate type's functionality.
        )");
 
        py_ff_component.def_static("is_class_of", &FFComponent::is_class_of, py::arg("component"), R"(
            Check whether a component is a FFComponent.
 
            :param hal_py.GateTypeComponent component: The component to check.
            :returns: ``True`` if component is a FFComponent, ``False`` otherwise.
            :rtype: bool
        )");
 
        py_ff_component.def_property("next_state_function", &FFComponent::get_next_state_function, &FFComponent::set_next_state_function, R"(
            The Boolean function describing the next internal state of the flip-flop.
        )");
 
        py_ff_component.def("get_next_state_function", &FFComponent::get_next_state_function, R"(
            Get the Boolean function describing the next internal state of the flip-flop.
 
            :returns: The function describing the internal state.
            :rtype: hal_py.BooleanFunction
        )");
 
        py_ff_component.def("set_next_state_function", &FFComponent::set_next_state_function, py::arg("next_state_bf"), R"(
            Set the Boolean function describing the next internal state of the flip-flop.
 
            :param hal_py.BooleanFunction next_state_bf: The function describing the internal state.
        )");
 
        py_ff_component.def_property("clock_function", &FFComponent::get_clock_function, &FFComponent::set_clock_function, R"(
            The Boolean function describing the clock input of the flip-flop.
        )");
 
        py_ff_component.def("get_clock_function", &FFComponent::get_clock_function, R"(
            Get the Boolean function describing the clock input of the flip-flop.
 
            :returns: The function describing the clock input.
            :rtype: hal_py.BooleanFunction
        )");
 
        py_ff_component.def("set_clock_function", &FFComponent::set_clock_function, py::arg("clock_bf"), R"(
            Set the Boolean function describing the clock input of the flip-flop.
 
            :param hal_py.BooleanFunction clock_bf: The function describing the clock input.
        )");
 
        py_ff_component.def_property("async_reset_function", &FFComponent::get_async_reset_function, &FFComponent::set_async_reset_function, R"(
            The Boolean function describing the asynchronous reset behavior of the flip-flop.
            Is an empty function if asynchronous reset is not supported by the flip-flop.
        )");
 
        py_ff_component.def("get_async_reset_function", &FFComponent::get_async_reset_function, R"(
            Get the Boolean function describing the asynchronous reset behavior of the flip-flop.
            Returns an empty function if asynchronous reset is not supported by the flip-flop.
 
            :returns: The function describing the asynchronous reset behavior.
            :rtype: hal_py.BooleanFunction
        )");
 
        py_ff_component.def("set_async_reset_function", &FFComponent::set_async_reset_function, py::arg("async_reset_bf"), R"(
            Set the Boolean function describing the asynchronous reset behavior of the flip-flop.
 
            :param hal_py.BooleanFunction async_reset_bf: The function describing the asynchronous reset behavior.
        )");
 
        py_ff_component.def_property("async_set_function", &FFComponent::get_async_set_function, &FFComponent::set_async_set_function, R"(
            The Boolean function describing the asynchronous set behavior of the flip-flop.
            Is an empty function if asynchronous set is not supported by the flip-flop.
        )");
 
        py_ff_component.def("get_async_set_function", &FFComponent::get_async_set_function, R"(
            Get the Boolean function describing the asynchronous set behavior of the flip-flop.
            Returns an empty function if asynchronous set is not supported by the flip-flop.
 
            :returns: The function describing the asynchronous set behavior.
            :rtype: hal_py.BooleanFunction
        )");
 
        py_ff_component.def("set_async_set_function", &FFComponent::set_async_set_function, py::arg("async_set_bf"), R"(
            Set the Boolean function describing the asynchronous set behavior of the flip-flop.
 
            :param hal_py.BooleanFunction async_set_bf: The function describing the asynchronous set behavior.
        )");
 
        py_ff_component.def("get_async_set_reset_behavior", &FFComponent::get_async_set_reset_behavior, R"(
            Get the behavior of the internal state and the negated internal state when both asynchronous set and reset are active at the same time.
 
            :returns: The values specifying the behavior for the internal and negated internal state.
            :rtype: tuple(hal_py.AsyncSetResetBehavior, hal_py.AsyncSetResetBehavior)
        )");
 
        py_ff_component.def("set_async_set_reset_behavior", &FFComponent::set_async_set_reset_behavior, py::arg("behav_state"), py::arg("behav_neg_state"), R"(
            Set the behavior of the internal state and the negated internal state when both asynchronous set and reset are active at the same time.
 
            :param hal_py.AsyncSetResetBehavior behav_state: The behavior of the internal state.
            :param hal_py.AsyncSetResetBehavior behav_neg_state: The behavior of the negated internal state.
        )");
 
        py::class_<LatchComponent, GateTypeComponent, RawPtrWrapper<LatchComponent>> py_latch_component(m, "LatchComponent", R"(
            A latch component specifying the latch gate type's functionality.
        )");
 
        py_latch_component.def_static("is_class_of", &LatchComponent::is_class_of, py::arg("component"), R"(
            Check whether a component is a LatchComponent.
 
            :param hal_py.GateTypeComponent component: The component to check.
            :returns: ``True`` if component is a LatchComponent, ``False`` otherwise.
            :rtype: bool
        )");
 
        py_latch_component.def_property("data_in_function", &LatchComponent::get_data_in_function, &LatchComponent::set_data_in_function, R"(
            The Boolean function describing the data input of the latch.
        )");
 
        py_latch_component.def("get_data_in_function", &LatchComponent::get_data_in_function, R"(
            Get the Boolean function describing the data input of the latch.
 
            :returns: The function describing the data input.
            :rtype: hal_py.BooleanFunction
        )");
 
        py_latch_component.def("set_data_in_function", &LatchComponent::set_data_in_function, py::arg("data_in_bf"), R"(
            Set the Boolean function describing the data input of the latch.
 
            :param hal_py.BooleanFunction data_in_bf: The function describing the data input.
        )");
 
        py_latch_component.def_property("enable_function", &LatchComponent::get_enable_function, &LatchComponent::set_enable_function, R"(
            The Boolean function describing the enable behavior of the latch.
        )");
 
        py_latch_component.def("get_enable_function", &LatchComponent::get_enable_function, R"(
            Get the Boolean function describing the enable behavior of the latch.
 
            :returns: The function describing the enable behavior.
            :rtype: hal_py.BooleanFunction
        )");
 
        py_latch_component.def("set_enable_function", &LatchComponent::set_enable_function, py::arg("enable_bf"), R"(
            Set the Boolean function describing the enable behavior of the latch.
 
            :param hal_py.BooleanFunction enable_bf: The function describing the enable behavior.
        )");
 
        py_latch_component.def_property("async_reset_function", &LatchComponent::get_async_reset_function, &LatchComponent::set_async_reset_function, R"(
            The Boolean function describing the asynchronous reset behavior of the latch.
            Is an empty function if asynchronous reset is not supported by the latch.
        )");
 
        py_latch_component.def("get_async_reset_function", &LatchComponent::get_async_reset_function, R"(
            Get the Boolean function describing the asynchronous reset behavior of the latch.
            Returns an empty function if asynchronous reset is not supported by the latch.
 
            :returns: The function describing the asynchronous reset behavior.
            :rtype: hal_py.BooleanFunction
        )");
 
        py_latch_component.def("set_async_reset_function", &LatchComponent::set_async_reset_function, py::arg("async_reset_bf"), R"(
            Set the Boolean function describing the asynchronous reset behavior of the latch.
 
            :param hal_py.BooleanFunction async_reset_bf: The function describing the asynchronous reset behavior.
        )");
 
        py_latch_component.def_property("async_set_function", &LatchComponent::get_async_set_function, &LatchComponent::set_async_set_function, R"(
            The Boolean function describing the asynchronous set behavior of the latch.
            Is an empty function if asynchronous set is not supported by the latch.
        )");
 
        py_latch_component.def("get_async_set_function", &LatchComponent::get_async_set_function, R"(
            Get the Boolean function describing the asynchronous set behavior of the latch.
            Returns an empty function if asynchronous set is not supported by the latch.
 
            :returns: The function describing the asynchronous set behavior.
            :rtype: hal_py.BooleanFunction
        )");
 
        py_latch_component.def("set_async_set_function", &LatchComponent::set_async_set_function, py::arg("async_set_bf"), R"(
            Set the Boolean function describing the asynchronous set behavior of the latch.
 
            :param hal_py.BooleanFunction async_set_bf: The function describing the asynchronous set behavior.
        )");
 
        py_latch_component.def("get_async_set_reset_behavior", &LatchComponent::get_async_set_reset_behavior, R"(
            Get the behavior of the internal state and the negated internal state when both asynchronous set and reset are active at the same time.
 
            :returns: The values specifying the behavior for the internal and negated internal state.
            :rtype: tuple(hal_py.AsyncSetResetBehavior, hal_py.AsyncSetResetBehavior)
        )");
 
        py_latch_component.def("set_async_set_reset_behavior", &LatchComponent::set_async_set_reset_behavior, py::arg("behav_state"), py::arg("behav_neg_state"), R"(
            Set the behavior of the internal state and the negated internal state when both asynchronous set and reset are active at the same time.
 
            :param hal_py.AsyncSetResetBehavior behav_state: The behavior of the internal state.
            :param hal_py.AsyncSetResetBehavior behav_neg_state: The behavior of the negated internal state.
        )");
 
        py::class_<RAMComponent, GateTypeComponent, RawPtrWrapper<RAMComponent>> py_ram_component(m, "RAMComponent", R"(
            A RAM component specifying the RAM gate type's functionality.
        )");
 
        py_ram_component.def_static("is_class_of", &RAMComponent::is_class_of, py::arg("component"), R"(
            Check whether a component is a RAMComponent.
 
            :param hal_py.GateTypeComponent component: The component to check.
            :returns: ``True`` if component is a RAMComponent, ``False`` otherwise.
            :rtype: bool
        )");
 
        py_ram_component.def_property("bit_size", &RAMComponent::get_bit_size, &RAMComponent::set_bit_size, R"(
            The size of the RAM in bits.
 
            :type: int
        )");
 
        py_ram_component.def("get_bit_size", &RAMComponent::get_bit_size, R"(
            Get the size of the RAM in bits.
 
            :returns: The size of the RAM in bits.
            :rtype: int
        )");
 
        py_ram_component.def("set_bit_size", &RAMComponent::set_bit_size, py::arg("bit_size"), R"(
            Set the size of the RAM in bits.
 
            :param int bit_size: The size of the RAM in bits.
        )");
 
        py::class_<MACComponent, GateTypeComponent, RawPtrWrapper<MACComponent>> py_mac_component(m, "MACComponent", R"(
            A MAC component specifying the MAC gate type's functionality.
        )");
 
        py_mac_component.def_static("is_class_of", &MACComponent::is_class_of, py::arg("component"), R"(
            Check whether a component is a MACComponent.
 
            :param hal_py.GateTypeComponent component: The component to check.
            :returns: ``True`` if component is a MACComponent, ``False`` otherwise.
            :rtype: bool
        )");
 
        py::class_<InitComponent, GateTypeComponent, RawPtrWrapper<InitComponent>> py_init_component(m, "InitComponent", R"(
            An initialization component specifying the initialization behavior of a gate type.
        )");
 
        py_init_component.def_static("is_class_of", &InitComponent::is_class_of, py::arg("component"), R"(
            Check whether a component is an InitComponent.
 
            :param hal_py.GateTypeComponent component: The component to check.
            :returns: ``True`` if component is an InitComponent, ``False`` otherwise.
            :rtype: bool
        )");
 
        py_init_component.def_property("init_category", &InitComponent::get_init_category, &InitComponent::set_init_category, R"(
            The category in which to find the initialization data.
            
            :type: str
        )");
 
        py_init_component.def("get_init_category", &InitComponent::get_init_category, R"(
            Get the category in which to find the initialization data.
 
            :returns: The data category.
            :rtype: str
        )");
 
        py_init_component.def("set_init_category", &InitComponent::set_init_category, py::arg("init_category"), R"(
            Set the category in which to find the initialization data.
 
            :param str init_category: The data category.
        )");
 
        py_init_component.def_property("init_identifiers", &InitComponent::get_init_identifiers, &InitComponent::set_init_identifiers, R"(
            The list of identifiers at which to find initialization data.
            
            :type: str
        )");
 
        py_init_component.def("get_init_identifier", &InitComponent::get_init_identifiers, R"(
            Get the list of identifiers at which to find the initialization data.
 
            :returns: The data identifiers.
            :rtype: list[str]
        )");
 
        py_init_component.def("set_init_identifier", &InitComponent::set_init_identifiers, py::arg("init_identifiers"), R"(
            Set the list of identifiers at which to find the initialization data.
 
            :param list[str] init_identifiers: The data identifiers.
        )");
 
        py::class_<StateComponent, GateTypeComponent, RawPtrWrapper<StateComponent>> py_state_component(m, "StateComponent", R"(
            A StateComponent with given child component and the internal state identifiers.
        )");
 
        py_state_component.def_static("is_class_of", &StateComponent::is_class_of, py::arg("component"), R"(
            Check whether a component is a StateComponent.
 
            :param hal_py.GateTypeComponent component: The component to check.
            :returns: ``True`` if component is a StateComponent, ``False`` otherwise.
            :rtype: bool
        )");
 
        py_state_component.def_property("state_identifier", &StateComponent::get_state_identifier, &StateComponent::set_state_identifier, R"(
            The identifier of the internal state.
            
            :type: str
        )");
 
        py_state_component.def("get_state_identifier", &StateComponent::get_state_identifier, R"(
            Get the identifier of the internal state.
 
            :returns: The identifier of the internal state.
            :rtype: str
        )");
 
        py_state_component.def("set_state_identifier", &StateComponent::set_state_identifier, py::arg("state_identifier"), R"(
            Set the identifier of the internal state.
 
            :param str state_identifier: The identifier of the internal state.
        )");
 
        py_state_component.def_property("neg_state_identifier", &StateComponent::get_neg_state_identifier, &StateComponent::set_neg_state_identifier, R"(
            The identifier of the negated internal state.
            
            :type: str
        )");
 
        py_state_component.def("get_neg_state_identifier", &StateComponent::get_neg_state_identifier, R"(
            Get the identifier of the negated internal state.
 
            :returns: The identifier of the negated internal state.
            :rtype: str
        )");
 
        py_state_component.def("set_neg_state_identifier", &StateComponent::set_neg_state_identifier, py::arg("neg_state_identifier"), R"(
            Set the identifier of the negated internal state.
 
            :param str neg_state_identifier: The identifier of the negated internal state.
        )");
 
        py::class_<RAMPortComponent, GateTypeComponent, RawPtrWrapper<RAMPortComponent>> py_ram_port_component(m, "RAMPortComponent", R"(
            A RAM port component specifying the behavior of a port belonging to a RAM gate type.
        )");
 
        py_ram_port_component.def_static("is_class_of", &RAMPortComponent::is_class_of, py::arg("component"), R"(
            Check whether a component is a RAMPortComponent.
 
            :param hal_py.GateTypeComponent component: The component to check.
            :returns: ``True`` if component is a RAMPortComponent, ``False`` otherwise.
            :rtype: bool
        )");
 
        py_ram_port_component.def_property("data_group", &RAMPortComponent::get_data_group, &RAMPortComponent::set_data_group, R"(
            The name of the read or write data pin group.
 
            :type: str
        )");
 
        py_ram_port_component.def("get_data_group", &RAMPortComponent::get_data_group, R"(
            Get the name of the read or write data pin group.
 
            :returns: The name of the pin group.
            :rtype: str
        )");
 
        py_ram_port_component.def("set_data_group", &RAMPortComponent::set_data_group, py::arg("data_group"), R"(
            Set the name of the read or write data pin group.
 
            :param str data_group: The name of the pin group.
        )");
 
        py_ram_port_component.def_property("address_group", &RAMPortComponent::get_address_group, &RAMPortComponent::set_address_group, R"(
            The name of the read or write address pin group.
 
            :type: str
        )");
 
        py_ram_port_component.def("get_address_group", &RAMPortComponent::get_address_group, R"(
            Get the name of the read or write address pin group.
 
            :returns: The name of the pin group.
            :rtype: str
        )");
 
        py_ram_port_component.def("set_address_group", &RAMPortComponent::set_address_group, py::arg("addr_group"), R"(
            Set the name of the read or write address pin group.
 
            :param str addr_group: The name of the pin group.
        )");
 
        py_ram_port_component.def_property("clock_function", &RAMPortComponent::get_clock_function, &RAMPortComponent::set_clock_function, R"(
            The Boolean function determining the read or write clock.
 
            :type: hal_py.BooleanFunction
        )");
 
        py_ram_port_component.def("get_clock_function", &RAMPortComponent::get_clock_function, R"(
            Get the Boolean function determining the read or write clock.
 
            :returns: The Boolean function.
            :rtype: hal_py.BooleanFunction
        )");
 
        py_ram_port_component.def("set_clock_function", &RAMPortComponent::set_clock_function, py::arg("clock_bf"), R"(
            Set the Boolean function determining the read or write clock.
 
            :param hal_py.BooleanFunction clock_bf: The Boolean function.
        )");
 
        py_ram_port_component.def_property("enable_function", &RAMPortComponent::get_enable_function, &RAMPortComponent::set_enable_function, R"(
            The Boolean function determining the read or write enable.
 
            :type: hal_py.BooleanFunction
        )");
 
        py_ram_port_component.def("get_enable_function", &RAMPortComponent::get_enable_function, R"(
            Get the Boolean function determining the read or write enable.
 
            :returns: The Boolean function.
            :rtype: hal_py.BooleanFunction
        )");
 
        py_ram_port_component.def("set_enable_function", &RAMPortComponent::set_enable_function, py::arg("enable_bf"), R"(
            Set the Boolean function determining the read or write enable.
 
            :param hal_py.BooleanFunction enable_bf: The Boolean function.
        )");
 
        py_ram_port_component.def_property("write_port", &RAMPortComponent::is_write_port, &RAMPortComponent::set_write_port, R"(
            ``True`` if the port is a write port, ``False`` if it is a read port.
 
            :type: bool
        )");
 
        py_ram_port_component.def("is_write_port", &RAMPortComponent::is_write_port, R"(
            Check whether the port is a write or a read port.
 
            :returns: ``True`` if the port is a write port, ``False`` otherwise.
            :rtype: bool
        )");
 
        py_ram_port_component.def("set_write_port", &RAMPortComponent::set_write_port, py::arg("is_write"), R"(
            Set the port to be a write or a read port.
 
            :param bool is_write: ``True`` to set the port to be a write port, ``False`` to set it to be a read port.
        )");
    }
}    // namespace hal