XmlRpc::XmlRpcValue Class Reference

RPC method arguments and results are represented by Values. More...

#include <XmlRpcValue.h>

Public Types
enum	Type {   TypeInvalid , TypeBoolean , TypeInt , TypeDouble ,   TypeString , TypeDateTime , TypeBase64 , TypeArray ,   TypeStruct }
typedef std::vector< char >	BinaryData
typedef std::vector< XmlRpcValue >	ValueArray
typedef std::map< std::string, XmlRpcValue >	ValueStruct

Public Member Functions
	XmlRpcValue ()
	Constructors.
	XmlRpcValue (bool value)
	XmlRpcValue (int value)
	XmlRpcValue (double value)
	XmlRpcValue (std::string const &value)
	XmlRpcValue (const char *value)
	XmlRpcValue (struct tm *value)
	XmlRpcValue (void *value, int nBytes)
	XmlRpcValue (std::string const &xml, int *offset)
	Construct from xml, beginning at *offset chars into the string, updates offset.
	XmlRpcValue (XmlRpcValue const &rhs)
	Copy.
	~XmlRpcValue ()
	Destructor (make virtual if you want to subclass).
void	clear ()
	Erase the current value.
XmlRpcValue &	operator= (XmlRpcValue const &rhs)
XmlRpcValue &	operator= (int const &rhs)
XmlRpcValue &	operator= (double const &rhs)
XmlRpcValue &	operator= (const char *rhs)
bool	operator== (XmlRpcValue const &other) const
bool	operator!= (XmlRpcValue const &other) const
	operator bool & ()
	operator int & ()
	operator double & ()
	operator std::string & ()
	operator BinaryData & ()
	operator struct tm & ()
XmlRpcValue const &	operator[] (int i) const
XmlRpcValue &	operator[] (int i)
XmlRpcValue &	operator[] (std::string const &k)
XmlRpcValue &	operator[] (const char *k)
bool	valid () const
	Return true if the value has been set to something.
Type const &	getType () const
	Return the type of the value stored.
int	size () const
	Return the size for string, base64, array, and struct values.
void	setSize (int size)
	Specify the size for array values. Array values will grow beyond this size if needed.
bool	hasMember (const std::string &name) const
	Check for the existence of a struct member by name.
bool	fromXml (std::string const &valueXml, int *offset)
	Decode xml. Destroys any existing value.
std::string	toXml () const
	Encode the Value in xml.
std::ostream &	write (std::ostream &os) const
	Write the value (no xml encoding).

Static Public Member Functions
static std::string const &	getDoubleFormat ()
	Return the format used to write double values.
static void	setDoubleFormat (const char *f)
	Specify the format used to write double values.

Protected Member Functions
void	invalidate ()
void	assertTypeOrInvalid (Type t)
void	assertArray (int size) const
void	assertArray (int size)
void	assertStruct ()
bool	boolFromXml (std::string const &valueXml, int *offset)
bool	intFromXml (std::string const &valueXml, int *offset)
bool	doubleFromXml (std::string const &valueXml, int *offset)
bool	stringFromXml (std::string const &valueXml, int *offset)
bool	timeFromXml (std::string const &valueXml, int *offset)
bool	binaryFromXml (std::string const &valueXml, int *offset)
bool	arrayFromXml (std::string const &valueXml, int *offset)
bool	structFromXml (std::string const &valueXml, int *offset)
std::string	boolToXml () const
std::string	intToXml () const
std::string	doubleToXml () const
std::string	stringToXml () const
std::string	timeToXml () const
std::string	binaryToXml () const
std::string	arrayToXml () const
std::string	structToXml () const

Protected Attributes
Type	_type
union {
bool   asBool
int   asInt
double   asDouble
struct tm *   asTime
std::string *   asString
BinaryData *   asBinary
ValueArray *   asArray
ValueStruct *   asStruct
}	_value

Static Protected Attributes
static std::string	_doubleFormat

Detailed Description

RPC method arguments and results are represented by Values.

Definition at line 22 of file XmlRpcValue.h.

Member Typedef Documentation

BinaryData

typedef std::vector<char> XmlRpc::XmlRpcValue::BinaryData

Definition at line 37 of file XmlRpcValue.h.

ValueArray

typedef std::vector<XmlRpcValue> XmlRpc::XmlRpcValue::ValueArray

Definition at line 38 of file XmlRpcValue.h.

ValueStruct

typedef std::map<std::string, XmlRpcValue> XmlRpc::XmlRpcValue::ValueStruct

Definition at line 39 of file XmlRpcValue.h.

Member Enumeration Documentation

Type

enum XmlRpc::XmlRpcValue::Type

Enumerator
TypeInvalid
TypeBoolean
TypeInt
TypeDouble
TypeString
TypeDateTime
TypeBase64
TypeArray
TypeStruct

Definition at line 24 of file XmlRpcValue.h.

              {
      TypeInvalid,
      TypeBoolean,
      TypeInt,
      TypeDouble,
      TypeString,
      TypeDateTime,
      TypeBase64,
      TypeArray,
      TypeStruct
    };

Constructor & Destructor Documentation

XmlRpcValue() [1/10]

XmlRpc::XmlRpcValue::XmlRpcValue ( )

inline

Constructors.

Definition at line 42 of file XmlRpcValue.h.

: _type( TypeInvalid ) { _value.asBinary = 0; }

Referenced by arrayFromXml(), operator!=(), operator=(), operator=(), operator=(), operator=(), operator==(), operator[](), operator[](), operator[](), operator[](), structFromXml(), and XmlRpcValue().

XmlRpcValue() [2/10]

XmlRpc::XmlRpcValue::XmlRpcValue ( bool value )

inline

Definition at line 43 of file XmlRpcValue.h.

: _type( TypeBoolean ) { _value.asBool = value; }

XmlRpcValue() [3/10]

XmlRpc::XmlRpcValue::XmlRpcValue ( int value )

inline

Definition at line 44 of file XmlRpcValue.h.

: _type( TypeInt ) { _value.asInt = value; }

XmlRpcValue() [4/10]

XmlRpc::XmlRpcValue::XmlRpcValue ( double value )

inline

Definition at line 45 of file XmlRpcValue.h.

: _type( TypeDouble ) { _value.asDouble = value; }

XmlRpcValue() [5/10]

XmlRpc::XmlRpcValue::XmlRpcValue ( std::string const & value )

inline

Definition at line 47 of file XmlRpcValue.h.

                                          : _type( TypeString ) {
      _value.asString = new std::string( value );
    }

XmlRpcValue() [6/10]

XmlRpc::XmlRpcValue::XmlRpcValue ( const char * value )

inline

Definition at line 51 of file XmlRpcValue.h.

                                     : _type( TypeString ) {
      _value.asString = new std::string( value );
    }

XmlRpcValue() [7/10]

XmlRpc::XmlRpcValue::XmlRpcValue ( struct tm * value )

inline

Definition at line 55 of file XmlRpcValue.h.

                                    : _type( TypeDateTime ) {
      _value.asTime = new struct tm( *value );
    }

XmlRpcValue() [8/10]

XmlRpc::XmlRpcValue::XmlRpcValue ( void * value, int nBytes )

inline

Definition at line 59 of file XmlRpcValue.h.

                                           : _type( TypeBase64 ) {
      _value.asBinary = new BinaryData( (char*)value, ( (char*)value ) + nBytes );
    }

XmlRpcValue() [9/10]

XmlRpc::XmlRpcValue::XmlRpcValue ( std::string const & xml, int * offset )

inline

Construct from xml, beginning at *offset chars into the string, updates offset.

Definition at line 64 of file XmlRpcValue.h.

                                                     : _type( TypeInvalid ) {
      if ( !fromXml( xml, offset ) ) _type = TypeInvalid;
    }

XmlRpcValue() [10/10]

XmlRpc::XmlRpcValue::XmlRpcValue ( XmlRpcValue const & rhs )

inline

Copy.

Definition at line 69 of file XmlRpcValue.h.

: _type( TypeInvalid ) { *this = rhs; }

~XmlRpcValue()

XmlRpc::XmlRpcValue::~XmlRpcValue ( )

inline

Destructor (make virtual if you want to subclass).

Definition at line 72 of file XmlRpcValue.h.

{ invalidate(); }

Member Function Documentation

arrayFromXml()

bool XmlRpc::XmlRpcValue::arrayFromXml ( std::string const & valueXml, int * offset )

protected

Definition at line 417 of file XmlRpcValue.cpp.

                                                                         {
    if ( !XmlRpcUtil::nextTagIs( DATA_TAG, valueXml, offset ) ) return false;
 
    _type          = TypeArray;
    _value.asArray = new ValueArray;
    XmlRpcValue v;
    while ( v.fromXml( valueXml, offset ) ) _value.asArray->push_back( v ); // copy...
 
    // Skip the trailing </data>
    (void)XmlRpcUtil::nextTagIs( DATA_ETAG, valueXml, offset );
    return true;
  }

Referenced by fromXml().

arrayToXml()

std::string XmlRpc::XmlRpcValue::arrayToXml ( ) const

protected

Definition at line 432 of file XmlRpcValue.cpp.

                                          {
    std::string xml = VALUE_TAG;
    xml += ARRAY_TAG;
    xml += DATA_TAG;
 
    int s = int( _value.asArray->size() );
    for ( int i = 0; i < s; ++i ) xml += _value.asArray->at( i ).toXml();
 
    xml += DATA_ETAG;
    xml += ARRAY_ETAG;
    xml += VALUE_ETAG;
    return xml;
  }

Referenced by toXml().

assertArray() [1/2]

void XmlRpc::XmlRpcValue::assertArray ( int size )

protected

Definition at line 86 of file XmlRpcValue.cpp.

                                          {
    if ( _type == TypeInvalid )
    {
      _type          = TypeArray;
      _value.asArray = new ValueArray( size );
    }
    else if ( _type == TypeArray )
    {
      if ( int( _value.asArray->size() ) < size ) _value.asArray->resize( size );
    }
    else throw XmlRpcException( "type error: expected an array" );
  }

assertArray() [2/2]

void XmlRpc::XmlRpcValue::assertArray ( int size ) const

protected

Definition at line 80 of file XmlRpcValue.cpp.

                                                {
    if ( _type != TypeArray ) throw XmlRpcException( "type error: expected an array" );
    else if ( int( _value.asArray->size() ) < size )
      throw XmlRpcException( "range error: array index too large" );
  }

Referenced by operator[](), operator[](), and setSize().

assertStruct()

void XmlRpc::XmlRpcValue::assertStruct ( )

protected

Definition at line 99 of file XmlRpcValue.cpp.

                                 {
    if ( _type == TypeInvalid )
    {
      _type           = TypeStruct;
      _value.asStruct = new ValueStruct();
    }
    else if ( _type != TypeStruct ) throw XmlRpcException( "type error: expected a struct" );
  }

Referenced by operator[](), and operator[]().

assertTypeOrInvalid()

void XmlRpc::XmlRpcValue::assertTypeOrInvalid ( Type t )

protected

Definition at line 63 of file XmlRpcValue.cpp.

                                                {
    if ( _type == TypeInvalid )
    {
      _type = t;
      switch ( _type )
      { // Ensure there is a valid value for the type
      case TypeString: _value.asString = new std::string(); break;
      case TypeDateTime: _value.asTime = new struct tm(); break;
      case TypeBase64: _value.asBinary = new BinaryData(); break;
      case TypeArray: _value.asArray = new ValueArray(); break;
      case TypeStruct: _value.asStruct = new ValueStruct(); break;
      default: _value.asBinary = 0; break;
      }
    }
    else if ( _type != t ) throw XmlRpcException( "type error" );
  }

Referenced by operator BinaryData &(), operator bool &(), operator double &(), operator int &(), operator std::string &(), and operator struct tm &().

binaryFromXml()

bool XmlRpc::XmlRpcValue::binaryFromXml ( std::string const & valueXml, int * offset )

protected

Definition at line 379 of file XmlRpcValue.cpp.

                                                                          {
    size_t valueEnd = valueXml.find( '<', *offset );
    if ( valueEnd == std::string::npos ) return false; // No end tag;
 
    _type                = TypeBase64;
    std::string asString = valueXml.substr( *offset, valueEnd - *offset );
    _value.asBinary      = new BinaryData();
    // check whether base64 encodings can contain chars xml encodes...
 
    // convert from base64 to binary
    int                                   iostatus = 0;
    base64<char>                          decoder;
    std::back_insert_iterator<BinaryData> ins = std::back_inserter( *( _value.asBinary ) );
    decoder.get( asString.begin(), asString.end(), ins, iostatus );
 
    *offset += int( asString.length() );
    return true;
  }

Referenced by fromXml().

binaryToXml()

std::string XmlRpc::XmlRpcValue::binaryToXml ( ) const

protected

Definition at line 398 of file XmlRpcValue.cpp.

                                           {
    // convert to base64
    std::vector<char>                            base64data;
    int                                          iostatus = 0;
    base64<char>                                 encoder;
    std::back_insert_iterator<std::vector<char>> ins = std::back_inserter( base64data );
    encoder.put( _value.asBinary->begin(), _value.asBinary->end(), ins, iostatus,
                 base64<>::crlf() );
 
    // Wrap with xml
    std::string xml = VALUE_TAG;
    xml += BASE64_TAG;
    xml.append( base64data.begin(), base64data.end() );
    xml += BASE64_ETAG;
    xml += VALUE_ETAG;
    return xml;
  }

Referenced by toXml().

boolFromXml()

bool XmlRpc::XmlRpcValue::boolFromXml ( std::string const & valueXml, int * offset )

protected

Definition at line 251 of file XmlRpcValue.cpp.

                                                                        {
    const char* valueStart = valueXml.c_str() + *offset;
    char*       valueEnd;
    long        ivalue = strtol( valueStart, &valueEnd, 10 );
    if ( valueEnd == valueStart || ( ivalue != 0 && ivalue != 1 ) ) return false;
 
    _type         = TypeBoolean;
    _value.asBool = ( ivalue == 1 );
    *offset += int( valueEnd - valueStart );
    return true;
  }

Referenced by fromXml().

boolToXml()

std::string XmlRpc::XmlRpcValue::boolToXml ( ) const

protected

Definition at line 263 of file XmlRpcValue.cpp.

                                         {
    std::string xml = VALUE_TAG;
    xml += BOOLEAN_TAG;
    xml += ( _value.asBool ? "1" : "0" );
    xml += BOOLEAN_ETAG;
    xml += VALUE_ETAG;
    return xml;
  }

Referenced by toXml().

clear()

void XmlRpc::XmlRpcValue::clear ( )

inline

Erase the current value.

Definition at line 75 of file XmlRpcValue.h.

{ invalidate(); }

Referenced by XmlRpc::XmlRpcClient::execute().

doubleFromXml()

bool XmlRpc::XmlRpcValue::doubleFromXml ( std::string const & valueXml, int * offset )

protected

Definition at line 298 of file XmlRpcValue.cpp.

                                                                          {
    const char* valueStart = valueXml.c_str() + *offset;
    char*       valueEnd;
    double      dvalue = strtod( valueStart, &valueEnd );
    if ( valueEnd == valueStart ) return false;
 
    _type           = TypeDouble;
    _value.asDouble = dvalue;
    *offset += int( valueEnd - valueStart );
    return true;
  }

Referenced by fromXml().

doubleToXml()

std::string XmlRpc::XmlRpcValue::doubleToXml ( ) const

protected

Definition at line 310 of file XmlRpcValue.cpp.

                                           {
    char buf[256];
    snprintf( buf, sizeof( buf ) - 1, getDoubleFormat().c_str(), _value.asDouble );
    buf[sizeof( buf ) - 1] = 0;
 
    std::string xml = VALUE_TAG;
    xml += DOUBLE_TAG;
    xml += buf;
    xml += DOUBLE_ETAG;
    xml += VALUE_ETAG;
    return xml;
  }

Referenced by toXml().

fromXml()

bool XmlRpc::XmlRpcValue::fromXml	(	std::string const &	valueXml,
		int *	offset )

Decode xml. Destroys any existing value.

Definition at line 198 of file XmlRpcValue.cpp.

                                                                    {
    int savedOffset = *offset;
 
    invalidate();
    if ( !XmlRpcUtil::nextTagIs( VALUE_TAG, valueXml, offset ) )
      return false; // Not a value, offset not updated
 
    int         afterValueOffset = *offset;
    std::string typeTag          = XmlRpcUtil::getNextTag( valueXml, offset );
    bool        result           = false;
    if ( typeTag == BOOLEAN_TAG ) result = boolFromXml( valueXml, offset );
    else if ( typeTag == I4_TAG || typeTag == INT_TAG )
      result = intFromXml( valueXml, offset );
    else if ( typeTag == DOUBLE_TAG ) result = doubleFromXml( valueXml, offset );
    else if ( typeTag.empty() || typeTag == STRING_TAG )
      result = stringFromXml( valueXml, offset );
    else if ( typeTag == DATETIME_TAG ) result = timeFromXml( valueXml, offset );
    else if ( typeTag == BASE64_TAG ) result = binaryFromXml( valueXml, offset );
    else if ( typeTag == ARRAY_TAG ) result = arrayFromXml( valueXml, offset );
    else if ( typeTag == STRUCT_TAG ) result = structFromXml( valueXml, offset );
    // Watch for empty/blank strings with no <string>tag
    else if ( typeTag == VALUE_ETAG )
    {
      *offset = afterValueOffset; // back up & try again
      result  = stringFromXml( valueXml, offset );
    }
 
    if ( result ) // Skip over the </value> tag
      XmlRpcUtil::findTag( VALUE_ETAG, valueXml, offset );
    else // Unrecognized tag after <value>
      *offset = savedOffset;
 
    return result;
  }

Referenced by XmlRpc::XmlRpcClient::parseResponse(), and XmlRpcValue().

getDoubleFormat()

std::string const & XmlRpc::XmlRpcValue::getDoubleFormat ( )

inlinestatic

Return the format used to write double values.

Definition at line 159 of file XmlRpcValue.h.

{ return _doubleFormat; }

Referenced by doubleToXml().

getType()

Type const & XmlRpc::XmlRpcValue::getType ( ) const

inline

Return the type of the value stored.

See also

Type.

Definition at line 137 of file XmlRpcValue.h.

{ return _type; }

Referenced by XmlRpc::XmlRpcServerConnection::executeMulticall(), XmlRpc::XmlRpcClient::generateRequest(), and getFnamesAtBkk().

hasMember()

bool XmlRpc::XmlRpcValue::hasMember

(

const std::string &

name

)

const

Check for the existence of a struct member by name.

Definition at line 192 of file XmlRpcValue.cpp.

                                                           {
    return _type == TypeStruct && _value.asStruct->find( name ) != _value.asStruct->end();
  }

intFromXml()

bool XmlRpc::XmlRpcValue::intFromXml ( std::string const & valueXml, int * offset )

protected

Definition at line 273 of file XmlRpcValue.cpp.

                                                                       {
    const char* valueStart = valueXml.c_str() + *offset;
    char*       valueEnd;
    long        ivalue = strtol( valueStart, &valueEnd, 10 );
    if ( valueEnd == valueStart ) return false;
 
    _type        = TypeInt;
    _value.asInt = int( ivalue );
    *offset += int( valueEnd - valueStart );
    return true;
  }

Referenced by fromXml().

intToXml()

std::string XmlRpc::XmlRpcValue::intToXml ( ) const

protected

Definition at line 285 of file XmlRpcValue.cpp.

                                        {
    char buf[256];
    snprintf( buf, sizeof( buf ) - 1, "%d", _value.asInt );
    buf[sizeof( buf ) - 1] = 0;
    std::string xml        = VALUE_TAG;
    xml += I4_TAG;
    xml += buf;
    xml += I4_ETAG;
    xml += VALUE_ETAG;
    return xml;
  }

Referenced by toXml().

invalidate()

void XmlRpc::XmlRpcValue::invalidate ( )

protected

Definition at line 48 of file XmlRpcValue.cpp.

                               {
    switch ( _type )
    {
    case TypeString: delete _value.asString; break;
    case TypeDateTime: delete _value.asTime; break;
    case TypeBase64: delete _value.asBinary; break;
    case TypeArray: delete _value.asArray; break;
    case TypeStruct: delete _value.asStruct; break;
    default: break;
    }
    _type           = TypeInvalid;
    _value.asBinary = 0;
  }

Referenced by clear(), fromXml(), operator=(), structFromXml(), and ~XmlRpcValue().

operator BinaryData &()

XmlRpc::XmlRpcValue::operator BinaryData & ( )

inline

Definition at line 104 of file XmlRpcValue.h.

                           {
      assertTypeOrInvalid( TypeBase64 );
      return *_value.asBinary;
    }

operator bool &()

XmlRpc::XmlRpcValue::operator bool & ( )

inline

Definition at line 88 of file XmlRpcValue.h.

                     {
      assertTypeOrInvalid( TypeBoolean );
      return _value.asBool;
    }

operator double &()

XmlRpc::XmlRpcValue::operator double & ( )

inline

Definition at line 96 of file XmlRpcValue.h.

                       {
      assertTypeOrInvalid( TypeDouble );
      return _value.asDouble;
    }

operator int &()

XmlRpc::XmlRpcValue::operator int & ( )

inline

Definition at line 92 of file XmlRpcValue.h.

                    {
      assertTypeOrInvalid( TypeInt );
      return _value.asInt;
    }

operator std::string &()

XmlRpc::XmlRpcValue::operator std::string & ( )

inline

Definition at line 100 of file XmlRpcValue.h.

                          {
      assertTypeOrInvalid( TypeString );
      return *_value.asString;
    }

operator struct tm &()

XmlRpc::XmlRpcValue::operator struct tm & ( )

inline

Definition at line 108 of file XmlRpcValue.h.

                           {
      assertTypeOrInvalid( TypeDateTime );
      return *_value.asTime;
    }

operator!=()

bool XmlRpc::XmlRpcValue::operator!=

(

XmlRpcValue const &

other

)

const

Definition at line 173 of file XmlRpcValue.cpp.

                                                             {
    return !( *this == other );
  }

operator=() [1/4]

XmlRpcValue & XmlRpc::XmlRpcValue::operator= ( const char * rhs )

inline

Definition at line 81 of file XmlRpcValue.h.

                                            {
      return operator=( XmlRpcValue( std::string( rhs ) ) );
    }

operator=() [2/4]

XmlRpcValue & XmlRpc::XmlRpcValue::operator= ( double const & rhs )

inline

Definition at line 80 of file XmlRpcValue.h.

{ return operator=( XmlRpcValue( rhs ) ); }

Referenced by operator=().

operator=() [3/4]

XmlRpcValue & XmlRpc::XmlRpcValue::operator= ( int const & rhs )

inline

Definition at line 79 of file XmlRpcValue.h.

{ return operator=( XmlRpcValue( rhs ) ); }

Referenced by operator=().

operator=() [4/4]

XmlRpcValue & XmlRpc::XmlRpcValue::operator=

(

XmlRpcValue const &

rhs

)

Definition at line 109 of file XmlRpcValue.cpp.

                                                            {
    if ( this != &rhs )
    {
      invalidate();
      _type = rhs._type;
      switch ( _type )
      {
      case TypeBoolean: _value.asBool = rhs._value.asBool; break;
      case TypeInt: _value.asInt = rhs._value.asInt; break;
      case TypeDouble: _value.asDouble = rhs._value.asDouble; break;
      case TypeDateTime: _value.asTime = new struct tm( *rhs._value.asTime ); break;
      case TypeString: _value.asString = new std::string( *rhs._value.asString ); break;
      case TypeBase64: _value.asBinary = new BinaryData( *rhs._value.asBinary ); break;
      case TypeArray: _value.asArray = new ValueArray( *rhs._value.asArray ); break;
      case TypeStruct: _value.asStruct = new ValueStruct( *rhs._value.asStruct ); break;
      default: _value.asBinary = 0; break;
      }
    }
    return *this;
  }

Referenced by operator=().

operator==()

bool XmlRpc::XmlRpcValue::operator==

(

XmlRpcValue const &

other

)

const

Definition at line 136 of file XmlRpcValue.cpp.

                                                             {
    if ( _type != other._type ) return false;
 
    switch ( _type )
    {
    case TypeBoolean:
      return ( !_value.asBool && !other._value.asBool ) ||
             ( _value.asBool && other._value.asBool );
    case TypeInt: return _value.asInt == other._value.asInt;
    case TypeDouble: return _value.asDouble == other._value.asDouble;
    case TypeDateTime: return tmEq( *_value.asTime, *other._value.asTime );
    case TypeString: return *_value.asString == *other._value.asString;
    case TypeBase64: return *_value.asBinary == *other._value.asBinary;
    case TypeArray: return *_value.asArray == *other._value.asArray;
 
    // The map<>::operator== requires the definition of value< for kcc
    case TypeStruct: // return *_value.asStruct == *other._value.asStruct;
    {
      if ( _value.asStruct->size() != other._value.asStruct->size() ) return false;
 
      ValueStruct::const_iterator it1 = _value.asStruct->begin();
      ValueStruct::const_iterator it2 = other._value.asStruct->begin();
      while ( it1 != _value.asStruct->end() )
      {
        const XmlRpcValue& v1 = it1->second;
        const XmlRpcValue& v2 = it2->second;
        if ( !( v1 == v2 ) ) return false;
        it1++;
        it2++;
      }
      return true;
    }
    default: break;
    }
    return true; // Both invalid values ...
  }

operator[]() [1/4]

XmlRpcValue & XmlRpc::XmlRpcValue::operator[] ( const char * k )

inline

Definition at line 126 of file XmlRpcValue.h.

                                             {
      assertStruct();
      std::string s( k );
      return ( *_value.asStruct )[s];
    }

operator[]() [2/4]

XmlRpcValue & XmlRpc::XmlRpcValue::operator[] ( int i )

inline

Definition at line 117 of file XmlRpcValue.h.

                                     {
      assertArray( i + 1 );
      return _value.asArray->at( i );
    }

operator[]() [3/4]

XmlRpcValue const & XmlRpc::XmlRpcValue::operator[] ( int i ) const

inline

Definition at line 113 of file XmlRpcValue.h.

                                                 {
      assertArray( i + 1 );
      return _value.asArray->at( i );
    }

operator[]() [4/4]

XmlRpcValue & XmlRpc::XmlRpcValue::operator[] ( std::string const & k )

inline

Definition at line 122 of file XmlRpcValue.h.

                                                  {
      assertStruct();
      return ( *_value.asStruct )[k];
    }

setDoubleFormat()

void XmlRpc::XmlRpcValue::setDoubleFormat ( const char * f )

inlinestatic

Specify the format used to write double values.

Definition at line 162 of file XmlRpcValue.h.

{ _doubleFormat = f; }

setSize()

void XmlRpc::XmlRpcValue::setSize ( int size )

inline

Specify the size for array values. Array values will grow beyond this size if needed.

Definition at line 143 of file XmlRpcValue.h.

{ assertArray( size ); }

Referenced by XmlRpc::XmlRpcServerConnection::executeMulticall(), getFnamesAtBkk(), XmlRpc::XmlRpcServer::listMethods(), testArray(), and testStruct().

size()

int XmlRpc::XmlRpcValue::size

(

)

const

Return the size for string, base64, array, and struct values.

Definition at line 178 of file XmlRpcValue.cpp.

                              {
    switch ( _type )
    {
    case TypeString: return int( _value.asString->size() );
    case TypeBase64: return int( _value.asBinary->size() );
    case TypeArray: return int( _value.asArray->size() );
    case TypeStruct: return int( _value.asStruct->size() );
    default: break;
    }
 
    throw XmlRpcException( "type error" );
  }

Referenced by assertArray(), assertArray(), ArrayOfStructsTest::execute(), ModerateSizeArrayCheck::execute(), Sum::execute(), XmlRpc::XmlRpcServerConnection::executeMulticall(), XmlRpc::XmlRpcClient::generateRequest(), getFnamesAtBkk(), main(), and setSize().

stringFromXml()

bool XmlRpc::XmlRpcValue::stringFromXml ( std::string const & valueXml, int * offset )

protected

Definition at line 324 of file XmlRpcValue.cpp.

                                                                          {
    size_t valueEnd = valueXml.find( '<', *offset );
    if ( valueEnd == std::string::npos ) return false; // No end tag;
 
    _type           = TypeString;
    _value.asString = new std::string(
        XmlRpcUtil::xmlDecode( valueXml.substr( *offset, valueEnd - *offset ) ) );
    *offset += int( _value.asString->length() );
    return true;
  }

Referenced by fromXml().

stringToXml()

std::string XmlRpc::XmlRpcValue::stringToXml ( ) const

protected

Definition at line 335 of file XmlRpcValue.cpp.

                                           {
    std::string xml = VALUE_TAG;
    // xml += STRING_TAG; optional
    xml += XmlRpcUtil::xmlEncode( *_value.asString );
    // xml += STRING_ETAG;
    xml += VALUE_ETAG;
    return xml;
  }

Referenced by toXml().

structFromXml()

bool XmlRpc::XmlRpcValue::structFromXml ( std::string const & valueXml, int * offset )

protected

Definition at line 447 of file XmlRpcValue.cpp.

                                                                          {
    _type           = TypeStruct;
    _value.asStruct = new ValueStruct;
 
    while ( XmlRpcUtil::nextTagIs( MEMBER_TAG, valueXml, offset ) )
    {
      // name
      const std::string name = XmlRpcUtil::parseTag( NAME_TAG, valueXml, offset );
      // value
      XmlRpcValue val( valueXml, offset );
      if ( !val.valid() )
      {
        invalidate();
        return false;
      }
      const std::pair<const std::string, XmlRpcValue> p( name, val );
      _value.asStruct->insert( p );
 
      (void)XmlRpcUtil::nextTagIs( MEMBER_ETAG, valueXml, offset );
    }
    return true;
  }

Referenced by fromXml().

structToXml()

std::string XmlRpc::XmlRpcValue::structToXml ( ) const

protected

Definition at line 472 of file XmlRpcValue.cpp.

                                           {
    std::string xml = VALUE_TAG;
    xml += STRUCT_TAG;
 
    ValueStruct::const_iterator it;
    for ( it = _value.asStruct->begin(); it != _value.asStruct->end(); ++it )
    {
      xml += MEMBER_TAG;
      xml += NAME_TAG;
      xml += XmlRpcUtil::xmlEncode( it->first );
      xml += NAME_ETAG;
      xml += it->second.toXml();
      xml += MEMBER_ETAG;
    }
 
    xml += STRUCT_ETAG;
    xml += VALUE_ETAG;
    return xml;
  }

Referenced by toXml().

timeFromXml()

bool XmlRpc::XmlRpcValue::timeFromXml ( std::string const & valueXml, int * offset )

protected

Definition at line 345 of file XmlRpcValue.cpp.

                                                                        {
    size_t valueEnd = valueXml.find( '<', *offset );
    if ( valueEnd == std::string::npos ) return false; // No end tag;
 
    std::string stime = valueXml.substr( *offset, valueEnd - *offset );
 
    struct tm t;
    if ( sscanf( stime.c_str(), "%4d%2d%2dT%2d:%2d:%2d", &t.tm_year, &t.tm_mon, &t.tm_mday,
                 &t.tm_hour, &t.tm_min, &t.tm_sec ) != 6 )
      return false;
 
    t.tm_isdst    = -1;
    _type         = TypeDateTime;
    _value.asTime = new struct tm( t );
    *offset += int( stime.length() );
    return true;
  }

Referenced by fromXml().

timeToXml()

std::string XmlRpc::XmlRpcValue::timeToXml ( ) const

protected

Definition at line 363 of file XmlRpcValue.cpp.

                                         {
    struct tm* t = _value.asTime;
    char       buf[20];
    snprintf( buf, sizeof( buf ) - 1, "%4d%02d%02dT%02d:%02d:%02d", t->tm_year, t->tm_mon,
              t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec );
    buf[sizeof( buf ) - 1] = 0;
 
    std::string xml = VALUE_TAG;
    xml += DATETIME_TAG;
    xml += buf;
    xml += DATETIME_ETAG;
    xml += VALUE_ETAG;
    return xml;
  }

Referenced by toXml().

toXml()

std::string XmlRpc::XmlRpcValue::toXml

(

)

const

Encode the Value in xml.

Definition at line 234 of file XmlRpcValue.cpp.

                                     {
    switch ( _type )
    {
    case TypeBoolean: return boolToXml();
    case TypeInt: return intToXml();
    case TypeDouble: return doubleToXml();
    case TypeString: return stringToXml();
    case TypeDateTime: return timeToXml();
    case TypeBase64: return binaryToXml();
    case TypeArray: return arrayToXml();
    case TypeStruct: return structToXml();
    default: break;
    }
    return std::string(); // Invalid value
  }

Referenced by XmlRpc::XmlRpcServerConnection::executeRequest(), XmlRpc::XmlRpcServerConnection::generateFaultResponse(), XmlRpc::XmlRpcClient::generateRequest(), and testString().

valid()

bool XmlRpc::XmlRpcValue::valid ( ) const

inline

Return true if the value has been set to something.

Definition at line 134 of file XmlRpcValue.h.

{ return _type != TypeInvalid; }

Referenced by XmlRpc::XmlRpcServerConnection::executeMethod(), XmlRpc::XmlRpcClient::generateRequest(), XmlRpc::XmlRpcClient::parseResponse(), and structFromXml().

write()

std::ostream & XmlRpc::XmlRpcValue::write

(

std::ostream &

os

)

const

Write the value (no xml encoding).

Definition at line 493 of file XmlRpcValue.cpp.

                                                       {
    switch ( _type )
    {
    default: break;
    case TypeBoolean: os << _value.asBool; break;
    case TypeInt: os << _value.asInt; break;
    case TypeDouble: os << _value.asDouble; break;
    case TypeString: os << *_value.asString; break;
    case TypeDateTime: {
      struct tm* t = _value.asTime;
      char       buf[20];
      snprintf( buf, sizeof( buf ) - 1, "%4d%02d%02dT%02d:%02d:%02d", t->tm_year, t->tm_mon,
                t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec );
      buf[sizeof( buf ) - 1] = 0;
      os << buf;
      break;
    }
    case TypeBase64: {
      int                            iostatus = 0;
      std::ostreambuf_iterator<char> out( os );
      base64<char>                   encoder;
      encoder.put( _value.asBinary->begin(), _value.asBinary->end(), out, iostatus,
                   base64<>::crlf() );
      break;
    }
    case TypeArray: {
      int s = int( _value.asArray->size() );
      os << '{';
      for ( int i = 0; i < s; ++i )
      {
        if ( i > 0 ) os << ',';
        _value.asArray->at( i ).write( os );
      }
      os << '}';
      break;
    }
    case TypeStruct: {
      os << '[';
      ValueStruct::const_iterator it;
      for ( it = _value.asStruct->begin(); it != _value.asStruct->end(); ++it )
      {
        if ( it != _value.asStruct->begin() ) os << ',';
        os << it->first << ':';
        it->second.write( os );
      }
      os << ']';
      break;
    }
    }
 
    return os;
  }

Member Data Documentation

_doubleFormat

std::string XmlRpc::XmlRpcValue::_doubleFormat

staticprotected

Definition at line 195 of file XmlRpcValue.h.

Referenced by getDoubleFormat(), and setDoubleFormat().

_type

Type XmlRpc::XmlRpcValue::_type

protected

Definition at line 198 of file XmlRpcValue.h.

Referenced by arrayFromXml(), assertArray(), assertArray(), assertStruct(), assertTypeOrInvalid(), binaryFromXml(), boolFromXml(), doubleFromXml(), getType(), hasMember(), intFromXml(), invalidate(), operator=(), operator==(), size(), stringFromXml(), structFromXml(), timeFromXml(), toXml(), valid(), write(), XmlRpcValue(), XmlRpcValue(), XmlRpcValue(), XmlRpcValue(), XmlRpcValue(), XmlRpcValue(), XmlRpcValue(), XmlRpcValue(), XmlRpcValue(), and XmlRpcValue().

[union]

union { ... } XmlRpc::XmlRpcValue::_value

Referenced by arrayFromXml(), arrayToXml(), assertArray(), assertArray(), assertStruct(), assertTypeOrInvalid(), binaryFromXml(), binaryToXml(), boolFromXml(), boolToXml(), doubleFromXml(), doubleToXml(), hasMember(), intFromXml(), intToXml(), invalidate(), operator BinaryData &(), operator bool &(), operator double &(), operator int &(), operator std::string &(), operator struct tm &(), operator=(), operator==(), operator[](), operator[](), operator[](), operator[](), size(), stringFromXml(), stringToXml(), structFromXml(), structToXml(), timeFromXml(), timeToXml(), write(), XmlRpcValue(), XmlRpcValue(), XmlRpcValue(), XmlRpcValue(), XmlRpcValue(), XmlRpcValue(), XmlRpcValue(), and XmlRpcValue().

asArray

ValueArray* XmlRpc::XmlRpcValue::asArray

Definition at line 209 of file XmlRpcValue.h.

Referenced by operator=().

asBinary

BinaryData* XmlRpc::XmlRpcValue::asBinary

Definition at line 208 of file XmlRpcValue.h.

Referenced by operator=().

asBool

bool XmlRpc::XmlRpcValue::asBool

Definition at line 203 of file XmlRpcValue.h.

Referenced by operator=().

asDouble

double XmlRpc::XmlRpcValue::asDouble

Definition at line 205 of file XmlRpcValue.h.

Referenced by operator=().

asInt

int XmlRpc::XmlRpcValue::asInt

Definition at line 204 of file XmlRpcValue.h.

Referenced by operator=().

asString

std::string* XmlRpc::XmlRpcValue::asString

Definition at line 207 of file XmlRpcValue.h.

Referenced by binaryFromXml(), and operator=().

asStruct

ValueStruct* XmlRpc::XmlRpcValue::asStruct

Definition at line 210 of file XmlRpcValue.h.

Referenced by operator=().

asTime

struct tm* XmlRpc::XmlRpcValue::asTime

Definition at line 206 of file XmlRpcValue.h.

Referenced by operator=().

---

The documentation for this class was generated from the following files:

• XmlRpcValue.h
• XmlRpcValue.cpp