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.125 and 1.169.4.8

version 1.125, 2005/10/31 17:39:12

version 1.169.4.8, 2013/09/19 10:56:58

Line 1

//%2005////////////////////////////////////////////////////////////////////////

//%LICENSE////////////////////////////////////////////////////////////////

// Licensed to The Open Group (TOG) under one or more contributor license

// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.

// agreements. Refer to the OpenPegasusNOTICE.txt file distributed with

// this work for additional information regarding copyright ownership.

// IBM Corp.; EMC Corporation, The Open Group.

// Each contributor licenses this file to you under the OpenPegasus Open

// Source License; you may not use this file except in compliance with the

// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

// License.

// EMC Corporation; VERITAS Software Corporation; The Open Group.

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

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

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

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

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

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

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

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

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

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

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

// 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 ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN

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

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

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

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

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

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

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

// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

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

// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

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

// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

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

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

// Carol Ann Krug Graves, Hewlett-Packard Company

// (carolann_graves@hp.com)

// Amit K Arora, IBM (amita@in.ibm.com) for PEP#101

// Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase1

// Willis White (whiwill@us.ibm.com) PEP 127 and 128

// Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase2

// Dave Sudlik, IBM (dsudlik@us.ibm.com)

// David Dillard, VERITAS Software Corp.

// (david.dillard@veritas.com)

// Vijay Eli, vijayeli@in.ibm.com, fix for #2571

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

Line 67

Line 51

#include "CIMQualifierDeclRep.h"

#include "CIMValue.h"

#include "XmlWriter.h"

#include "XmlParser.h"

#include "Tracer.h"

#include <Pegasus/Common/StatisticalData.h>

#include "CommonUTF.h"

#include "Buffer.h"

#include "StrLit.h"

#include "IDFactory.h"

#include "StringConversion.h"

PEGASUS_NAMESPACE_BEGIN

// This is a shortcut macro for outputing content length. This

// pads the output number to the max characters representing a Uint32 number

// so that it can be overwritten easily with a transfer encoding line later

// on in HTTPConnection if required. This is strictly for performance since

// messages can be very large. This overwriting shortcut allows us to NOT have

// to repackage a large message later.

#define OUTPUT_CONTENTLENGTH \

{ \

char contentLengthP[11]; \

sprintf(contentLengthP,"%.10u", contentLength); \

out << "content-length: " << contentLengthP << "\r\n"; \

}

Buffer& operator<<(Buffer& out, const char* x)

{

XmlWriter::append(out, x);

return out;

}

Buffer& operator<<(Buffer& out, char x)

{

XmlWriter::append(out, x);

return out;

}

Buffer& operator<<(Buffer& out, const Char16& x)

{

XmlWriter::append(out, x);

return out;

}

Buffer& operator<<(Buffer& out, const String& x)

{

XmlWriter::append(out, x);

return out;

}

Buffer& operator<<(Buffer& out, const Indentor& x)

{

XmlWriter::append(out, x);

return out;

}

Buffer& operator<<(Buffer& out, const Buffer& x)

{

out.append(x.getData(), x.size());

return out;

}

Buffer& operator<<(Buffer& out, Uint32 x)

{

XmlWriter::append(out, x);

return out;

}

Buffer& operator<<(Buffer& out, const CIMName& name)

{

XmlWriter::append(out, name.getString ());

return out;

}

// l10n

Buffer& operator<<(Buffer& out, const AcceptLanguages& al)

{

XmlWriter::append(out, al.toString ());

return out;

}

// l10n

Buffer& operator<<(Buffer& out, const ContentLanguages& cl)

{

XmlWriter::append(out, cl.toString ());

return out;

}

PEGASUS_STD(ostream)& operator<<(PEGASUS_STD(ostream)& os, const CIMDateTime& x)

{

return os << x.toString();

}

PEGASUS_STD(ostream)& operator<<(PEGASUS_STD(ostream)& os, const CIMName& name)

{

os << name.getString();

return os;

}

PEGASUS_STD(ostream)& operator<<(PEGASUS_STD(ostream)& os,

const CIMNamespaceName& name)

{

os << name.getString();

return os;

}

inline void _xmlWritter_appendChar(Buffer& out, const Char16& c)

{

// We need to convert the Char16 to UTF8 then append the UTF8

// character into the array.

// NOTE: The UTF8 character could be several bytes long.

// WARNING: This function will put in replacement character for

// all characters that have surogate pairs.

char str[6];

memset(str,0x00,sizeof(str));

Uint8* charIN = (Uint8 *)&c;

const Uint16 *strsrc = (Uint16 *)charIN;

Uint16 *endsrc = (Uint16 *)&charIN[1];

Uint8 *strtgt = (Uint8 *)str;

Uint8 *endtgt = (Uint8 *)&str[5];

UTF16toUTF8(&strsrc,

endsrc,

&strtgt,

endtgt);

out.append(str, UTF_8_COUNT_TRAIL_BYTES(str[0]) + 1);

}

inline void _xmlWritter_appendSpecialChar(Buffer& out, const Char16& c)

{

if ( ((c < Char16(0x20)) && (c >= Char16(0x00))) || (c == Char16(0x7f)) )

{

char charref[7];

sprintf(charref, "&#%u;", (Uint16)c);

out.append(charref, static_cast<Uint32>(strlen(charref)));

}

else

{

switch (c)

{

case '&':

out.append("&", 5);

break;

case '<':

out.append("<", 4);

break;

case '>':

out.append(">", 4);

break;

case '"':

out.append(""", 6);

break;

case '\'':

out.append("'", 6);

break;

default:

{

// We need to convert the Char16 to UTF8 then append the UTF8

// character into the array.

// NOTE: The UTF8 character could be several bytes long.

// WARNING: This function will put in replacement character for

// all characters that have surogate pairs.

char str[6];

memset(str,0x00,sizeof(str));

const char* charIN = reinterpret_cast<const char *>(&c);

const Uint16 *strsrc = (const Uint16 *)charIN;

const Uint16 *endsrc = (const Uint16 *)&charIN[1];

Uint8 *strtgt = (Uint8 *)str;

Uint8 *endtgt = (Uint8 *)&str[5];

UTF16toUTF8(&strsrc,

endsrc,

&strtgt,

endtgt);

Uint32 number1 = UTF_8_COUNT_TRAIL_BYTES(str[0]) + 1;

out.append(str,number1);

}

inline void _xmlWritter_appendSpecialChar(Buffer& out, char c)

{

if ( ((c < 0x20) && (c >= 0)) || (c == 0x7f) )

{

char charref[7];

sprintf(charref, "&#%u;", (Uint8)c);

out.append(charref, static_cast<Uint32>(strlen(charref)));

}

else

{

switch (c)

{

case '&':

out.append("&", 5);

break;

case '<':

out.append("<", 4);

break;

case '>':

out.append(">", 4);

break;

case '"':

out.append(""", 6);

break;

case '\'':

out.append("'", 6);

break;

default:

out.append(static_cast<Sint8>(c));

}

inline void _xmlWritter_appendSpecialChar(PEGASUS_STD(ostream)& os, char c)

{

if ( ((c < 0x20) && (c >= 0)) || (c == 0x7f) )

{

char charref[7];

sprintf(charref, "&#%u;", static_cast<Uint8>(c));

os << charref;

}

else

{

switch (c)

{

case '&':

os << "&";

break;

case '<':

os << "<";

break;

case '>':

os << ">";

break;

case '"':

os << """;

break;

case '\'':

os << "'";

break;

default:

os << c;

}

void _xmlWritter_appendSurrogatePair(Buffer& out, Uint16 high, Uint16 low)

{

char str[6];

Uint8 charIN[5];

memset(str,0x00,sizeof(str));

memcpy(&charIN,&high,2);

memcpy(&charIN[2],&low,2);

const Uint16 *strsrc = (Uint16 *)charIN;

Uint16 *endsrc = (Uint16 *)&charIN[3];

Uint8 *strtgt = (Uint8 *)str;

Uint8 *endtgt = (Uint8 *)&str[5];

UTF16toUTF8(&strsrc,

endsrc,

&strtgt,

endtgt);

Uint32 number1 = UTF_8_COUNT_TRAIL_BYTES(str[0]) + 1;

out.append(str,number1);

}

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

{

while (*str)

_xmlWritter_appendSpecialChar(os, *str++);

}

void XmlWriter::append(Buffer& out, const Char16& x)

{

_xmlWritter_appendChar(out, x);

}

void XmlWriter::append(Buffer& out, Boolean x)

{

append(out, (x ? "TRUE" : "FALSE"));

}

void XmlWriter::append(Buffer& out, Uint32 x)

{

char buffer[32];

sprintf(buffer, "%u", x);

append(out, buffer);

}

void XmlWriter::append(Buffer& out, Sint32 x)

{

char buffer[32];

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

append(out, buffer);

}

void XmlWriter::append(Buffer& out, Uint64 x)

{

char buffer[32]; // Should need 21 chars max

sprintf(buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "u", x);

append(out, buffer);

}

void XmlWriter::append(Buffer& out, Sint64 x)

{

char buffer[32]; // Should need 21 chars max

sprintf(buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "d", x);

append(out, buffer);

}

void XmlWriter::append(Buffer& out, Real32 x)

{

char buffer[128];

// %.7e gives '[-]m.ddddddde+/-xx', which seems compatible with the format

// given in the CIM/XML spec, and the precision required by the CIM 2.2 spec

// (4 byte IEEE floating point)

sprintf(buffer, "%.7e", x);

append(out, buffer);

}

void XmlWriter::append(Buffer& out, Real64 x)

{

char buffer[128];

// %.16e gives '[-]m.dddddddddddddddde+/-xx', which seems compatible with the format

// given in the CIM/XML spec, and the precision required by the CIM 2.2 spec

// (8 byte IEEE floating point)

sprintf(buffer, "%.16e", x);

append(out, buffer);

}

void XmlWriter::append(Buffer& out, const char* str)

{

while (*str)

XmlWriter::append(out, *str++);

}

void XmlWriter::append(Buffer& out, const String& str)

{

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

{

Uint16 c = str[i];

if(((c >= FIRST_HIGH_SURROGATE) && (c <= LAST_HIGH_SURROGATE)) ||

((c >= FIRST_LOW_SURROGATE) && (c <= LAST_LOW_SURROGATE)))

{

Char16 highSurrogate = str[i];

Char16 lowSurrogate = str[++i];

_xmlWritter_appendSurrogatePair(out, Uint16(highSurrogate),Uint16(lowSurrogate));

}

else

{

_xmlWritter_appendChar(out, str[i]);

}

void XmlWriter::append(Buffer& out, const Indentor& x)

{

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

out.append(' ');

}

void XmlWriter::appendSpecial(Buffer& out, const Char16& x)

{

_xmlWritter_appendSpecialChar(out, x);

}

void XmlWriter::appendSpecial(Buffer& out, char x)

{

_xmlWritter_appendSpecialChar(out, x);

}

void XmlWriter::appendSpecial(Buffer& out, const char* str)

{

while (*str)

_xmlWritter_appendSpecialChar(out, *str++);

}

void XmlWriter::appendSpecial(Buffer& out, const String& str)

{

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

{

Uint16 c = str[i];

if(((c >= FIRST_HIGH_SURROGATE) && (c <= LAST_HIGH_SURROGATE)) ||

((c >= FIRST_LOW_SURROGATE) && (c <= LAST_LOW_SURROGATE)))

{

Char16 highSurrogate = str[i];

Char16 lowSurrogate = str[++i];

_xmlWritter_appendSurrogatePair(out, Uint16(highSurrogate),Uint16(lowSurrogate));

}

else

{

_xmlWritter_appendSpecialChar(out, str[i]);

}

// See http://www.ietf.org/rfc/rfc2396.txt section 2

// Reserved characters = ';' '/' '?' ':' '@' '&' '=' '+' '$' ','

// Excluded characters:

// Control characters = 0x00-0x1f, 0x7f

// Space character = 0x20

// Delimiters = '<' '>' '#' '%' '"'

// Unwise = '{' '}' '|' '\\' '^' '[' ']' '`'

inline void _xmlWritter_encodeURIChar(String& outString, Sint8 char8)

{

Uint8 c = (Uint8)char8;

#ifndef PEGASUS_DO_NOT_IMPLEMENT_URI_ENCODING

if ( (c <= 0x20) || // Control characters + space char

( (c >= 0x22) && (c <= 0x26) ) || // '"' '#' '$' '%' '&'

(c == 0x2b) || // '+'

(c == 0x2c) || // ','

(c == 0x2f) || // '/'

( (c >= 0x3a) && (c <= 0x40) ) || // ':' ';' '<' '=' '>' '?' '@'

( (c >= 0x5b) && (c <= 0x5e) ) || // '[' '\\' ']' '^'

(c == 0x60) || // '`'

( (c >= 0x7b) && (c <= 0x7d) ) || // '{' '|' '}'

(c >= 0x7f) ) // Control character or non US-ASCII (UTF-8)

{

char hexencoding[4];

sprintf(hexencoding, "%%%X%X", c/16, c%16);

outString.append(hexencoding);

}

else

#endif

{

outString.append((Uint16)c);

}

String XmlWriter::encodeURICharacters(const Buffer& uriString)

{

String encodedString;

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

{

_xmlWritter_encodeURIChar(encodedString, uriString[i]);

}

return encodedString;

}

String XmlWriter::encodeURICharacters(const String& uriString)

{

String encodedString;

/* i18n remove - did not handle surrogate pairs

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

{

_xmlWritter_encodeURIChar(encodedString, uriString[i]);

}

// See the "CIM Operations over HTTP" spec, section 3.3.2 and

// 3.3.3, for the treatment of non US-ASCII (UTF-8) chars

// First, convert to UTF-8 (include handling of surrogate pairs)

Buffer utf8;

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

{

Uint16 c = uriString[i];

if(((c >= FIRST_HIGH_SURROGATE) && (c <= LAST_HIGH_SURROGATE)) ||

((c >= FIRST_LOW_SURROGATE) && (c <= LAST_LOW_SURROGATE)))

{

Char16 highSurrogate = uriString[i];

Char16 lowSurrogate = uriString[++i];

_xmlWritter_appendSurrogatePair(utf8, Uint16(highSurrogate),Uint16(lowSurrogate));

}

else

{

_xmlWritter_appendChar(utf8, uriString[i]);

}

// Second, escape the non HTTP-safe chars

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

{

_xmlWritter_encodeURIChar(encodedString, utf8[i]);

}

return encodedString;

}

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

// appendLocalNameSpacePathElement()

Line 594

Line 72

Buffer& out,

const CIMNamespaceName& nameSpace)

{

out << "<LOCALNAMESPACEPATH>\n";

out << STRLIT("<LOCALNAMESPACEPATH>\n");

char* nameSpaceCopy = strdup(nameSpace.getString().getCString());

#if defined(PEGASUS_PLATFORM_SOLARIS_SPARC_CC) || \

#if !defined(PEGASUS_COMPILER_MSVC) && !defined(PEGASUS_OS_ZOS)

defined(PEGASUS_OS_HPUX) || \

defined(PEGASUS_OS_LINUX)

char *last;

for (const char* p = strtok_r(nameSpaceCopy, "/", &last); p;

p = strtok_r(NULL, "/", &last))

Line 608

Line 84

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

#endif

{

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

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

}

free(nameSpaceCopy);

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

out << STRLIT("</LOCALNAMESPACEPATH>\n");

}

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

Line 628

Line 104

const String& host,

const CIMNamespaceName& nameSpace)

{

out << "<NAMESPACEPATH>\n";

out << STRLIT("<NAMESPACEPATH>\n"

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

"<HOST>") << host << STRLIT("</HOST>\n");

appendLocalNameSpacePathElement(out, nameSpace);

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

out << STRLIT("</NAMESPACEPATH>\n");

}

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

Line 648

Line 124

Buffer& out,

const CIMName& className)

{

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

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

}

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

Line 665

Line 141

Buffer& out,

const CIMObjectPath& instanceName)

{

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

out << STRLIT("<INSTANCENAME CLASSNAME=\"");

out << instanceName.getClassName() << STRLIT("\">\n");

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

const Array<CIMKeyBinding>& keyBindings = instanceName.getKeyBindings();

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

{

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

out << STRLIT("<KEYBINDING NAME=\"");

out << keyBindings[i].getName() << STRLIT("\">\n");

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

{

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

appendValueReferenceElement(out, ref, true);

// create an instancePath (i.e. isClassPath = false)

appendValueReferenceElement(out, ref, false, true);

}

else {

else

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

{

out << STRLIT("<KEYVALUE VALUETYPE=\"");

out << keyBindingTypeToString(keyBindings[i].getType());

out << "\">";

out << STRLIT("\">");

// fixed the special character problem - Markus

// fixed the special characters

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

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

out << STRLIT("</KEYVALUE>\n");

}

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

out << STRLIT("</KEYBINDING>\n");

}

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

out << STRLIT("</INSTANCENAME>\n");

}

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

Line 704

Line 184

Buffer& out,

const CIMObjectPath& classPath)

{

out << "<CLASSPATH>\n";

out << STRLIT("<CLASSPATH>\n");

appendNameSpacePathElement(out,

classPath.getHost(),

classPath.getNameSpace());

appendClassNameElement(out, classPath.getClassName());

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

out << STRLIT("</CLASSPATH>\n");

}

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

Line 724

Line 204

Buffer& out,

const CIMObjectPath& instancePath)

{

out << "<INSTANCEPATH>\n";

out << STRLIT("<INSTANCEPATH>\n");

appendNameSpacePathElement(out,

instancePath.getHost(),

instancePath.getNameSpace());

appendInstanceNameElement(out, instancePath);

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

out << STRLIT("</INSTANCEPATH>\n");

}

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

Line 744

Line 224

Buffer& out,

const CIMObjectPath& classPath)

{

out << "<LOCALCLASSPATH>\n";

out << STRLIT("<LOCALCLASSPATH>\n");

appendLocalNameSpacePathElement(out, classPath.getNameSpace());

appendClassNameElement(out, classPath.getClassName());

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

out << STRLIT("</LOCALCLASSPATH>\n");

}

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

Line 762

Line 242

Buffer& out,

const CIMObjectPath& instancePath)

{

out << "<LOCALINSTANCEPATH>\n";

out << STRLIT("<LOCALINSTANCEPATH>\n");

appendLocalNameSpacePathElement(out, instancePath.getNameSpace());

appendInstanceNameElement(out, instancePath);

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

out << STRLIT("</LOCALINSTANCEPATH>\n");

}

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

Line 777

Line 257

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

// appendValueReferenceElement does this correctly with isClassPath flag

// Called only but formatSimple

void XmlWriter::appendLocalObjectPathElement(

Buffer& out,

const CIMObjectPath& objectPath)

Line 786

Line 268

// distinguish instanceNames from classNames in every case

// The instanceName of a singleton instance of a keyless class has no

// key bindings

// See bBUG_3302.

if (objectPath.getKeyBindings ().size () != 0)

{

Line 870

Line 353

inline void _xmlWritter_appendValue(Buffer& out, const CIMDateTime& x)

{

out << x.toString(); //ATTN: append() method?

// It is not necessary to use XmlWriter::appendSpecial(), because

// CIMDateTime values do not contain special characters.

out << x.toString();

}

inline void _xmlWritter_appendValue(Buffer& out, const CIMObjectPath& x)

{

XmlWriter::appendValueReferenceElement(out, x, true);

// Emit Instance Path with value wrapper

XmlWriter::appendValueReferenceElement(out, x, false, true);

}

inline void _xmlWritter_appendValue(Buffer& out, const CIMObject& x)

Line 884

Line 370

_xmlWritter_appendValue(out, myStr);

}

void _xmlWritter_appendValueArray(Buffer& out, const CIMObjectPath* p, Uint32 size)

void _xmlWritter_appendValueArray(

Buffer& out, const CIMObjectPath* p, Uint32 size)

{

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

out << STRLIT("<VALUE.REFARRAY>\n");

while (size--)

{

_xmlWritter_appendValue(out, *p++);

}

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

out << STRLIT("</VALUE.REFARRAY>\n");

}

template<class T>

void _xmlWritter_appendValueArray(Buffer& out, const T* p, Uint32 size)

{

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

out << STRLIT("<VALUE.ARRAY>\n");

while (size--)

{

out << "<VALUE>";

out << STRLIT("<VALUE>");

_xmlWritter_appendValue(out, *p++);

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

out << STRLIT("</VALUE>\n");

}

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

out << STRLIT("</VALUE.ARRAY>\n");

}

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

Line 1032

Line 519

case CIMTYPE_STRING:

{

Array<String> a;

const String* data;

value.get(a);

Uint32 size;

_xmlWritter_appendValueArray(out, a.getData(), a.size());

value._get(data, size);

_xmlWritter_appendValueArray(out, data, size);

break;

}

Line 1061

Line 549

_xmlWritter_appendValueArray(out, a.getData(), a.size());

break;

}

case CIMTYPE_INSTANCE:

{

Array<CIMInstance> a;

value.get(a);

_xmlWritter_appendValueArray(out, a.getData(), a.size());

break;

}

default:

PEGASUS_ASSERT(false);

PEGASUS_UNREACHABLE(PEGASUS_ASSERT(false);)

}

else if (value.getType() == CIMTYPE_REFERENCE)

Line 1075

Line 569

}

else

{

out << "<VALUE>";

out << STRLIT("<VALUE>");

switch (value.getType())

{

Line 1198

Line 692

_xmlWritter_appendValue(out, v);

break;

}

case CIMTYPE_INSTANCE:

{

CIMInstance v;

value.get(v);

_xmlWritter_appendValue(out, v);

break;

}

default:

PEGASUS_ASSERT(false);

PEGASUS_UNREACHABLE(PEGASUS_ASSERT(false);)

}

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

out << STRLIT("</VALUE>\n");

}

Line 1213

Line 713

{

Buffer tmp;

appendValueElement(tmp, value);

tmp.append('\0');

os << tmp.getData() << PEGASUS_STD(endl);

}

Line 1228

Line 727

void XmlWriter::appendValueObjectWithPathElement(

Buffer& out,

const CIMObject& objectWithPath)

const CIMObject& objectWithPath,

Boolean includeQualifiers,

Boolean includeClassOrigin,

Boolean isClassObject,

const CIMPropertyList& propertyList)

{

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

out << STRLIT("<VALUE.OBJECTWITHPATH>\n");

appendValueReferenceElement(out, objectWithPath.getPath (), false);

appendValueReferenceElement(out, objectWithPath.getPath (),

appendObjectElement(out, objectWithPath);

isClassObject , false);

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

appendObjectElement(

out,

objectWithPath,

includeQualifiers,

includeClassOrigin,

propertyList);

out << STRLIT("</VALUE.OBJECTWITHPATH>\n");

}

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

Line 1248

Line 758

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

void XmlWriter::appendValueReferenceElement(

// appends INSTANCEPATH | LOCALINSTANCEPATH | INSTANCENAME

void XmlWriter::appendValueInstancePathElement(

Buffer& out,

const CIMObjectPath& reference,

const CIMObjectPath& reference)

Boolean putValueWrapper)

{

if (putValueWrapper)

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

// See if it is a class or instance reference (instance references have

// key-bindings; class references do not).

// ATTN-CAKG-P2-20020726: The following condition does not correctly

// distinguish instanceNames from classNames in every case

// The instanceName of a singleton instance of a keyless class has no

// key bindings

Array<CIMKeyBinding> kbs = reference.getKeyBindings();

if (kbs.size())

{

if (reference.getHost().size())

{

Line 1282

Line 776

appendInstanceNameElement(out, reference);

}

else

// appends CLASSPATH | LOCALCLASSPATH | CLASSNAME

void XmlWriter::appendValueClassPathElement(

Buffer& out,

const CIMObjectPath& reference)

{

if (reference.getHost().size())

{

appendClassPathElement(out, reference);

}

else if (!reference.getNameSpace().isNull())

{

appendLocalClassPathElement(out, reference);

}

else

{

appendClassNameElement(out, reference.getClassName());

}

// Builds either a classPath or InstancePath based on isClassPath

// parameter which was carried forward from, for example, the

// request. If wrapper true, wrap output with <VALUE.REFERENCE>

void XmlWriter::appendValueReferenceElement(

Buffer& out,

const CIMObjectPath& reference,

Boolean isClassPath,

Boolean addValueWrapper)

{

if (reference.getHost().size())

if (addValueWrapper)

{

appendClassPathElement(out, reference);

out << STRLIT("<VALUE.REFERENCE>\n");

}

else if (!reference.getNameSpace().isNull())

if (isClassPath)

{

appendLocalClassPathElement(out, reference);

appendValueClassPathElement(out,reference);

}

else

{

appendClassNameElement(out, reference.getClassName());

appendValueInstancePathElement(out,reference);

}

if (putValueWrapper)

if (addValueWrapper)

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

{

out << STRLIT("</VALUE.REFERENCE>\n");

}

void XmlWriter::printValueReferenceElement(

const CIMObjectPath& reference,

Boolean isClassPath,

PEGASUS_STD(ostream)& os)

{

Buffer tmp;

appendValueReferenceElement(tmp, reference, true);

appendValueReferenceElement(tmp, reference, isClassPath, true);

tmp.append('\0');

indentedPrint(os, tmp.getData());

}

Line 1322

Line 844

void XmlWriter::appendValueNamedInstanceElement(

Buffer& out,

const CIMInstance& namedInstance)

const CIMInstance& namedInstance,

Boolean includeQualifiers,

Boolean includeClassOrigin,

const CIMPropertyList& propertyList)

{

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

out << STRLIT("<VALUE.NAMEDINSTANCE>\n");

appendInstanceNameElement(out, namedInstance.getPath ());

appendInstanceElement(out, namedInstance);

appendInstanceElement(

out,

namedInstance,

includeQualifiers,

includeClassOrigin,

propertyList);

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

out << STRLIT("</VALUE.NAMEDINSTANCE>\n");

}

//EXP_PULL_BEGIN

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

// appendValueInstanceWithPathElement()

// <!ELEMENT VALUE.INSTANCEWITHPATH (INSTANCEPATH,INSTANCE)>

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

void XmlWriter::appendValueInstanceWithPathElement(

Buffer& out,

const CIMInstance& namedInstance,

Boolean includeQualifiers,

Boolean includeClassOrigin,

const CIMPropertyList& propertyList)

{

out << STRLIT("<VALUE.INSTANCEWITHPATH>\n");

appendInstancePathElement(out, namedInstance.getPath ());

appendInstanceElement(

out,

namedInstance,

includeQualifiers,

includeClassOrigin,

propertyList);

out << STRLIT("</VALUE.INSTANCEWITHPATH>\n");

}

//EXP_PULL_END

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

// appendClassElement()

Line 1346

Line 905

void XmlWriter::appendClassElement(

Buffer& out,

const CIMConstClass& cimclass)

const CIMConstClass& cimClass)

{

CheckRep(cimClass._rep);

const CIMClassRep* rep = cimClass._rep;

// Class opening element:

out << STRLIT("<CLASS NAME=\"")

<< rep->getClassName()

<< STRLIT("\" ");

if (!rep->getSuperClassName().isNull())

{

cimclass._checkRep();

out << STRLIT(" SUPERCLASS=\"")

cimclass._rep->toXml(out);

<< rep->getSuperClassName()

<< STRLIT("\" ");

}

out << STRLIT(">\n");

// Append Class Qualifiers:

for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++)

XmlWriter::appendQualifierElement(out, rep->getQualifier(i));

// Append Property definitions:

for (Uint32 i = 0, n = rep->getPropertyCount(); i < n; i++)

XmlWriter::appendPropertyElement(out, rep->getProperty(i));

// Append Method definitions:

for (Uint32 i = 0, n = rep->getMethodCount(); i < n; i++)

XmlWriter::appendMethodElement(out, rep->getMethod(i));

// Class closing element:

out << STRLIT("</CLASS>\n");

}

void XmlWriter::printClassElement(

Line 1358

Line 951

{

Buffer tmp;

appendClassElement(tmp, cimclass);

tmp.append('\0');

indentedPrint(os, tmp.getData(), 4);

}

Line 1375

Line 967

void XmlWriter::appendInstanceElement(

Buffer& out,

const CIMConstInstance& instance)

const CIMConstInstance& instance,

Boolean includeQualifiers,

Boolean includeClassOrigin,

const CIMPropertyList& propertyList)

{

CheckRep(instance._rep);

const CIMInstanceRep* rep = instance._rep;

// Class opening element:

out << STRLIT("<INSTANCE CLASSNAME=\"")

<< rep->getClassName()

<< STRLIT("\" >\n");

// Append Instance Qualifiers:

if(includeQualifiers)

{

for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++)

XmlWriter::appendQualifierElement(out, rep->getQualifier(i));

}

if(propertyList.isNull())

{

for (Uint32 i = 0, n = rep->getPropertyCount(); i < n; i++)

{

XmlWriter::appendPropertyElement(

out,

rep->getProperty(i),

includeQualifiers,includeClassOrigin);

}

else

{

instance._checkRep();

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

instance._rep->toXml(out);

{

CIMName name = propertyList[i];

Uint32 pos = rep->_properties.find(

propertyList[i],

propertyList.getCIMNameTag(i));

if(pos != PEG_NOT_FOUND)

{

PEG_TRACE((TRC_XML,Tracer::LEVEL4,

"XmlWriter::appendInstanceElement"

" Filtering the property name:%s for the className:%s"

"since it was not filtered by the provider.",

(const char *)name.getString().getCString(),

(const char *)instance.getClassName().

getString().getCString()));

XmlWriter::appendPropertyElement(

out,

rep->getProperty(pos),

includeQualifiers,includeClassOrigin);

}

// Instance closing element:

out << STRLIT("</INSTANCE>\n");

}

void XmlWriter::printInstanceElement(

Line 1387

Line 1035

{

Buffer tmp;

appendInstanceElement(tmp, instance);

tmp.append('\0');

os << tmp.getData() << PEGASUS_STD(endl);

}

Line 1401

Line 1048

void XmlWriter::appendObjectElement(

Buffer& out,

const CIMConstObject& object)

const CIMConstObject& object,

Boolean includeQualifiers,

Boolean includeClassOrigin,

const CIMPropertyList& propertyList)

{

if (object.isClass())

{

Line 1411

Line 1061

else if (object.isInstance())

{

CIMConstInstance i(object);

appendInstanceElement(out, i);

appendInstanceElement(

out,

includeQualifiers,

includeClassOrigin,

propertyList);

}

// else PEGASUS_ASSERT(0);

}

Line 1446

Line 1101

void XmlWriter::appendPropertyElement(

Buffer& out,

const CIMConstProperty& property)

const CIMConstProperty& property,

Boolean includeQualifiers,

Boolean includeClassOrigin)

{

CheckRep(property._rep);

const CIMPropertyRep* rep = property._rep;

if (rep->getValue().isArray())

{

out << STRLIT("<PROPERTY.ARRAY NAME=\"")

<< rep->getName()

<< STRLIT("\" ");

if (rep->getValue().getType() == CIMTYPE_OBJECT)

{

// If the property array type is CIMObject, then

// encode the property in CIM-XML as a string array with the

// EmbeddedObject attribute (there is not currently a CIM-XML

// "object" datatype)

Array<CIMObject> a;

rep->getValue().get(a);

out << STRLIT(" TYPE=\"string\"");

// If the Embedded Object is an instance, always add the

// EmbeddedObject attribute.

if (a.size() > 0 && a[0].isInstance())

{

out << STRLIT(" EmbeddedObject=\"object\""

" EMBEDDEDOBJECT=\"object\"");

}

#ifndef PEGASUS_SNIA_INTEROP_COMPATIBILITY

else

#endif

{

// Else the Embedded Object is a class, always add the

// EmbeddedObject qualifier. Note that if the macro

// PEGASUS_SNIA_INTEROP_COMPATIBILITY is defined, then

// the EmbeddedObject qualifier will always be added,

// whether it's a class or an instance.

if (rep->findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDOBJECT) ==

PEG_NOT_FOUND)

{

// Note that addQualifiers() cannot be called on a const

// CIMQualifierRep. In this case we really do want to add

// the EmbeddedObject qualifier, so we cast away the

// constness.

CIMPropertyRep* tmpRep = const_cast<CIMPropertyRep*>(rep);

tmpRep->addQualifier(

CIMQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDOBJECT,

true));

}

else if (rep->getValue().getType() == CIMTYPE_INSTANCE)

{

// If the property array type is CIMInstance, then

// encode the property in CIM-XML as a string array with the

// EmbeddedObject attribute (there is not currently a CIM-XML

// "instance" datatype)

Array<CIMInstance> a;

rep->getValue().get(a);

out << STRLIT(" TYPE=\"string\"");

// add the EmbeddedObject attribute

if (a.size() > 0)

{

out << STRLIT(" EmbeddedObject=\"instance\""

" EMBEDDEDOBJECT=\"instance\"");

// Note that if the macro PEGASUS_SNIA_INTEROP_COMPATIBILITY is

// defined, then the EmbeddedInstance qualifier will be added

# ifdef PEGASUS_SNIA_INTEROP_COMPATIBILITY

if (rep->findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDINSTANCE)

== PEG_NOT_FOUND)

{

// Note that addQualifiers() cannot be called on a const

// CIMQualifierRep. In this case we really do want to add

// the EmbeddedInstance qualifier, so we cast away the

// constness.

// For now, we assume that all the embedded instances in

// the array are of the same type

CIMPropertyRep* tmpRep = const_cast<CIMPropertyRep*>(rep);

tmpRep->addQualifier(CIMQualifier(

PEGASUS_QUALIFIERNAME_EMBEDDEDINSTANCE,

a[0].getClassName().getString()));

}

# endif

}

else

{

out.append(' ');

out << xmlWriterTypeStrings(rep->getValue().getType());

}

if (rep->getArraySize())

{

char buffer[32];

sprintf(buffer, "%u", rep->getArraySize());

out << STRLIT(" ARRAYSIZE=\"") << buffer;

out.append('"');

}

if(includeClassOrigin && !rep->getClassOrigin().isNull())

{

out << STRLIT(" CLASSORIGIN=\"") << rep->getClassOrigin();

out.append('"');

}

if (rep->getPropagated())

{

out << STRLIT(" PROPAGATED=\"true\"");

}

out << STRLIT(">\n");

if(includeQualifiers)

{

for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++)

XmlWriter::appendQualifierElement(out, rep->getQualifier(i));

}

XmlWriter::appendValueElement(out, rep->getValue());

out << STRLIT("</PROPERTY.ARRAY>\n");

}

else if (rep->getValue().getType() == CIMTYPE_REFERENCE)

{

out << STRLIT("<PROPERTY.REFERENCE"

" NAME=\"") << rep->getName() << STRLIT("\" ");

if (!rep->getReferenceClassName().isNull())

{

out << STRLIT(" REFERENCECLASS=\"") << rep->getReferenceClassName();

out.append('"');

}

if(includeClassOrigin && !rep->getClassOrigin().isNull())

{

out << STRLIT(" CLASSORIGIN=\"") << rep->getClassOrigin();

out.append('"');

}

if (rep->getPropagated())

{

out << STRLIT(" PROPAGATED=\"true\"");

}

out << STRLIT(">\n");

if(includeQualifiers)

{

for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++)

XmlWriter::appendQualifierElement(out, rep->getQualifier(i));

}

XmlWriter::appendValueElement(out, rep->getValue());

out << STRLIT("</PROPERTY.REFERENCE>\n");

}

else

{

out << STRLIT("<PROPERTY NAME=\"") << rep->getName() << STRLIT("\" ");

if(includeClassOrigin && !rep->getClassOrigin().isNull())

{

out << STRLIT(" CLASSORIGIN=\"") << rep->getClassOrigin();

out.append('"');

}

if (rep->getPropagated())

{

out << STRLIT(" PROPAGATED=\"true\"");

}

if (rep->getValue().getType() == CIMTYPE_OBJECT)

{

// If the property type is CIMObject, then

// encode the property in CIM-XML as a string with the

// EmbeddedObject attribute (there is not currently a CIM-XML

// "object" datatype)

CIMObject a;

rep->getValue().get(a);

out << STRLIT(" TYPE=\"string\"");

// If the Embedded Object is an instance, always add the

// EmbeddedObject attribute.

if (a.isInstance())

{

out << STRLIT(" EmbeddedObject=\"object\""

" EMBEDDEDOBJECT=\"object\"");

}

// Else the Embedded Object is a class, always add the

// EmbeddedObject qualifier.

#ifndef PEGASUS_SNIA_INTEROP_COMPATIBILITY

else

#endif

{

// Note that if the macro PEGASUS_SNIA_INTEROP_COMPATIBILITY

// is defined, then the EmbeddedObject qualifier will always

// be added, whether it's a class or an instance.

if (rep->findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDOBJECT) ==

PEG_NOT_FOUND)

{

// Note that addQualifiers() cannot be called on a const

// CIMQualifierRep. In this case we really do want to add

// the EmbeddedObject qualifier, so we cast away the

// constness.

CIMPropertyRep* tmpRep = const_cast<CIMPropertyRep*>(rep);

tmpRep->addQualifier(

CIMQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDOBJECT,

true));

}

else if (rep->getValue().getType() == CIMTYPE_INSTANCE)

{

CIMInstance a;

rep->getValue().get(a);

out << STRLIT(" TYPE=\"string\""

" EmbeddedObject=\"instance\""

" EMBEDDEDOBJECT=\"instance\"");

# ifdef PEGASUS_SNIA_INTEROP_COMPATIBILITY

if (rep->findQualifier(PEGASUS_QUALIFIERNAME_EMBEDDEDOBJECT)

== PEG_NOT_FOUND)

{

// Note that addQualifiers() cannot be called on a const

// CIMQualifierRep. In this case we really do want to add

// the EmbeddedInstance qualifier, so we cast away the

// constness.

CIMPropertyRep* tmpRep = const_cast<CIMPropertyRep*>(rep);

tmpRep->addQualifier(CIMQualifier(

PEGASUS_QUALIFIERNAME_EMBEDDEDINSTANCE,

a.getClassName().getString()));

}

# endif

}

else

{

out.append(' ');

out << xmlWriterTypeStrings(rep->getValue().getType());

}

out << STRLIT(">\n");

if(includeQualifiers)

{

property._checkRep();

for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++)

property._rep->toXml(out);

XmlWriter::appendQualifierElement(out, rep->getQualifier(i));

}

XmlWriter::appendValueElement(out, rep->getValue());

out << STRLIT("</PROPERTY>\n");

}

void XmlWriter::printPropertyElement(

Line 1458

Line 1363

{

Buffer tmp;

appendPropertyElement(tmp, property);

tmp.append('\0');

os << tmp.getData() << PEGASUS_STD(endl);

}

Line 1480

Line 1384

Buffer& out,

const CIMConstMethod& method)

{

method._checkRep();

CheckRep(method._rep);

method._rep->toXml(out);

const CIMMethodRep* rep = method._rep;

out << STRLIT("<METHOD NAME=\"") << rep->getName();

out << STRLIT("\" ");

out << xmlWriterTypeStrings(rep->getType());

if (!rep->getClassOrigin().isNull())

{

out << STRLIT(" CLASSORIGIN=\"") << rep->getClassOrigin();

out.append('"');

}

if (rep->getPropagated())

{

out << STRLIT(" PROPAGATED=\"true\"");

}

out << STRLIT(">\n");

for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++)

XmlWriter::appendQualifierElement(out, rep->getQualifier(i));

for (Uint32 i = 0, n = rep->getParameterCount(); i < n; i++)

XmlWriter::appendParameterElement(out, rep->getParameter(i));

out << STRLIT("</METHOD>\n");

}

void XmlWriter::printMethodElement(

Line 1490

Line 1420

{

Buffer tmp;

appendMethodElement(tmp, method);

tmp.append('\0');

os << tmp.getData() << PEGASUS_STD(endl);

}

Line 1526

Line 1455

Buffer& out,

const CIMConstParameter& parameter)

{

parameter._checkRep();

CheckRep(parameter._rep);

parameter._rep->toXml(out);

const CIMParameterRep* rep = parameter._rep;

if (rep->isArray())

{

if (rep->getType() == CIMTYPE_REFERENCE)

{

out << STRLIT("<PARAMETER.REFARRAY NAME=\"") << rep->getName();

out.append('"');

if (!rep->getReferenceClassName().isNull())

{

out << STRLIT(" REFERENCECLASS=\"");

out << rep->getReferenceClassName().getString();

out.append('"');

}

if (rep->getArraySize())

{

char buffer[32];

int n = sprintf(buffer, "%u", rep->getArraySize());

out << STRLIT(" ARRAYSIZE=\"");

out.append(buffer, n);

out.append('"');

}

out << STRLIT(">\n");

for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++)

XmlWriter::appendQualifierElement(out, rep->getQualifier(i));

out << STRLIT("</PARAMETER.REFARRAY>\n");

}

else

{

out << STRLIT("<PARAMETER.ARRAY"

" NAME=\"") << rep->getName();

out << STRLIT("\" ") << xmlWriterTypeStrings(rep->getType());

if (rep->getArraySize())

{

char buffer[32];

sprintf(buffer, "%u", rep->getArraySize());

out << STRLIT(" ARRAYSIZE=\"") << buffer;

out.append('"');

}

out << STRLIT(">\n");

for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++)

XmlWriter::appendQualifierElement(out, rep->getQualifier(i));

out << STRLIT("</PARAMETER.ARRAY>\n");

}

else if (rep->getType() == CIMTYPE_REFERENCE)

{

out << STRLIT("<PARAMETER.REFERENCE"

" NAME=\"") << rep->getName();

out.append('"');

if (!rep->getReferenceClassName().isNull())

{

out << STRLIT(" REFERENCECLASS=\"");

out << rep->getReferenceClassName().getString();

out.append('"');

}

out << STRLIT(">\n");

for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++)

XmlWriter::appendQualifierElement(out, rep->getQualifier(i));

out << STRLIT("</PARAMETER.REFERENCE>\n");

}

else

{

out << STRLIT("<PARAMETER"

" NAME=\"") << rep->getName();

out << STRLIT("\" ") << xmlWriterTypeStrings(rep->getType());

out << STRLIT(">\n");

for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++)

XmlWriter::appendQualifierElement(out, rep->getQualifier(i));

out << STRLIT("</PARAMETER>\n");

}

void XmlWriter::printParameterElement(

Line 1536

Line 1550

{

Buffer tmp;

appendParameterElement(tmp, parameter);

tmp.append('\0');

os << tmp.getData() << PEGASUS_STD(endl);

}

Line 1546

Line 1559

// <!ELEMENT PARAMVALUE (VALUE|VALUE.REFERENCE|VALUE.ARRAY|VALUE.REFARRAY)?>

// <!ATTLIST PARAMVALUE

// %CIMName;>

// %CIMName;

// %EmbeddedObject; #IMPLIED

// %ParamType;>

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

Line 1554

Line 1569

Buffer& out,

const CIMParamValue& paramValue)

{

paramValue._checkRep();

CheckRep(paramValue._rep);

paramValue._rep->toXml(out);

const CIMParamValueRep* rep = paramValue._rep;

out << STRLIT("<PARAMVALUE NAME=\"") << rep->getParameterName();

out.append('"');

CIMType type = rep->getValue().getType();

if (rep->isTyped())

{

XmlWriter::appendParamTypeAndEmbeddedObjAttrib(out, type);

}

out << STRLIT(">\n");

XmlWriter::appendValueElement(out, rep->getValue());

out << STRLIT("</PARAMVALUE>\n");

}

void XmlWriter::printParamValueElement(

Line 1564

Line 1594

{

Buffer tmp;

appendParamValueElement(tmp, paramValue);

tmp.append('\0');

os << tmp.getData() << PEGASUS_STD(endl);

}

Line 1585

Line 1614

Buffer& out,

const CIMConstQualifier& qualifier)

{

qualifier._checkRep();

CheckRep(qualifier._rep);

qualifier._rep->toXml(out);

const CIMQualifierRep* rep = qualifier._rep;

out << STRLIT("<QUALIFIER NAME=\"") << rep->getName();

out << STRLIT("\" ") << xmlWriterTypeStrings(rep->getValue().getType());

if (rep->getPropagated())

{

out << STRLIT(" PROPAGATED=\"true\"");

}

XmlWriter::appendQualifierFlavorEntity(out, rep->getFlavor());

out << STRLIT(">\n");

XmlWriter::appendValueElement(out, rep->getValue());

out << STRLIT("</QUALIFIER>\n");

}

void XmlWriter::printQualifierElement(

Line 1595

Line 1640

{

Buffer tmp;

appendQualifierElement(tmp, qualifier);

tmp.append('\0');

os << tmp.getData() << PEGASUS_STD(endl);

}

Line 1617

Line 1661

Buffer& out,

const CIMConstQualifierDecl& qualifierDecl)

{

qualifierDecl._checkRep();

CheckRep(qualifierDecl._rep);

qualifierDecl._rep->toXml(out);

const CIMQualifierDeclRep* rep = qualifierDecl._rep;

out << STRLIT("<QUALIFIER.DECLARATION NAME=\"") << rep->getName();

out << STRLIT("\" ") << xmlWriterTypeStrings(rep->getValue().getType());

if (rep->getValue().isArray())

{

out << STRLIT(" ISARRAY=\"true\"");

if (rep->getArraySize())

{

char buffer[64];

int n = sprintf(buffer, " ARRAYSIZE=\"%u\"", rep->getArraySize());

out.append(buffer, n);

}

XmlWriter::appendQualifierFlavorEntity(out, rep->getFlavor());

out << STRLIT(">\n");

XmlWriter::appendScopeElement(out, rep->getScope());

XmlWriter::appendValueElement(out, rep->getValue());

out << STRLIT("</QUALIFIER.DECLARATION>\n");

}

void XmlWriter::printQualifierDeclElement(

Line 1627

Line 1695

{

Buffer tmp;

appendQualifierDeclElement(tmp, qualifierDecl);

tmp.append('\0');

os << tmp.getData() << PEGASUS_STD(endl);

}

Line 1640

Line 1707

// TOINSTANCE (true|false) 'false'

// TRANSLATABLE (true|false) 'false'">

// DEPRECATION NOTE: The attribute TOINSTANCE is DEPRECATED and MAY be

// removed from the QualifierFlavor entity in a future version of this

// document. Use of this qualifier is discouraged.

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

void XmlWriter::appendQualifierFlavorEntity(

Line 1647

Line 1718

const CIMFlavor & flavor)

{

if (!(flavor.hasFlavor (CIMFlavor::OVERRIDABLE)))

out << " OVERRIDABLE=\"false\"";

out << STRLIT(" OVERRIDABLE=\"false\"");

if (!(flavor.hasFlavor (CIMFlavor::TOSUBCLASS)))

out << " TOSUBCLASS=\"false\"";

out << STRLIT(" TOSUBCLASS=\"false\"");

if (flavor.hasFlavor (CIMFlavor::TOINSTANCE))

//if (flavor.hasFlavor (CIMFlavor::TOINSTANCE))

out << " TOINSTANCE=\"true\"";

// out << STRLIT(" TOINSTANCE=\"true\"");

if (flavor.hasFlavor (CIMFlavor::TRANSLATABLE))

out << " TRANSLATABLE=\"true\"";

out << STRLIT(" TRANSLATABLE=\"true\"");

}

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

Line 1681

Line 1752

{

if (!(scope.equal (CIMScope ())))

{

out << "<SCOPE";

out << STRLIT("<SCOPE");

if (scope.hasScope (CIMScope::CLASS))

out << " CLASS=\"true\"";

out << STRLIT(" CLASS=\"true\"");

if (scope.hasScope (CIMScope::ASSOCIATION))

out << " ASSOCIATION=\"true\"";

out << STRLIT(" ASSOCIATION=\"true\"");

if (scope.hasScope (CIMScope::REFERENCE))

out << " REFERENCE=\"true\"";

out << STRLIT(" REFERENCE=\"true\"");

if (scope.hasScope (CIMScope::PROPERTY))

out << " PROPERTY=\"true\"";

out << STRLIT(" PROPERTY=\"true\"");

if (scope.hasScope (CIMScope::METHOD))

out << " METHOD=\"true\"";

out << STRLIT(" METHOD=\"true\"");

if (scope.hasScope (CIMScope::PARAMETER))

out << " PARAMETER=\"true\"";

out << STRLIT(" PARAMETER=\"true\"");

if (scope.hasScope (CIMScope::INDICATION))

out << " INDICATION=\"true\"";

out << STRLIT(" INDICATION=\"true\"");

out << "/>";

out << STRLIT("/>");

}

Line 1726

Line 1797

const String& cimObject,

const String& authenticationHeader,

HttpMethod httpMethod,

const AcceptLanguages & acceptLanguages,

const AcceptLanguageList& acceptLanguages,

const ContentLanguages & contentLanguages,

const ContentLanguageList& contentLanguages,

Uint32 contentLength)

Uint32 contentLength,

bool binaryRequest,

bool binaryResponse)

{

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

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

// ATTN: KS 20020926 - Temporary change to issue only POST. This may

// be changed in the DMTF CIM Operations standard in the future.

Line 1740

Line 1813

// installed. Required because of change to wbemservices cimom

if (httpMethod == HTTP_METHOD_M_POST)

{

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

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

}

else

{

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

out << STRLIT("POST /cimom HTTP/1.1\r\n");

}

out << STRLIT("HOST: ") << host << STRLIT("\r\n");

if (binaryRequest)

{

// Tell the server that the payload is encoded in the OpenPegasus

// binary protocol.

out << STRLIT("Content-Type: application/x-openpegasus\r\n");

}

else

{

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

}

if (binaryResponse)

{

// Tell the server that this client accepts the OpenPegasus binary

// protocol.

out << STRLIT("Accept: application/x-openpegasus\r\n");

}

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

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

OUTPUT_CONTENTLENGTH(out, contentLength);

OUTPUT_CONTENTLENGTH;

if (acceptLanguages.size() > 0)

{

out << "Accept-Language: " << acceptLanguages << "\r\n";

out << STRLIT("Accept-Language: ") << acceptLanguages << STRLIT("\r\n");

}

if (contentLanguages.size() > 0)

{

out << "Content-Language: " << contentLanguages << "\r\n";

out << STRLIT("Content-Language: ") << contentLanguages <<

STRLIT("\r\n");

}

#ifdef PEGASUS_DEBUG

Line 1766

Line 1858

static const char *clientTransferEncodingOff =

getenv("PEGASUS_HTTP_TRANSFER_ENCODING_REQUEST");

if (!clientTransferEncodingOff || *clientTransferEncodingOff != '0')

#endif

out << "TE: chunked, trailers" << "\r\n";

if (!binaryResponse)

{

// The binary protocol does not allow chunking.

out << STRLIT("TE: chunked, trailers\r\n");

}

if (httpMethod == HTTP_METHOD_M_POST)

{

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

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

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

out << nn << STRLIT("\r\n");

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

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

out << nn << "-CIMMethod: "

out << nn << STRLIT("-CIMMethod: ")

<< encodeURICharacters(cimMethod.getString()) << "\r\n";

<< encodeURICharacters(cimMethod.getString()) << STRLIT("\r\n");

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

out << nn << STRLIT("-CIMObject: ")

<< encodeURICharacters(cimObject) << STRLIT("\r\n");

}

else

{

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

out << STRLIT("CIMOperation: MethodCall\r\n");

out << "CIMMethod: " << encodeURICharacters(cimMethod.getString())

out << STRLIT("CIMMethod: ")

<< "\r\n";

<< encodeURICharacters(cimMethod.getString()) << STRLIT("\r\n");

out << "CIMObject: " << encodeURICharacters(cimObject) << "\r\n";

out << STRLIT("CIMObject: ") << encodeURICharacters(cimObject)

<< STRLIT("\r\n");

}

if (authenticationHeader.size())

{

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

out << authenticationHeader << STRLIT("\r\n");

}

out << "\r\n";

out << STRLIT("\r\n");

}

void XmlWriter::appendMethodResponseHeader(

Buffer& out,

HttpMethod httpMethod,

const ContentLanguages & contentLanguages,

const ContentLanguageList& contentLanguages,

Uint32 contentLength,

Uint32 serverResponseTime)

Uint64 serverResponseTime,

bool binaryResponse)

{

// Optimize the typical case for binary messages, circumventing the

// more expensive logic below.

if (binaryResponse &&

contentLength == 0 &&

httpMethod != HTTP_METHOD_M_POST &&

contentLanguages.size() == 0)

{

static const char HEADERS[] =

"HTTP/1.1 200 OK\r\n"

"Content-Type: application/x-openpegasus\r\n"

"content-length: 0000000000\r\n"

"CIMOperation: MethodResponse\r\n"

"\r\n";

// The HTTP processor fills in the content-length value later.

// It searches for a field matching "content-length" (so the first

// character must be lower case).

out.append(HEADERS, sizeof(HEADERS) - 1);

return;

}

out << STRLIT("HTTP/1.1 " HTTP_STATUS_OK "\r\n");

#ifndef PEGASUS_DISABLE_PERFINST

if (StatisticalData::current()->copyGSD)

{

out << STRLIT("WBEMServerResponseTime: ") <<

CIMValue(serverResponseTime).toString() << STRLIT("\r\n");

}

#endif

if (binaryResponse)

{

// According to MIME RFC, the "x-" prefix should be used for all

// non-registered values.

out << STRLIT("Content-Type: application/x-openpegasus\r\n");

}

else

{

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

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

out << "HTTP/1.1 " HTTP_STATUS_OK "\r\n";

}

STAT_SERVERTIME

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

OUTPUT_CONTENTLENGTH(out, contentLength);

OUTPUT_CONTENTLENGTH;

if (contentLanguages.size() > 0)

{

out << "Content-Language: " << contentLanguages << "\r\n";

out << STRLIT("Content-Language: ") << contentLanguages <<

STRLIT("\r\n");

}

if (httpMethod == HTTP_METHOD_M_POST)

{

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

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

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

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

out << STRLIT("Ext:\r\n"

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

"Cache-Control: no-cache\r\n"

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

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

out << nn << STRLIT("\r\n");

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

}

else

{

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

out << STRLIT("CIMOperation: MethodResponse\r\n\r\n");

}

Line 1849

Line 1990

const String& cimError,

const String& errorDetail)

{

out << "HTTP/1.1 " << status << "\r\n";

out << STRLIT("HTTP/1.1 ") << status << STRLIT("\r\n");

if (cimError != String::EMPTY)

{

out << "CIMError: " << cimError << "\r\n";

out << STRLIT("CIMError: ") << cimError << STRLIT("\r\n");

}

if (errorDetail != String::EMPTY)

{

// ATTN-RK-P3-20020404: It is critical that this text not contain '\n'

out << STRLIT(PEGASUS_HTTPHEADERTAG_ERRORDETAIL ": ")

// ATTN-RK-P3-20020404: Need to encode this value properly. (See

<< encodeURICharacters(errorDetail) << STRLIT("\r\n");

// CIM/HTTP Specification section 3.3.2

out << PEGASUS_HTTPHEADERTAG_ERRORDETAIL ": "

<< encodeURICharacters(errorDetail) << "\r\n";

}

out << "\r\n";

out << STRLIT("\r\n");

}

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

Line 1874

Line 2012

// Returns unauthorized message in the following format:

// HTTP/1.1 401 Unauthorized

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

// PGErrorDetail: <error text> (if specified by caller)

// WWW-Authenticate: Basic realm="HostName"

// <HTML><HEAD>

// <TITLE>401 Unauthorized</TITLE>

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

Line 1886

Line 2025

void XmlWriter::appendUnauthorizedResponseHeader(

Buffer& out,

const String& errorDetail,

const String& content)

{

out << "HTTP/1.1 " HTTP_STATUS_UNAUTHORIZED "\r\n";

out << STRLIT("HTTP/1.1 " HTTP_STATUS_UNAUTHORIZED "\r\n");

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

if (errorDetail.size() > 0)

out << "\r\n";

{

out << STRLIT(PEGASUS_HTTPHEADERTAG_ERRORDETAIL ": ")

<< encodeURICharacters(errorDetail) << STRLIT("\r\n");

}

OUTPUT_CONTENTLENGTH(out, 0);

out << content << STRLIT("\r\n\r\n");

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

// can display the error message.

Line 1927

Line 2073

Buffer& out,

const String& content)

{

out << "HTTP/1.1 " HTTP_STATUS_OK "\r\n";

out << STRLIT("HTTP/1.1 " HTTP_STATUS_OK "\r\n");

// Content-Length header needs to be added because 200 OK record

// is usually intended to have content. But, for Kerberos this

// may not always be the case so we need to indicate that there

// is no content

Uint32 contentLength = 0;

OUTPUT_CONTENTLENGTH(out, 0);

OUTPUT_CONTENTLENGTH;

out << content << STRLIT("\r\n\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.

Line 1964

Line 2108

Buffer& out,

const String& messageId)

{

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

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

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

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

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

"<MESSAGE ID=\"") << messageId;

out << STRLIT("\" PROTOCOLVERSION=\"1.0\">\n");

}

void XmlWriter::_appendMessageElementEnd(

Buffer& out)

{

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

out << STRLIT("</MESSAGE>\n</CIM>\n");

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

}

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

Line 1988

Line 2132

void XmlWriter::_appendSimpleReqElementBegin(

Buffer& out)

{

out << "<SIMPLEREQ>\n";

out << STRLIT("<SIMPLEREQ>\n");

}

void XmlWriter::_appendSimpleReqElementEnd(

Buffer& out)

{

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

out << STRLIT("</SIMPLEREQ>\n");

}

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

Line 2011

Line 2155

Buffer& out,

const CIMName& name)

{

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

out << STRLIT("<METHODCALL NAME=\"") << name << STRLIT("\">\n");

}

void XmlWriter::_appendMethodCallElementEnd(

Buffer& out)

{

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

out << STRLIT("</METHODCALL>\n");

}

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

Line 2034

Line 2178

Buffer& out,

const CIMName& name)

{

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

out << STRLIT("<IMETHODCALL NAME=\"") << name << STRLIT("\">\n");

}

void XmlWriter::_appendIMethodCallElementEnd(

Buffer& out)

{

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

out << STRLIT("</IMETHODCALL>\n");

}

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

Line 2059

Line 2203

Buffer& out,

const char* name)

{

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

out << STRLIT("<IPARAMVALUE NAME=\"") << name << STRLIT("\">\n");

}

void XmlWriter::_appendIParamValueElementEnd(

Buffer& out)

{

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

out << STRLIT("</IPARAMVALUE>\n");

}

//EXP_PULL_BEGIN

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

// _appendParamValueElementBegin()

// _appendParamValueElementEnd()

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

// |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION

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

// <!ATTLIST IPARAMVALUE %CIMName;>

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

void XmlWriter::_appendParamValueElementBegin(

Buffer& out,

const char* name)

{

out << STRLIT("<PARAMVALUE NAME=\"") << name << STRLIT("\">\n");

}

void XmlWriter::_appendParamValueElementEnd(

Buffer& out)

{

out << STRLIT("</PARAMVALUE>\n");

}

//EXP_PULL_END

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

Line 2080

Line 2251

void XmlWriter::_appendSimpleRspElementBegin(

Buffer& out)

{

out << "<SIMPLERSP>\n";

out << STRLIT("<SIMPLERSP>\n");

}

void XmlWriter::_appendSimpleRspElementEnd(

Buffer& out)

{

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

out << STRLIT("</SIMPLERSP>\n");

}

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

Line 2103

Line 2274

Buffer& out,

const CIMName& name)

{

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

out << STRLIT("<METHODRESPONSE NAME=\"") << name << STRLIT("\">\n");

}

void XmlWriter::_appendMethodResponseElementEnd(

Buffer& out)

{

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

out << STRLIT("</METHODRESPONSE>\n");

}

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

Line 2126

Line 2297

Buffer& out,

const CIMName& name)

{

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

out << STRLIT("<IMETHODRESPONSE NAME=\"") << name << STRLIT("\">\n");

}

void XmlWriter::_appendIMethodResponseElementEnd(

Buffer& out)

{

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

out << STRLIT("</IMETHODRESPONSE>\n");

}

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

Line 2145

Line 2316

Buffer& out,

const CIMException& cimException)

{

Tracer::traceCIMException(TRC_XML_WRITER, Tracer::LEVEL2, cimException);

Tracer::traceCIMException(TRC_XML, Tracer::LEVEL2, cimException);

out << STRLIT("<ERROR CODE=\"") << Uint32(cimException.getCode());

out.append('"');

out << "<ERROR";

out << " CODE=\"" << Uint32(cimException.getCode()) << "\"";

String description = TraceableCIMException(cimException).getDescription();

if (description != String::EMPTY)

{

out << " DESCRIPTION=\"";

out << STRLIT(" DESCRIPTION=\"");

appendSpecial(out, description);

out << "\"";

out.append('"');

}

if (cimException.getErrorCount())

{

out << STRLIT(">");

for (Uint32 i = 0, n = cimException.getErrorCount(); i < n; i++)

appendInstanceElement(out, cimException.getError(i));

out << STRLIT("</ERROR>");

}

out << "/>";

else

out << STRLIT("/>");

}

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

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

// appendReturnValueElement()

// appendParamTypeAndEmbeddedObjAttrib

// Appends the Param type and EmbeddedObject Info to the buffer

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

// <!ATTLIST RETURNVALUE

// %EmbeddedObject; #IMPLIED

// %ParamType;>

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

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

void XmlWriter::appendReturnValueElement(

void XmlWriter::appendParamTypeAndEmbeddedObjAttrib(

Buffer& out,

const CIMValue& value)

const CIMType& type)

{

out << "<RETURNVALUE";

CIMType type = value.getType();

// If the property type is CIMObject, then

// encode the property in CIM-XML as a string with the EMBEDDEDOBJECT attribute

// encode the property in CIM-XML as a string with the EmbeddedObject

// (there is not currently a CIM-XML "object" datatype)

// attribute (there is not currently a CIM-XML "object"

// datatype).

// Because of an error in Pegasus we were earlier outputting

// upper case "EMBEDDEDOBJECT" as the attribute name. The

// spec calls for mixed case "EmbeddedObject. Fixed in

// bug 7131 to output EmbeddedObject attribute in upper

// case and mixed case. Receiver will ignore one or the

// other.

// else

// output the real type

if (type == CIMTYPE_OBJECT)

{

out << " PARAMTYPE=\"string\"";

out << " EMBEDDEDOBJECT=\"object\"";

out << STRLIT(" PARAMTYPE=\"string\""

" EmbeddedObject=\"object\""

" EMBEDDEDOBJECT=\"object\"");

}

else if (type == CIMTYPE_INSTANCE)

{

out << STRLIT(" PARAMTYPE=\"string\""

" EmbeddedObject=\"instance\""

" EMBEDDEDOBJECT=\"instance\"");

}

else

{

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

out << STRLIT(" PARAM") << xmlWriterTypeStrings(type);

}

out << ">\n";

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

// appendReturnValueElement()

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

// <!ATTLIST RETURNVALUE

// %EmbeddedObject; #IMPLIED

// %ParamType;>

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

void XmlWriter::appendReturnValueElement(

Buffer& out,

const CIMValue& value)

{

out << STRLIT("<RETURNVALUE");

CIMType type = value.getType();

appendParamTypeAndEmbeddedObjAttrib(out, type);

out << STRLIT(">\n");

// Add value.

appendValueElement(out, value);

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

out << STRLIT("</RETURNVALUE>\n");

}

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

Line 2214

Line 2431

void XmlWriter::_appendIReturnValueElementBegin(

Buffer& out)

{

out << "<IRETURNVALUE>\n";

out << STRLIT("<IRETURNVALUE>\n");

}

void XmlWriter::_appendIReturnValueElementEnd(

Buffer& out)

{

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

out << STRLIT("</IRETURNVALUE>\n");

}

//EXP_PULL_BEGIN

void XmlWriter::_appendIReturnValueElementWithNameBegin(

Buffer& out,

const char* name)

{

out << STRLIT("<IRETURNVALUE NAME=\"") << name << STRLIT("\">\n");

}

//EXP_PULL_END

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

Line 2235

Line 2461

Boolean flag)

{

_appendIParamValueElementBegin(out, name);

out << "<VALUE>";

out << STRLIT("<VALUE>");

append(out, flag);

out << STRLIT("</VALUE>\n");

_appendIParamValueElementEnd(out);

}

//EXP_PULL_BEGIN

void XmlWriter::appendBooleanParameter(

Buffer& out,

const char* name,

Boolean flag)

{

_appendParamValueElementBegin(out, name);

out << STRLIT("<VALUE>");

append(out, flag);

out << STRLIT("</VALUE>\n");

_appendParamValueElementEnd(out);

}

void XmlWriter::appendBooleanIReturnValue(

Buffer& out,

const char* name,

Boolean flag)

{

_appendIReturnValueElementWithNameBegin(out, name);

out << STRLIT("<VALUE>");

append(out, flag);

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

out << STRLIT("</VALUE>\n");

_appendIReturnValueElementEnd(out);

}

void XmlWriter::appendUint32IParameter(

Buffer& out,

const char* name,

Uint32 val)

{

_appendIParamValueElementBegin(out, name);

out << STRLIT("<VALUE>");

append(out, val);

out << STRLIT("</VALUE>\n");

_appendIParamValueElementEnd(out);

}

// Can be used to generate either parameters with value,

// parameters with NULL (i.e. no value element) or

// no parameters output at all.

void XmlWriter::appendUint32ArgIParameter(

Buffer& out,

const char* name,

const Uint32Arg& val,

const Boolean required)

{

if (!required && val.isNull())

{

return;

}

_appendIParamValueElementBegin(out, name);

if (!val.isNull())

{

out << STRLIT("<VALUE>");

append(out, val.getValue());

out << STRLIT("</VALUE>\n");

}

_appendIParamValueElementEnd(out);

}

/* Output return value from Uint64Arg object as

Value inside IRETURNVALUE

If the state of the object is NULL output

the parameter without value. Else

output the value

void XmlWriter::appendUint64ReturnValue(

Buffer& out,

const char* name,

const Uint64Arg& val)

{

_appendIReturnValueElementBegin(out);

out << STRLIT("<VALUE>");

if (!val.isNull())

{

append(out, val.getValue());

}

out << STRLIT("</VALUE>\n");

_appendIReturnValueElementEnd(out);

}

//EXP_PULL_END

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

// appendStringIParameter()

Line 2253

Line 2561

const String& str)

{

_appendIParamValueElementBegin(out, name);

out << "<VALUE>";

out << STRLIT("<VALUE>");

appendSpecial(out, str);

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

out << STRLIT("</VALUE>\n");

_appendIParamValueElementEnd(out);

}

// EXP_PULL_BEGIN

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

// appendQualifierNameIParameter()

// appendStringIParameterIfNotEmpty()

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

void XmlWriter::appendQualifierNameIParameter(

void XmlWriter::appendStringIParameterIfNotEmpty(

Buffer& out,

const char* name,

const String& qualifierName)

const String& str)

{

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

if (str != String::EMPTY)

// |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION

{

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

appendStringIParameter(out,name,str);

}

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

// appendStringParameter()

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

void XmlWriter::appendStringParameter(

appendClassNameElement(out, qualifierName);

Buffer& out,

_appendIParamValueElementEnd(out);

const char* name,

const String& str)

{

_appendParamValueElementBegin(out, name);

out << STRLIT("<VALUE>");

appendSpecial(out, str);

out << STRLIT("</VALUE>\n");

_appendParamValueElementEnd(out);

}

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

// appendStringIReturnValue()

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

void XmlWriter::appendStringIReturnValue(

Buffer& out,

const char* name,

const String& str)

{

_appendIReturnValueElementWithNameBegin(out, name);

out << STRLIT("<VALUE>");

appendSpecial(out, str);

out << STRLIT("</VALUE>\n");

_appendIReturnValueElementEnd(out);

}

//EXP_PULL_END

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

// appendClassNameIParameter()

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

Line 2324

Line 2662

_appendIParamValueElementEnd(out);

}

void XmlWriter::appendObjectNameIParameter(

Buffer& out,

const char* name,

const CIMObjectPath& objectName)

{

// ATTN-CAKG-P2-20020726: The following condition does not correctly

// distinguish instanceNames from classNames in every case

// The instanceName of a singleton instance of a keyless class also

// has no key bindings

if (objectName.getKeyBindings ().size () == 0)

{

XmlWriter::appendClassNameIParameter(

out, name, objectName.getClassName());

}

else

{

XmlWriter::appendInstanceNameIParameter(

out, name, objectName);

}

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

// appendClassIParameter()

Line 2409

Line 2724

const CIMName& propertyName)

{

_appendIParamValueElementBegin(out, "PropertyName");

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

out << STRLIT("<VALUE>") << propertyName << STRLIT("</VALUE>\n");

_appendIParamValueElementEnd(out);

}

Line 2447

Line 2762

if (!propertyList.isNull ())

{

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

out << STRLIT("<VALUE.ARRAY>\n");

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

{

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

out << STRLIT("<VALUE>") << propertyList[i] << STRLIT("</VALUE>\n");

}

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

out << STRLIT("</VALUE.ARRAY>\n");

}

_appendIParamValueElementEnd(out);

Line 2510

Line 2825

const String& messageId,

HttpMethod httpMethod,

const String& authenticationHeader,

const AcceptLanguages& httpAcceptLanguages,

const AcceptLanguageList& httpAcceptLanguages,

const ContentLanguages& httpContentLanguages)

const ContentLanguageList& httpContentLanguages,

bool binaryResponse)

{

Buffer out;

Buffer tmp;

Line 2540

Line 2856

httpMethod,

httpAcceptLanguages,

httpContentLanguages,

out.size());

out.size(),

false,

binaryResponse);

tmp << out;

return tmp;

}

//PEP 128 adding serverRsponseTime to header

Buffer XmlWriter::formatSimpleMethodRspMessage(

const CIMName& methodName,

const String& messageId,

HttpMethod httpMethod,

const ContentLanguages & httpContentLanguages,

const ContentLanguageList& httpContentLanguages,

const Buffer& bodyParams,

const Buffer& body,

Uint32 serverResponseTime,

Uint64 serverResponseTime,

Boolean isFirst,

Boolean isLast)

{

Line 2563

Line 2881

{

// NOTE: temporarily put zero for content length. the http code

// will later decide to fill in the length or remove it altogether

appendMethodResponseHeader(out, httpMethod, httpContentLanguages, 0,

appendMethodResponseHeader(

serverResponseTime);

out, httpMethod, httpContentLanguages, 0, serverResponseTime);

_appendMessageElementBegin(out, messageId);

_appendSimpleRspElementBegin(out);

_appendMethodResponseElementBegin(out, methodName);

Line 2586

Line 2904

}

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

// XmlWriter::formatSimpleMethodErrorRspMessage()

Line 2610

Line 2927

_appendSimpleRspElementEnd(out);

_appendMessageElementEnd(out);

// l10n

appendMethodResponseHeader(

appendMethodResponseHeader(tmp,

tmp,

httpMethod,

cimException.getContentLanguages(),

out.size());

out.size(),

false);

tmp << out;

return tmp;

Line 2633

Line 2951

const String& messageId,

HttpMethod httpMethod,

const String& authenticationHeader,

const AcceptLanguages& httpAcceptLanguages,

const AcceptLanguageList& httpAcceptLanguages,

const ContentLanguages& httpContentLanguages,

const ContentLanguageList& httpContentLanguages,

const Buffer& body)

const Buffer& body,

bool binaryResponse)

{

Buffer out;

Buffer tmp;

Line 2658

Line 2977

httpMethod,

httpAcceptLanguages,

httpContentLanguages,

out.size());

out.size(),

false,

binaryResponse);

tmp << out;

return tmp;

Line 2670

Line 2991

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

Formats a IMethod Response Message. This function formats

messages for chunking based on the isFirst and isLast parameters.

If isFirst is set, it outputs headers and ResponseElement begin.

It always sends the body. If isLast is set, it sends the rtnParams

and the ResponseElement end followed by any parameter in the rtnParams.

KS_PULL_TBD_TODO - Determine what we want to do with chunking. Since this

This whole thing is based on the concept of each message sending a single

chunk and we will want in the future to modify so we can chose easily

whether we want to chunk or not and send the chunks.

Buffer XmlWriter::formatSimpleIMethodRspMessage(

const CIMName& iMethodName,

const String& messageId,

HttpMethod httpMethod,

const ContentLanguages & httpContentLanguages,

const ContentLanguageList& httpContentLanguages,

const Buffer& rtnParams,

const Buffer& body,

Uint32 serverResponseTime,

Uint64 serverResponseTime,

Boolean isFirst,

Boolean isLast)

{

Line 2686

Line 3019

{

// NOTE: temporarily put zero for content length. the http code

// will later decide to fill in the length or remove it altogether

appendMethodResponseHeader(out, httpMethod, httpContentLanguages, 0,

appendMethodResponseHeader(

serverResponseTime);

out, httpMethod, httpContentLanguages, 0, serverResponseTime);

_appendMessageElementBegin(out, messageId);

_appendSimpleRspElementBegin(out);

_appendIMethodResponseElementBegin(out, iMethodName);

// output the start of the return tag. Test if there is response data by:

// output the start of the return tag. Test if there is response data

// by:

// 1. there is data on the first chunk OR

// 2. there is no data on the first chunk but isLast is false implying

// there is more non-empty data to come. If all subsequent chunks

Line 2710

Line 3044

{

if (body.size() != 0 || isFirst == false)

_appendIReturnValueElementEnd(out);

// Insert any return parameters.

if (rtnParams.size() != 0)

{

out << rtnParams;

}

// //EXP_PULL_END

_appendIMethodResponseElementEnd(out);

_appendSimpleRspElementEnd(out);

_appendMessageElementEnd(out);

Line 2742

Line 3084

_appendSimpleRspElementEnd(out);

_appendMessageElementEnd(out);

// l10n

appendMethodResponseHeader(tmp,

httpMethod,

cimException.getContentLanguages(),

out.size());

out.size(), false);

tmp << out;

return tmp;

Line 2773

Line 3114

const CIMName& cimMethod,

HttpMethod httpMethod,

const String& authenticationHeader,

const AcceptLanguages& acceptLanguages,

const AcceptLanguageList& acceptLanguages,

const ContentLanguages& contentLanguages,

const ContentLanguageList& contentLanguages,

Uint32 contentLength)

{

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

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

if (httpMethod == HTTP_METHOD_M_POST)

{

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

out << STRLIT("M-POST ") << requestUri << STRLIT(" HTTP/1.1\r\n");

}

else

{

out << "POST " << requestUri << " HTTP/1.1\r\n";

out << STRLIT("POST ") << requestUri << STRLIT(" HTTP/1.1\r\n");

}

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

out << STRLIT("HOST: ") << host << STRLIT("\r\n"

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

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

OUTPUT_CONTENTLENGTH;

OUTPUT_CONTENTLENGTH(out, contentLength);

if (acceptLanguages.size() > 0)

{

out << "Accept-Language: " << acceptLanguages << "\r\n";

out << STRLIT("Accept-Language: ") << acceptLanguages << STRLIT("\r\n");

}

if (contentLanguages.size() > 0)

{

out << "Content-Language: " << contentLanguages << "\r\n";

out << STRLIT("Content-Language: ") << contentLanguages <<

STRLIT("\r\n");

}

#ifdef PEGASUS_DEBUG

Line 2810

Line 3152

getenv("PEGASUS_HTTP_TRANSFER_ENCODING_REQUEST");

if (!clientTransferEncodingOff || *clientTransferEncodingOff != '0')

#endif

out << "TE: chunked, trailers" << "\r\n";

out << STRLIT("TE: chunked, trailers\r\n");

if (httpMethod == HTTP_METHOD_M_POST)

{

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

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

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

out << nn << STRLIT("\r\n");

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

out << nn << STRLIT("-CIMExport: MethodRequest\r\n");

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

out << nn << STRLIT("-CIMExportMethod: ") << cimMethod <<

STRLIT("\r\n");

}

else

{

out << "CIMExport: MethodRequest\r\n";

out << STRLIT("CIMExport: MethodRequest\r\n"

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

"CIMExportMethod: ") << cimMethod << STRLIT("\r\n");

}

if (authenticationHeader.size())

{

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

out << authenticationHeader << STRLIT("\r\n");

}

out << "\r\n";

out << STRLIT("\r\n");

}

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

Line 2844

Line 3187

void XmlWriter::appendEMethodResponseHeader(

Buffer& out,

HttpMethod httpMethod,

const ContentLanguages& contentLanguages,

const ContentLanguageList& contentLanguages,

Uint32 contentLength)

{

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

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

out << "HTTP/1.1 " HTTP_STATUS_OK "\r\n";

out << STRLIT("HTTP/1.1 " HTTP_STATUS_OK "\r\n"

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

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

OUTPUT_CONTENTLENGTH;

OUTPUT_CONTENTLENGTH(out, contentLength);

if (contentLanguages.size() > 0)

{

out << "Content-Language: " << contentLanguages << "\r\n";

out << STRLIT("Content-Language: ") << contentLanguages <<

STRLIT("\r\n");

}

if (httpMethod == HTTP_METHOD_M_POST)

{

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

out << STRLIT("Ext:\r\n"

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

"Cache-Control: no-cache\r\n"

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

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

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

out << nn << STRLIT("\r\n");

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

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

}

else

{

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

out << STRLIT("CIMExport: MethodResponse\r\n\r\n");

}

Line 2883

Line 3227

void XmlWriter::_appendSimpleExportReqElementBegin(

Buffer& out)

{

out << "<SIMPLEEXPREQ>\n";

out << STRLIT("<SIMPLEEXPREQ>\n");

}

void XmlWriter::_appendSimpleExportReqElementEnd(

Buffer& out)

{

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

out << STRLIT("</SIMPLEEXPREQ>\n");

}

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

Line 2906

Line 3250

Buffer& out,

const CIMName& name)

{

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

out << STRLIT("<EXPMETHODCALL NAME=\"") << name << STRLIT("\">\n");

}

void XmlWriter::_appendEMethodCallElementEnd(

Buffer& out)

{

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

out << STRLIT("</EXPMETHODCALL>\n");

}

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

Line 2930

Line 3274

Buffer& out,

const char* name)

{

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

out << STRLIT("<EXPPARAMVALUE NAME=\"") << name << STRLIT("\">\n");

}

void XmlWriter::_appendEParamValueElementEnd(

Buffer& out)

{

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

out << STRLIT("</EXPPARAMVALUE>\n");

}

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

Line 2967

Line 3311

void XmlWriter::_appendSimpleExportRspElementBegin(

Buffer& out)

{

out << "<SIMPLEEXPRSP>\n";

out << STRLIT("<SIMPLEEXPRSP>\n");

}

void XmlWriter::_appendSimpleExportRspElementEnd(

Buffer& out)

{

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

out << STRLIT("</SIMPLEEXPRSP>\n");

}

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

Line 2990

Line 3334

Buffer& out,

const CIMName& name)

{

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

out << STRLIT("<EXPMETHODRESPONSE NAME=\"") << name << STRLIT("\">\n");

}

void XmlWriter::_appendEMethodResponseElementEnd(

Buffer& out)

{

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

out << STRLIT("</EXPMETHODRESPONSE>\n");

}

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

Line 3012

Line 3356

const String& messageId,

HttpMethod httpMethod,

const String& authenticationHeader,

const AcceptLanguages& httpAcceptLanguages,

const AcceptLanguageList& httpAcceptLanguages,

const ContentLanguages& httpContentLanguages,

const ContentLanguageList& httpContentLanguages,

const Buffer& body)

{

Buffer out;

Line 3052

Line 3396

const CIMName& eMethodName,

const String& messageId,

HttpMethod httpMethod,

const ContentLanguages& httpContentLanguages,

const ContentLanguageList& httpContentLanguages,

const Buffer& body)

{

Buffer out;

Line 3098

Line 3442

_appendSimpleExportRspElementEnd(out);

_appendMessageElementEnd(out);

// l10n

appendEMethodResponseHeader(

appendEMethodResponseHeader(tmp,

tmp,

httpMethod,

cimException.getContentLanguages(),

out.size());

Line 3110

Line 3454

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

// _xmlWritter_printAttributes()

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

void _xmlWritter_printAttributes(

PEGASUS_STD(ostream)& os,

const XmlAttribute* attributes,

Uint32 attributeCount)

{

for (Uint32 i = 0; i < attributeCount; i++)

{

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

os << '"';

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

os << '"';

if (i + 1 != attributeCount)

os << ' ';

}

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

// _xmlWritter_indent()

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

void _xmlWritter_indent(PEGASUS_STD(ostream)& os, Uint32 level, Uint32 indentChars)

{

Uint32 n = level * indentChars;

for (Uint32 i = 0; i < n; i++)

os << ' ';

}

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

// indentedPrint()

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

void XmlWriter::indentedPrint(

PEGASUS_STD(ostream)& os,

const char* text,

Uint32 indentChars)

{

AutoArrayPtr<char> tmp(strcpy(new char[strlen(text) + 1], text));

XmlParser parser(tmp.get());

XmlEntry entry;

Stack<const char*> stack;

while (parser.next(entry))

{

switch (entry.type)

{

case XmlEntry::XML_DECLARATION:

{

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

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

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

os << "?>";

break;

}

case XmlEntry::START_TAG:

{

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

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

if (entry.attributeCount)

os << ' ';

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

os << ">";

stack.push(entry.text);

break;

}

case XmlEntry::EMPTY_TAG:

{

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

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

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

os << "/>";

break;

}

case XmlEntry::END_TAG:

{

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

stack.pop();

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

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

break;

}

case XmlEntry::COMMENT:

{

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

os << "<!--";

_xmlWritter_appendSpecial(os, entry.text);

os << "-->";

break;

}

case XmlEntry::CONTENT:

{

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

_xmlWritter_appendSpecial(os, entry.text);

break;

}

case XmlEntry::CDATA:

{

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

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

break;

}

case XmlEntry::DOCTYPE:

{

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

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

break;

}

os << PEGASUS_STD(endl);

}

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

// XmlWriter::getNextMessageId()

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

static IDFactory _messageIDFactory(1000);

String XmlWriter::getNextMessageId()

{

// ATTN: make thread-safe:

char scratchBuffer[22];

static Uint32 messageId = 1000;

Uint32 n;

const char * startP = Uint32ToString(scratchBuffer,

messageId++;

_messageIDFactory.getID(),

n);

if (messageId < 1000)

return String(startP, n);

messageId = 1001;

char buffer[16];

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

return buffer;

}

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

Line 3276

Line 3475

// XmlWriter::keyBindingTypeToString

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

const char* XmlWriter::keyBindingTypeToString (CIMKeyBinding::Type type)

const StrLit XmlWriter::keyBindingTypeToString (CIMKeyBinding::Type type)

{

switch (type)

{

case CIMKeyBinding::BOOLEAN:

return "boolean";

return STRLIT("boolean");

case CIMKeyBinding::STRING:

return "string";

return STRLIT("string");

case CIMKeyBinding::NUMERIC:

return "numeric";

return STRLIT("numeric");

case CIMKeyBinding::REFERENCE:

default:

PEGASUS_ASSERT(false);

PEGASUS_UNREACHABLE(PEGASUS_ASSERT(false);)

}

return "unknown";

return STRLIT("unknown");

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.125
changed lines
	Added in v.1.169.4.8

No CVS admin address has been configured