SingleThreadAnalogMsgDispatcher.cpp

Go to the documentation of this file.

#include "SingleThreadAnalogMsgDispatcher.h"

#include <iostream>
using std::cerr;
using std::endl;

using std::make_pair;



SingleThreadAnalogMsgDispatcher::SingleThreadAnalogMsgDispatcher()
{
    initialized = false;
    port2port_msg_sources_positions = new port_msg_sources_positions_type;
    field2port_msg_sources_positions = new field_msg_sources_positions_type;
    port2field_msg_sources_positions = new port_msg_sources_positions_type;
    field2field_msg_sources_positions = new field_msg_sources_positions_type;
}

SingleThreadAnalogMsgDispatcher::~SingleThreadAnalogMsgDispatcher()
{
    if (!initialized) {
        delete port2port_msg_sources_positions;
        delete port2field_msg_sources_positions;
        delete field2port_msg_sources_positions;
        delete field2field_msg_sources_positions;
    }
}

void SingleThreadAnalogMsgDispatcher::dispatchAnalogMsgs()
{
    //cerr << "Invoked dispatch analog msgs" << endl;
    // Dispatch the port -> port messages
    port_msg_sources_type::const_iterator p2p_src_it;
    port_msg_destinations_type::const_iterator p2p_dest_it = port2port_msg_destinations.begin();
    for (p2p_src_it = port2port_msg_sources.begin(); p2p_src_it != port2port_msg_sources.end();
            ++p2p_src_it, ++p2p_dest_it) {
        vector< pair< SimObject *,analog_port_id_t> >::const_iterator p2p_dest_it_2;
        for (p2p_dest_it_2 = p2p_dest_it->begin(); p2p_dest_it_2 != p2p_dest_it->end(); ++p2p_dest_it_2) {
            double v = p2p_src_it->first->getAnalogOutput(p2p_src_it->second);
            p2p_dest_it_2->first->setAnalogInput(v, p2p_dest_it_2->second);
        }
    }

    // Dispatch field -> port messages

    //  cerr << "dispatch field -> port messages" << endl;
    field_msg_sources_type::const_iterator f2p_src_it;
    port_msg_destinations_type::const_iterator f2p_dest_it = field2port_msg_destinations.begin();
    for (f2p_src_it = field2port_msg_sources.begin(); f2p_src_it != field2port_msg_sources.end();
            ++f2p_src_it, ++f2p_dest_it) {
        vector< pair<SimObject *,analog_port_id_t> >::const_iterator f2p_dest_it_2;
        for (f2p_dest_it_2 = f2p_dest_it->begin(); f2p_dest_it_2 != f2p_dest_it->end(); ++f2p_dest_it_2) {              
            f2p_dest_it_2->first->setAnalogInput(Field::getValue(f2p_src_it->first, f2p_src_it->second), f2p_dest_it_2->second);
        }
    }

    //  cerr << "dispatch port->field messages" << endl;
    // Dispatch port -> field messages
    port_msg_sources_type::const_iterator p2f_src_it;
    field_msg_destinations_type::const_iterator p2f_dest_it = port2field_msg_destinations.begin();
    for (p2f_src_it = port2field_msg_sources.begin(); p2f_src_it != port2field_msg_sources.end();
            ++p2f_src_it, ++p2f_dest_it) {
        vector< pair<void *, Field::ValueType > >::const_iterator p2f_dest_it_2;
        for (p2f_dest_it_2 = p2f_dest_it->begin(); p2f_dest_it_2 != p2f_dest_it->end(); ++p2f_dest_it_2)
            Field::setValue(p2f_dest_it_2->first, p2f_dest_it_2->second, p2f_src_it->first->getAnalogOutput(p2f_src_it->second));
    }

    //  cerr << "dispatch field->field messages" << endl;
    // Dispatch field -> field messages
    field_msg_sources_type::const_iterator f2f_src_it;
    field_msg_destinations_type::const_iterator f2f_dest_it = field2field_msg_destinations.begin();
    for (f2f_src_it = field2field_msg_sources.begin(); f2f_src_it != field2field_msg_sources.end();
            ++f2f_src_it, ++f2f_dest_it) {
        vector< pair<void *, Field::ValueType> >::const_iterator f2f_dest_it_2;
        for (f2f_dest_it_2 = f2f_dest_it->begin(); f2f_dest_it_2 != f2f_dest_it->end(); ++f2f_dest_it_2)
            Field::setValue(f2f_dest_it_2->first, f2f_dest_it_2->second, Field::getValue(f2f_src_it->first, f2f_src_it->second));
    }
}

void SingleThreadAnalogMsgDispatcher::addAnalogMessage(SimObject *src, analog_port_id_t src_port, SimObject *dest, analog_port_id_t dest_port)
{
    port_msg_sources_positions_type::const_iterator src_pos_it;
    pair< SimObject *, analog_port_id_t> src_pair(src, src_port);
    int position;
    if ( (src_pos_it = port2port_msg_sources_positions->find(src_pair))
            != port2port_msg_sources_positions->end()) {
        position = src_pos_it->second;
    } else {
        position = port2port_msg_sources.size() ;
        port2port_msg_destinations.push_back( vector< pair< SimObject *, analog_port_id_t> >());
        port2port_msg_sources.push_back(src_pair);
        port2port_msg_sources_positions->insert(make_pair(src_pair, position));
    }    
    port2port_msg_destinations[position].push_back(make_pair(dest,dest_port));
}

void SingleThreadAnalogMsgDispatcher::addAnalogMessage(SimObject *src, analog_port_id_t src_port, SimObject *dest, string destfield)
{
        const Field * dest_field = dest->findField(destfield);
    port_msg_sources_positions_type::const_iterator src_pos_it;
    pair< SimObject *,analog_port_id_t> src_pair(src, src_port);
    int position;
    if ( (src_pos_it = port2field_msg_sources_positions->find(src_pair))
            != port2field_msg_sources_positions->end()) {
        position = src_pos_it->second;
    } else {
        position = port2field_msg_sources.size();
        port2field_msg_destinations.push_back( vector< pair< void *, Field::ValueType > >());        
        port2field_msg_sources.push_back(src_pair);
        port2field_msg_sources_positions->insert(make_pair(src_pair, position));
    }
    port2field_msg_destinations[position].push_back( make_pair(dest_field->getPtr(dest), dest_field->getType()));
    
}

void SingleThreadAnalogMsgDispatcher::addAnalogMessage(SimObject *src, string srcfield, SimObject *dest, analog_port_id_t dest_port)
{
        const Field * src_field = src->findField(srcfield);
    field_msg_sources_positions_type::const_iterator src_pos_it;    
    void *src_ptr = src_field->getPtr(src);
    int position;
    if ( (src_pos_it = field2port_msg_sources_positions->find(src_ptr))
            != field2port_msg_sources_positions->end()) {
        position = src_pos_it->second;
    } else {
        position = field2port_msg_sources.size();
        field2port_msg_sources.push_back(make_pair(src_ptr, src_field->getType()));        
        field2port_msg_destinations.push_back( vector< pair<SimObject *,analog_port_id_t> >());
        field2port_msg_sources_positions->insert(make_pair(src_ptr,position));
    }
    field2port_msg_destinations[position].push_back(make_pair(dest,dest_port));
}

void SingleThreadAnalogMsgDispatcher::addAnalogMessage(SimObject *src, string srcfield, SimObject *dest, string destfield)
{
        const Field * src_field = src->findField(srcfield);
        const Field * dest_field = dest->findField(destfield);
    field_msg_sources_positions_type::const_iterator src_pos_it;
    void *src_ptr =  src_field->getPtr(src);
    int position;
    if ( (src_pos_it = field2field_msg_sources_positions->find(src_ptr))
            != field2field_msg_sources_positions->end()) {
        position = src_pos_it->second;
    } else {
        position = field2field_msg_sources.size();
        field2field_msg_sources_positions->insert(make_pair(src_ptr, position));
        field2field_msg_sources.push_back(make_pair(src_ptr, src_field->getType()));
        field2field_msg_destinations.push_back( vector< pair< void *, Field::ValueType > >());
    }
    field2field_msg_destinations[position].push_back(make_pair(dest_field->getPtr(dest),dest_field->getType()));
}

void SingleThreadAnalogMsgDispatcher::initialize()
{
    if (!initialized) {
        initialized = true;
        delete port2port_msg_sources_positions;
        delete port2field_msg_sources_positions;
        delete field2port_msg_sources_positions;
        delete field2field_msg_sources_positions;
    }
}

---