(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.95 and 1.112

version 1.95, 2003/08/26 20:46:28 version 1.112, 2004/10/17 20:39:18
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2004////////////////////////////////////////////////////////////////////////
 // //
 // 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.
 // //
 // 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 32 
 //              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
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 35 
Line 42 
 #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 67 
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
   // 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<Sint8>& operator<<(Array<Sint8>& out, const char* x) Array<Sint8>& operator<<(Array<Sint8>& out, const char* x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
Line 143 
Line 163 
     return os;     return os;
 } }
  
 inline void _appendChar(Array<Sint8>& out, const Char16& c)  inline void _xmlWritter_appendChar(Array<Sint8>& out, const Char16& c)
 { {
     // We need to convert the Char16 to UTF8 then append the UTF8     // We need to convert the Char16 to UTF8 then append the UTF8
     // character into the array.     // character into the array.
Line 165 
Line 185 
                 &strtgt,                 &strtgt,
                 endtgt);                 endtgt);
  
     out.append((Sint8 *)str,trailingBytesForUTF8[Uint32(str[0])]+1);      out.append((Sint8 *)str, UTF_8_COUNT_TRAIL_BYTES(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)) )     if ( ((c < Char16(0x20)) && (c >= Char16(0x00))) || (c == Char16(0x7f)) )
     {     {
Line 222 
Line 242 
                                 &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((Sint8 *)str,number1);
                 }                 }
Line 230 
Line 250 
     }     }
 } }
  
 inline void _appendSpecialChar(Array<Sint8>& out, char c)  inline void _xmlWritter_appendSpecialChar(Array<Sint8>& out, char c)
 { {
     if ( ((c < Char16(0x20)) && (c >= Char16(0x00))) || (c == Char16(0x7f)) )     if ( ((c < Char16(0x20)) && (c >= Char16(0x00))) || (c == Char16(0x7f)) )
     {     {
Line 269 
Line 289 
 } }
  
  
 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 < Char16(0x20)) || (c == Char16(0x7f)) )
     {     {
Line 307 
Line 327 
     }     }
 } }
  
 void _appendSurrogatePair(Array<Sint8>& out, Uint16 high, Uint16 low)  void _xmlWritter_appendSurrogatePair(Array<Sint8>& out, Uint16 high, Uint16 low)
 { {
     Uint8 str[6];     Uint8 str[6];
     Uint8 charIN[5];     Uint8 charIN[5];
Line 325 
Line 345 
                 &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((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 373 
Line 393 
     append(out, buffer);     append(out, buffer);
 } }
  
   void XmlWriter::append(Array<Sint8>& 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<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++);        XmlWriter::append(out, *str++);
 } }
  
 void XmlWriter::append(Array<Sint8>& out, const String& str) void XmlWriter::append(Array<Sint8>& out, const String& str)
Line 398 
Line 430 
             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]);
         }         }
     }     }
 } }
Line 415 
Line 447 
  
 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, 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)
Line 441 
Line 473 
             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]);
         }         }
     }     }
 } }
  
 // 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 461 
Line 491 
 //   Unwise = '{' '}' '|' '\\' '^' '[' ']' '`' //   Unwise = '{' '}' '|' '\\' '^' '[' ']' '`'
 // //
  
 inline void _encodeURIChar(String& outString, Sint8 char8)  inline void _xmlWritter_encodeURIChar(String& outString, Sint8 char8)
 { {
     Uint8 c = (Uint8)char8;     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 475 
Line 505 
          ( (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 496 
Line 525 
  
     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]);
     }     }
  
     return encodedString;     return encodedString;
Line 509 
Line 538 
 /* i18n remove - did not handle surrogate pairs /* 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]);
     }     }
 */ */
  
Line 528 
Line 557 
             Char16 highSurrogate = uriString[i];             Char16 highSurrogate = uriString[i];
             Char16 lowSurrogate = uriString[++i];             Char16 lowSurrogate = uriString[++i];
  
             _appendSurrogatePair(utf8, Uint16(highSurrogate),Uint16(lowSurrogate));              _xmlWritter_appendSurrogatePair(utf8, Uint16(highSurrogate),Uint16(lowSurrogate));
         }         }
         else         else
         {         {
             _appendChar(utf8, uriString[i]);              _xmlWritter_appendChar(utf8, uriString[i]);
         }         }
     }     }
  
     // Second, escape the non HTTP-safe chars     // Second, escape the non HTTP-safe chars
     for (Uint32 i=0; i<utf8.size(); i++)     for (Uint32 i=0; i<utf8.size(); i++)
     {     {
         _encodeURIChar(encodedString, utf8[i]);          _xmlWritter_encodeURIChar(encodedString, utf8[i]);
     }     }
  
     return encodedString;     return encodedString;
Line 559 
Line 588 
 { {
     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 572 
Line 602 
     {     {
         out << "<NAMESPACE NAME=\"" << p << "\"/>\n";         out << "<NAMESPACE NAME=\"" << p << "\"/>\n";
     }     }
     delete nameSpaceCopy;      free(nameSpaceCopy);
  
     out << "</LOCALNAMESPACEPATH>\n";     out << "</LOCALNAMESPACEPATH>\n";
 } }
Line 765 
Line 795 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 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 894 
Line 924 
             {             {
                 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 902 
Line 932 
             {             {
                 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 910 
Line 940 
             {             {
                 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 918 
Line 948 
             {             {
                 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 926 
Line 956 
             {             {
                 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 934 
Line 964 
             {             {
                 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 942 
Line 972 
             {             {
                 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 950 
Line 980 
             {             {
                 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 958 
Line 988 
             {             {
                 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 966 
Line 996 
             {             {
                 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 974 
Line 1004 
             {             {
                 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 982 
Line 1012 
             {             {
                 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 990 
Line 1020 
             {             {
                 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 998 
Line 1028 
             {             {
                 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 1006 
Line 1036 
             {             {
                 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 1019 
Line 1049 
         // 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 1031 
Line 1061 
             {             {
                 Boolean v;                 Boolean v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 1039 
Line 1069 
             {             {
                 Uint8 v;                 Uint8 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 1047 
Line 1077 
             {             {
                 Sint8 v;                 Sint8 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 1055 
Line 1085 
             {             {
                 Uint16 v;                 Uint16 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 1063 
Line 1093 
             {             {
                 Sint16 v;                 Sint16 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 1071 
Line 1101 
             {             {
                 Uint32 v;                 Uint32 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 1079 
Line 1109 
             {             {
                 Sint32 v;                 Sint32 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 1087 
Line 1117 
             {             {
                 Uint64 v;                 Uint64 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 1095 
Line 1125 
             {             {
                 Sint64 v;                 Sint64 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 1103 
Line 1133 
             {             {
                 Real32 v;                 Real32 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 1111 
Line 1141 
             {             {
                 Real64 v;                 Real64 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 1119 
Line 1149 
             {             {
                 Char16 v;                 Char16 v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 1127 
Line 1157 
             {             {
                 String v;                 String v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 1135 
Line 1165 
             {             {
                 CIMDateTime v;                 CIMDateTime v;
                 value.get(v);                 value.get(v);
                 _appendValue(out, v);                  _xmlWritter_appendValue(out, v);
                 break;                 break;
             }             }
  
Line 1678 
Line 1708 
     // 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 1689 
Line 1716 
     {     {
         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 1701 
Line 1727 
     {     {
         out << "Content-Language: " << contentLanguages << "\r\n";         out << "Content-Language: " << contentLanguages << "\r\n";
     }     }
   
                   // 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.
   #ifdef PEGASUS_DEBUG
                   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 1722 
Line 1760 
     {     {
         out << authenticationHeader << "\r\n";         out << authenticationHeader << "\r\n";
     }     }
   
     out << "\r\n";     out << "\r\n";
 } }
  
Line 1743 
Line 1782 
     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";
       out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";
                   OUTPUT_CONTENTLENGTH;
   
       if (contentLanguages.size() > 0)
       {
           out << "Content-Language: " << contentLanguages << "\r\n";
       }
       if (httpMethod == HTTP_METHOD_M_POST)
       {
           out << "Ext:\r\n";
           out << "Cache-Control: no-cache\r\n";
           out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";
           out << nn <<"\r\n";
           out << nn << "-CIMOperation: MethodResponse\r\n\r\n";
       }
       else
       {
           out << "CIMOperation: MethodResponse\r\n\r\n";
       }
   }
   
   
    void XmlWriter::appendMethodResponseHeader(
        Array<Sint8>& out,
        HttpMethod httpMethod,
        const ContentLanguages & contentLanguages,
        Uint32 contentLength,
        Uint64 serverResponseTime)
    {
        char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
   
        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 1764 
Line 1836 
     }     }
 } }
  
   
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendHttpErrorResponseHeader() // appendHttpErrorResponseHeader()
Line 1847 
Line 1920 
 //     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 1862 
Line 1936 
     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 2317 
Line 2397 
 //     <IPARAMVALUE NAME="PropertyName"><VALUE>FreeSpace</VALUE></IPARAMVALUE> //     <IPARAMVALUE NAME="PropertyName"><VALUE>FreeSpace</VALUE></IPARAMVALUE>
 // //
 //     USE: Create parameter for getProperty operation //     USE: Create parameter for getProperty operation
 //==========================================================  //-----------------------------------------------------------
 void XmlWriter::appendPropertyNameIParameter( void XmlWriter::appendPropertyNameIParameter(
     Array<Sint8>& out,     Array<Sint8>& out,
     const CIMName& propertyName)     const CIMName& propertyName)
Line 2465 
Line 2545 
     const String& messageId,     const String& messageId,
     HttpMethod httpMethod,     HttpMethod httpMethod,
     const ContentLanguages & httpContentLanguages,     const ContentLanguages & httpContentLanguages,
     const Array<Sint8>& body)      const Array<Sint8>& body,
                   Boolean isFirst,
                   Boolean isLast)
 { {
     Array<Sint8> out;     Array<Sint8> out;
     Array<Sint8> tmp;  
  
           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);
     _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;  
   //PEP 128 adding serverRsponseTime to header
   Array<Sint8> XmlWriter::formatSimpleMethodRspMessage(
       const CIMName& methodName,
       const String& messageId,
       HttpMethod httpMethod,
       const ContentLanguages & httpContentLanguages,
       const Array<Sint8>& body,
           Uint64 serverResponseTime,
                   Boolean isFirst,
                   Boolean isLast)
   {
           Array<Sint8> 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);
                   _appendSimpleRspElementBegin(out);
                   _appendMethodResponseElementBegin(out, methodName);
 } }
  
           if (body.size() != 0)
           {
                   out << body;
           }
   
           if (isLast == true)
           {
                   _appendMethodResponseElementEnd(out);
                   _appendSimpleRspElementEnd(out);
                   _appendMessageElementEnd(out);
           }
   
           return out;
   }
   
   
   
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // XmlWriter::formatSimpleMethodErrorRspMessage() // XmlWriter::formatSimpleMethodErrorRspMessage()
Line 2575 
Line 2705 
     const String& messageId,     const String& messageId,
     HttpMethod httpMethod,     HttpMethod httpMethod,
     const ContentLanguages & httpContentLanguages,     const ContentLanguages & httpContentLanguages,
     const Array<Sint8>& body)      const Array<Sint8>& body,
                   Boolean isFirst,
                   Boolean isLast)
 { {
     Array<Sint8> out;     Array<Sint8> out;
     Array<Sint8> tmp;  
  
                   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);
     _appendMessageElementBegin(out, messageId);     _appendMessageElementBegin(out, messageId);
     _appendSimpleRspElementBegin(out);     _appendSimpleRspElementBegin(out);
     _appendIMethodResponseElementBegin(out, iMethodName);     _appendIMethodResponseElementBegin(out, iMethodName);
     if (body.size() != 0)     if (body.size() != 0)
     {  
         _appendIReturnValueElementBegin(out);         _appendIReturnValueElementBegin(out);
                   }
   
       if (body.size() != 0)
       {
         out << body;         out << body;
         _appendIReturnValueElementEnd(out);  
     }     }
   
                   if (isLast == true)
                   {
                           if (body.size() != 0)
                                   _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;  
   
   Array<Sint8> XmlWriter::formatSimpleIMethodRspMessage(
       const CIMName& iMethodName,
       const String& messageId,
       HttpMethod httpMethod,
       const ContentLanguages & httpContentLanguages,
       const Array<Sint8>& body,
           Uint64 serverResponseTime,
                   Boolean isFirst,
                   Boolean isLast)
   {
       Array<Sint8> 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);
                           _appendSimpleRspElementBegin(out);
                           _appendIMethodResponseElementBegin(out, iMethodName);
                           if (body.size() != 0)
                                   _appendIReturnValueElementBegin(out);
                   }
   
       if (body.size() != 0)
       {
                           out << body;
       }
   
                   if (isLast == true)
                   {
                           if (body.size() != 0)
                                   _appendIReturnValueElementEnd(out);
                           _appendIMethodResponseElementEnd(out);
                           _appendSimpleRspElementEnd(out);
                           _appendMessageElementEnd(out);
                   }
   
       return out;
 } }
  
   
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // XmlWriter::formatSimpleIMethodErrorRspMessage() // XmlWriter::formatSimpleIMethodErrorRspMessage()
Line 2672 
Line 2854 
     }     }
     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 2681 
Line 2864 
     {     {
         out << "Content-Language: " << contentLanguages << "\r\n";         out << "Content-Language: " << contentLanguages << "\r\n";
     }     }
   
                   // 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.
   #ifdef PEGASUS_DEBUG
                   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 2698 
Line 2893 
     {     {
         out << authenticationHeader << "\r\n";         out << authenticationHeader << "\r\n";
     }     }
   
     out << "\r\n";     out << "\r\n";
 } }
  
Line 2719 
Line 2915 
  
     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 2977 
Line 3174 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // _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 2991 
Line 3188 
         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 3001 
Line 3198 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // _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 3024 
Line 3221 
     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 3036 
Line 3233 
         {         {
             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 3061 
Line 3258 
  
             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 3074 
Line 3271 
                 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 3083 
Line 3280 
             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 3115 
Line 3312 
         os << PEGASUS_STD(endl);         os << PEGASUS_STD(endl);
     }     }
  
     delete [] tmp;  
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 3166 
Line 3362 
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END
   
   

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