commandport_obj.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 COMMANDPORT_OBJ_HPP
#define COMMANDPORT_OBJ_HPP

#include "refcount.hpp"
#include <utility>

#include "generic_obj.hpp"

#include "conn_binding.hpp"

REF_FORWARD_DECL(commandport_obj);

class commandport_obj : public generic_obj
{
 public:
   using command_type = enum {
      OPERATION = 0, 
      CONDITION, 
      SWITCH,    
      MULTIIF,   
      SELECTOR,  
      ALUSELECTOR,            
      UNBOUNDED,              
      MULTI_UNBOUNDED,        
      MULTI_UNBOUNDED_ENABLE, 
      WRENABLE                
   };

   using data_operation_pair = std::pair<unsigned int, vertex>;
   using transition = std::tuple<vertex, vertex, data_operation_pair>;

 private:
   vertex signal;

   generic_objRef elem;

   unsigned int mode;

   bool is_a_phi_write_enable;

   CustomOrderedSet<transition> activations;

   Wrefcount<structural_object> controller_SM;

 public:
   commandport_obj(const vertex& signal_, unsigned int _mode, const std::string& _name)
       : generic_obj(COMMAND_PORT, _name), signal(signal_), mode(_mode), is_a_phi_write_enable(false)
   {
      THROW_ASSERT(mode == OPERATION or mode == CONDITION or mode == SWITCH or mode == MULTIIF or mode == UNBOUNDED,
                   "Command mode not allowed into this constructor");
   }

   commandport_obj(generic_objRef _elem, unsigned int _mode, const std::string& _name)
       : generic_obj(COMMAND_PORT, _name), elem(_elem), mode(_mode), is_a_phi_write_enable(false)
   {
      THROW_ASSERT(mode == SELECTOR || mode == WRENABLE || mode == ALUSELECTOR or mode == MULTI_UNBOUNDED or
                       mode == MULTI_UNBOUNDED_ENABLE,
                   "Selector port is wrong");
   }

   ~commandport_obj() override = default;

   const vertex& get_vertex() const
   {
      THROW_ASSERT(mode == OPERATION or mode == CONDITION or mode == SWITCH or mode == MULTIIF or mode == UNBOUNDED,
                   "Command mode not allowed");
      return signal;
   }

   unsigned int get_command_type() const
   {
      return mode;
   }

   const CustomOrderedSet<transition>& get_activations() const
   {
      return activations;
   }

   void add_activation(const transition& act)
   {
      activations.insert(act);
   }

   void set_controller_obj(const structural_objectRef& _SM)
   {
      controller_SM = _SM;
   }

   const structural_objectRef get_controller_obj() const
   {
      return controller_SM.lock();
   }

   const generic_objRef& get_elem() const
   {
      THROW_ASSERT(mode == SELECTOR || mode == WRENABLE || mode == ALUSELECTOR || mode == MULTI_UNBOUNDED or
                       mode == MULTI_UNBOUNDED_ENABLE,
                   "Selector port is wrong");
      return elem;
   }

   static const std::string get_mode_string(unsigned int _mode)
   {
      switch(_mode)
      {
         case OPERATION:
            return "OPERATION";
         case CONDITION:
            return "CONDITION";
         case SWITCH:
            return "SWITCH";
         case MULTIIF:
            return "MULTIIF";
         case UNBOUNDED:
            return "UNBOUNDED";
         case MULTI_UNBOUNDED:
            return "MULTI_UNBOUNDED";
         case MULTI_UNBOUNDED_ENABLE:
            return "MULTI_UNBOUNDED_ENABLE";
         case SELECTOR:
            return "SELECTOR";
         case WRENABLE:
            return "WRENABLE";
         default:
            THROW_ERROR("Command mode not allowed for port");
      }
      return "";
   }

   void set_phi_write_enable()
   {
      is_a_phi_write_enable = true;
   }

   bool get_phi_write_enable()
   {
      return is_a_phi_write_enable;
   }
};

#endif