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.2 and 1.23.2.6

version 1.2, 2001/01/29 02:23:44

version 1.23.2.6, 2001/11/20 06:11:35

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.

// 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

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

//BEGIN_HISTORY

// Author:

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

// $Log$

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

// 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 "ClassDecl.h"

#include "CIMClass.h"

#include "QualifierDecl.h"

#include "CIMInstance.h"

#include "CIMQualifierDecl.h"

#include "XmlWriter.h"

#include "XmlParser.h"

Line 146

Line 142

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

}

delete [] tmp;

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

}

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

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

{

switch (c)

{

Line 178

Line 176

}

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

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

{

while (*str)

AppendSpecialChar(os, *str++);

Line 218

Line 216

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

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

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

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

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

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

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

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

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

Line 245

Line 243

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

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

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

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

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

out << "Content-Length: " << content.size() << "\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=";

Line 268

Line 266

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

Array<Sint8> XmlWriter::formatMessageElement(

Uint32 messageId,

const String& messageId,

const Array<Sint8>& body)

{

Array<Sint8> out;

Line 402

Line 400

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

Array<Sint8> XmlWriter::formatErrorElement(

CimException::Code code,

CIMStatusCode code,

const char* description)

{

Array<Sint8> out;

Line 432

Line 430

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

// appendStringIParameter()

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

Array<Sint8>& XmlWriter::appendStringIParameter(

Array<Sint8>& out,

const char* name,

const String& str)

{

Array<Sint8> tmp;

tmp << "<VALUE>";

appendSpecial(tmp, str);

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

return formatIParamValueElement(out, name, tmp);

}

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

// appendClassNameParameter()

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

Line 479

Line 495

Array<Sint8>& XmlWriter::appendClassParameter(

Array<Sint8>& out,

const char* parameterName,

const ConstClassDecl& classDecl)

const CIMConstClass& cimClass)

{

Array<Sint8> tmp;

classDecl.toXml(tmp);

cimClass.toXml(tmp);

return formatIParamValueElement(out, parameterName, tmp);

}

Line 495

Line 511

Array<Sint8>& XmlWriter::appendInstanceNameParameter(

Array<Sint8>& out,

const char* parameterName,

const Reference& instanceName)

const CIMReference& instanceName)

{

Array<Sint8> tmp;

instanceName.instanceNameToXml(tmp);

Line 504

Line 520

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

// appendClassParameter()

// appendInstanceParameter()

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

Array<Sint8>& XmlWriter::appendInstanceParameter(

Array<Sint8>& out,

const char* parameterName,

const CIMConstInstance& instance)

{

Array<Sint8> tmp;

instance.toXml(tmp);

return formatIParamValueElement(out, parameterName, tmp);

}

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

// appendPropertyNameParameter()

// </IPARAMVALUE>

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

// USE: Create parameter for getProperty operation

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

Array<Sint8>& XmlWriter::appendPropertyNameParameter(

Array<Sint8>& out,

const String& propertyName)

{

Array<Sint8> tmp;

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

return formatIParamValueElement(out,"PropertyName", tmp);}

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

// appendPropertyValueParameter()

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

Array<Sint8>& XmlWriter::appendPropertyValueParameter(

Array<Sint8>& out,

const char* parameterName,

const CIMValue& value)

{

Array<Sint8> tmp;

value.toXml(tmp);

return formatIParamValueElement(out, parameterName, tmp);

}

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

// appendPropertyListParameter()

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

Array<Sint8>& XmlWriter::appendPropertyListParameter(

Array<Sint8>& out,

const Array<String>& propertyList)

{

Array<Sint8> tmp;

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

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

{

tmp << "<VALUE>" << propertyList[i] << "</VALUE>\n";

}

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

return formatIParamValueElement(out, "PropertyList", tmp);

}

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

// appendQualifierDeclarationParameter()

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

Array<Sint8>& XmlWriter::appendQualifierDeclarationParameter(

Array<Sint8>& out,

const char* parameterName,

const ConstQualifierDecl& qualifierDecl)

const CIMConstQualifierDecl& qualifierDecl)

{

Array<Sint8> tmp;

qualifierDecl.toXml(tmp);

Line 533

Line 621

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

// appendInstanceNameElement()

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

Array<Sint8>& XmlWriter::appendInstanceNameElement(

Array<Sint8>& out,

const CIMReference& instanceName)

{

instanceName.instanceNameToXml(out);

return out;

}

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

// _printAttributes()

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

static void _printAttributes(

std::ostream& os,

PEGASUS_STD(ostream)& os,

const XmlAttribute* attributes,

Uint32 attributeCount)

{

Line 561

Line 663

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

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 576

Line 678

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

void XmlWriter::indentedPrint(

std::ostream& os,

PEGASUS_STD(ostream)& os,

const char* text,

Uint32 indentChars)

{

Line 592

Line 694

{

case XmlEntry::XML_DECLARATION:

{

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

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

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

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

Line 602

Line 704

case XmlEntry::START_TAG:

{

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

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

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

Line 617

Line 719

case XmlEntry::EMPTY_TAG:

{

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

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

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

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

Line 630

Line 732

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 639

Line 741

case XmlEntry::COMMENT:

{

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

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

os << "<!--";

AppendSpecial(os, entry.text);

os << "-->";

Line 648

Line 750

case XmlEntry::CONTENT:

{

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

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

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 680

Line 782

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

Uint32 XmlWriter::getNextMessageId()

String XmlWriter::getNextMessageId()

{

// ATTN: make thread-safe:

static Uint32 messageId = 1000;

Line 690

Line 792

if (messageId < 1000)

messageId = 1001;

return messageId;

char buffer[16];

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

return buffer;

}

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

// XmlWriter::formatSimpleReqMessage()

// XmlWriter::formatSimpleIMethodReqMessage()

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

Array<Sint8> XmlWriter::formatSimpleReqMessage(

Array<Sint8> XmlWriter::formatSimpleIMethodReqMessage(

const char* host,

const String& nameSpace,

const char* iMethodName,

const String& messageId,

const Array<Sint8>& body)

{

return XmlWriter::formatMPostHeader(

Line 711

Line 816

iMethodName,

nameSpace,

XmlWriter::formatMessageElement(

XmlWriter::getNextMessageId(),

messageId,

XmlWriter::formatSimpleReqElement(

XmlWriter::formatIMethodCallElement(

iMethodName,

Line 721

Line 826

Array<Sint8> XmlWriter::formatSimpleRspMessage(

const char* iMethodName,

const String& messageId,

const Array<Sint8>& body)

{

return XmlWriter::formatMethodResponseHeader(

XmlWriter::formatMessageElement(

XmlWriter::getNextMessageId(),

messageId,

XmlWriter::formatSimpleRspElement(

XmlWriter::formatIMethodResponseElement(

iMethodName,

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

}

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;

}

Array<Sint8>& XmlWriter::appendObjectNameParameter(

Array<Sint8>& out,

const char* name,

const CIMReference& objectName)

{

if (objectName.isClassName())

{

XmlWriter::appendClassNameParameter(

out, name, objectName.getClassName());

}

else

{

XmlWriter::appendInstanceNameParameter(

out, name, objectName);

}

return out;

}

Array<Sint8> XmlWriter::formatEMethodCallElement(

const char* name,

const Array<Sint8>& iParamValues)

{

Array<Sint8> out;

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

out << iParamValues;

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

return out;

}

Array<Sint8> XmlWriter::formatSimpleIndicationReqMessage(

const char* host,

const char* iMethodName,

const String& messageId,

const Array<Sint8>& body)

{

return XmlWriter::formatMPostIndicationHeader(

host,

"MethodRequest",

iMethodName,

XmlWriter::formatMessageElement(

messageId,

XmlWriter::formatSimpleExportReqElement(

XmlWriter::formatEMethodCallElement(

iMethodName,

body))));

}

Array<Sint8> XmlWriter::formatMPostIndicationHeader(

const char* host,

const char* cimOperation,

const char* cimMethod,

const Array<Sint8>& content)

{

Array<Sint8> out;

out.reserve(1024);

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: " << content.size() << "\r\n";

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

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

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

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

out << content;

return out;

}

Array<Sint8> XmlWriter::formatSimpleExportReqElement(

const Array<Sint8>& body)

{

Array<Sint8> out;

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

}

Array<Sint8> XmlWriter::formatSimpleIndicationRspMessage(

const char* iMethodName,

const String& messageId,

const Array<Sint8>& body)

{

return XmlWriter::formatEMethodResponseHeader(

XmlWriter::formatMessageElement(

messageId,

XmlWriter::formatSimpleExportRspElement(

XmlWriter::formatEMethodResponseElement(

iMethodName,

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

}

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

// formatSimpleExportRspElement()

// <!ELEMENT SIMPLEEXPRSP (METHODRESPONSE|EXPMETHODRESPONSE)>

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

Array<Sint8> XmlWriter::formatSimpleExportRspElement(

const Array<Sint8>& body)

{

Array<Sint8> out;

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

}

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

// formatIMethodResponseElement()

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

// <!ATTLIST EXPMETHODRESPONSE %CIMName;>

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

Array<Sint8> XmlWriter::formatEMethodResponseElement(

const char* name,

const Array<Sint8>& body)

{

Array<Sint8> out;

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

out << body;

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

return out;

}

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

// formatMethodResponseHeader()

// Build HTTP response header.

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

Array<Sint8> XmlWriter::formatEMethodResponseHeader(

const Array<Sint8>& content)

{

Array<Sint8> out;

out.reserve(1024);

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: " << content.size() << "\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";

out << content;

return out;

}

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

// XmlWriter::formatSimpleMethodReqMessage()

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

Array<Sint8> XmlWriter::formatSimpleMethodReqMessage(

const char* host,

const String& nameSpace,

const char* iMethodName,

const String& messageId,

const Array<Sint8>& body)

{

return XmlWriter::formatMPostHeader(

host,

"MethodCall",

iMethodName,

nameSpace,

XmlWriter::formatMessageElement(

messageId,

XmlWriter::formatSimpleReqElement(

XmlWriter::formatMethodCallElement(

iMethodName,

nameSpace,

body))));

}

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

// formatMethodCallElement()

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

// <!ATTLIST METHODCALL %CIMName;>

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

Array<Sint8> XmlWriter::formatMethodCallElement(

const char* name,

const String& nameSpace,

const Array<Sint8>& iParamValues)

{

Array<Sint8> out;

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

out << iParamValues;

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

return out;

}

Array<Sint8> XmlWriter::formatSimpleMethodRspMessage(

const char* iMethodName,

const String& messageId,

const Array<Sint8>& body)

{

/*return XmlWriter::formatMethodResponseHeader(

XmlWriter::formatMessageElement(

messageId,

XmlWriter::formatSimpleRspElement(

XmlWriter::formatMethodResponseElement(

iMethodName,

XmlWriter::formatReturnValueElement(body)))));*/

return XmlWriter::formatMethodResponseHeader(

XmlWriter::formatMessageElement(

messageId,

XmlWriter::formatSimpleRspElement(

XmlWriter::formatMethodResponseElement(

iMethodName,

body))));

}

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

// formatMethodResponseElement()

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

// <!ATTLIST METHODRESPONSE %CIMName;>

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

Array<Sint8> XmlWriter::formatMethodResponseElement(

const char* name,

const Array<Sint8>& body)

{

Array<Sint8> out;

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

out << body;

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

return out;

}

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

// appendStringParameter()

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

Array<Sint8>& XmlWriter::appendStringParameter(

Array<Sint8>& out,

const char* name,

const String& str)

{

Array<Sint8> tmp;

tmp << "<VALUE>";

appendSpecial(tmp, str);

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

return formatParamValueElement(out, name, tmp);

}

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

// formatParamValueElement()

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

// |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION

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

// <!ATTLIST PARAMVALUE %CIMName;>

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

Array<Sint8>& XmlWriter::formatParamValueElement(

Array<Sint8>& out,

const char* name,

const Array<Sint8>& body)

{

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

out << body;

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

return out;

}

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

// formatReturnValueElement()

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

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

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

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

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

Array<Sint8> XmlWriter::formatReturnValueElement(

const Array<Sint8>& body)

{

Array<Sint8> out;

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

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.2
changed lines
	Added in v.1.23.2.6

No CVS admin address has been configured