XmlRpcClient.h

Go to the documentation of this file.

#include "sick_scan/sick_scan_base.h" /* Base definitions included in all header files, added by add_sick_scan_base_header.py. Do not edit this line. */
 
#ifndef _XMLRPCCLIENT_H_
#define _XMLRPCCLIENT_H_
//
// XmlRpc++ Copyright (c) 2002-2003 by Chris Morley
//
#if defined(_MSC_VER)
# pragma warning(disable:4786)    // identifier was truncated in debug info
#endif
 
 
#ifndef MAKEDEPEND
# include <string>
#endif
 
#include "xmlrpcpp/XmlRpcDispatch.h"
#include "xmlrpcpp/XmlRpcSource.h"
#include "xmlrpcpp/XmlRpcDecl.h"
 
namespace XmlRpc {
 
  // Arguments and results are represented by XmlRpcValues
  class XmlRpcValue;
 
  class XMLRPCPP_DECL XmlRpcClient : public XmlRpcSource {
  public:
    // Static data
    static const char REQUEST_BEGIN[];
    static const char REQUEST_END_METHODNAME[];
    static const char PARAMS_TAG[];
    static const char PARAMS_ETAG[];
    static const char PARAM_TAG[];
    static const char PARAM_ETAG[];
    static const char REQUEST_END[];
    // Result tags
    static const char METHODRESPONSE_TAG[];
    static const char FAULT_TAG[];
 
    XmlRpcClient(const char* host, int port, const char* uri=0);
 
    virtual ~XmlRpcClient();
 
    bool execute(const char* method, XmlRpcValue const& params, XmlRpcValue& result);
 
    bool executeNonBlock(const char* method, XmlRpcValue const& params);
    bool executeCheckDone(XmlRpcValue& result);
 
    bool isFault() const { return _isFault; }
 
 
    // XmlRpcSource interface implementation
    virtual void close();
 
    virtual unsigned handleEvent(unsigned eventType);
 
  protected:
    // Execution processing helpers
    virtual bool doConnect();
    virtual bool setupConnection();
 
    virtual bool generateRequest(const char* method, XmlRpcValue const& params);
    virtual std::string generateHeader(std::string const& body);
    virtual bool writeRequest();
    virtual bool readHeader();
    virtual bool readResponse();
    virtual bool parseResponse(XmlRpcValue& result);
 
    // Possible IO states for the connection
    enum ClientConnectionState { NO_CONNECTION, CONNECTING, WRITE_REQUEST, READ_HEADER, READ_RESPONSE, IDLE };
    ClientConnectionState _connectionState;
 
    // Server location
    std::string _host;
    std::string _uri;
    int _port;
  public:
    const std::string &getHost() { return _host; }
    const std::string &getUri()  { return _uri; }
    int getPort() const { return _port; }
    
    // The xml-encoded request, http header of response, and response xml
    std::string _request;
    std::string _header;
    std::string _response;
 
    // Number of times the client has attempted to send the request
    int _sendAttempts;
 
    // Number of bytes of the request that have been written to the socket so far
    int _bytesWritten;
 
    // True if we are currently executing a request. If you want to multithread,
    // each thread should have its own client.
    bool _executing;
 
    // True if the server closed the connection
    bool _eof;
 
    // True if a fault response was returned by the server
    bool _isFault;
 
    // Number of bytes expected in the response body (parsed from response header)
    int _contentLength;
 
    // Event dispatcher
    XmlRpcDispatch _disp;
 
  };    // class XmlRpcClient
 
}       // namespace XmlRpc
 
#endif  // _XMLRPCCLIENT_H_