/home/sagar/ms/thesis/sarathi/src/libsarathi/libsarathi.cpp

Go to the documentation of this file.

#include "libsarathi.hpp"
#include "../gsoap/sarathi.nsmap"
#include <iostream>
#include <string>
#include <sstream>
#include <cassert>
#include <cstring>
#include <cstdio>
#include <cerrno>
#include <unistd.h>

namespace libsarathi {

sException::sException() throw() : std::runtime_error("Undefined fault")
{
        this->hintstring = "No hint available"; 
        this->detailstring = "No details available";
        this->errcode = 0;
}

sException::sException(std::string faultstr, std::string detailstr) throw() : std::runtime_error(faultstr)
{
        this->detailstring = (detailstr);
        this->hintstring = "No hint available";
        this->errcode = 0;

}

sException::sException(std::string faultstr, std::string detailstr, int err) throw() : std::runtime_error(faultstr)
{
        this->detailstring = (detailstr);
        this->hintstring = "No hint available";
        this->errcode = err;

}

sException::~sException() throw()
{
        this->exceptiondata_array.reset();
        this->exceptiondata_point.reset();
        this->errcode = 0;
}

const char* sException::detail() const throw()
{
        return this->detailstring.c_str();
}

const char* sException::hint() const throw()
{
        return this->hintstring.c_str();
}

void sException::get_exceptiondata(hyperpoint &point) const throw()
{
        point = this->exceptiondata_point;
        return;
}

void sException::get_exceptiondata(hyperarray &array) const throw()
{
        array = this->exceptiondata_array;
        return;
}

int sException::errorcode() const throw()
{
        return this->errcode;
}

serverProxy::serverProxy()
{
        sarathiServer = new sarathiProxy;
        sarathiServer->omode = SOAP_XML_INDENT;
        sarathiServer->soap_endpoint = NULL;
}

serverProxy::~serverProxy()
{
        if (sarathiServer->soap_endpoint != NULL)
                free ((void *)sarathiServer->soap_endpoint);
        delete sarathiServer;
}

int serverProxy::initialize (const std::string url, int port)
{
        std::string endpoint;
        endpoint += url;
        endpoint += ":";
        std::stringstream ss;
        ss << port;
        endpoint += ss.str();

        sarathiServer->soap_endpoint = strdup(endpoint.c_str());
//      std::cout << "serverProxy::initialize (): Server endpoint is: " << sarathiServer->soap_endpoint << std::endl;

        return (ALL_OK);
}

int serverProxy::stop (bool terminate_on_error)
{
        bool ok=false;
        if (sarathiServer->stop(terminate_on_error, ok)){
                sarathiServer->soap_print_fault(stderr);
                return (SOME_ERROR_OCCURRED);
        }
        return (ALL_OK);
}

int serverProxy::set_planner_file(std::string filename)
{
        bool ok = false;
        if (sarathiServer->set_planner_file(filename, ok) != SOAP_OK){
                handle_error();
                return (SOME_ERROR_OCCURRED);
        }
        return (ALL_OK);
}

int serverProxy::plan_to(std::string spacetype, hyperpoint *from, hyperpoint *to)
{
        bool ok = false;
        if (sarathiServer->plan_to(spacetype, from, to, ok)){
                handle_error();
                return (SOME_ERROR_OCCURRED);
        }
        return (ALL_OK);
}
        
int serverProxy::plan_along(std::string spacetype, hyperarray *keypoints)
{
        bool ok = false;
        if (sarathiServer->plan_along(spacetype, keypoints, ok) != SOAP_OK){
                handle_error();
                return (SOME_ERROR_OCCURRED);
        }
        return (ALL_OK);
}

int serverProxy::get_path(std::string spacetype, hyperarray *path)
{
        if (sarathiServer->get_path(spacetype, path) != SOAP_OK){
                handle_error();
                return (SOME_ERROR_OCCURRED);
        }
        return (ALL_OK);
}

int serverProxy::clear_path(void)
{
        bool ok = false;
        if (sarathiServer->clear_path(NULL,ok) != SOAP_OK){
                handle_error();
                return (SOME_ERROR_OCCURRED);
        }
        return (ALL_OK);
}

int serverProxy::get_position (std::string spacetype, hyperpoint *curr_pos)
{
        if (sarathiServer->get_position(spacetype, curr_pos) != SOAP_OK){
                handle_error();
                return (SOME_ERROR_OCCURRED);
        }
        return (ALL_OK);
}

int serverProxy::set_position(std::string spacetype, hyperpoint *des_pos)
{
        bool ok = false;
        if (sarathiServer->set_position(spacetype, des_pos, ok) != SOAP_OK){
                handle_error();
                return (SOME_ERROR_OCCURRED);
        }
        return (ALL_OK);
}

int serverProxy::move(void)
{
        bool ok = false;
        if (sarathiServer->move(NULL, ok) != SOAP_OK){
                handle_error();
                return (SOME_ERROR_OCCURRED);
        }
        return (ALL_OK);
}

int serverProxy::move_to (std::string spacetype, hyperpoint *point)
{
        bool ok = false;
        if (sarathiServer->move_to(spacetype, point, ok)){
                handle_error();
                return (SOME_ERROR_OCCURRED);
        }
        return (ALL_OK);
}

int serverProxy::move_along (std::string  spacetype, hyperarray *pointlist)
{
        bool ok = false;
        if (sarathiServer->move_along(spacetype, pointlist, ok)){
                handle_error();
                return (SOME_ERROR_OCCURRED);
        }
        return (ALL_OK);
}

int serverProxy::get_planning_status(std::string &status, bool &done, bool &result)
{       
        status.clear();
        if (sarathiServer->get_planning_status(NULL, status) != SOAP_OK){
                handle_error();
                return (SOME_ERROR_OCCURRED);
        }
                
//      std::cerr << "LIBSARATHI: get_planning_status() returned " << status;
        if (status.find("idle") != std::string::npos)
                done = true;
        else{
                done = false;
                result = false;
                return (ALL_OK);
        }
        if (status.find("success") != std::string::npos)
                result = true;
        else
                result = false;
        return (ALL_OK);
}

int serverProxy::get_motion_status(std::string &status, bool &done, bool &result)
{       
        status.clear();
        if (sarathiServer->get_motion_status(NULL, status) != SOAP_OK){
                handle_error();
                return (SOME_ERROR_OCCURRED);
        }
        if (status.find("idle") != std::string::npos)
                done = true;
        else{
                done = false;
                result = false;
                return (ALL_OK);
        }
        if (status.find("ERROR") != std::string::npos){
                done = true;
                result = false;
        }
        else
                result = true;
        //TODO: What is the value of done if status containes neither idle nor ERROR?
        return (ALL_OK);
}

void serverProxy::handle_error()
{
        int error_code = 0;
        std::string fault = sarathiServer->soap_fault_string();
        if (fault.find("Connection refused") != std::string::npos){
                error_code = ECONNREFUSED;
        }
        else if (fault.find("busy") != std::string::npos){
                error_code = EBUSY;
        }
        else if (fault.find("not found") != std::string::npos){
                error_code = ENOENT;
        }
        else if (fault.find("not yet implemented") != std::string::npos){
                error_code = EBADRQC;
        }
        else {
                error_code = EREMOTEIO;
        }
        
        throw sException(sarathiServer->soap_fault_string(), sarathiServer->soap_fault_detail(), error_code);
}       
}//namespace libsarathi

---