(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.83.4.1 and 1.103

version 1.83.4.1, 2003/03/11 19:56:55 version 1.103, 2004/04/14 19:25:57
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2003////////////////////////////////////////////////////////////////////////
 // //
 // 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.
 // //
 // 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 57 
Line 59 
 #include "XmlParser.h" #include "XmlParser.h"
 #include "Tracer.h" #include "Tracer.h"
 #include <Pegasus/Common/StatisticalData.h> #include <Pegasus/Common/StatisticalData.h>
   #include "CommonUTF.h"
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 108 
Line 111 
     return out;     return out;
 } }
  
   
   // l10n
   Array<Sint8>& operator<<(Array<Sint8>& out, const AcceptLanguages& al)
   {
       XmlWriter::append(out, al.toString ());
       return out;
   }
   
   // l10n
   Array<Sint8>& operator<<(Array<Sint8>& out, const ContentLanguages& cl)
   {
       XmlWriter::append(out, cl.toString ());
       return out;
   }
   
   
 PEGASUS_STD(ostream)& operator<<(PEGASUS_STD(ostream)& os, const CIMDateTime& x) PEGASUS_STD(ostream)& operator<<(PEGASUS_STD(ostream)& os, const CIMDateTime& x)
 { {
     return os << x.toString();     return os << x.toString();
Line 126 
Line 145 
     return os;     return os;
 } }
  
 inline void _appendChar(Array<Sint8>& out, const Char16& c)  inline void _xmlWritter_appendChar(Array<Sint8>& out, const Char16& c)
 { {
     out.append(Sint8(c));      // 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 *)&c;
   
       const Uint16 *strsrc = (Uint16 *)charIN;
       Uint16 *endsrc = (Uint16 *)&charIN[1];
   
       Uint8 *strtgt = (Uint8 *)str;
       Uint8 *endtgt = (Uint8 *)&str[5];
   
       UTF16toUTF8(&strsrc,
                   endsrc,
                   &strtgt,
                   endtgt);
   
       out.append((Sint8 *)str,trailingBytesForUTF8[Uint32(str[0])]+1);
 } }
  
 inline void _appendSpecialChar(Array<Sint8>& out, const Char16& c)  inline void _xmlWritter_appendSpecialChar(Array<Sint8>& out, const Char16& c)
   {
       if ( ((c < Char16(0x20)) && (c >= Char16(0x00))) || (c == Char16(0x7f)) )
       {
           char charref[7];
           sprintf(charref, "&#%u;", (Uint16)c);
           out.append(charref, strlen(charref));
       }
       else
       {
           switch (c)
           {
               case '&':
                   out.append("&amp;", 5);
                   break;
   
               case '<':
                   out.append("&lt;", 4);
                   break;
   
               case '>':
                   out.append("&gt;", 4);
                   break;
   
               case '"':
                   out.append("&quot;", 6);
                   break;
   
               case '\'':
                   out.append("&apos;", 6);
                   break;
   
               default:
 { {
     // ATTN-B: Only UTF-8 handled for now.                      // 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 *)&c;
  
                       const Uint16 *strsrc = (Uint16 *)charIN;
                       Uint16 *endsrc = (Uint16 *)&charIN[1];
   
                       Uint8 *strtgt = (Uint8 *)str;
                       Uint8 *endtgt = (Uint8 *)&str[5];
   
                       UTF16toUTF8(&strsrc,
                                   endsrc,
                                   &strtgt,
                                   endtgt);
   
                       Uint32 number1 = trailingBytesForUTF8[Uint32(str[0])]+1;
   
                       out.append((Sint8 *)str,number1);
                   }
           }
       }
   }
   
   inline void _xmlWritter_appendSpecialChar(Array<Sint8>& out, char c)
   {
       if ( ((c < Char16(0x20)) && (c >= Char16(0x00))) || (c == Char16(0x7f)) )
       {
           char charref[7];
           sprintf(charref, "&#%u;", (Uint8)c);
           out.append(charref, strlen(charref));
       }
       else
       {
     switch (c)     switch (c)
     {     {
         case '&':         case '&':
Line 161 
Line 268 
             out.append(Sint8(c));             out.append(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)) )
       {
           char charref[7];
           sprintf(charref, "&#%u;", (Uint8)c);
           os << charref;
       }
       else
 { {
     switch (c)     switch (c)
     {     {
Line 190 
Line 307 
             os << c;             os << c;
     }     }
 } }
   }
   
   void _xmlWritter_appendSurrogatePair(Array<Sint8>& out, Uint16 high, Uint16 low)
   {
       Uint8 str[6];
       Uint8 charIN[5];
       memset(str,0x00,sizeof(str));
       memcpy(&charIN,&high,2);
       memcpy(&charIN[2],&low,2);
       const Uint16 *strsrc = (Uint16 *)charIN;
       Uint16 *endsrc = (Uint16 *)&charIN[3];
   
       Uint8 *strtgt = (Uint8 *)str;
       Uint8 *endtgt = (Uint8 *)&str[5];
   
       UTF16toUTF8(&strsrc,
                   endsrc,
                   &strtgt,
                   endtgt);
   
       Uint32 number1 = trailingBytesForUTF8[Uint32(str[0])]+1;
       out.append((Sint8 *)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<Sint8>& out, const Char16& x)
 { {
     _appendChar(out, x);      _xmlWritter_appendChar(out, x);
 } }
  
 void XmlWriter::append(Array<Sint8>& out, Boolean x) void XmlWriter::append(Array<Sint8>& out, Boolean x)
Line 224 
Line 364 
 void XmlWriter::append(Array<Sint8>& out, Uint64 x) void XmlWriter::append(Array<Sint8>& out, Uint64 x)
 { {
     char buffer[32];  // Should need 21 chars max     char buffer[32];  // Should need 21 chars max
     // I know I shouldn't put platform flags here, but the other way is too hard      sprintf(buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "u", x);
 #if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)  
     sprintf(buffer, "%I64u", x);  
 #else  
     sprintf(buffer, "%llu", x);  
 #endif  
     append(out, buffer);     append(out, buffer);
 } }
  
 void XmlWriter::append(Array<Sint8>& out, Sint64 x) void XmlWriter::append(Array<Sint8>& out, Sint64 x)
 { {
     char buffer[32];  // Should need 21 chars max     char buffer[32];  // Should need 21 chars max
     // I know I shouldn't put platform flags here, but the other way is too hard      sprintf(buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "d", x);
 #if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)      append(out, buffer);
     sprintf(buffer, "%I64d", x);  }
 #else  
     sprintf(buffer, "%lld", x);  void XmlWriter::append(Array<Sint8>& out, Real32 x)
 #endif  {
       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);     append(out, buffer);
 } }
  
 void XmlWriter::append(Array<Sint8>& out, Real64 x) void XmlWriter::append(Array<Sint8>& 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<Sint8>& out, const char* str)
 { {
     while (*str)     while (*str)
         _appendChar(out, *str++);          _xmlWritter_appendChar(out, *str++);
 } }
  
 void XmlWriter::append(Array<Sint8>& out, const String& str) void XmlWriter::append(Array<Sint8>& out, const String& str)
 { {
     for (Uint32 i = 0; i < str.size(); i++)     for (Uint32 i = 0; i < str.size(); i++)
     {     {
         _appendChar(out, str[i]);          Uint16 c = str[i];
           if(((c >= FIRST_HIGH_SURROGATE) && (c <= LAST_HIGH_SURROGATE)) ||
              ((c >= FIRST_LOW_SURROGATE) && (c <= LAST_LOW_SURROGATE)))
           {
               Char16 highSurrogate = str[i];
               Char16 lowSurrogate = str[++i];
   
               _xmlWritter_appendSurrogatePair(out, Uint16(highSurrogate),Uint16(lowSurrogate));
           }
           else
           {
               _xmlWritter_appendChar(out, str[i]);
           }
     }     }
 } }
  
Line 275 
Line 429 
  
 void XmlWriter::appendSpecial(Array<Sint8>& out, const Char16& x) void XmlWriter::appendSpecial(Array<Sint8>& out, const Char16& x)
 { {
     _appendSpecialChar(out, x);      _xmlWritter_appendSpecialChar(out, x);
 } }
  
 void XmlWriter::appendSpecial(Array<Sint8>& out, char x) void XmlWriter::appendSpecial(Array<Sint8>& out, char x)
 { {
     _appendSpecialChar(out, Char16(x));      _xmlWritter_appendSpecialChar(out, x);
 } }
  
 void XmlWriter::appendSpecial(Array<Sint8>& out, const char* str) void XmlWriter::appendSpecial(Array<Sint8>& 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<Sint8>& out, const String& str)
 { {
     for (Uint32 i = 0; i < str.size(); i++)     for (Uint32 i = 0; i < str.size(); i++)
     {     {
         _appendSpecialChar(out, str[i]);          Uint16 c = str[i];
   
           if(((c >= FIRST_HIGH_SURROGATE) && (c <= LAST_HIGH_SURROGATE)) ||
              ((c >= FIRST_LOW_SURROGATE) && (c <= LAST_LOW_SURROGATE)))
           {
               Char16 highSurrogate = str[i];
               Char16 lowSurrogate = str[++i];
   
               _xmlWritter_appendSurrogatePair(out, Uint16(highSurrogate),Uint16(lowSurrogate));
           }
           else
           {
               _xmlWritter_appendSpecialChar(out, str[i]);
           }
     }     }
 } }
  
   // chuck start
   
 // See http://www.ietf.org/rfc/rfc2396.txt section 2 // See http://www.ietf.org/rfc/rfc2396.txt section 2
 // Reserved characters = ';' '/' '?' ':' '@' '&' '=' '+' '$' ',' // Reserved characters = ';' '/' '?' ':' '@' '&' '=' '+' '$' ','
 // Excluded characters: // Excluded characters:
Line 304 
Line 473 
 //   Space character = 0x20 //   Space character = 0x20
 //   Delimiters = '<' '>' '#' '%' '"' //   Delimiters = '<' '>' '#' '%' '"'
 //   Unwise = '{' '}' '|' '\\' '^' '[' ']' '`' //   Unwise = '{' '}' '|' '\\' '^' '[' ']' '`'
 inline void _encodeURIChar(String& outString, Char16 char16)  //
   
   inline void _xmlWritter_encodeURIChar(String& outString, Sint8 char8)
 { {
     // ATTN: Handle non-UTF-8 character sets      Uint8 c = (Uint8)char8;
     char c = char16 & 0x007f;  
  
 #if 0  #ifndef PEGASUS_DO_NOT_IMPLEMENT_URI_ENCODING
 // Enable this functionality when approved by Pegasus community      if ( ((c <= 0x20) && (c >= 0x00)) ||    // Control characters + space char
 //#ifndef PEGASUS_DO_NOT_IMPLEMENT_URI_ENCODING  
     if ( (c <= 0x20) ||                     // Control characters + space char  
          ( (c >= 0x22) && (c <= 0x26) ) ||  // '"' '#' '$' '%' '&'          ( (c >= 0x22) && (c <= 0x26) ) ||  // '"' '#' '$' '%' '&'
          (c == 0x2b) ||                     // '+'          (c == 0x2b) ||                     // '+'
          (c == 0x2c) ||                     // ','          (c == 0x2c) ||                     // ','
Line 321 
Line 489 
          ( (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
            (c >= 0x7f) )                      // Control character or non US-ASCII (UTF-8)
     {     {
         char hexencoding[4];         char hexencoding[4];
  
Line 331 
Line 500 
     else     else
 #endif #endif
     {     {
         outString.append(c);          outString.append((Uint16)c);
     }     }
 } }
  
Line 341 
Line 510 
  
     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;
Line 351 
Line 520 
 { {
     String encodedString;     String encodedString;
  
   /* i18n remove - did not handle surrogate pairs
       for (Uint32 i=0; i<uriString.size(); 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<Sint8> utf8;
     for (Uint32 i=0; i<uriString.size(); i++)     for (Uint32 i=0; i<uriString.size(); i++)
     {     {
         _encodeURIChar(encodedString, uriString[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 374 
Line 574 
     out << "<LOCALNAMESPACEPATH>\n";     out << "<LOCALNAMESPACEPATH>\n";
  
     char* nameSpaceCopy = strdup(nameSpace.getString().getCString());     char* nameSpaceCopy = strdup(nameSpace.getString().getCString());
   #if defined(PEGASUS_PLATFORM_SOLARIS_SPARC_CC) || \
       defined(PEGASUS_OS_HPUX) || \
       defined(PEGASUS_OS_LINUX)
       char *last;
       for (const char* p = strtok_r(nameSpaceCopy, "/", &last); p;
            p = strtok_r(NULL, "/", &last))
   #else
     for (const char* p = strtok(nameSpaceCopy, "/"); p; p = strtok(NULL, "/"))     for (const char* p = strtok(nameSpaceCopy, "/"); p; p = strtok(NULL, "/"))
   #endif
     {     {
         out << "<NAMESPACE NAME=\"" << p << "\"/>\n";         out << "<NAMESPACE NAME=\"" << p << "\"/>\n";
     }     }
     delete nameSpaceCopy;      free(nameSpaceCopy);
  
     out << "</LOCALNAMESPACEPATH>\n";     out << "</LOCALNAMESPACEPATH>\n";
 } }
Line 571 
Line 779 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 inline void _appendValue(Array<Sint8>& out, Boolean x)  inline void _xmlWritter_appendValue(Array<Sint8>& out, Boolean x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _appendValue(Array<Sint8>& out, Uint8 x)  inline void _xmlWritter_appendValue(Array<Sint8>& 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<Sint8>& 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<Sint8>& 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<Sint8>& 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<Sint8>& out, Uint32 x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _appendValue(Array<Sint8>& out, Sint32 x)  inline void _xmlWritter_appendValue(Array<Sint8>& out, Sint32 x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _appendValue(Array<Sint8>& out, Uint64 x)  inline void _xmlWritter_appendValue(Array<Sint8>& out, Uint64 x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _appendValue(Array<Sint8>& out, Sint64 x)  inline void _xmlWritter_appendValue(Array<Sint8>& out, Sint64 x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _appendValue(Array<Sint8>& out, Real32 x)  inline void _xmlWritter_appendValue(Array<Sint8>& 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<Sint8>& 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<Sint8>& 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<Sint8>& 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<Sint8>& 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<Sint8>& out, const CIMObjectPath& x)
 { {
     XmlWriter::appendValueReferenceElement(out, x, true);     XmlWriter::appendValueReferenceElement(out, x, true);
 } }
  
 void _appendValueArray(Array<Sint8>& out, const CIMObjectPath* p, Uint32 size)  void _xmlWritter_appendValueArray(Array<Sint8>& 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<Sint8>& 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 700 
Line 908 
             {             {
                 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 708 
Line 916 
             {             {
                 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 716 
Line 924 
             {             {
                 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 724 
Line 932 
             {             {
                 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 732 
Line 940 
             {             {
                 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 740 
Line 948 
             {             {
                 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 748 
Line 956 
             {             {
                 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 756 
Line 964 
             {             {
                 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 764 
Line 972 
             {             {
                 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 772 
Line 980 
             {             {
                 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 780 
Line 988 
             {             {
                 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 788 
Line 996 
             {             {
                 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 796 
Line 1004 
             {             {
                 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 804 
Line 1012 
             {             {
                 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 812 
Line 1020 
             {             {
                 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;                 break;
             }             }
  
Line 825 
Line 1033 
         // 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 837 
Line 1045 
             {             {
                 Boolean v;                 Boolean v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 845 
Line 1053 
             {             {
                 Uint8 v;                 Uint8 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 853 
Line 1061 
             {             {
                 Sint8 v;                 Sint8 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 861 
Line 1069 
             {             {
                 Uint16 v;                 Uint16 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 869 
Line 1077 
             {             {
                 Sint16 v;                 Sint16 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 877 
Line 1085 
             {             {
                 Uint32 v;                 Uint32 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 885 
Line 1093 
             {             {
                 Sint32 v;                 Sint32 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 893 
Line 1101 
             {             {
                 Uint64 v;                 Uint64 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 901 
Line 1109 
             {             {
                 Sint64 v;                 Sint64 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 909 
Line 1117 
             {             {
                 Real32 v;                 Real32 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 917 
Line 1125 
             {             {
                 Real64 v;                 Real64 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 925 
Line 1133 
             {             {
                 Char16 v;                 Char16 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 933 
Line 1141 
             {             {
                 String v;                 String v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 941 
Line 1149 
             {             {
                 CIMDateTime v;                 CIMDateTime v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 1454 
Line 1662 
     }     }
 } }
  
   // l10n - added content language and accept language support to
   // the header methods below
   
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendMethodCallHeader() // appendMethodCallHeader()
Line 1469 
Line 1680 
     const String& cimObject,     const String& cimObject,
     const String& authenticationHeader,     const String& authenticationHeader,
     HttpMethod httpMethod,     HttpMethod httpMethod,
       const AcceptLanguages & acceptLanguages,
       const ContentLanguages & contentLanguages,
     Uint32 contentLength)     Uint32 contentLength)
 { {
     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
Line 1479 
Line 1692 
     // 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
 #ifdef PEGASUS_SNIA_INTEROP_TEST  
     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 1490 
Line 1700 
     {     {
         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";     out << "Content-Length: " << contentLength << "\r\n";
       if (acceptLanguages.size() > 0)
       {
           out << "Accept-Language: " << acceptLanguages << "\r\n";
       }
       if (contentLanguages.size() > 0)
       {
           out << "Content-Language: " << contentLanguages << "\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 1518 
Line 1735 
     out << "\r\n";     out << "\r\n";
 } }
  
   
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendMethodResponseHeader() // appendMethodResponseHeader()
Line 1529 
Line 1747 
 void XmlWriter::appendMethodResponseHeader( void XmlWriter::appendMethodResponseHeader(
     Array<Sint8>& out,     Array<Sint8>& out,
     HttpMethod httpMethod,     HttpMethod httpMethod,
       const ContentLanguages & contentLanguages,
     Uint32 contentLength)     Uint32 contentLength)
 { {
     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
Line 1537 
Line 1756 
     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";     out << "Content-Length: " << contentLength << "\r\n";
       if (contentLanguages.size() > 0)
       {
           out << "Content-Language: " << contentLanguages << "\r\n";
       }
     if (httpMethod == HTTP_METHOD_M_POST)     if (httpMethod == HTTP_METHOD_M_POST)
     {     {
         out << "Ext:\r\n";         out << "Ext:\r\n";
Line 1624 
Line 1847 
 //    out << "</BODY></HTML>\r\n"; //    out << "</BODY></HTML>\r\n";
 } }
  
   #ifdef PEGASUS_KERBEROS_AUTHENTICATION
   //------------------------------------------------------------------------------
   //
   // appendOKResponseHeader()
   //
   //     Build HTTP authentication response header for unauthorized requests.
   //
   //     Returns OK message in the following format:
   //
   //        HTTP/1.1 200 OK
   //        Content-Length: 0
   //        WWW-Authenticate: Negotiate "token"
   //        <HTML><HEAD>
   //        <TITLE>200 OK</TITLE>
   //        </HEAD><BODY BGCOLOR="#99cc99">
   //        <H2>TEST200 OK</H2>
   //        <HR>
   //        </BODY></HTML>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendOKResponseHeader(
       Array<Sint8>& out,
       const String& content)
   {
       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
       out << "Content-Length: 0" << "\r\n";
       out << content << "\r\n";
       out << "\r\n";
   
   //ATTN: We may need to include the following line, so that the browsers
   //      can display the error message.
   //    out << "<HTML><HEAD>\r\n";
   //    out << "<TITLE>" << "200 OK" <<  "</TITLE>\r\n";
   //    out << "</HEAD><BODY BGCOLOR=\"#99cc99\">\r\n";
   //    out << "<H2>TEST" << "200 OK" << "</H2>\r\n";
   //    out << "<HR>\r\n";
   //    out << "</BODY></HTML>\r\n";
   }
   #endif
   
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // _appendMessageElementBegin() // _appendMessageElementBegin()
Line 2154 
Line 2422 
     return out;     return out;
 } }
  
   // l10n - add content language support to the format methods below
   
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // XmlWriter::formatSimpleMethodReqMessage() // XmlWriter::formatSimpleMethodReqMessage()
Line 2169 
Line 2439 
     const Array<CIMParamValue>& parameters,     const Array<CIMParamValue>& parameters,
     const String& messageId,     const String& messageId,
     HttpMethod httpMethod,     HttpMethod httpMethod,
     const String& authenticationHeader)      const String& authenticationHeader,
       const AcceptLanguages& httpAcceptLanguages,
       const ContentLanguages& httpContentLanguages)
 { {
     Array<Sint8> out;     Array<Sint8> out;
     Array<Sint8> tmp;     Array<Sint8> tmp;
Line 2196 
Line 2468 
         localObjectPath.toString(),         localObjectPath.toString(),
         authenticationHeader,         authenticationHeader,
         httpMethod,         httpMethod,
           httpAcceptLanguages,
           httpContentLanguages,
         out.size());         out.size());
     tmp << out;     tmp << out;
  
Line 2206 
Line 2480 
     const CIMName& methodName,     const CIMName& methodName,
     const String& messageId,     const String& messageId,
     HttpMethod httpMethod,     HttpMethod httpMethod,
       const ContentLanguages & httpContentLanguages,
     const Array<Sint8>& body)     const Array<Sint8>& body)
 { {
     Array<Sint8> out;     Array<Sint8> out;
Line 2219 
Line 2494 
     _appendSimpleRspElementEnd(out);     _appendSimpleRspElementEnd(out);
     _appendMessageElementEnd(out);     _appendMessageElementEnd(out);
  
     appendMethodResponseHeader(tmp, httpMethod, out.size());      appendMethodResponseHeader(tmp,
           httpMethod,
           httpContentLanguages,
           out.size());
     tmp << out;     tmp << out;
  
     return tmp;     return tmp;
Line 2248 
Line 2526 
     _appendSimpleRspElementEnd(out);     _appendSimpleRspElementEnd(out);
     _appendMessageElementEnd(out);     _appendMessageElementEnd(out);
  
     appendMethodResponseHeader(tmp, httpMethod, out.size());  // l10n
       appendMethodResponseHeader(tmp,
           httpMethod,
           cimException.getContentLanguages(),
           out.size());
     tmp << out;     tmp << out;
  
     return tmp;     return tmp;
Line 2267 
Line 2549 
     const String& messageId,     const String& messageId,
     HttpMethod httpMethod,     HttpMethod httpMethod,
     const String& authenticationHeader,     const String& authenticationHeader,
       const AcceptLanguages& httpAcceptLanguages,
       const ContentLanguages& httpContentLanguages,
     const Array<Sint8>& body)     const Array<Sint8>& body)
 { {
     Array<Sint8> out;     Array<Sint8> out;
Line 2288 
Line 2572 
         nameSpace.getString(),         nameSpace.getString(),
         authenticationHeader,         authenticationHeader,
         httpMethod,         httpMethod,
           httpAcceptLanguages,
           httpContentLanguages,
         out.size());         out.size());
     tmp << out;     tmp << out;
  
Line 2304 
Line 2590 
     const CIMName& iMethodName,     const CIMName& iMethodName,
     const String& messageId,     const String& messageId,
     HttpMethod httpMethod,     HttpMethod httpMethod,
       const ContentLanguages & httpContentLanguages,
     const Array<Sint8>& body)     const Array<Sint8>& body)
 { {
     Array<Sint8> out;     Array<Sint8> out;
Line 2322 
Line 2609 
     _appendSimpleRspElementEnd(out);     _appendSimpleRspElementEnd(out);
     _appendMessageElementEnd(out);     _appendMessageElementEnd(out);
  
     appendMethodResponseHeader(tmp, httpMethod, out.size());      appendMethodResponseHeader(tmp,
                    httpMethod,
                    httpContentLanguages,
            out.size());
     tmp << out;     tmp << out;
  
     return tmp;     return tmp;
Line 2351 
Line 2641 
     _appendSimpleRspElementEnd(out);     _appendSimpleRspElementEnd(out);
     _appendMessageElementEnd(out);     _appendMessageElementEnd(out);
  
     appendMethodResponseHeader(tmp, httpMethod, out.size());  // l10n
       appendMethodResponseHeader(tmp,
            httpMethod,
            cimException.getContentLanguages(),
            out.size());
     tmp << out;     tmp << out;
  
     return tmp;     return tmp;
Line 2378 
Line 2672 
     const CIMName& cimMethod,     const CIMName& cimMethod,
     HttpMethod httpMethod,     HttpMethod httpMethod,
     const String& authenticationHeader,     const String& authenticationHeader,
       const AcceptLanguages& acceptLanguages,
       const ContentLanguages& contentLanguages,
     Uint32 contentLength)     Uint32 contentLength)
 { {
     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
Line 2393 
Line 2689 
     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";     out << "Content-Length: " << contentLength << "\r\n";
       if (acceptLanguages.size() > 0)
       {
           out << "Accept-Language: " << acceptLanguages << "\r\n";
       }
       if (contentLanguages.size() > 0)
       {
           out << "Content-Language: " << contentLanguages << "\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.hp.com; ns=";
Line 2424 
Line 2728 
 void XmlWriter::appendEMethodResponseHeader( void XmlWriter::appendEMethodResponseHeader(
     Array<Sint8>& out,     Array<Sint8>& out,
     HttpMethod httpMethod,     HttpMethod httpMethod,
       const ContentLanguages& contentLanguages,
     Uint32 contentLength)     Uint32 contentLength)
 { {
     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
Line 2431 
Line 2736 
     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";     out << "Content-Length: " << contentLength << "\r\n";
       if (contentLanguages.size() > 0)
       {
           out << "Content-Language: " << contentLanguages << "\r\n";
       }
     if (httpMethod == HTTP_METHOD_M_POST)     if (httpMethod == HTTP_METHOD_M_POST)
     {     {
         out << "Ext:\r\n";         out << "Ext:\r\n";
Line 2586 
Line 2895 
     const String& messageId,     const String& messageId,
     HttpMethod httpMethod,     HttpMethod httpMethod,
     const String& authenticationHeader,     const String& authenticationHeader,
       const AcceptLanguages& httpAcceptLanguages,
       const ContentLanguages& httpContentLanguages,
     const Array<Sint8>& body)     const Array<Sint8>& body)
 { {
     Array<Sint8> out;     Array<Sint8> out;
Line 2606 
Line 2917 
         eMethodName,         eMethodName,
         httpMethod,         httpMethod,
         authenticationHeader,         authenticationHeader,
           httpAcceptLanguages,
           httpContentLanguages,
         out.size());         out.size());
     tmp << out;     tmp << out;
  
Line 2622 
Line 2935 
     const CIMName& eMethodName,     const CIMName& eMethodName,
     const String& messageId,     const String& messageId,
     HttpMethod httpMethod,     HttpMethod httpMethod,
       const ContentLanguages& httpContentLanguages,
     const Array<Sint8>& body)     const Array<Sint8>& body)
 { {
     Array<Sint8> out;     Array<Sint8> out;
Line 2635 
Line 2949 
     _appendSimpleExportRspElementEnd(out);     _appendSimpleExportRspElementEnd(out);
     _appendMessageElementEnd(out);     _appendMessageElementEnd(out);
  
     appendEMethodResponseHeader(tmp, httpMethod, out.size());      appendEMethodResponseHeader(tmp,
           httpMethod,
           httpContentLanguages,
           out.size());
     tmp << out;     tmp << out;
  
     return tmp;     return tmp;
Line 2664 
Line 2981 
     _appendSimpleExportRspElementEnd(out);     _appendSimpleExportRspElementEnd(out);
     _appendMessageElementEnd(out);     _appendMessageElementEnd(out);
  
     appendEMethodResponseHeader(tmp, httpMethod, out.size());  // l10n
       appendEMethodResponseHeader(tmp,
            httpMethod,
            cimException.getContentLanguages(),
                    out.size());
     tmp << out;     tmp << out;
  
     return tmp;     return tmp;
Line 2672 
Line 2993 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // _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 2686 
Line 3007 
         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 2696 
Line 3017 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // _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 2731 
Line 3052 
         {         {
             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 2756 
Line 3077 
  
             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 2769 
Line 3090 
                 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 2778 
Line 3099 
             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 2861 
Line 3182 
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END
   

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