version 1.1.2.2, 2009/09/28 13:24:08
|
version 1.1.2.6, 2009/10/14 10:12:39
|
|
|
| |
if (kbType == CIMTYPE_REFERENCE) | if (kbType == CIMTYPE_REFERENCE) |
{ | { |
/* |
SCMOInstance * ref = kbValue->extRefPtr; |
TODO: NEED RESOLvE the value down to a SCMO.... |
appendValueReferenceElement(out, *ref, true); |
CIMObjectPath ref = keyBindings[i].getValue(); |
|
appendValueReferenceElement(out, ref, true); |
|
*/ |
|
} | } |
else | else |
{ | { |
|
|
} | } |
| |
// Append Properties: | // Append Properties: |
for (Uint32 i=0,k=scmoInstance.inst.hdr->numberProperties;i<k;i++) |
for (Uint32 i=0,k=scmoInstance.getPropertyCount();i<k;i++) |
{ | { |
if (scmoInstance.inst.hdr->flags.isFiltered && | if (scmoInstance.inst.hdr->flags.isFiltered && |
!scmoInstance._isPropertyInFilter(i)) | !scmoInstance._isPropertyInFilter(i)) |
|
|
| |
out << STRLIT(">\n"); | out << STRLIT(">\n"); |
// append the value of the qualifier | // append the value of the qualifier |
|
SCMOXmlWriter::appendValueElement(out, theQualifier.value, base); |
// TODO: Implement and call appendValueElement |
|
//SCMOXmlWriter::appendValueElement(out, theQualifier.value, clsbase); |
|
| |
out << STRLIT("</QUALIFIER>\n"); | out << STRLIT("</QUALIFIER>\n"); |
} | } |
|
|
| |
if (propertyValue->flags.isArray) | if (propertyValue->flags.isArray) |
{ | { |
/* |
out << STRLIT("<PROPERTY.ARRAY NAME=\""); |
out << STRLIT("<PROPERTY.ARRAY NAME=\"") |
|
<< rep->getName() |
out.append( |
<< STRLIT("\" "); |
&(clsbase[propertyDef->name.start]), |
|
propertyDef->name.length-1); |
| |
|
out << STRLIT("\" "); |
if (propertyType == CIMTYPE_OBJECT) | if (propertyType == CIMTYPE_OBJECT) |
{ | { |
|
/* TODO: Implement writing CIM_OBJECT |
// If the property array type is CIMObject, then | // If the property array type is CIMObject, then |
// encode the property in CIM-XML as a string array with the | // encode the property in CIM-XML as a string array with the |
// EmbeddedObject attribute (there is not currently a CIM-XML | // EmbeddedObject attribute (there is not currently a CIM-XML |
|
|
true)); | true)); |
} | } |
} | } |
|
*/ |
} | } |
else if (propertyType == CIMTYPE_INSTANCE) | else if (propertyType == CIMTYPE_INSTANCE) |
{ | { |
|
/* TODO: Implement writing embedded instance |
// If the property array type is CIMInstance, then | // If the property array type is CIMInstance, then |
// encode the property in CIM-XML as a string array with the | // encode the property in CIM-XML as a string array with the |
// EmbeddedObject attribute (there is not currently a CIM-XML | // EmbeddedObject attribute (there is not currently a CIM-XML |
|
|
} | } |
# endif | # endif |
} | } |
|
*/ |
} | } |
else | else |
{ | { |
out.append(' '); | out.append(' '); |
out << xmlWriterTypeStrings(rep->getValue().getType()); |
out << xmlWriterTypeStrings(propertyType); |
} | } |
| |
if (rep->getArraySize()) |
Uint32 arraySize=propertyValue->valueArraySize; |
|
|
|
if (0 != arraySize) |
{ | { |
char buffer[32]; |
out << STRLIT(" ARRAYSIZE=\""); |
sprintf(buffer, "%u", rep->getArraySize()); |
SCMOXmlWriter::append(out, arraySize); |
out << STRLIT(" ARRAYSIZE=\"") << buffer; |
|
out.append('"'); | out.append('"'); |
} | } |
| |
if (!rep->getClassOrigin().isNull()) |
|
|
if (scmoInstance.inst.hdr->flags.includeClassOrigin) |
{ | { |
out << STRLIT(" CLASSORIGIN=\"") << rep->getClassOrigin(); |
if (propertyDef->originClassName.start != 0) |
|
{ |
|
out << STRLIT(" CLASSORIGIN=\""); |
|
out.append( |
|
&(clsbase[propertyDef->originClassName.start]), |
|
propertyDef->originClassName.length-1); |
out.append('"'); | out.append('"'); |
} | } |
|
} |
if (rep->getPropagated()) |
if (propertyDef->flags.propagated) |
{ | { |
out << STRLIT(" PROPAGATED=\"true\""); | out << STRLIT(" PROPAGATED=\"true\""); |
} | } |
| |
out << STRLIT(">\n"); | out << STRLIT(">\n"); |
| |
for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++) |
// Append Instance Qualifiers: |
XmlWriter::appendQualifierElement(out, rep->getQualifier(i)); |
if (scmoInstance.inst.hdr->flags.includeQualifiers) |
|
{ |
|
SCMBQualifier * theArray= |
|
(SCMBQualifier*) |
|
&(clsbase[propertyDef->qualifierArray.start]); |
|
// need to iterate |
|
for (Uint32 i=0, n=propertyDef->numberOfQualifiers;i<n;i++) |
|
{ |
|
SCMOXmlWriter::appendQualifierElement( |
|
out, |
|
theArray[i], |
|
clsbase); |
|
} |
|
} |
| |
XmlWriter::appendValueElement(out, rep->getValue()); |
SCMOXmlWriter::appendValueElement(out,*propertyValue,propertyValueBase); |
| |
out << STRLIT("</PROPERTY.ARRAY>\n"); | out << STRLIT("</PROPERTY.ARRAY>\n"); |
*/ |
|
} | } |
else if (propertyType == CIMTYPE_REFERENCE) | else if (propertyType == CIMTYPE_REFERENCE) |
{ | { |
/* |
out << STRLIT("<PROPERTY.REFERENCE NAME=\""); |
out << STRLIT("<PROPERTY.REFERENCE" |
out.append( |
" NAME=\"") << rep->getName() << STRLIT("\" "); |
&(clsbase[propertyDef->name.start]), |
|
propertyDef->name.length-1); |
|
out << STRLIT("\" "); |
| |
if (!rep->getReferenceClassName().isNull()) |
if (0 != propertyDef->refClassName.start) |
{ | { |
out << STRLIT(" REFERENCECLASS=\"") |
out << STRLIT(" REFERENCECLASS=\""); |
<< rep->getReferenceClassName(); |
out.append( |
|
&(clsbase[propertyDef->refClassName.start]), |
|
propertyDef->refClassName.length-1); |
out.append('"'); | out.append('"'); |
} | } |
| |
if (!rep->getClassOrigin().isNull()) |
if (scmoInstance.inst.hdr->flags.includeClassOrigin) |
{ | { |
out << STRLIT(" CLASSORIGIN=\"") << rep->getClassOrigin(); |
if (propertyDef->originClassName.start != 0) |
|
{ |
|
out << STRLIT(" CLASSORIGIN=\""); |
|
out.append( |
|
&(clsbase[propertyDef->originClassName.start]), |
|
propertyDef->originClassName.length-1); |
out.append('"'); | out.append('"'); |
} | } |
|
} |
if (rep->getPropagated()) |
if (propertyDef->flags.propagated) |
{ | { |
out << STRLIT(" PROPAGATED=\"true\""); | out << STRLIT(" PROPAGATED=\"true\""); |
} | } |
|
|
out << STRLIT(">\n"); | out << STRLIT(">\n"); |
|
// Append Instance Qualifiers: |
for (Uint32 i = 0, n = rep->getQualifierCount(); i < n; i++) |
if (scmoInstance.inst.hdr->flags.includeQualifiers) |
XmlWriter::appendQualifierElement(out, rep->getQualifier(i)); |
{ |
|
SCMBQualifier * theArray= |
XmlWriter::appendValueElement(out, rep->getValue()); |
(SCMBQualifier*) |
|
&(clsbase[propertyDef->qualifierArray.start]); |
|
// need to iterate |
|
for (Uint32 i=0, n=propertyDef->numberOfQualifiers;i<n;i++) |
|
{ |
|
SCMOXmlWriter::appendQualifierElement( |
|
out, |
|
theArray[i], |
|
clsbase); |
|
} |
|
} |
|
SCMOXmlWriter::appendValueElement(out,*propertyValue,propertyValueBase); |
out << STRLIT("</PROPERTY.REFERENCE>\n"); | out << STRLIT("</PROPERTY.REFERENCE>\n"); |
*/ |
|
} | } |
else | else |
{ | { |
// TODO: Optimize the property name using length as input |
|
out << STRLIT("<PROPERTY NAME=\""); | out << STRLIT("<PROPERTY NAME=\""); |
| |
out.append( | out.append( |
|
|
| |
if (propertyType == CIMTYPE_OBJECT) | if (propertyType == CIMTYPE_OBJECT) |
{ | { |
/* |
/* TODO: Implement writing Embedded Object |
// If the property type is CIMObject, then | // If the property type is CIMObject, then |
// encode the property in CIM-XML as a string with the | // encode the property in CIM-XML as a string with the |
// EmbeddedObject attribute (there is not currently a CIM-XML | // EmbeddedObject attribute (there is not currently a CIM-XML |
|
|
} | } |
else if (propertyType == CIMTYPE_INSTANCE) | else if (propertyType == CIMTYPE_INSTANCE) |
{ | { |
/* |
/* TODO: Implement writing Embedded Instance |
CIMInstance a; | CIMInstance a; |
rep->getValue().get(a); | rep->getValue().get(a); |
out << STRLIT(" TYPE=\"string\"" | out << STRLIT(" TYPE=\"string\"" |
|
|
clsbase); | clsbase); |
} | } |
} | } |
SCMOXmlWriter::appendValueElement( |
SCMOXmlWriter::appendValueElement(out,*propertyValue,propertyValueBase); |
out, |
|
*propertyValue, |
|
propertyValueBase); |
|
|
|
out << STRLIT("</PROPERTY>\n"); | out << STRLIT("</PROPERTY>\n"); |
} | } |
} | } |
|
|
| |
void SCMOXmlWriter::appendValueElement( | void SCMOXmlWriter::appendValueElement( |
Buffer& out, | Buffer& out, |
SCMBValue & value, |
const SCMBValue & value, |
const char * base) | const char * base) |
{ | { |
if (value.flags.isNull) | if (value.flags.isNull) |
|
|
} | } |
if (value.flags.isArray) | if (value.flags.isArray) |
{ | { |
/* |
appendSCMBUnionArray( |
switch (value.getType()) |
out, |
|
value.value, |
|
value.valueType, |
|
value.valueArraySize, |
|
base); |
|
} |
|
else if (value.valueType == CIMTYPE_REFERENCE) |
|
{ |
|
SCMOInstance * ref = value.value.extRefPtr; |
|
appendValueReferenceElement(out, *ref, true); |
|
} |
|
else |
|
{ |
|
out << STRLIT("<VALUE>"); |
|
|
|
// Call function to write a SCMBUnion + type field |
|
appendSCMBUnion(out,value.value, value.valueType,base); |
|
|
|
out << STRLIT("</VALUE>\n"); |
|
} |
|
} |
|
|
|
//------------------------------------------------------------------------------ |
|
// |
|
// appendValueReferenceElement() |
|
// |
|
// <!ELEMENT VALUE.REFERENCE |
|
// (CLASSPATH|LOCALCLASSPATH|CLASSNAME|INSTANCEPATH|LOCALINSTANCEPATH| |
|
// INSTANCENAME)> |
|
// |
|
//------------------------------------------------------------------------------ |
|
void SCMOXmlWriter::appendValueReferenceElement( |
|
Buffer& out, |
|
const SCMOInstance& ref, |
|
Boolean putValueWrapper) |
|
{ |
|
if (putValueWrapper) |
|
{ |
|
out << STRLIT("<VALUE.REFERENCE>\n"); |
|
} |
|
|
|
// See if it is a class or instance reference (instance references have |
|
// key-bindings; class references do not). |
|
|
|
// differentiate between instance and class using the SCMO flag |
|
if (ref.inst.hdr->flags.isClassOnly) |
|
{ |
|
// class |
|
if (0 != ref.inst.hdr->hostName.start) |
|
{ |
|
appendClassPathElement(out, ref); |
|
} |
|
else if (0 != ref.inst.hdr->instNameSpace.start) |
|
{ |
|
appendLocalClassPathElement(out, ref); |
|
} |
|
else |
|
{ |
|
Uint64 classNameLength=0; |
|
const char* className = ref.getClassName_l(classNameLength); |
|
appendClassNameElement(out, className, classNameLength-1); |
|
} |
|
} |
|
else |
|
{ |
|
// instance |
|
if (0 != ref.inst.hdr->hostName.start) |
|
{ |
|
appendInstancePathElement(out, ref); |
|
} |
|
else if (0 != ref.inst.hdr->instNameSpace.start) |
|
{ |
|
appendLocalInstancePathElement(out, ref); |
|
} |
|
else |
|
{ |
|
appendInstanceNameElement(out, ref); |
|
} |
|
} |
|
if (putValueWrapper) |
|
{ |
|
out << STRLIT("</VALUE.REFERENCE>\n"); |
|
} |
|
} |
|
|
|
// appendLocalInstancePathElement() |
|
// <!ELEMENT LOCALINSTANCEPATH (LOCALNAMESPACEPATH, INSTANCENAME)> |
|
void SCMOXmlWriter::appendLocalInstancePathElement( |
|
Buffer& out, |
|
const SCMOInstance& instancePath) |
|
{ |
|
out << STRLIT("<LOCALINSTANCEPATH>\n"); |
|
Uint64 nsLength=0; |
|
const char* ns=instancePath.getNameSpace_l(nsLength); |
|
appendLocalNameSpacePathElement(out, ns, nsLength-1); |
|
appendInstanceNameElement(out, instancePath); |
|
out << STRLIT("</LOCALINSTANCEPATH>\n"); |
|
} |
|
|
|
// appendInstancePathElement() |
|
// <!ELEMENT INSTANCEPATH (NAMESPACEPATH,INSTANCENAME)> |
|
void SCMOXmlWriter::appendInstancePathElement( |
|
Buffer& out, |
|
const SCMOInstance& instancePath) |
|
{ |
|
out << STRLIT("<INSTANCEPATH>\n"); |
|
|
|
Uint64 hostnameLength=0; |
|
const char* hostname=instancePath.getHostName_l(hostnameLength); |
|
Uint64 nsLength=0; |
|
const char* ns=instancePath.getNameSpace_l(nsLength); |
|
appendNameSpacePathElement(out,hostname,hostnameLength-1,ns,nsLength-1); |
|
|
|
appendInstanceNameElement(out, instancePath); |
|
out << STRLIT("</INSTANCEPATH>\n"); |
|
} |
|
|
|
// appendLocalClassPathElement() |
|
// <!ELEMENT LOCALCLASSPATH (LOCALNAMESPACEPATH, CLASSNAME)> |
|
void SCMOXmlWriter::appendLocalClassPathElement( |
|
Buffer& out, |
|
const SCMOInstance& classPath) |
|
{ |
|
out << STRLIT("<LOCALCLASSPATH>\n"); |
|
Uint64 hostnameLength=0; |
|
const char* hostname=classPath.getHostName_l(hostnameLength); |
|
Uint64 nsLength=0; |
|
const char* ns=classPath.getNameSpace_l(nsLength); |
|
|
|
appendNameSpacePathElement(out,hostname,hostnameLength-1,ns,nsLength-1); |
|
|
|
Uint64 classNameLength=0; |
|
const char* className = classPath.getClassName_l(classNameLength); |
|
appendClassNameElement(out, className, classNameLength-1); |
|
out << STRLIT("</LOCALCLASSPATH>\n"); |
|
} |
|
|
|
// appendClassPathElement() |
|
// <!ELEMENT CLASSPATH (NAMESPACEPATH,CLASSNAME)> |
|
void SCMOXmlWriter::appendClassPathElement( |
|
Buffer& out, |
|
const SCMOInstance& classPath) |
|
{ |
|
out << STRLIT("<CLASSPATH>\n"); |
|
|
|
Uint64 hostnameLength=0; |
|
const char* hostname=classPath.getHostName_l(hostnameLength); |
|
Uint64 nsLength=0; |
|
const char* ns=classPath.getNameSpace_l(nsLength); |
|
|
|
appendNameSpacePathElement(out,hostname,hostnameLength,ns,nsLength); |
|
|
|
Uint64 classNameLength=0; |
|
const char* className = classPath.getClassName_l(classNameLength); |
|
|
|
appendClassNameElement(out, className, classNameLength-1); |
|
out << STRLIT("</CLASSPATH>\n"); |
|
} |
|
|
|
void SCMOXmlWriter::appendSCMBUnion( |
|
Buffer& out, |
|
const SCMBUnion & u, |
|
const CIMType & valueType, |
|
const char * base) |
|
{ |
|
switch (valueType) |
{ | { |
case CIMTYPE_BOOLEAN: | case CIMTYPE_BOOLEAN: |
{ | { |
Array<Boolean> a; |
SCMOXmlWriter::append(out, u.simple.val.bin); |
value.get(a); |
|
_xmlWritter_appendValueArray(out, a.getData(), a.size()); |
|
break; | break; |
} | } |
| |
case CIMTYPE_UINT8: | case CIMTYPE_UINT8: |
{ | { |
Array<Uint8> a; |
SCMOXmlWriter::append(out, u.simple.val.u8); |
value.get(a); |
|
_xmlWritter_appendValueArray(out, a.getData(), a.size()); |
|
break; | break; |
} | } |
| |
case CIMTYPE_SINT8: | case CIMTYPE_SINT8: |
{ | { |
Array<Sint8> a; |
SCMOXmlWriter::append(out, u.simple.val.s8); |
value.get(a); |
|
_xmlWritter_appendValueArray(out, a.getData(), a.size()); |
|
break; | break; |
} | } |
| |
case CIMTYPE_UINT16: | case CIMTYPE_UINT16: |
{ | { |
Array<Uint16> a; |
SCMOXmlWriter::append(out, u.simple.val.u16); |
value.get(a); |
|
_xmlWritter_appendValueArray(out, a.getData(), a.size()); |
|
break; | break; |
} | } |
| |
case CIMTYPE_SINT16: | case CIMTYPE_SINT16: |
{ | { |
Array<Sint16> a; |
SCMOXmlWriter::append(out, u.simple.val.s16); |
value.get(a); |
|
_xmlWritter_appendValueArray(out, a.getData(), a.size()); |
|
break; | break; |
} | } |
| |
case CIMTYPE_UINT32: | case CIMTYPE_UINT32: |
{ | { |
Array<Uint32> a; |
SCMOXmlWriter::append(out, u.simple.val.u32); |
value.get(a); |
|
_xmlWritter_appendValueArray(out, a.getData(), a.size()); |
|
break; | break; |
} | } |
| |
case CIMTYPE_SINT32: | case CIMTYPE_SINT32: |
{ | { |
Array<Sint32> a; |
SCMOXmlWriter::append(out, u.simple.val.s32); |
value.get(a); |
|
_xmlWritter_appendValueArray(out, a.getData(), a.size()); |
|
break; | break; |
} | } |
| |
case CIMTYPE_UINT64: | case CIMTYPE_UINT64: |
{ | { |
Array<Uint64> a; |
SCMOXmlWriter::append(out, u.simple.val.u64); |
value.get(a); |
|
_xmlWritter_appendValueArray(out, a.getData(), a.size()); |
|
break; | break; |
} | } |
| |
case CIMTYPE_SINT64: | case CIMTYPE_SINT64: |
{ | { |
Array<Sint64> a; |
SCMOXmlWriter::append(out, u.simple.val.s64); |
value.get(a); |
|
_xmlWritter_appendValueArray(out, a.getData(), a.size()); |
|
break; | break; |
} | } |
| |
case CIMTYPE_REAL32: | case CIMTYPE_REAL32: |
{ | { |
Array<Real32> a; |
SCMOXmlWriter::append(out, u.simple.val.r32); |
value.get(a); |
|
_xmlWritter_appendValueArray(out, a.getData(), a.size()); |
|
break; | break; |
} | } |
| |
case CIMTYPE_REAL64: | case CIMTYPE_REAL64: |
{ | { |
Array<Real64> a; |
SCMOXmlWriter::append(out, u.simple.val.r64); |
value.get(a); |
|
_xmlWritter_appendValueArray(out, a.getData(), a.size()); |
|
break; | break; |
} | } |
| |
case CIMTYPE_CHAR16: | case CIMTYPE_CHAR16: |
{ | { |
Array<Char16> a; |
SCMOXmlWriter::appendSpecial( |
value.get(a); |
out, |
_xmlWritter_appendValueArray(out, a.getData(), a.size()); |
u.simple.val.c16); |
break; | break; |
} | } |
| |
case CIMTYPE_STRING: | case CIMTYPE_STRING: |
{ | { |
const String* data; |
SCMOXmlWriter::appendSpecial( |
Uint32 size; |
out, |
value._get(data, size); |
&(base[u.stringValue.start]), |
_xmlWritter_appendValueArray(out, data, size); |
u.stringValue.length-1); |
break; | break; |
} | } |
| |
case CIMTYPE_DATETIME: | case CIMTYPE_DATETIME: |
{ | { |
Array<CIMDateTime> a; |
// an SCMBDateTime is a CIMDateTimeRep |
value.get(a); |
// this should help us to reuse existing optimized Datetime |
_xmlWritter_appendValueArray(out, a.getData(), a.size()); |
char buffer[26]; |
break; |
_DateTimetoCStr(&(u.dateTimeValue), buffer); |
} |
// datetime value is formatted with a \0 at end, ignore |
|
out.append(buffer,sizeof(buffer)-1); |
case CIMTYPE_REFERENCE: |
|
{ |
|
Array<CIMObjectPath> a; |
|
value.get(a); |
|
_xmlWritter_appendValueArray(out, a.getData(), a.size()); |
|
break; | break; |
} | } |
|
/* |
case CIMTYPE_OBJECT: | case CIMTYPE_OBJECT: |
{ | { |
Array<CIMObject> a; |
CIMObject v; |
value.get(a); |
value.get(v); |
_xmlWritter_appendValueArray(out, a.getData(), a.size()); |
_xmlWritter_appendValue(out, v); |
break; | break; |
} | } |
case CIMTYPE_INSTANCE: | case CIMTYPE_INSTANCE: |
{ | { |
Array<CIMInstance> a; |
CIMInstance v; |
value.get(a); |
value.get(v); |
_xmlWritter_appendValueArray(out, a.getData(), a.size()); |
_xmlWritter_appendValue(out, v); |
break; | break; |
} | } |
default: | default: |
PEGASUS_ASSERT(false); | PEGASUS_ASSERT(false); |
} |
|
*/ | */ |
} | } |
else if (value.valueType == CIMTYPE_REFERENCE) |
|
{ |
|
/* |
|
// Has to be separate because it uses VALUE.REFERENCE tag |
|
CIMObjectPath v; |
|
value.get(v); |
|
_xmlWritter_appendValue(out, v); |
|
*/ |
|
} |
|
else |
|
{ |
|
out << STRLIT("<VALUE>"); |
|
|
|
// Call function to write a SCMBUnion + type field |
|
appendSCMBUnion(out,value.value, value.valueType,base); |
|
|
|
out << STRLIT("</VALUE>\n"); |
|
} |
|
} | } |
| |
void SCMOXmlWriter::appendSCMBUnion( |
void SCMOXmlWriter::appendSCMBUnionArray( |
Buffer& out, | Buffer& out, |
const SCMBUnion & u, | const SCMBUnion & u, |
const CIMType & valueType, | const CIMType & valueType, |
|
Uint32 numElements, |
const char * base) | const char * base) |
{ | { |
|
SCMBUnion* arr = (SCMBUnion*) &(base[u.arrayValue.start]); |
switch (valueType) | switch (valueType) |
{ | { |
case CIMTYPE_BOOLEAN: | case CIMTYPE_BOOLEAN: |
{ | { |
SCMOXmlWriter::append(out, u.simple.val.bin); |
out << STRLIT("<VALUE.ARRAY>\n"); |
|
while (numElements--) |
|
{ |
|
out << STRLIT("<VALUE>"); |
|
SCMOXmlWriter::append(out, arr->simple.val.bin); |
|
arr++; |
|
out << STRLIT("</VALUE>\n"); |
|
} |
|
out << STRLIT("</VALUE.ARRAY>\n"); |
break; | break; |
} | } |
|
|
case CIMTYPE_UINT8: | case CIMTYPE_UINT8: |
{ | { |
SCMOXmlWriter::append(out, u.simple.val.u8); |
out << STRLIT("<VALUE.ARRAY>\n"); |
|
while (numElements--) |
|
{ |
|
out << STRLIT("<VALUE>"); |
|
SCMOXmlWriter::append(out, arr->simple.val.u8); |
|
arr++; |
|
out << STRLIT("</VALUE>\n"); |
|
} |
|
out << STRLIT("</VALUE.ARRAY>\n"); |
break; | break; |
} | } |
| |
case CIMTYPE_SINT8: | case CIMTYPE_SINT8: |
{ | { |
SCMOXmlWriter::append(out, u.simple.val.s8); |
out << STRLIT("<VALUE.ARRAY>\n"); |
|
while (numElements--) |
|
{ |
|
out << STRLIT("<VALUE>"); |
|
SCMOXmlWriter::append(out, arr->simple.val.s8); |
|
arr++; |
|
out << STRLIT("</VALUE>\n"); |
|
} |
|
out << STRLIT("</VALUE.ARRAY>\n"); |
break; | break; |
} | } |
| |
case CIMTYPE_UINT16: | case CIMTYPE_UINT16: |
{ | { |
SCMOXmlWriter::append(out, u.simple.val.u16); |
out << STRLIT("<VALUE.ARRAY>\n"); |
|
while (numElements--) |
|
{ |
|
out << STRLIT("<VALUE>"); |
|
SCMOXmlWriter::append(out, arr->simple.val.u16); |
|
arr++; |
|
out << STRLIT("</VALUE>\n"); |
|
} |
|
out << STRLIT("</VALUE.ARRAY>\n"); |
break; | break; |
} | } |
| |
case CIMTYPE_SINT16: | case CIMTYPE_SINT16: |
{ | { |
SCMOXmlWriter::append(out, u.simple.val.s16); |
out << STRLIT("<VALUE.ARRAY>\n"); |
|
while (numElements--) |
|
{ |
|
out << STRLIT("<VALUE>"); |
|
SCMOXmlWriter::append(out, arr->simple.val.s16); |
|
arr++; |
|
out << STRLIT("</VALUE>\n"); |
|
} |
|
out << STRLIT("</VALUE.ARRAY>\n"); |
break; | break; |
} | } |
| |
case CIMTYPE_UINT32: | case CIMTYPE_UINT32: |
{ | { |
SCMOXmlWriter::append(out, u.simple.val.u32); |
out << STRLIT("<VALUE.ARRAY>\n"); |
|
while (numElements--) |
|
{ |
|
out << STRLIT("<VALUE>"); |
|
SCMOXmlWriter::append(out, arr->simple.val.u32); |
|
arr++; |
|
out << STRLIT("</VALUE>\n"); |
|
} |
|
out << STRLIT("</VALUE.ARRAY>\n"); |
break; | break; |
} | } |
| |
case CIMTYPE_SINT32: | case CIMTYPE_SINT32: |
{ | { |
SCMOXmlWriter::append(out, u.simple.val.s32); |
out << STRLIT("<VALUE.ARRAY>\n"); |
|
while (numElements--) |
|
{ |
|
out << STRLIT("<VALUE>"); |
|
SCMOXmlWriter::append(out, arr->simple.val.s32); |
|
arr++; |
|
out << STRLIT("</VALUE>\n"); |
|
} |
|
out << STRLIT("</VALUE.ARRAY>\n"); |
break; | break; |
} | } |
| |
case CIMTYPE_UINT64: | case CIMTYPE_UINT64: |
{ | { |
SCMOXmlWriter::append(out, u.simple.val.u64); |
out << STRLIT("<VALUE.ARRAY>\n"); |
|
while (numElements--) |
|
{ |
|
out << STRLIT("<VALUE>"); |
|
SCMOXmlWriter::append(out, arr->simple.val.u64); |
|
arr++; |
|
out << STRLIT("</VALUE>\n"); |
|
} |
|
out << STRLIT("</VALUE.ARRAY>\n"); |
break; | break; |
} | } |
| |
case CIMTYPE_SINT64: | case CIMTYPE_SINT64: |
{ | { |
SCMOXmlWriter::append(out, u.simple.val.s64); |
out << STRLIT("<VALUE.ARRAY>\n"); |
|
while (numElements--) |
|
{ |
|
out << STRLIT("<VALUE>"); |
|
SCMOXmlWriter::append(out, arr->simple.val.s64); |
|
arr++; |
|
out << STRLIT("</VALUE>\n"); |
|
} |
|
out << STRLIT("</VALUE.ARRAY>\n"); |
break; | break; |
} | } |
| |
case CIMTYPE_REAL32: | case CIMTYPE_REAL32: |
{ | { |
SCMOXmlWriter::append(out, u.simple.val.r32); |
out << STRLIT("<VALUE.ARRAY>\n"); |
|
while (numElements--) |
|
{ |
|
out << STRLIT("<VALUE>"); |
|
SCMOXmlWriter::append(out, arr->simple.val.r32); |
|
arr++; |
|
out << STRLIT("</VALUE>\n"); |
|
} |
|
out << STRLIT("</VALUE.ARRAY>\n"); |
break; | break; |
} | } |
| |
case CIMTYPE_REAL64: | case CIMTYPE_REAL64: |
{ | { |
SCMOXmlWriter::append(out, u.simple.val.r64); |
out << STRLIT("<VALUE.ARRAY>\n"); |
|
while (numElements--) |
|
{ |
|
out << STRLIT("<VALUE>"); |
|
SCMOXmlWriter::append(out, arr->simple.val.r64); |
|
arr++; |
|
out << STRLIT("</VALUE>\n"); |
|
} |
|
out << STRLIT("</VALUE.ARRAY>\n"); |
break; | break; |
} | } |
| |
case CIMTYPE_CHAR16: | case CIMTYPE_CHAR16: |
{ | { |
SCMOXmlWriter::appendSpecial( |
out << STRLIT("<VALUE.ARRAY>\n"); |
out, |
while (numElements--) |
u.simple.val.c16); |
{ |
|
out << STRLIT("<VALUE>"); |
|
SCMOXmlWriter::append(out, arr->simple.val.bin); |
|
SCMOXmlWriter::appendSpecial(out, arr->simple.val.c16); |
|
arr++; |
|
out << STRLIT("</VALUE>\n"); |
|
} |
|
out << STRLIT("</VALUE.ARRAY>\n"); |
break; | break; |
} | } |
| |
case CIMTYPE_STRING: | case CIMTYPE_STRING: |
{ | { |
|
out << STRLIT("<VALUE.ARRAY>\n"); |
|
while (numElements--) |
|
{ |
|
out << STRLIT("<VALUE>"); |
SCMOXmlWriter::appendSpecial( | SCMOXmlWriter::appendSpecial( |
out, | out, |
&(base[u.stringValue.start]), |
&(base[arr->stringValue.start]), |
u.stringValue.length-1); |
arr->stringValue.length-1); |
|
arr++; |
|
out << STRLIT("</VALUE>\n"); |
|
} |
|
out << STRLIT("</VALUE.ARRAY>\n"); |
|
|
break; | break; |
} | } |
| |
case CIMTYPE_DATETIME: | case CIMTYPE_DATETIME: |
{ | { |
|
out << STRLIT("<VALUE.ARRAY>\n"); |
|
char buffer[26]; |
|
while (numElements--) |
|
{ |
|
out << STRLIT("<VALUE>"); |
// an SCMBDateTime is a CIMDateTimeRep | // an SCMBDateTime is a CIMDateTimeRep |
// this should help us to reuse existing optimized Datetime | // this should help us to reuse existing optimized Datetime |
char buffer[26]; |
_DateTimetoCStr(&(arr->dateTimeValue), buffer); |
_DateTimetoCStr(&(u.dateTimeValue), buffer); |
|
// datetime value is formatted with a \0 at end, ignore | // datetime value is formatted with a \0 at end, ignore |
out.append(buffer,sizeof(buffer)-1); | out.append(buffer,sizeof(buffer)-1); |
|
arr++; |
|
out << STRLIT("</VALUE>\n"); |
|
} |
|
out << STRLIT("</VALUE.ARRAY>\n"); |
break; | break; |
} | } |
/* | /* |
|
|
PEGASUS_ASSERT(false); | PEGASUS_ASSERT(false); |
*/ | */ |
} | } |
|
|
} | } |
| |
| |
|
|
PEGASUS_NAMESPACE_END | PEGASUS_NAMESPACE_END |