Ignore:
Timestamp:
Apr 23, 2009, 5:55:59 PM (15 years ago)
Author:
Christoph Mayer
Message:

-temporärer commit, sorry kompiliert nicht :( muss aber die änderungen auf die andere maschine kriegen, ist in ca1h gefixt.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • source/ariba/overlay/BaseOverlay.cpp

    r3041 r3055  
    4040
    4141#include "ariba/utility/misc/OvlVis.h"
    42 using ariba::utility::OvlVis;
     42#include "ariba/NodeListener.h"
     43#include "ariba/CommunicationListener.h"
    4344
    4445namespace ariba {
     
    146147
    147148        // inform all registered services of the event
    148         BOOST_FOREACH( ServiceInterface* i, listenerMux.getOneList() ){
     149        BOOST_FOREACH( NodeListener* i, nodeListeners ){
    149150                if( ret ) i->onLeaveSuccess( spovnetId );
    150151                else      i->onLeaveFail( spovnetId );
     
    176177
    177178        overlayInterface->joinOverlay();
    178         BOOST_FOREACH( ServiceInterface* i, listenerMux.getOneList() ){
     179        BOOST_FOREACH( NodeListener* i, nodeListeners ){
    179180                i->onJoinSuccess( spovnetId );
    180181        }
     
    221222const LinkID BaseOverlay::establishLink(const EndpointDescriptor& ep, const ServiceID& service){
    222223
    223         if( !listenerMux.contains( service ) ){
     224        if( !communicationListeners.contains( service ) ){
    224225                logging_error( "no registered listener on serviceid " << service.toString() );
    225226                return LinkID::UNSPECIFIED;
    226227        }
    227228
    228         ServiceInterface* receiver = listenerMux.get( service );
     229        CommunicationListener* receiver = communicationListeners.get( service );
    229230        const LinkID link = bc->establishLink( ep );
    230231
     
    308309}
    309310
    310 bool BaseOverlay::bind(ServiceInterface* service, const ServiceID& sid) {
    311 
    312         logging_debug( "binding service " << service << " on serviceid " << sid.toString() );
    313 
    314         if( listenerMux.contains( sid ) ){
    315                 logging_error( "some service already registered for service id " << sid.toString() );
     311void BaseOverlay::bind(CommunicationListener* listener, const ServiceID& sid){
     312        logging_debug( "binding communication listener " << listener
     313                << " on serviceid " << sid.toString() );
     314
     315        if( communicationListeners.contains( sid ) ){
     316                logging_error( "some listener already registered for service id "
     317                        << sid.toString() );
    316318                return false;
    317319        }
    318320
    319         listenerMux.registerItem( service, sid );
     321        communicationListeners.registerItem( listener, sid );
    320322        return true;
    321323}
    322324
    323 ServiceInterface* BaseOverlay::unbind(const ServiceID& sid){
    324 
    325         logging_debug( "unbinding service from serviceid " << sid.toString() );
    326 
    327         if( !listenerMux.contains( sid ) ){
    328                 logging_warn( "cannot unbind service. no service registered on service id " << sid.toString() );
    329                 return NULL;
    330         }
    331 
    332         ServiceInterface* iface = listenerMux.get( sid );
    333         listenerMux.unregisterItem( sid );
    334 
    335         return NULL; //iface;
     325void BaseOverlay::unbind(CommunicationListener* listener, const ServiceID& sid){
     326        logging_debug( "unbinding listener " << listener
     327                << " from serviceid " << sid.toString() );
     328
     329        if( !communicationListeners.contains( sid ) ){
     330                logging_warn( "cannot unbind listener. no listener registered on service id " << sid.toString() );
     331                return;
     332        }
     333
     334        if( communicationListeners.get(sid) != listener ){
     335                logging_warn( "listener bound to service id " << sid.toString()
     336                        << " is different than listener trying to unbind" );
     337                return;
     338        }
     339
     340        communicationListeners.unregisterItem( sid );
     341}
     342
     343void BaseOverlay::bind(NodeListener* listener){
     344        logging_debug( "binding node listener " << listener );
     345
     346        NodeListenerVector::iterator i = nodeListeners.find( listener );
     347        if( i != nodeListeners.end() ){
     348                logging_warn( "node listener " << listener << " is already bound, cannot bind" );
     349                return;
     350        }
     351       
     352        nodeListeners.push_back( listener );
     353}
     354
     355void BaseOverlay::unbind(NodeListener* listener){
     356        logging_debug( "unbinding node listener " << listener );
     357
     358        NodeListenerVector::iterator i = nodeListeners.find( listener );
     359        if( i == nodeListeners.end() ){
     360                logging_warn( "node listener " << listener << " is not bound, cannot unbind" );
     361                return;
     362        }
     363       
     364        nodeListeners.erase( i );
    336365}
    337366
     
    501530
    502531                const ServiceID& service = overlayMsg->getService();
    503                 ServiceInterface* serviceListener = listenerMux.get( service );
     532                CommunicationListener* serviceListener = communicationListeners.get( service );
    504533
    505534                logging_debug( "received data for service " << service.toString() );
     
    544573                bool allow = true;
    545574
    546                 BOOST_FOREACH( ServiceInterface* i, listenerMux.getOneList() ){
     575                BOOST_FOREACH( NodeListener* i, nodeListeners ){
    547576                        allow &= i->isJoinAllowed( overlayMsg->getSourceNode(), spovnetId );
    548577                }
     
    615644
    616645                        // inform all registered services of the event
    617                         BOOST_FOREACH( ServiceInterface* i, listenerMux.getOneList() ){
     646                        BOOST_FOREACH( NodeListener* i, nodeListeners{
    618647                                i->onJoinFail( spovnetId );
    619648                        }
     
    640669
    641670                        // inform all registered services of the event
    642                         BOOST_FOREACH( ServiceInterface* i, listenerMux.getOneList() ){
     671                        BOOST_FOREACH( NodeListener* i, nodeListeners ){
    643672                                i->onJoinFail( spovnetId );
    644673                        }
     
    662691
    663692                // inform all registered services of the event
    664                 BOOST_FOREACH( ServiceInterface* i, listenerMux.getOneList() ){
     693                BOOST_FOREACH( NodeListener* i, nodeListeners ){
    665694                        i->onJoinSuccess( spovnetId );
    666695                }
     
    717746                //
    718747
    719                 if( !listenerMux.contains( service ) ){
     748                if( !communicationListeners.contains( service ) ){
    720749                        logging_warn( "linkup event for service that has not been registered" );
    721750                        return false;
    722751                }
    723752
    724                 ServiceInterface* iface = listenerMux.get( service );
     753                CommunicationListener* iface = communicationListeners.get( service );
    725754                if( iface == NULL ){
    726755                        logging_warn( "linkup event for service that has been registered with a NULL interface" );
     
    762791
    763792                        // inform all registered services of the event
    764                         BOOST_FOREACH( ServiceInterface* i, listenerMux.getOneList() ){
     793                        BOOST_FOREACH( NodeListener* i, nodeListeners ){
    765794                                i->onLeaveFail( spovnetId );
    766795                        }
     
    774803
    775804                        // inform all registered services of the event
    776                         BOOST_FOREACH( ServiceInterface* i, listenerMux.getOneList() ){
     805                        BOOST_FOREACH( NodeListener* i, nodeListeners ){
    777806                                i->onNodeLeave( overlayMsg->getSourceNode(), spovnetId );
    778807                        }
     
    879908                                << node.toString() );
    880909
    881         BOOST_FOREACH( ServiceInterface* i, listenerMux.getOneList() ){
     910        BOOST_FOREACH( NodeListener* i, nodeListeners ){
    882911                i->onNodeJoin( node, spovnetId );
    883912        }
Note: See TracChangeset for help on using the changeset viewer.