src/parsec/disk-image/parsec/parsec-benchmark/pkgs/tools/cmake/src/Utilities/cmxmlrpc/XmlRpcCpp.h - public/gem5-resources - Git at Google

 // -*- C++ -*-   <-- an Emacs control

 // Copyright information is at the bottom of the file.

 //=========================================================================
 //  XML-RPC C++ API
 //=========================================================================


 #ifndef  _XMLRPCCPP_H_
 #define  _XMLRPCCPP_H_ 1

 // The C++ standard says we should either include <string.h> (which gets
 // us the wrong header), or say 'using namespace std;' (which doesn't
 // work with our version of g++). So this header name is technically wrong.
 // Tell me what your compiler does; I can provide some autoconf magic to the
 // Right Thing on most platforms.
 //
 // 2004.12.22 Bryan: This looks like a problem with whatever g++ he was
 // using, so if anything, the special case should be for that.  In any case,
 // we've already added using namespace std to other files, without knowing
 // there was an issue, so I'm just going to do the "using namespace"
 // unconditionally and see who complains.  If there are complaints, we can
 // improve the documentation here.
 //
 // Formerly, the "using namespace std" was under
 // "#if defined(__GNUC__) && (__GNUC__ >= 3)".


 #include <string>

 using namespace std;

 #include <xmlrpc_config.h>
 #include <xmlrpc.h>
 #include <xmlrpc_client.h>
 #include <xmlrpc_server.h>

 #define XMLRPC_NO_ASSIGNMENT \
     XMLRPC_FATAL_ERROR("Assignment operator not available"); return *this;


 //=========================================================================
 //  XmlRpcFault
 //=========================================================================
 //  A C++ exception class representing an XML-RPC fault.

 class XmlRpcFault {

 private:
     xmlrpc_env   mFault;

     XmlRpcFault& operator= (const XmlRpcFault& f)
         { (void) f; XMLRPC_NO_ASSIGNMENT }

 public:
     XmlRpcFault (const XmlRpcFault &fault);
     XmlRpcFault (const int faultCode, const string faultString);
     XmlRpcFault (const xmlrpc_env *env);
     ~XmlRpcFault (void);

     int          getFaultCode (void) const;
     string       getFaultString (void) const;
     xmlrpc_env  *getFaultEnv (void);
 };

 inline int XmlRpcFault::getFaultCode (void) const {
     return mFault.fault_code;
 }

 inline xmlrpc_env *XmlRpcFault::getFaultEnv (void) {
     return &mFault;
 }


 //=========================================================================
 //  XmlRpcEnv
 //=========================================================================
 //  This class can be used to wrap xmlrpc_env object. Use it as follows:
 //
 //    XmlRpcEnv env;
 //    xmlrpc_parse_value(env, v, "(i)", &i);
 //    env.throwIfFaultOccurred();

 class XmlRpcEnv {

 private:
     xmlrpc_env   mEnv;

     void         throwMe (void) const;
     XmlRpcEnv&   operator= (const XmlRpcEnv& e)
         { (void) e; XMLRPC_NO_ASSIGNMENT }

 public:
     XmlRpcEnv (const XmlRpcEnv &env);
     XmlRpcEnv (void) { xmlrpc_env_init(&mEnv); }
     ~XmlRpcEnv (void) { xmlrpc_env_clean(&mEnv); }

     bool         faultOccurred (void) const { return mEnv.fault_occurred; };
     bool         hasFaultOccurred (void) const { return faultOccurred(); };
         /* hasFaultOccurred() is for backward compatibility.
            faultOccurred() is a superior name for this.
         */
     XmlRpcFault  getFault (void) const;

     void         throwIfFaultOccurred (void) const;

     operator xmlrpc_env * (void) { return &mEnv; }
 };

 inline void XmlRpcEnv::throwIfFaultOccurred (void) const {
     if (faultOccurred())
         throwMe();
 }


 //=========================================================================
 //  XmlRpcValue
 //=========================================================================
 //  An object in this class is an XML-RPC value.
 //
 //  We have a complex structure to allow C code mixed in with C++ code
 //  which uses this class to refer to the same XML-RPC value object.
 //  This is especially important because there aren't proper C++ facilities
 //  for much of Xmlrpc-c; you have to use the C facilities even if you'd
 //  rather use proper C++.
 //
 //  The XmlRpcValue object internally represents the value as an
 //  xmlrpc_value.  It hold one reference to the xmlrpc_value.  Users
 //  of XmlRpcValue never see that xmlrpc_value, but C code can.  the
 //  C code might create the xmlrpc_value and then bind it to an XmlRpcValue,
 //  or it might get the xmlrpc_value handle from the XmlRpcValue.  Finally,
 //  C code can simply use the XmlRpcValue where an xmlrpc_value handle is
 //  required and it gets converted automatically.
 //
 //  So reference counting for the xmlrpc_value is quite a nightmare.

 class XmlRpcValue {

 private:
     xmlrpc_value *mValue;

 public:
     enum ReferenceBehavior {
         MAKE_REFERENCE,
         CONSUME_REFERENCE
     };

     typedef xmlrpc_int32 int32;

     XmlRpcValue (void);
     XmlRpcValue (xmlrpc_value *value,
                  ReferenceBehavior behavior = MAKE_REFERENCE);
     XmlRpcValue (const XmlRpcValue& value);
     ~XmlRpcValue (void);

     XmlRpcValue&  operator= (const XmlRpcValue& value);

     // Accessing the value's type (think of this as lightweight RTTI).
     xmlrpc_type getType(void) const;

     // We don't supply an automatic conversion operator--you need to say
     // whether you want to make or borrow this object's reference.
     // XXX - Is it really OK for these to be const?
     xmlrpc_value *makeReference (void) const;
     xmlrpc_value *borrowReference (void) const;

     // Some static "constructor" functions.
     static XmlRpcValue makeInt      (const XmlRpcValue::int32 i);
     static XmlRpcValue makeBool     (const bool b);
     static XmlRpcValue makeDouble   (const double d);
     static XmlRpcValue makeDateTime (const string& dateTime);
     static XmlRpcValue makeString   (const string& str);
     static XmlRpcValue makeString   (const char *const str);
     static XmlRpcValue makeString   (const char *const str, size_t len);
     static XmlRpcValue makeArray    (void);
     static XmlRpcValue makeStruct   (void);
     static XmlRpcValue makeBase64   (const unsigned char *const data,
                                      size_t len);
     /*
     // An interface to xmlrpc_build_value.
     static XmlRpcValue buildValue (const char *const format, ...);
     */

     // Some functions to get the underlying data.
     // These will throw an XmlRpcFault if the data is the wrong type.
     XmlRpcValue::int32 getInt   (void) const;
     bool         getBool        (void) const;
     double       getDouble      (void) const;
     string       getRawDateTime (void) const;
     string       getString      (void) const;
     XmlRpcValue  getArray       (void) const;
     XmlRpcValue  getStruct      (void) const;

     // This returns an internal pointer which will become invalid when
     // all references to the underlying value are destroyed.
     void         getBase64      (const unsigned char *& out_data,
                                  size_t& out_len) const;

     /*
     // An interface to xmlrpc_parse_value.
     void parseValue (const char *const format, ...);
     */

     // Array functions. These will throw an XmlRpcFault if the value
     // isn't an array.
     size_t       arraySize (void) const;
     void         arrayAppendItem (const XmlRpcValue& value);
     XmlRpcValue  arrayGetItem (int index) const;

     // Struct functions. These will throw an XmlRpcFault if the value
     // isn't a struct.
     size_t       structSize (void) const;
     bool         structHasKey (const string& key) const;
     XmlRpcValue  structGetValue (const string& key) const;
     void         structSetValue (const string& key, const XmlRpcValue& value);
     void         structGetKeyAndValue (const int index,
                                        string& out_key,
                                        XmlRpcValue& out_value) const;
 };

 inline XmlRpcValue::XmlRpcValue (xmlrpc_value *value,
                                  ReferenceBehavior behavior)
 {
     mValue = value;

     if (behavior == MAKE_REFERENCE)
         xmlrpc_INCREF(value);
 }

 inline XmlRpcValue::XmlRpcValue (const XmlRpcValue& value) {
     mValue = value.mValue;
     xmlrpc_INCREF(mValue);
 }

 inline XmlRpcValue::~XmlRpcValue (void) {
     xmlrpc_DECREF(mValue);
 }

 inline XmlRpcValue& XmlRpcValue::operator= (const XmlRpcValue& value) {
     // Must increment before we decrement, in case of assignment to self.
     xmlrpc_INCREF(value.mValue);
     xmlrpc_DECREF(mValue);
     mValue = value.mValue;
     return *this;
 }

 inline xmlrpc_type XmlRpcValue::getType (void) const {
     return xmlrpc_value_type(mValue);
 }

 inline xmlrpc_value *XmlRpcValue::makeReference (void) const {
     xmlrpc_INCREF(mValue);
     return mValue;
 }

 inline xmlrpc_value *XmlRpcValue::borrowReference (void) const {
     return mValue;
 }


 //=========================================================================
 //  XmlRpcClient
 //=========================================================================

 class XmlRpcClient {

 private:
     string mServerUrl;

 public:
     static void Initialize (string appname, string appversion);
     static void Terminate (void);

     XmlRpcClient (const string& server_url) : mServerUrl(server_url) {}
     ~XmlRpcClient (void) {}

     XmlRpcClient (const XmlRpcClient& client);
     XmlRpcClient& operator= (const XmlRpcClient& client);

     XmlRpcValue call (string method_name, XmlRpcValue param_array);
     void call_asynch (string method_name,
                       XmlRpcValue param_array,
                       xmlrpc_response_handler callback,
                       void* user_data);
     void event_loop_asynch (unsigned long milliseconds);
 };

 inline void XmlRpcClient::call_asynch(string method_name,
                                       XmlRpcValue param_array,
                                       xmlrpc_response_handler callback,
                                       void* user_data)
 {
     xmlrpc_client_call_asynch_params(
         mServerUrl.c_str(),
         method_name.c_str(),
         callback,
         user_data,
         param_array.borrowReference());
 }

 inline void XmlRpcClient::event_loop_asynch(unsigned long milliseconds)
 {
     xmlrpc_client_event_loop_finish_asynch_timeout(milliseconds);
 }


 //=========================================================================
 //  XmlRpcClient Methods
 //=========================================================================
 //  These are inline for now, so we don't need to screw with linker issues
 //  and build a separate client library.

 inline XmlRpcClient::XmlRpcClient (const XmlRpcClient& client)
     : mServerUrl(client.mServerUrl)
 {
 }

 inline XmlRpcClient& XmlRpcClient::operator= (const XmlRpcClient& client) {
     if (this != &client)
         mServerUrl = client.mServerUrl;
     return *this;
 }

 inline void XmlRpcClient::Initialize (string appname, string appversion) {
     xmlrpc_client_init(XMLRPC_CLIENT_NO_FLAGS,
                        appname.c_str(),
                        appversion.c_str());
 }

 inline void XmlRpcClient::Terminate (void) {
     xmlrpc_client_cleanup();
 }

 inline XmlRpcValue XmlRpcClient::call (string method_name,
                        XmlRpcValue param_array)
 {
     XmlRpcEnv env;
     xmlrpc_value *result =
     xmlrpc_client_call_params(env,
                               mServerUrl.c_str(),
                               method_name.c_str(),
                               param_array.borrowReference());
     env.throwIfFaultOccurred();
     return XmlRpcValue(result, XmlRpcValue::CONSUME_REFERENCE);
 }

 //=========================================================================
 //  XmlRpcGenSrv
 //=========================================================================

 class XmlRpcGenSrv {

 private:

     xmlrpc_registry*    mRegistry;

     xmlrpc_mem_block* alloc (XmlRpcEnv& env, const string& body) const;

 public:

     XmlRpcGenSrv (int flags);
     ~XmlRpcGenSrv (void);

     xmlrpc_registry* getRegistry (void) const;

     XmlRpcGenSrv&   addMethod (const string& name,
                                xmlrpc_method method,
                                void *data);
     XmlRpcGenSrv&   addMethod (const string& name,
                                xmlrpc_method method,
                                void* data,
                                const string& signature,
                                const string& help);

     string handle (const string& body) const;
 };

 inline XmlRpcGenSrv::XmlRpcGenSrv (int flags) {

     XmlRpcEnv env;

     if (flags == flags){};

     mRegistry = xmlrpc_registry_new (env);
     env.throwIfFaultOccurred();
 }

 inline XmlRpcGenSrv::~XmlRpcGenSrv (void) {

     xmlrpc_registry_free (mRegistry);
 }

 inline xmlrpc_registry* XmlRpcGenSrv::getRegistry () const {

     return mRegistry;
 }

 #undef XMLRPC_NO_ASSIGNMENT


 // Copyright (C) 2001 by Eric Kidd. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions
 // are met:
 // 1. Redistributions of source code must retain the above copyright
 //    notice, this list of conditions and the following disclaimer.
 // 2. Redistributions in binary form must reproduce the above copyright
 //    notice, this list of conditions and the following disclaimer in the
 //    documentation and/or other materials provided with the distribution.
 // 3. The name of the author may not be used to endorse or promote products
 //    derived from this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 // ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 // OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 // HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 // OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 // SUCH DAMAGE.


 #endif /* _XMLRPCCPP_H_ */
	// -- C++ -- <-- an Emacs control

	// Copyright information is at the bottom of the file.

	//=========================================================================
	// XML-RPC C++ API
	//=========================================================================


	#ifndef _XMLRPCCPP_H_
	#define _XMLRPCCPP_H_ 1

	// The C++ standard says we should either include <string.h> (which gets
	// us the wrong header), or say 'using namespace std;' (which doesn't
	// work with our version of g++). So this header name is technically wrong.
	// Tell me what your compiler does; I can provide some autoconf magic to the
	// Right Thing on most platforms.
	//
	// 2004.12.22 Bryan: This looks like a problem with whatever g++ he was
	// using, so if anything, the special case should be for that. In any case,
	// we've already added using namespace std to other files, without knowing
	// there was an issue, so I'm just going to do the "using namespace"
	// unconditionally and see who complains. If there are complaints, we can
	// improve the documentation here.
	//
	// Formerly, the "using namespace std" was under
	// "#if defined(__GNUC__) && (__GNUC__ >= 3)".


	#include <string>

	using namespace std;

	#include <xmlrpc_config.h>
	#include <xmlrpc.h>
	#include <xmlrpc_client.h>
	#include <xmlrpc_server.h>

	#define XMLRPC_NO_ASSIGNMENT \
	XMLRPC_FATAL_ERROR("Assignment operator not available"); return *this;


	//=========================================================================
	// XmlRpcFault
	//=========================================================================
	// A C++ exception class representing an XML-RPC fault.

	class XmlRpcFault {

	private:
	xmlrpc_env mFault;

	XmlRpcFault& operator= (const XmlRpcFault& f)
	{ (void) f; XMLRPC_NO_ASSIGNMENT }

	public:
	XmlRpcFault (const XmlRpcFault &fault);
	XmlRpcFault (const int faultCode, const string faultString);
	XmlRpcFault (const xmlrpc_env *env);
	~XmlRpcFault (void);

	int getFaultCode (void) const;
	string getFaultString (void) const;
	xmlrpc_env *getFaultEnv (void);
	};

	inline int XmlRpcFault::getFaultCode (void) const {
	return mFault.fault_code;
	}

	inline xmlrpc_env *XmlRpcFault::getFaultEnv (void) {
	return &mFault;
	}


	//=========================================================================
	// XmlRpcEnv
	//=========================================================================
	// This class can be used to wrap xmlrpc_env object. Use it as follows:
	//
	// XmlRpcEnv env;
	// xmlrpc_parse_value(env, v, "(i)", &i);
	// env.throwIfFaultOccurred();

	class XmlRpcEnv {

	private:
	xmlrpc_env mEnv;

	void throwMe (void) const;
	XmlRpcEnv& operator= (const XmlRpcEnv& e)
	{ (void) e; XMLRPC_NO_ASSIGNMENT }

	public:
	XmlRpcEnv (const XmlRpcEnv &env);
	XmlRpcEnv (void) { xmlrpc_env_init(&mEnv); }
	~XmlRpcEnv (void) { xmlrpc_env_clean(&mEnv); }

	bool faultOccurred (void) const { return mEnv.fault_occurred; };
	bool hasFaultOccurred (void) const { return faultOccurred(); };
	/* hasFaultOccurred() is for backward compatibility.
	faultOccurred() is a superior name for this.
	*/
	XmlRpcFault getFault (void) const;

	void throwIfFaultOccurred (void) const;

	operator xmlrpc_env * (void) { return &mEnv; }
	};

	inline void XmlRpcEnv::throwIfFaultOccurred (void) const {
	if (faultOccurred())
	throwMe();
	}


	//=========================================================================
	// XmlRpcValue
	//=========================================================================
	// An object in this class is an XML-RPC value.
	//
	// We have a complex structure to allow C code mixed in with C++ code
	// which uses this class to refer to the same XML-RPC value object.
	// This is especially important because there aren't proper C++ facilities
	// for much of Xmlrpc-c; you have to use the C facilities even if you'd
	// rather use proper C++.
	//
	// The XmlRpcValue object internally represents the value as an
	// xmlrpc_value. It hold one reference to the xmlrpc_value. Users
	// of XmlRpcValue never see that xmlrpc_value, but C code can. the
	// C code might create the xmlrpc_value and then bind it to an XmlRpcValue,
	// or it might get the xmlrpc_value handle from the XmlRpcValue. Finally,
	// C code can simply use the XmlRpcValue where an xmlrpc_value handle is
	// required and it gets converted automatically.
	//
	// So reference counting for the xmlrpc_value is quite a nightmare.

	class XmlRpcValue {

	private:
	xmlrpc_value *mValue;

	public:
	enum ReferenceBehavior {
	MAKE_REFERENCE,
	CONSUME_REFERENCE
	};

	typedef xmlrpc_int32 int32;

	XmlRpcValue (void);
	XmlRpcValue (xmlrpc_value *value,
	ReferenceBehavior behavior = MAKE_REFERENCE);
	XmlRpcValue (const XmlRpcValue& value);
	~XmlRpcValue (void);

	XmlRpcValue& operator= (const XmlRpcValue& value);

	// Accessing the value's type (think of this as lightweight RTTI).
	xmlrpc_type getType(void) const;

	// We don't supply an automatic conversion operator--you need to say
	// whether you want to make or borrow this object's reference.
	// XXX - Is it really OK for these to be const?
	xmlrpc_value *makeReference (void) const;
	xmlrpc_value *borrowReference (void) const;

	// Some static "constructor" functions.
	static XmlRpcValue makeInt (const XmlRpcValue::int32 i);
	static XmlRpcValue makeBool (const bool b);
	static XmlRpcValue makeDouble (const double d);
	static XmlRpcValue makeDateTime (const string& dateTime);
	static XmlRpcValue makeString (const string& str);
	static XmlRpcValue makeString (const char *const str);
	static XmlRpcValue makeString (const char *const str, size_t len);
	static XmlRpcValue makeArray (void);
	static XmlRpcValue makeStruct (void);
	static XmlRpcValue makeBase64 (const unsigned char *const data,
	size_t len);
	/*
	// An interface to xmlrpc_build_value.
	static XmlRpcValue buildValue (const char *const format, ...);
	*/

	// Some functions to get the underlying data.
	// These will throw an XmlRpcFault if the data is the wrong type.
	XmlRpcValue::int32 getInt (void) const;
	bool getBool (void) const;
	double getDouble (void) const;
	string getRawDateTime (void) const;
	string getString (void) const;
	XmlRpcValue getArray (void) const;
	XmlRpcValue getStruct (void) const;

	// This returns an internal pointer which will become invalid when
	// all references to the underlying value are destroyed.
	void getBase64 (const unsigned char *& out_data,
	size_t& out_len) const;

	/*
	// An interface to xmlrpc_parse_value.
	void parseValue (const char *const format, ...);
	*/

	// Array functions. These will throw an XmlRpcFault if the value
	// isn't an array.
	size_t arraySize (void) const;
	void arrayAppendItem (const XmlRpcValue& value);
	XmlRpcValue arrayGetItem (int index) const;

	// Struct functions. These will throw an XmlRpcFault if the value
	// isn't a struct.
	size_t structSize (void) const;
	bool structHasKey (const string& key) const;
	XmlRpcValue structGetValue (const string& key) const;
	void structSetValue (const string& key, const XmlRpcValue& value);
	void structGetKeyAndValue (const int index,
	string& out_key,
	XmlRpcValue& out_value) const;
	};

	inline XmlRpcValue::XmlRpcValue (xmlrpc_value *value,
	ReferenceBehavior behavior)
	{
	mValue = value;

	if (behavior == MAKE_REFERENCE)
	xmlrpc_INCREF(value);
	}

	inline XmlRpcValue::XmlRpcValue (const XmlRpcValue& value) {
	mValue = value.mValue;
	xmlrpc_INCREF(mValue);
	}

	inline XmlRpcValue::~XmlRpcValue (void) {
	xmlrpc_DECREF(mValue);
	}

	inline XmlRpcValue& XmlRpcValue::operator= (const XmlRpcValue& value) {
	// Must increment before we decrement, in case of assignment to self.
	xmlrpc_INCREF(value.mValue);
	xmlrpc_DECREF(mValue);
	mValue = value.mValue;
	return *this;
	}

	inline xmlrpc_type XmlRpcValue::getType (void) const {
	return xmlrpc_value_type(mValue);
	}

	inline xmlrpc_value *XmlRpcValue::makeReference (void) const {
	xmlrpc_INCREF(mValue);
	return mValue;
	}

	inline xmlrpc_value *XmlRpcValue::borrowReference (void) const {
	return mValue;
	}


	//=========================================================================
	// XmlRpcClient
	//=========================================================================

	class XmlRpcClient {

	private:
	string mServerUrl;

	public:
	static void Initialize (string appname, string appversion);
	static void Terminate (void);

	XmlRpcClient (const string& server_url) : mServerUrl(server_url) {}
	~XmlRpcClient (void) {}

	XmlRpcClient (const XmlRpcClient& client);
	XmlRpcClient& operator= (const XmlRpcClient& client);

	XmlRpcValue call (string method_name, XmlRpcValue param_array);
	void call_asynch (string method_name,
	XmlRpcValue param_array,
	xmlrpc_response_handler callback,
	void* user_data);
	void event_loop_asynch (unsigned long milliseconds);
	};

	inline void XmlRpcClient::call_asynch(string method_name,
	XmlRpcValue param_array,
	xmlrpc_response_handler callback,
	void* user_data)
	{
	xmlrpc_client_call_asynch_params(
	mServerUrl.c_str(),
	method_name.c_str(),
	callback,
	user_data,
	param_array.borrowReference());
	}

	inline void XmlRpcClient::event_loop_asynch(unsigned long milliseconds)
	{
	xmlrpc_client_event_loop_finish_asynch_timeout(milliseconds);
	}


	//=========================================================================
	// XmlRpcClient Methods
	//=========================================================================
	// These are inline for now, so we don't need to screw with linker issues
	// and build a separate client library.

	inline XmlRpcClient::XmlRpcClient (const XmlRpcClient& client)
	: mServerUrl(client.mServerUrl)
	{
	}

	inline XmlRpcClient& XmlRpcClient::operator= (const XmlRpcClient& client) {
	if (this != &client)
	mServerUrl = client.mServerUrl;
	return *this;
	}

	inline void XmlRpcClient::Initialize (string appname, string appversion) {
	xmlrpc_client_init(XMLRPC_CLIENT_NO_FLAGS,
	appname.c_str(),
	appversion.c_str());
	}

	inline void XmlRpcClient::Terminate (void) {
	xmlrpc_client_cleanup();
	}

	inline XmlRpcValue XmlRpcClient::call (string method_name,
	XmlRpcValue param_array)
	{
	XmlRpcEnv env;
	xmlrpc_value *result =
	xmlrpc_client_call_params(env,
	mServerUrl.c_str(),
	method_name.c_str(),
	param_array.borrowReference());
	env.throwIfFaultOccurred();
	return XmlRpcValue(result, XmlRpcValue::CONSUME_REFERENCE);
	}

	//=========================================================================
	// XmlRpcGenSrv
	//=========================================================================

	class XmlRpcGenSrv {

	private:

	xmlrpc_registry* mRegistry;

	xmlrpc_mem_block* alloc (XmlRpcEnv& env, const string& body) const;

	public:

	XmlRpcGenSrv (int flags);
	~XmlRpcGenSrv (void);

	xmlrpc_registry* getRegistry (void) const;

	XmlRpcGenSrv& addMethod (const string& name,
	xmlrpc_method method,
	void *data);
	XmlRpcGenSrv& addMethod (const string& name,
	xmlrpc_method method,
	void* data,
	const string& signature,
	const string& help);

	string handle (const string& body) const;
	};

	inline XmlRpcGenSrv::XmlRpcGenSrv (int flags) {

	XmlRpcEnv env;

	if (flags == flags){};

	mRegistry = xmlrpc_registry_new (env);
	env.throwIfFaultOccurred();
	}

	inline XmlRpcGenSrv::~XmlRpcGenSrv (void) {

	xmlrpc_registry_free (mRegistry);
	}

	inline xmlrpc_registry* XmlRpcGenSrv::getRegistry () const {

	return mRegistry;
	}

	#undef XMLRPC_NO_ASSIGNMENT


	// Copyright (C) 2001 by Eric Kidd. All rights reserved.
	//
	// Redistribution and use in source and binary forms, with or without
	// modification, are permitted provided that the following conditions
	// are met:
	// 1. Redistributions of source code must retain the above copyright
	// notice, this list of conditions and the following disclaimer.
	// 2. Redistributions in binary form must reproduce the above copyright
	// notice, this list of conditions and the following disclaimer in the
	// documentation and/or other materials provided with the distribution.
	// 3. The name of the author may not be used to endorse or promote products
	// derived from this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
	// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	// ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
	// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	// SUCH DAMAGE.


	#endif /* _XMLRPCCPP_H_ */