(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.113 and 1.122

version 1.113, 2004/10/25 18:26:02 version 1.122, 2005/04/14 17:53:53
Line 1 
Line 1 
 //%2004////////////////////////////////////////////////////////////////////////  //%2005////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems. // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
Line 6 
Line 6 
 // IBM Corp.; EMC Corporation, The Open Group. // IBM Corp.; EMC Corporation, The Open Group.
 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.; // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
 // //
 // 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
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 36 
Line 38 
 //         Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase1 //         Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase1
 //                               Willis White (whiwill@us.ibm.com) PEP 127 and 128 //                               Willis White (whiwill@us.ibm.com) PEP 127 and 128
 //         Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase2 //         Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase2
   //              Dave Sudlik, IBM (dsudlik@us.ibm.com)
   //              David Dillard, VERITAS Software Corp.
   //                  (david.dillard@veritas.com)
   //              Vijay Eli, vijayeli@in.ibm.com, fix for #2571
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 82 
Line 88 
   out << "content-length: " << contentLengthP << "\r\n";     \   out << "content-length: " << contentLengthP << "\r\n";     \
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, const char* x)  Array<char>& operator<<(Array<char>& out, const char* x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
     return out;     return out;
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, char x)  Array<char>& operator<<(Array<char>& out, char x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
     return out;     return out;
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, const Char16& x)  Array<char>& operator<<(Array<char>& out, const Char16& x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
     return out;     return out;
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, const String& x)  Array<char>& operator<<(Array<char>& out, const String& x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
     return out;     return out;
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, const Indentor& x)  Array<char>& operator<<(Array<char>& out, const Indentor& x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
     return out;     return out;
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, const Array<Sint8>& x)  Array<char>& operator<<(Array<char>& out, const Array<char>& x)
 { {
     out.appendArray(x);     out.appendArray(x);
     return out;     return out;
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, Uint32 x)  Array<char>& operator<<(Array<char>& out, Uint32 x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
     return out;     return out;
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, const CIMName& name)  Array<char>& operator<<(Array<char>& out, const CIMName& name)
 { {
     XmlWriter::append(out, name.getString ());     XmlWriter::append(out, name.getString ());
     return out;     return out;
Line 132 
Line 138 
  
  
 // l10n // l10n
 Array<Sint8>& operator<<(Array<Sint8>& out, const AcceptLanguages& al)  Array<char>& operator<<(Array<char>& out, const AcceptLanguages& al)
 { {
     XmlWriter::append(out, al.toString ());     XmlWriter::append(out, al.toString ());
     return out;     return out;
 } }
  
 // l10n // l10n
 Array<Sint8>& operator<<(Array<Sint8>& out, const ContentLanguages& cl)  Array<char>& operator<<(Array<char>& out, const ContentLanguages& cl)
 { {
     XmlWriter::append(out, cl.toString ());     XmlWriter::append(out, cl.toString ());
     return out;     return out;
Line 164 
Line 170 
     return os;     return os;
 } }
  
 inline void _xmlWritter_appendChar(Array<Sint8>& out, const Char16& c)  inline void _xmlWritter_appendChar(Array<char>& 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.
     // NOTE: The UTF8 character could be several bytes long.     // NOTE: The UTF8 character could be several bytes long.
     // WARNING: This function will put in replacement character for     // WARNING: This function will put in replacement character for
     // all characters that have surogate pairs.     // all characters that have surogate pairs.
     Uint8 str[6];      char str[6];
     memset(str,0x00,sizeof(str));     memset(str,0x00,sizeof(str));
     Uint8* charIN = (Uint8 *)&c;     Uint8* charIN = (Uint8 *)&c;
  
Line 186 
Line 192 
                 &strtgt,                 &strtgt,
                 endtgt);                 endtgt);
  
     out.append((Sint8 *)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<Sint8>& out, const Char16& c)  inline void _xmlWritter_appendSpecialChar(Array<char>& out, const Char16& c)
 { {
     if ( ((c < Char16(0x20)) && (c >= Char16(0x00))) || (c == Char16(0x7f)) )     if ( ((c < Char16(0x20)) && (c >= Char16(0x00))) || (c == Char16(0x7f)) )
     {     {
         char charref[7];         char charref[7];
         sprintf(charref, "&#%u;", (Uint16)c);         sprintf(charref, "&#%u;", (Uint16)c);
         out.append(charref, strlen(charref));          out.append(charref, static_cast<Uint32>(strlen(charref)));
     }     }
     else     else
     {     {
Line 228 
Line 234 
                     // NOTE: The UTF8 character could be several bytes long.                     // NOTE: The UTF8 character could be several bytes long.
                     // WARNING: This function will put in replacement character for                     // WARNING: This function will put in replacement character for
                     // all characters that have surogate pairs.                     // all characters that have surogate pairs.
                     Uint8 str[6];              char str[6];
                     memset(str,0x00,sizeof(str));                     memset(str,0x00,sizeof(str));
                     Uint8* charIN = (Uint8 *)&c;                      const char* charIN = reinterpret_cast<const char *>(&c);
  
                     const Uint16 *strsrc = (Uint16 *)charIN;                      const Uint16 *strsrc = (const Uint16 *)charIN;
                     Uint16 *endsrc = (Uint16 *)&charIN[1];                      const Uint16 *endsrc = (const Uint16 *)&charIN[1];
  
                     Uint8 *strtgt = (Uint8 *)str;                     Uint8 *strtgt = (Uint8 *)str;
                     Uint8 *endtgt = (Uint8 *)&str[5];                     Uint8 *endtgt = (Uint8 *)&str[5];
Line 245 
Line 251 
  
                     Uint32 number1 = UTF_8_COUNT_TRAIL_BYTES(str[0]) + 1;                     Uint32 number1 = UTF_8_COUNT_TRAIL_BYTES(str[0]) + 1;
  
                     out.append((Sint8 *)str,number1);                      out.append(str,number1);
                 }                 }
         }         }
     }     }
 } }
  
 inline void _xmlWritter_appendSpecialChar(Array<Sint8>& out, char c)  inline void _xmlWritter_appendSpecialChar(Array<char>& out, char c)
 { {
     if ( ((c < Char16(0x20)) && (c >= Char16(0x00))) || (c == Char16(0x7f)) )          if ( ((c < 0x20) && (c >= 0)) || (c == 0x7f) )
     {     {
         char charref[7];         char charref[7];
         sprintf(charref, "&#%u;", (Uint8)c);         sprintf(charref, "&#%u;", (Uint8)c);
         out.append(charref, strlen(charref));          out.append(charref, static_cast<Uint32>(strlen(charref)));
     }     }
     else     else
     {     {
Line 284 
Line 290 
                 break;                 break;
  
             default:             default:
                 out.append(Sint8(c));                  out.append(static_cast<Sint8>(c));
         }         }
     }     }
 } }
Line 292 
Line 298 
  
 inline void _xmlWritter_appendSpecialChar(PEGASUS_STD(ostream)& os, char c) inline void _xmlWritter_appendSpecialChar(PEGASUS_STD(ostream)& os, char c)
 { {
     if ( (c < Char16(0x20)) || (c == Char16(0x7f)) )      if ( ((c < 0x20) && (c >= 0)) || (c == 0x7f) )
     {     {
         char charref[7];         char charref[7];
         sprintf(charref, "&#%u;", (Uint8)c);          sprintf(charref, "&#%u;", static_cast<Uint8>(c));
         os << charref;         os << charref;
     }     }
     else     else
Line 328 
Line 334 
     }     }
 } }
  
 void _xmlWritter_appendSurrogatePair(Array<Sint8>& out, Uint16 high, Uint16 low)  void _xmlWritter_appendSurrogatePair(Array<char>& out, Uint16 high, Uint16 low)
 { {
     Uint8 str[6];      char str[6];
     Uint8 charIN[5];     Uint8 charIN[5];
     memset(str,0x00,sizeof(str));     memset(str,0x00,sizeof(str));
     memcpy(&charIN,&high,2);     memcpy(&charIN,&high,2);
Line 347 
Line 353 
                 endtgt);                 endtgt);
  
     Uint32 number1 = UTF_8_COUNT_TRAIL_BYTES(str[0]) + 1;     Uint32 number1 = UTF_8_COUNT_TRAIL_BYTES(str[0]) + 1;
     out.append((Sint8 *)str,number1);      out.append(str,number1);
 } }
  
 inline void _xmlWritter_appendSpecial(PEGASUS_STD(ostream)& os, const char* str) inline void _xmlWritter_appendSpecial(PEGASUS_STD(ostream)& os, const char* str)
Line 356 
Line 362 
         _xmlWritter_appendSpecialChar(os, *str++);         _xmlWritter_appendSpecialChar(os, *str++);
 } }
  
 void XmlWriter::append(Array<Sint8>& out, const Char16& x)  void XmlWriter::append(Array<char>& out, const Char16& x)
 { {
     _xmlWritter_appendChar(out, x);     _xmlWritter_appendChar(out, x);
 } }
  
 void XmlWriter::append(Array<Sint8>& out, Boolean x)  void XmlWriter::append(Array<char>& out, Boolean x)
 { {
     append(out, (x ? "TRUE" : "FALSE"));     append(out, (x ? "TRUE" : "FALSE"));
 } }
  
 void XmlWriter::append(Array<Sint8>& out, Uint32 x)  void XmlWriter::append(Array<char>& 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<Sint8>& out, Sint32 x)  void XmlWriter::append(Array<char>& 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<Sint8>& out, Uint64 x)  void XmlWriter::append(Array<char>& 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<Sint8>& out, Sint64 x)  void XmlWriter::append(Array<char>& 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<Sint8>& out, Real32 x)  void XmlWriter::append(Array<char>& 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 404 
Line 410 
     append(out, buffer);     append(out, buffer);
 } }
  
 void XmlWriter::append(Array<Sint8>& out, Real64 x)  void XmlWriter::append(Array<char>& 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 414 
Line 420 
     append(out, buffer);     append(out, buffer);
 } }
  
 void XmlWriter::append(Array<Sint8>& out, const char* str)  void XmlWriter::append(Array<char>& out, const char* str)
 { {
     while (*str)     while (*str)
       XmlWriter::append(out, *str++);       XmlWriter::append(out, *str++);
 } }
  
 void XmlWriter::append(Array<Sint8>& out, const String& str)  void XmlWriter::append(Array<char>& out, const String& str)
 { {
     for (Uint32 i = 0; i < str.size(); i++)     for (Uint32 i = 0; i < str.size(); i++)
     {     {
Line 440 
Line 446 
     }     }
 } }
  
 void XmlWriter::append(Array<Sint8>& out, const Indentor& x)  void XmlWriter::append(Array<char>& 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<Sint8>& out, const Char16& x)  void XmlWriter::appendSpecial(Array<char>& out, const Char16& x)
 { {
     _xmlWritter_appendSpecialChar(out, x);     _xmlWritter_appendSpecialChar(out, x);
 } }
  
 void XmlWriter::appendSpecial(Array<Sint8>& out, char x)  void XmlWriter::appendSpecial(Array<char>& out, char x)
 { {
     _xmlWritter_appendSpecialChar(out, x);     _xmlWritter_appendSpecialChar(out, x);
 } }
  
 void XmlWriter::appendSpecial(Array<Sint8>& out, const char* str)  void XmlWriter::appendSpecial(Array<char>& out, const char* str)
 { {
     while (*str)     while (*str)
         _xmlWritter_appendSpecialChar(out, *str++);         _xmlWritter_appendSpecialChar(out, *str++);
 } }
  
 void XmlWriter::appendSpecial(Array<Sint8>& out, const String& str)  void XmlWriter::appendSpecial(Array<char>& out, const String& str)
 { {
     for (Uint32 i = 0; i < str.size(); i++)     for (Uint32 i = 0; i < str.size(); i++)
     {     {
Line 520 
Line 526 
     }     }
 } }
  
 String XmlWriter::encodeURICharacters(Array<Sint8> uriString)  String XmlWriter::encodeURICharacters(const Array<char>& uriString)
 { {
     String encodedString;     String encodedString;
  
Line 532 
Line 538 
     return encodedString;     return encodedString;
 } }
  
 String XmlWriter::encodeURICharacters(String uriString)  String XmlWriter::encodeURICharacters(const String& uriString)
 { {
     String encodedString;     String encodedString;
  
Line 547 
Line 553 
     // 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<Sint8> utf8;      Array<char> 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 584 
Line 590 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendLocalNameSpacePathElement( void XmlWriter::appendLocalNameSpacePathElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMNamespaceName& nameSpace)     const CIMNamespaceName& nameSpace)
 { {
     out << "<LOCALNAMESPACEPATH>\n";     out << "<LOCALNAMESPACEPATH>\n";
Line 617 
Line 623 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendNameSpacePathElement( void XmlWriter::appendNameSpacePathElement(
     Array<Sint8>& out,      Array<char>& out,
     const String& host,     const String& host,
     const CIMNamespaceName& nameSpace)     const CIMNamespaceName& nameSpace)
 { {
Line 638 
Line 644 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendClassNameElement( void XmlWriter::appendClassNameElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMName& className)     const CIMName& className)
 { {
     out << "<CLASSNAME NAME=\"" << className << "\"/>\n";     out << "<CLASSNAME NAME=\"" << className << "\"/>\n";
Line 655 
Line 661 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendInstanceNameElement( void XmlWriter::appendInstanceNameElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMObjectPath& instanceName)     const CIMObjectPath& instanceName)
 { {
     out << "<INSTANCENAME CLASSNAME=\"" << instanceName.getClassName() << "\">\n";     out << "<INSTANCENAME CLASSNAME=\"" << instanceName.getClassName() << "\">\n";
Line 694 
Line 700 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendClassPathElement( void XmlWriter::appendClassPathElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMObjectPath& classPath)     const CIMObjectPath& classPath)
 { {
     out << "<CLASSPATH>\n";     out << "<CLASSPATH>\n";
Line 714 
Line 720 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendInstancePathElement( void XmlWriter::appendInstancePathElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMObjectPath& instancePath)     const CIMObjectPath& instancePath)
 { {
     out << "<INSTANCEPATH>\n";     out << "<INSTANCEPATH>\n";
Line 734 
Line 740 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendLocalClassPathElement( void XmlWriter::appendLocalClassPathElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMObjectPath& classPath)     const CIMObjectPath& classPath)
 { {
     out << "<LOCALCLASSPATH>\n";     out << "<LOCALCLASSPATH>\n";
Line 752 
Line 758 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendLocalInstancePathElement( void XmlWriter::appendLocalInstancePathElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMObjectPath& instancePath)     const CIMObjectPath& instancePath)
 { {
     out << "<LOCALINSTANCEPATH>\n";     out << "<LOCALINSTANCEPATH>\n";
Line 771 
Line 777 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendLocalObjectPathElement( void XmlWriter::appendLocalObjectPathElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMObjectPath& objectPath)     const CIMObjectPath& objectPath)
 { {
     //     //
Line 796 
Line 802 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 inline void _xmlWritter_appendValue(Array<Sint8>& out, Boolean x)  inline void _xmlWritter_appendValue(Array<char>& out, Boolean x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _xmlWritter_appendValue(Array<Sint8>& out, Uint8 x)  inline void _xmlWritter_appendValue(Array<char>& out, Uint8 x)
 { {
     XmlWriter::append(out, Uint32(x));     XmlWriter::append(out, Uint32(x));
 } }
  
 inline void _xmlWritter_appendValue(Array<Sint8>& out, Sint8 x)  inline void _xmlWritter_appendValue(Array<char>& out, Sint8 x)
 { {
     XmlWriter::append(out, Sint32(x));     XmlWriter::append(out, Sint32(x));
 } }
  
 inline void _xmlWritter_appendValue(Array<Sint8>& out, Uint16 x)  inline void _xmlWritter_appendValue(Array<char>& out, Uint16 x)
 { {
     XmlWriter::append(out, Uint32(x));     XmlWriter::append(out, Uint32(x));
 } }
  
 inline void _xmlWritter_appendValue(Array<Sint8>& out, Sint16 x)  inline void _xmlWritter_appendValue(Array<char>& out, Sint16 x)
 { {
     XmlWriter::append(out, Sint32(x));     XmlWriter::append(out, Sint32(x));
 } }
  
 inline void _xmlWritter_appendValue(Array<Sint8>& out, Uint32 x)  inline void _xmlWritter_appendValue(Array<char>& out, Uint32 x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _xmlWritter_appendValue(Array<Sint8>& out, Sint32 x)  inline void _xmlWritter_appendValue(Array<char>& out, Sint32 x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _xmlWritter_appendValue(Array<Sint8>& out, Uint64 x)  inline void _xmlWritter_appendValue(Array<char>& out, Uint64 x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _xmlWritter_appendValue(Array<Sint8>& out, Sint64 x)  inline void _xmlWritter_appendValue(Array<char>& out, Sint64 x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _xmlWritter_appendValue(Array<Sint8>& out, Real32 x)  inline void _xmlWritter_appendValue(Array<char>& out, Real32 x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _xmlWritter_appendValue(Array<Sint8>& out, Real64 x)  inline void _xmlWritter_appendValue(Array<char>& out, Real64 x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _xmlWritter_appendValue(Array<Sint8>& out, const Char16& x)  inline void _xmlWritter_appendValue(Array<char>& out, const Char16& x)
 { {
     XmlWriter::appendSpecial(out, x);     XmlWriter::appendSpecial(out, x);
 } }
  
 inline void _xmlWritter_appendValue(Array<Sint8>& out, const String& x)  inline void _xmlWritter_appendValue(Array<char>& out, const String& x)
 { {
     XmlWriter::appendSpecial(out, x);     XmlWriter::appendSpecial(out, x);
 } }
  
 inline void _xmlWritter_appendValue(Array<Sint8>& out, const CIMDateTime& x)  inline void _xmlWritter_appendValue(Array<char>& out, const CIMDateTime& x)
 { {
     out << x.toString();  //ATTN: append() method?     out << x.toString();  //ATTN: append() method?
 } }
  
 inline void _xmlWritter_appendValue(Array<Sint8>& out, const CIMObjectPath& x)  inline void _xmlWritter_appendValue(Array<char>& out, const CIMObjectPath& x)
 { {
     XmlWriter::appendValueReferenceElement(out, x, true);     XmlWriter::appendValueReferenceElement(out, x, true);
 } }
  
 void _xmlWritter_appendValueArray(Array<Sint8>& out, const CIMObjectPath* p, Uint32 size)  inline void _xmlWritter_appendValue(Array<char>& out, const CIMObject& x)
   {
       String myStr = x.toString();
       _xmlWritter_appendValue(out, myStr);
   }
   
   void _xmlWritter_appendValueArray(Array<char>& out, const CIMObjectPath* p, Uint32 size)
 { {
     out << "<VALUE.REFARRAY>\n";     out << "<VALUE.REFARRAY>\n";
     while (size--)     while (size--)
Line 882 
Line 894 
 } }
  
 template<class T> template<class T>
 void _xmlWritter_appendValueArray(Array<Sint8>& out, const T* p, Uint32 size)  void _xmlWritter_appendValueArray(Array<char>& out, const T* p, Uint32 size)
 { {
     out << "<VALUE.ARRAY>\n";     out << "<VALUE.ARRAY>\n";
  
Line 910 
Line 922 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendValueElement( void XmlWriter::appendValueElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMValue& value)     const CIMValue& value)
 { {
     if (value.isNull())     if (value.isNull())
Line 1041 
Line 1053 
                 break;                 break;
             }             }
  
               case CIMTYPE_OBJECT:
               {
                   Array<CIMObject> a;
                   value.get(a);
                   _xmlWritter_appendValueArray(out, a.getData(), a.size());
                   break;
               }
   
             default:             default:
                 PEGASUS_ASSERT(false);                 PEGASUS_ASSERT(false);
         }         }
Line 1170 
Line 1190 
                 break;                 break;
             }             }
  
               case CIMTYPE_OBJECT:
               {
                   CIMObject v;
                   value.get(v);
                   _xmlWritter_appendValue(out, v);
                   break;
               }
   
             default:             default:
                 PEGASUS_ASSERT(false);                 PEGASUS_ASSERT(false);
         }         }
Line 1182 
Line 1210 
     const CIMValue& value,     const CIMValue& value,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<Sint8> tmp;      Array<char> 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 1198 
Line 1226 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendValueObjectWithPathElement( void XmlWriter::appendValueObjectWithPathElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMObject& objectWithPath)     const CIMObject& objectWithPath)
 { {
     out << "<VALUE.OBJECTWITHPATH>\n";     out << "<VALUE.OBJECTWITHPATH>\n";
Line 1220 
Line 1248 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendValueReferenceElement( void XmlWriter::appendValueReferenceElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMObjectPath& reference,     const CIMObjectPath& reference,
     Boolean putValueWrapper)     Boolean putValueWrapper)
 { {
Line 1277 
Line 1305 
     const CIMObjectPath& reference,     const CIMObjectPath& reference,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<Sint8> tmp;      Array<char> tmp;
     appendValueReferenceElement(tmp, reference, true);     appendValueReferenceElement(tmp, reference, true);
     tmp.append('\0');     tmp.append('\0');
     indentedPrint(os, tmp.getData());     indentedPrint(os, tmp.getData());
Line 1292 
Line 1320 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendValueNamedInstanceElement( void XmlWriter::appendValueNamedInstanceElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMInstance& namedInstance)     const CIMInstance& namedInstance)
 { {
     out << "<VALUE.NAMEDINSTANCE>\n";     out << "<VALUE.NAMEDINSTANCE>\n";
Line 1316 
Line 1344 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendClassElement( void XmlWriter::appendClassElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMConstClass& cimclass)     const CIMConstClass& cimclass)
 { {
     cimclass._checkRep();     cimclass._checkRep();
Line 1327 
Line 1355 
     const CIMConstClass& cimclass,     const CIMConstClass& cimclass,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<Sint8> tmp;      Array<char> tmp;
     appendClassElement(tmp, cimclass);     appendClassElement(tmp, cimclass);
     tmp.append('\0');     tmp.append('\0');
     indentedPrint(os, tmp.getData(), 4);     indentedPrint(os, tmp.getData(), 4);
Line 1345 
Line 1373 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendInstanceElement( void XmlWriter::appendInstanceElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMConstInstance& instance)     const CIMConstInstance& instance)
 { {
     instance._checkRep();     instance._checkRep();
Line 1356 
Line 1384 
     const CIMConstInstance& instance,     const CIMConstInstance& instance,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<Sint8> tmp;      Array<char> 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 1371 
Line 1399 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendObjectElement( void XmlWriter::appendObjectElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMConstObject& object)     const CIMConstObject& object)
 { {
     if (object.isClass())     if (object.isClass())
Line 1416 
Line 1444 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendPropertyElement( void XmlWriter::appendPropertyElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMConstProperty& property)     const CIMConstProperty& property)
 { {
     property._checkRep();     property._checkRep();
Line 1427 
Line 1455 
     const CIMConstProperty& property,     const CIMConstProperty& property,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<Sint8> tmp;      Array<char> 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 1448 
Line 1476 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendMethodElement( void XmlWriter::appendMethodElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMConstMethod& method)     const CIMConstMethod& method)
 { {
     method._checkRep();     method._checkRep();
Line 1459 
Line 1487 
     const CIMConstMethod& method,     const CIMConstMethod& method,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<Sint8> tmp;      Array<char> 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 1494 
Line 1522 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendParameterElement( void XmlWriter::appendParameterElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMConstParameter& parameter)     const CIMConstParameter& parameter)
 { {
     parameter._checkRep();     parameter._checkRep();
Line 1505 
Line 1533 
     const CIMConstParameter& parameter,     const CIMConstParameter& parameter,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<Sint8> tmp;      Array<char> 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 1522 
Line 1550 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendParamValueElement( void XmlWriter::appendParamValueElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMParamValue& paramValue)     const CIMParamValue& paramValue)
 { {
     paramValue._checkRep();     paramValue._checkRep();
Line 1533 
Line 1561 
     const CIMParamValue& paramValue,     const CIMParamValue& paramValue,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<Sint8> tmp;      Array<char> 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 1553 
Line 1581 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendQualifierElement( void XmlWriter::appendQualifierElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMConstQualifier& qualifier)     const CIMConstQualifier& qualifier)
 { {
     qualifier._checkRep();     qualifier._checkRep();
Line 1564 
Line 1592 
     const CIMConstQualifier& qualifier,     const CIMConstQualifier& qualifier,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<Sint8> tmp;      Array<char> 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 1585 
Line 1613 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendQualifierDeclElement( void XmlWriter::appendQualifierDeclElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMConstQualifierDecl& qualifierDecl)     const CIMConstQualifierDecl& qualifierDecl)
 { {
     qualifierDecl._checkRep();     qualifierDecl._checkRep();
Line 1596 
Line 1624 
     const CIMConstQualifierDecl& qualifierDecl,     const CIMConstQualifierDecl& qualifierDecl,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<Sint8> tmp;      Array<char> 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 1614 
Line 1642 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendQualifierFlavorEntity( void XmlWriter::appendQualifierFlavorEntity(
     Array<Sint8>& out,      Array<char>& out,
     const CIMFlavor & flavor)     const CIMFlavor & flavor)
 { {
     if (!(flavor.hasFlavor (CIMFlavor::OVERRIDABLE)))     if (!(flavor.hasFlavor (CIMFlavor::OVERRIDABLE)))
Line 1647 
Line 1675 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendScopeElement( void XmlWriter::appendScopeElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMScope & scope)     const CIMScope & scope)
 { {
     if (!(scope.equal (CIMScope ())))     if (!(scope.equal (CIMScope ())))
Line 1691 
Line 1719 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendMethodCallHeader( void XmlWriter::appendMethodCallHeader(
     Array<Sint8>& out,      Array<char>& out,
     const char* host,     const char* host,
     const CIMName& cimMethod,     const CIMName& cimMethod,
     const String& cimObject,     const String& cimObject,
Line 1769 
Line 1797 
  
  
 void XmlWriter::appendMethodResponseHeader( void XmlWriter::appendMethodResponseHeader(
      Array<Sint8>& out,       Array<char>& out,
      HttpMethod httpMethod,      HttpMethod httpMethod,
      const ContentLanguages & contentLanguages,      const ContentLanguages & contentLanguages,
      Uint32 contentLength,      Uint32 contentLength,
      Uint64 serverResponseTime)       Uint32 serverResponseTime)
 { {
      char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };      char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
      out << "HTTP/1.1 " HTTP_STATUS_OK "\r\n";      out << "HTTP/1.1 " HTTP_STATUS_OK "\r\n";
Line 1815 
Line 1843 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendHttpErrorResponseHeader( void XmlWriter::appendHttpErrorResponseHeader(
     Array<Sint8>& out,      Array<char>& out,
     const String& status,     const String& status,
     const String& cimError,     const String& cimError,
     const String& errorDetail)     const String& errorDetail)
Line 1856 
Line 1884 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendUnauthorizedResponseHeader( void XmlWriter::appendUnauthorizedResponseHeader(
     Array<Sint8>& out,      Array<char>& 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 1895 
Line 1923 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendOKResponseHeader( void XmlWriter::appendOKResponseHeader(
     Array<Sint8>& out,      Array<char>& 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 1932 
Line 1960 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendMessageElementBegin( void XmlWriter::_appendMessageElementBegin(
     Array<Sint8>& out,      Array<char>& 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 1941 
Line 1969 
 } }
  
 void XmlWriter::_appendMessageElementEnd( void XmlWriter::_appendMessageElementEnd(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "</MESSAGE>\n";     out << "</MESSAGE>\n";
     out << "</CIM>\n";     out << "</CIM>\n";
Line 1957 
Line 1985 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendSimpleReqElementBegin( void XmlWriter::_appendSimpleReqElementBegin(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "<SIMPLEREQ>\n";     out << "<SIMPLEREQ>\n";
 } }
  
 void XmlWriter::_appendSimpleReqElementEnd( void XmlWriter::_appendSimpleReqElementEnd(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "</SIMPLEREQ>\n";     out << "</SIMPLEREQ>\n";
 } }
Line 1979 
Line 2007 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendMethodCallElementBegin( void XmlWriter::_appendMethodCallElementBegin(
     Array<Sint8>& out,      Array<char>& out,
     const CIMName& name)     const CIMName& name)
 { {
     out << "<METHODCALL NAME=\"" << name << "\">\n";     out << "<METHODCALL NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::_appendMethodCallElementEnd( void XmlWriter::_appendMethodCallElementEnd(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "</METHODCALL>\n";     out << "</METHODCALL>\n";
 } }
Line 2002 
Line 2030 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendIMethodCallElementBegin( void XmlWriter::_appendIMethodCallElementBegin(
     Array<Sint8>& out,      Array<char>& out,
     const CIMName& name)     const CIMName& name)
 { {
     out << "<IMETHODCALL NAME=\"" << name << "\">\n";     out << "<IMETHODCALL NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::_appendIMethodCallElementEnd( void XmlWriter::_appendIMethodCallElementEnd(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "</IMETHODCALL>\n";     out << "</IMETHODCALL>\n";
 } }
Line 2027 
Line 2055 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendIParamValueElementBegin( void XmlWriter::_appendIParamValueElementBegin(
     Array<Sint8>& out,      Array<char>& out,
     const char* name)     const char* name)
 { {
     out << "<IPARAMVALUE NAME=\"" << name << "\">\n";     out << "<IPARAMVALUE NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::_appendIParamValueElementEnd( void XmlWriter::_appendIParamValueElementEnd(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "</IPARAMVALUE>\n";     out << "</IPARAMVALUE>\n";
 } }
Line 2049 
Line 2077 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendSimpleRspElementBegin( void XmlWriter::_appendSimpleRspElementBegin(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "<SIMPLERSP>\n";     out << "<SIMPLERSP>\n";
 } }
  
 void XmlWriter::_appendSimpleRspElementEnd( void XmlWriter::_appendSimpleRspElementEnd(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "</SIMPLERSP>\n";     out << "</SIMPLERSP>\n";
 } }
Line 2071 
Line 2099 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendMethodResponseElementBegin( void XmlWriter::_appendMethodResponseElementBegin(
     Array<Sint8>& out,      Array<char>& out,
     const CIMName& name)     const CIMName& name)
 { {
     out << "<METHODRESPONSE NAME=\"" << name << "\">\n";     out << "<METHODRESPONSE NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::_appendMethodResponseElementEnd( void XmlWriter::_appendMethodResponseElementEnd(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "</METHODRESPONSE>\n";     out << "</METHODRESPONSE>\n";
 } }
Line 2094 
Line 2122 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendIMethodResponseElementBegin( void XmlWriter::_appendIMethodResponseElementBegin(
     Array<Sint8>& out,      Array<char>& out,
     const CIMName& name)     const CIMName& name)
 { {
     out << "<IMETHODRESPONSE NAME=\"" << name << "\">\n";     out << "<IMETHODRESPONSE NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::_appendIMethodResponseElementEnd( void XmlWriter::_appendIMethodResponseElementEnd(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "</IMETHODRESPONSE>\n";     out << "</IMETHODRESPONSE>\n";
 } }
Line 2113 
Line 2141 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendErrorElement( void XmlWriter::_appendErrorElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMException& cimException)     const CIMException& cimException)
 { {
     Tracer::traceCIMException(TRC_XML_WRITER, Tracer::LEVEL2, cimException);     Tracer::traceCIMException(TRC_XML_WRITER, Tracer::LEVEL2, cimException);
Line 2136 
Line 2164 
 // //
 // <!ELEMENT RETURNVALUE (VALUE|VALUE.REFERENCE)> // <!ELEMENT RETURNVALUE (VALUE|VALUE.REFERENCE)>
 // <!ATTLIST RETURNVALUE // <!ATTLIST RETURNVALUE
   //     %EmbeddedObject; #IMPLIED
 //     %ParamType;> //     %ParamType;>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendReturnValueElement( void XmlWriter::appendReturnValueElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMValue& value)     const CIMValue& value)
 { {
     out << "<RETURNVALUE";     out << "<RETURNVALUE";
  
     CIMType type = value.getType();     CIMType type = value.getType();
       // If the property type is CIMObject, then
       //   encode the property in CIM-XML as a string with the EMBEDDEDOBJECT attribute
       //   (there is not currently a CIM-XML "object" datatype)
       // else
       //   output the real type
       if (type == CIMTYPE_OBJECT)
       {
           out << " PARAMTYPE=\"string\"";
           out << " EMBEDDEDOBJECT=\"object\"";
       }
       else
       {
     out << " PARAMTYPE=\"" << cimTypeToString (type) << "\"";     out << " PARAMTYPE=\"" << cimTypeToString (type) << "\"";
       }
  
     out << ">\n";     out << ">\n";
  
Line 2169 
Line 2211 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendIReturnValueElementBegin( void XmlWriter::_appendIReturnValueElementBegin(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "<IRETURNVALUE>\n";     out << "<IRETURNVALUE>\n";
 } }
  
 void XmlWriter::_appendIReturnValueElementEnd( void XmlWriter::_appendIReturnValueElementEnd(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "</IRETURNVALUE>\n";     out << "</IRETURNVALUE>\n";
 } }
Line 2187 
Line 2229 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendBooleanIParameter( void XmlWriter::appendBooleanIParameter(
     Array<Sint8>& out,      Array<char>& out,
     const char* name,     const char* name,
     Boolean flag)     Boolean flag)
 { {
Line 2205 
Line 2247 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendStringIParameter( void XmlWriter::appendStringIParameter(
     Array<Sint8>& out,      Array<char>& out,
     const char* name,     const char* name,
     const String& str)     const String& str)
 { {
Line 2223 
Line 2265 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendQualifierNameIParameter( void XmlWriter::appendQualifierNameIParameter(
     Array<Sint8>& out,      Array<char>& out,
     const char* name,     const char* name,
     const String& qualifierName)     const String& qualifierName)
 { {
Line 2247 
Line 2289 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendClassNameIParameter( void XmlWriter::appendClassNameIParameter(
     Array<Sint8>& out,      Array<char>& out,
     const char* name,     const char* name,
     const CIMName& className)     const CIMName& className)
 { {
Line 2272 
Line 2314 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendInstanceNameIParameter( void XmlWriter::appendInstanceNameIParameter(
     Array<Sint8>& out,      Array<char>& out,
     const char* name,     const char* name,
     const CIMObjectPath& instanceName)     const CIMObjectPath& instanceName)
 { {
Line 2282 
Line 2324 
 } }
  
 void XmlWriter::appendObjectNameIParameter( void XmlWriter::appendObjectNameIParameter(
     Array<Sint8>& out,      Array<char>& out,
     const char* name,     const char* name,
     const CIMObjectPath& objectName)     const CIMObjectPath& objectName)
 { {
Line 2311 
Line 2353 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendClassIParameter( void XmlWriter::appendClassIParameter(
     Array<Sint8>& out,      Array<char>& out,
     const char* name,     const char* name,
     const CIMConstClass& cimClass)     const CIMConstClass& cimClass)
 { {
Line 2327 
Line 2369 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendInstanceIParameter( void XmlWriter::appendInstanceIParameter(
     Array<Sint8>& out,      Array<char>& out,
     const char* name,     const char* name,
     const CIMConstInstance& instance)     const CIMConstInstance& instance)
 { {
Line 2343 
Line 2385 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendNamedInstanceIParameter( void XmlWriter::appendNamedInstanceIParameter(
     Array<Sint8>& out,      Array<char>& out,
     const char* name,     const char* name,
     const CIMInstance& namedInstance)     const CIMInstance& namedInstance)
 { {
Line 2362 
Line 2404 
 //     USE: Create parameter for getProperty operation //     USE: Create parameter for getProperty operation
 //========================================================== //==========================================================
 void XmlWriter::appendPropertyNameIParameter( void XmlWriter::appendPropertyNameIParameter(
     Array<Sint8>& out,      Array<char>& out,
     const CIMName& propertyName)     const CIMName& propertyName)
 { {
     _appendIParamValueElementBegin(out, "PropertyName");     _appendIParamValueElementBegin(out, "PropertyName");
Line 2377 
Line 2419 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendPropertyValueIParameter( void XmlWriter::appendPropertyValueIParameter(
     Array<Sint8>& out,      Array<char>& out,
     const char* name,     const char* name,
     const CIMValue& value)     const CIMValue& value)
 { {
Line 2393 
Line 2435 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendPropertyListIParameter( void XmlWriter::appendPropertyListIParameter(
     Array<Sint8>& out,      Array<char>& out,
     const CIMPropertyList& propertyList)     const CIMPropertyList& propertyList)
 { {
     _appendIParamValueElementBegin(out, "PropertyList");     _appendIParamValueElementBegin(out, "PropertyList");
Line 2422 
Line 2464 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendQualifierDeclarationIParameter( void XmlWriter::appendQualifierDeclarationIParameter(
     Array<Sint8>& out,      Array<char>& out,
     const char* name,     const char* name,
     const CIMConstQualifierDecl& qualifierDecl)     const CIMConstQualifierDecl& qualifierDecl)
 { {
Line 2437 
Line 2479 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatHttpErrorRspMessage(  Array<char> XmlWriter::formatHttpErrorRspMessage(
     const String& status,     const String& status,
     const String& cimError,     const String& cimError,
     const String& errorDetail)     const String& errorDetail)
 { {
     Array<Sint8> out;      Array<char> out;
  
     appendHttpErrorResponseHeader(out, status, cimError, errorDetail);     appendHttpErrorResponseHeader(out, status, cimError, errorDetail);
  
Line 2458 
Line 2500 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 // ATTN-RK-P1-20020228: Need to complete copy elimination optimization // ATTN-RK-P1-20020228: Need to complete copy elimination optimization
 Array<Sint8> XmlWriter::formatSimpleMethodReqMessage(  Array<char> XmlWriter::formatSimpleMethodReqMessage(
     const char* host,     const char* host,
     const CIMNamespaceName& nameSpace,     const CIMNamespaceName& nameSpace,
     const CIMObjectPath& path,     const CIMObjectPath& path,
Line 2470 
Line 2512 
     const AcceptLanguages& httpAcceptLanguages,     const AcceptLanguages& httpAcceptLanguages,
     const ContentLanguages& httpContentLanguages)     const ContentLanguages& httpContentLanguages)
 { {
     Array<Sint8> out;      Array<char> out;
     Array<Sint8> tmp;      Array<char> tmp;
     CIMObjectPath localObjectPath = path;     CIMObjectPath localObjectPath = path;
     localObjectPath.setNameSpace(nameSpace.getString());     localObjectPath.setNameSpace(nameSpace.getString());
     localObjectPath.setHost(String::EMPTY);     localObjectPath.setHost(String::EMPTY);
Line 2504 
Line 2546 
 } }
  
 //PEP 128 adding serverRsponseTime to header //PEP 128 adding serverRsponseTime to header
 Array<Sint8> XmlWriter::formatSimpleMethodRspMessage(  Array<char> 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<Sint8>& body,      const Array<char>& body,
                 Uint64 serverResponseTime,                  Uint32 serverResponseTime,
                 Boolean isFirst,                 Boolean isFirst,
                 Boolean isLast)                 Boolean isLast)
 { {
         Array<Sint8> out;          Array<char> out;
  
         if (isFirst == true)         if (isFirst == true)
         {         {
Line 2550 
Line 2592 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleMethodErrorRspMessage(  Array<char> 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<Sint8> out;      Array<char> out;
     Array<Sint8> tmp;      Array<char> tmp;
  
     _appendMessageElementBegin(out, messageId);     _appendMessageElementBegin(out, messageId);
     _appendSimpleRspElementBegin(out);     _appendSimpleRspElementBegin(out);
Line 2583 
Line 2625 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleIMethodReqMessage(  Array<char> XmlWriter::formatSimpleIMethodReqMessage(
     const char* host,     const char* host,
     const CIMNamespaceName& nameSpace,     const CIMNamespaceName& nameSpace,
     const CIMName& iMethodName,     const CIMName& iMethodName,
Line 2592 
Line 2634 
     const String& authenticationHeader,     const String& authenticationHeader,
     const AcceptLanguages& httpAcceptLanguages,     const AcceptLanguages& httpAcceptLanguages,
     const ContentLanguages& httpContentLanguages,     const ContentLanguages& httpContentLanguages,
     const Array<Sint8>& body)      const Array<char>& body)
 { {
     Array<Sint8> out;      Array<char> out;
     Array<Sint8> tmp;      Array<char> tmp;
  
     _appendMessageElementBegin(out, messageId);     _appendMessageElementBegin(out, messageId);
     _appendSimpleReqElementBegin(out);     _appendSimpleReqElementBegin(out);
Line 2627 
Line 2669 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleIMethodRspMessage(  Array<char> 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<Sint8>& body,      const Array<char>& body,
                 Uint64 serverResponseTime,      Uint32 serverResponseTime,
                 Boolean isFirst,                 Boolean isFirst,
                 Boolean isLast)                 Boolean isLast)
 { {
     Array<Sint8> out;      Array<char> out;
  
                 if (isFirst == true)                 if (isFirst == true)
                 {                 {
Line 2682 
Line 2724 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleIMethodErrorRspMessage(  Array<char> 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<Sint8> out;      Array<char> out;
     Array<Sint8> tmp;      Array<char> tmp;
  
     _appendMessageElementBegin(out, messageId);     _appendMessageElementBegin(out, messageId);
     _appendSimpleRspElementBegin(out);     _appendSimpleRspElementBegin(out);
Line 2724 
Line 2766 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendEMethodRequestHeader( void XmlWriter::appendEMethodRequestHeader(
     Array<Sint8>& out,      Array<char>& out,
     const char* requestUri,     const char* requestUri,
     const char* host,     const char* host,
     const CIMName& cimMethod,     const CIMName& cimMethod,
Line 2799 
Line 2841 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendEMethodResponseHeader( void XmlWriter::appendEMethodResponseHeader(
     Array<Sint8>& out,      Array<char>& out,
     HttpMethod httpMethod,     HttpMethod httpMethod,
     const ContentLanguages& contentLanguages,     const ContentLanguages& contentLanguages,
     Uint32 contentLength)     Uint32 contentLength)
Line 2838 
Line 2880 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendSimpleExportReqElementBegin( void XmlWriter::_appendSimpleExportReqElementBegin(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "<SIMPLEEXPREQ>\n";     out << "<SIMPLEEXPREQ>\n";
 } }
  
 void XmlWriter::_appendSimpleExportReqElementEnd( void XmlWriter::_appendSimpleExportReqElementEnd(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "</SIMPLEEXPREQ>\n";     out << "</SIMPLEEXPREQ>\n";
 } }
Line 2860 
Line 2902 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendEMethodCallElementBegin( void XmlWriter::_appendEMethodCallElementBegin(
     Array<Sint8>& out,      Array<char>& out,
     const CIMName& name)     const CIMName& name)
 { {
     out << "<EXPMETHODCALL NAME=\"" << name << "\">\n";     out << "<EXPMETHODCALL NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::_appendEMethodCallElementEnd( void XmlWriter::_appendEMethodCallElementEnd(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "</EXPMETHODCALL>\n";     out << "</EXPMETHODCALL>\n";
 } }
Line 2884 
Line 2926 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendEParamValueElementBegin( void XmlWriter::_appendEParamValueElementBegin(
     Array<Sint8>& out,      Array<char>& out,
     const char* name)     const char* name)
 { {
     out << "<EXPPARAMVALUE NAME=\"" << name << "\">\n";     out << "<EXPPARAMVALUE NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::_appendEParamValueElementEnd( void XmlWriter::_appendEParamValueElementEnd(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "</EXPPARAMVALUE>\n";     out << "</EXPPARAMVALUE>\n";
 } }
Line 2903 
Line 2945 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendInstanceEParameter( void XmlWriter::appendInstanceEParameter(
     Array<Sint8>& out,      Array<char>& out,
     const char* name,     const char* name,
     const CIMInstance& instance)     const CIMInstance& instance)
 { {
Line 2922 
Line 2964 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendSimpleExportRspElementBegin( void XmlWriter::_appendSimpleExportRspElementBegin(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "<SIMPLEEXPRSP>\n";     out << "<SIMPLEEXPRSP>\n";
 } }
  
 void XmlWriter::_appendSimpleExportRspElementEnd( void XmlWriter::_appendSimpleExportRspElementEnd(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "</SIMPLEEXPRSP>\n";     out << "</SIMPLEEXPRSP>\n";
 } }
Line 2944 
Line 2986 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendEMethodResponseElementBegin( void XmlWriter::_appendEMethodResponseElementBegin(
     Array<Sint8>& out,      Array<char>& out,
     const CIMName& name)     const CIMName& name)
 { {
     out << "<EXPMETHODRESPONSE NAME=\"" << name << "\">\n";     out << "<EXPMETHODRESPONSE NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::_appendEMethodResponseElementEnd( void XmlWriter::_appendEMethodResponseElementEnd(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "</EXPMETHODRESPONSE>\n";     out << "</EXPMETHODRESPONSE>\n";
 } }
Line 2962 
Line 3004 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleEMethodReqMessage(  Array<char> XmlWriter::formatSimpleEMethodReqMessage(
     const char* requestUri,     const char* requestUri,
     const char* host,     const char* host,
     const CIMName& eMethodName,     const CIMName& eMethodName,
Line 2971 
Line 3013 
     const String& authenticationHeader,     const String& authenticationHeader,
     const AcceptLanguages& httpAcceptLanguages,     const AcceptLanguages& httpAcceptLanguages,
     const ContentLanguages& httpContentLanguages,     const ContentLanguages& httpContentLanguages,
     const Array<Sint8>& body)      const Array<char>& body)
 { {
     Array<Sint8> out;      Array<char> out;
     Array<Sint8> tmp;      Array<char> tmp;
  
     _appendMessageElementBegin(out, messageId);     _appendMessageElementBegin(out, messageId);
     _appendSimpleExportReqElementBegin(out);     _appendSimpleExportReqElementBegin(out);
Line 3005 
Line 3047 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleEMethodRspMessage(  Array<char> 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<Sint8>& body)      const Array<char>& body)
 { {
     Array<Sint8> out;      Array<char> out;
     Array<Sint8> tmp;      Array<char> tmp;
  
     _appendMessageElementBegin(out, messageId);     _appendMessageElementBegin(out, messageId);
     _appendSimpleExportRspElementBegin(out);     _appendSimpleExportRspElementBegin(out);
Line 3038 
Line 3080 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleEMethodErrorRspMessage(  Array<char> 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<Sint8> out;      Array<char> out;
     Array<Sint8> tmp;      Array<char> tmp;
  
     _appendMessageElementBegin(out, messageId);     _appendMessageElementBegin(out, messageId);
     _appendSimpleExportRspElementBegin(out);     _appendSimpleExportRspElementBegin(out);


Legend:
Removed from v.1.113  
changed lines
  Added in v.1.122

No CVS admin address has been configured
Powered by
ViewCVS 0.9.2