/home/fwph/code/wurde/rde/core/capabilities/Bumper.cpp

Go to the documentation of this file.

#include <Bumper.H>
#include <CommsManager.H>
#include <Logger.H>

// $Id: Type.cpp 68 2007-02-01 17:56:57Z fwph $

using namespace WURDE;

Bumper::Bumper(const std::string & streamname){
       init(streamname,STRAT_NORMAL,"Any");

       //global name will be set later
       m_haveGlobalname=false;
}

Bumper::Bumper(const ConnectionStrategy & strategy,const std::string & gblName){
       init("Any",strategy,gblName);

       if(strategy==STRAT_NORMAL){
              //then the global name really specifies the streamname,
              // and the global name should be assigned automagically once we have
              // confirmation that the stream has been started
              m_haveGlobalname=false;   
       }

       m_haveStream=false;
       
}

Bumper::Bumper(const std::string &streamname,const std::string &gblName){
       init(streamname,STRAT_NORMAL,gblName);
}

void Bumper::init(const std::string &streamname,const ConnectionStrategy &strategy,const std::string &gblName){
  m_globalname=gblName;
  m_streamname=streamname;

  myCOMObject=NULL;
  
  //  data.source=streamname.c_str();
  requests=info;

  m_queue=false;
  m_supplier=false;
  m_doTimestamp=true;
  m_doTag=true;

  m_doPublishData=false;
  m_doPublishInfo=false;

  m_initialize=false;
  m_strategy=strategy;

  m_haveStream=true;
  m_haveGlobalname=true;
  m_doPublishData=false;
  m_doPublishInfo=false;

  m_doAutoPing=true;

  info.source=streamname;
  requests.source=m_globalname;
  info.target="Any";
  requests.target=streamname;
  info.timestamp.now();
  requests.timestamp.now();

  m_streamRequest=STAT_NULL;
  
  m_sourceModule="Unknown";
}


Bumper::~Bumper(){
  myManager=NULL;
  if(myCOMObject){

         //      delete myCOMObject;
  }
}


void Bumper::activateSupplier(){
       if(m_haveStream){
              m_supplier=true;
              m_globalname=m_streamname;
              m_haveGlobalname=true;
              m_initialize=false;
              if(myCOMObject){
                      //                     myCOMObject=new CMUIPCRobotProtocol::CMUIPCBumper(m_globalname);
                     myCOMObject->setGlobalName(m_globalname);
                     myCOMObject->setStreamName(m_streamname);
                     myCOMObject->setInfo(&requests);
                     myCOMObject->setRequests(&info);
                     myCOMObject->setStaging(&data);
                     myCOMObject->activateSupplier();
                     myCOMObject->setAutoPing(m_doAutoPing);
                     myCOMObject->setInfoVector(&m_requestVector);
                     myCOMObject->setRequestVector(&m_infoVector);
                     myCOMObject->setDataVector(&m_dataVector);

                     data.source=m_streamname;
                     info.source=m_streamname;

                     if(m_queue){
                            myCOMObject->setQueueMode(true);
                     }

              }else{
                      g_fatal("Attempted to activateSupplier before setting a COMObject Please just use registerSupplier.");
                      exit(-1);
              }
        data.bumped=0;
        data.bumpers.clear();
        if(m_supplier){
                info.x_offset.setCMode(C_SUPPLIER);
        }else{
                info.x_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.y_offset.setCMode(C_SUPPLIER);
        }else{
                info.y_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.phi_separation.setCMode(C_SUPPLIER);
        }else{
                info.phi_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.psi_offset.setCMode(C_SUPPLIER);
        }else{
                info.psi_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.x_separation.setCMode(C_SUPPLIER);
        }else{
                info.x_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.phi_offset.setCMode(C_SUPPLIER);
        }else{
                info.phi_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.theta_separation.setCMode(C_SUPPLIER);
        }else{
                info.theta_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.psi_separation.setCMode(C_SUPPLIER);
        }else{
                info.psi_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.sensor_positions.setCMode(C_SUPPLIER);
        }else{
                info.sensor_positions.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.y_separation.setCMode(C_SUPPLIER);
        }else{
                info.y_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.uniform.setCMode(C_SUPPLIER);
        }else{
                info.uniform.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.theta_offset.setCMode(C_SUPPLIER);
        }else{
                info.theta_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.z_separation.setCMode(C_SUPPLIER);
        }else{
                info.z_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.z_offset.setCMode(C_SUPPLIER);
        }else{
                info.z_offset.setCMode(C_CONSUMER);
        }
       }else{
              //this shouldn't happen, but there's no real problem with it.
              //it'd just be dumb.
              m_initialize=true;
              m_supplier=true;
       }
       
       requests=info;

}

void Bumper::activateConsumer(){
       std::string localname;
       
       if(m_haveStream){
              m_initialize=false;
              m_supplier=false;
              if(myCOMObject&&myManager){
                      /* global name so we don't have conflicts with the naming service */
                      if(!m_haveGlobalname&&m_strategy==STRAT_NORMAL){
                              m_globalname=myManager->getName()+BUMPER+m_streamname+"Consumer";
                              m_haveGlobalname=true;
                      }

                     myCOMObject->setGlobalName(m_globalname);
                     myCOMObject->setStreamName(m_streamname);
                     requests.source=m_globalname;
                     data.source=m_streamname;
                     info.source=m_streamname;
                     myCOMObject->setInfo(&info);
                     myCOMObject->setRequests(&requests);
                     myCOMObject->setStaging(&data);
                     myCOMObject->setAutoPing(m_doAutoPing);
                     myCOMObject->activateConsumer();
                     myCOMObject->setInfoVector(&m_infoVector);
                     myCOMObject->setRequestVector(&m_requestVector);
                     myCOMObject->setDataVector(&m_dataVector);

                     if(m_queue){
                            myCOMObject->setQueueMode(true);
                     }
              }else{
                      g_fatal("Attempted to activateConsumer before setting a COMObject and CommsManager. Please use registerConsumer instead.");
                     exit(-1);
              }

        data.bumped=0;
        data.bumpers.clear();
        if(m_supplier){
                info.x_offset.setCMode(C_SUPPLIER);
        }else{
                info.x_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.y_offset.setCMode(C_SUPPLIER);
        }else{
                info.y_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.phi_separation.setCMode(C_SUPPLIER);
        }else{
                info.phi_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.psi_offset.setCMode(C_SUPPLIER);
        }else{
                info.psi_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.x_separation.setCMode(C_SUPPLIER);
        }else{
                info.x_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.phi_offset.setCMode(C_SUPPLIER);
        }else{
                info.phi_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.theta_separation.setCMode(C_SUPPLIER);
        }else{
                info.theta_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.psi_separation.setCMode(C_SUPPLIER);
        }else{
                info.psi_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.sensor_positions.setCMode(C_SUPPLIER);
        }else{
                info.sensor_positions.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.y_separation.setCMode(C_SUPPLIER);
        }else{
                info.y_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.uniform.setCMode(C_SUPPLIER);
        }else{
                info.uniform.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.theta_offset.setCMode(C_SUPPLIER);
        }else{
                info.theta_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.z_separation.setCMode(C_SUPPLIER);
        }else{
                info.z_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.z_offset.setCMode(C_SUPPLIER);
        }else{
                info.z_offset.setCMode(C_CONSUMER);
        }
       }else{
              //no stream, so we can't connect yet. tell the system 
              //to initialize as soon as we've got one
              m_initialize=true;
       }

}

void Bumper::runUpdate(){
       if(myCOMObject){

              myCOMObject->runUpdate(m_doPublishData,m_doPublishInfo);
              
              m_doPublishData=false;
              m_doPublishInfo=false;
              
       }
}

void Bumper::setManager(CommsManager *myManager_){

  if(!myCOMObject){
    myManager=myManager_;
  }

}

void Bumper::setQueueMode(const bool & val){

       if(!myCOMObject){
              m_queue=val;
       }else if(!m_queue&&val){
              m_queue=val;
              myCOMObject->setDataVector(&m_dataVector);
              myCOMObject->setQueueMode(true);

       }else if(!val&&m_queue){
              m_queue=val;
              myCOMObject->setQueueMode(false);
              while(!m_dataVector.empty()){
                     m_dataVector.pop();
              }
              while(!m_infoVector.empty()){
                     m_infoVector.pop();
              }
              while(!m_requestVector.empty()){
                     m_requestVector.pop();
              }
       }
}

bool Bumper::newData(){
       if(m_queue){
              return !m_dataVector.empty();
       }else{
              if(myCOMObject){
                     return myCOMObject->newData();
              }
       }

       return false;
}

bool Bumper::newInfo(){
       if(m_queue){
              if(m_supplier){
                     return !m_requestVector.empty();
              }

              return !m_infoVector.empty();
       }else{
              if(myCOMObject){
                     return myCOMObject->newInfo();
              }
       }


       return false;
}

void Bumper::publishData(){
       if(m_supplier){
              if(m_doTimestamp){
                     data.timestamp.now();
              }
              if(m_doTag){
                     data.source=m_globalname;
              }
              if(m_queue){
                     BumperDataStruct temp;
        temp.bumped=0;
        temp.bumpers.clear();
                     temp.source=data.source;
temp.timestamp=data.timestamp;
temp.bumped=data.bumped;
temp.bumpers=data.bumpers;
 
                     m_dataVector.push(temp);
                              //                     m_dataVector.push(data);
              }
              m_doPublishData=true;
       }
}

void Bumper::publishInfo(){
       if(m_supplier){

              info.mType=MESSAGE_INFO;
              if(m_doTimestamp){
                     info.timestamp.now();
              }

              if(m_doTag){
                     info.source=m_globalname;
                     info.target="Any";
              }

              if(m_queue){
                     BumperInfoStruct temp;
                     
                    
                     temp.x_offset=info.x_offset;
temp.source=info.source;
temp.y_offset=info.y_offset;
temp.phi_separation=info.phi_separation;
temp.target=info.target;
temp.psi_offset=info.psi_offset;
temp.timestamp=info.timestamp;
temp.x_separation=info.x_separation;
temp.phi_offset=info.phi_offset;
temp.theta_separation=info.theta_separation;
temp.psi_separation=info.psi_separation;
temp.sensor_positions=info.sensor_positions;
temp.y_separation=info.y_separation;
temp.mType=info.mType;
temp.uniform=info.uniform;
temp.theta_offset=info.theta_offset;
temp.z_separation=info.z_separation;
temp.z_offset=info.z_offset;

                     m_infoVector.push(temp);
                    
                     //              m_infoVector.push(info);
              }

              m_doPublishInfo=true;
       }else{

              requests.mType=MESSAGE_REQUEST;
              
              if(m_doTimestamp){
                     requests.timestamp.now();
              }

              if(m_doTag){
                     requests.source=m_globalname;
                     requests.target=m_streamname;
              }

              if(m_queue){
                     BumperInfoStruct temp;
        if(m_supplier){
                temp.x_offset.setCMode(C_SUPPLIER);
        }else{
                temp.x_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                temp.y_offset.setCMode(C_SUPPLIER);
        }else{
                temp.y_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                temp.phi_separation.setCMode(C_SUPPLIER);
        }else{
                temp.phi_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                temp.psi_offset.setCMode(C_SUPPLIER);
        }else{
                temp.psi_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                temp.x_separation.setCMode(C_SUPPLIER);
        }else{
                temp.x_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                temp.phi_offset.setCMode(C_SUPPLIER);
        }else{
                temp.phi_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                temp.theta_separation.setCMode(C_SUPPLIER);
        }else{
                temp.theta_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                temp.psi_separation.setCMode(C_SUPPLIER);
        }else{
                temp.psi_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                temp.sensor_positions.setCMode(C_SUPPLIER);
        }else{
                temp.sensor_positions.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                temp.y_separation.setCMode(C_SUPPLIER);
        }else{
                temp.y_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                temp.uniform.setCMode(C_SUPPLIER);
        }else{
                temp.uniform.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                temp.theta_offset.setCMode(C_SUPPLIER);
        }else{
                temp.theta_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                temp.z_separation.setCMode(C_SUPPLIER);
        }else{
                temp.z_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                temp.z_offset.setCMode(C_SUPPLIER);
        }else{
                temp.z_offset.setCMode(C_CONSUMER);
        }
                     temp.x_offset=requests.x_offset;
temp.source=requests.source;
temp.y_offset=requests.y_offset;
temp.target=requests.target;
temp.phi_separation=requests.phi_separation;
temp.timestamp=requests.timestamp;
temp.psi_offset=requests.psi_offset;
temp.phi_offset=requests.phi_offset;
temp.x_separation=requests.x_separation;
temp.theta_separation=requests.theta_separation;
temp.psi_separation=requests.psi_separation;
temp.y_separation=requests.y_separation;
temp.sensor_positions=requests.sensor_positions;
temp.mType=requests.mType;
temp.uniform=requests.uniform;
temp.theta_offset=requests.theta_offset;
temp.z_separation=requests.z_separation;
temp.z_offset=requests.z_offset;

                     m_requestVector.push(temp);

                     //              m_requestVector.push(requests);
              }

              m_doPublishInfo=true;
       }
}

BumperDataStruct Bumper::getNextData(){
       if(m_queue){
              BumperDataStruct retval;
        retval.bumped=0;
        retval.bumpers.clear();
              retval.source="NULL";
              if(m_dataVector.empty()){
                     return data;
              }
             
              retval.source=m_dataVector.front().source;
retval.timestamp=m_dataVector.front().timestamp;
retval.bumpers=m_dataVector.front().bumpers;
retval.bumped=m_dataVector.front().bumped;

                       //             retval=m_dataVector.front();
              m_dataVector.pop();
              data=retval;
       
              return retval;
       }else{
              myCOMObject->resetData();
              return data;
       }
}

BumperInfoStruct Bumper::getNextInfo(){
       if(m_queue){
              BumperInfoStruct retval;
        if(m_supplier){
                retval.x_offset.setCMode(C_SUPPLIER);
        }else{
                retval.x_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.y_offset.setCMode(C_SUPPLIER);
        }else{
                retval.y_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.phi_separation.setCMode(C_SUPPLIER);
        }else{
                retval.phi_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.psi_offset.setCMode(C_SUPPLIER);
        }else{
                retval.psi_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.x_separation.setCMode(C_SUPPLIER);
        }else{
                retval.x_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.phi_offset.setCMode(C_SUPPLIER);
        }else{
                retval.phi_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.theta_separation.setCMode(C_SUPPLIER);
        }else{
                retval.theta_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.psi_separation.setCMode(C_SUPPLIER);
        }else{
                retval.psi_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.sensor_positions.setCMode(C_SUPPLIER);
        }else{
                retval.sensor_positions.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.y_separation.setCMode(C_SUPPLIER);
        }else{
                retval.y_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.uniform.setCMode(C_SUPPLIER);
        }else{
                retval.uniform.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.theta_offset.setCMode(C_SUPPLIER);
        }else{
                retval.theta_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.z_separation.setCMode(C_SUPPLIER);
        }else{
                retval.z_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.z_offset.setCMode(C_SUPPLIER);
        }else{
                retval.z_offset.setCMode(C_CONSUMER);
        }
              retval.source="NULL";
              if(m_supplier){
                     if(m_requestVector.empty()){
                            return requests;
                     }
                     retval.x_offset=m_requestVector.front().x_offset;
retval.source=m_requestVector.front().source;
retval.y_offset=m_requestVector.front().y_offset;
retval.target=m_requestVector.front().target;
retval.phi_separation=m_requestVector.front().phi_separation;
retval.timestamp=m_requestVector.front().timestamp;
retval.psi_offset=m_requestVector.front().psi_offset;
retval.phi_offset=m_requestVector.front().phi_offset;
retval.x_separation=m_requestVector.front().x_separation;
retval.theta_separation=m_requestVector.front().theta_separation;
retval.psi_separation=m_requestVector.front().psi_separation;
retval.y_separation=m_requestVector.front().y_separation;
retval.sensor_positions=m_requestVector.front().sensor_positions;
retval.mType=m_requestVector.front().mType;
retval.uniform=m_requestVector.front().uniform;
retval.theta_offset=m_requestVector.front().theta_offset;
retval.z_separation=m_requestVector.front().z_separation;
retval.z_offset=m_requestVector.front().z_offset;

                              //                     retval=m_requestVector.front();
        if(m_supplier){
                retval.x_offset.setCMode(C_SUPPLIER);
        }else{
                retval.x_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.y_offset.setCMode(C_SUPPLIER);
        }else{
                retval.y_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.phi_separation.setCMode(C_SUPPLIER);
        }else{
                retval.phi_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.psi_offset.setCMode(C_SUPPLIER);
        }else{
                retval.psi_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.x_separation.setCMode(C_SUPPLIER);
        }else{
                retval.x_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.phi_offset.setCMode(C_SUPPLIER);
        }else{
                retval.phi_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.theta_separation.setCMode(C_SUPPLIER);
        }else{
                retval.theta_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.psi_separation.setCMode(C_SUPPLIER);
        }else{
                retval.psi_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.sensor_positions.setCMode(C_SUPPLIER);
        }else{
                retval.sensor_positions.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.y_separation.setCMode(C_SUPPLIER);
        }else{
                retval.y_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.uniform.setCMode(C_SUPPLIER);
        }else{
                retval.uniform.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.theta_offset.setCMode(C_SUPPLIER);
        }else{
                retval.theta_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.z_separation.setCMode(C_SUPPLIER);
        }else{
                retval.z_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.z_offset.setCMode(C_SUPPLIER);
        }else{
                retval.z_offset.setCMode(C_CONSUMER);
        }
                     m_requestVector.pop();
                     requests=retval;
                     return retval;
              }else{
                     if(m_infoVector.empty()){
                            return info;
                     }
                     retval.x_offset=m_infoVector.front().x_offset;
retval.source=m_infoVector.front().source;
retval.y_offset=m_infoVector.front().y_offset;
retval.target=m_infoVector.front().target;
retval.phi_separation=m_infoVector.front().phi_separation;
retval.timestamp=m_infoVector.front().timestamp;
retval.psi_offset=m_infoVector.front().psi_offset;
retval.phi_offset=m_infoVector.front().phi_offset;
retval.x_separation=m_infoVector.front().x_separation;
retval.theta_separation=m_infoVector.front().theta_separation;
retval.psi_separation=m_infoVector.front().psi_separation;
retval.y_separation=m_infoVector.front().y_separation;
retval.sensor_positions=m_infoVector.front().sensor_positions;
retval.mType=m_infoVector.front().mType;
retval.uniform=m_infoVector.front().uniform;
retval.theta_offset=m_infoVector.front().theta_offset;
retval.z_separation=m_infoVector.front().z_separation;
retval.z_offset=m_infoVector.front().z_offset;

        if(m_supplier){
                retval.x_offset.setCMode(C_SUPPLIER);
        }else{
                retval.x_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.y_offset.setCMode(C_SUPPLIER);
        }else{
                retval.y_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.phi_separation.setCMode(C_SUPPLIER);
        }else{
                retval.phi_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.psi_offset.setCMode(C_SUPPLIER);
        }else{
                retval.psi_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.x_separation.setCMode(C_SUPPLIER);
        }else{
                retval.x_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.phi_offset.setCMode(C_SUPPLIER);
        }else{
                retval.phi_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.theta_separation.setCMode(C_SUPPLIER);
        }else{
                retval.theta_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.psi_separation.setCMode(C_SUPPLIER);
        }else{
                retval.psi_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.sensor_positions.setCMode(C_SUPPLIER);
        }else{
                retval.sensor_positions.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.y_separation.setCMode(C_SUPPLIER);
        }else{
                retval.y_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.uniform.setCMode(C_SUPPLIER);
        }else{
                retval.uniform.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.theta_offset.setCMode(C_SUPPLIER);
        }else{
                retval.theta_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.z_separation.setCMode(C_SUPPLIER);
        }else{
                retval.z_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                retval.z_offset.setCMode(C_SUPPLIER);
        }else{
                retval.z_offset.setCMode(C_CONSUMER);
        }
                     m_infoVector.pop();
                     info=retval;
                     // the requests struct really should get the values in 
                     // info
                     requests=info;
                     
                     return retval;
              }
       }else{
              myCOMObject->resetInfo();
              if(m_supplier){
        if(m_supplier){
                requests.x_offset.setCMode(C_SUPPLIER);
        }else{
                requests.x_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                requests.y_offset.setCMode(C_SUPPLIER);
        }else{
                requests.y_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                requests.phi_separation.setCMode(C_SUPPLIER);
        }else{
                requests.phi_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                requests.psi_offset.setCMode(C_SUPPLIER);
        }else{
                requests.psi_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                requests.x_separation.setCMode(C_SUPPLIER);
        }else{
                requests.x_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                requests.phi_offset.setCMode(C_SUPPLIER);
        }else{
                requests.phi_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                requests.theta_separation.setCMode(C_SUPPLIER);
        }else{
                requests.theta_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                requests.psi_separation.setCMode(C_SUPPLIER);
        }else{
                requests.psi_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                requests.sensor_positions.setCMode(C_SUPPLIER);
        }else{
                requests.sensor_positions.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                requests.y_separation.setCMode(C_SUPPLIER);
        }else{
                requests.y_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                requests.uniform.setCMode(C_SUPPLIER);
        }else{
                requests.uniform.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                requests.theta_offset.setCMode(C_SUPPLIER);
        }else{
                requests.theta_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                requests.z_separation.setCMode(C_SUPPLIER);
        }else{
                requests.z_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                requests.z_offset.setCMode(C_SUPPLIER);
        }else{
                requests.z_offset.setCMode(C_CONSUMER);
        }
                     return requests;
              }else{
        if(m_supplier){
                info.x_offset.setCMode(C_SUPPLIER);
        }else{
                info.x_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.y_offset.setCMode(C_SUPPLIER);
        }else{
                info.y_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.phi_separation.setCMode(C_SUPPLIER);
        }else{
                info.phi_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.psi_offset.setCMode(C_SUPPLIER);
        }else{
                info.psi_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.x_separation.setCMode(C_SUPPLIER);
        }else{
                info.x_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.phi_offset.setCMode(C_SUPPLIER);
        }else{
                info.phi_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.theta_separation.setCMode(C_SUPPLIER);
        }else{
                info.theta_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.psi_separation.setCMode(C_SUPPLIER);
        }else{
                info.psi_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.sensor_positions.setCMode(C_SUPPLIER);
        }else{
                info.sensor_positions.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.y_separation.setCMode(C_SUPPLIER);
        }else{
                info.y_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.uniform.setCMode(C_SUPPLIER);
        }else{
                info.uniform.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.theta_offset.setCMode(C_SUPPLIER);
        }else{
                info.theta_offset.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.z_separation.setCMode(C_SUPPLIER);
        }else{
                info.z_separation.setCMode(C_CONSUMER);
        }
        if(m_supplier){
                info.z_offset.setCMode(C_SUPPLIER);
        }else{
                info.z_offset.setCMode(C_CONSUMER);
        }
                     // the requests struct really should get the values in 
                     // info
                     requests=info;
                     return info;
              }
       }
}

void Bumper::setStreamName(const std::string & name){

       if(m_supplier&&name=="Any"){
              return;
       }

       m_streamname=name;
       m_haveStream=true;

       if(m_supplier){
              m_globalname=name;
       }
       
       if(myCOMObject){
              myCOMObject->setStreamName(name);
       }

       if(m_initialize){
              if(m_supplier){
                     activateSupplier();
              }else{
                     activateConsumer();
              }
       }

       m_streamRequest=STAT_OKAY;
}

void Bumper::setGlobalName(const std::string & name){
       
       if(name=="Any"){
              return;
       }

       m_globalname=name;
       m_haveGlobalname=true;
       if(m_supplier){
              m_streamname=name;
       }

       if(myCOMObject){
              myCOMObject->setGlobalName(name);
       }
}

void Bumper::doPing(){
       if(myCOMObject){
              myCOMObject->doPing();
       }
}

void Bumper::setAutoPing(const bool & val){
       m_doAutoPing=val; 
       if(myCOMObject){
              myCOMObject->setAutoPing(val);
       }
}

---