structural_manager.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_MANAGER_HPP
#define STRUCTURAL_MANAGER_HPP

#include "config_HAVE_EUCALYPTUS_BUILT.hpp"

#include "NP_functionality.hpp"
#include "graph.hpp"
#include "refcount.hpp"
#include "structural_objects.hpp"
#include <iosfwd> // for ostream
#include <string>

#define TREENODE_CHECK (-1)

REF_FORWARD_DECL(structural_object);
CONSTREF_FORWARD_DECL(technology_manager);
REF_FORWARD_DECL(tree_manager);
CONSTREF_FORWARD_DECL(Parameter);
REF_FORWARD_DECL(technology_manager);
REF_FORWARD_DECL(technology_node);
struct graphs_collection;
struct graph;
class xml_element;

class structural_manager
{
 public:
   // no copy constructor
   structural_manager(const structural_manager& inst) = delete;

   enum circuit_graph_type
   {
      DATA_G,
      COMPLETE_G
   };

 private:
   const ParameterConstRef Param;

   int debug_level;

   graphs_collection* og;
   graph* data_graph;
   graph* circuit_graph;

   structural_objectRef circuit;

   bool check_type(structural_objectRef src_type, structural_objectRef dest_type);
   bool check_bound(structural_objectRef src, structural_objectRef sign);

   void check_structure(structural_objectRef obj, bool permissive = false);

   void build_graph(const structural_objectRef& top, graphs_collection* bg);

 public:
   explicit structural_manager(const ParameterConstRef Param);

   void set_top_info(const std::string& id, const technology_managerRef& LM, const std::string& Library = "");

   ~structural_manager();

   static bool check_object(std::string id, structural_objectRef owner, so_kind type);

   // structural_objectRef getc_object(const structural_objectRef &o_tn, int tn) const;

   void set_top_info(std::string id, structural_type_descriptorRef module_type, unsigned int treenode = 0);
   structural_objectRef create(std::string id, so_kind ctype, structural_objectRef owner,
                               structural_type_descriptorRef obj_type, unsigned int treenode = 0);

   structural_objectRef add_module_from_technology_library(const std::string& id, const std::string& fu_name,
                                                           const std::string& library_name,
                                                           const structural_objectRef owner,
                                                           const technology_managerConstRef TM);

   void remove_module(structural_objectRef obj);

   void remove_connection(structural_objectRef src, structural_objectRef dest);

   void change_connection(structural_objectRef old_obj, structural_objectRef new_obj, structural_objectRef owner);

   static structural_objectRef add_port(const std::string& id, port_o::port_direction pdir, structural_objectRef owner,
                                        structural_type_descriptorRef type_descr, unsigned int treenode = 0);

   static void change_port_direction(structural_objectRef port_object, port_o::port_direction pdir,
                                     structural_objectRef owner);

   static structural_objectRef add_port_vector(std::string id, port_o::port_direction pdir, unsigned int n_ports,
                                               structural_objectRef owner, structural_type_descriptorRef type_descr,
                                               unsigned int treenode = 0);
   static structural_objectRef add_sign(std::string id, structural_objectRef owner,
                                        structural_type_descriptorRef sign_type, unsigned int treenode = 0);

   static structural_objectRef add_sign_vector(std::string id, unsigned int n_signs, structural_objectRef owner,
                                               structural_type_descriptorRef sign_type, unsigned int treenode = 0);

   void remove_empty_signal(structural_objectRef& signal);

   void reconnect_signal_member(structural_objectRef& member, structural_objectRef& from_signal,
                                structural_objectRef& to_signal);

   structural_objectRef add_constant(std::string id, structural_objectRef owner, structural_type_descriptorRef type,
                                     std::string value, unsigned int treenode = 0);

   static void add_NP_functionality(structural_objectRef cir, NP_functionality::NP_functionaly_type dt,
                                    std::string functionality_description);

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

   void add_sensitivity(structural_objectRef obj, structural_objectRef pr);
   void add_connection(structural_objectRef src, structural_objectRef dest);

   void print(std::ostream& os) const;
   void WriteDot(const std::string& file_name, circuit_graph_type gt, graph* g = nullptr) const;

   const structural_objectRef get_circ() const
   {
      return circuit;
   }

   static void xload(const xml_element* node, structural_managerRef const& CM);
   void xwrite(xml_element* rootnode, const technology_nodeRef& tn = technology_nodeRef()) const;

   friend std::ostream& operator<<(std::ostream& os, const structural_manager& s)
   {
      s.print(os);
      return os;
   }
   friend std::ostream& operator<<(std::ostream& os, const structural_managerRef s)
   {
      if(s)
      {
         s->print(os);
      }
      return os;
   }
   const vertex& get_PI(structural_objectRef level) const;

   void INIT(bool permissive = false);

   int get_debug_level() const
   {
      return debug_level;
   }
};

using structural_managerRef = refcount<structural_manager>;

#endif