XmlRpc::XmlRpcUtil Class Reference

Utilities for XML parsing, encoding, and decoding and message handlers. More...

#include <XmlRpcUtil.h>

Static Public Member Functions
static std::string	parseTag (const char *tag, std::string const &xml, int *offset)
	Returns contents between <tag> and </tag>, updates offset to char after </tag>.
static bool	findTag (const char *tag, std::string const &xml, int *offset)
	Returns true if the tag is found and updates offset to the char after the tag.
static std::string	getNextTag (std::string const &xml, int *offset)
static bool	nextTagIs (const char *tag, std::string const &xml, int *offset)
static std::string	xmlEncode (const std::string &raw)
	Convert raw text to encoded xml.
static std::string	xmlDecode (const std::string &encoded)
	Convert encoded xml to raw text.
static void	log (int level, const char *fmt,...)
	Dump messages somewhere.
static void	error (const char *fmt,...)
	Dump error messages somewhere.

Detailed Description

Utilities for XML parsing, encoding, and decoding and message handlers.

Definition at line 27 of file XmlRpcUtil.h.

Member Function Documentation

error()

void XmlRpcUtil::error ( const char * fmt, ... )

static

Dump error messages somewhere.

Definition at line 80 of file XmlRpcUtil.cpp.

                                             {
  va_list va;
  va_start( va, fmt );
  char buf[1024];
  vsnprintf( buf, sizeof( buf ) - 1, fmt, va );
  buf[sizeof( buf ) - 1] = 0;
  XmlRpcErrorHandler::getErrorHandler()->error( buf );
}

Referenced by XmlRpc::XmlRpcServer::acceptConnection(), XmlRpc::XmlRpcServer::bindAndListen(), XmlRpc::XmlRpcClient::doConnect(), XmlRpc::XmlRpcClient::handleEvent(), XmlRpc::XmlRpcClient::parseResponse(), XmlRpc::XmlRpcClient::readHeader(), XmlRpc::XmlRpcServerConnection::readHeader(), XmlRpc::XmlRpcServerConnection::readRequest(), XmlRpc::XmlRpcClient::readResponse(), XmlRpc::XmlRpcDispatch::work(), XmlRpc::XmlRpcClient::writeRequest(), and XmlRpc::XmlRpcServerConnection::writeResponse().

findTag()

bool XmlRpcUtil::findTag ( const char * tag, std::string const & xml, int * offset )

static

Returns true if the tag is found and updates offset to the char after the tag.

Definition at line 105 of file XmlRpcUtil.cpp.

                                                                             {
  if ( *offset >= int( xml.length() ) ) return false;
  size_t istart = xml.find( tag, *offset );
  if ( istart == std::string::npos ) return false;
 
  *offset = int( istart + strlen( tag ) );
  return true;
}

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

getNextTag()

std::string XmlRpcUtil::getNextTag ( std::string const & xml, int * offset )

static

Returns the next tag and updates offset to the char after the tag, or empty string if the next non-whitespace character is not '<'

Definition at line 137 of file XmlRpcUtil.cpp.

                                                                    {
  if ( *offset >= int( xml.length() ) ) return std::string();
 
  size_t      pos = *offset;
  const char* cp  = xml.c_str() + pos;
  while ( *cp && isspace( *cp ) )
  {
    ++cp;
    ++pos;
  }
 
  if ( *cp != '<' ) return std::string();
 
  std::string s;
  do {
    s += *cp;
    ++pos;
  } while ( *cp++ != '>' && *cp != 0 );
 
  *offset = int( pos );
  return s;
}

Referenced by XmlRpc::XmlRpcValue::fromXml().

log()

void XmlRpcUtil::log ( int level, const char * fmt, ... )

static

Dump messages somewhere.

Definition at line 68 of file XmlRpcUtil.cpp.

                                                      {
  if ( level <= XmlRpcLogHandler::getVerbosity() )
  {
    va_list va;
    char    buf[1024];
    va_start( va, fmt );
    vsnprintf( buf, sizeof( buf ) - 1, fmt, va );
    buf[sizeof( buf ) - 1] = 0;
    XmlRpcLogHandler::getLogHandler()->log( level, buf );
  }
}

Referenced by XmlRpc::XmlRpcServer::acceptConnection(), XmlRpc::XmlRpcServer::bindAndListen(), XmlRpc::XmlRpcClient::close(), XmlRpc::XmlRpcSocket::close(), XmlRpc::XmlRpcSource::close(), XmlRpc::XmlRpcClient::doConnect(), XmlRpc::XmlRpcClient::execute(), XmlRpc::XmlRpcServerConnection::executeRequest(), XmlRpc::XmlRpcClient::generateRequest(), XmlRpc::XmlRpcServerConnection::generateResponse(), XmlRpc::XmlRpcSocket::nbRead(), XmlRpc::XmlRpcSocket::nbWrite(), parseRequest(), XmlRpc::XmlRpcClient::readHeader(), XmlRpc::XmlRpcServerConnection::readHeader(), XmlRpc::XmlRpcServerConnection::readRequest(), XmlRpc::XmlRpcClient::readResponse(), XmlRpc::XmlRpcServer::work(), XmlRpc::XmlRpcClient::writeRequest(), XmlRpc::XmlRpcServerConnection::writeResponse(), XmlRpc::XmlRpcClient::XmlRpcClient(), XmlRpc::XmlRpcServerConnection::XmlRpcServerConnection(), and XmlRpc::XmlRpcServerConnection::~XmlRpcServerConnection().

nextTagIs()

bool XmlRpcUtil::nextTagIs ( const char * tag, std::string const & xml, int * offset )

static

Returns true if the tag is found at the specified offset (modulo any whitespace) and updates offset to the char after the tag

Definition at line 116 of file XmlRpcUtil.cpp.

                                                                               {
  if ( *offset >= int( xml.length() ) ) return false;
  const char* cp = xml.c_str() + *offset;
  int         nc = 0;
  while ( *cp && isspace( *cp ) )
  {
    ++cp;
    ++nc;
  }
 
  int len = int( strlen( tag ) );
  if ( *cp && ( strncmp( cp, tag, len ) == 0 ) )
  {
    *offset += nc + len;
    return true;
  }
  return false;
}

Referenced by XmlRpc::XmlRpcValue::arrayFromXml(), XmlRpc::XmlRpcValue::fromXml(), parseRequest(), XmlRpc::XmlRpcServerConnection::parseRequest(), XmlRpc::XmlRpcClient::parseResponse(), and XmlRpc::XmlRpcValue::structFromXml().

parseTag()

std::string XmlRpcUtil::parseTag ( const char * tag, std::string const & xml, int * offset )

static

Returns contents between <tag> and </tag>, updates offset to char after </tag>.

Definition at line 90 of file XmlRpcUtil.cpp.

                                                                                   {
  if ( *offset >= int( xml.length() ) ) return std::string();
  size_t istart = xml.find( tag, *offset );
  if ( istart == std::string::npos ) return std::string();
  istart += strlen( tag );
  std::string etag = "</";
  etag += tag + 1;
  size_t iend = xml.find( etag, istart );
  if ( iend == std::string::npos ) return std::string();
 
  *offset = int( iend + etag.length() );
  return xml.substr( istart, iend - istart );
}

Referenced by parseRequest(), XmlRpc::XmlRpcServerConnection::parseRequest(), and XmlRpc::XmlRpcValue::structFromXml().

xmlDecode()

std::string XmlRpcUtil::xmlDecode ( const std::string & encoded )

static

Convert encoded xml to raw text.

Definition at line 168 of file XmlRpcUtil.cpp.

                                                          {
  std::string::size_type iAmp = encoded.find( AMP );
  if ( iAmp == std::string::npos ) return encoded;
 
  std::string            decoded( encoded, 0, iAmp );
  std::string::size_type iSize = encoded.size();
  decoded.reserve( iSize );
 
  const char* ens = encoded.c_str();
  while ( iAmp != iSize )
  {
    if ( encoded[iAmp] == AMP && iAmp + 1 < iSize )
    {
      int iEntity;
      for ( iEntity = 0; xmlEntity[iEntity] != 0; ++iEntity )
        // if (encoded.compare(iAmp+1, xmlEntLen[iEntity], xmlEntity[iEntity]) == 0)
        if ( strncmp( ens + iAmp + 1, xmlEntity[iEntity], xmlEntLen[iEntity] ) == 0 )
        {
          decoded += rawEntity[iEntity];
          iAmp += xmlEntLen[iEntity] + 1;
          break;
        }
      if ( xmlEntity[iEntity] == 0 ) // unrecognized sequence
        decoded += encoded[iAmp++];
    }
    else { decoded += encoded[iAmp++]; }
  }
 
  return decoded;
}

Referenced by main(), and XmlRpc::XmlRpcValue::stringFromXml().

xmlEncode()

std::string XmlRpcUtil::xmlEncode ( const std::string & raw )

static

Convert raw text to encoded xml.

Definition at line 201 of file XmlRpcUtil.cpp.

                                                      {
  std::string::size_type iRep = raw.find_first_of( rawEntity );
  if ( iRep == std::string::npos ) return raw;
 
  std::string            encoded( raw, 0, iRep );
  std::string::size_type iSize = raw.size();
 
  while ( iRep != iSize )
  {
    int iEntity;
    for ( iEntity = 0; rawEntity[iEntity] != 0; ++iEntity )
      if ( raw[iRep] == rawEntity[iEntity] )
      {
        encoded += AMP;
        encoded += xmlEntity[iEntity];
        break;
      }
    if ( rawEntity[iEntity] == 0 ) encoded += raw[iRep];
    ++iRep;
  }
  return encoded;
}

Referenced by main(), XmlRpc::XmlRpcValue::stringToXml(), and XmlRpc::XmlRpcValue::structToXml().

---

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

• XmlRpcUtil.h
• XmlRpcUtil.cpp