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

version 1.109, 2004/07/31 00:47:19 version 1.122, 2005/04/14 17:53:53
Line 1 
Line 1 
 //%2003////////////////////////////////////////////////////////////////////////  //%2005////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002  BMC Software, Hewlett-Packard Development  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // Company, L. P., IBM Corp., The Open Group, Tivoli Systems.  // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.; // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.;
 // IBM Corp.; EMC Corporation, The Open Group. // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 33 
Line 37 
 //              Amit K Arora, IBM (amita@in.ibm.com) for PEP#101 //              Amit K Arora, IBM (amita@in.ibm.com) for PEP#101
 //              Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase1 //              Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase1
 //              Willis White (whiwill@us.ibm.com) PEP 127 and 128 //              Willis White (whiwill@us.ibm.com) PEP 127 and 128
   //         Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase2
   //              Dave Sudlik, IBM (dsudlik@us.ibm.com)
   //              David Dillard, VERITAS Software Corp.
   //                  (david.dillard@veritas.com)
   //              Vijay Eli, vijayeli@in.ibm.com, fix for #2571
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 79 
Line 88 
   out << "content-length: " << contentLengthP << "\r\n";     \   out << "content-length: " << contentLengthP << "\r\n";     \
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, const char* x)  Array<char>& operator<<(Array<char>& out, const char* x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
     return out;     return out;
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, char x)  Array<char>& operator<<(Array<char>& out, char x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
     return out;     return out;
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, const Char16& x)  Array<char>& operator<<(Array<char>& out, const Char16& x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
     return out;     return out;
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, const String& x)  Array<char>& operator<<(Array<char>& out, const String& x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
     return out;     return out;
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, const Indentor& x)  Array<char>& operator<<(Array<char>& out, const Indentor& x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
     return out;     return out;
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, const Array<Sint8>& x)  Array<char>& operator<<(Array<char>& out, const Array<char>& x)
 { {
     out.appendArray(x);     out.appendArray(x);
     return out;     return out;
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, Uint32 x)  Array<char>& operator<<(Array<char>& out, Uint32 x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
     return out;     return out;
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, const CIMName& name)  Array<char>& operator<<(Array<char>& out, const CIMName& name)
 { {
     XmlWriter::append(out, name.getString ());     XmlWriter::append(out, name.getString ());
     return out;     return out;
Line 129 
Line 138 
  
  
 // l10n // l10n
 Array<Sint8>& operator<<(Array<Sint8>& out, const AcceptLanguages& al)  Array<char>& operator<<(Array<char>& out, const AcceptLanguages& al)
 { {
     XmlWriter::append(out, al.toString ());     XmlWriter::append(out, al.toString ());
     return out;     return out;
 } }
  
 // l10n // l10n
 Array<Sint8>& operator<<(Array<Sint8>& out, const ContentLanguages& cl)  Array<char>& operator<<(Array<char>& out, const ContentLanguages& cl)
 { {
     XmlWriter::append(out, cl.toString ());     XmlWriter::append(out, cl.toString ());
     return out;     return out;
Line 161 
Line 170 
     return os;     return os;
 } }
  
 inline void _xmlWritter_appendChar(Array<Sint8>& out, const Char16& c)  inline void _xmlWritter_appendChar(Array<char>& out, const Char16& c)
 { {
     // We need to convert the Char16 to UTF8 then append the UTF8     // We need to convert the Char16 to UTF8 then append the UTF8
     // character into the array.     // character into the array.
     // NOTE: The UTF8 character could be several bytes long.     // NOTE: The UTF8 character could be several bytes long.
     // WARNING: This function will put in replacement character for     // WARNING: This function will put in replacement character for
     // all characters that have surogate pairs.     // all characters that have surogate pairs.
     Uint8 str[6];      char str[6];
     memset(str,0x00,sizeof(str));     memset(str,0x00,sizeof(str));
     Uint8* charIN = (Uint8 *)&c;     Uint8* charIN = (Uint8 *)&c;
  
Line 183 
Line 192 
                 &strtgt,                 &strtgt,
                 endtgt);                 endtgt);
  
     out.append((Sint8 *)str, UTF_8_COUNT_TRAIL_BYTES(str[0]) + 1);      out.append(str, UTF_8_COUNT_TRAIL_BYTES(str[0]) + 1);
 } }
  
 inline void _xmlWritter_appendSpecialChar(Array<Sint8>& out, const Char16& c)  inline void _xmlWritter_appendSpecialChar(Array<char>& out, const Char16& c)
 { {
     if ( ((c < Char16(0x20)) && (c >= Char16(0x00))) || (c == Char16(0x7f)) )     if ( ((c < Char16(0x20)) && (c >= Char16(0x00))) || (c == Char16(0x7f)) )
     {     {
         char charref[7];         char charref[7];
         sprintf(charref, "&#%u;", (Uint16)c);         sprintf(charref, "&#%u;", (Uint16)c);
         out.append(charref, strlen(charref));          out.append(charref, static_cast<Uint32>(strlen(charref)));
     }     }
     else     else
     {     {
Line 225 
Line 234 
                     // NOTE: The UTF8 character could be several bytes long.                     // NOTE: The UTF8 character could be several bytes long.
                     // WARNING: This function will put in replacement character for                     // WARNING: This function will put in replacement character for
                     // all characters that have surogate pairs.                     // all characters that have surogate pairs.
                     Uint8 str[6];              char str[6];
                     memset(str,0x00,sizeof(str));                     memset(str,0x00,sizeof(str));
                     Uint8* charIN = (Uint8 *)&c;                      const char* charIN = reinterpret_cast<const char *>(&c);
  
                     const Uint16 *strsrc = (Uint16 *)charIN;                      const Uint16 *strsrc = (const Uint16 *)charIN;
                     Uint16 *endsrc = (Uint16 *)&charIN[1];                      const Uint16 *endsrc = (const Uint16 *)&charIN[1];
  
                     Uint8 *strtgt = (Uint8 *)str;                     Uint8 *strtgt = (Uint8 *)str;
                     Uint8 *endtgt = (Uint8 *)&str[5];                     Uint8 *endtgt = (Uint8 *)&str[5];
Line 242 
Line 251 
  
                     Uint32 number1 = UTF_8_COUNT_TRAIL_BYTES(str[0]) + 1;                     Uint32 number1 = UTF_8_COUNT_TRAIL_BYTES(str[0]) + 1;
  
                     out.append((Sint8 *)str,number1);                      out.append(str,number1);
                 }                 }
         }         }
     }     }
 } }
  
 inline void _xmlWritter_appendSpecialChar(Array<Sint8>& out, char c)  inline void _xmlWritter_appendSpecialChar(Array<char>& out, char c)
 { {
     if ( ((c < Char16(0x20)) && (c >= Char16(0x00))) || (c == Char16(0x7f)) )          if ( ((c < 0x20) && (c >= 0)) || (c == 0x7f) )
     {     {
         char charref[7];         char charref[7];
         sprintf(charref, "&#%u;", (Uint8)c);         sprintf(charref, "&#%u;", (Uint8)c);
         out.append(charref, strlen(charref));          out.append(charref, static_cast<Uint32>(strlen(charref)));
     }     }
     else     else
     {     {
Line 281 
Line 290 
                 break;                 break;
  
             default:             default:
                 out.append(Sint8(c));                  out.append(static_cast<Sint8>(c));
         }         }
     }     }
 } }
Line 289 
Line 298 
  
 inline void _xmlWritter_appendSpecialChar(PEGASUS_STD(ostream)& os, char c) inline void _xmlWritter_appendSpecialChar(PEGASUS_STD(ostream)& os, char c)
 { {
     if ( (c < Char16(0x20)) || (c == Char16(0x7f)) )      if ( ((c < 0x20) && (c >= 0)) || (c == 0x7f) )
     {     {
         char charref[7];         char charref[7];
         sprintf(charref, "&#%u;", (Uint8)c);          sprintf(charref, "&#%u;", static_cast<Uint8>(c));
         os << charref;         os << charref;
     }     }
     else     else
Line 325 
Line 334 
     }     }
 } }
  
 void _xmlWritter_appendSurrogatePair(Array<Sint8>& out, Uint16 high, Uint16 low)  void _xmlWritter_appendSurrogatePair(Array<char>& out, Uint16 high, Uint16 low)
 { {
     Uint8 str[6];      char str[6];
     Uint8 charIN[5];     Uint8 charIN[5];
     memset(str,0x00,sizeof(str));     memset(str,0x00,sizeof(str));
     memcpy(&charIN,&high,2);     memcpy(&charIN,&high,2);
Line 344 
Line 353 
                 endtgt);                 endtgt);
  
     Uint32 number1 = UTF_8_COUNT_TRAIL_BYTES(str[0]) + 1;     Uint32 number1 = UTF_8_COUNT_TRAIL_BYTES(str[0]) + 1;
     out.append((Sint8 *)str,number1);      out.append(str,number1);
 } }
  
 inline void _xmlWritter_appendSpecial(PEGASUS_STD(ostream)& os, const char* str) inline void _xmlWritter_appendSpecial(PEGASUS_STD(ostream)& os, const char* str)
Line 353 
Line 362 
         _xmlWritter_appendSpecialChar(os, *str++);         _xmlWritter_appendSpecialChar(os, *str++);
 } }
  
 void XmlWriter::append(Array<Sint8>& out, const Char16& x)  void XmlWriter::append(Array<char>& out, const Char16& x)
 { {
     _xmlWritter_appendChar(out, x);     _xmlWritter_appendChar(out, x);
 } }
  
 void XmlWriter::append(Array<Sint8>& out, Boolean x)  void XmlWriter::append(Array<char>& out, Boolean x)
 { {
     append(out, (x ? "TRUE" : "FALSE"));     append(out, (x ? "TRUE" : "FALSE"));
 } }
  
 void XmlWriter::append(Array<Sint8>& out, Uint32 x)  void XmlWriter::append(Array<char>& out, Uint32 x)
 { {
     char buffer[32];     char buffer[32];
     sprintf(buffer, "%u", x);     sprintf(buffer, "%u", x);
     append(out, buffer);     append(out, buffer);
 } }
  
 void XmlWriter::append(Array<Sint8>& out, Sint32 x)  void XmlWriter::append(Array<char>& out, Sint32 x)
 { {
     char buffer[32];     char buffer[32];
     sprintf(buffer, "%d", x);     sprintf(buffer, "%d", x);
     append(out, buffer);     append(out, buffer);
 } }
  
 void XmlWriter::append(Array<Sint8>& out, Uint64 x)  void XmlWriter::append(Array<char>& out, Uint64 x)
 { {
     char buffer[32];  // Should need 21 chars max     char buffer[32];  // Should need 21 chars max
     sprintf(buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "u", x);     sprintf(buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "u", x);
     append(out, buffer);     append(out, buffer);
 } }
  
 void XmlWriter::append(Array<Sint8>& out, Sint64 x)  void XmlWriter::append(Array<char>& out, Sint64 x)
 { {
     char buffer[32];  // Should need 21 chars max     char buffer[32];  // Should need 21 chars max
     sprintf(buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "d", x);     sprintf(buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "d", x);
     append(out, buffer);     append(out, buffer);
 } }
  
 void XmlWriter::append(Array<Sint8>& out, Real32 x)  void XmlWriter::append(Array<char>& out, Real32 x)
 { {
     char buffer[128];     char buffer[128];
     // %.7e gives '[-]m.ddddddde+/-xx', which seems compatible with the format     // %.7e gives '[-]m.ddddddde+/-xx', which seems compatible with the format
Line 401 
Line 410 
     append(out, buffer);     append(out, buffer);
 } }
  
 void XmlWriter::append(Array<Sint8>& out, Real64 x)  void XmlWriter::append(Array<char>& out, Real64 x)
 { {
     char buffer[128];     char buffer[128];
     // %.16e gives '[-]m.dddddddddddddddde+/-xx', which seems compatible with the format     // %.16e gives '[-]m.dddddddddddddddde+/-xx', which seems compatible with the format
Line 411 
Line 420 
     append(out, buffer);     append(out, buffer);
 } }
  
 void XmlWriter::append(Array<Sint8>& out, const char* str)  void XmlWriter::append(Array<char>& out, const char* str)
 { {
     while (*str)     while (*str)
       XmlWriter::append(out, *str++);       XmlWriter::append(out, *str++);
 } }
  
 void XmlWriter::append(Array<Sint8>& out, const String& str)  void XmlWriter::append(Array<char>& out, const String& str)
 { {
     for (Uint32 i = 0; i < str.size(); i++)     for (Uint32 i = 0; i < str.size(); i++)
     {     {
Line 437 
Line 446 
     }     }
 } }
  
 void XmlWriter::append(Array<Sint8>& out, const Indentor& x)  void XmlWriter::append(Array<char>& out, const Indentor& x)
 { {
     for (Uint32 i = 0; i < 4 * x.getLevel(); i++)     for (Uint32 i = 0; i < 4 * x.getLevel(); i++)
         out.append(' ');         out.append(' ');
 } }
  
 void XmlWriter::appendSpecial(Array<Sint8>& out, const Char16& x)  void XmlWriter::appendSpecial(Array<char>& out, const Char16& x)
 { {
     _xmlWritter_appendSpecialChar(out, x);     _xmlWritter_appendSpecialChar(out, x);
 } }
  
 void XmlWriter::appendSpecial(Array<Sint8>& out, char x)  void XmlWriter::appendSpecial(Array<char>& out, char x)
 { {
     _xmlWritter_appendSpecialChar(out, x);     _xmlWritter_appendSpecialChar(out, x);
 } }
  
 void XmlWriter::appendSpecial(Array<Sint8>& out, const char* str)  void XmlWriter::appendSpecial(Array<char>& out, const char* str)
 { {
     while (*str)     while (*str)
         _xmlWritter_appendSpecialChar(out, *str++);         _xmlWritter_appendSpecialChar(out, *str++);
 } }
  
 void XmlWriter::appendSpecial(Array<Sint8>& out, const String& str)  void XmlWriter::appendSpecial(Array<char>& out, const String& str)
 { {
     for (Uint32 i = 0; i < str.size(); i++)     for (Uint32 i = 0; i < str.size(); i++)
     {     {
Line 494 
Line 503 
     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 503 
Line 512 
          ( (c >= 0x5b) && (c <= 0x5e) ) ||  // '[' '\\' ']' '^'          ( (c >= 0x5b) && (c <= 0x5e) ) ||  // '[' '\\' ']' '^'
          (c == 0x60) ||                     // '`'          (c == 0x60) ||                     // '`'
          ( (c >= 0x7b) && (c <= 0x7d) ) ||  // '{' '|' '}'          ( (c >= 0x7b) && (c <= 0x7d) ) ||  // '{' '|' '}'
 //       (c == 0x7f) )                      // Control character  
          (c >= 0x7f) )                      // Control character or non US-ASCII (UTF-8)          (c >= 0x7f) )                      // Control character or non US-ASCII (UTF-8)
     {     {
         char hexencoding[4];         char hexencoding[4];
Line 518 
Line 526 
     }     }
 } }
  
 String XmlWriter::encodeURICharacters(Array<Sint8> uriString)  String XmlWriter::encodeURICharacters(const Array<char>& uriString)
 { {
     String encodedString;     String encodedString;
  
Line 530 
Line 538 
     return encodedString;     return encodedString;
 } }
  
 String XmlWriter::encodeURICharacters(String uriString)  String XmlWriter::encodeURICharacters(const String& uriString)
 { {
     String encodedString;     String encodedString;
  
Line 545 
Line 553 
     // 3.3.3, for the treatment of non US-ASCII (UTF-8) chars     // 3.3.3, for the treatment of non US-ASCII (UTF-8) chars
  
     // First, convert to UTF-8 (include handling of surrogate pairs)     // First, convert to UTF-8 (include handling of surrogate pairs)
     Array<Sint8> utf8;      Array<char> utf8;
     for (Uint32 i = 0; i < uriString.size(); i++)     for (Uint32 i = 0; i < uriString.size(); i++)
     {     {
         Uint16 c = uriString[i];         Uint16 c = uriString[i];
Line 582 
Line 590 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendLocalNameSpacePathElement( void XmlWriter::appendLocalNameSpacePathElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMNamespaceName& nameSpace)     const CIMNamespaceName& nameSpace)
 { {
     out << "<LOCALNAMESPACEPATH>\n";     out << "<LOCALNAMESPACEPATH>\n";
Line 615 
Line 623 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendNameSpacePathElement( void XmlWriter::appendNameSpacePathElement(
     Array<Sint8>& out,      Array<char>& out,
     const String& host,     const String& host,
     const CIMNamespaceName& nameSpace)     const CIMNamespaceName& nameSpace)
 { {
Line 636 
Line 644 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendClassNameElement( void XmlWriter::appendClassNameElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMName& className)     const CIMName& className)
 { {
     out << "<CLASSNAME NAME=\"" << className << "\"/>\n";     out << "<CLASSNAME NAME=\"" << className << "\"/>\n";
Line 653 
Line 661 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendInstanceNameElement( void XmlWriter::appendInstanceNameElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMObjectPath& instanceName)     const CIMObjectPath& instanceName)
 { {
     out << "<INSTANCENAME CLASSNAME=\"" << instanceName.getClassName() << "\">\n";     out << "<INSTANCENAME CLASSNAME=\"" << instanceName.getClassName() << "\">\n";
Line 692 
Line 700 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendClassPathElement( void XmlWriter::appendClassPathElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMObjectPath& classPath)     const CIMObjectPath& classPath)
 { {
     out << "<CLASSPATH>\n";     out << "<CLASSPATH>\n";
Line 712 
Line 720 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendInstancePathElement( void XmlWriter::appendInstancePathElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMObjectPath& instancePath)     const CIMObjectPath& instancePath)
 { {
     out << "<INSTANCEPATH>\n";     out << "<INSTANCEPATH>\n";
Line 732 
Line 740 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendLocalClassPathElement( void XmlWriter::appendLocalClassPathElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMObjectPath& classPath)     const CIMObjectPath& classPath)
 { {
     out << "<LOCALCLASSPATH>\n";     out << "<LOCALCLASSPATH>\n";
Line 750 
Line 758 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendLocalInstancePathElement( void XmlWriter::appendLocalInstancePathElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMObjectPath& instancePath)     const CIMObjectPath& instancePath)
 { {
     out << "<LOCALINSTANCEPATH>\n";     out << "<LOCALINSTANCEPATH>\n";
Line 769 
Line 777 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendLocalObjectPathElement( void XmlWriter::appendLocalObjectPathElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMObjectPath& objectPath)     const CIMObjectPath& objectPath)
 { {
     //     //
Line 794 
Line 802 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 inline void _xmlWritter_appendValue(Array<Sint8>& out, Boolean x)  inline void _xmlWritter_appendValue(Array<char>& out, Boolean x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _xmlWritter_appendValue(Array<Sint8>& out, Uint8 x)  inline void _xmlWritter_appendValue(Array<char>& out, Uint8 x)
 { {
     XmlWriter::append(out, Uint32(x));     XmlWriter::append(out, Uint32(x));
 } }
  
 inline void _xmlWritter_appendValue(Array<Sint8>& out, Sint8 x)  inline void _xmlWritter_appendValue(Array<char>& out, Sint8 x)
 { {
     XmlWriter::append(out, Sint32(x));     XmlWriter::append(out, Sint32(x));
 } }
  
 inline void _xmlWritter_appendValue(Array<Sint8>& out, Uint16 x)  inline void _xmlWritter_appendValue(Array<char>& out, Uint16 x)
 { {
     XmlWriter::append(out, Uint32(x));     XmlWriter::append(out, Uint32(x));
 } }
  
 inline void _xmlWritter_appendValue(Array<Sint8>& out, Sint16 x)  inline void _xmlWritter_appendValue(Array<char>& out, Sint16 x)
 { {
     XmlWriter::append(out, Sint32(x));     XmlWriter::append(out, Sint32(x));
 } }
  
 inline void _xmlWritter_appendValue(Array<Sint8>& out, Uint32 x)  inline void _xmlWritter_appendValue(Array<char>& out, Uint32 x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _xmlWritter_appendValue(Array<Sint8>& out, Sint32 x)  inline void _xmlWritter_appendValue(Array<char>& out, Sint32 x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _xmlWritter_appendValue(Array<Sint8>& out, Uint64 x)  inline void _xmlWritter_appendValue(Array<char>& out, Uint64 x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _xmlWritter_appendValue(Array<Sint8>& out, Sint64 x)  inline void _xmlWritter_appendValue(Array<char>& out, Sint64 x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _xmlWritter_appendValue(Array<Sint8>& out, Real32 x)  inline void _xmlWritter_appendValue(Array<char>& out, Real32 x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _xmlWritter_appendValue(Array<Sint8>& out, Real64 x)  inline void _xmlWritter_appendValue(Array<char>& out, Real64 x)
 { {
     XmlWriter::append(out, x);     XmlWriter::append(out, x);
 } }
  
 inline void _xmlWritter_appendValue(Array<Sint8>& out, const Char16& x)  inline void _xmlWritter_appendValue(Array<char>& out, const Char16& x)
 { {
     XmlWriter::appendSpecial(out, x);     XmlWriter::appendSpecial(out, x);
 } }
  
 inline void _xmlWritter_appendValue(Array<Sint8>& out, const String& x)  inline void _xmlWritter_appendValue(Array<char>& out, const String& x)
 { {
     XmlWriter::appendSpecial(out, x);     XmlWriter::appendSpecial(out, x);
 } }
  
 inline void _xmlWritter_appendValue(Array<Sint8>& out, const CIMDateTime& x)  inline void _xmlWritter_appendValue(Array<char>& out, const CIMDateTime& x)
 { {
     out << x.toString();  //ATTN: append() method?     out << x.toString();  //ATTN: append() method?
 } }
  
 inline void _xmlWritter_appendValue(Array<Sint8>& out, const CIMObjectPath& x)  inline void _xmlWritter_appendValue(Array<char>& out, const CIMObjectPath& x)
 { {
     XmlWriter::appendValueReferenceElement(out, x, true);     XmlWriter::appendValueReferenceElement(out, x, true);
 } }
  
 void _xmlWritter_appendValueArray(Array<Sint8>& out, const CIMObjectPath* p, Uint32 size)  inline void _xmlWritter_appendValue(Array<char>& out, const CIMObject& x)
   {
       String myStr = x.toString();
       _xmlWritter_appendValue(out, myStr);
   }
   
   void _xmlWritter_appendValueArray(Array<char>& out, const CIMObjectPath* p, Uint32 size)
 { {
     out << "<VALUE.REFARRAY>\n";     out << "<VALUE.REFARRAY>\n";
     while (size--)     while (size--)
Line 880 
Line 894 
 } }
  
 template<class T> template<class T>
 void _xmlWritter_appendValueArray(Array<Sint8>& out, const T* p, Uint32 size)  void _xmlWritter_appendValueArray(Array<char>& out, const T* p, Uint32 size)
 { {
     out << "<VALUE.ARRAY>\n";     out << "<VALUE.ARRAY>\n";
  
Line 908 
Line 922 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendValueElement( void XmlWriter::appendValueElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMValue& value)     const CIMValue& value)
 { {
     if (value.isNull())     if (value.isNull())
Line 1039 
Line 1053 
                 break;                 break;
             }             }
  
               case CIMTYPE_OBJECT:
               {
                   Array<CIMObject> a;
                   value.get(a);
                   _xmlWritter_appendValueArray(out, a.getData(), a.size());
                   break;
               }
   
             default:             default:
                 PEGASUS_ASSERT(false);                 PEGASUS_ASSERT(false);
         }         }
Line 1168 
Line 1190 
                 break;                 break;
             }             }
  
               case CIMTYPE_OBJECT:
               {
                   CIMObject v;
                   value.get(v);
                   _xmlWritter_appendValue(out, v);
                   break;
               }
   
             default:             default:
                 PEGASUS_ASSERT(false);                 PEGASUS_ASSERT(false);
         }         }
Line 1180 
Line 1210 
     const CIMValue& value,     const CIMValue& value,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<Sint8> tmp;      Array<char> tmp;
     appendValueElement(tmp, value);     appendValueElement(tmp, value);
     tmp.append('\0');     tmp.append('\0');
     os << tmp.getData() << PEGASUS_STD(endl);     os << tmp.getData() << PEGASUS_STD(endl);
Line 1196 
Line 1226 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendValueObjectWithPathElement( void XmlWriter::appendValueObjectWithPathElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMObject& objectWithPath)     const CIMObject& objectWithPath)
 { {
     out << "<VALUE.OBJECTWITHPATH>\n";     out << "<VALUE.OBJECTWITHPATH>\n";
Line 1218 
Line 1248 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendValueReferenceElement( void XmlWriter::appendValueReferenceElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMObjectPath& reference,     const CIMObjectPath& reference,
     Boolean putValueWrapper)     Boolean putValueWrapper)
 { {
Line 1275 
Line 1305 
     const CIMObjectPath& reference,     const CIMObjectPath& reference,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<Sint8> tmp;      Array<char> tmp;
     appendValueReferenceElement(tmp, reference, true);     appendValueReferenceElement(tmp, reference, true);
     tmp.append('\0');     tmp.append('\0');
     indentedPrint(os, tmp.getData());     indentedPrint(os, tmp.getData());
Line 1290 
Line 1320 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendValueNamedInstanceElement( void XmlWriter::appendValueNamedInstanceElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMInstance& namedInstance)     const CIMInstance& namedInstance)
 { {
     out << "<VALUE.NAMEDINSTANCE>\n";     out << "<VALUE.NAMEDINSTANCE>\n";
Line 1314 
Line 1344 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendClassElement( void XmlWriter::appendClassElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMConstClass& cimclass)     const CIMConstClass& cimclass)
 { {
     cimclass._checkRep();     cimclass._checkRep();
Line 1325 
Line 1355 
     const CIMConstClass& cimclass,     const CIMConstClass& cimclass,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<Sint8> tmp;      Array<char> tmp;
     appendClassElement(tmp, cimclass);     appendClassElement(tmp, cimclass);
     tmp.append('\0');     tmp.append('\0');
     indentedPrint(os, tmp.getData(), 4);     indentedPrint(os, tmp.getData(), 4);
Line 1343 
Line 1373 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendInstanceElement( void XmlWriter::appendInstanceElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMConstInstance& instance)     const CIMConstInstance& instance)
 { {
     instance._checkRep();     instance._checkRep();
Line 1354 
Line 1384 
     const CIMConstInstance& instance,     const CIMConstInstance& instance,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<Sint8> tmp;      Array<char> tmp;
     appendInstanceElement(tmp, instance);     appendInstanceElement(tmp, instance);
     tmp.append('\0');     tmp.append('\0');
     os << tmp.getData() << PEGASUS_STD(endl);     os << tmp.getData() << PEGASUS_STD(endl);
Line 1369 
Line 1399 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendObjectElement( void XmlWriter::appendObjectElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMConstObject& object)     const CIMConstObject& object)
 { {
     if (object.isClass())     if (object.isClass())
Line 1414 
Line 1444 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendPropertyElement( void XmlWriter::appendPropertyElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMConstProperty& property)     const CIMConstProperty& property)
 { {
     property._checkRep();     property._checkRep();
Line 1425 
Line 1455 
     const CIMConstProperty& property,     const CIMConstProperty& property,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<Sint8> tmp;      Array<char> tmp;
     appendPropertyElement(tmp, property);     appendPropertyElement(tmp, property);
     tmp.append('\0');     tmp.append('\0');
     os << tmp.getData() << PEGASUS_STD(endl);     os << tmp.getData() << PEGASUS_STD(endl);
Line 1446 
Line 1476 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendMethodElement( void XmlWriter::appendMethodElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMConstMethod& method)     const CIMConstMethod& method)
 { {
     method._checkRep();     method._checkRep();
Line 1457 
Line 1487 
     const CIMConstMethod& method,     const CIMConstMethod& method,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<Sint8> tmp;      Array<char> tmp;
     appendMethodElement(tmp, method);     appendMethodElement(tmp, method);
     tmp.append('\0');     tmp.append('\0');
     os << tmp.getData() << PEGASUS_STD(endl);     os << tmp.getData() << PEGASUS_STD(endl);
Line 1492 
Line 1522 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendParameterElement( void XmlWriter::appendParameterElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMConstParameter& parameter)     const CIMConstParameter& parameter)
 { {
     parameter._checkRep();     parameter._checkRep();
Line 1503 
Line 1533 
     const CIMConstParameter& parameter,     const CIMConstParameter& parameter,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<Sint8> tmp;      Array<char> tmp;
     appendParameterElement(tmp, parameter);     appendParameterElement(tmp, parameter);
     tmp.append('\0');     tmp.append('\0');
     os << tmp.getData() << PEGASUS_STD(endl);     os << tmp.getData() << PEGASUS_STD(endl);
Line 1520 
Line 1550 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendParamValueElement( void XmlWriter::appendParamValueElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMParamValue& paramValue)     const CIMParamValue& paramValue)
 { {
     paramValue._checkRep();     paramValue._checkRep();
Line 1531 
Line 1561 
     const CIMParamValue& paramValue,     const CIMParamValue& paramValue,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<Sint8> tmp;      Array<char> tmp;
     appendParamValueElement(tmp, paramValue);     appendParamValueElement(tmp, paramValue);
     tmp.append('\0');     tmp.append('\0');
     os << tmp.getData() << PEGASUS_STD(endl);     os << tmp.getData() << PEGASUS_STD(endl);
Line 1551 
Line 1581 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendQualifierElement( void XmlWriter::appendQualifierElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMConstQualifier& qualifier)     const CIMConstQualifier& qualifier)
 { {
     qualifier._checkRep();     qualifier._checkRep();
Line 1562 
Line 1592 
     const CIMConstQualifier& qualifier,     const CIMConstQualifier& qualifier,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<Sint8> tmp;      Array<char> tmp;
     appendQualifierElement(tmp, qualifier);     appendQualifierElement(tmp, qualifier);
     tmp.append('\0');     tmp.append('\0');
     os << tmp.getData() << PEGASUS_STD(endl);     os << tmp.getData() << PEGASUS_STD(endl);
Line 1583 
Line 1613 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendQualifierDeclElement( void XmlWriter::appendQualifierDeclElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMConstQualifierDecl& qualifierDecl)     const CIMConstQualifierDecl& qualifierDecl)
 { {
     qualifierDecl._checkRep();     qualifierDecl._checkRep();
Line 1594 
Line 1624 
     const CIMConstQualifierDecl& qualifierDecl,     const CIMConstQualifierDecl& qualifierDecl,
     PEGASUS_STD(ostream)& os)     PEGASUS_STD(ostream)& os)
 { {
     Array<Sint8> tmp;      Array<char> tmp;
     appendQualifierDeclElement(tmp, qualifierDecl);     appendQualifierDeclElement(tmp, qualifierDecl);
     tmp.append('\0');     tmp.append('\0');
     os << tmp.getData() << PEGASUS_STD(endl);     os << tmp.getData() << PEGASUS_STD(endl);
Line 1612 
Line 1642 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendQualifierFlavorEntity( void XmlWriter::appendQualifierFlavorEntity(
     Array<Sint8>& out,      Array<char>& out,
     const CIMFlavor & flavor)     const CIMFlavor & flavor)
 { {
     if (!(flavor.hasFlavor (CIMFlavor::OVERRIDABLE)))     if (!(flavor.hasFlavor (CIMFlavor::OVERRIDABLE)))
Line 1645 
Line 1675 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendScopeElement( void XmlWriter::appendScopeElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMScope & scope)     const CIMScope & scope)
 { {
     if (!(scope.equal (CIMScope ())))     if (!(scope.equal (CIMScope ())))
Line 1689 
Line 1719 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendMethodCallHeader( void XmlWriter::appendMethodCallHeader(
     Array<Sint8>& out,      Array<char>& out,
     const char* host,     const char* host,
     const CIMName& cimMethod,     const CIMName& cimMethod,
     const String& cimObject,     const String& cimObject,
Line 1727 
Line 1757 
         out << "Content-Language: " << contentLanguages << "\r\n";         out << "Content-Language: " << contentLanguages << "\r\n";
     }     }
  
   #ifdef PEGASUS_DEBUG
                 // backdoor environment variable to turn OFF client requesting transfer                 // backdoor environment variable to turn OFF client requesting transfer
                 // encoding. The default is on. to turn off, set this variable to zero.                 // 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                 // This should be removed when stable. This should only be turned off in
Line 1735 
Line 1766 
                 static const char *clientTransferEncodingOff =                 static const char *clientTransferEncodingOff =
                         getenv("PEGASUS_HTTP_TRANSFER_ENCODING_REQUEST");                         getenv("PEGASUS_HTTP_TRANSFER_ENCODING_REQUEST");
                 if (!clientTransferEncodingOff || *clientTransferEncodingOff != '0')                 if (!clientTransferEncodingOff || *clientTransferEncodingOff != '0')
   #endif
   
                         out << "TE: chunked, trailers" << "\r\n";                         out << "TE: chunked, trailers" << "\r\n";
  
     if (httpMethod == HTTP_METHOD_M_POST)     if (httpMethod == HTTP_METHOD_M_POST)
Line 1763 
Line 1796 
 } }
  
  
 //------------------------------------------------------------------------------  
 //  
 // appendMethodResponseHeader()  
 //  
 //     Build HTTP response header.  
 //  
 //------------------------------------------------------------------------------  
   
 void XmlWriter::appendMethodResponseHeader( void XmlWriter::appendMethodResponseHeader(
     Array<Sint8>& out,       Array<char>& out,
     HttpMethod httpMethod,  
     const ContentLanguages & contentLanguages,  
     Uint32 contentLength)  
 {  
     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };  
   
     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,      HttpMethod httpMethod,
      const ContentLanguages & contentLanguages,      const ContentLanguages & contentLanguages,
      Uint32 contentLength,      Uint32 contentLength,
      Uint64 serverResponseTime)       Uint32 serverResponseTime)
  {  {
      char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };      char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
   
      out << "HTTP/1.1 " HTTP_STATUS_OK "\r\n";      out << "HTTP/1.1 " HTTP_STATUS_OK "\r\n";
      STAT_SERVERTIME      STAT_SERVERTIME
      out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";      out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";
Line 1850 
Line 1843 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendHttpErrorResponseHeader( void XmlWriter::appendHttpErrorResponseHeader(
     Array<Sint8>& out,      Array<char>& out,
     const String& status,     const String& status,
     const String& cimError,     const String& cimError,
     const String& errorDetail)     const String& errorDetail)
Line 1891 
Line 1884 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendUnauthorizedResponseHeader( void XmlWriter::appendUnauthorizedResponseHeader(
     Array<Sint8>& out,      Array<char>& out,
     const String& content)     const String& content)
 { {
     out << "HTTP/1.1 " HTTP_STATUS_UNAUTHORIZED "\r\n";     out << "HTTP/1.1 " HTTP_STATUS_UNAUTHORIZED "\r\n";
Line 1930 
Line 1923 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendOKResponseHeader( void XmlWriter::appendOKResponseHeader(
     Array<Sint8>& out,      Array<char>& out,
     const String& content)     const String& content)
 { {
     out << "HTTP/1.1 " HTTP_STATUS_OK "\r\n";     out << "HTTP/1.1 " HTTP_STATUS_OK "\r\n";
Line 1967 
Line 1960 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendMessageElementBegin( void XmlWriter::_appendMessageElementBegin(
     Array<Sint8>& out,      Array<char>& out,
     const String& messageId)     const String& messageId)
 { {
     out << "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";     out << "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";
Line 1976 
Line 1969 
 } }
  
 void XmlWriter::_appendMessageElementEnd( void XmlWriter::_appendMessageElementEnd(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "</MESSAGE>\n";     out << "</MESSAGE>\n";
     out << "</CIM>\n";     out << "</CIM>\n";
Line 1992 
Line 1985 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendSimpleReqElementBegin( void XmlWriter::_appendSimpleReqElementBegin(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "<SIMPLEREQ>\n";     out << "<SIMPLEREQ>\n";
 } }
  
 void XmlWriter::_appendSimpleReqElementEnd( void XmlWriter::_appendSimpleReqElementEnd(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "</SIMPLEREQ>\n";     out << "</SIMPLEREQ>\n";
 } }
Line 2014 
Line 2007 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendMethodCallElementBegin( void XmlWriter::_appendMethodCallElementBegin(
     Array<Sint8>& out,      Array<char>& out,
     const CIMName& name)     const CIMName& name)
 { {
     out << "<METHODCALL NAME=\"" << name << "\">\n";     out << "<METHODCALL NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::_appendMethodCallElementEnd( void XmlWriter::_appendMethodCallElementEnd(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "</METHODCALL>\n";     out << "</METHODCALL>\n";
 } }
Line 2037 
Line 2030 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendIMethodCallElementBegin( void XmlWriter::_appendIMethodCallElementBegin(
     Array<Sint8>& out,      Array<char>& out,
     const CIMName& name)     const CIMName& name)
 { {
     out << "<IMETHODCALL NAME=\"" << name << "\">\n";     out << "<IMETHODCALL NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::_appendIMethodCallElementEnd( void XmlWriter::_appendIMethodCallElementEnd(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "</IMETHODCALL>\n";     out << "</IMETHODCALL>\n";
 } }
Line 2062 
Line 2055 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendIParamValueElementBegin( void XmlWriter::_appendIParamValueElementBegin(
     Array<Sint8>& out,      Array<char>& out,
     const char* name)     const char* name)
 { {
     out << "<IPARAMVALUE NAME=\"" << name << "\">\n";     out << "<IPARAMVALUE NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::_appendIParamValueElementEnd( void XmlWriter::_appendIParamValueElementEnd(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "</IPARAMVALUE>\n";     out << "</IPARAMVALUE>\n";
 } }
Line 2084 
Line 2077 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendSimpleRspElementBegin( void XmlWriter::_appendSimpleRspElementBegin(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "<SIMPLERSP>\n";     out << "<SIMPLERSP>\n";
 } }
  
 void XmlWriter::_appendSimpleRspElementEnd( void XmlWriter::_appendSimpleRspElementEnd(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "</SIMPLERSP>\n";     out << "</SIMPLERSP>\n";
 } }
Line 2106 
Line 2099 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendMethodResponseElementBegin( void XmlWriter::_appendMethodResponseElementBegin(
     Array<Sint8>& out,      Array<char>& out,
     const CIMName& name)     const CIMName& name)
 { {
     out << "<METHODRESPONSE NAME=\"" << name << "\">\n";     out << "<METHODRESPONSE NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::_appendMethodResponseElementEnd( void XmlWriter::_appendMethodResponseElementEnd(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "</METHODRESPONSE>\n";     out << "</METHODRESPONSE>\n";
 } }
Line 2129 
Line 2122 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendIMethodResponseElementBegin( void XmlWriter::_appendIMethodResponseElementBegin(
     Array<Sint8>& out,      Array<char>& out,
     const CIMName& name)     const CIMName& name)
 { {
     out << "<IMETHODRESPONSE NAME=\"" << name << "\">\n";     out << "<IMETHODRESPONSE NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::_appendIMethodResponseElementEnd( void XmlWriter::_appendIMethodResponseElementEnd(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "</IMETHODRESPONSE>\n";     out << "</IMETHODRESPONSE>\n";
 } }
Line 2148 
Line 2141 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendErrorElement( void XmlWriter::_appendErrorElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMException& cimException)     const CIMException& cimException)
 { {
     Tracer::traceCIMException(TRC_XML_WRITER, Tracer::LEVEL2, cimException);     Tracer::traceCIMException(TRC_XML_WRITER, Tracer::LEVEL2, cimException);
Line 2171 
Line 2164 
 // //
 // <!ELEMENT RETURNVALUE (VALUE|VALUE.REFERENCE)> // <!ELEMENT RETURNVALUE (VALUE|VALUE.REFERENCE)>
 // <!ATTLIST RETURNVALUE // <!ATTLIST RETURNVALUE
   //     %EmbeddedObject; #IMPLIED
 //     %ParamType;> //     %ParamType;>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendReturnValueElement( void XmlWriter::appendReturnValueElement(
     Array<Sint8>& out,      Array<char>& out,
     const CIMValue& value)     const CIMValue& value)
 { {
     out << "<RETURNVALUE";     out << "<RETURNVALUE";
  
     CIMType type = value.getType();     CIMType type = value.getType();
       // If the property type is CIMObject, then
       //   encode the property in CIM-XML as a string with the EMBEDDEDOBJECT attribute
       //   (there is not currently a CIM-XML "object" datatype)
       // else
       //   output the real type
       if (type == CIMTYPE_OBJECT)
       {
           out << " PARAMTYPE=\"string\"";
           out << " EMBEDDEDOBJECT=\"object\"";
       }
       else
       {
     out << " PARAMTYPE=\"" << cimTypeToString (type) << "\"";     out << " PARAMTYPE=\"" << cimTypeToString (type) << "\"";
       }
  
     out << ">\n";     out << ">\n";
  
Line 2204 
Line 2211 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendIReturnValueElementBegin( void XmlWriter::_appendIReturnValueElementBegin(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "<IRETURNVALUE>\n";     out << "<IRETURNVALUE>\n";
 } }
  
 void XmlWriter::_appendIReturnValueElementEnd( void XmlWriter::_appendIReturnValueElementEnd(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "</IRETURNVALUE>\n";     out << "</IRETURNVALUE>\n";
 } }
Line 2222 
Line 2229 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendBooleanIParameter( void XmlWriter::appendBooleanIParameter(
     Array<Sint8>& out,      Array<char>& out,
     const char* name,     const char* name,
     Boolean flag)     Boolean flag)
 { {
Line 2240 
Line 2247 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendStringIParameter( void XmlWriter::appendStringIParameter(
     Array<Sint8>& out,      Array<char>& out,
     const char* name,     const char* name,
     const String& str)     const String& str)
 { {
Line 2258 
Line 2265 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendQualifierNameIParameter( void XmlWriter::appendQualifierNameIParameter(
     Array<Sint8>& out,      Array<char>& out,
     const char* name,     const char* name,
     const String& qualifierName)     const String& qualifierName)
 { {
Line 2282 
Line 2289 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendClassNameIParameter( void XmlWriter::appendClassNameIParameter(
     Array<Sint8>& out,      Array<char>& out,
     const char* name,     const char* name,
     const CIMName& className)     const CIMName& className)
 { {
Line 2307 
Line 2314 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendInstanceNameIParameter( void XmlWriter::appendInstanceNameIParameter(
     Array<Sint8>& out,      Array<char>& out,
     const char* name,     const char* name,
     const CIMObjectPath& instanceName)     const CIMObjectPath& instanceName)
 { {
Line 2317 
Line 2324 
 } }
  
 void XmlWriter::appendObjectNameIParameter( void XmlWriter::appendObjectNameIParameter(
     Array<Sint8>& out,      Array<char>& out,
     const char* name,     const char* name,
     const CIMObjectPath& objectName)     const CIMObjectPath& objectName)
 { {
Line 2346 
Line 2353 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendClassIParameter( void XmlWriter::appendClassIParameter(
     Array<Sint8>& out,      Array<char>& out,
     const char* name,     const char* name,
     const CIMConstClass& cimClass)     const CIMConstClass& cimClass)
 { {
Line 2362 
Line 2369 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendInstanceIParameter( void XmlWriter::appendInstanceIParameter(
     Array<Sint8>& out,      Array<char>& out,
     const char* name,     const char* name,
     const CIMConstInstance& instance)     const CIMConstInstance& instance)
 { {
Line 2378 
Line 2385 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendNamedInstanceIParameter( void XmlWriter::appendNamedInstanceIParameter(
     Array<Sint8>& out,      Array<char>& out,
     const char* name,     const char* name,
     const CIMInstance& namedInstance)     const CIMInstance& namedInstance)
 { {
Line 2397 
Line 2404 
 //     USE: Create parameter for getProperty operation //     USE: Create parameter for getProperty operation
 //========================================================== //==========================================================
 void XmlWriter::appendPropertyNameIParameter( void XmlWriter::appendPropertyNameIParameter(
     Array<Sint8>& out,      Array<char>& out,
     const CIMName& propertyName)     const CIMName& propertyName)
 { {
     _appendIParamValueElementBegin(out, "PropertyName");     _appendIParamValueElementBegin(out, "PropertyName");
Line 2412 
Line 2419 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendPropertyValueIParameter( void XmlWriter::appendPropertyValueIParameter(
     Array<Sint8>& out,      Array<char>& out,
     const char* name,     const char* name,
     const CIMValue& value)     const CIMValue& value)
 { {
Line 2428 
Line 2435 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendPropertyListIParameter( void XmlWriter::appendPropertyListIParameter(
     Array<Sint8>& out,      Array<char>& out,
     const CIMPropertyList& propertyList)     const CIMPropertyList& propertyList)
 { {
     _appendIParamValueElementBegin(out, "PropertyList");     _appendIParamValueElementBegin(out, "PropertyList");
Line 2457 
Line 2464 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendQualifierDeclarationIParameter( void XmlWriter::appendQualifierDeclarationIParameter(
     Array<Sint8>& out,      Array<char>& out,
     const char* name,     const char* name,
     const CIMConstQualifierDecl& qualifierDecl)     const CIMConstQualifierDecl& qualifierDecl)
 { {
Line 2472 
Line 2479 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatHttpErrorRspMessage(  Array<char> XmlWriter::formatHttpErrorRspMessage(
     const String& status,     const String& status,
     const String& cimError,     const String& cimError,
     const String& errorDetail)     const String& errorDetail)
 { {
     Array<Sint8> out;      Array<char> out;
  
     appendHttpErrorResponseHeader(out, status, cimError, errorDetail);     appendHttpErrorResponseHeader(out, status, cimError, errorDetail);
  
Line 2493 
Line 2500 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 // ATTN-RK-P1-20020228: Need to complete copy elimination optimization // ATTN-RK-P1-20020228: Need to complete copy elimination optimization
 Array<Sint8> XmlWriter::formatSimpleMethodReqMessage(  Array<char> XmlWriter::formatSimpleMethodReqMessage(
     const char* host,     const char* host,
     const CIMNamespaceName& nameSpace,     const CIMNamespaceName& nameSpace,
     const CIMObjectPath& path,     const CIMObjectPath& path,
Line 2505 
Line 2512 
     const AcceptLanguages& httpAcceptLanguages,     const AcceptLanguages& httpAcceptLanguages,
     const ContentLanguages& httpContentLanguages)     const ContentLanguages& httpContentLanguages)
 { {
     Array<Sint8> out;      Array<char> out;
     Array<Sint8> tmp;      Array<char> tmp;
     CIMObjectPath localObjectPath = path;     CIMObjectPath localObjectPath = path;
     localObjectPath.setNameSpace(nameSpace.getString());     localObjectPath.setNameSpace(nameSpace.getString());
     localObjectPath.setHost(String::EMPTY);     localObjectPath.setHost(String::EMPTY);
Line 2538 
Line 2545 
     return tmp;     return tmp;
 } }
  
 Array<Sint8> XmlWriter::formatSimpleMethodRspMessage(  
     const CIMName& methodName,  
     const String& messageId,  
     HttpMethod httpMethod,  
     const ContentLanguages & httpContentLanguages,  
     const Array<Sint8>& body,  
                 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);  
                 _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;  
 }  
   
   
 //PEP 128 adding serverRsponseTime to header //PEP 128 adding serverRsponseTime to header
 Array<Sint8> XmlWriter::formatSimpleMethodRspMessage(  Array<char> XmlWriter::formatSimpleMethodRspMessage(
     const CIMName& methodName,     const CIMName& methodName,
     const String& messageId,     const String& messageId,
     HttpMethod httpMethod,     HttpMethod httpMethod,
     const ContentLanguages & httpContentLanguages,     const ContentLanguages & httpContentLanguages,
     const Array<Sint8>& body,      const Array<char>& body,
         Uint64 serverResponseTime,                  Uint32 serverResponseTime,
                 Boolean isFirst,                 Boolean isFirst,
                 Boolean isLast)                 Boolean isLast)
 { {
         Array<Sint8> out;          Array<char> out;
  
         if (isFirst == true)         if (isFirst == true)
         {         {
                 // NOTE: temporarily put zero for content length. the http code                 // NOTE: temporarily put zero for content length. the http code
                 // will later decide to fill in the length or remove it altogether                 // will later decide to fill in the length or remove it altogether
                 appendMethodResponseHeader(out, httpMethod, httpContentLanguages, 0, serverResponseTime);                  appendMethodResponseHeader(out, httpMethod, httpContentLanguages, 0,
                                                                                                                            serverResponseTime);
                 _appendMessageElementBegin(out, messageId);                 _appendMessageElementBegin(out, messageId);
                 _appendSimpleRspElementBegin(out);                 _appendSimpleRspElementBegin(out);
                 _appendMethodResponseElementBegin(out, methodName);                 _appendMethodResponseElementBegin(out, methodName);
Line 2621 
Line 2592 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleMethodErrorRspMessage(  Array<char> XmlWriter::formatSimpleMethodErrorRspMessage(
     const CIMName& methodName,     const CIMName& methodName,
     const String& messageId,     const String& messageId,
     HttpMethod httpMethod,     HttpMethod httpMethod,
     const CIMException& cimException)     const CIMException& cimException)
 { {
     Array<Sint8> out;      Array<char> out;
     Array<Sint8> tmp;      Array<char> tmp;
  
     _appendMessageElementBegin(out, messageId);     _appendMessageElementBegin(out, messageId);
     _appendSimpleRspElementBegin(out);     _appendSimpleRspElementBegin(out);
Line 2654 
Line 2625 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleIMethodReqMessage(  Array<char> XmlWriter::formatSimpleIMethodReqMessage(
     const char* host,     const char* host,
     const CIMNamespaceName& nameSpace,     const CIMNamespaceName& nameSpace,
     const CIMName& iMethodName,     const CIMName& iMethodName,
Line 2663 
Line 2634 
     const String& authenticationHeader,     const String& authenticationHeader,
     const AcceptLanguages& httpAcceptLanguages,     const AcceptLanguages& httpAcceptLanguages,
     const ContentLanguages& httpContentLanguages,     const ContentLanguages& httpContentLanguages,
     const Array<Sint8>& body)      const Array<char>& body)
 { {
     Array<Sint8> out;      Array<char> out;
     Array<Sint8> tmp;      Array<char> tmp;
  
     _appendMessageElementBegin(out, messageId);     _appendMessageElementBegin(out, messageId);
     _appendSimpleReqElementBegin(out);     _appendSimpleReqElementBegin(out);
Line 2698 
Line 2669 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleIMethodRspMessage(  Array<char> XmlWriter::formatSimpleIMethodRspMessage(
     const CIMName& iMethodName,     const CIMName& iMethodName,
     const String& messageId,     const String& messageId,
     HttpMethod httpMethod,     HttpMethod httpMethod,
     const ContentLanguages & httpContentLanguages,     const ContentLanguages & httpContentLanguages,
     const Array<Sint8>& body,      const Array<char>& body,
       Uint32 serverResponseTime,
                 Boolean isFirst,                 Boolean isFirst,
                 Boolean isLast)                 Boolean isLast)
 { {
     Array<Sint8> out;      Array<char> out;
  
                 if (isFirst == true)                 if (isFirst == true)
                 {                 {
                         // NOTE: temporarily put zero for content length. the http code                         // NOTE: temporarily put zero for content length. the http code
                         // will later decide to fill in the length or remove it altogether                         // will later decide to fill in the length or remove it altogether
                         appendMethodResponseHeader(out, httpMethod, httpContentLanguages, 0);                          appendMethodResponseHeader(out, httpMethod, httpContentLanguages, 0,
                                                                                                                                    serverResponseTime);
                         _appendMessageElementBegin(out, messageId);                         _appendMessageElementBegin(out, messageId);
                         _appendSimpleRspElementBegin(out);                         _appendSimpleRspElementBegin(out);
                         _appendIMethodResponseElementBegin(out, iMethodName);                         _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;  
 }  
   
   
   
 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)                          // output the start of the return tag. Test if there is response data by:
                 {                          // 1. there is data on the first chunk OR
                         // NOTE: temporarily put zero for content length. the http code                          // 2. there is no data on the first chunk but isLast is false implying
                         // will later decide to fill in the length or remove it altogether                          //    there is more non-empty data to come. If all subsequent chunks
                         appendMethodResponseHeader(out, httpMethod, httpContentLanguages, 0, serverResponseTime);                          //    are empty, then this generates and empty response.
                         _appendMessageElementBegin(out, messageId);                          if (body.size() != 0 || isLast == false)
                         _appendSimpleRspElementBegin(out);  
                         _appendIMethodResponseElementBegin(out, iMethodName);  
                         if (body.size() != 0)  
                                 _appendIReturnValueElementBegin(out);                                 _appendIReturnValueElementBegin(out);
                 }                 }
  
Line 2771 
Line 2707 
  
                 if (isLast == true)                 if (isLast == true)
                 {                 {
                         if (body.size() != 0)                          if (body.size() != 0 || isFirst == false)
                                 _appendIReturnValueElementEnd(out);                                 _appendIReturnValueElementEnd(out);
                         _appendIMethodResponseElementEnd(out);                         _appendIMethodResponseElementEnd(out);
                         _appendSimpleRspElementEnd(out);                         _appendSimpleRspElementEnd(out);
Line 2788 
Line 2724 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleIMethodErrorRspMessage(  Array<char> XmlWriter::formatSimpleIMethodErrorRspMessage(
     const CIMName& iMethodName,     const CIMName& iMethodName,
     const String& messageId,     const String& messageId,
     HttpMethod httpMethod,     HttpMethod httpMethod,
     const CIMException& cimException)     const CIMException& cimException)
 { {
     Array<Sint8> out;      Array<char> out;
     Array<Sint8> tmp;      Array<char> tmp;
  
     _appendMessageElementBegin(out, messageId);     _appendMessageElementBegin(out, messageId);
     _appendSimpleRspElementBegin(out);     _appendSimpleRspElementBegin(out);
Line 2830 
Line 2766 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendEMethodRequestHeader( void XmlWriter::appendEMethodRequestHeader(
     Array<Sint8>& out,      Array<char>& out,
     const char* requestUri,     const char* requestUri,
     const char* host,     const char* host,
     const CIMName& cimMethod,     const CIMName& cimMethod,
Line 2863 
Line 2799 
         out << "Content-Language: " << contentLanguages << "\r\n";         out << "Content-Language: " << contentLanguages << "\r\n";
     }     }
  
   #ifdef PEGASUS_DEBUG
                 // backdoor environment variable to turn OFF client requesting transfer                 // backdoor environment variable to turn OFF client requesting transfer
                 // encoding. The default is on. to turn off, set this variable to zero.                 // 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                 // This should be removed when stable. This should only be turned off in
Line 2871 
Line 2808 
                 static const char *clientTransferEncodingOff =                 static const char *clientTransferEncodingOff =
                         getenv("PEGASUS_HTTP_TRANSFER_ENCODING_REQUEST");                         getenv("PEGASUS_HTTP_TRANSFER_ENCODING_REQUEST");
                 if (!clientTransferEncodingOff || *clientTransferEncodingOff != '0')                 if (!clientTransferEncodingOff || *clientTransferEncodingOff != '0')
   #endif
                         out << "TE: chunked, trailers" << "\r\n";                         out << "TE: chunked, trailers" << "\r\n";
  
     if (httpMethod == HTTP_METHOD_M_POST)     if (httpMethod == HTTP_METHOD_M_POST)
Line 2903 
Line 2841 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendEMethodResponseHeader( void XmlWriter::appendEMethodResponseHeader(
     Array<Sint8>& out,      Array<char>& out,
     HttpMethod httpMethod,     HttpMethod httpMethod,
     const ContentLanguages& contentLanguages,     const ContentLanguages& contentLanguages,
     Uint32 contentLength)     Uint32 contentLength)
Line 2942 
Line 2880 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendSimpleExportReqElementBegin( void XmlWriter::_appendSimpleExportReqElementBegin(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "<SIMPLEEXPREQ>\n";     out << "<SIMPLEEXPREQ>\n";
 } }
  
 void XmlWriter::_appendSimpleExportReqElementEnd( void XmlWriter::_appendSimpleExportReqElementEnd(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "</SIMPLEEXPREQ>\n";     out << "</SIMPLEEXPREQ>\n";
 } }
Line 2964 
Line 2902 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendEMethodCallElementBegin( void XmlWriter::_appendEMethodCallElementBegin(
     Array<Sint8>& out,      Array<char>& out,
     const CIMName& name)     const CIMName& name)
 { {
     out << "<EXPMETHODCALL NAME=\"" << name << "\">\n";     out << "<EXPMETHODCALL NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::_appendEMethodCallElementEnd( void XmlWriter::_appendEMethodCallElementEnd(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "</EXPMETHODCALL>\n";     out << "</EXPMETHODCALL>\n";
 } }
Line 2988 
Line 2926 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendEParamValueElementBegin( void XmlWriter::_appendEParamValueElementBegin(
     Array<Sint8>& out,      Array<char>& out,
     const char* name)     const char* name)
 { {
     out << "<EXPPARAMVALUE NAME=\"" << name << "\">\n";     out << "<EXPPARAMVALUE NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::_appendEParamValueElementEnd( void XmlWriter::_appendEParamValueElementEnd(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "</EXPPARAMVALUE>\n";     out << "</EXPPARAMVALUE>\n";
 } }
Line 3007 
Line 2945 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendInstanceEParameter( void XmlWriter::appendInstanceEParameter(
     Array<Sint8>& out,      Array<char>& out,
     const char* name,     const char* name,
     const CIMInstance& instance)     const CIMInstance& instance)
 { {
Line 3026 
Line 2964 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendSimpleExportRspElementBegin( void XmlWriter::_appendSimpleExportRspElementBegin(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "<SIMPLEEXPRSP>\n";     out << "<SIMPLEEXPRSP>\n";
 } }
  
 void XmlWriter::_appendSimpleExportRspElementEnd( void XmlWriter::_appendSimpleExportRspElementEnd(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "</SIMPLEEXPRSP>\n";     out << "</SIMPLEEXPRSP>\n";
 } }
Line 3048 
Line 2986 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::_appendEMethodResponseElementBegin( void XmlWriter::_appendEMethodResponseElementBegin(
     Array<Sint8>& out,      Array<char>& out,
     const CIMName& name)     const CIMName& name)
 { {
     out << "<EXPMETHODRESPONSE NAME=\"" << name << "\">\n";     out << "<EXPMETHODRESPONSE NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::_appendEMethodResponseElementEnd( void XmlWriter::_appendEMethodResponseElementEnd(
     Array<Sint8>& out)      Array<char>& out)
 { {
     out << "</EXPMETHODRESPONSE>\n";     out << "</EXPMETHODRESPONSE>\n";
 } }
Line 3066 
Line 3004 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleEMethodReqMessage(  Array<char> XmlWriter::formatSimpleEMethodReqMessage(
     const char* requestUri,     const char* requestUri,
     const char* host,     const char* host,
     const CIMName& eMethodName,     const CIMName& eMethodName,
Line 3075 
Line 3013 
     const String& authenticationHeader,     const String& authenticationHeader,
     const AcceptLanguages& httpAcceptLanguages,     const AcceptLanguages& httpAcceptLanguages,
     const ContentLanguages& httpContentLanguages,     const ContentLanguages& httpContentLanguages,
     const Array<Sint8>& body)      const Array<char>& body)
 { {
     Array<Sint8> out;      Array<char> out;
     Array<Sint8> tmp;      Array<char> tmp;
  
     _appendMessageElementBegin(out, messageId);     _appendMessageElementBegin(out, messageId);
     _appendSimpleExportReqElementBegin(out);     _appendSimpleExportReqElementBegin(out);
Line 3109 
Line 3047 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleEMethodRspMessage(  Array<char> XmlWriter::formatSimpleEMethodRspMessage(
     const CIMName& eMethodName,     const CIMName& eMethodName,
     const String& messageId,     const String& messageId,
     HttpMethod httpMethod,     HttpMethod httpMethod,
     const ContentLanguages& httpContentLanguages,     const ContentLanguages& httpContentLanguages,
     const Array<Sint8>& body)      const Array<char>& body)
 { {
     Array<Sint8> out;      Array<char> out;
     Array<Sint8> tmp;      Array<char> tmp;
  
     _appendMessageElementBegin(out, messageId);     _appendMessageElementBegin(out, messageId);
     _appendSimpleExportRspElementBegin(out);     _appendSimpleExportRspElementBegin(out);
Line 3142 
Line 3080 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleEMethodErrorRspMessage(  Array<char> XmlWriter::formatSimpleEMethodErrorRspMessage(
     const CIMName& eMethodName,     const CIMName& eMethodName,
     const String& messageId,     const String& messageId,
     HttpMethod httpMethod,     HttpMethod httpMethod,
     const CIMException& cimException)     const CIMException& cimException)
 { {
     Array<Sint8> out;      Array<char> out;
     Array<Sint8> tmp;      Array<char> tmp;
  
     _appendMessageElementBegin(out, messageId);     _appendMessageElementBegin(out, messageId);
     _appendSimpleExportRspElementBegin(out);     _appendSimpleExportRspElementBegin(out);

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