structural_objects.hpp

Go to the documentation of this file.

/*
 *
 *                   _/_/_/    _/_/   _/    _/ _/_/_/    _/_/
 *                  _/   _/ _/    _/ _/_/  _/ _/   _/ _/    _/
 *                 _/_/_/  _/_/_/_/ _/  _/_/ _/   _/ _/_/_/_/
 *                _/      _/    _/ _/    _/ _/   _/ _/    _/
 *               _/      _/    _/ _/    _/ _/_/_/  _/    _/
 *
 *             ***********************************************
 *                              PandA Project
 *                     URL: http://panda.dei.polimi.it
 *                       Politecnico di Milano - DEIB
 *                        System Architectures Group
 *             ***********************************************
 *              Copyright (C) 2004-2024 Politecnico di Milano
 *
 *   This file is part of the PandA framework.
 *
 *   The PandA framework is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
#ifndef STRUCTURAL_OBJECTS_HPP
#define STRUCTURAL_OBJECTS_HPP

#include "config_HAVE_TECHNOLOGY_BUILT.hpp"

#include "NP_functionality.hpp"
#include "custom_map.hpp"
#include "exceptions.hpp"
#include "refcount.hpp"
#include "simple_indent.hpp"

#include <boost/preprocessor/seq/for_each.hpp>
#include <ostream>
#include <string>
#include <utility>
#include <vector>

CONSTREF_FORWARD_DECL(BehavioralHelper);
REF_FORWARD_DECL(structural_manager);
REF_FORWARD_DECL(NP_functionality);
CONSTREF_FORWARD_DECL(structural_object);
REF_FORWARD_DECL(structural_object);
REF_FORWARD_DECL(structural_type_descriptor);
CONSTREF_FORWARD_DECL(technology_manager);
REF_FORWARD_DECL(technology_node);
REF_FORWARD_DECL(attribute);
class xml_element;
class simple_indent;


#define HIERARCHY_SEPARATOR "/"

#define MEMORY_PARAMETER "MEMORY_PARAMETER"
#define PIPE_PARAMETER "PIPE_PARAMETER"
#define VALUE_PARAMETER "VALUE_PARAMETER"

#define CLOCK_PORT_NAME "clock"
#define WENABLE_PORT_NAME "wenable"
#define START_PORT_NAME "start_port"
#define RESET_PORT_NAME "reset"
#define DONE_PORT_NAME "done_port"
#define RETURN_PORT_NAME "return_port"
#define START_PORT_NAME_CFC "start_port_CFC"
#define DONE_PORT_NAME_CFC "done_port_CFC"
#define MOUT_OE_PORT_NAME "Mout_oe_ram"
#define MOUT_BACK_PRESSURE_PORT_NAME "Mout_back_pressure"
#define PRESENT_STATE_PORT_NAME "present_state"
#define NEXT_STATE_PORT_NAME "next_state"
#define NOTIFIER_PORT_MISMATCH "out_mismatch"
#define NOTIFIER_PORT_MISMATCH_ID "out_mismatch_id"
#define NOTIFIER_PORT_MISMATCH_OFFSET "out_mismatch_trace_offset"
#define SELECTOR_REGISTER_FILE "selector_register_file"
#define SUSPENSION "suspension"
#define REQUEST_ACCEPTED "request_accepted"
#define TASKS_POOL_END "task_pool_end"
#define DONE_SCHEDULER "done_scheduler"
#define DONE_REQUEST "done_request"
#define PROXY_PREFIX "PROXY_PREF_"
#define WRAPPED_PROXY_PREFIX "WRAPPED_PROXY_PREF_"

#define GET_SO_KIND_TEXT(meth)                \
   std::string get_kind_text() const override \
   {                                          \
      return std::string(#meth);              \
   }

struct structural_type_descriptor
{
   enum s_type
   {
      OTHER = 0,
      BOOL,
      INT,
      UINT,
      REAL,
      USER,
      VECTOR_BOOL,
      VECTOR_INT,
      VECTOR_UINT,
      VECTOR_REAL,
      VECTOR_USER,
      UNKNOWN
   };

   s_type type;

   unsigned long long size;

   unsigned long long vector_size;

   std::string id_type;

   unsigned int treenode;

   structural_type_descriptor()
       : type(UNKNOWN), size(size_DEFAULT), vector_size(vector_size_DEFAULT), treenode(treenode_DEFAULT)
   {
   }

   structural_type_descriptor(const std::string& type_name, unsigned long long vector_size);

   explicit structural_type_descriptor(const std::string& module_name)
       : type(OTHER),
         size(size_DEFAULT),
         vector_size(vector_size_DEFAULT),
         id_type(module_name),
         treenode(treenode_DEFAULT)
   {
   }

   structural_type_descriptor(unsigned int index, const BehavioralHelperConstRef helper);

   ~structural_type_descriptor() = default;

   void copy(structural_type_descriptorRef dest);

   const std::string get_name() const;

   static bool check_type(structural_type_descriptorRef src_type, structural_type_descriptorRef dest_type);

   void xload(const xml_element* Enode, structural_type_descriptorRef owner);

   void xwrite(xml_element* rootnode);

   void print(std::ostream& os) const;

   std::string get_kind_text() const
   {
      return std::string("structural_type_descriptor");
   }

   friend std::ostream& operator<<(std::ostream& os, const structural_type_descriptorRef o)
   {
      if(o)
      {
         o->print(os);
      }
      return os;
   }

 private:
   static const s_type type_DEFAULT = OTHER;
   static const unsigned int treenode_DEFAULT = 0;
   static const unsigned int size_DEFAULT = 0;
   static const unsigned int vector_size_DEFAULT = 0;
   static const char* s_typeNames[];
};

#define GET_TYPE_NAME(structural_obj) ((structural_obj)->get_typeRef()->id_type)

#define GET_TYPE_SIZE(structural_obj)                                                            \
   ((structural_obj)->get_typeRef()->vector_size ?                                               \
        ((structural_obj)->get_typeRef()->vector_size * (structural_obj)->get_typeRef()->size) : \
        (structural_obj)->get_typeRef()->size)

#define STD_GET_SIZE(structural_obj) \
   ((structural_obj)->vector_size ? ((structural_obj)->vector_size * (structural_obj)->size) : (structural_obj)->size)

using structural_type_descriptorRef = refcount<structural_type_descriptor>;

enum so_kind
{
   component_o_K,
   channel_o_K,
   bus_connection_o_K,
   constant_o_K,
   signal_o_K,
   signal_vector_o_K,
   port_o_K,
   port_vector_o_K,
   event_o_K,
   data_o_K,
   action_o_K
};

#define GET_SO_KIND(meth)                 \
   enum so_kind get_kind() const override \
   {                                      \
      return (meth##_K);                  \
   }

class structural_object
{
   Wrefcount<structural_object> owner;

   std::string id;

   structural_type_descriptorRef type;

   unsigned int treenode;

   bool black_box;

   CustomMap<std::string, std::string> parameters;

   CustomMap<std::string, std::string> default_parameters;

 protected:
   friend structural_manager;

   int debug_level;

   std::string convert_so_short(so_kind in) const;
   static simple_indent PP;

#if HAVE_TECHNOLOGY_BUILT
   std::vector<std::string> attribute_list;

   std::map<std::string, attributeRef> attributes;
#endif

 public:
   structural_object(int debug_level, const structural_objectRef o);

   virtual ~structural_object() = default;

   const structural_objectRef get_owner() const;

   void set_owner(const structural_objectRef new_owner);

   void set_treenode(unsigned int n);

   unsigned int get_treenode() const;

   void set_id(const std::string& s);

   const std::string& get_id() const;

   void set_type(const structural_type_descriptorRef& s);

   const structural_type_descriptorRef& get_typeRef() const;

   void type_resize(unsigned long long new_bit_size);

   void type_resize(unsigned long long new_bit_size, unsigned long long new_vec_size);
   void set_black_box(bool bb);

   bool get_black_box() const;

   void SetParameter(const std::string& name, const std::string& value);

   bool ExistsParameter(std::string name) const;

   std::string GetParameter(std::string name) const;

   std::string GetDefaultParameter(std::string name) const;

   CustomMap<std::string, std::string> GetParameters() const;

   virtual void AddParameter(const std::string& name, const std::string& default_value);

   const std::string get_path() const;

   virtual void copy(structural_objectRef dest) const;

   virtual structural_objectRef find_member(const std::string& id, so_kind type,
                                            const structural_objectRef owner) const = 0;

   virtual structural_objectRef find_isomorphic(const structural_objectRef key) const = 0;

   virtual void xload(const xml_element* Enode, structural_objectRef owner, structural_managerRef const& CM);

   virtual void xwrite(xml_element* Enode);

#if HAVE_TECHNOLOGY_BUILT

   virtual void xwrite_attributes(xml_element* rootnode, const technology_nodeRef& tn = technology_nodeRef());
#endif

   virtual void print(std::ostream& os) const;

   friend std::ostream& operator<<(std::ostream& os, const structural_objectRef o)
   {
      if(o)
      {
         o->print(os);
      }
      return os;
   }

   virtual std::string get_kind_text() const = 0;
   virtual enum so_kind get_kind() const = 0;

#if HAVE_TECHNOLOGY_BUILT
   void add_attribute(const std::string& name, const attributeRef& attribute);

   attributeRef get_attribute(const std::string& name) const;

   const std::vector<std::string>& get_attribute_list() const;
#endif

 private:
   static const unsigned int treenode_DEFAULT = 0;
   static const bool black_box_DEFAULT = true;
};

using structural_objectRef = refcount<structural_object>;

#define ENUM_ID(r, data, elem) elem,
#define PORT_INTERFACE_ENUM                                                                                            \
   (PI_RNONE)(PI_WNONE)(PI_RACK)(PI_WACK)(PI_RVALID)(PI_WVALID)(PI_EMPTY_N)(PI_READ)(PI_FULL_N)(PI_WRITE)(PI_FDIN)(    \
       PI_FDOUT)(PI_ADDRESS)(PI_CHIPENABLE)(PI_WRITEENABLE)(PI_DIN)(PI_DOUT)(PI_M_AXI_OFF)(PI_M_AXI_DIRECT)(           \
       M_AXI_AWVALID)(M_AXI_AWREADY)(M_AXI_AWADDR)(M_AXI_AWID)(M_AXI_AWLEN)(M_AXI_AWSIZE)(M_AXI_AWBURST)(              \
       M_AXI_AWLOCK)(M_AXI_AWCACHE)(M_AXI_AWPROT)(M_AXI_AWQOS)(M_AXI_AWREGION)(M_AXI_AWUSER)(M_AXI_WVALID)(            \
       M_AXI_WREADY)(M_AXI_WDATA)(M_AXI_WSTRB)(M_AXI_WLAST)(M_AXI_WID)(M_AXI_WUSER)(M_AXI_ARVALID)(M_AXI_ARREADY)(     \
       M_AXI_ARADDR)(M_AXI_ARID)(M_AXI_ARLEN)(M_AXI_ARSIZE)(M_AXI_ARBURST)(M_AXI_ARLOCK)(M_AXI_ARCACHE)(M_AXI_ARPROT)( \
       M_AXI_ARQOS)(M_AXI_ARREGION)(M_AXI_ARUSER)(M_AXI_RVALID)(M_AXI_RREADY)(M_AXI_RDATA)(M_AXI_RLAST)(M_AXI_RID)(    \
       M_AXI_RUSER)(M_AXI_RRESP)(M_AXI_BVALID)(M_AXI_BREADY)(M_AXI_BRESP)(M_AXI_BID)(M_AXI_BUSER)(S_AXIL_AWVALID)(     \
       S_AXIL_AWREADY)(S_AXIL_AWADDR)(S_AXIL_WVALID)(S_AXIL_WREADY)(S_AXIL_WDATA)(S_AXIL_WSTRB)(S_AXIL_ARVALID)(       \
       S_AXIL_ARREADY)(S_AXIL_ARADDR)(S_AXIL_RVALID)(S_AXIL_RREADY)(S_AXIL_RDATA)(S_AXIL_RRESP)(S_AXIL_BVALID)(        \
       S_AXIL_BREADY)(S_AXIL_BRESP)(PI_S_AXIS_TVALID)(PI_S_AXIS_TREADY)(PI_S_AXIS_TDATA)(PI_M_AXIS_TVALID)(            \
       PI_M_AXIS_TREADY)(PI_M_AXIS_TDATA)(PI_DEFAULT)

#define PORT_DIRECTION_ENUM (IN)(OUT)(IO)(GEN)(UNKNOWN)(TLM_IN)(TLM_OUT)(TLM_INOUT)

struct port_o : public structural_object
{
 public:
   enum port_direction
   {
      BOOST_PP_SEQ_FOR_EACH(ENUM_ID, BOOST_PP_EMPTY, PORT_DIRECTION_ENUM)
   };

   static std::string GetString(enum port_direction);

   enum port_endianess
   {
      LITTLE = 0,
      BIG,
      NONE
   };

   enum port_interface : int
   {
      BOOST_PP_SEQ_FOR_EACH(ENUM_ID, BOOST_PP_EMPTY, PORT_INTERFACE_ENUM)
   };

   static std::string GetString(enum port_interface);

   static const unsigned int PARAMETRIC_PORT = static_cast<unsigned int>(-1);

   static port_direction to_port_direction(const std::string& val);

   static port_interface to_port_interface(const std::string& val);

   port_o(int debug_level, const structural_objectRef o, port_direction dir, so_kind _port_type);

   ~port_o() override = default;

   std::string size_parameter;

   void add_connection(structural_objectRef s);

   void remove_connection(structural_objectRef s);

   bool is_connected(structural_objectRef s) const;

   void substitute_connection(structural_objectRef old_conn, structural_objectRef new_conn);

   const structural_objectRef get_connection(unsigned int n) const;

   unsigned int get_connections_size() const;

   port_direction get_port_direction() const;

   void set_port_direction(port_direction dir);

   port_endianess get_port_endianess() const;

   void set_port_endianess(port_endianess end);

   port_interface get_port_interface() const;

   void set_port_interface(port_interface pi);

   unsigned int get_port_alignment() const;

   void set_port_alignment(unsigned int algn);

   structural_objectRef get_connected_signal() const;

   void set_port_size(unsigned int dim);

   unsigned long long get_port_size() const;

   void set_is_var_args(bool c);
   bool get_is_var_args() const;

   void set_is_clock(bool c);
   bool get_is_clock() const;

   void set_is_extern(bool c);
   bool get_is_extern() const;

   void set_bus_bundle(const std::string& name);

   std::string get_bus_bundle() const;

   void set_is_global(bool c);
   bool get_is_global() const;

   void set_is_memory(bool c);
   bool get_is_memory() const;

   void set_is_slave(bool c);
   bool get_is_slave() const;

   void set_is_master(bool c);
   bool get_is_master() const;

   void set_is_data_bus(bool c);

   bool get_is_data_bus() const;

   void set_is_addr_bus(bool c);

   bool get_is_addr_bus() const;

   void set_is_size_bus(bool c);

   bool get_is_size_bus() const;

   void set_is_tag_bus(bool c);

   bool get_is_tag_bus() const;

   void set_is_doubled(bool c);

   bool get_is_doubled() const;

   void set_is_halved(bool c);

   bool get_is_halved() const;

   structural_objectRef
   find_bounded_object(const structural_objectConstRef f_owner = structural_objectConstRef()) const;

   void set_critical();

   bool get_critical() const;

   void set_reverse();

   bool get_reverse() const;

   void copy(structural_objectRef dest) const override;

   structural_objectRef find_member(const std::string& id, so_kind type,
                                    const structural_objectRef owner) const override;

   structural_objectRef find_isomorphic(const structural_objectRef key) const override;

   void xload(const xml_element* Enode, structural_objectRef owner, structural_managerRef const& CM) override;

   void xwrite(xml_element* rootnode) override;

#if HAVE_TECHNOLOGY_BUILT

   void xwrite_attributes(xml_element* rootnode, const technology_nodeRef& tn = technology_nodeRef()) override;
#endif

   void add_n_ports(unsigned int n_ports, structural_objectRef owner);

   const structural_objectRef get_port(unsigned int n) const;

   unsigned int get_ports_size() const;

   unsigned int get_lsb() const
   {
      return lsb;
   }

   static bool resize_if_busport(unsigned long long bus_size_bitsize, unsigned long long bus_addr_bitsize,
                                 unsigned long long bus_data_bitsize, unsigned long long bus_tag_bitsize,
                                 structural_objectRef port);

   static void resize_std_port(unsigned long long bitsize_variable, unsigned long long n_elements, int debug_level,
                               structural_objectRef port);

   static void fix_port_properties(structural_objectRef port_i, structural_objectRef cir_port);

   void print(std::ostream& os) const override;

   std::string get_kind_text() const override
   {
      if(port_type == port_vector_o_K)
      {
         return "port_vector_o";
      }
      else
      {
         return "port_o";
      }
   }
   enum so_kind get_kind() const override
   {
      return port_type;
   }

 private:
   std::vector<Wrefcount<structural_object>> connected_objects;

   port_direction dir;

   port_endianess end;

   port_interface pi;

   unsigned int aligment;

   bool is_var_args;

   bool is_clock;

   bool is_extern;

   bool is_global;

   bool is_reverse;

   bool is_memory;

   bool is_slave;

   bool is_master;

   bool is_data_bus;

   bool is_addr_bus;

   bool is_size_bus;

   bool is_tag_bus;

   bool is_doubled;

   bool is_halved;

   bool is_critical;

   std::string bus_bundle;

   unsigned int lsb;

   std::vector<structural_objectRef> ports;

   so_kind port_type;

   static const bool is_clock_DEFAULT = false;
   static const bool is_extern_DEFAULT = false;
   static const bool is_global_DEFAULT = false;
   static const bool is_memory_DEFAULT = false;
   static const bool is_slave_DEFAULT = false;
   static const bool is_master_DEFAULT = false;
   static const bool is_data_bus_DEFAULT = false;
   static const bool is_addr_bus_DEFAULT = false;
   static const bool is_tag_bus_DEFAULT = false;
   static const bool is_size_bus_DEFAULT = false;
   static const bool is_doubled_DEFAULT = false;
   static const bool is_halved_DEFAULT = false;
   static const bool is_critical_DEFAULT = false;
   static const bool is_reverse_DEFAULT = false;
   static const bool is_var_args_DEFAULT = false;
   static const unsigned port_interface_alignment_DEFAULT = 0;
};

class event_o : public structural_object
{
 public:
   event_o(int debug_level, const structural_objectRef o);

   ~event_o() override = default;

   void copy(structural_objectRef dest) const override;

   structural_objectRef find_member(const std::string& id, so_kind type,
                                    const structural_objectRef owner) const override;

   structural_objectRef find_isomorphic(const structural_objectRef key) const override;

   void xload(const xml_element* Enode, structural_objectRef owner, structural_managerRef const& CM) override;

   void xwrite(xml_element* rootnode) override;

   void print(std::ostream& os) const override;

   GET_SO_KIND_TEXT(event_o)
   GET_SO_KIND(event_o)
};

class data_o : public structural_object
{
 public:
   data_o(int debug_level, const structural_objectRef o);

   ~data_o() override = default;

   void copy(structural_objectRef dest) const override;

   structural_objectRef find_member(const std::string& id, so_kind type,
                                    const structural_objectRef owner) const override;

   structural_objectRef find_isomorphic(const structural_objectRef key) const override;

   void xload(const xml_element* Enode, structural_objectRef owner, structural_managerRef const& CM) override;

   void xwrite(xml_element* rootnode) override;

   void print(std::ostream& os) const override;

   GET_SO_KIND_TEXT(data_o)
   GET_SO_KIND(data_o)
};

class action_o : public structural_object
{
 public:
   enum process_type
   {
      THREAD = 0,
      CTHREAD,
      METHOD,
      SERVICE,
      UNKNOWN
   };

 private:
   std::vector<structural_objectRef> parameters;

   unsigned int function_id;

   process_type action_type;

   std::vector<structural_objectRef> action_sensitivity;

   std::string scope;

 public:
   action_o(int debug_level, const structural_objectRef o);

   ~action_o() override = default;

   void add_parameter(structural_objectRef d);

   const structural_objectRef get_parameter(unsigned int n) const;

   unsigned int get_parameters_size() const;

   void set_fun_id(unsigned int id);

   unsigned int get_fun_id() const;

   void set_action_type(process_type at);

   process_type get_action_type() const;

   void add_event_to_sensitivity(structural_objectRef e);

   unsigned int get_sensitivity_size() const;

   const structural_objectRef get_sensitivity(unsigned int n) const;

   void set_scope(const std::string& sc);

   const std::string& get_scope() const;

   bool get_process_nservice() const;

   void copy(structural_objectRef dest) const override;

   structural_objectRef find_member(const std::string& id, so_kind type,
                                    const structural_objectRef owner) const override;

   structural_objectRef find_isomorphic(const structural_objectRef key) const override;

   void xload(const xml_element* Enode, structural_objectRef owner, structural_managerRef const& CM) override;

   void xwrite(xml_element* rootnode) override;

   void print(std::ostream& os) const override;

   GET_SO_KIND_TEXT(action_o)
   GET_SO_KIND(action_o)

 private:
   static const char* process_typeNames[];
};

class constant_o : public structural_object
{
   std::string value;

   std::vector<Wrefcount<structural_object>> connected_objects;

 public:
   constant_o(int debug_level, const structural_objectRef o);

   constant_o(int debug_level, const structural_objectRef o, std::string value);

   ~constant_o() override = default;

   void add_connection(structural_objectRef p);

   structural_objectRef get_connection(unsigned int idx) const;

   unsigned int get_connected_objects_size() const;

   unsigned long long get_size() const;

   std::string get_value() const;

   void copy(structural_objectRef dest) const override;

   structural_objectRef find_member(const std::string& id, so_kind type,
                                    const structural_objectRef owner) const override;

   structural_objectRef find_isomorphic(const structural_objectRef key) const override;

   void xload(const xml_element* Enode, structural_objectRef owner, structural_managerRef const& CM) override;

   void xwrite(xml_element* rootnode) override;

   void print(std::ostream& os) const override;

   GET_SO_KIND_TEXT(constant_o)
   GET_SO_KIND(constant_o)
};

class signal_o : public structural_object
{
 public:
   static const unsigned int PARAMETRIC_SIGNAL = static_cast<unsigned int>(-1);

   signal_o(int debug_level, const structural_objectRef o, so_kind _signal_type);

   ~signal_o() override = default;

   void add_port(structural_objectRef p);

   void remove_port(structural_objectRef s);

   bool is_connected(structural_objectRef s) const;

   void substitute_port(structural_objectRef old_conn, structural_objectRef new_conn);

   void set_critical();

   bool get_critical() const;

   const structural_objectRef get_port(unsigned int n) const;

   structural_objectRef get_port(unsigned int n);

   unsigned int get_connected_objects_size() const;

   bool is_full_connected() const;

   void add_n_signals(unsigned int n_signals, structural_objectRef owner);

   const structural_objectRef get_signal(unsigned int n) const;

   const structural_objectRef get_positional_signal(unsigned int n) const;

   unsigned int get_signals_size() const;

   unsigned int get_lsb() const
   {
      return lsb;
   }

   void copy(structural_objectRef dest) const override;

   structural_objectRef find_member(const std::string& id, so_kind type,
                                    const structural_objectRef owner) const override;

   structural_objectRef find_isomorphic(const structural_objectRef key) const override;

   void xload(const xml_element* Enode, structural_objectRef owner, structural_managerRef const& CM) override;

   void xwrite(xml_element* rootnode) override;

   void print(std::ostream& os) const override;

   std::string get_kind_text() const override
   {
      if(signal_type == signal_vector_o_K)
      {
         return "signal_vector_o";
      }
      else
      {
         return "signal_o";
      }
   }
   enum so_kind get_kind() const override
   {
      return signal_type;
   }

 private:
   std::vector<Wrefcount<structural_object>> connected_objects;

   bool is_critical;

   std::vector<structural_objectRef> signals_;

   unsigned int lsb;

   so_kind signal_type;
};

class module : public structural_object
{
   std::vector<structural_objectRef> in_ports;

   std::vector<structural_objectRef> out_ports;

   std::vector<structural_objectRef> in_out_ports;

   std::vector<structural_objectRef> gen_ports;

   std::vector<structural_objectRef> internal_objects;

   std::vector<structural_objectRef> local_data;

   std::vector<structural_objectRef> list_of_event;

   std::vector<structural_objectRef> list_of_process;

   std::vector<structural_objectRef> list_of_service;

   NP_functionalityRef NP_descriptions;

   unsigned int last_position_port;

   bool is_critical;

   bool is_generated;

   std::map<unsigned int, structural_objectRef> positional_map;

   std::map<std::string, structural_objectRef> index_signals;

   std::map<std::string, structural_objectRef> index_constants;

   std::map<std::string, structural_objectRef> index_components;

   std::map<std::string, structural_objectRef> index_channels;

   std::map<std::string, structural_objectRef> index_bus_connections;

   std::string description;

   std::string copyright;

   std::string authors;

   std::string license;

   std::string specialized;

   unsigned int multi_unit_multiplicity;

   bool keep_hierarchy;

 public:
   module(int debug_level, const structural_objectRef o);

   ~module() override = default;

   unsigned int get_num_ports() const;

   structural_objectRef get_positional_port(unsigned int index) const;

   void add_in_port(structural_objectRef p);

   const structural_objectRef get_in_port(unsigned int n) const;

   unsigned int get_in_port_size() const;

   void add_out_port(structural_objectRef p);

   const structural_objectRef get_out_port(unsigned int n) const;

   unsigned int get_out_port_size() const;

   void add_in_out_port(structural_objectRef p);

   const structural_objectRef get_in_out_port(unsigned int n) const;

   unsigned int get_in_out_port_size() const;

   void add_gen_port(structural_objectRef p);

   const structural_objectRef get_gen_port(unsigned int n) const;

   unsigned int get_gen_port_size() const;

   void remove_port(const std::string& id);

   void add_internal_object(structural_objectRef c);

   void remove_internal_object(structural_objectRef s);

   const structural_objectRef get_internal_object(unsigned int n) const;

   unsigned int get_internal_objects_size() const;

   void add_process(structural_objectRef p);

   const structural_objectRef get_process(unsigned int n) const;

   unsigned int get_process_size() const;

   void add_service(structural_objectRef p);

   const structural_objectRef get_service(unsigned int n) const;

   unsigned int get_service_size() const;

   void add_event(structural_objectRef e);

   const structural_objectRef get_event(unsigned int n) const;

   unsigned int get_event_size() const;

   void add_local_data(structural_objectRef d);

   const structural_objectRef get_local_data(unsigned int n) const;

   unsigned int get_local_data_size() const;

   void set_NP_functionality(NP_functionalityRef f);

   const NP_functionalityRef& get_NP_functionality() const;

   void get_NP_library_parameters(structural_objectRef owner,
                                  std::vector<std::pair<std::string, structural_objectRef>>& parameters) const;

   void copy(structural_objectRef dest) const override;

   structural_objectRef find_member(const std::string& id, so_kind type,
                                    const structural_objectRef owner) const override;

   structural_objectRef find_isomorphic(const structural_objectRef key) const override;

   void xload(const xml_element* Enode, structural_objectRef owner, structural_managerRef const& CM) override = 0;

#if HAVE_TECHNOLOGY_BUILT

   void xwrite_attributes(xml_element* rootnode, const technology_nodeRef& tn = technology_nodeRef()) override = 0;
#endif

   void xwrite(xml_element* rootnode) override = 0;

   bool is_var_args() const;

   void print(std::ostream& os) const override;

   void set_critical();

   bool get_critical() const;

   void set_generated();

   bool get_generated() const;

   void set_multi_unit_multiplicity(unsigned int value);

   unsigned int get_multi_unit_multiplicity() const;

   void set_keep_hierarchy(bool ky);

   bool get_keep_hierarchy() const;

   void change_port_direction(structural_objectRef port, port_o::port_direction pdir);

   const std::string get_description() const
   {
      return description;
   }

   void set_description(const std::string& d)
   {
      description = d;
   }

   const std::string get_copyright() const
   {
      return copyright;
   }

   void set_copyright(const std::string& c)
   {
      copyright = c;
   }

   const std::string get_authors() const
   {
      return authors;
   }

   void set_authors(const std::string& a)
   {
      authors = a;
   }

   const std::string get_license() const
   {
      return license;
   }

   void set_license(const std::string& l)
   {
      license = l;
   }

   const std::string get_specialized() const
   {
      return specialized;
   }

   void set_specialized(const std::string& s)
   {
      specialized = s;
   }

#if HAVE_TECHNOLOGY_BUILT

   structural_type_descriptor::s_type get_parameter_type(const technology_managerConstRef TM,
                                                         const std::string& name) const;

   structural_objectRef get_generic_object(const technology_managerConstRef TM) const;
#endif

   void AddParameter(const std::string& name, const std::string& default_value) override;
};

class component_o : public module
{
 public:
   component_o(int debug_level, const structural_objectRef o);

   ~component_o() override = default;

   void copy(structural_objectRef dest) const override;

   structural_objectRef find_member(const std::string& id, so_kind type,
                                    const structural_objectRef owner) const override;

   structural_objectRef find_isomorphic(const structural_objectRef key) const override;

   void xload(const xml_element* Enode, structural_objectRef owner, structural_managerRef const& CM) override;

   void xwrite(xml_element* rootnode) override;

#if HAVE_TECHNOLOGY_BUILT

   void xwrite_attributes(xml_element* rootnode, const technology_nodeRef& tn = technology_nodeRef()) override;
#endif

   void print(std::ostream& os) const override;

   GET_SO_KIND_TEXT(component_o)
   GET_SO_KIND(component_o)
};

class channel_o : public module
{
   std::map<unsigned int, std::string> impl_interfaces;

   std::vector<Wrefcount<structural_object>> connected_objects;

 public:
   channel_o(int debug_level, const structural_objectRef o);

   ~channel_o() override = default;

   void add_interface(unsigned int t, const std::string& _interface);

   const std::string& get_interface(unsigned int t) const;

   void add_port(structural_objectRef p);

   const structural_objectRef get_port(unsigned int n) const;

   unsigned int get_connected_objects_size() const;

   void copy(structural_objectRef dest) const override;

   structural_objectRef find_member(const std::string& id, so_kind type,
                                    const structural_objectRef owner) const override;

   structural_objectRef find_isomorphic(const structural_objectRef key) const override;

   void xload(const xml_element* Enode, structural_objectRef owner, structural_managerRef const& CM) override;

   void xwrite(xml_element* rootnode) override;

#if HAVE_TECHNOLOGY_BUILT

   void xwrite_attributes(xml_element* rootnode, const technology_nodeRef& tn = technology_nodeRef()) override;
#endif

   void print(std::ostream& os) const override;

   GET_SO_KIND_TEXT(channel_o)
   GET_SO_KIND(channel_o)
};

class bus_connection_o : public structural_object
{
   std::vector<Wrefcount<structural_object>> connections;

 public:
   bus_connection_o(int debug_level, const structural_objectRef o);

   ~bus_connection_o() override = default;

   void add_connection(structural_objectRef c);

   const structural_objectRef get_connection(unsigned int n) const;

   unsigned int get_connections_size() const;

   void copy(structural_objectRef dest) const override;

   structural_objectRef find_member(const std::string& id, so_kind type,
                                    const structural_objectRef owner) const override;

   structural_objectRef find_isomorphic(const structural_objectRef key) const override;

   void xload(const xml_element* Enode, structural_objectRef owner, structural_managerRef const& CM) override;

   void xwrite(xml_element* rootnode) override;

   void print(std::ostream& os) const override;

   GET_SO_KIND_TEXT(bus_connection_o)
   GET_SO_KIND(bus_connection_o)
};

#endif