(file) Return to XmlWriter.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/XmlWriter.cpp between version 1.124 and 1.125

version 1.124, 2005/05/12 18:14:59 version 1.125, 2005/10/31 17:39:12
Line 71 
Line 71 
 #include "Tracer.h" #include "Tracer.h"
 #include <Pegasus/Common/StatisticalData.h> #include <Pegasus/Common/StatisticalData.h>
 #include "CommonUTF.h" #include "CommonUTF.h"
   #include "Buffer.h"
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 88 
Line 89 
     out << "content-length: " << contentLengthP << "\r\n";     \     out << "content-length: " << contentLengthP << "\r\n";     \
 } }
  
 Array<char>& operator<<(Array<char>& out, const char* x)  Buffer& operator<<(Buffer& out, const char* x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
     return out;     return out;
 } }
  
 Array<char>& operator<<(Array<char>& out, char x)  Buffer& operator<<(Buffer& out, char x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
     return out;     return out;
 } }
  
 Array<char>& operator<<(Array<char>& out, const Char16& x)  Buffer& operator<<(Buffer& out, const Char16& x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
     return out;     return out;
 } }
  
 Array<char>& operator<<(Array<char>& out, const String& x)  Buffer& operator<<(Buffer& out, const String& x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
     return out;     return out;
 } }
  
 Array<char>& operator<<(Array<char>& out, const Indentor& x)  Buffer& operator<<(Buffer& out, const Indentor& x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
     return out;     return out;
 } }
  
 Array<char>& operator<<(Array<char>& out, const Array<char>& x)  Buffer& operator<<(Buffer& out, const Buffer& x)
 { {
     out.appendArray(x);      out.append(x.getData(), x.size());
     return out;     return out;
 } }
  
 Array<char>& operator<<(Array<char>& out, Uint32 x)  Buffer& operator<<(Buffer& out, Uint32 x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
     return out;     return out;
 } }
  
 Array<char>& operator<<(Array<char>& out, const CIMName& name)  Buffer& operator<<(Buffer& out, const CIMName& name)
 { {
     XmlWriter::append(out, name.getString ());     XmlWriter::append(out, name.getString ());
     return out;     return out;
Line 138 
Line 139 
  
  
 // l10n // l10n
 Array<char>& operator<<(Array<char>& out, const AcceptLanguages& al)  Buffer& operator<<(Buffer& out, const AcceptLanguages& al)
 { {
     XmlWriter::append(out, al.toString ());     XmlWriter::append(out, al.toString ());
     return out;     return out;
 } }
  
 // l10n // l10n
 Array<char>& operator<<(Array<char>& out, const ContentLanguages& cl)  Buffer& operator<<(Buffer& out, const ContentLanguages& cl)
 { {
     XmlWriter::append(out, cl.toString ());     XmlWriter::append(out, cl.toString ());
     return out;     return out;
Line 170 
Line 171 
     return os;     return os;
 } }
  
 inline void _xmlWritter_appendChar(Array<char>& out, const Char16& c)  inline void _xmlWritter_appendChar(Buffer& out, const Char16& c)
 { {
     // We need to convert the Char16 to UTF8 then append the UTF8     // We need to convert the Char16 to UTF8 then append the UTF8
     // character into the array.     // character into the array.
Line 195 
Line 196 
     out.append(str, UTF_8_COUNT_TRAIL_BYTES(str[0]) + 1);     out.append(str, UTF_8_COUNT_TRAIL_BYTES(str[0]) + 1);
 } }
  
 inline void _xmlWritter_appendSpecialChar(Array<char>& out, const Char16& c)  inline void _xmlWritter_appendSpecialChar(Buffer& out, const Char16& c)
 { {
     if ( ((c < Char16(0x20)) && (c >= Char16(0x00))) || (c == Char16(0x7f)) )     if ( ((c < Char16(0x20)) && (c >= Char16(0x00))) || (c == Char16(0x7f)) )
     {     {
Line 257 
Line 258 
     }     }
 } }
  
 inline void _xmlWritter_appendSpecialChar(Array<char>& out, char c)  inline void _xmlWritter_appendSpecialChar(Buffer& out, char c)
 { {
         if ( ((c < 0x20) && (c >= 0)) || (c == 0x7f) )         if ( ((c < 0x20) && (c >= 0)) || (c == 0x7f) )
     {     {
Line 334 
Line 335 
     }     }
 } }
  
 void _xmlWritter_appendSurrogatePair(Array<char>& out, Uint16 high, Uint16 low)  void _xmlWritter_appendSurrogatePair(Buffer& out, Uint16 high, Uint16 low)
 { {
     char str[6];     char str[6];
     Uint8 charIN[5];     Uint8 charIN[5];
Line 362 
Line 363 
         _xmlWritter_appendSpecialChar(os, *str++);         _xmlWritter_appendSpecialChar(os, *str++);
 } }
  
 void XmlWriter::append(Array<char>& out, const Char16& x)  void XmlWriter::append(Buffer& out, const Char16& x)
 { {
     _xmlWritter_appendChar(out, x);     _xmlWritter_appendChar(out, x);
 } }
  
 void XmlWriter::append(Array<char>& out, Boolean x)  void XmlWriter::append(Buffer& out, Boolean x)
 { {
     append(out, (x ? "TRUE" : "FALSE"));     append(out, (x ? "TRUE" : "FALSE"));
 } }
  
 void XmlWriter::append(Array<char>& out, Uint32 x)  void XmlWriter::append(Buffer& out, Uint32 x)
 { {
     char buffer[32];     char buffer[32];
     sprintf(buffer, "%u", x);     sprintf(buffer, "%u", x);
     append(out, buffer);     append(out, buffer);
 } }
  
 void XmlWriter::append(Array<char>& out, Sint32 x)  void XmlWriter::append(Buffer& out, Sint32 x)
 { {
     char buffer[32];     char buffer[32];
     sprintf(buffer, "%d", x);     sprintf(buffer, "%d", x);
     append(out, buffer);     append(out, buffer);
 } }
  
 void XmlWriter::append(Array<char>& out, Uint64 x)  void XmlWriter::append(Buffer& out, Uint64 x)
 { {
     char buffer[32];  // Should need 21 chars max     char buffer[32];  // Should need 21 chars max
     sprintf(buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "u", x);     sprintf(buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "u", x);
     append(out, buffer);     append(out, buffer);
 } }
  
 void XmlWriter::append(Array<char>& out, Sint64 x)  void XmlWriter::append(Buffer& out, Sint64 x)
 { {
     char buffer[32];  // Should need 21 chars max     char buffer[32];  // Should need 21 chars max
     sprintf(buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "d", x);     sprintf(buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "d", x);
     append(out, buffer);     append(out, buffer);
 } }
  
 void XmlWriter::append(Array<char>& out, Real32 x)  void XmlWriter::append(Buffer& out, Real32 x)
 { {
     char buffer[128];     char buffer[128];
     // %.7e gives '[-]m.ddddddde+/-xx', which seems compatible with the format     // %.7e gives '[-]m.ddddddde+/-xx', which seems compatible with the format
Line 410 
Line 411 
     append(out, buffer);     append(out, buffer);
 } }
  
 void XmlWriter::append(Array<char>& out, Real64 x)  void XmlWriter::append(Buffer& out, Real64 x)
 { {
     char buffer[128];     char buffer[128];
     // %.16e gives '[-]m.dddddddddddddddde+/-xx', which seems compatible with the format     // %.16e gives '[-]m.dddddddddddddddde+/-xx', which seems compatible with the format
Line 420 
Line 421 
     append(out, buffer);     append(out, buffer);
 } }
  
 void XmlWriter::append(Array<char>& out, const char* str)  void XmlWriter::append(Buffer& out, const char* str)
 { {
     while (*str)     while (*str)
       XmlWriter::append(out, *str++);       XmlWriter::append(out, *str++);
 } }
  
 void XmlWriter::append(Array<char>& out, const String& str)  void XmlWriter::append(Buffer& out, const String& str)
 { {
     for (Uint32 i = 0; i < str.size(); i++)     for (Uint32 i = 0; i < str.size(); i++)
     {     {
Line 446 
Line 447 
     }     }
 } }
  
 void XmlWriter::append(Array<char>& out, const Indentor& x)  void XmlWriter::append(Buffer& out, const Indentor& x)
 { {
     for (Uint32 i = 0; i < 4 * x.getLevel(); i++)     for (Uint32 i = 0; i < 4 * x.getLevel(); i++)
         out.append(' ');         out.append(' ');
 } }
  
 void XmlWriter::appendSpecial(Array<char>& out, const Char16& x)  void XmlWriter::appendSpecial(Buffer& out, const Char16& x)
 { {
     _xmlWritter_appendSpecialChar(out, x);     _xmlWritter_appendSpecialChar(out, x);
 } }
  
 void XmlWriter::appendSpecial(Array<char>& out, char x)  void XmlWriter::appendSpecial(Buffer& out, char x)
 { {
     _xmlWritter_appendSpecialChar(out, x);     _xmlWritter_appendSpecialChar(out, x);
 } }
  
 void XmlWriter::appendSpecial(Array<char>& out, const char* str)  void XmlWriter::appendSpecial(Buffer& out, const char* str)
 { {
     while (*str)     while (*str)
         _xmlWritter_appendSpecialChar(out, *str++);         _xmlWritter_appendSpecialChar(out, *str++);
 } }
  
 void XmlWriter::appendSpecial(Array<char>& out, const String& str)  void XmlWriter::appendSpecial(Buffer& out, const String& str)
 { {
     for (Uint32 i = 0; i < str.size(); i++)     for (Uint32 i = 0; i < str.size(); i++)
     {     {
Line 526 
Line 527 
     }     }
 } }
  
 String XmlWriter::encodeURICharacters(const Array<char>& uriString)  String XmlWriter::encodeURICharacters(const Buffer& uriString)
 { {
     String encodedString;     String encodedString;
  
Line 553 
Line 554 
     // 3.3.3, for the treatment of non US-ASCII (UTF-8) chars     // 3.3.3, for the treatment of non US-ASCII (UTF-8) chars
  
     // First, convert to UTF-8 (include handling of surrogate pairs)     // First, convert to UTF-8 (include handling of surrogate pairs)
     Array<char> utf8;      Buffer utf8;
     for (Uint32 i = 0; i < uriString.size(); i++)     for (Uint32 i = 0; i < uriString.size(); i++)
     {     {
         Uint16 c = uriString[i];         Uint16 c = uriString[i];
Line 590 
Line 591 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendLocalNameSpacePathElement( void XmlWriter::appendLocalNameSpacePathElement(
     Array<char>& out,      Buffer& out,
     const CIMNamespaceName& nameSpace)     const CIMNamespaceName& nameSpace)
 { {
     out << "<LOCALNAMESPACEPATH>\n";     out << "<LOCALNAMESPACEPATH>\n";
Line 623 
Line 624 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendNameSpacePathElement( void XmlWriter::appendNameSpacePathElement(
     Array<char>& out,      Buffer& out,
     const String& host,     const String& host,
     const CIMNamespaceName& nameSpace)     const CIMNamespaceName& nameSpace)
 { {
Line 644 
Line 645 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendClassNameElement( void XmlWriter::appendClassNameElement(
     Array<char>& out,      Buffer& out,
     const CIMName& className)     const CIMName& className)
 { {
     out << "<CLASSNAME NAME=\"" << className << "\"/>\n";     out << "<CLASSNAME NAME=\"" << className << "\"/>\n";
Line 661 
Line 662 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendInstanceNameElement( void XmlWriter::appendInstanceNameElement(
     Array<char>& out,      Buffer& out,
     const CIMObjectPath& instanceName)     const CIMObjectPath& instanceName)
 { {
     out << "<INSTANCENAME CLASSNAME=\"" << instanceName.getClassName() << "\">\n";     out << "<INSTANCENAME CLASSNAME=\"" << instanceName.getClassName() << "\">\n";
Line 700 
Line 701 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendClassPathElement( void XmlWriter::appendClassPathElement(
     Array<char>& out,      Buffer& out,
     const CIMObjectPath& classPath)     const CIMObjectPath& classPath)
 { {
     out << "<CLASSPATH>\n";     out << "<CLASSPATH>\n";
Line 720 
Line 721 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendInstancePathElement( void XmlWriter::appendInstancePathElement(
     Array<char>& out,      Buffer& out,
     const CIMObjectPath& instancePath)     const CIMObjectPath& instancePath)
 { {
     out << "<INSTANCEPATH>\n";     out << "<INSTANCEPATH>\n";
Line 740 
Line 741 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendLocalClassPathElement( void XmlWriter::appendLocalClassPathElement(
     Array<char>& out,      Buffer& out,
     const CIMObjectPath& classPath)     const CIMObjectPath& classPath)
 { {
     out << "<LOCALCLASSPATH>\n";     out << "<LOCALCLASSPATH>\n";
Line 758 
Line 759 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendLocalInstancePathElement( void XmlWriter::appendLocalInstancePathElement(
     Array<char>& out,      Buffer& out,
     const CIMObjectPath& instancePath)     const CIMObjectPath& instancePath)
 { {
     out << "<LOCALINSTANCEPATH>\n";     out << "<LOCALINSTANCEPATH>\n";
Line 777 
Line 778 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendLocalObjectPathElement( void XmlWriter::appendLocalObjectPathElement(
     Array<char>& out,      Buffer& out,
     const CIMObjectPath& objectPath)     const CIMObjectPath& objectPath)
 { {
     //     //
Line 802 
Line 803 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 inline void _xmlWritter_appendValue(Array<char>& out, Boolean x)  inline void _xmlWritter_appendValue(Buffer& out, Boolean x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _xmlWritter_appendValue(Array<char>& out, Uint8 x)  inline void _xmlWritter_appendValue(Buffer& out, Uint8 x)
 { {
     XmlWriter::append(out, Uint32(x));     XmlWriter::append(out, Uint32(x));
 } }
  
 inline void _xmlWritter_appendValue(Array<char>& out, Sint8 x)  inline void _xmlWritter_appendValue(Buffer& out, Sint8 x)
 { {
     XmlWriter::append(out, Sint32(x));     XmlWriter::append(out, Sint32(x));
 } }
  
 inline void _xmlWritter_appendValue(Array<char>& out, Uint16 x)  inline void _xmlWritter_appendValue(Buffer& out, Uint16 x)
 { {
     XmlWriter::append(out, Uint32(x));     XmlWriter::append(out, Uint32(x));
 } }
  
 inline void _xmlWritter_appendValue(Array<char>& out, Sint16 x)  inline void _xmlWritter_appendValue(Buffer& out, Sint16 x)
 { {
     XmlWriter::append(out, Sint32(x));     XmlWriter::append(out, Sint32(x));
 } }
  
 inline void _xmlWritter_appendValue(Array<char>& out, Uint32 x)  inline void _xmlWritter_appendValue(Buffer& out, Uint32 x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _xmlWritter_appendValue(Array<char>& out, Sint32 x)  inline void _xmlWritter_appendValue(Buffer& out, Sint32 x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _xmlWritter_appendValue(Array<char>& out, Uint64 x)  inline void _xmlWritter_appendValue(Buffer& out, Uint64 x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _xmlWritter_appendValue(Array<char>& out, Sint64 x)  inline void _xmlWritter_appendValue(Buffer& out, Sint64 x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _xmlWritter_appendValue(Array<char>& out, Real32 x)  inline void _xmlWritter_appendValue(Buffer& out, Real32 x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _xmlWritter_appendValue(Array<char>& out, Real64 x)  inline void _xmlWritter_appendValue(Buffer& out, Real64 x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _xmlWritter_appendValue(Array<char>& out, const Char16& x)  inline void _xmlWritter_appendValue(Buffer& out, const Char16& x)
 { {
     XmlWriter::appendSpecial(out, x);     XmlWriter::appendSpecial(out, x);
 } }
  
 inline void _xmlWritter_appendValue(Array<char>& out, const String& x)  inline void _xmlWritter_appendValue(Buffer& out, const String& x)
 { {
     XmlWriter::appendSpecial(out, x);     XmlWriter::appendSpecial(out, x);
 } }
  
 inline void _xmlWritter_appendValue(Array<char>& out, const CIMDateTime& x)  inline void _xmlWritter_appendValue(Buffer& out, const CIMDateTime& x)
 { {
     out << x.toString();  //ATTN: append() method?     out << x.toString();  //ATTN: append() method?
 } }
  
 inline void _xmlWritter_appendValue(Array<char>& out, const CIMObjectPath& x)  inline void _xmlWritter_appendValue(Buffer& out, const CIMObjectPath& x)
 { {
     XmlWriter::appendValueReferenceElement(out, x, true);     XmlWriter::appendValueReferenceElement(out, x, true);
 } }
  
 inline void _xmlWritter_appendValue(Array<char>& out, const CIMObject& x)  inline void _xmlWritter_appendValue(Buffer& out, const CIMObject& x)
 { {
     String myStr = x.toString();     String myStr = x.toString();
     _xmlWritter_appendValue(out, myStr);     _xmlWritter_appendValue(out, myStr);
 } }
  
 void _xmlWritter_appendValueArray(Array<char>& out, const CIMObjectPath* p, Uint32 size)  void _xmlWritter_appendValueArray(Buffer& out, const CIMObjectPath* p, Uint32 size)
 { {
     out << "<VALUE.REFARRAY>\n";     out << "<VALUE.REFARRAY>\n";
     while (size--)     while (size--)
Line 894 
Line 895 
 } }
  
 template<class T> template<class T>
 void _xmlWritter_appendValueArray(Array<char>& out, const T* p, Uint32 size)  void _xmlWritter_appendValueArray(Buffer& out, const T* p, Uint32 size)
 { {
     out << "<VALUE.ARRAY>\n";     out << "<VALUE.ARRAY>\n";
  
Line 922 
Line 923 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendValueElement( void XmlWriter::appendValueElement(
     Array<char>& out,      Buffer& out,
     const CIMValue& value)     const CIMValue& value)
 { {
     if (value.isNull())     if (value.isNull())
Line 1210 
Line 1211 
     const CIMValue& value,     const CIMValue& value,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<char> tmp;      Buffer tmp;
     appendValueElement(tmp, value);     appendValueElement(tmp, value);
     tmp.append('\0');     tmp.append('\0');
     os << tmp.getData() << PEGASUS_STD(endl);     os << tmp.getData() << PEGASUS_STD(endl);
Line 1226 
Line 1227 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendValueObjectWithPathElement( void XmlWriter::appendValueObjectWithPathElement(
     Array<char>& out,      Buffer& out,
     const CIMObject& objectWithPath)     const CIMObject& objectWithPath)
 { {
     out << "<VALUE.OBJECTWITHPATH>\n";     out << "<VALUE.OBJECTWITHPATH>\n";
Line 1248 
Line 1249 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendValueReferenceElement( void XmlWriter::appendValueReferenceElement(
     Array<char>& out,      Buffer& out,
     const CIMObjectPath& reference,     const CIMObjectPath& reference,
     Boolean putValueWrapper)     Boolean putValueWrapper)
 { {
Line 1305 
Line 1306 
     const CIMObjectPath& reference,     const CIMObjectPath& reference,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<char> tmp;      Buffer tmp;
     appendValueReferenceElement(tmp, reference, true);     appendValueReferenceElement(tmp, reference, true);
     tmp.append('\0');     tmp.append('\0');
     indentedPrint(os, tmp.getData());     indentedPrint(os, tmp.getData());
Line 1320 
Line 1321 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendValueNamedInstanceElement( void XmlWriter::appendValueNamedInstanceElement(
     Array<char>& out,      Buffer& out,
     const CIMInstance& namedInstance)     const CIMInstance& namedInstance)
 { {
     out << "<VALUE.NAMEDINSTANCE>\n";     out << "<VALUE.NAMEDINSTANCE>\n";
Line 1344 
Line 1345 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendClassElement( void XmlWriter::appendClassElement(
     Array<char>& out,      Buffer& out,
     const CIMConstClass& cimclass)     const CIMConstClass& cimclass)
 { {
     cimclass._checkRep();     cimclass._checkRep();
Line 1355 
Line 1356 
     const CIMConstClass& cimclass,     const CIMConstClass& cimclass,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<char> tmp;      Buffer tmp;
     appendClassElement(tmp, cimclass);     appendClassElement(tmp, cimclass);
     tmp.append('\0');     tmp.append('\0');
     indentedPrint(os, tmp.getData(), 4);     indentedPrint(os, tmp.getData(), 4);
Line 1373 
Line 1374 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendInstanceElement( void XmlWriter::appendInstanceElement(
     Array<char>& out,      Buffer& out,
     const CIMConstInstance& instance)     const CIMConstInstance& instance)
 { {
     instance._checkRep();     instance._checkRep();
Line 1384 
Line 1385 
     const CIMConstInstance& instance,     const CIMConstInstance& instance,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<char> tmp;      Buffer tmp;
     appendInstanceElement(tmp, instance);     appendInstanceElement(tmp, instance);
     tmp.append('\0');     tmp.append('\0');
     os << tmp.getData() << PEGASUS_STD(endl);     os << tmp.getData() << PEGASUS_STD(endl);
Line 1399 
Line 1400 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendObjectElement( void XmlWriter::appendObjectElement(
     Array<char>& out,      Buffer& out,
     const CIMConstObject& object)     const CIMConstObject& object)
 { {
     if (object.isClass())     if (object.isClass())
Line 1444 
Line 1445 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendPropertyElement( void XmlWriter::appendPropertyElement(
     Array<char>& out,      Buffer& out,
     const CIMConstProperty& property)     const CIMConstProperty& property)
 { {
     property._checkRep();     property._checkRep();
Line 1455 
Line 1456 
     const CIMConstProperty& property,     const CIMConstProperty& property,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<char> tmp;      Buffer tmp;
     appendPropertyElement(tmp, property);     appendPropertyElement(tmp, property);
     tmp.append('\0');     tmp.append('\0');
     os << tmp.getData() << PEGASUS_STD(endl);     os << tmp.getData() << PEGASUS_STD(endl);
Line 1476 
Line 1477 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendMethodElement( void XmlWriter::appendMethodElement(
     Array<char>& out,      Buffer& out,
     const CIMConstMethod& method)     const CIMConstMethod& method)
 { {
     method._checkRep();     method._checkRep();
Line 1487 
Line 1488 
     const CIMConstMethod& method,     const CIMConstMethod& method,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<char> tmp;      Buffer tmp;
     appendMethodElement(tmp, method);     appendMethodElement(tmp, method);
     tmp.append('\0');     tmp.append('\0');
     os << tmp.getData() << PEGASUS_STD(endl);     os << tmp.getData() << PEGASUS_STD(endl);
Line 1522 
Line 1523 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendParameterElement( void XmlWriter::appendParameterElement(
     Array<char>& out,      Buffer& out,
     const CIMConstParameter& parameter)     const CIMConstParameter& parameter)
 { {
     parameter._checkRep();     parameter._checkRep();
Line 1533 
Line 1534 
     const CIMConstParameter& parameter,     const CIMConstParameter& parameter,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<char> tmp;      Buffer tmp;
     appendParameterElement(tmp, parameter);     appendParameterElement(tmp, parameter);
     tmp.append('\0');     tmp.append('\0');
     os << tmp.getData() << PEGASUS_STD(endl);     os << tmp.getData() << PEGASUS_STD(endl);
Line 1550 
Line 1551 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendParamValueElement( void XmlWriter::appendParamValueElement(
     Array<char>& out,      Buffer& out,
     const CIMParamValue& paramValue)     const CIMParamValue& paramValue)
 { {
     paramValue._checkRep();     paramValue._checkRep();
Line 1561 
Line 1562 
     const CIMParamValue& paramValue,     const CIMParamValue& paramValue,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<char> tmp;      Buffer tmp;
     appendParamValueElement(tmp, paramValue);     appendParamValueElement(tmp, paramValue);
     tmp.append('\0');     tmp.append('\0');
     os << tmp.getData() << PEGASUS_STD(endl);     os << tmp.getData() << PEGASUS_STD(endl);
Line 1581 
Line 1582 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendQualifierElement( void XmlWriter::appendQualifierElement(
     Array<char>& out,      Buffer& out,
     const CIMConstQualifier& qualifier)     const CIMConstQualifier& qualifier)
 { {
     qualifier._checkRep();     qualifier._checkRep();
Line 1592 
Line 1593 
     const CIMConstQualifier& qualifier,     const CIMConstQualifier& qualifier,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<char> tmp;      Buffer tmp;
     appendQualifierElement(tmp, qualifier);     appendQualifierElement(tmp, qualifier);
     tmp.append('\0');     tmp.append('\0');
     os << tmp.getData() << PEGASUS_STD(endl);     os << tmp.getData() << PEGASUS_STD(endl);
Line 1613 
Line 1614 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendQualifierDeclElement( void XmlWriter::appendQualifierDeclElement(
     Array<char>& out,      Buffer& out,
     const CIMConstQualifierDecl& qualifierDecl)     const CIMConstQualifierDecl& qualifierDecl)
 { {
     qualifierDecl._checkRep();     qualifierDecl._checkRep();
Line 1624 
Line 1625 
     const CIMConstQualifierDecl& qualifierDecl,     const CIMConstQualifierDecl& qualifierDecl,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<char> tmp;      Buffer tmp;
     appendQualifierDeclElement(tmp, qualifierDecl);     appendQualifierDeclElement(tmp, qualifierDecl);
     tmp.append('\0');     tmp.append('\0');
     os << tmp.getData() << PEGASUS_STD(endl);     os << tmp.getData() << PEGASUS_STD(endl);
Line 1642 
Line 1643 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendQualifierFlavorEntity( void XmlWriter::appendQualifierFlavorEntity(
     Array<char>& out,      Buffer& out,
     const CIMFlavor & flavor)     const CIMFlavor & flavor)
 { {
     if (!(flavor.hasFlavor (CIMFlavor::OVERRIDABLE)))     if (!(flavor.hasFlavor (CIMFlavor::OVERRIDABLE)))
Line 1675 
Line 1676 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendScopeElement( void XmlWriter::appendScopeElement(
     Array<char>& out,      Buffer& out,
     const CIMScope & scope)     const CIMScope & scope)
 { {
     if (!(scope.equal (CIMScope ())))     if (!(scope.equal (CIMScope ())))
Line 1719 
Line 1720 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendMethodCallHeader( void XmlWriter::appendMethodCallHeader(
     Array<char>& out,      Buffer& out,
     const char* host,     const char* host,
     const CIMName& cimMethod,     const CIMName& cimMethod,
     const String& cimObject,     const String& cimObject,
Line 1797 
Line 1798 
  
  
 void XmlWriter::appendMethodResponseHeader( void XmlWriter::appendMethodResponseHeader(
      Array<char>& out,       Buffer& out,
      HttpMethod httpMethod,      HttpMethod httpMethod,
      const ContentLanguages & contentLanguages,      const ContentLanguages & contentLanguages,
      Uint32 contentLength,      Uint32 contentLength,
Line 1843 
Line 1844 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendHttpErrorResponseHeader( void XmlWriter::appendHttpErrorResponseHeader(
     Array<char>& out,      Buffer& out,
     const String& status,     const String& status,
     const String& cimError,     const String& cimError,
     const String& errorDetail)     const String& errorDetail)
Line 1884 
Line 1885 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendUnauthorizedResponseHeader( void XmlWriter::appendUnauthorizedResponseHeader(
     Array<char>& out,      Buffer& out,
     const String& content)     const String& content)
 { {
     out << "HTTP/1.1 " HTTP_STATUS_UNAUTHORIZED "\r\n";     out << "HTTP/1.1 " HTTP_STATUS_UNAUTHORIZED "\r\n";
Line 1923 
Line 1924 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendOKResponseHeader( void XmlWriter::appendOKResponseHeader(
     Array<char>& out,      Buffer& out,
     const String& content)     const String& content)
 { {
     out << "HTTP/1.1 " HTTP_STATUS_OK "\r\n";     out << "HTTP/1.1 " HTTP_STATUS_OK "\r\n";
Line 1960 
Line 1961 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendMessageElementBegin( void XmlWriter::_appendMessageElementBegin(
     Array<char>& out,      Buffer& out,
     const String& messageId)     const String& messageId)
 { {
     out << "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";     out << "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";
Line 1969 
Line 1970 
 } }
  
 void XmlWriter::_appendMessageElementEnd( void XmlWriter::_appendMessageElementEnd(
     Array<char>& out)      Buffer& out)
 { {
     out << "</MESSAGE>\n";     out << "</MESSAGE>\n";
     out << "</CIM>\n";     out << "</CIM>\n";
Line 1985 
Line 1986 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendSimpleReqElementBegin( void XmlWriter::_appendSimpleReqElementBegin(
     Array<char>& out)      Buffer& out)
 { {
     out << "<SIMPLEREQ>\n";     out << "<SIMPLEREQ>\n";
 } }
  
 void XmlWriter::_appendSimpleReqElementEnd( void XmlWriter::_appendSimpleReqElementEnd(
     Array<char>& out)      Buffer& out)
 { {
     out << "</SIMPLEREQ>\n";     out << "</SIMPLEREQ>\n";
 } }
Line 2007 
Line 2008 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendMethodCallElementBegin( void XmlWriter::_appendMethodCallElementBegin(
     Array<char>& out,      Buffer& out,
     const CIMName& name)     const CIMName& name)
 { {
     out << "<METHODCALL NAME=\"" << name << "\">\n";     out << "<METHODCALL NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::_appendMethodCallElementEnd( void XmlWriter::_appendMethodCallElementEnd(
     Array<char>& out)      Buffer& out)
 { {
     out << "</METHODCALL>\n";     out << "</METHODCALL>\n";
 } }
Line 2030 
Line 2031 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendIMethodCallElementBegin( void XmlWriter::_appendIMethodCallElementBegin(
     Array<char>& out,      Buffer& out,
     const CIMName& name)     const CIMName& name)
 { {
     out << "<IMETHODCALL NAME=\"" << name << "\">\n";     out << "<IMETHODCALL NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::_appendIMethodCallElementEnd( void XmlWriter::_appendIMethodCallElementEnd(
     Array<char>& out)      Buffer& out)
 { {
     out << "</IMETHODCALL>\n";     out << "</IMETHODCALL>\n";
 } }
Line 2055 
Line 2056 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendIParamValueElementBegin( void XmlWriter::_appendIParamValueElementBegin(
     Array<char>& out,      Buffer& out,
     const char* name)     const char* name)
 { {
     out << "<IPARAMVALUE NAME=\"" << name << "\">\n";     out << "<IPARAMVALUE NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::_appendIParamValueElementEnd( void XmlWriter::_appendIParamValueElementEnd(
     Array<char>& out)      Buffer& out)
 { {
     out << "</IPARAMVALUE>\n";     out << "</IPARAMVALUE>\n";
 } }
Line 2077 
Line 2078 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendSimpleRspElementBegin( void XmlWriter::_appendSimpleRspElementBegin(
     Array<char>& out)      Buffer& out)
 { {
     out << "<SIMPLERSP>\n";     out << "<SIMPLERSP>\n";
 } }
  
 void XmlWriter::_appendSimpleRspElementEnd( void XmlWriter::_appendSimpleRspElementEnd(
     Array<char>& out)      Buffer& out)
 { {
     out << "</SIMPLERSP>\n";     out << "</SIMPLERSP>\n";
 } }
Line 2099 
Line 2100 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendMethodResponseElementBegin( void XmlWriter::_appendMethodResponseElementBegin(
     Array<char>& out,      Buffer& out,
     const CIMName& name)     const CIMName& name)
 { {
     out << "<METHODRESPONSE NAME=\"" << name << "\">\n";     out << "<METHODRESPONSE NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::_appendMethodResponseElementEnd( void XmlWriter::_appendMethodResponseElementEnd(
     Array<char>& out)      Buffer& out)
 { {
     out << "</METHODRESPONSE>\n";     out << "</METHODRESPONSE>\n";
 } }
Line 2122 
Line 2123 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendIMethodResponseElementBegin( void XmlWriter::_appendIMethodResponseElementBegin(
     Array<char>& out,      Buffer& out,
     const CIMName& name)     const CIMName& name)
 { {
     out << "<IMETHODRESPONSE NAME=\"" << name << "\">\n";     out << "<IMETHODRESPONSE NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::_appendIMethodResponseElementEnd( void XmlWriter::_appendIMethodResponseElementEnd(
     Array<char>& out)      Buffer& out)
 { {
     out << "</IMETHODRESPONSE>\n";     out << "</IMETHODRESPONSE>\n";
 } }
Line 2141 
Line 2142 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendErrorElement( void XmlWriter::_appendErrorElement(
     Array<char>& out,      Buffer& out,
     const CIMException& cimException)     const CIMException& cimException)
 { {
     Tracer::traceCIMException(TRC_XML_WRITER, Tracer::LEVEL2, cimException);     Tracer::traceCIMException(TRC_XML_WRITER, Tracer::LEVEL2, cimException);
Line 2170 
Line 2171 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendReturnValueElement( void XmlWriter::appendReturnValueElement(
     Array<char>& out,      Buffer& out,
     const CIMValue& value)     const CIMValue& value)
 { {
     out << "<RETURNVALUE";     out << "<RETURNVALUE";
Line 2211 
Line 2212 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendIReturnValueElementBegin( void XmlWriter::_appendIReturnValueElementBegin(
     Array<char>& out)      Buffer& out)
 { {
     out << "<IRETURNVALUE>\n";     out << "<IRETURNVALUE>\n";
 } }
  
 void XmlWriter::_appendIReturnValueElementEnd( void XmlWriter::_appendIReturnValueElementEnd(
     Array<char>& out)      Buffer& out)
 { {
     out << "</IRETURNVALUE>\n";     out << "</IRETURNVALUE>\n";
 } }
Line 2229 
Line 2230 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendBooleanIParameter( void XmlWriter::appendBooleanIParameter(
     Array<char>& out,      Buffer& out,
     const char* name,     const char* name,
     Boolean flag)     Boolean flag)
 { {
Line 2247 
Line 2248 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendStringIParameter( void XmlWriter::appendStringIParameter(
     Array<char>& out,      Buffer& out,
     const char* name,     const char* name,
     const String& str)     const String& str)
 { {
Line 2265 
Line 2266 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendQualifierNameIParameter( void XmlWriter::appendQualifierNameIParameter(
     Array<char>& out,      Buffer& out,
     const char* name,     const char* name,
     const String& qualifierName)     const String& qualifierName)
 { {
Line 2289 
Line 2290 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendClassNameIParameter( void XmlWriter::appendClassNameIParameter(
     Array<char>& out,      Buffer& out,
     const char* name,     const char* name,
     const CIMName& className)     const CIMName& className)
 { {
Line 2314 
Line 2315 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendInstanceNameIParameter( void XmlWriter::appendInstanceNameIParameter(
     Array<char>& out,      Buffer& out,
     const char* name,     const char* name,
     const CIMObjectPath& instanceName)     const CIMObjectPath& instanceName)
 { {
Line 2324 
Line 2325 
 } }
  
 void XmlWriter::appendObjectNameIParameter( void XmlWriter::appendObjectNameIParameter(
     Array<char>& out,      Buffer& out,
     const char* name,     const char* name,
     const CIMObjectPath& objectName)     const CIMObjectPath& objectName)
 { {
Line 2353 
Line 2354 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendClassIParameter( void XmlWriter::appendClassIParameter(
     Array<char>& out,      Buffer& out,
     const char* name,     const char* name,
     const CIMConstClass& cimClass)     const CIMConstClass& cimClass)
 { {
Line 2369 
Line 2370 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendInstanceIParameter( void XmlWriter::appendInstanceIParameter(
     Array<char>& out,      Buffer& out,
     const char* name,     const char* name,
     const CIMConstInstance& instance)     const CIMConstInstance& instance)
 { {
Line 2385 
Line 2386 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendNamedInstanceIParameter( void XmlWriter::appendNamedInstanceIParameter(
     Array<char>& out,      Buffer& out,
     const char* name,     const char* name,
     const CIMInstance& namedInstance)     const CIMInstance& namedInstance)
 { {
Line 2404 
Line 2405 
 //     USE: Create parameter for getProperty operation //     USE: Create parameter for getProperty operation
 //========================================================== //==========================================================
 void XmlWriter::appendPropertyNameIParameter( void XmlWriter::appendPropertyNameIParameter(
     Array<char>& out,      Buffer& out,
     const CIMName& propertyName)     const CIMName& propertyName)
 { {
     _appendIParamValueElementBegin(out, "PropertyName");     _appendIParamValueElementBegin(out, "PropertyName");
Line 2419 
Line 2420 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendPropertyValueIParameter( void XmlWriter::appendPropertyValueIParameter(
     Array<char>& out,      Buffer& out,
     const char* name,     const char* name,
     const CIMValue& value)     const CIMValue& value)
 { {
Line 2435 
Line 2436 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendPropertyListIParameter( void XmlWriter::appendPropertyListIParameter(
     Array<char>& out,      Buffer& out,
     const CIMPropertyList& propertyList)     const CIMPropertyList& propertyList)
 { {
     _appendIParamValueElementBegin(out, "PropertyList");     _appendIParamValueElementBegin(out, "PropertyList");
Line 2464 
Line 2465 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendQualifierDeclarationIParameter( void XmlWriter::appendQualifierDeclarationIParameter(
     Array<char>& out,      Buffer& out,
     const char* name,     const char* name,
     const CIMConstQualifierDecl& qualifierDecl)     const CIMConstQualifierDecl& qualifierDecl)
 { {
Line 2479 
Line 2480 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<char> XmlWriter::formatHttpErrorRspMessage(  Buffer XmlWriter::formatHttpErrorRspMessage(
     const String& status,     const String& status,
     const String& cimError,     const String& cimError,
     const String& errorDetail)     const String& errorDetail)
 { {
     Array<char> out;      Buffer out;
  
     appendHttpErrorResponseHeader(out, status, cimError, errorDetail);     appendHttpErrorResponseHeader(out, status, cimError, errorDetail);
  
Line 2500 
Line 2501 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 // ATTN-RK-P1-20020228: Need to complete copy elimination optimization // ATTN-RK-P1-20020228: Need to complete copy elimination optimization
 Array<char> XmlWriter::formatSimpleMethodReqMessage(  Buffer XmlWriter::formatSimpleMethodReqMessage(
     const char* host,     const char* host,
     const CIMNamespaceName& nameSpace,     const CIMNamespaceName& nameSpace,
     const CIMObjectPath& path,     const CIMObjectPath& path,
Line 2512 
Line 2513 
     const AcceptLanguages& httpAcceptLanguages,     const AcceptLanguages& httpAcceptLanguages,
     const ContentLanguages& httpContentLanguages)     const ContentLanguages& httpContentLanguages)
 { {
     Array<char> out;      Buffer out;
     Array<char> tmp;      Buffer tmp;
     CIMObjectPath localObjectPath = path;     CIMObjectPath localObjectPath = path;
     localObjectPath.setNameSpace(nameSpace.getString());     localObjectPath.setNameSpace(nameSpace.getString());
     localObjectPath.setHost(String::EMPTY);     localObjectPath.setHost(String::EMPTY);
Line 2546 
Line 2547 
 } }
  
 //PEP 128 adding serverRsponseTime to header //PEP 128 adding serverRsponseTime to header
 Array<char> XmlWriter::formatSimpleMethodRspMessage(  Buffer XmlWriter::formatSimpleMethodRspMessage(
     const CIMName& methodName,     const CIMName& methodName,
     const String& messageId,     const String& messageId,
     HttpMethod httpMethod,     HttpMethod httpMethod,
     const ContentLanguages & httpContentLanguages,     const ContentLanguages & httpContentLanguages,
     const Array<char>& body,      const Buffer& body,
                 Uint32 serverResponseTime,                 Uint32 serverResponseTime,
                 Boolean isFirst,                 Boolean isFirst,
                 Boolean isLast)                 Boolean isLast)
 { {
         Array<char> out;          Buffer out;
  
         if (isFirst == true)         if (isFirst == true)
         {         {
Line 2592 
Line 2593 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<char> XmlWriter::formatSimpleMethodErrorRspMessage(  Buffer XmlWriter::formatSimpleMethodErrorRspMessage(
     const CIMName& methodName,     const CIMName& methodName,
     const String& messageId,     const String& messageId,
     HttpMethod httpMethod,     HttpMethod httpMethod,
     const CIMException& cimException)     const CIMException& cimException)
 { {
     Array<char> out;      Buffer out;
     Array<char> tmp;      Buffer tmp;
  
     _appendMessageElementBegin(out, messageId);     _appendMessageElementBegin(out, messageId);
     _appendSimpleRspElementBegin(out);     _appendSimpleRspElementBegin(out);
Line 2625 
Line 2626 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<char> XmlWriter::formatSimpleIMethodReqMessage(  Buffer XmlWriter::formatSimpleIMethodReqMessage(
     const char* host,     const char* host,
     const CIMNamespaceName& nameSpace,     const CIMNamespaceName& nameSpace,
     const CIMName& iMethodName,     const CIMName& iMethodName,
Line 2634 
Line 2635 
     const String& authenticationHeader,     const String& authenticationHeader,
     const AcceptLanguages& httpAcceptLanguages,     const AcceptLanguages& httpAcceptLanguages,
     const ContentLanguages& httpContentLanguages,     const ContentLanguages& httpContentLanguages,
     const Array<char>& body)      const Buffer& body)
 { {
     Array<char> out;      Buffer out;
     Array<char> tmp;      Buffer tmp;
  
     _appendMessageElementBegin(out, messageId);     _appendMessageElementBegin(out, messageId);
     _appendSimpleReqElementBegin(out);     _appendSimpleReqElementBegin(out);
Line 2669 
Line 2670 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<char> XmlWriter::formatSimpleIMethodRspMessage(  Buffer XmlWriter::formatSimpleIMethodRspMessage(
     const CIMName& iMethodName,     const CIMName& iMethodName,
     const String& messageId,     const String& messageId,
     HttpMethod httpMethod,     HttpMethod httpMethod,
     const ContentLanguages & httpContentLanguages,     const ContentLanguages & httpContentLanguages,
     const Array<char>& body,      const Buffer& body,
     Uint32 serverResponseTime,     Uint32 serverResponseTime,
     Boolean isFirst,     Boolean isFirst,
     Boolean isLast)     Boolean isLast)
 { {
     Array<char> out;      Buffer out;
  
                 if (isFirst == true)                 if (isFirst == true)
                 {                 {
Line 2724 
Line 2725 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<char> XmlWriter::formatSimpleIMethodErrorRspMessage(  Buffer XmlWriter::formatSimpleIMethodErrorRspMessage(
     const CIMName& iMethodName,     const CIMName& iMethodName,
     const String& messageId,     const String& messageId,
     HttpMethod httpMethod,     HttpMethod httpMethod,
     const CIMException& cimException)     const CIMException& cimException)
 { {
     Array<char> out;      Buffer out;
     Array<char> tmp;      Buffer tmp;
  
     _appendMessageElementBegin(out, messageId);     _appendMessageElementBegin(out, messageId);
     _appendSimpleRspElementBegin(out);     _appendSimpleRspElementBegin(out);
Line 2766 
Line 2767 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendEMethodRequestHeader( void XmlWriter::appendEMethodRequestHeader(
     Array<char>& out,      Buffer& out,
     const char* requestUri,     const char* requestUri,
     const char* host,     const char* host,
     const CIMName& cimMethod,     const CIMName& cimMethod,
Line 2841 
Line 2842 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendEMethodResponseHeader( void XmlWriter::appendEMethodResponseHeader(
     Array<char>& out,      Buffer& out,
     HttpMethod httpMethod,     HttpMethod httpMethod,
     const ContentLanguages& contentLanguages,     const ContentLanguages& contentLanguages,
     Uint32 contentLength)     Uint32 contentLength)
Line 2880 
Line 2881 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendSimpleExportReqElementBegin( void XmlWriter::_appendSimpleExportReqElementBegin(
     Array<char>& out)      Buffer& out)
 { {
     out << "<SIMPLEEXPREQ>\n";     out << "<SIMPLEEXPREQ>\n";
 } }
  
 void XmlWriter::_appendSimpleExportReqElementEnd( void XmlWriter::_appendSimpleExportReqElementEnd(
     Array<char>& out)      Buffer& out)
 { {
     out << "</SIMPLEEXPREQ>\n";     out << "</SIMPLEEXPREQ>\n";
 } }
Line 2902 
Line 2903 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendEMethodCallElementBegin( void XmlWriter::_appendEMethodCallElementBegin(
     Array<char>& out,      Buffer& out,
     const CIMName& name)     const CIMName& name)
 { {
     out << "<EXPMETHODCALL NAME=\"" << name << "\">\n";     out << "<EXPMETHODCALL NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::_appendEMethodCallElementEnd( void XmlWriter::_appendEMethodCallElementEnd(
     Array<char>& out)      Buffer& out)
 { {
     out << "</EXPMETHODCALL>\n";     out << "</EXPMETHODCALL>\n";
 } }
Line 2926 
Line 2927 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendEParamValueElementBegin( void XmlWriter::_appendEParamValueElementBegin(
     Array<char>& out,      Buffer& out,
     const char* name)     const char* name)
 { {
     out << "<EXPPARAMVALUE NAME=\"" << name << "\">\n";     out << "<EXPPARAMVALUE NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::_appendEParamValueElementEnd( void XmlWriter::_appendEParamValueElementEnd(
     Array<char>& out)      Buffer& out)
 { {
     out << "</EXPPARAMVALUE>\n";     out << "</EXPPARAMVALUE>\n";
 } }
Line 2945 
Line 2946 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendInstanceEParameter( void XmlWriter::appendInstanceEParameter(
     Array<char>& out,      Buffer& out,
     const char* name,     const char* name,
     const CIMInstance& instance)     const CIMInstance& instance)
 { {
Line 2964 
Line 2965 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendSimpleExportRspElementBegin( void XmlWriter::_appendSimpleExportRspElementBegin(
     Array<char>& out)      Buffer& out)
 { {
     out << "<SIMPLEEXPRSP>\n";     out << "<SIMPLEEXPRSP>\n";
 } }
  
 void XmlWriter::_appendSimpleExportRspElementEnd( void XmlWriter::_appendSimpleExportRspElementEnd(
     Array<char>& out)      Buffer& out)
 { {
     out << "</SIMPLEEXPRSP>\n";     out << "</SIMPLEEXPRSP>\n";
 } }
Line 2986 
Line 2987 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendEMethodResponseElementBegin( void XmlWriter::_appendEMethodResponseElementBegin(
     Array<char>& out,      Buffer& out,
     const CIMName& name)     const CIMName& name)
 { {
     out << "<EXPMETHODRESPONSE NAME=\"" << name << "\">\n";     out << "<EXPMETHODRESPONSE NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::_appendEMethodResponseElementEnd( void XmlWriter::_appendEMethodResponseElementEnd(
     Array<char>& out)      Buffer& out)
 { {
     out << "</EXPMETHODRESPONSE>\n";     out << "</EXPMETHODRESPONSE>\n";
 } }
Line 3004 
Line 3005 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<char> XmlWriter::formatSimpleEMethodReqMessage(  Buffer XmlWriter::formatSimpleEMethodReqMessage(
     const char* requestUri,     const char* requestUri,
     const char* host,     const char* host,
     const CIMName& eMethodName,     const CIMName& eMethodName,
Line 3013 
Line 3014 
     const String& authenticationHeader,     const String& authenticationHeader,
     const AcceptLanguages& httpAcceptLanguages,     const AcceptLanguages& httpAcceptLanguages,
     const ContentLanguages& httpContentLanguages,     const ContentLanguages& httpContentLanguages,
     const Array<char>& body)      const Buffer& body)
 { {
     Array<char> out;      Buffer out;
     Array<char> tmp;      Buffer tmp;
  
     _appendMessageElementBegin(out, messageId);     _appendMessageElementBegin(out, messageId);
     _appendSimpleExportReqElementBegin(out);     _appendSimpleExportReqElementBegin(out);
Line 3047 
Line 3048 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<char> XmlWriter::formatSimpleEMethodRspMessage(  Buffer XmlWriter::formatSimpleEMethodRspMessage(
     const CIMName& eMethodName,     const CIMName& eMethodName,
     const String& messageId,     const String& messageId,
     HttpMethod httpMethod,     HttpMethod httpMethod,
     const ContentLanguages& httpContentLanguages,     const ContentLanguages& httpContentLanguages,
     const Array<char>& body)      const Buffer& body)
 { {
     Array<char> out;      Buffer out;
     Array<char> tmp;      Buffer tmp;
  
     _appendMessageElementBegin(out, messageId);     _appendMessageElementBegin(out, messageId);
     _appendSimpleExportRspElementBegin(out);     _appendSimpleExportRspElementBegin(out);
Line 3080 
Line 3081 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<char> XmlWriter::formatSimpleEMethodErrorRspMessage(  Buffer XmlWriter::formatSimpleEMethodErrorRspMessage(
     const CIMName& eMethodName,     const CIMName& eMethodName,
     const String& messageId,     const String& messageId,
     HttpMethod httpMethod,     HttpMethod httpMethod,
     const CIMException& cimException)     const CIMException& cimException)
 { {
     Array<char> out;      Buffer out;
     Array<char> tmp;      Buffer tmp;
  
     _appendMessageElementBegin(out, messageId);     _appendMessageElementBegin(out, messageId);
     _appendSimpleExportRspElementBegin(out);     _appendSimpleExportRspElementBegin(out);

Legend:
Removed from v.1.124  
changed lines
  Added in v.1.125
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2