gate_type_components.cpp

Go to the documentation of this file.

#include "hal_core/netlist/gate.h"
#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", py::cpp_function(&GateTypeComponent::get_type, py::is_method(py_gate_type_component), borrowed()), R"(
            The type of the gate type component.
 
            :type: hal_py.GateTypeComponent.ComponentType
        )");
 
        py_gate_type_component.def("get_type", &GateTypeComponent::get_type, borrowed(), 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", py::cpp_function(&GateTypeComponent::get_components, py::is_method(py_gate_type_component), borrowed()), 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, borrowed(), 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, borrowed(), 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::class_<LUTComponent::LUTOutputConfig>(py_lut_component, "LUTOutputConfig", R"(
            Per-output-pin INIT configuration for a LUT component.
        )")
            .def(py::init<std::string, u32, u32, bool, std::vector<std::string>>(),
                 py::arg("init_identifier"),
                 py::arg("bit_offset"),
                 py::arg("bit_count"),
                 py::arg("is_ascending") = true,
                 py::arg("input_pins"))
            .def_readonly("init_identifier", &LUTComponent::LUTOutputConfig::init_identifier, R"(
                The data identifier within the INIT category for this output pin.
 
                :type: str
            )")
            .def_readonly("bit_offset", &LUTComponent::LUTOutputConfig::bit_offset, R"(
                The first bit (LSB = 0) of the slice within the parsed INIT value.
 
                :type: int
            )")
            .def_readonly("bit_count", &LUTComponent::LUTOutputConfig::bit_count, R"(
                The number of bits in the slice. Must be a non-zero power of two.
 
                :type: int
            )")
            .def_readonly("is_ascending", &LUTComponent::LUTOutputConfig::is_ascending, R"(
                True if the INIT bits are stored in ascending order (LSB first), False for descending.
 
                :type: bool
            )")
            .def_readonly("input_pins", &LUTComponent::LUTOutputConfig::input_pins, R"(
                Ordered list of input pin names used by this output. Must be non-empty; size must equal log2(bit_count).
 
                :type: list[str]
            )");
 
        py_lut_component.def(
            "get_output_pin_config",
            [](const LUTComponent& self, const std::string& pin_name) -> const LUTComponent::LUTOutputConfig* { return self.get_output_pin_config(pin_name); },
            py::arg("pin_name"),
            py::return_value_policy::reference_internal,
            R"(
            Get the output configuration for a specific pin, or None if none is set.
 
            :param str pin_name: Name of the LUT output pin.
            :returns: The output configuration or None.
            :rtype: hal_py.LUTComponent.LUTOutputConfig or None
        )");
 
        py_lut_component.def(
            "get_output_pin_configs",
            [](const LUTComponent& self) { return self.get_output_pin_configs(); },
            R"(
            Get all per-output-pin configurations.
 
            :returns: Dict mapping pin name to LUTOutputConfig.
            :rtype: dict[str, hal_py.LUTComponent.LUTOutputConfig]
        )");
 
        py_lut_component.def_static(
            "extract_init_slice",
            [](const std::string& full_hex, u32 bit_offset, u32 bit_count) -> std::optional<std::string> {
                auto res = LUTComponent::extract_init_slice(full_hex, bit_offset, bit_count);
                if (res.is_error())
                {
                    log_error("python_context", "{}.", res.get_error().get());
                    return std::nullopt;
                }
                return res.get();
            },
            py::arg("full_hex"),
            py::arg("bit_offset"),
            py::arg("bit_count"),
            R"(
            Extract a bit slice from a full INIT hex string.
            Returns the slice as an uppercase hex string padded to ``(bit_count+3)//4`` characters.
 
            :param str full_hex: Full INIT value as a hex string; must not be empty and must contain at least ``(bit_offset+bit_count+3)//4`` hex chars.
            :param int bit_offset: First bit (LSB = 0) of the slice.
            :param int bit_count: Number of bits in the slice; must be non-zero.
            :returns: The extracted hex string, or ``None`` if ``full_hex`` is empty, too short, or invalid.
            :rtype: str or None
        )");
 
        py_lut_component.def_static(
            "splice_init_slice",
            [](const std::string& full_hex, const std::string& slice_hex, u32 bit_offset, u32 bit_count) -> std::optional<std::string> {
                auto res = LUTComponent::splice_init_slice(full_hex, slice_hex, bit_offset, bit_count);
                if (res.is_error())
                {
                    log_error("python_context", "{}.", res.get_error().get());
                    return std::nullopt;
                }
                return res.get();
            },
            py::arg("full_hex"),
            py::arg("slice_hex"),
            py::arg("bit_offset"),
            py::arg("bit_count"),
            R"(
            Splice a new slice value into a full INIT hex string at ``[bit_offset, bit_offset+bit_count)``.
            The output preserves the digit width of ``full_hex``; if ``full_hex`` is empty the minimum width
            needed to hold the splice is used.
 
            :param str full_hex: Current full INIT value as a hex string (may be empty).
            :param str slice_hex: New value for the bit slice.
            :param int bit_offset: First bit (LSB = 0) of the slice.
            :param int bit_count: Number of bits in the slice; must be non-zero.
            :returns: The updated full hex string, or ``None`` on parse failure.
            :rtype: str or None
        )");
 
        py_lut_component.def(
            "get_init_string",
            [](const LUTComponent& self, Gate* gate, const std::string& pin_name) -> std::optional<std::string> {
                auto res = self.get_init_string(gate, pin_name);
                if (res.is_ok())
                {
                    return res.get();
                }
                log_error("python_context", "error getting INIT string: {}", res.get_error().get());
                return std::nullopt;
            },
            py::arg("gate"),
            py::arg("pin_name"),
            R"(
            Get the INIT hex string for a specific LUT output pin on a gate instance.
 
            :param hal_py.Gate gate: The gate instance.
            :param str pin_name: The output pin name.
            :returns: The hex INIT string (no prefix) on success, ``None`` otherwise.
            :rtype: str or None
        )");
 
        py_lut_component.def(
            "get_init_string",
            [](const LUTComponent& self, Gate* gate, GatePin* pin) -> std::optional<std::string> {
                auto res = self.get_init_string(gate, pin);
                if (res.is_ok())
                {
                    return res.get();
                }
                log_error("python_context", "error getting INIT string: {}", res.get_error().get());
                return std::nullopt;
            },
            py::arg("gate"),
            py::arg("pin"),
            R"(
            Get the INIT hex string for a specific LUT output pin on a gate instance.
 
            :param hal_py.Gate gate: The gate instance.
            :param hal_py.GatePin pin: The output pin.
            :returns: The hex INIT string (no prefix) on success, ``None`` otherwise.
            :rtype: str or None
        )");
 
        py_lut_component.def(
            "set_init_string",
            [](const LUTComponent& self, Gate* gate, const std::string& pin_name, const std::string& hex) -> bool {
                auto res = self.set_init_string(gate, pin_name, hex);
                if (res.is_ok())
                {
                    return true;
                }
                log_error("python_context", "error setting INIT string: {}", res.get_error().get());
                return false;
            },
            py::arg("gate"),
            py::arg("pin_name"),
            py::arg("hex"),
            R"(
            Set the INIT hex string for a specific LUT output pin on a gate instance.
 
            :param hal_py.Gate gate: The gate instance.
            :param str pin_name: The output pin name.
            :param str hex: Hex string without prefix.
            :returns: ``True`` on success, ``False`` otherwise.
            :rtype: bool
        )");
 
        py_lut_component.def(
            "set_init_string",
            [](const LUTComponent& self, Gate* gate, GatePin* pin, const std::string& hex) -> bool {
                auto res = self.set_init_string(gate, pin, hex);
                if (res.is_ok())
                {
                    return true;
                }
                log_error("python_context", "error setting INIT string: {}", res.get_error().get());
                return false;
            },
            py::arg("gate"),
            py::arg("pin"),
            py::arg("hex"),
            R"(
            Set the INIT hex string for a specific LUT output pin on a gate instance.
 
            :param hal_py.Gate gate: The gate instance.
            :param hal_py.GatePin pin: The output pin.
            :param str hex: Hex string without prefix.
            :returns: ``True`` on success, ``False`` otherwise.
            :rtype: bool
        )");
 
        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_ram_component.def_property("init_identifiers", &RAMComponent::get_init_identifiers, &RAMComponent::set_init_identifiers, R"(
            The parameter names used to find initialization data for this RAM.
 
            :type: list[str]
        )");
 
        py_ram_component.def("get_init_identifiers", &RAMComponent::get_init_identifiers, R"(
            Get the parameter names used to find initialization data for this RAM.
 
            :returns: The list of init identifier strings.
            :rtype: list[str]
        )");
 
        py_ram_component.def("set_init_identifiers", &RAMComponent::set_init_identifiers, py::arg("init_identifiers"), R"(
            Set the parameter names used to find initialization data for this RAM.
 
            :param list[str] init_identifiers: The list of init identifier strings.
        )");
 
        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