XmlRpc::XmlRpcValue Class Reference

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

#include <XmlRpcValue.h>

List of all members.

Public Types
typedef std::vector< char >	BinaryData
enum	Type {   TypeInvalid, TypeBoolean, TypeInt, TypeDouble,   TypeString, TypeDateTime, TypeBase64, TypeArray,   TypeStruct }
typedef std::vector< XmlRpcValue >	ValueArray
typedef std::map< std::string, XmlRpcValue >	ValueStruct
Public Member Functions
void	clear ()
	Erase the current value.
bool	fromXml (std::string const &valueXml, int *offset)
	Decode xml. Destroys any existing value.
Type const &	getType () const
	Return the type of the value stored. Type.
bool	hasMember (const std::string &name) const
	Check for the existence of a struct member by name.
	operator BinaryData & ()
	operator bool & ()
	operator double & ()
	operator int & ()
	operator std::string & ()
	operator struct tm & ()
bool	operator!= (XmlRpcValue const &other) const
XmlRpcValue &	operator= (const char *rhs)
XmlRpcValue &	operator= (double const &rhs)
XmlRpcValue &	operator= (int const &rhs)
XmlRpcValue &	operator= (XmlRpcValue const &rhs)
bool	operator== (XmlRpcValue const &other) const
XmlRpcValue &	operator[] (const char *k)
XmlRpcValue &	operator[] (std::string const &k)
XmlRpcValue &	operator[] (int i)
XmlRpcValue const &	operator[] (int i) const
void	setSize (int size)
	Specify the size for array values. Array values will grow beyond this size if needed.
int	size () const
	Return the size for string, base64, array, and struct values.
std::string	toXml () const
	Encode the Value in xml.
bool	valid () const
	Return true if the value has been set to something.
std::ostream &	write (std::ostream &os) const
	Write the value (no xml encoding).
	XmlRpcValue (XmlRpcValue const &rhs)
	Copy.
	XmlRpcValue (std::string const &xml, int *offset)
	Construct from xml, beginning at *offset chars into the string, updates offset.
	XmlRpcValue (void *value, int nBytes)
	XmlRpcValue (struct tm *value)
	XmlRpcValue (const char *value)
	XmlRpcValue (std::string const &value)
	XmlRpcValue (double value)
	XmlRpcValue (int value)
	XmlRpcValue (bool value)
	XmlRpcValue ()
	Constructors.
	~XmlRpcValue ()
	Destructor (make virtual if you want to subclass).
Static Public Member Functions
std::string const &	getDoubleFormat ()
	Return the format used to write double values.
void	setDoubleFormat (const char *f)
	Specify the format used to write double values.
Protected Member Functions
bool	arrayFromXml (std::string const &valueXml, int *offset)
std::string	arrayToXml () const
void	assertArray (int size)
void	assertArray (int size) const
void	assertStruct ()
void	assertTypeOrInvalid (Type t)
bool	binaryFromXml (std::string const &valueXml, int *offset)
std::string	binaryToXml () const
bool	boolFromXml (std::string const &valueXml, int *offset)
std::string	boolToXml () const
bool	doubleFromXml (std::string const &valueXml, int *offset)
std::string	doubleToXml () const
bool	intFromXml (std::string const &valueXml, int *offset)
std::string	intToXml () const
void	invalidate ()
bool	stringFromXml (std::string const &valueXml, int *offset)
std::string	stringToXml () const
bool	structFromXml (std::string const &valueXml, int *offset)
std::string	structToXml () const
bool	timeFromXml (std::string const &valueXml, int *offset)
std::string	timeToXml () const
Protected Attributes
Type	_type
union {
ValueArray *   asArray
BinaryData *   asBinary
bool   asBool
double   asDouble
int   asInt
std::string *   asString
ValueStruct *   asStruct
tm *   asTime
}	_value
Static Protected Attributes
std::string	_doubleFormat

---

Detailed Description

RPC method arguments and results are represented by Values.

---

Member Typedef Documentation

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

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

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

---

Member Enumeration Documentation

enum XmlRpc::XmlRpcValue::Type

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

---

Constructor & Destructor Documentation

XmlRpc::XmlRpcValue::XmlRpcValue (   )  [inline]

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

XmlRpc::XmlRpcValue::XmlRpcValue (  bool  value  )  [inline]

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

XmlRpc::XmlRpcValue::XmlRpcValue (  int  value  )  [inline]

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

XmlRpc::XmlRpcValue::XmlRpcValue (  double  value  )  [inline]

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

XmlRpc::XmlRpcValue::XmlRpcValue (  std::string const &  value  )  [inline]

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

XmlRpc::XmlRpcValue::XmlRpcValue (  const char *  value  )  [inline]

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

XmlRpc::XmlRpcValue::XmlRpcValue (  struct tm *  value  )  [inline]

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

XmlRpc::XmlRpcValue::XmlRpcValue (  void *  value, int  nBytes )  [inline]

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

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

Construct from xml, beginning at *offset chars into the string, updates offset. : _type(TypeInvalid) { if ( ! fromXml(xml,offset)) _type = TypeInvalid; }

XmlRpc::XmlRpcValue::XmlRpcValue (  XmlRpcValue const &  rhs  )  [inline]

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

XmlRpc::XmlRpcValue::~XmlRpcValue (   )  [inline]

Destructor (make virtual if you want to subclass). { invalidate(); }

---

Member Function Documentation

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

{ 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; }

std::string XmlRpc::XmlRpcValue::arrayToXml (   )  const [protected]

{ 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; }

void XmlRpc::XmlRpcValue::assertArray (  int  size  )  [protected]

{ 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"); }

void XmlRpc::XmlRpcValue::assertArray (  int  size  )  const [protected]

{ 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"); }

void XmlRpc::XmlRpcValue::assertStruct (   )  [protected]

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

void XmlRpc::XmlRpcValue::assertTypeOrInvalid (  Type  t  )  [protected]

{ 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"); }

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

{ 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; }

std::string XmlRpc::XmlRpcValue::binaryToXml (   )  const [protected]

{ // 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; }

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

{ 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; }

std::string XmlRpc::XmlRpcValue::boolToXml (   )  const [protected]

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

void XmlRpc::XmlRpcValue::clear (  void   )  [inline]

Erase the current value. { invalidate(); }

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

{ 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; }

std::string XmlRpc::XmlRpcValue::doubleToXml (   )  const [protected]

{ 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; }

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

Decode xml. Destroys any existing value. { 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; }

std::string const& XmlRpc::XmlRpcValue::getDoubleFormat (   )  [inline, static]

Return the format used to write double values. { return _doubleFormat; }

Type const& XmlRpc::XmlRpcValue::getType (   )  const [inline]

Return the type of the value stored. Type. { return _type; }

bool XmlRpc::XmlRpcValue::hasMember (  const std::string &  name  )  const

Check for the existence of a struct member by name. { return _type == TypeStruct && _value.asStruct->find(name) != _value.asStruct->end(); }

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

{ 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; }

std::string XmlRpc::XmlRpcValue::intToXml (   )  const [protected]

{ 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; }

void XmlRpc::XmlRpcValue::invalidate (   )  [protected]

{ 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; }

XmlRpc::XmlRpcValue::operator BinaryData & (   )  [inline]

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

XmlRpc::XmlRpcValue::operator bool & (   )  [inline]

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

XmlRpc::XmlRpcValue::operator double & (   )  [inline]

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

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

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

XmlRpc::XmlRpcValue::operator std::string & (   )  [inline]

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

XmlRpc::XmlRpcValue::operator struct tm & (   )  [inline]

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

bool XmlRpc::XmlRpcValue::operator!= (  XmlRpcValue const &  other  )  const

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

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

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

XmlRpcValue& XmlRpc::XmlRpcValue::operator= (  double const &  rhs  )  [inline]

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

XmlRpcValue& XmlRpc::XmlRpcValue::operator= (  int const &  rhs  )  [inline]

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

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

{ 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; }

bool XmlRpc::XmlRpcValue::operator== (  XmlRpcValue const &  other  )  const

{ 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 ... }

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

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

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

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

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

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

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

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

void XmlRpc::XmlRpcValue::setDoubleFormat (  const char *  f  )  [inline, static]

Specify the format used to write double values. { _doubleFormat = f; }

void XmlRpc::XmlRpcValue::setSize (  int  size  )  [inline]

Specify the size for array values. Array values will grow beyond this size if needed. { assertArray(size); }

int XmlRpc::XmlRpcValue::size (   )  const

Return the size for string, base64, array, and struct values. { 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"); }

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

{ 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; }

std::string XmlRpc::XmlRpcValue::stringToXml (   )  const [protected]

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

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

{ _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; }

std::string XmlRpc::XmlRpcValue::structToXml (   )  const [protected]

{ 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; }

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

{ 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; }

std::string XmlRpc::XmlRpcValue::timeToXml (   )  const [protected]

{ 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; }

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

Encode the Value in xml. { 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 }

bool XmlRpc::XmlRpcValue::valid (   )  const [inline]

Return true if the value has been set to something. { return _type != TypeInvalid; }

std::ostream & XmlRpc::XmlRpcValue::write (  std::ostream &  os  )  const

Write the value (no xml encoding). { 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

std::string XmlRpc::XmlRpcValue::_doubleFormat [static, protected]

Type XmlRpc::XmlRpcValue::_type [protected]

union { ... } XmlRpc::XmlRpcValue::_value [protected]

ValueArray* XmlRpc::XmlRpcValue::asArray [protected]

BinaryData* XmlRpc::XmlRpcValue::asBinary [protected]

bool XmlRpc::XmlRpcValue::asBool [protected]

double XmlRpc::XmlRpcValue::asDouble [protected]

int XmlRpc::XmlRpcValue::asInt [protected]

std::string* XmlRpc::XmlRpcValue::asString [protected]

ValueStruct* XmlRpc::XmlRpcValue::asStruct [protected]

struct tm* XmlRpc::XmlRpcValue::asTime [protected]

---

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

• /data0/mdestefa/bes3soft/Boss_6.5.5/dist/6.5.5/Utilities/JobInfoSvc/JobInfoSvc-00-00-01/xmlrpc++0.7/src/XmlRpcValue.h
• /data0/mdestefa/bes3soft/Boss_6.5.5/dist/6.5.5/Utilities/JobInfoSvc/JobInfoSvc-00-00-01/xmlrpc++0.7/src/XmlRpcValue.cpp

---