server/Server.cpp

Go to the documentation of this file.

//## begin module%3796143E0382.cm preserve=no
//        %X% %Q% %Z% %W%
//## end module%3796143E0382.cm

//## begin module%3796143E0382.cp preserve=no
//## end module%3796143E0382.cp

//## Module: Server%3796143E0382; Pseudo Package body
//## Source file: E:\mpk\code\MPKserver\Server.cpp

//## begin module%3796143E0382.additionalIncludes preserve=no
//## end module%3796143E0382.additionalIncludes

//## begin module%3796143E0382.includes preserve=yes
#pragma warning( disable : 4786 )
#include <assert.h>
#include <iostream>
#include <planners\plannertype.h>
#include <stdio.h>
#include <strstream>
#include <string.h>
#include "windows.h"
//IMPROVE: alphabetize these
//## end module%3796143E0382.includes

// Server
#include "server\Server.h"
//## begin module%3796143E0382.additionalDeclarations preserve=yes
const int stringSize = 500 ;
using std::cout ;
using std::endl ;
using std::istrstream ;

//## end module%3796143E0382.additionalDeclarations

// Class Server 


//## begin Server::numberOfServers%37A1F74F009C.attr preserve=no  protected: static int {UA} 0
int Server::numberOfServers = 0;
//## end Server::numberOfServers%37A1F74F009C.attr

Server::Server (SOCKET socket )
  //## begin Server::Server%933360616.hasinit preserve=no
      : socketOK(true)
  //## end Server::Server%933360616.hasinit
  //## begin Server::Server%933360616.initialization preserve=yes
  ,socket( socket )
  //## end Server::Server%933360616.initialization
{
  //## begin Server::Server%933360616.body preserve=yes
        m_CurrentConfig = m_StartConfig ;
        numberOfServers++ ;
  //## end Server::Server%933360616.body
}


Server::~Server()
{
  //## begin Server::~Server%.body preserve=yes
        numberOfServers-- ;
  //## end Server::~Server%.body
}



//## Other Operations (implementation)
bool Server::ExecuteCommand (const char* command)
{
  //## begin Server::ExecuteCommand%932581524.body preserve=yes

        static const char specifyRobotCommand[]         =       "#specify_robot" ;
        static const char specifyCollisionDetector[]    =       "#specify_collision_detector" ;
        static const char specifyPlanner[]                              =       "#specify_planner" ;
        static const char planCommand[]                         =       "#plan" ;
        static const char sendPath[]                                    =       "#send_path" ;
        static const char startConfig[]                         =       "#start_config" ;
        static const char goalConfig[]                                  =       "#goal_config" ;
        static const char specifyEnvironment[]                  =       "#specify_workspace" ;
        static const char configure[]                                   =       "#configure" ;
        static const char redrawCommand[]                               =       "#redraw" ;

        cout << "Executing command: " << command << endl ;

        //determine the command
        //extract the first word of the command         //IMPROVE: this should be a function
        char firstWord[ stringSize ] = "" ;
        sscanf( command, "%s", firstWord ) ;
        int numChars = strlen( firstWord ) ;
        char* offset = strstr( command, firstWord ) ;

        //check if it's a configure command - moves the position of the robot
        if( stricmp( firstWord, configure ) == 0 )
        {
                return ConfigureRobot( offset + numChars ) ;
        }

        //check if it's a "specify_robot" command
        if( stricmp( firstWord, specifyRobotCommand ) == 0 )
        {
                return SpecifyRobot( offset + numChars ) ;
        }

        //check if it's a "specify_environment" command
        if( stricmp( firstWord, specifyEnvironment ) == 0 )
        {
                return SpecifyEnvironment( offset + numChars ) ;
        }

        //check if it's a "specify_collision_detector" command
        if( stricmp( firstWord, specifyCollisionDetector ) == 0 )
        {
                return SpecifyCollisionDetector( command + numChars ) ;
        }

        //check if it's a "specify_planner" command
        if( stricmp( firstWord, specifyPlanner ) == 0 )
        {
                return SpecifyPlanner( command + numChars ) ;
        }

        //check if it's a "plan" command
        if( stricmp( firstWord, planCommand ) == 0 )
        {
                return Plan() ;
        }

        //check if it's a "sendPath" command
        if( stricmp( firstWord, sendPath) == 0 )
        {
                SendPath() ;    //IMPROVE: should this return a bool?
                return true ;
        }

        //check if it's a "startConfig" command
        if( stricmp( firstWord, startConfig ) == 0 )
        {
                return StartConfig( command + numChars ) ;
        }

        //check if it's a "goalConfig" command
        if( stricmp( firstWord, goalConfig ) == 0 )
        {
                return GoalConfig( command + numChars ) ;
        }

        //check if it's a "redraw" command
        //IMPROVE: the most frequently used commands should come first in the if checking
        if( stricmp( firstWord, redrawCommand ) == 0 )
        {
                return Redraw( command + numChars ) ;
        }

        cout << "Unknown command: " << firstWord << endl ;
        return false ;  //unknown command
  //## end Server::ExecuteCommand%932581524.body
}

bool Server::SpecifyRobot (const char* command)
{
  //## begin Server::SpecifyRobot%932600044.body preserve=yes
        const char threeCylinderRobot[] = "ThreeCylinderRobot" ;

        //extract the first word of the command 
        char firstWord[ stringSize ] = "" ;
        sscanf( command, "%s", firstWord ) ;
        int numChars = strlen( firstWord ) ;

        if( stricmp( firstWord, threeCylinderRobot ) == 0 )
        {
                R_ThreeCylinderRobot() ;
                return true ;
        }

        cout << "Specify Robot, Unknown Command: " << firstWord << endl ;
        return false ;
  //## end Server::SpecifyRobot%932600044.body
}

bool Server::SpecifyCollisionDetector (const char* command)
{
  //## begin Server::SpecifyCollisionDetector%932600046.body preserve=yes
        const char vcollide[] = "vcollide" ;

        //extract the first word of the command 
        char firstWord[ stringSize ] = "" ;
        sscanf( command, "%s", firstWord ) ;
        int numChars = strlen( firstWord ) ;

        delete collisionDetector ;

        if( stricmp( firstWord, vcollide ) == 0 )
        {
                this->SetCollisionDetector( CD_VCOLLIDE ) ;//IMPROVE: this can potentially yeild an error code
                return true ;
        }
        else
        {
                cout << "Specify CollisionDetector, Unknown Command: " << firstWord << endl ;
                return false ;
        }
        planner->SetCollisionDetector( collisionDetector ) ;
  //## end Server::SpecifyCollisionDetector%932600046.body
}

bool Server::SpecifyPlanner (const char* command)
{
  //## begin Server::SpecifyPlanner%932600048.body preserve=yes
        const char aca[] = "aca" ;
        const char sequential[] = "sequential" ;

        //extract the first word of the command 
        char firstWord[ stringSize ] = "" ;
        sscanf( command, "%s", firstWord ) ;
        int numChars = strlen( firstWord ) ;

        bool success = true ;
        if( stricmp( firstWord, aca ) == 0 )
        {
                success &= this->SetPlanner( PLANNER_ACA ) ;
                //P_Aca() ;             //IMPROVE: this can potentially yeild an error code
        }
        else if( stricmp( firstWord, sequential ) == 0 )
        {
                success &= this->SetPlanner( PLANNER_SEQUENTIAL ) ;
                //P_Sequential() ;
        }
        else
        {
                //this is the case where the command is unknown
                cout << "Specify Planner, Unknown Command: " << firstWord << endl ;
                return false ;
        }
        //planner->SetCollisionDetector( collisionDetector ) ;
        return success ;
  //## end Server::SpecifyPlanner%932600048.body
}

bool Server::Plan ()
{
  //## begin Server::Plan%932600050.body preserve=yes
        this->SetCollisionDetector( collisionDetectorType ) ;
        assert( collisionDetector != NULL ) ;   //there must be a collision detector at this point

        CD_BasicStyle* cd = dynamic_cast< CD_BasicStyle* >( collisionDetector ) ;
        planner->SetCollisionDetector( cd ) ;   //IMPROVE: is this in multiple places?
        //IMPROVE: don't want to have CD_Vcollide explicitly cast here 

        planner->SetStartConfig( m_StartConfig ) ;      //IMPROVE: why does this call plannerbase, not PL_Juan
        planner->SetGoalConfig( m_GoalConfig ) ;
        planPassed = planner->Plan() ;
        return true ;
  //## end Server::Plan%932600050.body
}

void Server::SendString (const char* str) const
{
  //## begin Server::SendString%933360615.body preserve=yes
        char* copy = new char[ strlen( str ) * 2 ]  ;
        strcpy( copy, str ) ;
        FixNewlines( copy ) ;

        if( send( socket, copy, strlen( copy ), 0 ) == SOCKET_ERROR ) 
        {
                fprintf( stderr, "mpk send error: %d\n", GetLastError() ) ;
                closesocket( socket ) ;
                socketOK = false ;
        }

        delete[] copy ;
  //## end Server::SendString%933360615.body
}

bool Server::SocketOK () const
{
  //## begin Server::SocketOK%933360617.body preserve=yes
        return socketOK ;
  //## end Server::SocketOK%933360617.body
}

void Server::SendPath () const
{
  //## begin Server::SendPath%933360618.body preserve=yes
        const PathBase* path = planner->GetPath() ;
        if( planPassed == false )
        {
                char failedString[] = "#PATH_FAILED\n" ;
                this->SendString( failedString ) ;
        }
        else
        {
                char str[ 1000 ] = "";          //IMPROVE: is 1000 enough?
                path->Serialize( str, 1000 ) ;
                this->SendString( str ) ;
        }
  //## end Server::SendPath%933360618.body
}

bool Server::StartConfig (const char* command)
{
  //## begin Server::StartConfig%933617731.body preserve=yes
        int length = strlen( command ) ;
        char* copy = new char [ length + 1 ] ;
        strcpy( copy, command ) ;
        istrstream instr( copy, length ) ;
        
        Configuration config ;
        instr >> config ;
        m_StartConfig = config ;
        assert( m_StartConfig.Length() != 0 ) ;

        delete[] copy ;
        //IMPROVE: need some error checking about sizes and ranges?

        return true ;
  //## end Server::StartConfig%933617731.body
}

bool Server::GoalConfig (const char* command)
{
  //## begin Server::GoalConfig%933617732.body preserve=yes
        int length = strlen( command ) ;
        char* copy = new char [ length + 1 ] ;
        strcpy( copy, command ) ;
        istrstream instr( copy, strlen( copy ) ) ;
        Configuration config ;
        instr >> config ;
        m_GoalConfig = config ;
        assert( m_GoalConfig.Length() != 0 ) ;

        delete[] copy ;
        //IMPROVE: need some error checking about sizes and ranges?

        return true ;
  //## end Server::GoalConfig%933617732.body
}

void Server::FixNewlines (char* str)
{
  //## begin Server::FixNewlines%933617733.body preserve=yes
        
        char* buffer = new char[ strlen( str ) * 2 ] ;
        strcpy( buffer, str ) ;

        int j = 0 ;

        //look for all the '\n's in the string, and replace them with '/r/n'
        for( int i = 0; i < strlen( str ); i++ )
        {
                //if you find an '\n'
                if( ( str[ i ] == '\n' ) && ( str[ i - 1 ] != '\r' ) )
                {
                        //move the string down one and insert the '\r'
                        strcpy( buffer + j + 2, str + i +1 ) ;
                        buffer[ j ]             = char( '\r' );
                        buffer[ j + 1 ] = char( '\n' );
                        j++ ;
                }
                j++ ;
        }

        strcpy( str, buffer ) ;
        delete[] buffer ;
  //## end Server::FixNewlines%933617733.body
}

bool Server::SpecifyEnvironment (const char* command)
{
  //## begin Server::SpecifyEnvironment%936229639.body preserve=yes
        return ParseObstacleFile( command ) ;
        //return ParseObstacleFile( "\nshapes/environment.wrl" ) ;
  //## end Server::SpecifyEnvironment%936229639.body
}

// Additional Declarations
  //## begin Server%3796143E0382.declarations preserve=yes
bool Server::ConfigureRobot( const char* command )
{
        int length = strlen( command ) ;
        char* copy = new char [ length + 1 ] ;
        strcpy( copy, command ) ;
        istrstream instr( copy, strlen( copy ) ) ;
        Configuration config ;
        instr >> config ;
        m_CurrentConfig = config ;
        double c0 = config[ 0 ] ;
        double c1 = config[ 1 ] ;
        double c2 = config[ 2 ] ;
        assert( m_CurrentConfig.Length() != 0 ) ;

        Redraw( NULL ) ;
        delete[] copy ;
        //IMPROVE: need some error checking about sizes and ranges?
        return true ;
}

bool Server::Redraw( const char* command ) const
{
        //IMPROVE: why does this function require a string as a parameter?
        //IMPROVE: accomplish refreshing the views some other way.  I expect this to be really slow
        ::InvalidateRect( NULL, NULL, FALSE ) ;
        return true ;
}
  //## end Server%3796143E0382.declarations

//## begin module%3796143E0382.epilog preserve=yes
//## end module%3796143E0382.epilog

---