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

version 1.94, 2003/08/25 15:15:02 version 1.122, 2005/04/14 17:53:53
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2005////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // The Open Group, Tivoli Systems  // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // 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 28 
Line 34 
 //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com) //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
 //              Carol Ann Krug Graves, Hewlett-Packard Company //              Carol Ann Krug Graves, Hewlett-Packard Company
 //                  (carolann_graves@hp.com) //                  (carolann_graves@hp.com)
   //              Amit K Arora, IBM (amita@in.ibm.com) for PEP#101
   //         Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase1
   //                               Willis White (whiwill@us.ibm.com) PEP 127 and 128
   //         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 35 
Line 49 
 #include <cstdlib> #include <cstdlib>
 #include <cstdio> #include <cstdio>
 #include "Constants.h" #include "Constants.h"
 #include "Destroyer.h"  
 #include "CIMClass.h" #include "CIMClass.h"
 #include "CIMClassRep.h" #include "CIMClassRep.h"
 #include "CIMInstance.h" #include "CIMInstance.h"
Line 61 
Line 74 
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 Array<Sint8>& operator<<(Array<Sint8>& out, const char* x)  // This is a shortcut macro for outputing content length. This
   // pads the output number to the max characters representing a Uint32 number
   // so that it can be overwritten easily with a transfer encoding line later
   // on in HTTPConnection if required. This is strictly for performance since
   // messages can be very large. This overwriting shortcut allows us to NOT have
   // to repackage a large message later.
   
   #define OUTPUT_CONTENTLENGTH                                   \
   {                                                              \
       char contentLengthP[11];                                   \
       sprintf(contentLengthP,"%.10u", contentLength);            \
       out << "content-length: " << contentLengthP << "\r\n";     \
   }
   
   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 111 
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 143 
Line 170 
     return os;     return os;
 } }
  
 inline void _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 165 
Line 192 
                 &strtgt,                 &strtgt,
                 endtgt);                 endtgt);
  
     out.append((Sint8 *)str,trailingBytesForUTF8[Uint32(str[0])]+1);      out.append(str, UTF_8_COUNT_TRAIL_BYTES(str[0]) + 1);
 } }
  
 inline void _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 207 
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 222 
Line 249 
                                 &strtgt,                                 &strtgt,
                                 endtgt);                                 endtgt);
  
                     Uint32 number1 = trailingBytesForUTF8[Uint32(str[0])]+1;                      Uint32 number1 = UTF_8_COUNT_TRAIL_BYTES(str[0]) + 1;
  
                     out.append((Sint8 *)str,number1);                      out.append(str,number1);
                 }                 }
         }         }
     }     }
 } }
  
 inline void _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 263 
Line 290 
                 break;                 break;
  
             default:             default:
                 out.append(Sint8(c));                  out.append(static_cast<Sint8>(c));
         }         }
     }     }
 } }
  
  
 static inline void _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 307 
Line 334 
     }     }
 } }
  
 void _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 325 
Line 352 
                 &strtgt,                 &strtgt,
                 endtgt);                 endtgt);
  
     Uint32 number1 = trailingBytesForUTF8[Uint32(str[0])]+1;      Uint32 number1 = UTF_8_COUNT_TRAIL_BYTES(str[0]) + 1;
     out.append((Sint8 *)str,number1);      out.append(str,number1);
 } }
  
 static inline void _appendSpecial(PEGASUS_STD(ostream)& os, const char* str)  inline void _xmlWritter_appendSpecial(PEGASUS_STD(ostream)& os, const char* str)
 { {
     while (*str)     while (*str)
         _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)
 { {
     _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, Real64 x)  void XmlWriter::append(Array<char>& out, Real32 x)
   {
       char buffer[128];
       // %.7e gives '[-]m.ddddddde+/-xx', which seems compatible with the format
       // given in the CIM/XML spec, and the precision required by the CIM 2.2 spec
       // (4 byte IEEE floating point)
       sprintf(buffer, "%.7e", x);
       append(out, buffer);
   }
   
   void XmlWriter::append(Array<char>& out, Real64 x)
 { {
     char buffer[128];     char buffer[128];
     // %e gives '[-]m.dddddde+/-xx', which seems compatible with CIM/XML spec      // %.16e gives '[-]m.dddddddddddddddde+/-xx', which seems compatible with the format
     sprintf(buffer, "%e", x);      // given in the CIM/XML spec, and the precision required by the CIM 2.2 spec
       // (8 byte IEEE floating point)
       sprintf(buffer, "%.16e", x);
     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)
         _appendChar(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 398 
Line 437 
             Char16 highSurrogate = str[i];             Char16 highSurrogate = str[i];
             Char16 lowSurrogate = str[++i];             Char16 lowSurrogate = str[++i];
  
             _appendSurrogatePair(out, Uint16(highSurrogate),Uint16(lowSurrogate));              _xmlWritter_appendSurrogatePair(out, Uint16(highSurrogate),Uint16(lowSurrogate));
         }         }
         else         else
         {         {
             _appendChar(out, str[i]);              _xmlWritter_appendChar(out, str[i]);
         }         }
     }     }
 } }
  
 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)
 { {
     _appendSpecialChar(out, x);      _xmlWritter_appendSpecialChar(out, x);
 } }
  
 void XmlWriter::appendSpecial(Array<Sint8>& out, char x)  void XmlWriter::appendSpecial(Array<char>& out, char x)
 { {
     _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)
         _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 441 
Line 480 
             Char16 highSurrogate = str[i];             Char16 highSurrogate = str[i];
             Char16 lowSurrogate = str[++i];             Char16 lowSurrogate = str[++i];
  
             _appendSurrogatePair(out, Uint16(highSurrogate),Uint16(lowSurrogate));              _xmlWritter_appendSurrogatePair(out, Uint16(highSurrogate),Uint16(lowSurrogate));
         }         }
         else         else
         {         {
             _appendSpecialChar(out, str[i]);              _xmlWritter_appendSpecialChar(out, str[i]);
         }         }
     }     }
 } }
Line 458 
Line 497 
 //   Delimiters = '<' '>' '#' '%' '"' //   Delimiters = '<' '>' '#' '%' '"'
 //   Unwise = '{' '}' '|' '\\' '^' '[' ']' '`' //   Unwise = '{' '}' '|' '\\' '^' '[' ']' '`'
 // //
 // Also see the "CIM Operations over HTTP" spec, section 3.3.2 and  
 // 3.3.3, for the treatment of non US-ASCII chars  
 inline void _encodeURIChar(String& outString, Char16 char16)  
 {  
     // We need to convert the Char16 to UTF8 then append the UTF8  
     // character into the array.  
     // NOTE: The UTF8 character could be several bytes long.  
     // WARNING: This function will put in replacement character for  
     // all characters that have surogate pairs.  
     Uint8 str[6];  
     memset(str,0x00,sizeof(str));  
     Uint8* charIN = (Uint8 *)&char16;  
   
     const Uint16 *strsrc = (Uint16 *)charIN;  
     Uint16 *endsrc = (Uint16 *)&charIN[1];  
  
     Uint8 *strtgt = (Uint8 *)str;  inline void _xmlWritter_encodeURIChar(String& outString, Sint8 char8)
     Uint8 *endtgt = (Uint8 *)&str[5];  
   
     UTF16toUTF8(&strsrc,  
                 endsrc,  
                 &strtgt,  
                 endtgt);  
   
     // Loop through the UTF8 bytes for the character,  
     // escaping as needed.  
     Uint32 number1 = trailingBytesForUTF8[Uint32(str[0])]+1;  
     for (Uint32 i = 0; i < number1; i++)  
     {     {
         Uint8 c = str[i];      Uint8 c = (Uint8)char8;
  
 #ifndef PEGASUS_DO_NOT_IMPLEMENT_URI_ENCODING #ifndef PEGASUS_DO_NOT_IMPLEMENT_URI_ENCODING
         if ( ((c <= 0x20) && (c >= 0x00)) ||    // Control characters + space char      if ( (c <= 0x20) ||                     // Control characters + space char
              ( (c >= 0x22) && (c <= 0x26) ) ||  // '"' '#' '$' '%' '&'              ( (c >= 0x22) && (c <= 0x26) ) ||  // '"' '#' '$' '%' '&'
              (c == 0x2b) ||                     // '+'              (c == 0x2b) ||                     // '+'
              (c == 0x2c) ||                     // ','              (c == 0x2c) ||                     // ','
Line 499 
Line 512 
              ( (c >= 0x5b) && (c <= 0x5e) ) ||  // '[' '\\' ']' '^'              ( (c >= 0x5b) && (c <= 0x5e) ) ||  // '[' '\\' ']' '^'
              (c == 0x60) ||                     // '`'              (c == 0x60) ||                     // '`'
              ( (c >= 0x7b) && (c <= 0x7d) ) ||  // '{' '|' '}'              ( (c >= 0x7b) && (c <= 0x7d) ) ||  // '{' '|' '}'
 //           (c == 0x7f) )                      // Control character  
              (c >= 0x7f) )                      // Control character or non US-ASCII (UTF-8)              (c >= 0x7f) )                      // Control character or non US-ASCII (UTF-8)
         {         {
             char hexencoding[4];             char hexencoding[4];
Line 513 
Line 525 
             outString.append((Uint16)c);             outString.append((Uint16)c);
         }         }
     }     }
 }  
  
 String XmlWriter::encodeURICharacters(Array<Sint8> uriString)  String XmlWriter::encodeURICharacters(const Array<char>& uriString)
 { {
     String encodedString;     String encodedString;
  
     for (Uint32 i=0; i<uriString.size(); i++)     for (Uint32 i=0; i<uriString.size(); i++)
     {     {
         _encodeURIChar(encodedString, Char16(uriString[i]));          _xmlWritter_encodeURIChar(encodedString, uriString[i]);
     }     }
  
     return encodedString;     return encodedString;
 } }
  
 String XmlWriter::encodeURICharacters(String uriString)  String XmlWriter::encodeURICharacters(const String& uriString)
 { {
     String encodedString;     String encodedString;
  
   /* i18n remove - did not handle surrogate pairs
     for (Uint32 i=0; i<uriString.size(); i++)     for (Uint32 i=0; i<uriString.size(); i++)
     {     {
         _encodeURIChar(encodedString, uriString[i]);          _xmlWritter_encodeURIChar(encodedString, uriString[i]);
       }
   */
   
       // See the "CIM Operations over HTTP" spec, section 3.3.2 and
       // 3.3.3, for the treatment of non US-ASCII (UTF-8) chars
   
       // First, convert to UTF-8 (include handling of surrogate pairs)
       Array<char> utf8;
       for (Uint32 i = 0; i < uriString.size(); i++)
       {
           Uint16 c = uriString[i];
   
           if(((c >= FIRST_HIGH_SURROGATE) && (c <= LAST_HIGH_SURROGATE)) ||
              ((c >= FIRST_LOW_SURROGATE) && (c <= LAST_LOW_SURROGATE)))
           {
               Char16 highSurrogate = uriString[i];
               Char16 lowSurrogate = uriString[++i];
   
               _xmlWritter_appendSurrogatePair(utf8, Uint16(highSurrogate),Uint16(lowSurrogate));
           }
           else
           {
               _xmlWritter_appendChar(utf8, uriString[i]);
           }
       }
   
       // Second, escape the non HTTP-safe chars
       for (Uint32 i=0; i<utf8.size(); i++)
       {
           _xmlWritter_encodeURIChar(encodedString, utf8[i]);
     }     }
  
     return encodedString;     return encodedString;
Line 548 
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";
  
     char* nameSpaceCopy = strdup(nameSpace.getString().getCStringUTF8());      char* nameSpaceCopy = strdup(nameSpace.getString().getCString());
   
 #if defined(PEGASUS_PLATFORM_SOLARIS_SPARC_CC) || \ #if defined(PEGASUS_PLATFORM_SOLARIS_SPARC_CC) || \
     defined(PEGASUS_OS_HPUX) || \     defined(PEGASUS_OS_HPUX) || \
     defined(PEGASUS_OS_LINUX)     defined(PEGASUS_OS_LINUX)
Line 566 
Line 609 
     {     {
         out << "<NAMESPACE NAME=\"" << p << "\"/>\n";         out << "<NAMESPACE NAME=\"" << p << "\"/>\n";
     }     }
     delete nameSpaceCopy;      free(nameSpaceCopy);
  
     out << "</LOCALNAMESPACEPATH>\n";     out << "</LOCALNAMESPACEPATH>\n";
 } }
Line 580 
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 601 
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 618 
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 657 
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 677 
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 697 
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 715 
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 734 
Line 777 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendLocalObjectPathElement( void XmlWriter::appendLocalObjectPathElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMObjectPath& objectPath)     const CIMObjectPath& objectPath)
 { {
     //     //
Line 759 
Line 802 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 inline void _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 _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 _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 _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 _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 _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 _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 _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 _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 _appendValue(Array<Sint8>& out, Real32 x)  inline void _xmlWritter_appendValue(Array<char>& out, Real32 x)
 { {
     XmlWriter::append(out, Real64(x));      XmlWriter::append(out, x);
 } }
  
 inline void _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 _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 _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 _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 _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 _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--)
     {     {
         _appendValue(out, *p++);          _xmlWritter_appendValue(out, *p++);
     }     }
     out << "</VALUE.REFARRAY>\n";     out << "</VALUE.REFARRAY>\n";
 } }
  
 template<class T> template<class T>
 void _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";
  
     while (size--)     while (size--)
     {     {
         out << "<VALUE>";         out << "<VALUE>";
         _appendValue(out, *p++);          _xmlWritter_appendValue(out, *p++);
         out << "</VALUE>\n";         out << "</VALUE>\n";
     }     }
  
Line 873 
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 888 
Line 937 
             {             {
                 Array<Boolean> a;                 Array<Boolean> a;
                 value.get(a);                 value.get(a);
                 _appendValueArray(out, a.getData(), a.size());                  _xmlWritter_appendValueArray(out, a.getData(), a.size());
                 break;                 break;
             }             }
  
Line 896 
Line 945 
             {             {
                 Array<Uint8> a;                 Array<Uint8> a;
                 value.get(a);                 value.get(a);
                 _appendValueArray(out, a.getData(), a.size());                  _xmlWritter_appendValueArray(out, a.getData(), a.size());
                 break;                 break;
             }             }
  
Line 904 
Line 953 
             {             {
                 Array<Sint8> a;                 Array<Sint8> a;
                 value.get(a);                 value.get(a);
                 _appendValueArray(out, a.getData(), a.size());                  _xmlWritter_appendValueArray(out, a.getData(), a.size());
                 break;                 break;
             }             }
  
Line 912 
Line 961 
             {             {
                 Array<Uint16> a;                 Array<Uint16> a;
                 value.get(a);                 value.get(a);
                 _appendValueArray(out, a.getData(), a.size());                  _xmlWritter_appendValueArray(out, a.getData(), a.size());
                 break;                 break;
             }             }
  
Line 920 
Line 969 
             {             {
                 Array<Sint16> a;                 Array<Sint16> a;
                 value.get(a);                 value.get(a);
                 _appendValueArray(out, a.getData(), a.size());                  _xmlWritter_appendValueArray(out, a.getData(), a.size());
                 break;                 break;
             }             }
  
Line 928 
Line 977 
             {             {
                 Array<Uint32> a;                 Array<Uint32> a;
                 value.get(a);                 value.get(a);
                 _appendValueArray(out, a.getData(), a.size());                  _xmlWritter_appendValueArray(out, a.getData(), a.size());
                 break;                 break;
             }             }
  
Line 936 
Line 985 
             {             {
                 Array<Sint32> a;                 Array<Sint32> a;
                 value.get(a);                 value.get(a);
                 _appendValueArray(out, a.getData(), a.size());                  _xmlWritter_appendValueArray(out, a.getData(), a.size());
                 break;                 break;
             }             }
  
Line 944 
Line 993 
             {             {
                 Array<Uint64> a;                 Array<Uint64> a;
                 value.get(a);                 value.get(a);
                 _appendValueArray(out, a.getData(), a.size());                  _xmlWritter_appendValueArray(out, a.getData(), a.size());
                 break;                 break;
             }             }
  
Line 952 
Line 1001 
             {             {
                 Array<Sint64> a;                 Array<Sint64> a;
                 value.get(a);                 value.get(a);
                 _appendValueArray(out, a.getData(), a.size());                  _xmlWritter_appendValueArray(out, a.getData(), a.size());
                 break;                 break;
             }             }
  
Line 960 
Line 1009 
             {             {
                 Array<Real32> a;                 Array<Real32> a;
                 value.get(a);                 value.get(a);
                 _appendValueArray(out, a.getData(), a.size());                  _xmlWritter_appendValueArray(out, a.getData(), a.size());
                 break;                 break;
             }             }
  
Line 968 
Line 1017 
             {             {
                 Array<Real64> a;                 Array<Real64> a;
                 value.get(a);                 value.get(a);
                 _appendValueArray(out, a.getData(), a.size());                  _xmlWritter_appendValueArray(out, a.getData(), a.size());
                 break;                 break;
             }             }
  
Line 976 
Line 1025 
             {             {
                 Array<Char16> a;                 Array<Char16> a;
                 value.get(a);                 value.get(a);
                 _appendValueArray(out, a.getData(), a.size());                  _xmlWritter_appendValueArray(out, a.getData(), a.size());
                 break;                 break;
             }             }
  
Line 984 
Line 1033 
             {             {
                 Array<String> a;                 Array<String> a;
                 value.get(a);                 value.get(a);
                 _appendValueArray(out, a.getData(), a.size());                  _xmlWritter_appendValueArray(out, a.getData(), a.size());
                 break;                 break;
             }             }
  
Line 992 
Line 1041 
             {             {
                 Array<CIMDateTime> a;                 Array<CIMDateTime> a;
                 value.get(a);                 value.get(a);
                 _appendValueArray(out, a.getData(), a.size());                  _xmlWritter_appendValueArray(out, a.getData(), a.size());
                 break;                 break;
             }             }
  
Line 1000 
Line 1049 
             {             {
                 Array<CIMObjectPath> a;                 Array<CIMObjectPath> a;
                 value.get(a);                 value.get(a);
                 _appendValueArray(out, a.getData(), a.size());                  _xmlWritter_appendValueArray(out, a.getData(), a.size());
                   break;
               }
   
               case CIMTYPE_OBJECT:
               {
                   Array<CIMObject> a;
                   value.get(a);
                   _xmlWritter_appendValueArray(out, a.getData(), a.size());
                 break;                 break;
             }             }
  
Line 1013 
Line 1070 
         // Has to be separate because it uses VALUE.REFERENCE tag         // Has to be separate because it uses VALUE.REFERENCE tag
         CIMObjectPath v;         CIMObjectPath v;
         value.get(v);         value.get(v);
         _appendValue(out, v);          _xmlWritter_appendValue(out, v);
     }     }
     else     else
     {     {
Line 1025 
Line 1082 
             {             {
                 Boolean v;                 Boolean v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 1033 
Line 1090 
             {             {
                 Uint8 v;                 Uint8 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 1041 
Line 1098 
             {             {
                 Sint8 v;                 Sint8 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 1049 
Line 1106 
             {             {
                 Uint16 v;                 Uint16 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 1057 
Line 1114 
             {             {
                 Sint16 v;                 Sint16 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 1065 
Line 1122 
             {             {
                 Uint32 v;                 Uint32 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 1073 
Line 1130 
             {             {
                 Sint32 v;                 Sint32 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 1081 
Line 1138 
             {             {
                 Uint64 v;                 Uint64 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 1089 
Line 1146 
             {             {
                 Sint64 v;                 Sint64 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 1097 
Line 1154 
             {             {
                 Real32 v;                 Real32 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 1105 
Line 1162 
             {             {
                 Real64 v;                 Real64 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 1113 
Line 1170 
             {             {
                 Char16 v;                 Char16 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 1121 
Line 1178 
             {             {
                 String v;                 String v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 1129 
Line 1186 
             {             {
                 CIMDateTime v;                 CIMDateTime v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                   break;
               }
   
               case CIMTYPE_OBJECT:
               {
                   CIMObject v;
                   value.get(v);
                   _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 1145 
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 1161 
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 1183 
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 1240 
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 1255 
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 1279 
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 1290 
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 1308 
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 1319 
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 1334 
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 1379 
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 1390 
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 1411 
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 1422 
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 1457 
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 1468 
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 1485 
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 1496 
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 1516 
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 1527 
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 1548 
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 1559 
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 1577 
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 1610 
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 1654 
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 1672 
Line 1737 
     // do that in client today. Permanent change is to retry until spec     // do that in client today. Permanent change is to retry until spec
     // updated. This change is temp to finish tests or until the retry     // updated. This change is temp to finish tests or until the retry
     // installed.  Required because of change to wbemservices cimom     // installed.  Required because of change to wbemservices cimom
 #if defined PEGASUS_SNIA_INTEROP_TEST || defined PEGASUS_FORCE_POST_METHOD  
     out << "POST /cimom HTTP/1.1\r\n";  
 #else  
     if (httpMethod == HTTP_METHOD_M_POST)     if (httpMethod == HTTP_METHOD_M_POST)
     {     {
         out << "M-POST /cimom HTTP/1.1\r\n";         out << "M-POST /cimom HTTP/1.1\r\n";
Line 1683 
Line 1745 
     {     {
         out << "POST /cimom HTTP/1.1\r\n";         out << "POST /cimom HTTP/1.1\r\n";
     }     }
 #endif  
     out << "HOST: " << host << "\r\n";     out << "HOST: " << host << "\r\n";
     out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";     out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";
     out << "Content-Length: " << contentLength << "\r\n";                  OUTPUT_CONTENTLENGTH;
     if (acceptLanguages.size() > 0)     if (acceptLanguages.size() > 0)
     {     {
         out << "Accept-Language: " << acceptLanguages << "\r\n";         out << "Accept-Language: " << acceptLanguages << "\r\n";
Line 1695 
Line 1756 
     {     {
         out << "Content-Language: " << contentLanguages << "\r\n";         out << "Content-Language: " << contentLanguages << "\r\n";
     }     }
   
   #ifdef PEGASUS_DEBUG
                   // backdoor environment variable to turn OFF client requesting transfer
                   // encoding. The default is on. to turn off, set this variable to zero.
                   // This should be removed when stable. This should only be turned off in
                   // a debugging/testing environment.
   
                   static const char *clientTransferEncodingOff =
                           getenv("PEGASUS_HTTP_TRANSFER_ENCODING_REQUEST");
                   if (!clientTransferEncodingOff || *clientTransferEncodingOff != '0')
   #endif
   
                           out << "TE: chunked, trailers" << "\r\n";
   
     if (httpMethod == HTTP_METHOD_M_POST)     if (httpMethod == HTTP_METHOD_M_POST)
     {     {
         out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";         out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";
Line 1716 
Line 1791 
     {     {
         out << authenticationHeader << "\r\n";         out << authenticationHeader << "\r\n";
     }     }
   
     out << "\r\n";     out << "\r\n";
 } }
  
  
 //------------------------------------------------------------------------------  
 //  
 // appendMethodResponseHeader()  
 //  
 //     Build HTTP response header.  
 //  
 //------------------------------------------------------------------------------  
   
 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,
        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";
     STAT_SERVERTIME     STAT_SERVERTIME
     out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";     out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";
     out << "Content-Length: " << contentLength << "\r\n";       OUTPUT_CONTENTLENGTH;
   
     if (contentLanguages.size() > 0)     if (contentLanguages.size() > 0)
     {     {
         out << "Content-Language: " << contentLanguages << "\r\n";         out << "Content-Language: " << contentLanguages << "\r\n";
Line 1758 
Line 1827 
     }     }
 } }
  
   
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendHttpErrorResponseHeader() // appendHttpErrorResponseHeader()
Line 1773 
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 1814 
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 1841 
Line 1911 
 //     Returns OK message in the following format: //     Returns OK message in the following format:
 // //
 //        HTTP/1.1 200 OK //        HTTP/1.1 200 OK
   //        Content-Length: 0
 //        WWW-Authenticate: Negotiate "token" //        WWW-Authenticate: Negotiate "token"
 //        <HTML><HEAD> //        <HTML><HEAD>
 //        <TITLE>200 OK</TITLE> //        <TITLE>200 OK</TITLE>
Line 1852 
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";
       // Content-Length header needs to be added because 200 OK record
       // is usually intended to have content.  But, for Kerberos this
       // may not always be the case so we need to indicate that there
       // is no content
                   Uint32 contentLength = 0;
                   OUTPUT_CONTENTLENGTH;
     out << content << "\r\n";     out << content << "\r\n";
     out << "\r\n";     out << "\r\n";
  
Line 1883 
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 1892 
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 1908 
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 1930 
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 1953 
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 1978 
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 2000 
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 2022 
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 2045 
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 2064 
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 2087 
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 2120 
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 2138 
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 2156 
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 2174 
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 2198 
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 2223 
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 2233 
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 2262 
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 2278 
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 2294 
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 2313 
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 2328 
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 2344 
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 2373 
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 2388 
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 2409 
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 2421 
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 2454 
Line 2545 
     return tmp;     return tmp;
 } }
  
 Array<Sint8> XmlWriter::formatSimpleMethodRspMessage(  //PEP 128 adding serverRsponseTime to header
   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,
 {                  Uint32 serverResponseTime,
     Array<Sint8> out;                  Boolean isFirst,
     Array<Sint8> tmp;                  Boolean isLast)
   {
           Array<char> out;
   
           if (isFirst == true)
           {
                   // NOTE: temporarily put zero for content length. the http code
                   // will later decide to fill in the length or remove it altogether
                   appendMethodResponseHeader(out, httpMethod, httpContentLanguages, 0,
                                                                                                                            serverResponseTime);
     _appendMessageElementBegin(out, messageId);     _appendMessageElementBegin(out, messageId);
     _appendSimpleRspElementBegin(out);     _appendSimpleRspElementBegin(out);
     _appendMethodResponseElementBegin(out, methodName);     _appendMethodResponseElementBegin(out, methodName);
           }
   
           if (body.size() != 0)
           {
     out << body;     out << body;
           }
   
           if (isLast == true)
           {
     _appendMethodResponseElementEnd(out);     _appendMethodResponseElementEnd(out);
     _appendSimpleRspElementEnd(out);     _appendSimpleRspElementEnd(out);
     _appendMessageElementEnd(out);     _appendMessageElementEnd(out);
           }
  
     appendMethodResponseHeader(tmp,          return out;
         httpMethod,  
         httpContentLanguages,  
         out.size());  
     tmp << out;  
   
     return tmp;  
 } }
  
   
   
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // XmlWriter::formatSimpleMethodErrorRspMessage() // XmlWriter::formatSimpleMethodErrorRspMessage()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 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 2520 
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 2529 
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 2564 
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,
 {      Uint32 serverResponseTime,
     Array<Sint8> out;      Boolean isFirst,
     Array<Sint8> tmp;      Boolean isLast)
   {
       Array<char> out;
   
                   if (isFirst == true)
                   {
                           // NOTE: temporarily put zero for content length. the http code
                           // will later decide to fill in the length or remove it altogether
                           appendMethodResponseHeader(out, httpMethod, httpContentLanguages, 0,
                                                                                                                                    serverResponseTime);
     _appendMessageElementBegin(out, messageId);     _appendMessageElementBegin(out, messageId);
     _appendSimpleRspElementBegin(out);     _appendSimpleRspElementBegin(out);
     _appendIMethodResponseElementBegin(out, iMethodName);     _appendIMethodResponseElementBegin(out, iMethodName);
   
                           // output the start of the return tag. Test if there is response data by:
                           // 1. there is data on the first chunk OR
                           // 2. there is no data on the first chunk but isLast is false implying
                           //    there is more non-empty data to come. If all subsequent chunks
                           //    are empty, then this generates and empty response.
                           if (body.size() != 0 || isLast == false)
                                   _appendIReturnValueElementBegin(out);
                   }
   
     if (body.size() != 0)     if (body.size() != 0)
     {     {
         _appendIReturnValueElementBegin(out);  
         out << body;         out << body;
         _appendIReturnValueElementEnd(out);  
     }     }
   
                   if (isLast == true)
                   {
                           if (body.size() != 0 || isFirst == false)
                                   _appendIReturnValueElementEnd(out);
     _appendIMethodResponseElementEnd(out);     _appendIMethodResponseElementEnd(out);
     _appendSimpleRspElementEnd(out);     _appendSimpleRspElementEnd(out);
     _appendMessageElementEnd(out);     _appendMessageElementEnd(out);
                   }
  
     appendMethodResponseHeader(tmp,      return out;
                  httpMethod,  
                  httpContentLanguages,  
          out.size());  
     tmp << out;  
   
     return tmp;  
 } }
  
   
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // XmlWriter::formatSimpleIMethodErrorRspMessage() // XmlWriter::formatSimpleIMethodErrorRspMessage()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 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 2644 
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 2666 
Line 2788 
     }     }
     out << "HOST: " << host << "\r\n";     out << "HOST: " << host << "\r\n";
     out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";     out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";
     out << "Content-Length: " << contentLength << "\r\n";                  OUTPUT_CONTENTLENGTH;
   
     if (acceptLanguages.size() > 0)     if (acceptLanguages.size() > 0)
     {     {
         out << "Accept-Language: " << acceptLanguages << "\r\n";         out << "Accept-Language: " << acceptLanguages << "\r\n";
Line 2675 
Line 2798 
     {     {
         out << "Content-Language: " << contentLanguages << "\r\n";         out << "Content-Language: " << contentLanguages << "\r\n";
     }     }
   
   #ifdef PEGASUS_DEBUG
                   // backdoor environment variable to turn OFF client requesting transfer
                   // encoding. The default is on. to turn off, set this variable to zero.
                   // This should be removed when stable. This should only be turned off in
                   // a debugging/testing environment.
   
                   static const char *clientTransferEncodingOff =
                           getenv("PEGASUS_HTTP_TRANSFER_ENCODING_REQUEST");
                   if (!clientTransferEncodingOff || *clientTransferEncodingOff != '0')
   #endif
                           out << "TE: chunked, trailers" << "\r\n";
   
     if (httpMethod == HTTP_METHOD_M_POST)     if (httpMethod == HTTP_METHOD_M_POST)
     {     {
         out << "Man: http://www.hp.com; ns=";                            out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";
         out << nn <<"\r\n";         out << nn <<"\r\n";
         out << nn << "-CIMExport: MethodRequest\r\n";         out << nn << "-CIMExport: MethodRequest\r\n";
         out << nn << "-CIMExportMethod: " << cimMethod << "\r\n";         out << nn << "-CIMExportMethod: " << cimMethod << "\r\n";
Line 2692 
Line 2828 
     {     {
         out << authenticationHeader << "\r\n";         out << authenticationHeader << "\r\n";
     }     }
   
     out << "\r\n";     out << "\r\n";
 } }
  
Line 2704 
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 2713 
Line 2850 
  
     out << "HTTP/1.1 " HTTP_STATUS_OK "\r\n";     out << "HTTP/1.1 " HTTP_STATUS_OK "\r\n";
     out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";     out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";
     out << "Content-Length: " << contentLength << "\r\n";                  OUTPUT_CONTENTLENGTH;
   
     if (contentLanguages.size() > 0)     if (contentLanguages.size() > 0)
     {     {
         out << "Content-Language: " << contentLanguages << "\r\n";         out << "Content-Language: " << contentLanguages << "\r\n";
Line 2742 
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 2764 
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 2788 
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 2807 
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 2826 
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 2848 
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 2866 
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 2875 
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 2909 
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 2942 
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);
Line 2971 
Line 3109 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // _printAttributes()  // _xmlWritter_printAttributes()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 static void _printAttributes(  void _xmlWritter_printAttributes(
     PEGASUS_STD(ostream)& os,     PEGASUS_STD(ostream)& os,
     const XmlAttribute* attributes,     const XmlAttribute* attributes,
     Uint32 attributeCount)     Uint32 attributeCount)
Line 2985 
Line 3123 
         os << attributes[i].name << "=";         os << attributes[i].name << "=";
  
         os << '"';         os << '"';
         _appendSpecial(os, attributes[i].value);          _xmlWritter_appendSpecial(os, attributes[i].value);
         os << '"';         os << '"';
  
         if (i + 1 != attributeCount)         if (i + 1 != attributeCount)
Line 2995 
Line 3133 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // _indent()  // _xmlWritter_indent()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 static void _indent(PEGASUS_STD(ostream)& os, Uint32 level, Uint32 indentChars)  void _xmlWritter_indent(PEGASUS_STD(ostream)& os, Uint32 level, Uint32 indentChars)
 { {
     Uint32 n = level * indentChars;     Uint32 n = level * indentChars;
  
Line 3018 
Line 3156 
     const char* text,     const char* text,
     Uint32 indentChars)     Uint32 indentChars)
 { {
     char* tmp = strcpy(new char[strlen(text) + 1], text);      AutoArrayPtr<char> tmp(strcpy(new char[strlen(text) + 1], text));
  
     XmlParser parser(tmp);      XmlParser parser(tmp.get());
     XmlEntry entry;     XmlEntry entry;
     Stack<const char*> stack;     Stack<const char*> stack;
  
Line 3030 
Line 3168 
         {         {
             case XmlEntry::XML_DECLARATION:             case XmlEntry::XML_DECLARATION:
             {             {
                 _indent(os, stack.size(), indentChars);                  _xmlWritter_indent(os, stack.size(), indentChars);
  
                 os << "<?" << entry.text << " ";                 os << "<?" << entry.text << " ";
                 _printAttributes(os, entry.attributes, entry.attributeCount);                  _xmlWritter_printAttributes(os, entry.attributes, entry.attributeCount);
                 os << "?>";                 os << "?>";
                 break;                 break;
             }             }
  
             case XmlEntry::START_TAG:             case XmlEntry::START_TAG:
             {             {
                 _indent(os, stack.size(), indentChars);                  _xmlWritter_indent(os, stack.size(), indentChars);
  
                 os << "<" << entry.text;                 os << "<" << entry.text;
  
                 if (entry.attributeCount)                 if (entry.attributeCount)
                     os << ' ';                     os << ' ';
  
                 _printAttributes(os, entry.attributes, entry.attributeCount);                  _xmlWritter_printAttributes(os, entry.attributes, entry.attributeCount);
                 os << ">";                 os << ">";
                 stack.push(entry.text);                 stack.push(entry.text);
                 break;                 break;
Line 3055 
Line 3193 
  
             case XmlEntry::EMPTY_TAG:             case XmlEntry::EMPTY_TAG:
             {             {
                 _indent(os, stack.size(), indentChars);                  _xmlWritter_indent(os, stack.size(), indentChars);
  
                 os << "<" << entry.text << " ";                 os << "<" << entry.text << " ";
                 _printAttributes(os, entry.attributes, entry.attributeCount);                  _xmlWritter_printAttributes(os, entry.attributes, entry.attributeCount);
                 os << "/>";                 os << "/>";
                 break;                 break;
             }             }
Line 3068 
Line 3206 
                 if (!stack.isEmpty() && strcmp(stack.top(), entry.text) == 0)                 if (!stack.isEmpty() && strcmp(stack.top(), entry.text) == 0)
                     stack.pop();                     stack.pop();
  
                 _indent(os, stack.size(), indentChars);                  _xmlWritter_indent(os, stack.size(), indentChars);
  
                 os << "</" << entry.text << ">";                 os << "</" << entry.text << ">";
                 break;                 break;
Line 3077 
Line 3215 
             case XmlEntry::COMMENT:             case XmlEntry::COMMENT:
             {             {
  
                 _indent(os, stack.size(), indentChars);                  _xmlWritter_indent(os, stack.size(), indentChars);
                 os << "<!--";                 os << "<!--";
                 _appendSpecial(os, entry.text);                  _xmlWritter_appendSpecial(os, entry.text);
                 os << "-->";                 os << "-->";
                 break;                 break;
             }             }
  
             case XmlEntry::CONTENT:             case XmlEntry::CONTENT:
             {             {
                 _indent(os, stack.size(), indentChars);                  _xmlWritter_indent(os, stack.size(), indentChars);
                 _appendSpecial(os, entry.text);                  _xmlWritter_appendSpecial(os, entry.text);
                 break;                 break;
             }             }
  
             case XmlEntry::CDATA:             case XmlEntry::CDATA:
             {             {
                 _indent(os, stack.size(), indentChars);                  _xmlWritter_indent(os, stack.size(), indentChars);
                 os << "<![CDATA[...]]>";                 os << "<![CDATA[...]]>";
                 break;                 break;
             }             }
  
             case XmlEntry::DOCTYPE:             case XmlEntry::DOCTYPE:
             {             {
                 _indent(os, stack.size(), indentChars);                  _xmlWritter_indent(os, stack.size(), indentChars);
                 os << "<!DOCTYPE...>";                 os << "<!DOCTYPE...>";
                 break;                 break;
             }             }
Line 3109 
Line 3247 
         os << PEGASUS_STD(endl);         os << PEGASUS_STD(endl);
     }     }
  
     delete [] tmp;  
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 3160 
Line 3297 
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END
   
   

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