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.78 and 1.169.4.1

version 1.78, 2002/09/11 21:20:24

version 1.169.4.1, 2011/01/15 21:26:53

Line 1

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

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

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

// The Open Group, Tivoli Systems

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

// this work for additional information regarding copyright ownership.

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

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

// License.

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

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

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

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

// and/or 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 SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

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

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

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

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

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

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

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

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

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

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

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

// 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 SOFTWARE IS PROVIDED

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

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

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

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

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

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

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

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

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

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

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

// Carol Ann Krug Graves, Hewlett-Packard Company

// (carolann_graves@hp.com)

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

Line 35

Line 33

#include <cstdlib>

#include <cstdio>

#include "Constants.h"

#include "Destroyer.h"

#include "CIMClass.h"

#include "CIMClassRep.h"

#include "CIMInstance.h"

Line 54

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

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

{

XmlWriter::append(out, x);

return out;

}

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

{

XmlWriter::append(out, x);

return out;

}

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

{

XmlWriter::append(out, x);

return out;

}

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

{

XmlWriter::append(out, x);

return out;

}

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

{

XmlWriter::append(out, x);

return out;

}

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

{

out.appendArray(x);

return out;

}

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

{

XmlWriter::append(out, x);

return out;

}

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

{

return os << x.toString();

}

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

{

out.append(Sint8(c));

}

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

{

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

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(Sint8(c));

}

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

{

switch (c)

{

case '&':

os << "&";

break;

case '<':

os << "<";

break;

case '>':

os << ">";

break;

case '"':

os << """;

break;

case '\'':

os << "'";

break;

default:

os << c;

}

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

{

while (*str)

_appendSpecialChar(os, *str++);

}

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

{

_appendChar(out, x);

}

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

{

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

}

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

{

char buffer[32];

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

append(out, buffer);

}

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

{

char buffer[32];

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

append(out, buffer);

}

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

{

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

// I know I shouldn't put platform flags here, but the other way is too hard

#if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)

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

#else

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

#endif

append(out, buffer);

}

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

{

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

// I know I shouldn't put platform flags here, but the other way is too hard

#if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)

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

#else

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

#endif

append(out, buffer);

}

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

{

char buffer[128];

// %e gives '[-]m.dddddde+/-xx', which seems compatible with CIM/XML spec

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

append(out, buffer);

}

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

{

while (*str)

_appendChar(out, *str++);

}

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

{

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

{

_appendChar(out, str[i]);

}

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

{

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

out.append(' ');

}

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

{

_appendSpecialChar(out, x);

}

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

{

_appendSpecialChar(out, Char16(x));

}

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

{

while (*str)

_appendSpecialChar(out, *str++);

}

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

{

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

{

_appendSpecialChar(out, str[i]);

}

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

// appendLocalNameSpacePathElement()

Line 287

Line 70

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

void XmlWriter::appendLocalNameSpacePathElement(

Array<Sint8>& out,

Buffer& out,

const String& nameSpace)

const CIMNamespaceName& nameSpace)

{

out << "<LOCALNAMESPACEPATH>\n";

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

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

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

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

char *last;

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

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

#else

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

#endif

{

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

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

}

delete nameSpaceCopy;

free(nameSpaceCopy);

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

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

}

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

Line 311

Line 101

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

void XmlWriter::appendNameSpacePathElement(

Array<Sint8>& out,

Buffer& out,

const String& host,

const String& nameSpace)

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 332

Line 122

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

void XmlWriter::appendClassNameElement(

Array<Sint8>& out,

Buffer& out,

const String& className)

const CIMName& className)

{

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

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

}

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

Line 349

Line 139

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

void XmlWriter::appendInstanceNameElement(

Array<Sint8>& out,

Buffer& out,

const CIMObjectPath& instanceName)

{

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

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

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

Array<KeyBinding> 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() == KeyBinding::REFERENCE)

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

{

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

appendValueReferenceElement(out, ref, true);

}

else {

else

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

{

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

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

out << "\">";

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

// fixed the special character problem - Markus

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 388

Line 181

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

void XmlWriter::appendClassPathElement(

Array<Sint8>& out,

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 408

Line 201

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

void XmlWriter::appendInstancePathElement(

Array<Sint8>& out,

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 428

Line 221

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

void XmlWriter::appendLocalClassPathElement(

Array<Sint8>& out,

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 446

Line 239

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

void XmlWriter::appendLocalInstancePathElement(

Array<Sint8>& out,

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 465

Line 258

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

void XmlWriter::appendLocalObjectPathElement(

Array<Sint8>& out,

Buffer& out,

const CIMObjectPath& objectPath)

{

Line 490

Line 283

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

inline void _appendValue(Array<Sint8>& out, Boolean x)

inline void _xmlWritter_appendValue(Buffer& out, Boolean x)

{

XmlWriter::append(out, x);

}

inline void _appendValue(Array<Sint8>& out, Uint8 x)

inline void _xmlWritter_appendValue(Buffer& out, Uint8 x)

{

XmlWriter::append(out, Uint32(x));

}

inline void _appendValue(Array<Sint8>& out, Sint8 x)

inline void _xmlWritter_appendValue(Buffer& out, Sint8 x)

{

XmlWriter::append(out, Sint32(x));

}

inline void _appendValue(Array<Sint8>& out, Uint16 x)

inline void _xmlWritter_appendValue(Buffer& out, Uint16 x)

{

XmlWriter::append(out, Uint32(x));

}

inline void _appendValue(Array<Sint8>& out, Sint16 x)

inline void _xmlWritter_appendValue(Buffer& out, Sint16 x)

{

XmlWriter::append(out, Sint32(x));

}

inline void _appendValue(Array<Sint8>& out, Uint32 x)

inline void _xmlWritter_appendValue(Buffer& out, Uint32 x)

{

XmlWriter::append(out, x);

}

inline void _appendValue(Array<Sint8>& out, Sint32 x)

inline void _xmlWritter_appendValue(Buffer& out, Sint32 x)

{

XmlWriter::append(out, x);

}

inline void _appendValue(Array<Sint8>& out, Uint64 x)

inline void _xmlWritter_appendValue(Buffer& out, Uint64 x)

{

XmlWriter::append(out, x);

}

inline void _appendValue(Array<Sint8>& out, Sint64 x)

inline void _xmlWritter_appendValue(Buffer& out, Sint64 x)

{

XmlWriter::append(out, x);

}

inline void _appendValue(Array<Sint8>& out, Real32 x)

inline void _xmlWritter_appendValue(Buffer& out, Real32 x)

{

XmlWriter::append(out, Real64(x));

XmlWriter::append(out, x);

}

inline void _appendValue(Array<Sint8>& out, Real64 x)

inline void _xmlWritter_appendValue(Buffer& out, Real64 x)

{

XmlWriter::append(out, x);

}

inline void _appendValue(Array<Sint8>& out, const Char16& x)

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

{

XmlWriter::appendSpecial(out, x);

}

inline void _appendValue(Array<Sint8>& out, const String& x)

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

{

XmlWriter::appendSpecial(out, x);

}

inline void _appendValue(Array<Sint8>& out, const CIMDateTime& x)

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 _appendValue(Array<Sint8>& out, const CIMObjectPath& x)

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

{

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

}

void _appendValueArray(Array<Sint8>& out, const CIMObjectPath* p, Uint32 size)

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

{

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

String myStr = x.toString();

_xmlWritter_appendValue(out, myStr);

}

void _xmlWritter_appendValueArray(

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

{

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

while (size--)

{

_appendValue(out, *p++);

_xmlWritter_appendValue(out, *p++);

}

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

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

}

template<class T>

void _appendValueArray(Array<Sint8>& out, const T* p, Uint32 size)

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

_appendValue(out, *p++);

_xmlWritter_appendValue(out, *p++);

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

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

}

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

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

}

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

Line 604

Line 406

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

void XmlWriter::appendValueElement(

Array<Sint8>& out,

Buffer& out,

const CIMValue& value)

{

if (value.isNull())

Line 619

Line 421

{

Array<Boolean> a;

value.get(a);

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

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

break;

}

Line 627

Line 429

{

Array<Uint8> a;

value.get(a);

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

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

break;

}

Line 635

Line 437

{

Array<Sint8> a;

value.get(a);

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

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

break;

}

Line 643

Line 445

{

Array<Uint16> a;

value.get(a);

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

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

break;

}

Line 651

Line 453

{

Array<Sint16> a;

value.get(a);

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

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

break;

}

Line 659

Line 461

{

Array<Uint32> a;

value.get(a);

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

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

break;

}

Line 667

Line 469

{

Array<Sint32> a;

value.get(a);

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

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

break;

}

Line 675

Line 477

{

Array<Uint64> a;

value.get(a);

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

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

break;

}

Line 683

Line 485

{

Array<Sint64> a;

value.get(a);

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

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

break;

}

Line 691

Line 493

{

Array<Real32> a;

value.get(a);

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

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

break;

}

Line 699

Line 501

{

Array<Real64> a;

value.get(a);

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

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

break;

}

Line 707

Line 509

{

Array<Char16> a;

value.get(a);

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

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

break;

}

case CIMTYPE_STRING:

{

Array<String> a;

const String* data;

value.get(a);

Uint32 size;

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

value._get(data, size);

_xmlWritter_appendValueArray(out, data, size);

break;

}

Line 723

Line 526

{

Array<CIMDateTime> a;

value.get(a);

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

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

break;

}

Line 731

Line 534

{

Array<CIMObjectPath> a;

value.get(a);

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

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

break;

}

case CIMTYPE_OBJECT:

{

Array<CIMObject> a;

value.get(a);

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

}

Line 744

Line 561

// Has to be separate because it uses VALUE.REFERENCE tag

CIMObjectPath v;

value.get(v);

_appendValue(out, v);

_xmlWritter_appendValue(out, v);

}

else

{

out << "<VALUE>";

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

switch (value.getType())

{

Line 756

Line 573

{

Boolean v;

value.get(v);

_appendValue(out, v);

_xmlWritter_appendValue(out, v);

break;

}

Line 764

Line 581

{

Uint8 v;

value.get(v);

_appendValue(out, v);

_xmlWritter_appendValue(out, v);

break;

}

Line 772

Line 589

{

Sint8 v;

value.get(v);

_appendValue(out, v);

_xmlWritter_appendValue(out, v);

break;

}

Line 780

Line 597

{

Uint16 v;

value.get(v);

_appendValue(out, v);

_xmlWritter_appendValue(out, v);

break;

}

Line 788

Line 605

{

Sint16 v;

value.get(v);

_appendValue(out, v);

_xmlWritter_appendValue(out, v);

break;

}

Line 796

Line 613

{

Uint32 v;

value.get(v);

_appendValue(out, v);

_xmlWritter_appendValue(out, v);

break;

}

Line 804

Line 621

{

Sint32 v;

value.get(v);

_appendValue(out, v);

_xmlWritter_appendValue(out, v);

break;

}

Line 812

Line 629

{

Uint64 v;

value.get(v);

_appendValue(out, v);

_xmlWritter_appendValue(out, v);

break;

}

Line 820

Line 637

{

Sint64 v;

value.get(v);

_appendValue(out, v);

_xmlWritter_appendValue(out, v);

break;

}

Line 828

Line 645

{

Real32 v;

value.get(v);

_appendValue(out, v);

_xmlWritter_appendValue(out, v);

break;

}

Line 836

Line 653

{

Real64 v;

value.get(v);

_appendValue(out, v);

_xmlWritter_appendValue(out, v);

break;

}

Line 844

Line 661

{

Char16 v;

value.get(v);

_appendValue(out, v);

_xmlWritter_appendValue(out, v);

break;

}

Line 852

Line 669

{

String v;

value.get(v);

_appendValue(out, v);

_xmlWritter_appendValue(out, v);

break;

}

Line 860

Line 677

{

CIMDateTime v;

value.get(v);

_appendValue(out, v);

_xmlWritter_appendValue(out, v);

break;

}

case CIMTYPE_OBJECT:

{

CIMObject v;

value.get(v);

_xmlWritter_appendValue(out, v);

break;

}

case CIMTYPE_INSTANCE:

{

CIMInstance v;

value.get(v);

_xmlWritter_appendValue(out, v);

break;

}

default:

PEGASUS_ASSERT(false);

}

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

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

}

Line 876

Line 707

const CIMValue& value,

PEGASUS_STD(ostream)& os)

{

Array<Sint8> tmp;

Buffer tmp;

appendValueElement(tmp, value);

tmp.append('\0');

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

}

Line 892

Line 722

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

void XmlWriter::appendValueObjectWithPathElement(

Array<Sint8>& out,

Buffer& out,

const CIMObject& objectWithPath)

{

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

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

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

appendObjectElement(out, objectWithPath);

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

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

}

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

Line 914

Line 744

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

void XmlWriter::appendValueReferenceElement(

Array<Sint8>& out,

Buffer& out,

const CIMObjectPath& reference,

Boolean putValueWrapper)

{

if (putValueWrapper)

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

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

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

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

Line 930

Line 760

// key bindings

KeyBindingArray kbs = reference.getKeyBindings();

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

if (kbs.size())

{

Line 964

Line 794

}

if (putValueWrapper)

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

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

}

void XmlWriter::printValueReferenceElement(

const CIMObjectPath& reference,

PEGASUS_STD(ostream)& os)

{

Array<Sint8> tmp;

Buffer tmp;

appendValueReferenceElement(tmp, reference, true);

tmp.append('\0');

indentedPrint(os, tmp.getData());

}

Line 986

Line 815

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

void XmlWriter::appendValueNamedInstanceElement(

Array<Sint8>& out,

Buffer& out,

const CIMInstance& namedInstance)

{

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

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

appendInstanceNameElement(out, namedInstance.getPath ());

appendInstanceElement(out, namedInstance);

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

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

}

//EXP_PULL

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

// appendValueInstanceWithPathElement()

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

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

// EXP_PULL_TBD checkout the INSTANCEPATH vs NAMEDINSTANCE

void XmlWriter::appendValueInstanceWithPathElement(

Buffer& out,

const CIMInstance& namedInstance)

{

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

appendInstancePathElement(out, namedInstance.getPath ());

appendInstanceElement(out, namedInstance);

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

}

//EXP_PULL_END

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

// appendClassElement()

Line 1010

Line 860

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

void XmlWriter::appendClassElement(

Array<Sint8>& out,

Buffer& out,

const CIMConstClass& cimclass)

const CIMConstClass& cimClass)

{

cimclass._checkRep();

CheckRep(cimClass._rep);

cimclass._rep->toXml(out);

const CIMClassRep* rep = cimClass._rep;

// Class opening element:

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

<< rep->getClassName()

<< STRLIT("\" ");

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

{

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

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

const CIMConstClass& cimclass,

PEGASUS_STD(ostream)& os)

{

Array<Sint8> tmp;

Buffer tmp;

appendClassElement(tmp, cimclass);

tmp.append('\0');

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

}

Line 1039

Line 922

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

void XmlWriter::appendInstanceElement(

Array<Sint8>& out,

Buffer& out,

const CIMConstInstance& instance)

{

instance._checkRep();

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:

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

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

// Append Properties:

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

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

// Instance closing element:

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

}

void XmlWriter::printInstanceElement(

const CIMConstInstance& instance,

PEGASUS_STD(ostream)& os)

{

Array<Sint8> tmp;

Buffer tmp;

appendInstanceElement(tmp, instance);

tmp.append('\0');

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

}

Line 1065

Line 967

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

void XmlWriter::appendObjectElement(

Array<Sint8>& out,

Buffer& out,

const CIMConstObject& object)

{

if (object.isClass())

Line 1110

Line 1012

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

void XmlWriter::appendPropertyElement(

Array<Sint8>& out,

Buffer& out,

const CIMConstProperty& property)

{

property._checkRep();

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

}

void XmlWriter::printPropertyElement(

if (rep->getArraySize())

const CIMConstProperty& property,

PEGASUS_STD(ostream)& os)

{

Array<Sint8> tmp;

char buffer[32];

appendPropertyElement(tmp, property);

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

tmp.append('\0');

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

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

out.append('"');

}

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

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

{

// appendMethodElement()

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

out.append('"');

// <!ELEMENT METHOD (QUALIFIER*,

}

// (PARAMETER|PARAMETER.REFERENCE|PARAMETER.ARRAY|PARAMETER.REFARRAY)*)>

// <!ATTLIST METHOD

// %CIMName;

// %CIMType; #IMPLIED

// %ClassOrigin;

// %Propagated;>

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

void XmlWriter::appendMethodElement(

if (rep->getPropagated())

Array<Sint8>& out,

const CIMConstMethod& method)

{

method._checkRep();

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

method._rep->toXml(out);

}

void XmlWriter::printMethodElement(

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

const CIMConstMethod& method,

PEGASUS_STD(ostream)& os)

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)

{

Array<Sint8> tmp;

out << STRLIT("<PROPERTY.REFERENCE"

appendMethodElement(tmp, method);

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

tmp.append('\0');

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

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

{

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

out.append('"');

}

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

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

{

// appendParameterElement()

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

out.append('"');

// <!ELEMENT PARAMETER (QUALIFIER*)>

}

// <!ATTLIST PARAMETER

// %CIMName;

if (rep->getPropagated())

// %CIMType; #REQUIRED>

{

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

// <!ELEMENT PARAMETER.REFERENCE (QUALIFIER*)>

}

// <!ATTLIST PARAMETER.REFERENCE

// %CIMName;

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

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

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(

const CIMConstProperty& property,

PEGASUS_STD(ostream)& os)

{

Buffer tmp;

appendPropertyElement(tmp, property);

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

}

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

// appendMethodElement()

// <!ELEMENT METHOD (QUALIFIER*,

// (PARAMETER|PARAMETER.REFERENCE|PARAMETER.ARRAY|PARAMETER.REFARRAY)*)>

// <!ATTLIST METHOD

// %CIMName;

// %CIMType; #IMPLIED

// %ClassOrigin;

// %Propagated;>

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

void XmlWriter::appendMethodElement(

Buffer& out,

const CIMConstMethod& method)

{

CheckRep(method._rep);

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(

const CIMConstMethod& method,

PEGASUS_STD(ostream)& os)

{

Buffer tmp;

appendMethodElement(tmp, method);

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

}

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

// appendParameterElement()

// <!ELEMENT PARAMETER (QUALIFIER*)>

// <!ATTLIST PARAMETER

// %CIMName;

// %CIMType; #REQUIRED>

// <!ELEMENT PARAMETER.REFERENCE (QUALIFIER*)>

// <!ATTLIST PARAMETER.REFERENCE

// %CIMName;

// %ReferenceClass;>

// <!ELEMENT PARAMETER.ARRAY (QUALIFIER*)>

Line 1188

Line 1358

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

void XmlWriter::appendParameterElement(

Array<Sint8>& out,

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(

const CIMConstParameter& parameter,

PEGASUS_STD(ostream)& os)

{

Array<Sint8> tmp;

Buffer tmp;

appendParameterElement(tmp, parameter);

tmp.append('\0');

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

}

Line 1211

Line 1465

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

// <!ATTLIST PARAMVALUE

// %CIMName;>

// %CIMName;

// %EmbeddedObject; #IMPLIED

// %ParamType;>

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

void XmlWriter::appendParamValueElement(

Array<Sint8>& out,

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(

const CIMParamValue& paramValue,

PEGASUS_STD(ostream)& os)

{

Array<Sint8> tmp;

Buffer tmp;

appendParamValueElement(tmp, paramValue);

tmp.append('\0');

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

}

Line 1247

Line 1517

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

void XmlWriter::appendQualifierElement(

Array<Sint8>& out,

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(

const CIMConstQualifier& qualifier,

PEGASUS_STD(ostream)& os)

{

Array<Sint8> tmp;

Buffer tmp;

appendQualifierElement(tmp, qualifier);

tmp.append('\0');

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

}

Line 1279

Line 1564

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

void XmlWriter::appendQualifierDeclElement(

Array<Sint8>& out,

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(

const CIMConstQualifierDecl& qualifierDecl,

PEGASUS_STD(ostream)& os)

{

Array<Sint8> tmp;

Buffer tmp;

appendQualifierDeclElement(tmp, qualifierDecl);

tmp.append('\0');

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

}

Line 1305

Line 1613

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

Array<Sint8>& out,

Buffer& out,

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 1341

Line 1653

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

void XmlWriter::appendScopeElement(

Array<Sint8>& out,

Buffer& out,

const CIMScope & scope)

{

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

}

// l10n - added content language and accept language support to

// the header methods below

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

// appendMethodCallHeader()

Line 1382

Line 1697

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

void XmlWriter::appendMethodCallHeader(

Array<Sint8>& out,

Buffer& out,

const char* host,

const char* cimMethod,

const CIMName& cimMethod,

const String& cimObject,

const String& authenticationHeader,

Uint32 contentLength)

HttpMethod httpMethod,

const AcceptLanguageList& acceptLanguages,

const ContentLanguageList& contentLanguages,

Uint32 contentLength,

bool binaryRequest,

bool binaryResponse)

{

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

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

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

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

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

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

// If we kept M-Post we would have to retry with Post. Does not

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

// do that in client today. Permanent change is to retry until spec

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

// updated. This change is temp to finish tests or until the retry

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

// installed. Required because of change to wbemservices cimom

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

if (httpMethod == HTTP_METHOD_M_POST)

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

{

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

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

}

else

{

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

}

OUTPUT_CONTENTLENGTH(out, contentLength);

if (acceptLanguages.size() > 0)

{

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

}

if (contentLanguages.size() > 0)

{

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

STRLIT("\r\n");

}

#ifdef PEGASUS_DEBUG

// backdoor environment variable to turn OFF client requesting transfer

// encoding. The default is on. to turn off, set this variable to zero.

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

// a debugging/testing environment.

static const char *clientTransferEncodingOff =

getenv("PEGASUS_HTTP_TRANSFER_ENCODING_REQUEST");

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

{

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

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

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

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

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

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

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

}

else

{

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

out << STRLIT("CIMMethod: ")

<< encodeURICharacters(cimMethod.getString()) << STRLIT("\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");

}

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

// appendMethodResponseHeader()

// Build HTTP response header.

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

void XmlWriter::appendMethodResponseHeader(

Array<Sint8>& out,

Buffer& out,

Uint32 contentLength)

HttpMethod httpMethod,

const ContentLanguageList& contentLanguages,

Uint32 contentLength,

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

{

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

}

OUTPUT_CONTENTLENGTH(out, contentLength);

if (contentLanguages.size() > 0)

{

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

STRLIT("\r\n");

}

if (httpMethod == HTTP_METHOD_M_POST)

{

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

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

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

STAT_SERVERTIME

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

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

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

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

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

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

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

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

}

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

else

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

{

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

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

}

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

Line 1447

Line 1895

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

void XmlWriter::appendHttpErrorResponseHeader(

Array<Sint8>& out,

Buffer& out,

const String& status,

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 ": " << errorDetail << "\r\n";

}

out << "\r\n";

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

}

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

Line 1476

Line 1922

// Returns unauthorized message in the following format:

// HTTP/1.1 401 Unauthorized

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

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

// <HTML><HEAD>

// <TITLE>401 Unauthorized</TITLE>

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

Line 1487

Line 1933

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

void XmlWriter::appendUnauthorizedResponseHeader(

Array<Sint8>& out,

Buffer& out,

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

OUTPUT_CONTENTLENGTH(out, 0);

out << "\r\n";

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 1504

Line 1950

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

}

#ifdef PEGASUS_KERBEROS_AUTHENTICATION

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

// appendOKResponseHeader()

// Build HTTP authentication response header for unauthorized requests.

// Returns OK message in the following format:

// HTTP/1.1 200 OK

// Content-Length: 0

// WWW-Authenticate: Negotiate "token"

// <HTML><HEAD>

// <TITLE>200 OK</TITLE>

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

// <H2>TEST200 OK</H2>

// <HR>

// </BODY></HTML>

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

void XmlWriter::appendOKResponseHeader(

Buffer& out,

const String& content)

{

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

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.

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

// out << "<TITLE>" << "200 OK" << "</TITLE>\r\n";

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

// out << "<H2>TEST" << "200 OK" << "</H2>\r\n";

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

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

}

#endif

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

// _appendMessageElementBegin()

Line 1517

Line 2007

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

void XmlWriter::_appendMessageElementBegin(

Array<Sint8>& out,

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(

Array<Sint8>& out)

Buffer& out)

{

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

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

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

}

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

Line 1542

Line 2032

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

void XmlWriter::_appendSimpleReqElementBegin(

Array<Sint8>& out)

Buffer& out)

{

out << "<SIMPLEREQ>\n";

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

}

void XmlWriter::_appendSimpleReqElementEnd(

Array<Sint8>& out)

Buffer& out)

{

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

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

}

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

Line 1564

Line 2054

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

void XmlWriter::_appendMethodCallElementBegin(

Array<Sint8>& out,

Buffer& out,

const char* name)

const CIMName& name)

{

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

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

}

void XmlWriter::_appendMethodCallElementEnd(

Array<Sint8>& out)

Buffer& out)

{

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

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

}

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

Line 1587

Line 2077

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

void XmlWriter::_appendIMethodCallElementBegin(

Array<Sint8>& out,

Buffer& out,

const char* name)

const CIMName& name)

{

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

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

}

void XmlWriter::_appendIMethodCallElementEnd(

Array<Sint8>& out)

Buffer& out)

{

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

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

}

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

Line 1612

Line 2102

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

void XmlWriter::_appendIParamValueElementBegin(

Array<Sint8>& out,

Buffer& out,

const char* name)

{

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

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

}

void XmlWriter::_appendIParamValueElementEnd(

Array<Sint8>& out)

Buffer& out)

{

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

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

}

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

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

}

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

// _appendSimpleRspElementBegin()

// _appendSimpleRspElementEnd()

Line 1634

Line 2148

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

void XmlWriter::_appendSimpleRspElementBegin(

Array<Sint8>& out)

Buffer& out)

{

out << "<SIMPLERSP>\n";

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

}

void XmlWriter::_appendSimpleRspElementEnd(

Array<Sint8>& out)

Buffer& out)

{

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

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

}

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

Line 1656

Line 2170

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

void XmlWriter::_appendMethodResponseElementBegin(

Array<Sint8>& out,

Buffer& out,

const char* name)

const CIMName& name)

{

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

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

}

void XmlWriter::_appendMethodResponseElementEnd(

Array<Sint8>& out)

Buffer& out)

{

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

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

}

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

Line 1679

Line 2193

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

void XmlWriter::_appendIMethodResponseElementBegin(

Array<Sint8>& out,

Buffer& out,

const char* name)

const CIMName& name)

{

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

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

}

void XmlWriter::_appendIMethodResponseElementEnd(

Array<Sint8>& out)

Buffer& out)

{

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

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

}

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

Line 1698

Line 2212

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

void XmlWriter::_appendErrorElement(

Array<Sint8>& out,

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

}

else

out << STRLIT("/>");

}

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

// appendParamTypeAndEmbeddedObjAttrib

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

// %EmbeddedObject; #IMPLIED

// %ParamType;>

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

void XmlWriter::appendParamTypeAndEmbeddedObjAttrib(

Buffer& out,

const CIMType& type)

{

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

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

" EmbeddedObject=\"object\""

" EMBEDDEDOBJECT=\"object\"");

}

else if (type == CIMTYPE_INSTANCE)

{

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

" EmbeddedObject=\"instance\""

" EMBEDDEDOBJECT=\"instance\"");

}

else

{

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

}

out << "/>";

}

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

Line 1721

Line 2293

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

// <!ATTLIST RETURNVALUE

// %EmbeddedObject; #IMPLIED

// %ParamType;>

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

void XmlWriter::appendReturnValueElement(

Array<Sint8>& out,

Buffer& out,

const CIMValue& value)

{

out << "<RETURNVALUE";

out << STRLIT("<RETURNVALUE");

CIMType type = value.getType();

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

out << ">\n";

appendParamTypeAndEmbeddedObjAttrib(out, type);

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

// Add value.

appendValueElement(out, value);

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

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

}

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

Line 1754

Line 2328

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

void XmlWriter::_appendIReturnValueElementBegin(

Array<Sint8>& out)

Buffer& out)

{

out << "<IRETURNVALUE>\n";

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

}

void XmlWriter::_appendIReturnValueElementEnd(

Array<Sint8>& out)

Buffer& out)

{

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

}

//EXP_PULL_BEGIN

void XmlWriter::_appendIReturnValueElementWithNameBegin(

Buffer& out,

const char* name)

{

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

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

}

//EXP_PULL_END

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

Line 1772

Line 2355

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

void XmlWriter::appendBooleanIParameter(

Array<Sint8>& out,

Buffer& out,

const char* name,

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

}

// 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::appendUint32IParameter(

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 1790

Line 2444

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

void XmlWriter::appendStringIParameter(

Array<Sint8>& out,

Buffer& out,

const char* name,

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

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

// appendQualifierNameIParameter()

// appendStringIParameterIfNotEmpty()

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

void XmlWriter::appendQualifierNameIParameter(

void XmlWriter::appendStringIParameterIfNotEmpty(

Array<Sint8>& out,

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

}

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

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

// appendStringParameter()

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

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

void XmlWriter::appendClassNameIParameter(

Array<Sint8>& out,

Buffer& out,

const char* name,

const String& className)

const CIMName& className)

{

_appendIParamValueElementBegin(out, name);

// A NULL (unassigned) value for a parameter is specified by an

// <IPARAMVALUE> element with no subelement

if (!className.isNull ())

{

appendClassNameElement(out, className);

}

_appendIParamValueElementEnd(out);

}

Line 1848

Line 2541

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

void XmlWriter::appendInstanceNameIParameter(

Array<Sint8>& out,

Buffer& out,

const char* name,

const CIMObjectPath& instanceName)

{

Line 1858

Line 2551

}

void XmlWriter::appendObjectNameIParameter(

Array<Sint8>& out,

Buffer& out,

const char* name,

const CIMObjectPath& objectName)

{

Line 1887

Line 2580

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

void XmlWriter::appendClassIParameter(

Array<Sint8>& out,

Buffer& out,

const char* name,

const CIMConstClass& cimClass)

{

Line 1903

Line 2596

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

void XmlWriter::appendInstanceIParameter(

Array<Sint8>& out,

Buffer& out,

const char* name,

const CIMConstInstance& instance)

{

Line 1919

Line 2612

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

void XmlWriter::appendNamedInstanceIParameter(

Array<Sint8>& out,

Buffer& out,

const char* name,

const CIMInstance& namedInstance)

{

Line 1938

Line 2631

// USE: Create parameter for getProperty operation

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

void XmlWriter::appendPropertyNameIParameter(

Array<Sint8>& out,

Buffer& out,

const String& propertyName)

const CIMName& propertyName)

{

_appendIParamValueElementBegin(out, "PropertyName");

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

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

_appendIParamValueElementEnd(out);

}

Line 1953

Line 2646

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

void XmlWriter::appendPropertyValueIParameter(

Array<Sint8>& out,

Buffer& out,

const char* name,

const CIMValue& value)

{

Line 1969

Line 2662

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

void XmlWriter::appendPropertyListIParameter(

Array<Sint8>& out,

Buffer& out,

const CIMPropertyList& propertyList)

{

// ATTN: P3 KS 4 Mar 2002 - As check shouldn't we check for null property list

_appendIParamValueElementBegin(out, "PropertyList");

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

// A NULL (unassigned) value for a parameter is specified by an

// <IPARAMVALUE> element with no subelement

if (!propertyList.isNull ())

{

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

}

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

_appendIParamValueElementEnd(out);

}

Line 1992

Line 2691

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

void XmlWriter::appendQualifierDeclarationIParameter(

Array<Sint8>& out,

Buffer& out,

const char* name,

const CIMConstQualifierDecl& qualifierDecl)

{

Line 2007

Line 2706

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

Array<Sint8> XmlWriter::formatHttpErrorRspMessage(

Buffer XmlWriter::formatHttpErrorRspMessage(

const String& status,

const String& cimError,

const String& errorDetail)

{

Array<Sint8> out;

Buffer out;

appendHttpErrorResponseHeader(out, status, cimError, errorDetail);

return out;

}

// l10n - add content language support to the format methods below

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

// XmlWriter::formatSimpleMethodReqMessage()

Line 2026

Line 2727

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

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

Array<Sint8> XmlWriter::formatSimpleMethodReqMessage(

Buffer XmlWriter::formatSimpleMethodReqMessage(

const char* host,

const String& nameSpace,

const CIMNamespaceName& nameSpace,

const CIMObjectPath& path,

const char* methodName,

const CIMName& methodName,

const Array<CIMParamValue>& parameters,

const String& messageId,

const String& authenticationHeader)

HttpMethod httpMethod,

const String& authenticationHeader,

const AcceptLanguageList& httpAcceptLanguages,

const ContentLanguageList& httpContentLanguages,

bool binaryResponse)

{

Array<Sint8> out;

Buffer out;

Array<Sint8> tmp;

Buffer tmp;

CIMObjectPath localObjectPath = path;

localObjectPath.setNameSpace(nameSpace);

localObjectPath.setNameSpace(nameSpace.getString());

localObjectPath.setHost(String::EMPTY);

_appendMessageElementBegin(out, messageId);

Line 2059

Line 2764

methodName,

localObjectPath.toString(),

authenticationHeader,

out.size());

httpMethod,

httpAcceptLanguages,

httpContentLanguages,

out.size(),

false,

binaryResponse);

tmp << out;

return tmp;

}

Array<Sint8> XmlWriter::formatSimpleMethodRspMessage(

Buffer XmlWriter::formatSimpleMethodRspMessage(

const char* methodName,

const CIMName& methodName,

const String& messageId,

const Array<Sint8>& body)

HttpMethod httpMethod,

{

const ContentLanguageList& httpContentLanguages,

Array<Sint8> out;

const Buffer& bodyParams,

Array<Sint8> tmp;

const Buffer& body,

Uint64 serverResponseTime,

Boolean isFirst,

Boolean isLast)

{

Buffer out;

if (isFirst == true)

{

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

_appendMessageElementBegin(out, messageId);

_appendSimpleRspElementBegin(out);

_appendMethodResponseElementBegin(out, methodName);

}

if (body.size() != 0)

{

out << body;

}

if (isLast == true)

{

_appendMethodResponseElementEnd(out);

_appendSimpleRspElementEnd(out);

_appendMessageElementEnd(out);

}

appendMethodResponseHeader(tmp, out.size());

return out;

tmp << out;

return tmp;

}

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

// XmlWriter::formatSimpleMethodErrorRspMessage()

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

Array<Sint8> XmlWriter::formatSimpleMethodErrorRspMessage(

Buffer XmlWriter::formatSimpleMethodErrorRspMessage(

const String& methodName,

const CIMName& methodName,

const String& messageId,

HttpMethod httpMethod,

const CIMException& cimException)

{

Array<Sint8> out;

Buffer out;

Array<Sint8> tmp;

Buffer tmp;

_appendMessageElementBegin(out, messageId);

_appendSimpleRspElementBegin(out);

_appendMethodResponseElementBegin(out, methodName.getCString());

_appendMethodResponseElementBegin(out, methodName);

_appendErrorElement(out, cimException);

_appendMethodResponseElementEnd(out);

_appendSimpleRspElementEnd(out);

_appendMessageElementEnd(out);

appendMethodResponseHeader(tmp, out.size());

appendMethodResponseHeader(

tmp,

httpMethod,

cimException.getContentLanguages(),

out.size(),

false);

tmp << out;

return tmp;

Line 2121

Line 2855

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

Array<Sint8> XmlWriter::formatSimpleIMethodReqMessage(

Buffer XmlWriter::formatSimpleIMethodReqMessage(

const char* host,

const String& nameSpace,

const CIMNamespaceName& nameSpace,

const char* iMethodName,

const CIMName& iMethodName,

const String& messageId,

HttpMethod httpMethod,

const String& authenticationHeader,

const Array<Sint8>& body)

const AcceptLanguageList& httpAcceptLanguages,

const ContentLanguageList& httpContentLanguages,

const Buffer& body,

bool binaryResponse)

{

Array<Sint8> out;

Buffer out;

Array<Sint8> tmp;

Buffer tmp;

_appendMessageElementBegin(out, messageId);

_appendSimpleReqElementBegin(out);

_appendIMethodCallElementBegin(out, iMethodName);

appendLocalNameSpacePathElement(out, nameSpace);

appendLocalNameSpacePathElement(out, nameSpace.getString());

out << body;

_appendIMethodCallElementEnd(out);

_appendSimpleReqElementEnd(out);

Line 2145

Line 2883

tmp,

host,

iMethodName,

nameSpace,

nameSpace.getString(),

authenticationHeader,

out.size());

httpMethod,

httpAcceptLanguages,

httpContentLanguages,

out.size(),

false,

binaryResponse);

tmp << out;

return tmp;

Line 2159

Line 2902

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

Array<Sint8> XmlWriter::formatSimpleIMethodRspMessage(

const char* iMethodName,

Formats a IMethod Response Message. Note that 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,

const Array<Sint8>& body)

HttpMethod httpMethod,

{

const ContentLanguageList& httpContentLanguages,

Array<Sint8> out;

const Buffer& rtnParams,

Array<Sint8> tmp;

const Buffer& body,

Uint64 serverResponseTime,

Boolean isFirst,

Boolean isLast)

{

Buffer out;

if (isFirst == true)

{

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

_appendMessageElementBegin(out, messageId);

_appendSimpleRspElementBegin(out);

_appendIMethodResponseElementBegin(out, iMethodName);

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

// are empty, then this generates and empty response.

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

_appendIReturnValueElementBegin(out);

}

if (body.size() != 0)

{

_appendIReturnValueElementBegin(out);

out << body;

}

if (isLast == true)

{

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

_appendIReturnValueElementEnd(out);

// EXP_PULL

// If there are any parameters include them here.

// Assumes that it is prebuilt with all components

if (rtnParams.size() != 0)

{

out << rtnParams;

}

// //EXP_PULL_END

_appendIMethodResponseElementEnd(out);

_appendSimpleRspElementEnd(out);

_appendMessageElementEnd(out);

}

appendMethodResponseHeader(tmp, out.size());

return out;

tmp << out;

return tmp;

}

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

// XmlWriter::formatSimpleIMethodErrorRspMessage()

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

Array<Sint8> XmlWriter::formatSimpleIMethodErrorRspMessage(

Buffer XmlWriter::formatSimpleIMethodErrorRspMessage(

const String& iMethodName,

const CIMName& iMethodName,

const String& messageId,

HttpMethod httpMethod,

const CIMException& cimException)

{

Array<Sint8> out;

Buffer out;

Array<Sint8> tmp;

Buffer tmp;

_appendMessageElementBegin(out, messageId);

_appendSimpleRspElementBegin(out);

_appendIMethodResponseElementBegin(out, iMethodName.getCString());

_appendIMethodResponseElementBegin(out, iMethodName);

_appendErrorElement(out, cimException);

_appendIMethodResponseElementEnd(out);

_appendSimpleRspElementEnd(out);

_appendMessageElementEnd(out);

appendMethodResponseHeader(tmp, out.size());

appendMethodResponseHeader(tmp,

httpMethod,

cimException.getContentLanguages(),

out.size(), false);

tmp << out;

return tmp;

Line 2229

Line 3021

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

void XmlWriter::appendEMethodRequestHeader(

Array<Sint8>& out,

Buffer& out,

const char* requestUri,

const char* host,

const char* cimMethod,

const CIMName& cimMethod,

HttpMethod httpMethod,

const String& authenticationHeader,

const AcceptLanguageList& acceptLanguages,

const ContentLanguageList& contentLanguages,

Uint32 contentLength)

{

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

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

if (httpMethod == HTTP_METHOD_M_POST)

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

{

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

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

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

}

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

else

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

{

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

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

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

}

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

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

OUTPUT_CONTENTLENGTH(out, contentLength);

if (acceptLanguages.size() > 0)

{

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

}

if (contentLanguages.size() > 0)

{

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

STRLIT("\r\n");

}

#ifdef PEGASUS_DEBUG

// backdoor environment variable to turn OFF client requesting transfer

// encoding. The default is on. to turn off, set this variable to zero.

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

// a debugging/testing environment.

static const char *clientTransferEncodingOff =

getenv("PEGASUS_HTTP_TRANSFER_ENCODING_REQUEST");

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

#endif

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

if (httpMethod == HTTP_METHOD_M_POST)

{

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

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

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

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

STRLIT("\r\n");

}

else

{

out << STRLIT("CIMExport: MethodRequest\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 2262

Line 3098

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

void XmlWriter::appendEMethodResponseHeader(

Array<Sint8>& out,

Buffer& out,

HttpMethod httpMethod,

const ContentLanguageList& contentLanguages,

Uint32 contentLength)

{

char nn[] = { '0' + (rand() % 10), '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");

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

OUTPUT_CONTENTLENGTH(out, contentLength);

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

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

if (contentLanguages.size() > 0)

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

{

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

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

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

STRLIT("\r\n");

}

if (httpMethod == HTTP_METHOD_M_POST)

{

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("-CIMExport: MethodResponse\r\n\r\n");

}

else

{

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

}

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

Line 2287

Line 3138

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

void XmlWriter::_appendSimpleExportReqElementBegin(

Array<Sint8>& out)

Buffer& out)

{

out << "<SIMPLEEXPREQ>\n";

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

}

void XmlWriter::_appendSimpleExportReqElementEnd(

Array<Sint8>& out)

Buffer& out)

{

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

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

}

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

Line 2309

Line 3160

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

void XmlWriter::_appendEMethodCallElementBegin(

Array<Sint8>& out,

Buffer& out,

const char* name)

const CIMName& name)

{

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

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

}

void XmlWriter::_appendEMethodCallElementEnd(

Array<Sint8>& out)

Buffer& out)

{

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

}

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

// _appendEParamValueElementBegin()

// _appendEParamValueElementEnd()

// <!ELEMENT EXPPARAMVALUE (INSTANCE)>

// <!ATTLIST EXPPARAMVALUE

// %CIMName;>

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

void XmlWriter::_appendEParamValueElementBegin(

Buffer& out,

const char* name)

{

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

}

void XmlWriter::_appendEParamValueElementEnd(

Buffer& out)

{

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

}

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

// appendInstanceEParameter()

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

void XmlWriter::appendInstanceEParameter(

Buffer& out,

const char* name,

const CIMInstance& instance)

{

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

_appendEParamValueElementBegin(out, name);

appendInstanceElement(out, instance);

_appendEParamValueElementEnd(out);

}

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

Line 2331

Line 3222

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

void XmlWriter::_appendSimpleExportRspElementBegin(

Array<Sint8>& out)

Buffer& out)

{

out << "<SIMPLEEXPRSP>\n";

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

}

void XmlWriter::_appendSimpleExportRspElementEnd(

Array<Sint8>& out)

Buffer& out)

{

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

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

}

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

Line 2353

Line 3244

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

void XmlWriter::_appendEMethodResponseElementBegin(

Array<Sint8>& out,

Buffer& out,

const char* name)

const CIMName& name)

{

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

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

}

void XmlWriter::_appendEMethodResponseElementEnd(

Array<Sint8>& out)

Buffer& out)

{

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

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

}

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

Line 2371

Line 3262

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

Array<Sint8> XmlWriter::formatSimpleEMethodReqMessage(

Buffer XmlWriter::formatSimpleEMethodReqMessage(

const char* requestUri,

const char* host,

const char* eMethodName,

const CIMName& eMethodName,

const String& messageId,

HttpMethod httpMethod,

const String& authenticationHeader,

const Array<Sint8>& body)

const AcceptLanguageList& httpAcceptLanguages,

const ContentLanguageList& httpContentLanguages,

const Buffer& body)

{

Array<Sint8> out;

Buffer out;

Array<Sint8> tmp;

Buffer tmp;

_appendMessageElementBegin(out, messageId);

_appendSimpleExportReqElementBegin(out);

Line 2395

Line 3289

requestUri,

host,

eMethodName,

httpMethod,

authenticationHeader,

httpAcceptLanguages,

httpContentLanguages,

out.size());

tmp << out;

Line 2408

Line 3305

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

Array<Sint8> XmlWriter::formatSimpleEMethodRspMessage(

Buffer XmlWriter::formatSimpleEMethodRspMessage(

const char* eMethodName,

const CIMName& eMethodName,

const String& messageId,

const Array<Sint8>& body)

HttpMethod httpMethod,

const ContentLanguageList& httpContentLanguages,

const Buffer& body)

{

Array<Sint8> out;

Buffer out;

Array<Sint8> tmp;

Buffer tmp;

_appendMessageElementBegin(out, messageId);

_appendSimpleExportRspElementBegin(out);

Line 2424

Line 3323

_appendSimpleExportRspElementEnd(out);

_appendMessageElementEnd(out);

appendEMethodResponseHeader(tmp, out.size());

appendEMethodResponseHeader(tmp,

httpMethod,

httpContentLanguages,

out.size());

tmp << out;

return tmp;

Line 2436

Line 3338

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

Array<Sint8> XmlWriter::formatSimpleEMethodErrorRspMessage(

Buffer XmlWriter::formatSimpleEMethodErrorRspMessage(

const String& eMethodName,

const CIMName& eMethodName,

const String& messageId,

HttpMethod httpMethod,

const CIMException& cimException)

{

Array<Sint8> out;

Buffer out;

Array<Sint8> tmp;

Buffer tmp;

_appendMessageElementBegin(out, messageId);

_appendSimpleExportRspElementBegin(out);

_appendEMethodResponseElementBegin(out, eMethodName.getCString());

_appendEMethodResponseElementBegin(out, eMethodName);

_appendErrorElement(out, cimException);

_appendEMethodResponseElementEnd(out);

_appendSimpleExportRspElementEnd(out);

_appendMessageElementEnd(out);

appendEMethodResponseHeader(tmp, out.size());

appendEMethodResponseHeader(

tmp,

httpMethod,

cimException.getContentLanguages(),

out.size());

tmp << out;

return tmp;

Line 2460

Line 3367

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

// _printAttributes()

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

static void _printAttributes(

PEGASUS_STD(ostream)& os,

const XmlAttribute* attributes,

Uint32 attributeCount)

{

for (Uint32 i = 0; i < attributeCount; i++)

{

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

os << '"';

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

os << '"';

if (i + 1 != attributeCount)

os << ' ';

}

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

// _indent()

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

static void _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)

{

char* tmp = strcpy(new char[strlen(text) + 1], text);

XmlParser parser(tmp);

XmlEntry entry;

Stack<const char*> stack;

while (parser.next(entry))

{

switch (entry.type)

{

case XmlEntry::XML_DECLARATION:

{

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

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

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

os << "?>";

break;

}

case XmlEntry::START_TAG:

{

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

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

if (entry.attributeCount)

os << ' ';

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

os << ">";

stack.push(entry.text);

break;

}

case XmlEntry::EMPTY_TAG:

{

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

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

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

os << "/>";

break;

}

case XmlEntry::END_TAG:

{

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

stack.pop();

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

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

break;

}

case XmlEntry::COMMENT:

{

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

os << "<!--";

_appendSpecial(os, entry.text);

os << "-->";

break;

}

case XmlEntry::CONTENT:

{

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

_appendSpecial(os, entry.text);

break;

}

case XmlEntry::CDATA:

{

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

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

break;

}

case XmlEntry::DOCTYPE:

{

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

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

break;

}

os << PEGASUS_STD(endl);

}

delete [] tmp;

}

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

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

Line 3388

// XmlWriter::keyBindingTypeToString

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

const char* XmlWriter::keyBindingTypeToString (KeyBinding::Type type)

const StrLit XmlWriter::keyBindingTypeToString (CIMKeyBinding::Type type)

{

switch (type)

{

case KeyBinding::BOOLEAN:

case CIMKeyBinding::BOOLEAN:

return "boolean";

return STRLIT("boolean");

case KeyBinding::STRING:

case CIMKeyBinding::STRING:

return "string";

return STRLIT("string");

case KeyBinding::NUMERIC:

case CIMKeyBinding::NUMERIC:

return "numeric";

return STRLIT("numeric");

case KeyBinding::REFERENCE:

case CIMKeyBinding::REFERENCE:

default:

PEGASUS_ASSERT(false);

}

return "unknown";

return STRLIT("unknown");

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.78
changed lines
	Added in v.1.169.4.1

No CVS admin address has been configured