ippBasicExecutor.cpp

Go to the documentation of this file.

// 
// DISCLAIMER: 
//  This software was produced by the National Institute of Standards 
//  and Technology (NIST), an agency of the U.S. government, and by statute is 
//  not subject to copyright in the United States.  Recipients of this 
//  software assume all responsibility associated with its operation,
//  modification,maintenance, and subsequent redistribution. 
//
//  See NIST Administration Manual 4.09.07 b and Appendix I. 
//
#include "stdafx.h"

#include "ippdme/Executor/ippBasicExecutor.h"
#include "ippdme/world.h"


#include "ippdme/Response/ippGetDMEVersionResponse.h"
#include "ippdme/Response/ippKeyPressEResponse.h"
#include "ippdme/Response/responses.h"

#include "ippdme/Property/ippOnePropertyId.h"
#include "ippdme/Property/ippOnePropertyName.h"
#include "ippdme/Property/ippOnePropertyNumber.h"

#include "ippdme/Command/ippStopDaemonCommand.h"
#include "ippdme/Command/ippGetPropCommand.h"
#include "ippdme/Command/ippChangeToolCommand.h"
#include "ippdme/Command/ippFindToolCommand.h"
#include "ippdme/Command/ippSetToolCommand.h"
#include "ippdme/Command/ippGetCommand.h"
#include "ippdme/Command/ippGetCsyTransformationCommand.h"
#include "ippdme/Command/ippEnumAllPropCommand.h"
#include "ippdme/Command/ippEnumPropCommand.h"

#include "ippdme/misc/ippPropDefinition.h"

#include "ippdme/assert.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

//=============================================================================
ippBasicExecutor::ippBasicExecutor(world& w)
//-----------------------------------------------------------------------------
:_world(w)
{
 //xx _previousTool = getTools()->getActiveTool();

}


//=============================================================================
void ippBasicExecutor::resetExecutor()
//-----------------------------------------------------------------------------
{
  ippExecutor::resetExecutor();
  _world.stopAllDaemons();
}



//=============================================================================
void  ippBasicExecutor::executeIsHomed()
//-----------------------------------------------------------------------------
{
        unsigned int tag_num = _currentCommand->getTag().getTagNumber();
        ippIsHomedResponsePtr x = new ippIsHomedResponse (tag_num, _world.getIsHomed());
        _returningValues.push_back(x);
        generateCompletedResponse();
} 


//=============================================================================
void ippBasicExecutor::StopAllDaemons()
//-----------------------------------------------------------------------------
{
  _world.stopAllDaemons();
}

//=============================================================================
int  ippBasicExecutor::DaemonCount() const
//-----------------------------------------------------------------------------
{
  return _world.daemonCount();
}




//=============================================================================
void ippBasicExecutor::executeStartSession()
//-----------------------------------------------------------------------------
{
  _world.update(_currentCommand);  // world performs update
  _world.setReadiness(ready);
  generateCompletedResponse();
} 

//=============================================================================
void ippBasicExecutor::executeEndSession()
//-----------------------------------------------------------------------------
{
  _world.update(_currentCommand);   // Execution world model changes
  generateCompletedResponse(); 
} 

//=============================================================================
void ippBasicExecutor::executeStopDaemon()
//-----------------------------------------------------------------------------
{
  ippStopDaemonCommandPtr cmd=static_cast<ippStopDaemonCommand*>(_currentCommand.get());

  int daemon_tag = cmd->getDaemonTag().getTagNumber();
  if (!_world.daemonExists(daemon_tag)) {
    generateErrorResponse(DaemonDoesNotExist,"");
  } else {
    _world.stopDaemon(daemon_tag);
  }
  generateCompletedResponse();
}

//=============================================================================
void ippBasicExecutor::executeStopAllDaemons()
//-----------------------------------------------------------------------------
{
  if(_world.daemonCount() == 0 ) { 
    generateErrorResponse(NoDaemonsAreActive,"");
  }
  _world.stopAllDaemons();
  generateCompletedResponse();
}

//==============================================================================
void ippBasicExecutor::executeGetDMEVersion()
//-----------------------------------------------------------------------------
{
  
  unsigned int tag_num = _currentCommand->getTag().getTagNumber();
  ippResponsePtr r= new ippGetDMEVersionResponse(tag_num, "1.5");
  _returningValues.push_back(r);
  generateCompletedResponse();
}

//==============================================================================
void ippBasicExecutor::executeOnMoveReportE()
//-----------------------------------------------------------------------------
{

  ippOnMoveReportECommandPtr currentOnMoveReportE = 
  static_cast<ippOnMoveReportECommand*>(_currentCommand.get());

  int daemon_tag  =_currentCommand->getTag().getTagNumber();
   
  if (_world.daemonExists(_currentCommand->getTag().getTagNumber())) { 
    // a daemon with this tag already exists
    generateErrorResponse(DaemonAlreadyExists,"");
  } else {
    _world.addDaemon(currentOnMoveReportE.get());
  }

  generateCompletedResponse();
  
} // end executeOnMoveReportE()

//==============================================================================
void  ippBasicExecutor::executeOnPtMeasReport()
//-----------------------------------------------------------------------------
{
  _world.update(_currentCommand);
  generateCompletedResponse();

} 

//==============================================================================
void ippBasicExecutor::executeOnScanReport()
//-----------------------------------------------------------------------------
{
  _world.update(_currentCommand);
  generateCompletedResponse();

} 


ippOnePropertyPtr ippBasicExecutor::GetToolProperty(
  ippKToolConstPtr theTool,
  const ippProp& prop
)
{
  IPP_ASSERT(theTool.get());

  double val =0;
  if (prop.getKey2() == Alignment) {   
    return _world.getCurrentAlignment();    

  } else if (prop.getKey2() == CollisionVolume) {
    return theTool->getCollisionVolume();
  } else if (prop.getKey2() == AvrRadius) {
    val = theTool->getRadius();
    return new ippOnePropertyNumber(prop,val);  
  } else if (prop.getKey2() == Id) {
      return new ippOnePropertyId(prop.getKey1(), theTool->getId());

  } else if (prop.getKey2() == Name) {
     return new ippOnePropertyName(prop.getKey1(), theTool->getName());

  } else if (prop.getKey2() == GoToPar /*&& theTool != getTools()->getUnDefTool()*/) {
        
    bool bSuccess = false;
    ippGoToParsPtr pars1 = theTool->getGoToPar();
    switch (prop.getKey3()) {
      case Speed:
        bSuccess = pars1->getSpeed().getProperty(prop.getKey4(),val);
        break;
      case Accel:
        bSuccess = pars1->getAccel().getProperty(prop.getKey4(),val);
        break;
    default:
        break;
    }
    if (bSuccess) {
     return new ippOnePropertyNumber(prop,val);
   }


  } else if (prop.getKey2() == PtMeasPar /*&& theTool != getTools()->getNoTool()*/) {   
    bool bSuccess = false;
    ippPtMeasParsPtr pars2 = theTool->getPtMeasPar();
    switch (prop.getKey3()) {
      case Speed:
        bSuccess = pars2->getSpeed().getProperty(prop.getKey4(),val);
        break;
      case Accel:
        bSuccess = pars2->getAccel().getProperty(prop.getKey4(),val);
        break;
      case Approach:
        bSuccess = pars2->getApproach().getProperty(prop.getKey4(),val);
        break;
      case Retract:
        bSuccess = pars2->getRetract().getProperty(prop.getKey4(),val);
        break;
      case Search:
        bSuccess = pars2->getSearch().getProperty(prop.getKey4(),val);
        break;
      default:
        break;
    }
    if (bSuccess) return new ippOnePropertyNumber(prop,val);
  
  } else if (prop.getKey2() == ScanPar /*&& theTool != getTools()->getNoTool()*/) {  
    bool bSuccess = false;
    ippScanParsPtr pars = theTool->getScanPar();
    IPP_ASSERT(pars);
    if (pars) {
      switch (prop.getKey3()) {
        case Speed:
          bSuccess = pars->getSpeed().getProperty(prop.getKey4(),val);
          break;
        case Accel:
          bSuccess = pars->getAccel().getProperty(prop.getKey4(),val);
          break;
        case Retract:
          bSuccess = pars->getRetract().getProperty(prop.getKey4(),val);
          break;
        default:
          break;
      }
    }
    if (bSuccess) return new ippOnePropertyNumber(prop,val);
 } 
 return 0;
}


//=============================================================================
void ippBasicExecutor::beforeExecuteGet()
//
//
//-----------------------------------------------------------------------------
{
  IPP_ASSERT_FAIL("Should be overridden by the derived class->in this method\n"
              " the implementation should make sure that the world objects"
              " reflects the actual state of the connected DME ");
}

//=============================================================================
void  ippBasicExecutor::executeGet()
//-----------------------------------------------------------------------------
{
  beforeExecuteGet();

  double er=0, i=0, j=0, k=0, r=0, x=0, y=0, z=0, toolA=0, toolB=0, toolC=0;

  int ijkAct=0;

  bool hasER = false, hasIJK = false, hasR = false;
  bool hasX = false, hasY = false, hasZ = false;
  bool hasToolA = false, hasToolB = false, hasToolC = false;
  bool hasIJKAct = false;
  bool hasQ = false;
  double q=0;

  ippGetCommandPtr  cmd = static_cast<ippGetCommand *>(_currentCommand.get());

  
  if (cmd->getHasR()){
          r = _world.getCurrentR();
          hasR = true;
  }


  if (cmd->getHasX()){
    x = _world.getCurrentX();
    hasX = true;
  }
  if (cmd->getHasY()){
    y = _world.getCurrentX();
    hasY = true;
  }
  if (cmd->getHasZ()){
    z = _world.getCurrentX();
    hasZ = true;
  }
  if (cmd->getHasToolA()){
    toolA = _world.getCurrentToolA();
    hasToolA = true;
  }
  if (cmd->getHasToolB()){
    toolB = _world.getCurrentToolB();
    hasToolB = true;
  }
  if (cmd->getHasToolC()){
    toolC = _world.getCurrentToolC();
    hasToolC = true;
  }
//  if (cmd->getHasIJKAct()){
//    IJKAct =0;
//    hasIJKAct = true;
//  }
//
  if(hasER==true || hasIJK==true || hasR==true || hasX==true || hasY==true || hasZ==true || 
                hasToolA==true || hasToolB==true || hasToolC==true)
  {
    unsigned int tag_num = _currentCommand->getTag().getTagNumber();
    ippPtMeasOrGetResponsePtr res = new ippPtMeasOrGetResponse(tag_num, 
                hasER, hasIJK, hasIJKAct, hasQ, hasR, hasToolA, hasToolB, hasToolC, hasX, hasY, hasZ, 
            er, i, j, k, ijkAct, q, r, toolA, toolB, toolC, x, y, z);
  
    _returningValues.push_back(res);

    generateCompletedResponse();
  } else {
    generateCompletedResponse();
  }

}  

//=============================================================================
ippToolChangerPtr ippBasicExecutor::getTools()
//-----------------------------------------------------------------------------
{
  IPP_ASSERT(_world.getTools());
  return  _world.getTools();
}


//==============================================================================
void ippBasicExecutor::executeGetProp()
//-----------------------------------------------------------------------------
{
  // [TODO] there is plenty of scope to rationalize and remove code duplication here.
  //        between executeGetProp and executeGetPropE !
  ippGetPropCommandConstPtr cmd = static_cast<ippGetPropCommand*>(_currentCommand.get());

  int numberProps = cmd->getNumberProps();

  ippGetPropResponsePtr res = new ippGetPropResponse(
    _currentCommand->getTag().getTagNumber(),
    _currentCommand->getTag().getTagType());

  for (int n=0; n<numberProps; n++){

    const ippProp& prop = cmd->getProp(n);

    ippKToolConstPtr theTool;

    if (prop.getKey1() == Tool) {
      theTool = getTools()->getActiveTool();
    } else if (prop.getKey1() == FoundTool){
      theTool = getTools()->getFoundTool();
      // Note: what should happen if found tool is the UnDefTOol here ?
      //       We must assume that at least FindTool has been called once.
    }
    ippOnePropertyPtr p = GetToolProperty(theTool,prop);
    if (p) res->append(p);

  }

  _returningValues.push_back(res);

  generateCompletedResponse();
}


//==============================================================================
void ippBasicExecutor::executeGetPropE()
//-----------------------------------------------------------------------------
{
   executeGetProp();
} // end executeGetPropE()

//==============================================================================
void ippBasicExecutor::generateOnMoveReport()
//-----------------------------------------------------------------------------
{

  if (_world.daemonCount() == 0 ) return;

  double r = -1, x = -1, y = -1, z = -1, toolA = -1, toolB = -1, toolC = -1;
  bool hasR = false, hasX = false, hasY = false, hasZ = false;
  bool hasToolA = false, hasToolB = false, hasToolC = false;
  
  ippDaemonConstPtr daemon = _world.getDaemon();
  
  ippOnMoveReportECommandConstPtr cmd = daemon->getOnMoveReportECommand();

  if (cmd->getHasR()){
   r = _world.getCurrentR();
   hasR = true;
  }
  if (cmd->getHasX()){
   x = _world.getCurrentX();
   hasX = true;
  }
  if (cmd->getHasY()){
   y = _world.getCurrentY();
   hasY = true;
  }
   if (cmd->getHasZ()){
    z = _world.getCurrentZ();
    hasZ = true;
  }
   if (cmd->getHasToolA()){
   toolA = _world.getCurrentToolA();
   hasToolA = true;
  }
   if (cmd->getHasToolB()){
   toolB = _world.getCurrentToolB();
   hasToolB = true;
  }
   if (cmd->getHasToolC()){
   toolC = _world.getCurrentToolC();
   hasToolC = true;
  }
   if(hasR==true || hasX==true || hasY==true || hasZ==true || 
    hasToolA==true || hasToolB==true || hasToolC==true){

    unsigned int tag_num = cmd->getTag().getTagNumber();

    ippOnMoveReportEResponsePtr res = new ippOnMoveReportEResponse 
    (tag_num, hasR, hasToolA, hasToolB, hasToolC, hasX, hasY, hasZ, 
              r, toolA, toolB, toolC, x, y, z);
  
    _returningValues.push_back(res);
   }
}


//==============================================================================
void ippBasicExecutor::generatePtMeasReport()
// 9.5.3 Pick manual point
//-----------------------------------------------------------------------------
{
  // Generate response based on data request by the last OnPtmeasReport command
  double r = -1, x = -1, y = -1, z = -1, toolA = -1, toolB = -1, toolC = -1, 
    er = -1, i = -1, j = -1, k = -1;
  bool hasR = false, hasX = false, hasY = false, hasZ = false, hasER = false;
  bool hasToolA = false, hasToolB = false, hasToolC = false, hasIJK = false;
  bool hasIJKAct = false;
  bool hasQ = false;
  int ijkAct = 1;
  double q = -1.0;
  
  //    unsigned int tag_num = _currentPtMeas->getTag().getTagNumber();

  ippOnPtMeasReportCommandConstPtr cmd = _world.getOnPtMeasReportCommand();

  if (cmd->getHasR()){
    r = _world.getCurrentR();
    hasR = true;
  }
  if (cmd->getHasX()){
    x = _world.getCurrentX();
    hasX = true;
  }
  if (cmd->getHasY()){
    y = _world.getCurrentY();
    hasY = true;
  }
  if (cmd->getHasZ()){
    z = _world.getCurrentZ();
    hasZ = true;
  }
  if (cmd->getHasToolA()){
    toolA = _world.getCurrentToolA();
    hasToolA = true;
  }
  if (cmd->getHasToolB()){
    toolB = _world.getCurrentToolB();
    hasToolB = true;
  }
  if (cmd->getHasToolC()){
    toolC = _world.getCurrentToolC();
    hasToolC = true;
  }
  if (cmd->getHasER()){
    er = _world.getProbeRadius();
    hasER = true;
  }
  if (cmd->getHasQ()){
    q = _world.getCurrentQ();
    hasQ = true;
  }
  if (cmd->getHasIJKAct()){
    ijkAct = _world.getIJKAct();
    hasIJKAct = true;
  }
  
  if (cmd->getHasIJK()){
    // Note if _scanning us 001, however, if
    // single point must compute ijk from 
    // start and destination.
    i = 0;
    j = 0;
    k = 1;
    hasIJK = true;
  }
  
  int tag_num = 0;
  if (_currentCommand) {
    tag_num = _currentCommand->getTag().getTagNumber();
  }  else {
    // unsollicited contact 
  }

  if(hasR || hasX|| hasY || hasZ || 
    hasToolA || hasToolB|| hasToolC||
    hasIJK || hasER || hasQ || hasIJKAct) {
    
    ippResponsePtr  res = new ippPtMeasOrGetResponse(tag_num,
      hasER, hasIJK, hasIJKAct, hasQ,
      hasR, hasToolA, hasToolB, hasToolC, hasX, hasY, hasZ, 
      er,i, j, k, ijkAct,q,r, toolA, toolB, toolC, x, y, z);
    _returningValues.push_back(res);
  }
}

//==============================================================================
void ippBasicExecutor::generateIntermediatePointReport()
//
// 9.5.2. Clearance or intermediate point set
//
//-----------------------------------------------------------------------------
{


}
//==============================================================================
void ippBasicExecutor::generateKeyPress(const char* key)
//
// 9.5.2. Clearance or intermediate point set
//
//-----------------------------------------------------------------------------
{
  ippKeyPressEResponsePtr res = new ippKeyPressEResponse(key);
  _returningValues.push_back(res);

}
//==============================================================================
void ippBasicExecutor::executeEnumTools()
//-----------------------------------------------------------------------------
{

  UpdateTools();

  const std::vector<ippKToolPtr>& listOfTools = getTools()->getToolList();
  std::vector<ippKToolPtr>::const_iterator p;

  unsigned int tag_num = _currentCommand->getTag().getTagNumber();

  for (p = listOfTools.begin(); p != listOfTools.end(); p++)
  {
    ippKToolPtr kt = *p;
    if( strcmp(kt->getName(),"UnDefTool") !=0 && strcmp(kt->getName(),"BaseTool")!=0) {
        ippResponsePtr r = new ippStringResponse(tag_num, kt->getName());
        _returningValues.push_back(r);
    }
  }
  
  generateCompletedResponse();

} // end executeEnumTools()

//==============================================================================
void  ippBasicExecutor::executeFindTool()
//-----------------------------------------------------------------------------
{
 
  const ippFindToolCommand * theFind =
      static_cast<const ippFindToolCommand *>(_currentCommand.get());

  ippKToolPtr foundTool = getTools()->findTool(theFind->getToolName());
  
  if (!foundTool || strcmp(foundTool->getName(),"UnDefTool") ==0 ){
    std::string  cmdStr =_currentCommand->getCommandString();
    ippResponsePtr x = new ippErrorResponse(_currentCommand->getTag(),ToolNotFound, cmdStr.c_str());
    _returningValues.push_back(x);
  }

  _world.update(_currentCommand);   //World updates found tool
  generateCompletedResponse();

} // end executeFindTool()

//==============================================================================
void ippBasicExecutor::executeGetChangeToolAction()
//-----------------------------------------------------------------------------
{
  double toolDiff = 0;
  toolDiff = _previousTool->getLength() - (getTools()->getActiveTool()->getLength()); 

  unsigned int tag_num = _currentCommand->getTag().getTagNumber();

  ippResponsePtr res = new ippGetChangeToolActionResponse(
      tag_num,Switch,0,0,toolDiff);
                                      //  changeToolActionType inChangeType,
                                      //  double inX, double inY, double inZ);

  _returningValues.push_back(res);

  generateCompletedResponse();

}

//=============================================================================
void  ippBasicExecutor::executeChangeTool()
//-----------------------------------------------------------------------------
{
  ippChangeToolCommandConstPtr cmd =
      static_cast<const ippChangeToolCommand *>(_currentCommand.get());

  ippKToolPtr foundTool = getTools()->findTool(cmd->getToolName());
  
  if (!foundTool ||
    strcmp(foundTool->getName(),"UnDefTool") ==0 ||
    strcmp(foundTool->getName(),"BaseTool") ==0 ) {
    std::string  cmdStr =_currentCommand->getCommandString();

    ippResponsePtr x = new ippErrorResponse(_currentCommand->getTag(),
                                ToolNotFound, cmdStr.c_str());

    _returningValues.push_back(x);
  }
  
  _previousTool = getTools()->getActiveTool();

  setTool(foundTool);

  _world.update(_currentCommand); // Execution world model changes
                                        // Sets the active tool

  generateCompletedResponse();

} // end executeChangeTool()


 //==============================================================================
void ippBasicExecutor::UpdateTools()
//-----------------------------------------------------------------------------
{
  IPP_ASSERT_FAIL("Should be overridden by the derived class->in this method\n"
              " the implementation should make sure that the tool collection"
              " of the world object reflects the actual state of the connected DME ");

}
 //==============================================================================
void ippBasicExecutor::setTool(ippKToolPtr& tool)
//-----------------------------------------------------------------------------
{
  IPP_ASSERT_FAIL("Should be overridden by the derived class->in this method\n"
              " the implementation should make sure that the specified tool is"
              " is set on the connected DME ");

}
//=============================================================================
void  ippBasicExecutor::executeSetTool()
//-----------------------------------------------------------------------------
{

   ippSetToolCommandConstPtr cmd =
      static_cast<const ippSetToolCommand *>(_currentCommand.get());

  ippKToolPtr foundTool = getTools()->findTool(cmd->getToolName());
  
  if (!foundTool) {
    // [TO DO] it is unclear what other tool might be disallowed here
    std::string  cmdStr =_currentCommand->getCommandString();

    ippResponsePtr x = new ippErrorResponse(_currentCommand->getTag(),
                               ToolNotFound, cmdStr.c_str());

    _returningValues.push_back(x);
  }

  setTool(foundTool);
  _world.update(_currentCommand);  // world performs update


  generateCompletedResponse();

} 


//==============================================================================
void  ippBasicExecutor::executeGetMachineClass()
//-----------------------------------------------------------------------------
{
  unsigned int tag_num = _currentCommand->getTag().getTagNumber();

  ippGetMachineClassResponsePtr r = new ippGetMachineClassResponse(tag_num);
  r->setMachineClass(_world.getMachineClass());
  _returningValues.push_back(r);
  generateCompletedResponse();

} 



//=============================================================================
void  ippBasicExecutor::executeDisableUser()
//-----------------------------------------------------------------------------
{
  _world.update(_currentCommand); // Execution world model changes
                                  // WM user_enabled flag to false
  generateCompletedResponse();

} 



//=============================================================================
void  ippBasicExecutor::executeEnableUser()
//-----------------------------------------------------------------------------
{
  _world.update(_currentCommand); // Execution world model changes
                                  // WM user_enabled flag to true
  generateCompletedResponse();
} 


//=============================================================================
void  ippBasicExecutor::executeIsUserEnabled()
//-----------------------------------------------------------------------------
{
  unsigned int tag_num = _currentCommand->getTag().getTagNumber();
  
  ippIsUserEnabledResponse *x = new ippIsUserEnabledResponse(
    tag_num, _world.getUserEnabled());
 
  _returningValues.push_back(x);

  generateCompletedResponse();

} 


//==============================================================================
void  ippBasicExecutor::executeGetCoordSystem()
//-----------------------------------------------------------------------------
{
  unsigned int tag_num = _currentCommand->getTag().getTagNumber();
  ippCoordSysType i = _world.getCurrentCsy();
  ippResponsePtr x = new ippGetCoordSystemResponse(tag_num, i);
  _returningValues.push_back(x);
  generateCompletedResponse();

} 

//==============================================================================
void  ippBasicExecutor::executeGetCsyTransformation()
//-----------------------------------------------------------------------------
{
  unsigned int tag_num =  _currentCommand->getTag().getTagNumber();
  ippGetCsyTransformationCommandConstPtr gcsytc
    = boost::static_pointer_cast<ippGetCsyTransformationCommand>(_currentCommand);

  ippCoordSysType cst = gcsytc->getCoordSys();
 
  ippCsyTransform * cT = 0;
 
  switch (cst){

    case JogDisplayCsy :
      cT = _world.getJogDisplayCsyTransform();
      break;
    case JogMoveCsy :
      cT = _world.getJogMoveCsyTransform();
      break;
    case MoveableMachineCsy :
      cT = _world.getMoveableCsyTransform();
      break;
    case MultipleArmCsy :
      cT = _world.getMultipleCsyTransform();
      break;
    case PartCsy :
      cT = _world.getPartCsyTransform();
      break;
    case SensorCsy :
      cT = _world.getSensorCsyTransform(); 
      break;
    default:
     IPP_ASSERT_FAIL("INVALID case");

  }
 
  ippResponsePtr x = new ippGetCsyTransformationResponse(
                          tag_num, 
                          cT->getX(), cT->getY(), cT->getZ(), 
                          cT->getTheta(), cT->getPsi(), cT->getPhi()
                        );


  _returningValues.push_back(x);

  generateCompletedResponse();

} 

//=============================================================================
void  ippBasicExecutor::executeSetCoordSystem()
//-----------------------------------------------------------------------------
{
  _world.update(_currentCommand);
  generateCompletedResponse();

} 



//=============================================================================
void  ippBasicExecutor::executeSetCsyTransformation()
//-----------------------------------------------------------------------------
{
  _world.update(_currentCommand);  // world performs update
  generateCompletedResponse();

} 



//=============================================================================
void ippBasicExecutor::executeEnumAllProp()
//-----------------------------------------------------------------------------
{
  ippEnumAllPropCommandConstPtr 
  cmd  = static_cast<const ippEnumAllPropCommand*>(_currentCommand.get());
  
  const ippProp& prop = cmd->getProp();

  GenerateEnumAllPropResponses(cmd,_returningValues);

  generateCompletedResponse();

}  

//==============================================================================
void ippBasicExecutor::executeEnumProp() 
//-----------------------------------------------------------------------------
{
  ippEnumPropCommandConstPtr theSet
    = boost::static_pointer_cast<ippEnumPropCommand>(_currentCommand);
  const ippProp& prop = theSet->getProp();

  GenerateEnumPropResponses(theSet,_returningValues);
  generateCompletedResponse();

} 

//=============================================================================
void  ippBasicExecutor::executeScanOnCircleHint()
//-----------------------------------------------------------------------------
{
  _world.update(_currentCommand);
  generateCompletedResponse();

}
//=============================================================================
void  ippBasicExecutor::executeScanOnLineHint()
//-----------------------------------------------------------------------------
{
  _world.update(_currentCommand);
  generateCompletedResponse();
} 
//=============================================================================
void  ippBasicExecutor::executeScanUnknownHint()
//-----------------------------------------------------------------------------
{
  _world.update(_currentCommand);
  generateCompletedResponse();
}
//=============================================================================
void ippBasicExecutor::executeScanOnCurveHint()
//-----------------------------------------------------------------------------
{
  // TO DO : provide a suitable implementation
  executeNotImplemented();
}


//==============================================================================
void ippBasicExecutor::executeNotImplemented()
//
// History
// DICC  Who When       What
// ----- --- ---------- -------------------------------------------------------
// <xxx> ER  20/05/2005 Written.
//-----------------------------------------------------------------------------
{
  generateErrorResponse(UnsupportedCommand," Command is currently not implemented" );
  generateCompletedResponse();
}

---