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.153.2.1 and 1.169.4.7

version 1.153.2.1, 2008/02/07 18:46:11

version 1.169.4.7, 2013/09/14 23:08:17

Line 1

//%2006////////////////////////////////////////////////////////////////////////

//%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"),

// EMC Corporation; Symantec Corporation; The Open Group.

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

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

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

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

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

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

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

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

// The above copyright notice and this permission notice shall be included

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

// in all copies or substantial portions of the Software.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

//////////////////////////////////////////////////////////////////////////

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

Line 53

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 "LanguageParser.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]; \

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

out << STRLIT("content-length: "); \

out.append(contentLengthP, n); \

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

}

////////////////////////////////////////////////////////////////////////////////

// SpecialChar and table.

////////////////////////////////////////////////////////////////////////////////

// Note: we cannot use StrLit here since it has a constructur (forbits

// structure initialization).

struct SpecialChar

{

const char* str;

Uint32 size;

};

// Defines encodings of special characters. Just use a 7-bit ASCII character

// as an index into this array to retrieve its string encoding and encoding

// length in bytes.

static const SpecialChar _specialChars[] =

{

{STRLIT_ARGS("")},

{STRLIT_ARGS("	")},

{STRLIT_ARGS("
")},

{STRLIT_ARGS("")},

{STRLIT_ARGS("")},

{STRLIT_ARGS("")},

{STRLIT_ARGS(" ")},

{STRLIT_ARGS("!")},

{STRLIT_ARGS(""")},

{STRLIT_ARGS("#")},

{STRLIT_ARGS("$")},

{STRLIT_ARGS("%")},

{STRLIT_ARGS("&")},

{STRLIT_ARGS("'")},

{STRLIT_ARGS("(")},

{STRLIT_ARGS(")")},

{STRLIT_ARGS("*")},

{STRLIT_ARGS("+")},

{STRLIT_ARGS(",")},

{STRLIT_ARGS("-")},

{STRLIT_ARGS(".")},

{STRLIT_ARGS("/")},

{STRLIT_ARGS("0")},

{STRLIT_ARGS("1")},

{STRLIT_ARGS("2")},

{STRLIT_ARGS("3")},

{STRLIT_ARGS("4")},

{STRLIT_ARGS("5")},

{STRLIT_ARGS("6")},

{STRLIT_ARGS("7")},

{STRLIT_ARGS("8")},

{STRLIT_ARGS("9")},

{STRLIT_ARGS(":")},

{STRLIT_ARGS(";")},

{STRLIT_ARGS("<")},

{STRLIT_ARGS("=")},

{STRLIT_ARGS(">")},

{STRLIT_ARGS("?")},

{STRLIT_ARGS("@")},

{STRLIT_ARGS("A")},

{STRLIT_ARGS("B")},

{STRLIT_ARGS("C")},

{STRLIT_ARGS("D")},

{STRLIT_ARGS("E")},

{STRLIT_ARGS("F")},

{STRLIT_ARGS("G")},

{STRLIT_ARGS("H")},

{STRLIT_ARGS("I")},

{STRLIT_ARGS("J")},

{STRLIT_ARGS("K")},

{STRLIT_ARGS("L")},

{STRLIT_ARGS("M")},

{STRLIT_ARGS("N")},

{STRLIT_ARGS("O")},

{STRLIT_ARGS("P")},

{STRLIT_ARGS("Q")},

{STRLIT_ARGS("R")},

{STRLIT_ARGS("S")},

{STRLIT_ARGS("T")},

{STRLIT_ARGS("U")},

{STRLIT_ARGS("V")},

{STRLIT_ARGS("W")},

{STRLIT_ARGS("X")},

{STRLIT_ARGS("Y")},

{STRLIT_ARGS("Z")},

{STRLIT_ARGS("[")},

{STRLIT_ARGS("\\")},

{STRLIT_ARGS("]")},

{STRLIT_ARGS("^")},

{STRLIT_ARGS("_")},

{STRLIT_ARGS("`")},

{STRLIT_ARGS("a")},

{STRLIT_ARGS("b")},

{STRLIT_ARGS("c")},

{STRLIT_ARGS("d")},

{STRLIT_ARGS("e")},

{STRLIT_ARGS("f")},

{STRLIT_ARGS("g")},

{STRLIT_ARGS("h")},

{STRLIT_ARGS("i")},

{STRLIT_ARGS("j")},

{STRLIT_ARGS("k")},

{STRLIT_ARGS("l")},

{STRLIT_ARGS("m")},

{STRLIT_ARGS("n")},

{STRLIT_ARGS("o")},

{STRLIT_ARGS("p")},

{STRLIT_ARGS("q")},

{STRLIT_ARGS("r")},

{STRLIT_ARGS("s")},

{STRLIT_ARGS("t")},

{STRLIT_ARGS("u")},

{STRLIT_ARGS("v")},

{STRLIT_ARGS("w")},

{STRLIT_ARGS("x")},

{STRLIT_ARGS("y")},

{STRLIT_ARGS("z")},

{STRLIT_ARGS("{")},

{STRLIT_ARGS("|")},

{STRLIT_ARGS("}")},

{STRLIT_ARGS("~")},

{STRLIT_ARGS("")},

};

// If _isSpecialChar7[ch] is true, then ch is a special character, which must

// have a special encoding in XML. But only use 7-bit ASCII characters to

// index this array.

static const int _isSpecialChar7[] =

{

1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,0,0,

0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,

};

////////////////////////////////////////////////////////////////////////////////

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;

}

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

{

XmlWriter::append(out, LanguageParser::buildAcceptLanguageHeader(al));

return out;

}

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

{

XmlWriter::append(out, LanguageParser::buildContentLanguageHeader(cl));

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;

}

static 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 _appendSpecialChar7(Buffer& out, char c)

{

if (_isSpecialChar7[int(c)])

out.append(_specialChars[int(c)].str, _specialChars[int(c)].size);

else

out.append(c);

}

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

{

if (c < 128)

_appendSpecialChar7(out, char(c));

else

_xmlWritter_appendChar(out, c);

}

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

{

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

{

char scratchBuffer[22];

Uint32 outputLength;

const char * output = Uint8ToString(scratchBuffer,

static_cast<Uint8>(c),

outputLength);

os << "&#" << output << ";";

}

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

}

// On windows sprintf outputs 3 digit precision exponent prepending

// zeros. Make it 2 digit precision if first digit is zero in the exponent.

#ifdef PEGASUS_OS_TYPE_WINDOWS

inline void _xmlWriter_normalizeRealValueString(char *str)

{

// skip initial sign value...

if (*str == '-' || *str == '+')

{

++str;

}

while (*str && *str != '+' && *str != '-')

{

++str;

}

if (*str && * ++str == '0')

{

*str = *(str+1);

*(str+1) = *(str+2);

*(str+2) = 0;

}

#endif

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

{

_xmlWritter_appendChar(out, x);

}

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

{

if (x)

out.append(STRLIT_ARGS("TRUE"));

else

out.append(STRLIT_ARGS("FALSE"));

}

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

{

Uint32 outputLength=0;

char buffer[22];

const char * output = Uint32ToString(buffer, x, outputLength);

out.append(output, outputLength);

}

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

{

Uint32 outputLength=0;

char buffer[22];

const char * output = Sint32ToString(buffer, x, outputLength);

out.append(output, outputLength);

}

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

{

Uint32 outputLength=0;

char buffer[22];

const char * output = Uint64ToString(buffer, x, outputLength);

out.append(output, outputLength);

}

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

{

Uint32 outputLength=0;

char buffer[22];

const char * output = Sint64ToString(buffer, x, outputLength);

out.append(output, outputLength);

}

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

#ifdef PEGASUS_OS_TYPE_WINDOWS

_xmlWriter_normalizeRealValueString(buffer);

#endif

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

#ifdef PEGASUS_OS_TYPE_WINDOWS

_xmlWriter_normalizeRealValueString(buffer);

#endif

append(out, buffer);

}

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

{

size_t n = strlen(str);

out.append(str, n);

}

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

{

const Uint16* p = (const Uint16*)str.getChar16Data();

size_t n = str.size();

// Handle leading ASCII 7 characers in these next two loops (use unrolling).

while (n >= 8 && ((p[0]|p[1]|p[2]|p[3]|p[4]|p[5]|p[6]|p[7]) & 0xFF80) == 0)

{

out.append(p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);

p += 8;

n -= 8;

}

while (n >= 4 && ((p[0]|p[1]|p[2]|p[3]) & 0xFF80) == 0)

{

out.append(p[0], p[1], p[2], p[3]);

p += 4;

n -= 4;

}

while (n--)

{

Uint16 c = *p++;

// Special processing for UTF8 case:

if (c < 128)

{

out.append(c);

continue;

}

// Handle UTF8 case (if reached).

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

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

{

Char16 highSurrogate = p[-1];

Char16 lowSurrogate = p[0];

p++;

n--;

_xmlWritter_appendSurrogatePair(

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

}

else

{

_xmlWritter_appendChar(out, c);

}

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)

{

_appendSpecialChar7(out, x);

}

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

{

while (*str)

_appendSpecialChar7(out, *str++);

}

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

{

const Uint16* p = (const Uint16*)str.getChar16Data();

// prevCharIsSpace is true when the last character written to the Buffer

// is a space character (not a character reference).

Boolean prevCharIsSpace = false;

// If the first character is a space, use a character reference to avoid

// space compression.

if (*p == ' ')

{

out.append(STRLIT_ARGS(" "));

p++;

}

Uint16 c;

while ((c = *p++) != 0)

{

if (c < 128)

{

if (_isSpecialChar7[c])

{

// Write the character reference for the special character

out.append(

_specialChars[int(c)].str, _specialChars[int(c)].size);

prevCharIsSpace = false;

}

else if (prevCharIsSpace && (c == ' '))

{

// Write the character reference for the space character, to

// avoid compression

out.append(STRLIT_ARGS(" "));

prevCharIsSpace = false;

}

else

{

out.append(c);

prevCharIsSpace = (c == ' ');

}

else

{

// Handle UTF8 case

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

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

*p)

{

_xmlWritter_appendSurrogatePair(out, c, *p++);

}

else

{

_xmlWritter_appendChar(out, c);

}

prevCharIsSpace = false;

}

// If the last character is a space, use a character reference to avoid

// space compression.

if (prevCharIsSpace)

{

out.remove(out.size() - 1);

out.append(STRLIT_ARGS(" "));

}

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

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

// Excluded characters:

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

// Space character = 0x20

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

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

static const char _is_uri[128] =

{

1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,

1,1,0,0,0,0,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,

};

// Perform the necessary URI encoding of characters in HTTP header values.

// This is required by the HTTP/1.1 specification and the CIM/HTTP

// Specification (section 3.3.2).

static void _xmlWritter_encodeURIChar(String& outString, Sint8 char8)

{

Uint8 c = (Uint8)char8;

#ifndef PEGASUS_DO_NOT_IMPLEMENT_URI_ENCODING

if (c > 127 || _is_uri[int(c)])

{

char hexencoding[4];

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

#ifdef PEGASUS_USE_STRING_EXTENSIONS

outString.append(hexencoding, n);

#else /* PEGASUS_USE_STRING_EXTENSIONS */

outString.append(hexencoding);

#endif /* PEGASUS_USE_STRING_EXTENSIONS */

}

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 809

Line 104

const String& host,

const CIMNamespaceName& nameSpace)

{

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

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

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

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

appendLocalNameSpacePathElement(out, nameSpace);

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

}

Line 858

Line 153

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

{

Line 866

Line 162

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

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

// fixed the special character problem - Markus

// fixed the special characters

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

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

Line 961

Line 257

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

// appendValueReferenceElement does this correctly with isClassPath flag

// Called only but formatSimple

void XmlWriter::appendLocalObjectPathElement(

Buffer& out,

const CIMObjectPath& objectPath)

Line 970

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 1061

Line 360

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 1249

Line 549

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

break;

}

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

case CIMTYPE_INSTANCE:

{

Array<CIMInstance> a;

Line 1257

Line 556

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

break;

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

default:

PEGASUS_ASSERT(false);

PEGASUS_UNREACHABLE(PEGASUS_ASSERT(false);)

}

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

Line 1394

Line 692

_xmlWritter_appendValue(out, v);

break;

}

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

case CIMTYPE_INSTANCE:

{

CIMInstance v;

Line 1402

Line 699

_xmlWritter_appendValue(out, v);

break;

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

default:

PEGASUS_ASSERT(false);

PEGASUS_UNREACHABLE(PEGASUS_ASSERT(false);)

}

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

Line 1431

Line 727

void XmlWriter::appendValueObjectWithPathElement(

Buffer& out,

const CIMObject& objectWithPath)

const CIMObject& objectWithPath,

Boolean includeQualifiers,

Boolean includeClassOrigin,

Boolean isClassObject,

const CIMPropertyList& propertyList)

{

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

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

appendValueReferenceElement(out, objectWithPath.getPath (),

appendObjectElement(out, objectWithPath);

isClassObject , false);

appendObjectElement(

out,

objectWithPath,

includeQualifiers,

includeClassOrigin,

propertyList);

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

}

Line 1451

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 << STRLIT("<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

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

if (kbs.size())

{

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

{

Line 1485

Line 776

appendInstanceNameElement(out, reference);

}

else

// appends CLASSPATH | LOCALCLASSPATH | CLASSNAME

void XmlWriter::appendValueClassPathElement(

Buffer& out,

const CIMObjectPath& reference)

{

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

{

Line 1501

Line 796

}

if (putValueWrapper)

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

{

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

}

if (isClassPath)

{

appendValueClassPathElement(out,reference);

}

else

{

appendValueInstancePathElement(out,reference);

}

if (addValueWrapper)

{

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

indentedPrint(os, tmp.getData());

}

Line 1524

Line 844

void XmlWriter::appendValueNamedInstanceElement(

Buffer& out,

const CIMInstance& namedInstance)

const CIMInstance& namedInstance,

Boolean includeQualifiers,

Boolean includeClassOrigin,

const CIMPropertyList& propertyList)

{

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

appendInstanceNameElement(out, namedInstance.getPath ());

appendInstanceElement(out, namedInstance);

appendInstanceElement(

out,

namedInstance,

includeQualifiers,

includeClassOrigin,

propertyList);

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 1548

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

{

CheckRep(cimclass._rep);

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 1576

Line 967

void XmlWriter::appendInstanceElement(

Buffer& out,

const CIMConstInstance& instance)

const CIMConstInstance& instance,

Boolean includeQualifiers,

Boolean includeClassOrigin,

const CIMPropertyList& propertyList)

{

CheckRep(instance._rep);

instance._rep->toXml(out);

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

{

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

{

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 1601

Line 1048

void XmlWriter::appendObjectElement(

Buffer& out,

const CIMConstObject& object)

const CIMConstObject& object,

Boolean includeQualifiers,

Boolean includeClassOrigin,

const CIMPropertyList& propertyList)

{

if (object.isClass())

{

Line 1611

Line 1061

else if (object.isInstance())

{

CIMConstInstance i(object);

appendInstanceElement(out, i);

appendInstanceElement(

out,

includeQualifiers,

includeClassOrigin,

propertyList);

}

// else PEGASUS_ASSERT(0);

}

Line 1646

Line 1101

void XmlWriter::appendPropertyElement(

Buffer& out,

const CIMConstProperty& property)

const CIMConstProperty& property,

Boolean includeQualifiers,

Boolean includeClassOrigin)

{

CheckRep(property._rep);

property._rep->toXml(out);

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)

{

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

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

}

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

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

}

void XmlWriter::printPropertyElement(

Line 1680

Line 1385

const CIMConstMethod& method)

{

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 1725

Line 1456

const CIMConstParameter& parameter)

{

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 1743

Line 1559

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

// <!ATTLIST PARAMVALUE

// %CIMName;>

// %CIMName;

// %EmbeddedObject; #IMPLIED

// %ParamType;>

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

Line 1752

Line 1570

const CIMParamValue& paramValue)

{

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 1782

Line 1615

const CIMConstQualifier& qualifier)

{

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 1813

Line 1662

const CIMConstQualifierDecl& qualifierDecl)

{

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 1834

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 1846

Line 1723

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

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

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

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

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

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

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

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

Line 1922

Line 1799

HttpMethod httpMethod,

const AcceptLanguageList& acceptLanguages,

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 1941

Line 1820

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

}

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

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

OUTPUT_CONTENTLENGTH;

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

}

OUTPUT_CONTENTLENGTH(out, contentLength);

if (acceptLanguages.size() > 0)

{

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

Line 1959

Line 1856

// This should be removed when stable. This should only be turned off in

// a debugging/testing environment.

static const char *clientTransferEncodingOff =

//// static const char *clientTransferEncodingOff =

getenv("PEGASUS_HTTP_TRANSFER_ENCODING_REQUEST");

//// getenv("PEGASUS_HTTP_TRANSFER_ENCODING_REQUEST");

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

// EXP_PULL_TEMP DELETE

// KS_TODO - Remove this. Temp to insure no chunking during testing

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

#endif

// EXP_PULL TEMP DELETE out << STRLIT("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)

{

Line 1974

Line 1879

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

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

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

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

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

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

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

}

else

{

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

out << STRLIT("CIMMethod: ")

<< encodeURICharacters(cimMethod.getString())

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

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

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

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

}

Line 2001

Line 1905

HttpMethod httpMethod,

const ContentLanguageList& contentLanguages,

Uint32 contentLength,

Uint64 serverResponseTime)

Uint64 serverResponseTime,

bool binaryResponse)

{

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

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

Line 2014

Line 1939

}

#endif

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

if (binaryResponse)

OUTPUT_CONTENTLENGTH;

{

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

{

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

}

OUTPUT_CONTENTLENGTH(out, contentLength);

if (contentLanguages.size() > 0)

{

Line 2024

Line 1959

}

if (httpMethod == HTTP_METHOD_M_POST)

{

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

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

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

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

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

"Cache-Control: no-cache\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");

}

Line 2079

Line 2016

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

Line 2029

void XmlWriter::appendUnauthorizedResponseHeader(

Buffer& out,

const String& errorDetail,

const String& content)

{

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

Uint32 contentLength = 0;

if (errorDetail.size() > 0)

OUTPUT_CONTENTLENGTH;

{

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

out << STRLIT(PEGASUS_HTTPHEADERTAG_ERRORDETAIL ": ")

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

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

Line 2082

// 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 << STRLIT("\r\n");

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

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

// can display the error message.

Line 2171

Line 2112

Buffer& out,

const String& messageId)

{

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

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

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

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

out << STRLIT("<MESSAGE ID=\"") << messageId;

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

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

}

void XmlWriter::_appendMessageElementEnd(

Buffer& out)

{

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

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

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

}

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

Line 2276

Line 2216

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

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

// _appendSimpleRspElementBegin()

Line 2353

Line 2320

Buffer& out,

const CIMException& cimException)

{

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

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

out << STRLIT("<ERROR");

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

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

out.append('"');

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

Line 2381

Line 2347

out << STRLIT("/>");

}

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

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

// appendReturnValueElement()

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

// appendParamTypeAndEmbeddedObjAttrib

// <!ATTLIST RETURNVALUE

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

// %EmbeddedObject; #IMPLIED

// %ParamType;>

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

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

void XmlWriter::appendReturnValueElement(

void XmlWriter::appendParamTypeAndEmbeddedObjAttrib(

Buffer& out,

const CIMValue& value)

const CIMType& type)

{

out << STRLIT("<RETURNVALUE");

CIMType type = value.getType();

// If the property type is CIMObject, then

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

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

// attribute (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 << STRLIT(" PARAMTYPE=\"string\"");

out << STRLIT(" EMBEDDEDOBJECT=\"object\"");

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

" EmbeddedObject=\"object\""

" EMBEDDEDOBJECT=\"object\"");

}

#ifdef PEGASUS_EMBEDDED_INSTANCE_SUPPORT

else if (type == CIMTYPE_INSTANCE)

{

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

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

out << STRLIT(" EMBEDDEDOBJECT=\"instance\"");

" EmbeddedObject=\"instance\""

" EMBEDDEDOBJECT=\"instance\"");

}

#endif // PEGASUS_EMBEDDED_INSTANCE_SUPPORT

else

{

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

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

out.append('"');

}

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

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

Line 2453

Line 2444

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

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

// appendBooleanIParameter()

Line 2471

_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 << 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 2489

Line 2571

_appendIParamValueElementEnd(out);

}

// EXP_PULL_BEGIN

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

// appendStringIParameterIfNotEmpty()

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

void XmlWriter::appendStringIParameterIfNotEmpty(

Buffer& out,

const char* name,

const String& str)

{

if (str != String::EMPTY)

{

appendStringIParameter(out,name,str);

}

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

// appendStringParameter()

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

void XmlWriter::appendStringParameter(

Buffer& 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 2530

Line 2666

_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 2717

Line 2830

HttpMethod httpMethod,

const String& authenticationHeader,

const AcceptLanguageList& httpAcceptLanguages,

const ContentLanguageList& httpContentLanguages)

const ContentLanguageList& httpContentLanguages,

bool binaryResponse)

{

Buffer out;

Buffer tmp;

Line 2746

Line 2860

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 ContentLanguageList& httpContentLanguages,

const Buffer& bodyParams,

const Buffer& body,

Uint64 serverResponseTime,

Boolean isFirst,

Line 2819

Line 2935

tmp,

httpMethod,

cimException.getContentLanguages(),

out.size());

out.size(),

false);

tmp << out;

return tmp;

Line 2840

Line 2957

const String& authenticationHeader,

const AcceptLanguageList& httpAcceptLanguages,

const ContentLanguageList& httpContentLanguages,

const Buffer& body)

const Buffer& body,

bool binaryResponse)

{

Buffer out;

Buffer tmp;

Line 2863

Line 2981

httpMethod,

httpAcceptLanguages,

httpContentLanguages,

out.size());

out.size(),

false,

binaryResponse);

tmp << out;

return tmp;

Line 2875

Line 2995

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

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 ContentLanguageList& httpContentLanguages,

const Buffer& rtnParams,

const Buffer& body,

Uint64 serverResponseTime,

Boolean isFirst,

Line 2916

Line 3048

{

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 2951

Line 3091

appendMethodResponseHeader(tmp,

httpMethod,

cimException.getContentLanguages(),

out.size());

out.size(), false);

tmp << out;

return tmp;

Line 2982

Line 3122

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)

{

Line 2992

Line 3132

{

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

}

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

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

out << STRLIT("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)

{

Line 3028

Line 3168

}

else

{

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

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

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

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

}

if (authenticationHeader.size())

Line 3054

Line 3194

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 << STRLIT("HTTP/1.1 " HTTP_STATUS_OK "\r\n");

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

out << STRLIT("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)

{

Line 3067

Line 3207

}

if (httpMethod == HTTP_METHOD_M_POST)

{

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

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

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

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

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

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

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

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

}

Line 3318

Line 3458

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

// _xmlWritter_printAttributes()

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

void _xmlWritter_printAttributes(

PEGASUS_STD(ostream)& os,

const Array<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.attributes.size());

os << "?>";

break;

}

case XmlEntry::START_TAG:

{

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

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

if (entry.attributes.size())

os << ' ';

_xmlWritter_printAttributes(

os, entry.attributes, entry.attributes.size());

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.attributes.size());

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[" << entry.text << "]]>";

break;

}

case XmlEntry::DOCTYPE:

{

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

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

break;

}

os << PEGASUS_STD(endl);

}

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

// XmlWriter::getNextMessageId()

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

Line 3485

Line 3479

// 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.153.2.1
changed lines
	Added in v.1.169.4.7

No CVS admin address has been configured