version 1.57, 2002/05/15 20:04:10
|
version 1.67, 2002/07/30 16:14:53
|
|
|
//%///////////////////////////////////////////////////////////////////////////// | //%///////////////////////////////////////////////////////////////////////////// |
// | // |
// Copyright (c) 2000, 2001 BMC Software, Hewlett-Packard Company, IBM, |
// Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM, |
// The Open Group, Tivoli Systems | // The Open Group, Tivoli Systems |
// | // |
// Permission is hereby granted, free of charge, to any person obtaining a copy | // Permission is hereby granted, free of charge, to any person obtaining a copy |
|
|
// Modified By: Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com) | // Modified By: Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com) |
// Nag Boranna, Hewlett-Packard Company (nagaraja_boranna@hp.com) | // Nag Boranna, Hewlett-Packard Company (nagaraja_boranna@hp.com) |
// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com) | // Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com) |
|
// Carol Ann Krug Graves, Hewlett-Packard Company |
|
// (carolann_graves@hp.com) |
// | // |
//%///////////////////////////////////////////////////////////////////////////// | //%///////////////////////////////////////////////////////////////////////////// |
| |
|
|
| |
void XmlWriter::append(Array<Sint8>& out, const String& str) | void XmlWriter::append(Array<Sint8>& out, const String& str) |
{ | { |
const Char16* tmp = str.getData(); |
for (Uint32 i = 0; i < str.size(); i++) |
|
{ |
while (*tmp) |
_appendChar(out, str[i]); |
_appendChar(out, *tmp++); |
} |
} | } |
| |
void XmlWriter::append(Array<Sint8>& out, const Indentor& x) | void XmlWriter::append(Array<Sint8>& out, const Indentor& x) |
|
|
| |
void XmlWriter::appendSpecial(Array<Sint8>& out, const String& str) | void XmlWriter::appendSpecial(Array<Sint8>& out, const String& str) |
{ | { |
const Char16* tmp = str.getData(); |
for (Uint32 i = 0; i < str.size(); i++) |
|
{ |
while (*tmp) |
_appendSpecialChar(out, str[i]); |
_appendSpecialChar(out, *tmp++); |
} |
} | } |
| |
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
|
|
| |
void XmlWriter::appendInstanceNameElement( | void XmlWriter::appendInstanceNameElement( |
Array<Sint8>& out, | Array<Sint8>& out, |
const CIMReference& instanceName) |
const CIMObjectPath& instanceName) |
{ | { |
out << "<INSTANCENAME CLASSNAME=\"" << instanceName.getClassName() << "\">\n"; | out << "<INSTANCENAME CLASSNAME=\"" << instanceName.getClassName() << "\">\n"; |
| |
|
|
| |
if (keyBindings[i].getType() == KeyBinding::REFERENCE) | if (keyBindings[i].getType() == KeyBinding::REFERENCE) |
{ | { |
CIMReference ref = keyBindings[i].getValue(); |
CIMObjectPath ref = keyBindings[i].getValue(); |
appendValueReferenceElement(out, ref, true); | appendValueReferenceElement(out, ref, true); |
} | } |
else { | else { |
|
|
| |
void XmlWriter::appendClassPathElement( | void XmlWriter::appendClassPathElement( |
Array<Sint8>& out, | Array<Sint8>& out, |
const CIMReference& classPath) |
const CIMObjectPath& classPath) |
{ | { |
out << "<CLASSPATH>\n"; | out << "<CLASSPATH>\n"; |
appendNameSpacePathElement(out, | appendNameSpacePathElement(out, |
|
|
| |
void XmlWriter::appendInstancePathElement( | void XmlWriter::appendInstancePathElement( |
Array<Sint8>& out, | Array<Sint8>& out, |
const CIMReference& instancePath) |
const CIMObjectPath& instancePath) |
{ | { |
out << "<INSTANCEPATH>\n"; | out << "<INSTANCEPATH>\n"; |
appendNameSpacePathElement(out, | appendNameSpacePathElement(out, |
|
|
| |
void XmlWriter::appendLocalClassPathElement( | void XmlWriter::appendLocalClassPathElement( |
Array<Sint8>& out, | Array<Sint8>& out, |
const CIMReference& classPath) |
const CIMObjectPath& classPath) |
{ | { |
out << "<LOCALCLASSPATH>\n"; | out << "<LOCALCLASSPATH>\n"; |
appendLocalNameSpacePathElement(out, classPath.getNameSpace()); | appendLocalNameSpacePathElement(out, classPath.getNameSpace()); |
|
|
| |
void XmlWriter::appendLocalInstancePathElement( | void XmlWriter::appendLocalInstancePathElement( |
Array<Sint8>& out, | Array<Sint8>& out, |
const CIMReference& instancePath) |
const CIMObjectPath& instancePath) |
{ | { |
out << "<LOCALINSTANCEPATH>\n"; | out << "<LOCALINSTANCEPATH>\n"; |
appendLocalNameSpacePathElement(out, instancePath.getNameSpace()); | appendLocalNameSpacePathElement(out, instancePath.getNameSpace()); |
|
|
| |
void XmlWriter::appendLocalObjectPathElement( | void XmlWriter::appendLocalObjectPathElement( |
Array<Sint8>& out, | Array<Sint8>& out, |
const CIMReference& objectPath) |
const CIMObjectPath& objectPath) |
{ | { |
if (objectPath.isInstanceName()) | if (objectPath.isInstanceName()) |
{ | { |
|
|
out << x.getString(); //ATTN: append() method? | out << x.getString(); //ATTN: append() method? |
} | } |
| |
inline void _appendValue(Array<Sint8>& out, const CIMReference& x) |
inline void _appendValue(Array<Sint8>& out, const CIMObjectPath& x) |
{ | { |
XmlWriter::appendValueReferenceElement(out, x, true); | XmlWriter::appendValueReferenceElement(out, x, true); |
} | } |
| |
void _appendValueArray(Array<Sint8>& out, const CIMReference* p, Uint32 size) |
void _appendValueArray(Array<Sint8>& out, const CIMObjectPath* p, Uint32 size) |
{ | { |
out << "<VALUE.REFARRAY>\n"; | out << "<VALUE.REFARRAY>\n"; |
while (size--) | while (size--) |
|
|
{ | { |
switch (value.getType()) | switch (value.getType()) |
{ | { |
case CIMType::BOOLEAN: |
case CIMTYPE_BOOLEAN: |
{ | { |
Array<Boolean> a; | Array<Boolean> a; |
value.get(a); | value.get(a); |
|
|
break; | break; |
} | } |
| |
case CIMType::UINT8: |
case CIMTYPE_UINT8: |
{ | { |
Array<Uint8> a; | Array<Uint8> a; |
value.get(a); | value.get(a); |
|
|
break; | break; |
} | } |
| |
case CIMType::SINT8: |
case CIMTYPE_SINT8: |
{ | { |
Array<Sint8> a; | Array<Sint8> a; |
value.get(a); | value.get(a); |
|
|
break; | break; |
} | } |
| |
case CIMType::UINT16: |
case CIMTYPE_UINT16: |
{ | { |
Array<Uint16> a; | Array<Uint16> a; |
value.get(a); | value.get(a); |
|
|
break; | break; |
} | } |
| |
case CIMType::SINT16: |
case CIMTYPE_SINT16: |
{ | { |
Array<Sint16> a; | Array<Sint16> a; |
value.get(a); | value.get(a); |
|
|
break; | break; |
} | } |
| |
case CIMType::UINT32: |
case CIMTYPE_UINT32: |
{ | { |
Array<Uint32> a; | Array<Uint32> a; |
value.get(a); | value.get(a); |
|
|
break; | break; |
} | } |
| |
case CIMType::SINT32: |
case CIMTYPE_SINT32: |
{ | { |
Array<Sint32> a; | Array<Sint32> a; |
value.get(a); | value.get(a); |
|
|
break; | break; |
} | } |
| |
case CIMType::UINT64: |
case CIMTYPE_UINT64: |
{ | { |
Array<Uint64> a; | Array<Uint64> a; |
value.get(a); | value.get(a); |
|
|
break; | break; |
} | } |
| |
case CIMType::SINT64: |
case CIMTYPE_SINT64: |
{ | { |
Array<Sint64> a; | Array<Sint64> a; |
value.get(a); | value.get(a); |
|
|
break; | break; |
} | } |
| |
case CIMType::REAL32: |
case CIMTYPE_REAL32: |
{ | { |
Array<Real32> a; | Array<Real32> a; |
value.get(a); | value.get(a); |
|
|
break; | break; |
} | } |
| |
case CIMType::REAL64: |
case CIMTYPE_REAL64: |
{ | { |
Array<Real64> a; | Array<Real64> a; |
value.get(a); | value.get(a); |
|
|
break; | break; |
} | } |
| |
case CIMType::CHAR16: |
case CIMTYPE_CHAR16: |
{ | { |
Array<Char16> a; | Array<Char16> a; |
value.get(a); | value.get(a); |
|
|
break; | break; |
} | } |
| |
case CIMType::STRING: |
case CIMTYPE_STRING: |
{ | { |
Array<String> a; | Array<String> a; |
value.get(a); | value.get(a); |
|
|
break; | break; |
} | } |
| |
case CIMType::DATETIME: |
case CIMTYPE_DATETIME: |
{ | { |
Array<CIMDateTime> a; | Array<CIMDateTime> a; |
value.get(a); | value.get(a); |
|
|
break; | break; |
} | } |
| |
case CIMType::REFERENCE: |
case CIMTYPE_REFERENCE: |
{ | { |
Array<CIMReference> a; |
Array<CIMObjectPath> a; |
value.get(a); | value.get(a); |
_appendValueArray(out, a.getData(), a.size()); | _appendValueArray(out, a.getData(), a.size()); |
break; | break; |
|
|
throw CIMValueInvalidType(); | throw CIMValueInvalidType(); |
} | } |
} | } |
else if (value.getType() == CIMType::REFERENCE) |
else if (value.getType() == CIMTYPE_REFERENCE) |
{ | { |
// Has to be separate because it uses VALUE.REFERENCE tag | // Has to be separate because it uses VALUE.REFERENCE tag |
CIMReference v; |
CIMObjectPath v; |
value.get(v); | value.get(v); |
_appendValue(out, v); | _appendValue(out, v); |
} | } |
|
|
| |
switch (value.getType()) | switch (value.getType()) |
{ | { |
case CIMType::BOOLEAN: |
case CIMTYPE_BOOLEAN: |
{ | { |
Boolean v; | Boolean v; |
value.get(v); | value.get(v); |
|
|
break; | break; |
} | } |
| |
case CIMType::UINT8: |
case CIMTYPE_UINT8: |
{ | { |
Uint8 v; | Uint8 v; |
value.get(v); | value.get(v); |
|
|
break; | break; |
} | } |
| |
case CIMType::SINT8: |
case CIMTYPE_SINT8: |
{ | { |
Sint8 v; | Sint8 v; |
value.get(v); | value.get(v); |
|
|
break; | break; |
} | } |
| |
case CIMType::UINT16: |
case CIMTYPE_UINT16: |
{ | { |
Uint16 v; | Uint16 v; |
value.get(v); | value.get(v); |
|
|
break; | break; |
} | } |
| |
case CIMType::SINT16: |
case CIMTYPE_SINT16: |
{ | { |
Sint16 v; | Sint16 v; |
value.get(v); | value.get(v); |
|
|
break; | break; |
} | } |
| |
case CIMType::UINT32: |
case CIMTYPE_UINT32: |
{ | { |
Uint32 v; | Uint32 v; |
value.get(v); | value.get(v); |
|
|
break; | break; |
} | } |
| |
case CIMType::SINT32: |
case CIMTYPE_SINT32: |
{ | { |
Sint32 v; | Sint32 v; |
value.get(v); | value.get(v); |
|
|
break; | break; |
} | } |
| |
case CIMType::UINT64: |
case CIMTYPE_UINT64: |
{ | { |
Uint64 v; | Uint64 v; |
value.get(v); | value.get(v); |
|
|
break; | break; |
} | } |
| |
case CIMType::SINT64: |
case CIMTYPE_SINT64: |
{ | { |
Sint64 v; | Sint64 v; |
value.get(v); | value.get(v); |
|
|
break; | break; |
} | } |
| |
case CIMType::REAL32: |
case CIMTYPE_REAL32: |
{ | { |
Real32 v; | Real32 v; |
value.get(v); | value.get(v); |
|
|
break; | break; |
} | } |
| |
case CIMType::REAL64: |
case CIMTYPE_REAL64: |
{ | { |
Real64 v; | Real64 v; |
value.get(v); | value.get(v); |
|
|
break; | break; |
} | } |
| |
case CIMType::CHAR16: |
case CIMTYPE_CHAR16: |
{ | { |
Char16 v; | Char16 v; |
value.get(v); | value.get(v); |
|
|
break; | break; |
} | } |
| |
case CIMType::STRING: |
case CIMTYPE_STRING: |
{ | { |
String v; | String v; |
value.get(v); | value.get(v); |
|
|
break; | break; |
} | } |
| |
case CIMType::DATETIME: |
case CIMTYPE_DATETIME: |
{ | { |
CIMDateTime v; | CIMDateTime v; |
value.get(v); | value.get(v); |
|
|
| |
void XmlWriter::appendValueObjectWithPathElement( | void XmlWriter::appendValueObjectWithPathElement( |
Array<Sint8>& out, | Array<Sint8>& out, |
const CIMObjectWithPath& objectWithPath) |
const CIMObject& objectWithPath) |
{ | { |
out << "<VALUE.OBJECTWITHPATH>\n"; | out << "<VALUE.OBJECTWITHPATH>\n"; |
| |
appendValueReferenceElement(out, objectWithPath.getReference(), false); |
appendValueReferenceElement(out, objectWithPath.getPath (), false); |
appendObjectElement(out, objectWithPath.getObject()); |
appendObjectElement(out, objectWithPath); |
| |
out << "</VALUE.OBJECTWITHPATH>\n"; | out << "</VALUE.OBJECTWITHPATH>\n"; |
} | } |
|
|
| |
void XmlWriter::appendValueReferenceElement( | void XmlWriter::appendValueReferenceElement( |
Array<Sint8>& out, | Array<Sint8>& out, |
const CIMReference& reference, |
const CIMObjectPath& reference, |
Boolean putValueWrapper) | Boolean putValueWrapper) |
{ | { |
if (putValueWrapper) | if (putValueWrapper) |
|
|
// See if it is a class or instance reference (instance references have | // See if it is a class or instance reference (instance references have |
// key-bindings; class references do not). | // key-bindings; class references do not). |
| |
KeyBindingArray kbs = reference.getKeyBindingArray(); |
//KeyBindingArray kbs = reference.getKeyBindingArray(); |
|
KeyBindingArray kbs = reference.getKeyBindings(); |
|
|
if (kbs.size()) | if (kbs.size()) |
{ | { |
if (reference.getHost().size()) | if (reference.getHost().size()) |
{ | { |
appendInstancePathElement(out, reference); | appendInstancePathElement(out, reference); |
} | } |
else if (reference.getNameSpace().size()) |
else if (!reference.getNameSpace().isNull()) |
{ | { |
appendLocalInstancePathElement(out, reference); | appendLocalInstancePathElement(out, reference); |
} | } |
|
|
{ | { |
appendClassPathElement(out, reference); | appendClassPathElement(out, reference); |
} | } |
else if (reference.getNameSpace().size()) |
else if (!reference.getNameSpace().isNull()) |
{ | { |
appendLocalClassPathElement(out, reference); | appendLocalClassPathElement(out, reference); |
} | } |
|
|
} | } |
| |
void XmlWriter::printValueReferenceElement( | void XmlWriter::printValueReferenceElement( |
const CIMReference& reference, |
const CIMObjectPath& reference, |
PEGASUS_STD(ostream)& os) | PEGASUS_STD(ostream)& os) |
{ | { |
Array<Sint8> tmp; | Array<Sint8> tmp; |
|
|
| |
void XmlWriter::appendValueNamedInstanceElement( | void XmlWriter::appendValueNamedInstanceElement( |
Array<Sint8>& out, | Array<Sint8>& out, |
const CIMNamedInstance& namedInstance) |
const CIMInstance& namedInstance) |
{ | { |
out << "<VALUE.NAMEDINSTANCE>\n"; | out << "<VALUE.NAMEDINSTANCE>\n"; |
| |
appendInstanceNameElement(out, namedInstance.getInstanceName()); |
appendInstanceNameElement(out, namedInstance.getPath ()); |
appendInstanceElement(out, namedInstance.getInstance()); |
appendInstanceElement(out, namedInstance); |
| |
out << "</VALUE.NAMEDINSTANCE>\n"; | out << "</VALUE.NAMEDINSTANCE>\n"; |
} | } |
|
|
| |
//------------------------------------------------------------------------------ | //------------------------------------------------------------------------------ |
// | // |
|
// appendScopeElement() |
|
// |
|
// <!ELEMENT SCOPE EMPTY> |
|
// <!ATTLIST SCOPE |
|
// CLASS (true|false) 'false' |
|
// ASSOCIATION (true|false) 'false' |
|
// REFERENCE (true|false) 'false' |
|
// PROPERTY (true|false) 'false' |
|
// METHOD (true|false) 'false' |
|
// PARAMETER (true|false) 'false' |
|
// INDICATION (true|false) 'false'> |
|
// |
|
//------------------------------------------------------------------------------ |
|
|
|
void XmlWriter::appendScopeElement( |
|
Array<Sint8>& out, |
|
Uint32 scope) |
|
{ |
|
if (scope) |
|
{ |
|
out << "<SCOPE"; |
|
|
|
if (scope & CIMScope::CLASS) |
|
out << " CLASS=\"true\""; |
|
|
|
if (scope & CIMScope::ASSOCIATION) |
|
out << " ASSOCIATION=\"true\""; |
|
|
|
if (scope & CIMScope::REFERENCE) |
|
out << " REFERENCE=\"true\""; |
|
|
|
if (scope & CIMScope::PROPERTY) |
|
out << " PROPERTY=\"true\""; |
|
|
|
if (scope & CIMScope::METHOD) |
|
out << " METHOD=\"true\""; |
|
|
|
if (scope & CIMScope::PARAMETER) |
|
out << " PARAMETER=\"true\""; |
|
|
|
if (scope & CIMScope::INDICATION) |
|
out << " INDICATION=\"true\""; |
|
|
|
out << "/>"; |
|
} |
|
} |
|
|
|
//------------------------------------------------------------------------------ |
|
// |
// appendMethodCallHeader() | // appendMethodCallHeader() |
// | // |
// Build HTTP method call request header. | // Build HTTP method call request header. |
|
|
out << "<RETURNVALUE"; | out << "<RETURNVALUE"; |
| |
CIMType type = value.getType(); | CIMType type = value.getType(); |
if (type != CIMType::NONE) |
if (type != CIMTYPE_NONE) |
{ | { |
out << " PARAMTYPE=\"" << type.toString() << "\""; |
out << " PARAMTYPE=\"" << cimTypeToString (type) << "\""; |
} | } |
| |
out << ">\n"; | out << ">\n"; |
|
|
void XmlWriter::appendInstanceNameIParameter( | void XmlWriter::appendInstanceNameIParameter( |
Array<Sint8>& out, | Array<Sint8>& out, |
const char* name, | const char* name, |
const CIMReference& instanceName) |
const CIMObjectPath& instanceName) |
{ | { |
_appendIParamValueElementBegin(out, name); | _appendIParamValueElementBegin(out, name); |
appendInstanceNameElement(out, instanceName); | appendInstanceNameElement(out, instanceName); |
|
|
void XmlWriter::appendObjectNameIParameter( | void XmlWriter::appendObjectNameIParameter( |
Array<Sint8>& out, | Array<Sint8>& out, |
const char* name, | const char* name, |
const CIMReference& objectName) |
const CIMObjectPath& objectName) |
{ | { |
if (objectName.isClassName()) | if (objectName.isClassName()) |
{ | { |
|
|
void XmlWriter::appendNamedInstanceIParameter( | void XmlWriter::appendNamedInstanceIParameter( |
Array<Sint8>& out, | Array<Sint8>& out, |
const char* name, | const char* name, |
const CIMNamedInstance& namedInstance) |
const CIMInstance& namedInstance) |
{ | { |
_appendIParamValueElementBegin(out, name); | _appendIParamValueElementBegin(out, name); |
appendValueNamedInstanceElement(out, namedInstance); | appendValueNamedInstanceElement(out, namedInstance); |
|
|
_appendIParamValueElementBegin(out, "PropertyList"); | _appendIParamValueElementBegin(out, "PropertyList"); |
| |
out << "<VALUE.ARRAY>\n"; | out << "<VALUE.ARRAY>\n"; |
for (Uint32 i = 0; i < propertyList.getNumProperties(); i++) |
for (Uint32 i = 0; i < propertyList.size(); i++) |
{ | { |
out << "<VALUE>" << propertyList.getPropertyName(i) << "</VALUE>\n"; |
out << "<VALUE>" << propertyList[i] << "</VALUE>\n"; |
} | } |
out << "</VALUE.ARRAY>\n"; | out << "</VALUE.ARRAY>\n"; |
| |
|
|
Array<Sint8> XmlWriter::formatSimpleMethodReqMessage( | Array<Sint8> XmlWriter::formatSimpleMethodReqMessage( |
const char* host, | const char* host, |
const String& nameSpace, | const String& nameSpace, |
const CIMReference& path, |
const CIMObjectPath& path, |
const char* methodName, | const char* methodName, |
const Array<CIMParamValue>& parameters, | const Array<CIMParamValue>& parameters, |
const String& messageId, | const String& messageId, |
|
|
{ | { |
Array<Sint8> out; | Array<Sint8> out; |
Array<Sint8> tmp; | Array<Sint8> tmp; |
CIMReference localObjectPath = path; |
CIMObjectPath localObjectPath = path; |
localObjectPath.setNameSpace(nameSpace); | localObjectPath.setNameSpace(nameSpace); |
| |
_appendMessageElementBegin(out, messageId); | _appendMessageElementBegin(out, messageId); |