pegasus/src/Pegasus/Common/XmlWriter.cpp - diff

Return to XmlWriter.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/XmlWriter.cpp between version 1.10 and 1.31

version 1.10, 2001/04/13 18:20:51

version 1.31, 2002/03/02 00:15:57

Line 1

//BEGIN_LICENSE

//%/////////////////////////////////////////////////////////////////////////////

// The Open Group, Tivoli Systems

// Permission is hereby granted, free of charge, to any person obtaining a

// Permission is hereby granted, free of charge, to any person obtaining a copy

// copy of this software and associated documentation files (the "Software"),

// of this software and associated documentation files (the "Software"), to

// to deal in the Software without restriction, including without limitation

// deal in the Software without restriction, including without limitation the

// the rights to use, copy, modify, merge, publish, distribute, sublicense,

// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

// and/or sell copies of the Software, and to permit persons to whom the

// sell copies of the Software, and to permit persons to whom the Software is

// Software is furnished to do so, subject to the following conditions:

// furnished to do so, subject to the following conditions:

// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN

// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED

// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT

// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR

// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

//==============================================================================

// Author: Mike Brasher (mbrasher@bmc.com)

// Modified By: Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)

// Nag Boranna, Hewlett-Packard Company (nagaraja_boranna@hp.com)

// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

//%/////////////////////////////////////////////////////////////////////////////

// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

// DEALINGS IN THE SOFTWARE.

//END_LICENSE

//BEGIN_HISTORY

// Author:

// $Log$

// Revision 1.10 2001/04/13 18:20:51 mike

// Ported so Solaris.

// Fixed memory leaks.

// Revision 1.9 2001/04/08 01:13:22 mike

// Changed "ConstCIM" to "CIMConst"

// Revision 1.7 2001/02/20 07:25:57 mike

// Added basic create-instance in repository and in client.

// Revision 1.6 2001/02/19 01:47:17 mike

// Renamed names of the form CIMConst to CIMConst.

// Revision 1.5 2001/02/18 03:56:01 mike

// Changed more class names (e.g., ConstClassDecl -> CIMConstClass)

// Revision 1.4 2001/02/16 02:06:07 mike

// Renamed many classes and headers.

// Revision 1.3 2001/01/31 08:20:51 mike

// Added dispatcher framework.

// Added enumerateInstanceNames.

// Revision 1.2 2001/01/29 02:23:44 mike

// Added support for GetInstance operation

// Revision 1.1.1.1 2001/01/14 19:53:36 mike

// Pegasus import

//END_HISTORY

#include <cstdlib>

#include <cstdio>

#include "Destroyer.h"

#include "CIMClass.h"

#include "CIMInstance.h"

#include "CIMQualifierDecl.h"

Line 65

Line 40

PEGASUS_NAMESPACE_BEGIN

inline void AppendChar(Array<Sint8>& out, Char16 c)

Array<Sint8>& operator<<(Array<Sint8>& out, const char* x)

{

XmlWriter::append(out, x);

return out;

}

Array<Sint8>& operator<<(Array<Sint8>& out, char x)

{

XmlWriter::append(out, x);

return out;

}

Array<Sint8>& operator<<(Array<Sint8>& out, Char16 x)

{

XmlWriter::append(out, x);

return out;

}

Array<Sint8>& operator<<(Array<Sint8>& out, const String& x)

{

XmlWriter::append(out, x);

return out;

}

Array<Sint8>& operator<<(Array<Sint8>& out, const Indentor& x)

{

XmlWriter::append(out, x);

return out;

}

Array<Sint8>& operator<<(Array<Sint8>& out, const Array<Sint8>& x)

{

out.appendArray(x);

return out;

}

Array<Sint8>& operator<<(Array<Sint8>& out, Uint32 x)

{

XmlWriter::append(out, x);

return out;

}

inline void _appendChar(Array<Sint8>& out, Char16 c)

{

out.append(Sint8(c));

}

inline void AppendSpecialChar(Array<Sint8>& out, Char16 c)

inline void _appendSpecialChar(Array<Sint8>& out, Char16 c)

{

// ATTN-B: Only UTF-8 handled for now.

Line 101

Line 118

}

static inline void _appendSpecialChar(PEGASUS_STD(ostream)& os, char c)

{

switch (c)

{

case '&':

os << "&";

break;

case '<':

os << "<";

break;

case '>':

os << ">";

break;

case '"':

os << """;

break;

case '\'':

os << "'";

break;

default:

os << c;

}

static inline void _appendSpecial(PEGASUS_STD(ostream)& os, const char* str)

{

while (*str)

_appendSpecialChar(os, *str++);

}

void XmlWriter::append(Array<Sint8>& out, Char16 x)

{

AppendChar(out, x);

_appendChar(out, x);

}

void XmlWriter::append(Array<Sint8>& out, Uint32 x)

Line 116

Line 168

void XmlWriter::append(Array<Sint8>& out, const char* str)

{

while (*str)

AppendChar(out, *str++);

_appendChar(out, *str++);

}

void XmlWriter::append(Array<Sint8>& out, const String& str)

{

const Char16* tmp = str.getData();

while (*tmp)

_appendChar(out, *tmp++);

}

void XmlWriter::append(Array<Sint8>& out, const Indentor& x)

{

for (Uint32 i = 0; i < 4 * x.getLevel(); i++)

out.append(' ');

}

void XmlWriter::appendSpecial(Array<Sint8>& out, Char16 x)

{

AppendSpecialChar(out, x);

_appendSpecialChar(out, x);

}

void XmlWriter::appendSpecial(Array<Sint8>& out, char x)

{

AppendSpecialChar(out, Char16(x));

_appendSpecialChar(out, Char16(x));

}

void XmlWriter::appendSpecial(Array<Sint8>& out, const char* str)

{

while (*str)

AppendSpecialChar(out, *str++);

_appendSpecialChar(out, *str++);

}

void XmlWriter::appendSpecial(Array<Sint8>& out, const String& str)

Line 140

Line 206

const Char16* tmp = str.getData();

while (*tmp)

AppendSpecialChar(out, *tmp++);

_appendSpecialChar(out, *tmp++);

}

void XmlWriter::append(Array<Sint8>& out, const String& str)

{

const Char16* tmp = str.getData();

while (*tmp)

AppendChar(out, *tmp++);

}

void XmlWriter::append(Array<Sint8>& out, const Indentor& x)

//------------------------------------------------------------------------------

{

for (Uint32 i = 0; i < 4 * x.getLevel(); i++)

// appendLocalNameSpacePathElement()

out.append(' ');

}

// <!ELEMENT LOCALNAMESPACEPATH (NAMESPACE+)>

//------------------------------------------------------------------------------

void XmlWriter::appendLocalNameSpaceElement(

void XmlWriter::appendLocalNameSpacePathElement(

Array<Sint8>& out,

const String& nameSpace)

{

Line 165

Line 225

char* tmp = nameSpace.allocateCString();

// ATTN-RK-P3-20020301: Is it necessary/helpful to break this into parts?

for (char* p = strtok(tmp, "/"); p; p = strtok(NULL, "/"))

{

out << "<NAMESPACE NAME=\"" << p << "\"/>\n";

Line 175

Line 236

out << "</LOCALNAMESPACEPATH>\n";

}

static inline void AppendSpecialChar(std::ostream& os, char c)

//------------------------------------------------------------------------------

// appendNameSpacePathElement()

// <!ELEMENT NAMESPACEPATH (HOST,LOCALNAMESPACEPATH)>

//------------------------------------------------------------------------------

void XmlWriter::appendNameSpacePathElement(

Array<Sint8>& out,

const String& host,

const String& nameSpace)

{

switch (c)

out << "<NAMESPACEPATH>\n";

out << "<HOST>" << host << "</HOST>\n";

appendLocalNameSpacePathElement(out, nameSpace);

out << "</NAMESPACEPATH>\n";

}

//------------------------------------------------------------------------------

// appendClassNameElement()

// <!ELEMENT CLASSNAME EMPTY>

// <!ATTLIST CLASSNAME

// %CIMName;>

//------------------------------------------------------------------------------

void XmlWriter::appendClassNameElement(

Array<Sint8>& out,

const String& className)

{

case '&':

out << "<CLASSNAME NAME=\"" << className << "\"/>\n";

os << "&";

}

break;

case '<':

//------------------------------------------------------------------------------

os << "<";

break;

// appendInstanceNameElement()

// <!ELEMENT INSTANCENAME (KEYBINDING*|KEYVALUE?|VALUE.REFERENCE?)>

// <!ATTLIST INSTANCENAME

// %ClassName;>

//------------------------------------------------------------------------------

case '>':

void XmlWriter::appendInstanceNameElement(

os << ">";

Array<Sint8>& out,

break;

const CIMReference& instanceName)

{

out << "<INSTANCENAME CLASSNAME=\"" << instanceName.getClassName() << "\">\n";

case '"':

Array<KeyBinding> keyBindings = instanceName.getKeyBindings();

os << """;

for (Uint32 i = 0, n = keyBindings.size(); i < n; i++)

break;

{

out << "<KEYBINDING NAME=\"" << keyBindings[i].getName() << "\">\n";

case '\'':

if (keyBindings[i].getType() == KeyBinding::REFERENCE)

os << "'";

{

break;

CIMReference ref = keyBindings[i].getValue();

ref.toXml(out, true);

}

else {

out << "<KEYVALUE VALUETYPE=\"";

out << KeyBinding::typeToString(keyBindings[i].getType());

out << "\">";

default:

// fixed the special character problem - Markus

os << c;

appendSpecial(out, keyBindings[i].getValue());

out << "</KEYVALUE>\n";

}

out << "</KEYBINDING>\n";

}

out << "</INSTANCENAME>\n";

}

//------------------------------------------------------------------------------

// appendClassPathElement()

// <!ELEMENT CLASSPATH (NAMESPACEPATH,CLASSNAME)>

//------------------------------------------------------------------------------

void XmlWriter::appendClassPathElement(

Array<Sint8>& out,

const CIMReference& classPath)

{

out << "<CLASSPATH>\n";

appendNameSpacePathElement(out,

classPath.getHost(),

classPath.getNameSpace());

appendClassNameElement(out, classPath.getClassName());

out << "</CLASSPATH>\n";

}

//------------------------------------------------------------------------------

// appendInstancePathElement()

// <!ELEMENT INSTANCEPATH (NAMESPACEPATH,INSTANCENAME)>

//------------------------------------------------------------------------------

void XmlWriter::appendInstancePathElement(

Array<Sint8>& out,

const CIMReference& instancePath)

{

out << "<INSTANCEPATH>\n";

appendNameSpacePathElement(out,

instancePath.getHost(),

instancePath.getNameSpace());

appendInstanceNameElement(out, instancePath);

out << "</INSTANCEPATH>\n";

}

//------------------------------------------------------------------------------

// appendLocalClassPathElement()

// <!ELEMENT LOCALCLASSPATH (LOCALNAMESPACEPATH, CLASSNAME)>

//------------------------------------------------------------------------------

void XmlWriter::appendLocalClassPathElement(

Array<Sint8>& out,

const CIMReference& classPath)

{

out << "<LOCALCLASSPATH>\n";

appendLocalNameSpacePathElement(out, classPath.getNameSpace());

appendClassNameElement(out, classPath.getClassName());

out << "</LOCALCLASSPATH>\n";

}

//------------------------------------------------------------------------------

// appendLocalInstancePathElement()

// <!ELEMENT LOCALINSTANCEPATH (LOCALNAMESPACEPATH, INSTANCENAME)>

//------------------------------------------------------------------------------

void XmlWriter::appendLocalInstancePathElement(

Array<Sint8>& out,

const CIMReference& instancePath)

{

out << "<LOCALINSTANCEPATH>\n";

appendLocalNameSpacePathElement(out, instancePath.getNameSpace());

appendInstanceNameElement(out, instancePath);

out << "</LOCALINSTANCEPATH>\n";

}

//------------------------------------------------------------------------------

// appendLocalObjectPathElement()

// If the reference refers to an instance, write a LOCALINSTANCEPATH;

// otherwise write a LOCALCLASSPATH.

//------------------------------------------------------------------------------

void XmlWriter::appendLocalObjectPathElement(

Array<Sint8>& out,

const CIMReference& objectPath)

{

if (objectPath.isInstanceName())

{

appendLocalInstancePathElement(out, objectPath);

}

else

{

appendLocalClassPathElement(out, objectPath);

}

//------------------------------------------------------------------------------

// appendMethodCallHeader()

// Build HTTP method call request header.

//------------------------------------------------------------------------------

void XmlWriter::appendMethodCallHeader(

Array<Sint8>& out,

const char* host,

const char* cimMethod,

const String& cimObject,

const String& authenticationHeader,

Uint32 contentLength)

{

char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };

out << "M-POST /cimom HTTP/1.1\r\n";

out << "HOST: " << host << "\r\n";

out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";

out << "Content-Length: " << contentLength << "\r\n";

out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";

out << nn <<"\r\n";

out << nn << "-CIMOperation: MethodCall\r\n";

out << nn << "-CIMMethod: " << cimMethod << "\r\n";

out << nn << "-CIMObject: " << cimObject << "\r\n";

if (authenticationHeader.size())

{

out << authenticationHeader << "\r\n";

}

out << "\r\n";

}

//------------------------------------------------------------------------------

// appendMethodResponseHeader()

// Build HTTP response header.

//------------------------------------------------------------------------------

void XmlWriter::appendMethodResponseHeader(

Array<Sint8>& out,

Uint32 contentLength)

{

char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };

out << "HTTP/1.1 200 OK\r\n";

out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";

out << "Content-Length: " << contentLength << "\r\n";

out << "Ext:\r\n";

out << "Cache-Control: no-cache\r\n";

out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";

out << nn <<"\r\n";

out << nn << "-CIMOperation: MethodResponse\r\n\r\n";

}

//------------------------------------------------------------------------------

// appendUnauthorizedResponseHeader()

// Build HTTP authentication response header for unauthorized requests.

// Returns unauthorized message in the following format:

// HTTP/1.1 401 Unauthorized

// WWW-Authenticate: Basic "hostname:80"

// <HTML><HEAD>

// <TITLE>401 Unauthorized</TITLE>

// </HEAD><BODY BGCOLOR="#99cc99">

// <H2>TEST401 Unauthorized</H2>

// <HR>

// </BODY></HTML>

//------------------------------------------------------------------------------

void XmlWriter::appendUnauthorizedResponseHeader(

Array<Sint8>& out,

const String& content)

{

out << "HTTP/1.1 401 Unauthorized\r\n";

out << content << "\r\n";

out << "\r\n";

//ATTN: We may need to include the following line, so that the browsers

// can display the error message.

// out << "<HTML><HEAD>\r\n";

// out << "<TITLE>" << "401 Unauthorized" << "</TITLE>\r\n";

// out << "</HEAD><BODY BGCOLOR=\"#99cc99\">\r\n";

// out << "<H2>TEST" << "401 Unauthorized" << "</H2>\r\n";

// out << "<HR>\r\n";

// out << "</BODY></HTML>\r\n";

}

//------------------------------------------------------------------------------

// _appendMessageElementBegin()

// _appendMessageElementEnd()

// <!ELEMENT MESSAGE (SIMPLEREQ|MULTIREQ|SIMPLERSP|MULTIRSP)>

// <!ATTLIST MESSAGE

// ID CDATA #REQUIRED

// PROTOCOLVERSION CDATA #REQUIRED>

//------------------------------------------------------------------------------

void XmlWriter::_appendMessageElementBegin(

Array<Sint8>& out,

const String& messageId)

{

out << "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";

out << "<CIM CIMVERSION=\"2.0\" DTDVERSION=\"2.0\">\n";

out << "<MESSAGE ID=\"" << messageId << "\" PROTOCOLVERSION=\"1.0\">\n";

}

void XmlWriter::_appendMessageElementEnd(

Array<Sint8>& out)

{

out << "</MESSAGE>\n";

out << "</CIM>\n";

}

//------------------------------------------------------------------------------

// _appendSimpleReqElementBegin()

// _appendSimpleReqElementEnd()

// <!ELEMENT SIMPLEREQ (IMETHODCALL|METHODCALL)>

//------------------------------------------------------------------------------

void XmlWriter::_appendSimpleReqElementBegin(

Array<Sint8>& out)

{

out << "<SIMPLEREQ>\n";

}

void XmlWriter::_appendSimpleReqElementEnd(

Array<Sint8>& out)

{

out << "</SIMPLEREQ>\n";

}

//------------------------------------------------------------------------------

// _appendMethodCallElementBegin()

// _appendMethodCallElementEnd()

// <!ELEMENT METHODCALL ((LOCALCLASSPATH|LOCALINSTANCEPATH),PARAMVALUE*)>

// <!ATTLIST METHODCALL %CIMName;>

//------------------------------------------------------------------------------

void XmlWriter::_appendMethodCallElementBegin(

Array<Sint8>& out,

const char* name)

{

out << "<METHODCALL NAME=\"" << name << "\">\n";

}

void XmlWriter::_appendMethodCallElementEnd(

Array<Sint8>& out)

{

out << "</METHODCALL>\n";

}

//------------------------------------------------------------------------------

// _appendIMethodCallElementBegin()

// _appendIMethodCallElementEnd()

// <!ELEMENT IMETHODCALL (LOCALNAMESPACEPATH,IPARAMVALUE*)>

// <!ATTLIST IMETHODCALL %CIMName;>

//------------------------------------------------------------------------------

void XmlWriter::_appendIMethodCallElementBegin(

Array<Sint8>& out,

const char* name)

{

out << "<IMETHODCALL NAME=\"" << name << "\">\n";

}

void XmlWriter::_appendIMethodCallElementEnd(

Array<Sint8>& out)

{

out << "</IMETHODCALL>\n";

}

//------------------------------------------------------------------------------

// _appendIParamValueElementBegin()

// _appendIParamValueElementEnd()

// <!ELEMENT IPARAMVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE

// |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION

// |CLASS|INSTANCE|VALUE.NAMEDINSTANCE)?>

// <!ATTLIST IPARAMVALUE %CIMName;>

//------------------------------------------------------------------------------

void XmlWriter::_appendIParamValueElementBegin(

Array<Sint8>& out,

const char* name)

{

out << "<IPARAMVALUE NAME=\"" << name << "\">\n";

}

void XmlWriter::_appendIParamValueElementEnd(

Array<Sint8>& out)

{

out << "</IPARAMVALUE>\n";

}

//------------------------------------------------------------------------------

// _appendSimpleRspElementBegin()

// _appendSimpleRspElementEnd()

// <!ELEMENT SIMPLERSP (METHODRESPONSE|IMETHODRESPONSE)>

//------------------------------------------------------------------------------

void XmlWriter::_appendSimpleRspElementBegin(

Array<Sint8>& out)

{

out << "<SIMPLERSP>\n";

}

void XmlWriter::_appendSimpleRspElementEnd(

Array<Sint8>& out)

{

out << "</SIMPLERSP>\n";

}

//------------------------------------------------------------------------------

// _appendMethodResponseElementBegin()

// _appendMethodResponseElementEnd()

// <!ELEMENT METHODRESPONSE (ERROR|IRETURNVALUE?)>

// <!ATTLIST METHODRESPONSE %CIMName;>

//------------------------------------------------------------------------------

void XmlWriter::_appendMethodResponseElementBegin(

Array<Sint8>& out,

const char* name)

{

out << "<METHODRESPONSE NAME=\"" << name << "\">\n";

}

void XmlWriter::_appendMethodResponseElementEnd(

Array<Sint8>& out)

{

out << "</METHODRESPONSE>\n";

}

//------------------------------------------------------------------------------

// _appendIMethodResponseElementBegin()

// _appendIMethodResponseElementEnd()

// <!ELEMENT IMETHODRESPONSE (ERROR|IRETURNVALUE?)>

// <!ATTLIST IMETHODRESPONSE %CIMName;>

//------------------------------------------------------------------------------

void XmlWriter::_appendIMethodResponseElementBegin(

Array<Sint8>& out,

const char* name)

{

out << "<IMETHODRESPONSE NAME=\"" << name << "\">\n";

}

void XmlWriter::_appendIMethodResponseElementEnd(

Array<Sint8>& out)

{

out << "</IMETHODRESPONSE>\n";

}

//------------------------------------------------------------------------------

// _appendErrorElement()

//------------------------------------------------------------------------------

void XmlWriter::_appendErrorElement(

Array<Sint8>& out,

CIMStatusCode code,

const char* description)

{

out << "<ERROR";

out << " CODE=\"" << Uint32(code) << "\"";

out << " DESCRIPTION=\"";

appendSpecial(out, description);

out << "\"/>";

}

//------------------------------------------------------------------------------

// appendReturnValueElement()

// <!ELEMENT RETURNVALUE (VALUE|VALUE.REFERENCE)>

// <!ATTLIST RETURNVALUE

// %ParamType;>

//------------------------------------------------------------------------------

void XmlWriter::appendReturnValueElement(

Array<Sint8>& out,

const CIMValue& value)

{

out << "<RETURNVALUE";

CIMType type = value.getType();

if (type != CIMType::NONE)

{

out << " PARAMTYPE=\"" << TypeToString(type) << "\"";

}

out << ">\n";

value.toXml(out);

out << "</RETURNVALUE>\n";

}

//------------------------------------------------------------------------------

// _appendIReturnValueElementBegin()

// _appendIReturnValueElementEnd()

// <!ELEMENT IRETURNVALUE (CLASSNAME*|INSTANCENAME*|VALUE*|

// VALUE.OBJECTWITHPATH*|VALUE.OBJECTWITHLOCALPATH*|VALUE.OBJECT*|

// OBJECTPATH*|QUALIFIER.DECLARATION*|VALUE.ARRAY?|VALUE.REFERENCE?|

// CLASS*|INSTANCE*|VALUE.NAMEDINSTANCE*)>

//------------------------------------------------------------------------------

void XmlWriter::_appendIReturnValueElementBegin(

Array<Sint8>& out)

{

out << "<IRETURNVALUE>\n";

}

void XmlWriter::_appendIReturnValueElementEnd(

Array<Sint8>& out)

{

out << "</IRETURNVALUE>\n";

}

//------------------------------------------------------------------------------

// appendBooleanIParameter()

//------------------------------------------------------------------------------

void XmlWriter::appendBooleanIParameter(

Array<Sint8>& out,

const char* name,

Boolean flag)

{

_appendIParamValueElementBegin(out, name);

out << "<VALUE>" << (flag ? "TRUE" : "FALSE") << "</VALUE>\n";

_appendIParamValueElementEnd(out);

}

//------------------------------------------------------------------------------

// appendStringIParameter()

//------------------------------------------------------------------------------

void XmlWriter::appendStringIParameter(

Array<Sint8>& out,

const char* name,

const String& str)

{

_appendIParamValueElementBegin(out, name);

out << "<VALUE>";

appendSpecial(out, str);

out << "</VALUE>\n";

_appendIParamValueElementEnd(out);

}

//------------------------------------------------------------------------------

// appendQualifierNameIParameter()

//------------------------------------------------------------------------------

void XmlWriter::appendQualifierNameIParameter(

Array<Sint8>& out,

const char* name,

const String& qualifierName)

{

// <!ELEMENT IPARAMVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE

// |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION

// |CLASS|INSTANCE|VALUE.NAMEDINSTANCE)?>

// ATTN: notice that there is really no way to pass a qualifier name

// as an IPARAMVALUE element according to the spec (look above). So we

// just pass it as a class name. An answer must be obtained later.

_appendIParamValueElementBegin(out, name);

appendClassNameElement(out, qualifierName);

_appendIParamValueElementEnd(out);

}

//------------------------------------------------------------------------------

// appendClassNameIParameter()

//------------------------------------------------------------------------------

void XmlWriter::appendClassNameIParameter(

Array<Sint8>& out,

const char* name,

const String& className)

{

_appendIParamValueElementBegin(out, name);

appendClassNameElement(out, className);

_appendIParamValueElementEnd(out);

}

//------------------------------------------------------------------------------

// appendInstanceNameIParameter()

//------------------------------------------------------------------------------

void XmlWriter::appendInstanceNameIParameter(

Array<Sint8>& out,

const char* name,

const CIMReference& instanceName)

{

_appendIParamValueElementBegin(out, name);

appendInstanceNameElement(out, instanceName);

_appendIParamValueElementEnd(out);

}

void XmlWriter::appendObjectNameIParameter(

Array<Sint8>& out,

const char* name,

const CIMReference& objectName)

{

if (objectName.isClassName())

{

XmlWriter::appendClassNameIParameter(

out, name, objectName.getClassName());

}

else

{

XmlWriter::appendInstanceNameIParameter(

out, name, objectName);

}

//------------------------------------------------------------------------------

// appendClassIParameter()

//------------------------------------------------------------------------------

void XmlWriter::appendClassIParameter(

Array<Sint8>& out,

const char* name,

const CIMConstClass& cimClass)

{

_appendIParamValueElementBegin(out, name);

cimClass.toXml(out);

_appendIParamValueElementEnd(out);

}

//------------------------------------------------------------------------------

// appendInstanceIParameter()

//------------------------------------------------------------------------------

void XmlWriter::appendInstanceIParameter(

Array<Sint8>& out,

const char* name,

const CIMConstInstance& instance)

{

_appendIParamValueElementBegin(out, name);

instance.toXml(out);

_appendIParamValueElementEnd(out);

}

//------------------------------------------------------------------------------

// appendNamedInstanceIParameter()

//------------------------------------------------------------------------------

void XmlWriter::appendNamedInstanceIParameter(

Array<Sint8>& out,

const char* name,

const CIMNamedInstance& namedInstance)

{

_appendIParamValueElementBegin(out, name);

namedInstance.toXml(out);

_appendIParamValueElementEnd(out);

}

static inline void AppendSpecial(std::ostream& os, const char* str)

//----------------------------------------------------------

// appendPropertyNameIParameter()

// </IPARAMVALUE>

// <IPARAMVALUE NAME="PropertyName"><VALUE>FreeSpace</VALUE></IPARAMVALUE>

// USE: Create parameter for getProperty operation

//==========================================================

void XmlWriter::appendPropertyNameIParameter(

Array<Sint8>& out,

const String& propertyName)

{

while (*str)

_appendIParamValueElementBegin(out, "PropertyName");

AppendSpecialChar(os, *str++);

out << "<VALUE>" << propertyName << "</VALUE>\n";

_appendIParamValueElementEnd(out);

}

//------------------------------------------------------------------------------

// formatGetHeader()

// appendPropertyValueIParameter()

//------------------------------------------------------------------------------

Array<Sint8> XmlWriter::formatGetHeader(

void XmlWriter::appendPropertyValueIParameter(

const char* documentPath)

Array<Sint8>& out,

const char* name,

const CIMValue& value)

{

Array<Sint8> out;

_appendIParamValueElementBegin(out, name);

return out << "GET " << documentPath << "HTTP/1.0\r\n\r\n";

value.toXml(out);

_appendIParamValueElementEnd(out);

}

//------------------------------------------------------------------------------

// formatMPostHeader()

// appendPropertyListIParameter()

// Build HTTP request header.

//------------------------------------------------------------------------------

Array<Sint8> XmlWriter::formatMPostHeader(

void XmlWriter::appendPropertyListIParameter(

const char* host,

Array<Sint8>& out,

const char* cimOperation,

const CIMPropertyList& propertyList)

const char* cimMethod,

const String& cimObject,

const Array<Sint8>& content)

{

Array<Sint8> out;

_appendIParamValueElementBegin(out, "PropertyList");

out.reserve(1024);

char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };

out << "M-POST /cimom HTTP/1.1\r\n";

out << "<VALUE.ARRAY>\n";

out << "HOST: " << host << "\r\n";

for (Uint32 i = 0; i < propertyList.getNumProperties(); i++)

out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";

{

out << "Content-Length: " << content.getSize() << "\r\n";

out << "<VALUE>" << propertyList.getPropertyName(i) << "</VALUE>\n";

out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";

}

out << nn <<"\r\n";

out << "</VALUE.ARRAY>\n";

out << nn << "-CIMOperation: " << cimOperation << "\r\n";

out << nn << "-CIMMethod: " << cimMethod << "\r\n";

_appendIParamValueElementEnd(out);

out << nn << "-CIMObject: " << cimObject << "\r\n\r\n";

out << content;

return out;

}

//------------------------------------------------------------------------------

// formatMethodResponseHeader()

// appendQualifierDeclarationIParameter()

// Build HTTP response header.

//------------------------------------------------------------------------------

Array<Sint8> XmlWriter::formatMethodResponseHeader(

void XmlWriter::appendQualifierDeclarationIParameter(

const Array<Sint8>& content)

Array<Sint8>& out,

const char* name,

const CIMConstQualifierDecl& qualifierDecl)

{

Array<Sint8> out;

_appendIParamValueElementBegin(out, name);

out.reserve(1024);

qualifierDecl.toXml(out);

char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };

_appendIParamValueElementEnd(out);

out << "HTTP/1.1 200 OK\r\n";

out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";

out << "Content-Length: " << content.getSize() << "\r\n";

out << "Ext:\r\n";

out << "Cache-Control: no-cache\r\n";

out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";

out << nn <<"\r\n";

out << nn << "-CIMOperation: MethodResponse\r\n\r\n";

out << content;

return out;

}

//------------------------------------------------------------------------------

// formatMessageElement()

// XmlWriter::formatSimpleMethodReqMessage()

// <!ELEMENT MESSAGE (SIMPLEREQ|MULTIREQ|SIMPLERSP|MULTIRSP)>

// <!ATTLIST MESSAGE

// ID CDATA #REQUIRED

// PROTOCOLVERSION CDATA #REQUIRED>

//------------------------------------------------------------------------------

Array<Sint8> XmlWriter::formatMessageElement(

// ATTN-RK-P1-20020228: Need to complete copy elimination optimization

Uint32 messageId,

Array<Sint8> XmlWriter::formatSimpleMethodReqMessage(

const Array<Sint8>& body)

const char* host,

const CIMReference& path,

const char* methodName,

const Array<CIMParamValue>& parameters,

const String& messageId,

const String& authenticationHeader)

{

Array<Sint8> out;

out.reserve(1024);

Array<Sint8> tmp;

out << "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";

_appendMessageElementBegin(out, messageId);

out << "<CIM CIMVERSION=\"2.0\" DTDVERSION=\"2.0\">\n";

_appendSimpleReqElementBegin(out);

out << "<MESSAGE ID=\"" << messageId << "\" PROTOCOLVERSION=\"1.0\">\n";

_appendMethodCallElementBegin(out, methodName);

out << body;

appendLocalObjectPathElement(out, path);

out << "</MESSAGE>\n";

for (Uint32 i=0; i < parameters.size(); i++)

out << "</CIM>\n";

{

return out;

parameters[i].toXml(out);

}

_appendMethodCallElementEnd(out);

_appendSimpleReqElementEnd(out);

_appendMessageElementEnd(out);

//------------------------------------------------------------------------------

appendMethodCallHeader(

tmp,

// formatSimpleReqElement()

host,

methodName,

// <!ELEMENT SIMPLEREQ (IMETHODCALL|METHODCALL)>

path.toString(false),

authenticationHeader,

//------------------------------------------------------------------------------

out.size());

tmp << out;

return tmp;

}

Array<Sint8> XmlWriter::formatSimpleReqElement(

Array<Sint8> XmlWriter::formatSimpleMethodRspMessage(

const char* methodName,

const String& messageId,

const Array<Sint8>& body)

{

Array<Sint8> out;

return out << "<SIMPLEREQ>\n" << body << "</SIMPLEREQ>\n";

Array<Sint8> tmp;

_appendMessageElementBegin(out, messageId);

_appendSimpleRspElementBegin(out);

_appendMethodResponseElementBegin(out, methodName);

out << body;

_appendMethodResponseElementEnd(out);

_appendSimpleRspElementEnd(out);

_appendMessageElementEnd(out);

appendMethodResponseHeader(tmp, out.size());

tmp << out;

return tmp;

}

//------------------------------------------------------------------------------

// formatSimpleRspElement()

// XmlWriter::formatSimpleMethodErrorRspMessage()

// <!ELEMENT SIMPLERSP (METHODRESPONSE|IMETHODRESPONSE)>

//------------------------------------------------------------------------------

Array<Sint8> XmlWriter::formatSimpleRspElement(

Array<Sint8> XmlWriter::formatSimpleMethodErrorRspMessage(

const Array<Sint8>& body)

const String& methodName,

const String& messageId,

CIMStatusCode code,

const String& description)

{

ArrayDestroyer<char> tmp1(methodName.allocateCString());

ArrayDestroyer<char> tmp2(description.allocateCString());

Array<Sint8> out;

return out << "<SIMPLERSP>\n" << body << "</SIMPLERSP>\n";

Array<Sint8> tmp;

_appendMessageElementBegin(out, messageId);

_appendSimpleRspElementBegin(out);

_appendMethodResponseElementBegin(out, tmp1.getPointer());

_appendErrorElement(out, code, tmp2.getPointer());

_appendMethodResponseElementEnd(out);

_appendSimpleRspElementEnd(out);

_appendMessageElementEnd(out);

appendMethodResponseHeader(tmp, out.size());

tmp << out;

return tmp;

}

//------------------------------------------------------------------------------

// formatIMethodCallElement()

// XmlWriter::formatSimpleIMethodReqMessage()

// <!ELEMENT IMETHODCALL (LOCALNAMESPACEPATH,IPARAMVALUE*)>

// <!ATTLIST IMETHODCALL %CIMName;>

//------------------------------------------------------------------------------

Array<Sint8> XmlWriter::formatIMethodCallElement(

Array<Sint8> XmlWriter::formatSimpleIMethodReqMessage(

const char* name,

const char* host,

const String& nameSpace,

const Array<Sint8>& iParamValues)

const char* iMethodName,

const String& messageId,

const String& authenticationHeader,

const Array<Sint8>& body)

{

Array<Sint8> out;

out << "<IMETHODCALL NAME=\"" << name << "\">\n";

Array<Sint8> tmp;

XmlWriter::appendLocalNameSpaceElement(out, nameSpace);

out << iParamValues;

_appendMessageElementBegin(out, messageId);

out << "</IMETHODCALL>\n";

_appendSimpleReqElementBegin(out);

return out;

_appendIMethodCallElementBegin(out, iMethodName);

appendLocalNameSpacePathElement(out, nameSpace);

out << body;

_appendIMethodCallElementEnd(out);

_appendSimpleReqElementEnd(out);

_appendMessageElementEnd(out);

appendMethodCallHeader(

tmp,

host,

iMethodName,

nameSpace,

authenticationHeader,

out.size());

tmp << out;

return tmp;

}

//------------------------------------------------------------------------------

// formatIMethodResponseElement()

// XmlWriter::formatSimpleIMethodRspMessage()

// <!ELEMENT IMETHODRESPONSE (ERROR|IRETURNVALUE?)>

// <!ATTLIST IMETHODRESPONSE %CIMName;>

//------------------------------------------------------------------------------

Array<Sint8> XmlWriter::formatIMethodResponseElement(

Array<Sint8> XmlWriter::formatSimpleIMethodRspMessage(

const char* name,

const char* iMethodName,

const String& messageId,

const Array<Sint8>& body)

{

Array<Sint8> out;

out << "<IMETHODRESPONSE NAME=\"" << name << "\">\n";

Array<Sint8> tmp;

_appendMessageElementBegin(out, messageId);

_appendSimpleRspElementBegin(out);

_appendIMethodResponseElementBegin(out, iMethodName);

_appendIReturnValueElementBegin(out);

out << body;

out << "</IMETHODRESPONSE>\n";

_appendIReturnValueElementEnd(out);

return out;

_appendIMethodResponseElementEnd(out);

_appendSimpleRspElementEnd(out);

_appendMessageElementEnd(out);

appendMethodResponseHeader(tmp, out.size());

tmp << out;

return tmp;

}

//------------------------------------------------------------------------------

// formatIReturnValueElement()

// XmlWriter::formatSimpleIMethodErrorRspMessage()

// <!ELEMENT IRETURNVALUE (CLASSNAME*|INSTANCENAME*|VALUE*|

// VALUE.OBJECTWITHPATH*|VALUE.OBJECTWITHLOCALPATH*|VALUE.OBJECT*|

// OBJECTPATH*|QUALIFIER.DECLARATION*|VALUE.ARRAY?|VALUE.REFERENCE?|

// CLASS*|INSTANCE*|VALUE.NAMEDINSTANCE*)>

//------------------------------------------------------------------------------

Array<Sint8> XmlWriter::formatIReturnValueElement(

Array<Sint8> XmlWriter::formatSimpleIMethodErrorRspMessage(

const Array<Sint8>& body)

const String& iMethodName,

const String& messageId,

CIMStatusCode code,

const String& description)

{

ArrayDestroyer<char> tmp1(iMethodName.allocateCString());

ArrayDestroyer<char> tmp2(description.allocateCString());

Array<Sint8> out;

return out << "<IRETURNVALUE>\n" << body << "</IRETURNVALUE>\n";

Array<Sint8> tmp;

_appendMessageElementBegin(out, messageId);

_appendSimpleRspElementBegin(out);

_appendIMethodResponseElementBegin(out, tmp1.getPointer());

_appendErrorElement(out, code, tmp2.getPointer());

_appendIMethodResponseElementEnd(out);

_appendSimpleRspElementEnd(out);

_appendMessageElementEnd(out);

appendMethodResponseHeader(tmp, out.size());

tmp << out;

return tmp;

}

//******************************************************************************

// Export Messages (used for indications)

//******************************************************************************

//------------------------------------------------------------------------------

// formatIParamValueElement()

// appendEMethodRequestHeader()

// <!ELEMENT IPARAMVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE

// Build HTTP request header for export operation.

// |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION

// |CLASS|INSTANCE|VALUE.NAMEDINSTANCE)?>

// <!ATTLIST IPARAMVALUE %CIMName;>

//------------------------------------------------------------------------------

Array<Sint8>& XmlWriter::formatIParamValueElement(

void XmlWriter::appendEMethodRequestHeader(

Array<Sint8>& out,

const char* name,

const char* host,

const Array<Sint8>& body)

const char* cimMethod,

const String& authenticationHeader,

Uint32 contentLength)

{

out << "<IPARAMVALUE NAME=\"" << name << "\">\n";

char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };

out << body;

out << "</IPARAMVALUE>\n";

return out;

}

//------------------------------------------------------------------------------

// formatErrorElement()

//------------------------------------------------------------------------------

Array<Sint8> XmlWriter::formatErrorElement(

out << "M-POST /cimom HTTP/1.1\r\n";

CIMException::Code code,

out << "HOST: " << host << "\r\n";

const char* description)

out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";

out << "Content-Length: " << contentLength << "\r\n";

out << "Man: http://www.hp.com; ns=";

out << nn <<"\r\n";

out << nn << "-CIMExport: MethodRequest\r\n"; // ATTN-RK-P2-20020228: Should this be "MethodCall"?

out << nn << "-CIMExportMethod: " << cimMethod << "\r\n";

if (authenticationHeader.size())

{

Array<Sint8> out;

out << authenticationHeader << "\r\n";

out << "<ERROR";

}

out << " CODE=\"" << Uint32(code) << "\"";

out << "\r\n";

out << " DESCRIPTION=\"";

appendSpecial(out, description);

out << "\"/>";

return out;

}

//------------------------------------------------------------------------------

// appendBooleanParameter()

// appendEMethodResponseHeader()

// Build HTTP response header for export operation.

//------------------------------------------------------------------------------

Array<Sint8>& XmlWriter::appendBooleanParameter(

void XmlWriter::appendEMethodResponseHeader(

Array<Sint8>& out,

const char* name,

Uint32 contentLength)

Boolean flag)

{

Array<Sint8> tmp;

char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };

tmp << "<VALUE>" << (flag ? "TRUE" : "FALSE") << "</VALUE>\n";

return formatIParamValueElement(out, name, tmp);

out << "HTTP/1.1 200 OK\r\n";

out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";

out << "Content-Length: " << contentLength << "\r\n";

out << "Ext:\r\n";

out << "Cache-Control: no-cache\r\n";

out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";

out << nn <<"\r\n";

out << nn << "-CIMExport: MethodResponse\r\n\r\n";

}

//------------------------------------------------------------------------------

// appendClassNameParameter()

// _appendSimpleExportReqElementBegin()

// _appendSimpleExportReqElementEnd()

// <!ELEMENT SIMPLEEXPREQ (EXPMETHODCALL)>

//------------------------------------------------------------------------------

Array<Sint8>& XmlWriter::appendClassNameParameter(

void XmlWriter::_appendSimpleExportReqElementBegin(

Array<Sint8>& out,

Array<Sint8>& out)

const char* name,

const String& className)

{

Array<Sint8> tmp;

out << "<SIMPLEEXPREQ>\n";

appendClassNameElement(tmp, className);

}

return formatIParamValueElement(out, name, tmp);

void XmlWriter::_appendSimpleExportReqElementEnd(

Array<Sint8>& out)

{

out << "</SIMPLEEXPREQ>\n";

}

//------------------------------------------------------------------------------

// appendQualifierNameParameter()

// _appendEMethodCallElementBegin()

// _appendEMethodCallElementEnd()

// <!ELEMENT EXPMETHODCALL (IPARAMVALUE*)>

// <!ATTLIST EXPMETHODCALL %CIMName;>

//------------------------------------------------------------------------------

Array<Sint8>& XmlWriter::appendQualifierNameParameter(

void XmlWriter::_appendEMethodCallElementBegin(

Array<Sint8>& out,

const char* name,

const char* name)

const String& qualifierName)

{

// <!ELEMENT IPARAMVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE

out << "<EXPMETHODCALL NAME=\"" << name << "\">\n";

// |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION

}

// |CLASS|INSTANCE|VALUE.NAMEDINSTANCE)?>

// ATTN: notice that there is really no way to pass a qualifier name

// as an IPARAMVALUE element according to the spec (look above). So we

// just pass it as a class name. An answer must be obtained later.

Array<Sint8> tmp;

void XmlWriter::_appendEMethodCallElementEnd(

appendClassNameElement(tmp, qualifierName);

Array<Sint8>& out)

return formatIParamValueElement(out, name, tmp);

{

out << "</EXPMETHODCALL>\n";

}

//------------------------------------------------------------------------------

// appendClassParameter()

// _appendSimpleExportRspElementBegin()

// _appendSimpleExportRspElementEnd()

// <!ELEMENT SIMPLEEXPRSP (EXPMETHODRESPONSE)>

//------------------------------------------------------------------------------

Array<Sint8>& XmlWriter::appendClassParameter(

void XmlWriter::_appendSimpleExportRspElementBegin(

Array<Sint8>& out,

Array<Sint8>& out)

const char* parameterName,

const CIMConstClass& cimClass)

{

Array<Sint8> tmp;

out << "<SIMPLEEXPRSP>\n";

cimClass.toXml(tmp);

return formatIParamValueElement(out, parameterName, tmp);

}

//------------------------------------------------------------------------------

void XmlWriter::_appendSimpleExportRspElementEnd(

Array<Sint8>& out)

// appendInstanceNameParameter()

//------------------------------------------------------------------------------

Array<Sint8>& XmlWriter::appendInstanceNameParameter(

Array<Sint8>& out,

const char* parameterName,

const CIMReference& instanceName)

{

Array<Sint8> tmp;

out << "</SIMPLEEXPRSP>\n";

instanceName.instanceNameToXml(tmp);

return formatIParamValueElement(out, parameterName, tmp);

}

//------------------------------------------------------------------------------

// appendInstanceParameter()

// _appendEMethodResponseElementBegin()

// _appendEMethodResponseElementEnd()

// <!ELEMENT EXPMETHODRESPONSE (ERROR|IRETURNVALUE?)>

// <!ATTLIST EXPMETHODRESPONSE %CIMName;>

//------------------------------------------------------------------------------

Array<Sint8>& XmlWriter::appendInstanceParameter(

void XmlWriter::_appendEMethodResponseElementBegin(

Array<Sint8>& out,

const char* parameterName,

const char* name)

const CIMConstInstance& instance)

{

Array<Sint8> tmp;

out << "<EXPMETHODRESPONSE NAME=\"" << name << "\">\n";

instance.toXml(tmp);

}

return formatIParamValueElement(out, parameterName, tmp);

void XmlWriter::_appendEMethodResponseElementEnd(

Array<Sint8>& out)

{

out << "</EXPMETHODRESPONSE>\n";

}

//------------------------------------------------------------------------------

// appendClassParameter()

// XmlWriter::formatSimpleEMethodReqMessage()

//------------------------------------------------------------------------------

Array<Sint8>& XmlWriter::appendQualifierDeclarationParameter(

Array<Sint8> XmlWriter::formatSimpleEMethodReqMessage(

Array<Sint8>& out,

const char* host,

const char* parameterName,

const char* eMethodName,

const CIMConstQualifierDecl& qualifierDecl)

const String& messageId,

const String& authenticationHeader,

const Array<Sint8>& body)

{

Array<Sint8> out;

Array<Sint8> tmp;

qualifierDecl.toXml(tmp);

return formatIParamValueElement(out, parameterName, tmp);

_appendMessageElementBegin(out, messageId);

_appendSimpleExportReqElementBegin(out);

_appendEMethodCallElementBegin(out, eMethodName);

out << body;

_appendEMethodCallElementEnd(out);

_appendSimpleExportReqElementEnd(out);

_appendMessageElementEnd(out);

appendEMethodRequestHeader(

tmp,

host,

eMethodName,

authenticationHeader,

out.size());

tmp << out;

return out;

}

//------------------------------------------------------------------------------

// appendClassNameElement()

// XmlWriter::formatSimpleEMethodRspMessage()

//------------------------------------------------------------------------------

Array<Sint8>& XmlWriter::appendClassNameElement(

Array<Sint8> XmlWriter::formatSimpleEMethodRspMessage(

Array<Sint8>& out,

const char* eMethodName,

const String& className)

const String& messageId,

const Array<Sint8>& body)

{

return out << "<CLASSNAME NAME=\"" << className << "\"/>\n";

Array<Sint8> out;

Array<Sint8> tmp;

_appendMessageElementBegin(out, messageId);

_appendSimpleExportRspElementBegin(out);

_appendEMethodResponseElementBegin(out, eMethodName);

out << body;

_appendEMethodResponseElementEnd(out);

_appendSimpleExportRspElementEnd(out);

_appendMessageElementEnd(out);

appendEMethodResponseHeader(tmp, out.size());

tmp << out;

return tmp;

}

//------------------------------------------------------------------------------

// appendInstanceNameElement()

// XmlWriter::formatSimpleEMethodErrorRspMessage()

//------------------------------------------------------------------------------

Array<Sint8>& XmlWriter::appendInstanceNameElement(

Array<Sint8> XmlWriter::formatSimpleEMethodErrorRspMessage(

Array<Sint8>& out,

const String& eMethodName,

const CIMReference& instanceName)

const String& messageId,

CIMStatusCode code,

const String& description)

{

instanceName.instanceNameToXml(out);

ArrayDestroyer<char> tmp1(eMethodName.allocateCString());

return out;

ArrayDestroyer<char> tmp2(description.allocateCString());

Array<Sint8> out;

Array<Sint8> tmp;

_appendMessageElementBegin(out, messageId);

_appendSimpleExportRspElementBegin(out);

_appendEMethodResponseElementBegin(out, tmp1.getPointer());

_appendErrorElement(out, code, tmp2.getPointer());

_appendEMethodResponseElementEnd(out);

_appendSimpleExportRspElementEnd(out);

_appendMessageElementEnd(out);

appendEMethodResponseHeader(tmp, out.size());

tmp << out;

return tmp;

}

//------------------------------------------------------------------------------

Line 594

Line 1435

//------------------------------------------------------------------------------

static void _printAttributes(

std::ostream& os,

PEGASUS_STD(ostream)& os,

const XmlAttribute* attributes,

Uint32 attributeCount)

{

Line 603

Line 1444

os << attributes[i].name << "=";

os << '"';

AppendSpecial(os, attributes[i].value);

_appendSpecial(os, attributes[i].value);

os << '"';

if (i + 1 != attributeCount)

Line 617

Line 1458

//------------------------------------------------------------------------------

static void _indent(std::ostream& os, Uint32 level, Uint32 indentChars)

static void _indent(PEGASUS_STD(ostream)& os, Uint32 level, Uint32 indentChars)

{

Uint32 n = level * indentChars;

Line 632

Line 1473

//------------------------------------------------------------------------------

void XmlWriter::indentedPrint(

std::ostream& os,

PEGASUS_STD(ostream)& os,

const char* text,

Uint32 indentChars)

{

Line 648

Line 1489

{

case XmlEntry::XML_DECLARATION:

{

_indent(os, stack.getSize(), indentChars);

_indent(os, stack.size(), indentChars);

os << "<?" << entry.text << " ";

_printAttributes(os, entry.attributes, entry.attributeCount);

Line 658

Line 1499

case XmlEntry::START_TAG:

{

_indent(os, stack.getSize(), indentChars);

_indent(os, stack.size(), indentChars);

os << "<" << entry.text;

Line 673

Line 1514

case XmlEntry::EMPTY_TAG:

{

_indent(os, stack.getSize(), indentChars);

_indent(os, stack.size(), indentChars);

os << "<" << entry.text << " ";

_printAttributes(os, entry.attributes, entry.attributeCount);

Line 686

Line 1527

if (!stack.isEmpty() && strcmp(stack.top(), entry.text) == 0)

stack.pop();

_indent(os, stack.getSize(), indentChars);

_indent(os, stack.size(), indentChars);

os << "</" << entry.text << ">";

break;

Line 695

Line 1536

case XmlEntry::COMMENT:

{

_indent(os, stack.getSize(), indentChars);

_indent(os, stack.size(), indentChars);

os << "<!--";

AppendSpecial(os, entry.text);

_appendSpecial(os, entry.text);

os << "-->";

break;

}

case XmlEntry::CONTENT:

{

_indent(os, stack.getSize(), indentChars);

_indent(os, stack.size(), indentChars);

AppendSpecial(os, entry.text);

_appendSpecial(os, entry.text);

break;

}

case XmlEntry::CDATA:

{

_indent(os, stack.getSize(), indentChars);

_indent(os, stack.size(), indentChars);

os << "<![CDATA[...]]>";

break;

}

case XmlEntry::DOCTYPE:

{

_indent(os, stack.getSize(), indentChars);

_indent(os, stack.size(), indentChars);

os << "<!DOCTYPE...>";

break;

}

os << std::endl;

os << PEGASUS_STD(endl);

}

delete [] tmp;

Line 736

Line 1577

//------------------------------------------------------------------------------

Uint32 XmlWriter::getNextMessageId()

String XmlWriter::getNextMessageId()

{

// ATTN: make thread-safe:

static Uint32 messageId = 1000;

Line 746

Line 1587

if (messageId < 1000)

messageId = 1001;

return messageId;

char buffer[16];

}

sprintf(buffer, "%d", messageId);

return buffer;

//------------------------------------------------------------------------------

// XmlWriter::formatSimpleReqMessage()

//------------------------------------------------------------------------------

Array<Sint8> XmlWriter::formatSimpleReqMessage(

const char* host,

const String& nameSpace,

const char* iMethodName,

const Array<Sint8>& body)

{

return XmlWriter::formatMPostHeader(

host,

"MethodCall",

iMethodName,

nameSpace,

XmlWriter::formatMessageElement(

XmlWriter::getNextMessageId(),

XmlWriter::formatSimpleReqElement(

XmlWriter::formatIMethodCallElement(

iMethodName,

nameSpace,

body))));

}

Array<Sint8> XmlWriter::formatSimpleRspMessage(

const char* iMethodName,

const Array<Sint8>& body)

{

return XmlWriter::formatMethodResponseHeader(

XmlWriter::formatMessageElement(

XmlWriter::getNextMessageId(),

XmlWriter::formatSimpleRspElement(

XmlWriter::formatIMethodResponseElement(

iMethodName,

XmlWriter::formatIReturnValueElement(body)))));

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.10
changed lines
	Added in v.1.31

No CVS admin address has been configured