mirror of
https://github.com/stefanocasazza/ULib.git
synced 2025-09-28 19:05:55 +08:00
245 lines
8.4 KiB
C++
245 lines
8.4 KiB
C++
// ============================================================================
|
|
//
|
|
// = LIBRARY
|
|
// ULib - c++ library
|
|
//
|
|
// = FILENAME
|
|
// soap_encoder.h
|
|
//
|
|
// = AUTHOR
|
|
// Stefano Casazza
|
|
//
|
|
// ============================================================================
|
|
|
|
#ifndef ULIB_SOAP_ENCODER_H
|
|
#define ULIB_SOAP_ENCODER_H 1
|
|
|
|
#include <ulib/utility/base64.h>
|
|
#include <ulib/net/rpc/rpc_encoder.h>
|
|
|
|
/**
|
|
* @class USOAPEncoder
|
|
*
|
|
* Here's something that templates and C++ still can't handle. Using this in conjunction with
|
|
* the encodeArgument() methods below, we avoid type WRT the argument names. Spell it wrong and
|
|
* you get a compile time error. Better at compile-time then run-time
|
|
*/
|
|
|
|
#define U_SOAP_ENCODE_ARG(arg) ((USOAPEncoder*)URPCMethod::encoder)->encodeArgument(U_STRING_FROM_CONSTANT("" #arg ""), arg)
|
|
#define U_SOAP_ENCB64_ARG(arg) ((USOAPEncoder*)URPCMethod::encoder)->encodeArgBase64(U_STRING_FROM_CONSTANT("" #arg ""),arg)
|
|
#define U_SOAP_ENCODE_RES(arg) ((USOAPEncoder*)URPCMethod::encoder)->encodeResponse(arg)
|
|
#define U_SOAP_ENCODE_NAME_ARG(name, arg) ((USOAPEncoder*)URPCMethod::encoder)->encodeArgument(name, arg)
|
|
#define U_SOAP_ENCB64_NAME_ARG(name, arg) ((USOAPEncoder*)URPCMethod::encoder)->encodeArgBase64(name, arg)
|
|
|
|
class U_EXPORT USOAPEncoder : public URPCEncoder {
|
|
public:
|
|
|
|
USOAPEncoder()
|
|
{
|
|
U_TRACE_CTOR(0, USOAPEncoder, "")
|
|
}
|
|
|
|
virtual ~USOAPEncoder()
|
|
{
|
|
U_TRACE_DTOR(0, USOAPEncoder)
|
|
}
|
|
|
|
// ENCODING FUNCTIONS
|
|
|
|
virtual void encodeArgument(const UString& argName, const UString& argType, const UString& argContent) U_DECL_OVERRIDE;
|
|
|
|
void encodeArgument(const UString& argName, const UString& argType, bool value)
|
|
{ URPCEncoder::encodeArgument(argName, argType, value); }
|
|
|
|
void encodeArgument(const UString& argName, const UString& argType, char value)
|
|
{ URPCEncoder::encodeArgument(argName, argType, value); }
|
|
|
|
void encodeArgument(const UString& argName, const UString& argType, unsigned char value)
|
|
{ URPCEncoder::encodeArgument(argName, argType, value); }
|
|
|
|
void encodeArgument(const UString& argName, const UString& argType, short value)
|
|
{ URPCEncoder::encodeArgument(argName, argType, value); }
|
|
|
|
void encodeArgument(const UString& argName, const UString& argType, unsigned short value)
|
|
{ URPCEncoder::encodeArgument(argName, argType, value); }
|
|
|
|
void encodeArgument(const UString& argName, const UString& argType, int value)
|
|
{ URPCEncoder::encodeArgument(argName, argType, value); }
|
|
|
|
void encodeArgument(const UString& argName, const UString& argType, unsigned int value)
|
|
{ URPCEncoder::encodeArgument(argName, argType, value); }
|
|
|
|
void encodeArgument(const UString& argName, const UString& argType, long int value)
|
|
{ URPCEncoder::encodeArgument(argName, argType, value); }
|
|
|
|
void encodeArgument(const UString& argName, const UString& argType, unsigned long int value)
|
|
{ URPCEncoder::encodeArgument(argName, argType, value); }
|
|
|
|
void encodeArgument(const UString& argName, const UString& argType, const long long& value)
|
|
{ URPCEncoder::encodeArgument(argName, argType, value); }
|
|
|
|
void encodeArgument(const UString& argName, const UString& argType, const unsigned long long& value)
|
|
{ URPCEncoder::encodeArgument(argName, argType, value); }
|
|
|
|
void encodeArgument(const UString& argName, const UString& argType, float value)
|
|
{ URPCEncoder::encodeArgument(argName, argType, value); }
|
|
|
|
void encodeArgument(const UString& argName, const UString& argType, const double& value)
|
|
{ URPCEncoder::encodeArgument(argName, argType, value); }
|
|
|
|
// This set of overloads encodes the argument using the xsd:[type] data as <argName>value</argName>.
|
|
// To avoid spelling errors, I recommend using the encodeArg macro, which can produce the argument name and value
|
|
|
|
void encodeArgument(const UString& argName, bool value)
|
|
{
|
|
U_TRACE(0, "USOAPEncoder::encodeArgument(%V,%b)", argName.rep, value)
|
|
|
|
encodeArgument(argName, *UString::str_boolean, value);
|
|
}
|
|
|
|
void encodeArgument(const UString& argName, char value)
|
|
{
|
|
U_TRACE(0, "USOAPEncoder::encodeArgument(%V,%C)", argName.rep, value)
|
|
|
|
encodeArgument(argName, *UString::str_byte, value);
|
|
}
|
|
|
|
void encodeArgument(const UString& argName, unsigned char value)
|
|
{
|
|
U_TRACE(0, "USOAPEncoder::encodeArgument(%V,%C)", argName.rep, value)
|
|
|
|
encodeArgument(argName, *UString::str_unsignedByte, value);
|
|
}
|
|
|
|
void encodeArgument(const UString& argName, short value)
|
|
{
|
|
U_TRACE(0, "USOAPEncoder::encodeArgument(%V,%d)", argName.rep, value)
|
|
|
|
encodeArgument(argName, *UString::str_short, value);
|
|
}
|
|
|
|
void encodeArgument(const UString& argName, unsigned short value)
|
|
{
|
|
U_TRACE(0, "USOAPEncoder::encodeArgument(%V,%d)", argName.rep, value)
|
|
|
|
encodeArgument(argName, *UString::str_unsignedShort, value);
|
|
}
|
|
|
|
void encodeArgument(const UString& argName, int value)
|
|
{
|
|
U_TRACE(0, "USOAPEncoder::encodeArgument(%V,%d)", argName.rep, value)
|
|
|
|
encodeArgument(argName, *UString::str_int, value);
|
|
}
|
|
|
|
void encodeArgument(const UString& argName, unsigned int value)
|
|
{
|
|
U_TRACE(0, "USOAPEncoder::encodeArgument(%V,%u)", argName.rep, value)
|
|
|
|
encodeArgument(argName, *UString::str_unsignedInt, value);
|
|
}
|
|
|
|
void encodeArgument(const UString& argName, long int value)
|
|
{
|
|
U_TRACE(0, "USOAPEncoder::encodeArgument(%V,%ld)", argName.rep, value)
|
|
|
|
encodeArgument(argName, *UString::str_int, value);
|
|
}
|
|
|
|
void encodeArgument(const UString& argName, unsigned long int value)
|
|
{
|
|
U_TRACE(0, "USOAPEncoder::encodeArgument(%V,%lu)", argName.rep, value)
|
|
|
|
encodeArgument(argName, *UString::str_unsignedInt, value);
|
|
}
|
|
|
|
void encodeArgument(const UString& argName, const long long& value)
|
|
{
|
|
U_TRACE(0, "USOAPEncoder::encodeArgument(%V,%lld)", argName.rep, value)
|
|
|
|
encodeArgument(argName, *UString::str_long, value);
|
|
}
|
|
|
|
void encodeArgument(const UString& argName, const unsigned long long& value)
|
|
{
|
|
U_TRACE(0, "USOAPEncoder::encodeArgument(%V,%llu)", argName.rep, value)
|
|
|
|
encodeArgument(argName, *UString::str_unsignedLong, value);
|
|
}
|
|
|
|
void encodeArgument(const UString& argName, float value)
|
|
{
|
|
U_TRACE(0, "USOAPEncoder::encodeArgument(%V,%f)", argName.rep, value)
|
|
|
|
encodeArgument(argName, *UString::str_float, value);
|
|
}
|
|
|
|
void encodeArgument(const UString& argName, const double& value)
|
|
{
|
|
U_TRACE(0, "USOAPEncoder::encodeArgument(%V,%g)", argName.rep, value)
|
|
|
|
encodeArgument(argName, *UString::str_double, value);
|
|
}
|
|
|
|
void encodeArgument(const UString& argName, const UString& value)
|
|
{
|
|
U_TRACE(0, "USOAPEncoder::encodeArgument(%V,%V)", argName.rep, value.rep)
|
|
|
|
encodeArgument(argName, *UString::str_string, value);
|
|
}
|
|
|
|
// It takes a pointer and the length of the data to encode from that pointer in bytes, then base64 encodes the data
|
|
|
|
void encodeArgBase64(const UString& argName, const UString& value)
|
|
{
|
|
U_TRACE(0, "USOAPEncoder::encodeArgBase64(%V,%V)", argName.rep, value.rep)
|
|
|
|
if (value)
|
|
{
|
|
buffer.setBuffer(value.size() * 2);
|
|
|
|
UBase64::encode(value, buffer);
|
|
}
|
|
|
|
encodeArgument(argName, *UString::str_base64Binary, buffer);
|
|
}
|
|
|
|
void encodeResponse(const UString& value)
|
|
{
|
|
U_TRACE(0, "USOAPEncoder::encodeResponse(%V)", value.rep)
|
|
|
|
encodedValue.replace(value);
|
|
}
|
|
|
|
// Encodes the complete fault into a complete URPCEnvelope
|
|
|
|
virtual UString encodeFault(URPCFault* fault) U_DECL_OVERRIDE
|
|
{
|
|
U_TRACE(0, "USOAPEncoder::encodeFault(%p)", fault)
|
|
|
|
fault->encode(buffer); // Encode the fault
|
|
|
|
U_SOAP_ENCODE_RES(buffer);
|
|
|
|
U_RETURN_STRING(encodedValue);
|
|
}
|
|
|
|
// DEBUG
|
|
|
|
#if defined(U_STDCPP_ENABLE) && defined(DEBUG)
|
|
const char* dump(bool reset) const { return URPCEncoder::dump(reset); }
|
|
#endif
|
|
|
|
protected:
|
|
|
|
// Called by the encodeMethodResponse and encodeMethodCall members to finish encoding the method.
|
|
// As you may guess, the two methods share a lot, and this item holds that common code
|
|
|
|
virtual UString encodeMethod(URPCMethod& method, const UString& nsName) U_DECL_OVERRIDE; // namespace qualified element information
|
|
|
|
private:
|
|
U_DISALLOW_COPY_AND_ASSIGN(USOAPEncoder)
|
|
};
|
|
|
|
#endif
|