(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.23.2.6 and 1.37

version 1.23.2.6, 2001/11/20 06:11:35 version 1.37, 2002/03/07 00:42:12
Line 24 
Line 24 
 // Author: Mike Brasher (mbrasher@bmc.com) // Author: Mike Brasher (mbrasher@bmc.com)
 // //
 // Modified By: Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com) // Modified By: Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)
   //              Nag Boranna, Hewlett-Packard Company (nagaraja_boranna@hp.com)
   //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include <cstdlib> #include <cstdlib>
 #include <cstdio> #include <cstdio>
   #include "Destroyer.h"
 #include "CIMClass.h" #include "CIMClass.h"
 #include "CIMInstance.h" #include "CIMInstance.h"
 #include "CIMQualifierDecl.h" #include "CIMQualifierDecl.h"
Line 37 
Line 40 
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 inline void AppendChar(Array<Sint8>& out, Char16 c)  Array<Sint8>& operator<<(Array<Sint8>& out, const char* x)
   {
       XmlWriter::append(out, x);
       return out;
   }
   
   Array<Sint8>& operator<<(Array<Sint8>& out, char x)
   {
       XmlWriter::append(out, x);
       return out;
   }
   
   Array<Sint8>& operator<<(Array<Sint8>& out, Char16 x)
   {
       XmlWriter::append(out, x);
       return out;
   }
   
   Array<Sint8>& operator<<(Array<Sint8>& out, const String& x)
   {
       XmlWriter::append(out, x);
       return out;
   }
   
   Array<Sint8>& operator<<(Array<Sint8>& out, const Indentor& x)
   {
       XmlWriter::append(out, x);
       return out;
   }
   
   Array<Sint8>& operator<<(Array<Sint8>& out, const Array<Sint8>& x)
   {
       out.appendArray(x);
       return out;
   }
   
   Array<Sint8>& operator<<(Array<Sint8>& out, Uint32 x)
   {
       XmlWriter::append(out, x);
       return out;
   }
   
   inline void _appendChar(Array<Sint8>& out, Char16 c)
 { {
     out.append(Sint8(c));     out.append(Sint8(c));
 } }
  
 inline void AppendSpecialChar(Array<Sint8>& out, Char16 c)  inline void _appendSpecialChar(Array<Sint8>& out, Char16 c)
 { {
     // ATTN-B: Only UTF-8 handled for now.     // ATTN-B: Only UTF-8 handled for now.
  
Line 73 
Line 118 
     }     }
 } }
  
   static inline void _appendSpecialChar(PEGASUS_STD(ostream)& os, char c)
   {
       switch (c)
       {
           case '&':
               os << "&amp;";
               break;
   
           case '<':
               os << "&lt;";
               break;
   
           case '>':
               os << "&gt;";
               break;
   
           case '"':
               os << "&quot;";
               break;
   
           case '\'':
               os << "&apos;";
               break;
   
           default:
               os << c;
       }
   }
   
   static inline void _appendSpecial(PEGASUS_STD(ostream)& os, const char* str)
   {
       while (*str)
           _appendSpecialChar(os, *str++);
   }
   
 void XmlWriter::append(Array<Sint8>& out, Char16 x) void XmlWriter::append(Array<Sint8>& out, Char16 x)
 { {
     AppendChar(out, x);      _appendChar(out, x);
 } }
  
 void XmlWriter::append(Array<Sint8>& out, Uint32 x) void XmlWriter::append(Array<Sint8>& out, Uint32 x)
Line 88 
Line 168 
 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++);          _appendChar(out, *str++);
   }
   
   void XmlWriter::append(Array<Sint8>& out, const String& str)
   {
       const Char16* tmp = str.getData();
   
       while (*tmp)
           _appendChar(out, *tmp++);
   }
   
   void XmlWriter::append(Array<Sint8>& out, const Indentor& x)
   {
       for (Uint32 i = 0; i < 4 * x.getLevel(); i++)
           out.append(' ');
 } }
  
 void XmlWriter::appendSpecial(Array<Sint8>& out, Char16 x) void XmlWriter::appendSpecial(Array<Sint8>& out, Char16 x)
 { {
     AppendSpecialChar(out, x);      _appendSpecialChar(out, x);
 } }
  
 void XmlWriter::appendSpecial(Array<Sint8>& out, char x) void XmlWriter::appendSpecial(Array<Sint8>& out, char x)
 { {
     AppendSpecialChar(out, Char16(x));      _appendSpecialChar(out, Char16(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++);          _appendSpecialChar(out, *str++);
 } }
  
 void XmlWriter::appendSpecial(Array<Sint8>& out, const String& str) void XmlWriter::appendSpecial(Array<Sint8>& out, const String& str)
Line 112 
Line 206 
     const Char16* tmp = str.getData();     const Char16* tmp = str.getData();
  
     while (*tmp)     while (*tmp)
         AppendSpecialChar(out, *tmp++);          _appendSpecialChar(out, *tmp++);
 }  
   
 void XmlWriter::append(Array<Sint8>& out, const String& str)  
 {  
     const Char16* tmp = str.getData();  
   
     while (*tmp)  
         AppendChar(out, *tmp++);  
 } }
  
 void XmlWriter::append(Array<Sint8>& out, const Indentor& x)  //------------------------------------------------------------------------------
 {  //
     for (Uint32 i = 0; i < 4 * x.getLevel(); i++)  // appendLocalNameSpacePathElement()
         out.append(' ');  //
 }  //     <!ELEMENT LOCALNAMESPACEPATH (NAMESPACE+)>
   //
   //------------------------------------------------------------------------------
  
 void XmlWriter::appendLocalNameSpaceElement(  void XmlWriter::appendLocalNameSpacePathElement(
     Array<Sint8>& out,     Array<Sint8>& out,
     const String& nameSpace)     const String& nameSpace)
 { {
Line 147 
Line 235 
     out << "</LOCALNAMESPACEPATH>\n";     out << "</LOCALNAMESPACEPATH>\n";
 } }
  
 static inline void AppendSpecialChar(PEGASUS_STD(ostream)& os, char c)  //------------------------------------------------------------------------------
   //
   // appendNameSpacePathElement()
   //
   //     <!ELEMENT NAMESPACEPATH (HOST,LOCALNAMESPACEPATH)>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendNameSpacePathElement(
       Array<Sint8>& out,
       const String& host,
       const String& nameSpace)
 { {
     switch (c)      out << "<NAMESPACEPATH>\n";
       out << "<HOST>" << host << "</HOST>\n";
       appendLocalNameSpacePathElement(out, nameSpace);
       out << "</NAMESPACEPATH>\n";
   }
   
   //------------------------------------------------------------------------------
   //
   // appendClassNameElement()
   //
   //     <!ELEMENT CLASSNAME EMPTY>
   //     <!ATTLIST CLASSNAME
   //              %CIMName;>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendClassNameElement(
       Array<Sint8>& out,
       const String& className)
     {     {
         case '&':      out << "<CLASSNAME NAME=\"" << className << "\"/>\n";
             os << "&amp;";  }
             break;  
  
         case '<':  //------------------------------------------------------------------------------
             os << "&lt;";  //
             break;  // appendInstanceNameElement()
   //
   //    <!ELEMENT INSTANCENAME (KEYBINDING*|KEYVALUE?|VALUE.REFERENCE?)>
   //    <!ATTLIST INSTANCENAME
   //              %ClassName;>
   //
   //------------------------------------------------------------------------------
  
         case '>':  void XmlWriter::appendInstanceNameElement(
             os << "&gt;";      Array<Sint8>& out,
             break;      const CIMReference& instanceName)
   {
       out << "<INSTANCENAME CLASSNAME=\"" << instanceName.getClassName() << "\">\n";
  
         case '"':      Array<KeyBinding> keyBindings = instanceName.getKeyBindings();
             os << "&quot;";      for (Uint32 i = 0, n = keyBindings.size(); i < n; i++)
             break;      {
           out << "<KEYBINDING NAME=\"" << keyBindings[i].getName() << "\">\n";
  
         case '\'':          if (keyBindings[i].getType() == KeyBinding::REFERENCE)
             os << "&apos;";          {
             break;              CIMReference ref = keyBindings[i].getValue();
               ref.toXml(out, true);
           }
           else {
               out << "<KEYVALUE VALUETYPE=\"";
               out << KeyBinding::typeToString(keyBindings[i].getType());
               out << "\">";
  
         default:              // fixed the special character problem - Markus
             os << c;  
               appendSpecial(out, keyBindings[i].getValue());
               out << "</KEYVALUE>\n";
           }
           out << "</KEYBINDING>\n";
       }
       out << "</INSTANCENAME>\n";
   }
   
   //------------------------------------------------------------------------------
   //
   // appendClassPathElement()
   //
   //     <!ELEMENT CLASSPATH (NAMESPACEPATH,CLASSNAME)>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendClassPathElement(
       Array<Sint8>& out,
       const CIMReference& classPath)
   {
       out << "<CLASSPATH>\n";
       appendNameSpacePathElement(out,
                                  classPath.getHost(),
                                  classPath.getNameSpace());
       appendClassNameElement(out, classPath.getClassName());
       out << "</CLASSPATH>\n";
     }     }
   
   //------------------------------------------------------------------------------
   //
   // appendInstancePathElement()
   //
   //     <!ELEMENT INSTANCEPATH (NAMESPACEPATH,INSTANCENAME)>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendInstancePathElement(
       Array<Sint8>& out,
       const CIMReference& instancePath)
   {
       out << "<INSTANCEPATH>\n";
       appendNameSpacePathElement(out,
                                  instancePath.getHost(),
                                  instancePath.getNameSpace());
       appendInstanceNameElement(out, instancePath);
       out << "</INSTANCEPATH>\n";
 } }
  
 static inline void AppendSpecial(PEGASUS_STD(ostream)& os, const char* str)  //------------------------------------------------------------------------------
   //
   // appendLocalClassPathElement()
   //
   //     <!ELEMENT LOCALCLASSPATH (LOCALNAMESPACEPATH, CLASSNAME)>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendLocalClassPathElement(
       Array<Sint8>& out,
       const CIMReference& classPath)
 { {
     while (*str)      out << "<LOCALCLASSPATH>\n";
         AppendSpecialChar(os, *str++);      appendLocalNameSpacePathElement(out, classPath.getNameSpace());
       appendClassNameElement(out, classPath.getClassName());
       out << "</LOCALCLASSPATH>\n";
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatGetHeader()  // appendLocalInstancePathElement()
   //
   //     <!ELEMENT LOCALINSTANCEPATH (LOCALNAMESPACEPATH, INSTANCENAME)>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatGetHeader(  void XmlWriter::appendLocalInstancePathElement(
     const char* documentPath)      Array<Sint8>& out,
       const CIMReference& instancePath)
 { {
     Array<Sint8> out;      out << "<LOCALINSTANCEPATH>\n";
     return out << "GET " << documentPath << "HTTP/1.0\r\n\r\n";      appendLocalNameSpacePathElement(out, instancePath.getNameSpace());
       appendInstanceNameElement(out, instancePath);
       out << "</LOCALINSTANCEPATH>\n";
   }
   
   //------------------------------------------------------------------------------
   //
   // appendLocalObjectPathElement()
   //
   //     If the reference refers to an instance, write a LOCALINSTANCEPATH;
   //     otherwise write a LOCALCLASSPATH.
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendLocalObjectPathElement(
       Array<Sint8>& out,
       const CIMReference& objectPath)
   {
       if (objectPath.isInstanceName())
       {
           appendLocalInstancePathElement(out, objectPath);
       }
       else
       {
           appendLocalClassPathElement(out, objectPath);
       }
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatMPostHeader()  // appendMethodCallHeader()
 // //
 //     Build HTTP request header.  //     Build HTTP method call request header.
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatMPostHeader(  void XmlWriter::appendMethodCallHeader(
       Array<Sint8>& out,
     const char* host,     const char* host,
     const char* cimOperation,  
     const char* cimMethod,     const char* cimMethod,
     const String& cimObject,     const String& cimObject,
     const Array<Sint8>& content)      const String& authenticationHeader,
       Uint32 contentLength)
 { {
     Array<Sint8> out;  
     out.reserve(1024);  
     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
  
     out << "M-POST /cimom HTTP/1.1\r\n";     out << "M-POST /cimom HTTP/1.1\r\n";
     out << "HOST: " << host << "\r\n";     out << "HOST: " << host << "\r\n";
     out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";     out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";
     out << "Content-Length: " << content.size() << "\r\n";      out << "Content-Length: " << contentLength << "\r\n";
     out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";     out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";
     out << nn <<"\r\n";     out << nn <<"\r\n";
     out << nn << "-CIMOperation: " << cimOperation << "\r\n";      out << nn << "-CIMOperation: MethodCall\r\n";
     out << nn << "-CIMMethod: " << cimMethod << "\r\n";     out << nn << "-CIMMethod: " << cimMethod << "\r\n";
     out << nn << "-CIMObject: " << cimObject << "\r\n\r\n";      out << nn << "-CIMObject: " << cimObject << "\r\n";
     out << content;      if (authenticationHeader.size())
     return out;      {
           out << authenticationHeader << "\r\n";
       }
       out << "\r\n";
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatMethodResponseHeader()  // appendMethodResponseHeader()
 // //
 //     Build HTTP response header. //     Build HTTP response header.
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatMethodResponseHeader(  void XmlWriter::appendMethodResponseHeader(
     const Array<Sint8>& content)      Array<Sint8>& out,
       Uint32 contentLength)
 { {
     Array<Sint8> out;  
     out.reserve(1024);  
     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
  
     out << "HTTP/1.1 200 OK\r\n";     out << "HTTP/1.1 200 OK\r\n";
     out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";     out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";
     out << "Content-Length: " << content.size() << "\r\n";      out << "Content-Length: " << contentLength << "\r\n";
     out << "Ext:\r\n";     out << "Ext:\r\n";
     out << "Cache-Control: no-cache\r\n";     out << "Cache-Control: no-cache\r\n";
     out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";     out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";
     out << nn <<"\r\n";     out << nn <<"\r\n";
     out << nn << "-CIMOperation: MethodResponse\r\n\r\n";     out << nn << "-CIMOperation: MethodResponse\r\n\r\n";
     out << content;  
     return out;  
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatMessageElement()  // appendUnauthorizedResponseHeader()
 // //
 //     <!ELEMENT MESSAGE (SIMPLEREQ|MULTIREQ|SIMPLERSP|MULTIRSP)>  //     Build HTTP authentication response header for unauthorized requests.
 //     <!ATTLIST MESSAGE  //
 //         ID CDATA #REQUIRED  //     Returns unauthorized message in the following format:
 //         PROTOCOLVERSION CDATA #REQUIRED>  //
   //        HTTP/1.1 401 Unauthorized
   //        WWW-Authenticate: Basic "hostname:80"
   //        <HTML><HEAD>
   //        <TITLE>401 Unauthorized</TITLE>
   //        </HEAD><BODY BGCOLOR="#99cc99">
   //        <H2>TEST401 Unauthorized</H2>
   //        <HR>
   //        </BODY></HTML>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatMessageElement(  void XmlWriter::appendUnauthorizedResponseHeader(
     const String& messageId,      Array<Sint8>& out,
     const Array<Sint8>& body)      const String& content)
 { {
     Array<Sint8> out;      out << "HTTP/1.1 401 Unauthorized\r\n";
     out.reserve(1024);      out << content << "\r\n";
       out << "\r\n";
  
     out << "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";  //ATTN: We may need to include the following line, so that the browsers
     out << "<CIM CIMVERSION=\"2.0\" DTDVERSION=\"2.0\">\n";  //      can display the error message.
     out << "<MESSAGE ID=\"" << messageId << "\" PROTOCOLVERSION=\"1.0\">\n";  //    out << "<HTML><HEAD>\r\n";
     out << body;  //    out << "<TITLE>" << "401 Unauthorized" <<  "</TITLE>\r\n";
     out << "</MESSAGE>\n";  //    out << "</HEAD><BODY BGCOLOR=\"#99cc99\">\r\n";
     out << "</CIM>\n";  //    out << "<H2>TEST" << "401 Unauthorized" << "</H2>\r\n";
     return out;  //    out << "<HR>\r\n";
   //    out << "</BODY></HTML>\r\n";
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatSimpleReqElement()  // appendBadRequestResponseHeader()
 // //
 //     <!ELEMENT SIMPLEREQ (IMETHODCALL|METHODCALL)>  //     Build HTTP response header for bad requests.
   //
   //     Returns Bad Request message in the following format:
   //
   //        HTTP/1.1 400 Bad Request
   //        CIMError: <error text>    (only if specified by caller)
   //        <HTML><HEAD>
   //        <TITLE>400 Bad Request</TITLE>
   //        </HEAD><BODY BGCOLOR="#99cc99">
   //        <H2>TEST400 Bad Request</H2>
   //        <HR>
   //        </BODY></HTML>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleReqElement(  void XmlWriter::appendBadRequestResponseHeader(
     const Array<Sint8>& body)      Array<Sint8>& out,
       const String& cimError)
 { {
     Array<Sint8> out;      out << "HTTP/1.1 400 Bad Request\r\n";
     return out << "<SIMPLEREQ>\n" << body << "</SIMPLEREQ>\n";      if (cimError != String::EMPTY)
       {
           out << "CIMError: " << cimError << "\r\n";
       }
       out << "\r\n";
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatSimpleRspElement()  // appendNotImplementedResponseHeader()
 // //
 //     <!ELEMENT SIMPLERSP (METHODRESPONSE|IMETHODRESPONSE)>  //     Build HTTP 501 Not Implemented response header
   //
   //     Returns Not Implemented message in the following format:
   //
   //        HTTP/1.1 501 Not Implemented
   //        <HTML><HEAD>
   //        <TITLE>501 Not Implemented</TITLE>
   //        CIMError: <error text>    (only if specified by caller)
   //        </HEAD><BODY BGCOLOR="#99cc99">
   //        <H2>TEST501 Not Implemented</H2>
   //        <HR>
   //        </BODY></HTML>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleRspElement(  void XmlWriter::appendNotImplementedResponseHeader(
     const Array<Sint8>& body)      Array<Sint8>& out,
       const String& cimError)
 { {
     Array<Sint8> out;      out << "HTTP/1.1 501 Not Implemented\r\n";
     return out << "<SIMPLERSP>\n" << body << "</SIMPLERSP>\n";      if (cimError != String::EMPTY)
       {
           out << "CIMError: " << cimError << "\r\n";
       }
       out << "\r\n";
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatIMethodCallElement()  // _appendMessageElementBegin()
   // _appendMessageElementEnd()
 // //
 //     <!ELEMENT IMETHODCALL (LOCALNAMESPACEPATH,IPARAMVALUE*)>  //     <!ELEMENT MESSAGE (SIMPLEREQ|MULTIREQ|SIMPLERSP|MULTIRSP)>
 //     <!ATTLIST IMETHODCALL %CIMName;>  //     <!ATTLIST MESSAGE
   //         ID CDATA #REQUIRED
   //         PROTOCOLVERSION CDATA #REQUIRED>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatIMethodCallElement(  void XmlWriter::_appendMessageElementBegin(
     const char* name,      Array<Sint8>& out,
     const String& nameSpace,      const String& messageId)
     const Array<Sint8>& iParamValues)  
 { {
     Array<Sint8> out;      out << "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";
     out << "<IMETHODCALL NAME=\"" << name << "\">\n";      out << "<CIM CIMVERSION=\"2.0\" DTDVERSION=\"2.0\">\n";
     XmlWriter::appendLocalNameSpaceElement(out, nameSpace);      out << "<MESSAGE ID=\"" << messageId << "\" PROTOCOLVERSION=\"1.0\">\n";
     out << iParamValues;  }
     out << "</IMETHODCALL>\n";  
     return out;  void XmlWriter::_appendMessageElementEnd(
       Array<Sint8>& out)
   {
       out << "</MESSAGE>\n";
       out << "</CIM>\n";
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatIMethodResponseElement()  // _appendSimpleReqElementBegin()
   // _appendSimpleReqElementEnd()
 // //
 //     <!ELEMENT IMETHODRESPONSE (ERROR|IRETURNVALUE?)>  //     <!ELEMENT SIMPLEREQ (IMETHODCALL|METHODCALL)>
 //     <!ATTLIST IMETHODRESPONSE %CIMName;>  
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatIMethodResponseElement(  void XmlWriter::_appendSimpleReqElementBegin(
     const char* name,      Array<Sint8>& out)
     const Array<Sint8>& body)  
 { {
     Array<Sint8> out;      out << "<SIMPLEREQ>\n";
     out << "<IMETHODRESPONSE NAME=\"" << name << "\">\n";  }
     out << body;  
     out << "</IMETHODRESPONSE>\n";  void XmlWriter::_appendSimpleReqElementEnd(
     return out;      Array<Sint8>& out)
   {
       out << "</SIMPLEREQ>\n";
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatIReturnValueElement()  // _appendMethodCallElementBegin()
   // _appendMethodCallElementEnd()
 // //
 //      <!ELEMENT IRETURNVALUE (CLASSNAME*|INSTANCENAME*|VALUE*|  //     <!ELEMENT METHODCALL ((LOCALCLASSPATH|LOCALINSTANCEPATH),PARAMVALUE*)>
 //          VALUE.OBJECTWITHPATH*|VALUE.OBJECTWITHLOCALPATH*|VALUE.OBJECT*|  //     <!ATTLIST METHODCALL %CIMName;>
 //          OBJECTPATH*|QUALIFIER.DECLARATION*|VALUE.ARRAY?|VALUE.REFERENCE?|  
 //          CLASS*|INSTANCE*|VALUE.NAMEDINSTANCE*)>  
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatIReturnValueElement(  void XmlWriter::_appendMethodCallElementBegin(
     const Array<Sint8>& body)      Array<Sint8>& out,
       const char* name)
 { {
     Array<Sint8> out;      out << "<METHODCALL NAME=\"" << name << "\">\n";
     return out << "<IRETURNVALUE>\n" << body << "</IRETURNVALUE>\n";  }
   
   void XmlWriter::_appendMethodCallElementEnd(
       Array<Sint8>& out)
   {
       out << "</METHODCALL>\n";
   }
   
   //------------------------------------------------------------------------------
   //
   // _appendIMethodCallElementBegin()
   // _appendIMethodCallElementEnd()
   //
   //     <!ELEMENT IMETHODCALL (LOCALNAMESPACEPATH,IPARAMVALUE*)>
   //     <!ATTLIST IMETHODCALL %CIMName;>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::_appendIMethodCallElementBegin(
       Array<Sint8>& out,
       const char* name)
   {
       out << "<IMETHODCALL NAME=\"" << name << "\">\n";
   }
   
   void XmlWriter::_appendIMethodCallElementEnd(
       Array<Sint8>& out)
   {
       out << "</IMETHODCALL>\n";
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatIParamValueElement()  // _appendIParamValueElementBegin()
   // _appendIParamValueElementEnd()
 // //
 //     <!ELEMENT IPARAMVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE //     <!ELEMENT IPARAMVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE
 //         |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION //         |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION
Line 382 
Line 675 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::formatIParamValueElement(  void XmlWriter::_appendIParamValueElementBegin(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* name,      const char* name)
     const Array<Sint8>& body)  
 { {
     out << "<IPARAMVALUE NAME=\"" << name << "\">\n";     out << "<IPARAMVALUE NAME=\"" << name << "\">\n";
     out << body;  }
   
   void XmlWriter::_appendIParamValueElementEnd(
       Array<Sint8>& out)
   {
     out << "</IPARAMVALUE>\n";     out << "</IPARAMVALUE>\n";
     return out;  
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatErrorElement()  // _appendSimpleRspElementBegin()
   // _appendSimpleRspElementEnd()
   //
   //     <!ELEMENT SIMPLERSP (METHODRESPONSE|IMETHODRESPONSE)>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::_appendSimpleRspElementBegin(
       Array<Sint8>& out)
   {
       out << "<SIMPLERSP>\n";
   }
   
   void XmlWriter::_appendSimpleRspElementEnd(
       Array<Sint8>& out)
   {
       out << "</SIMPLERSP>\n";
   }
   
   //------------------------------------------------------------------------------
   //
   // _appendMethodResponseElementBegin()
   // _appendMethodResponseElementEnd()
   //
   //     <!ELEMENT METHODRESPONSE (ERROR|IRETURNVALUE?)>
   //     <!ATTLIST METHODRESPONSE %CIMName;>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::_appendMethodResponseElementBegin(
       Array<Sint8>& out,
       const char* name)
   {
       out << "<METHODRESPONSE NAME=\"" << name << "\">\n";
   }
   
   void XmlWriter::_appendMethodResponseElementEnd(
       Array<Sint8>& out)
   {
       out << "</METHODRESPONSE>\n";
   }
   
   //------------------------------------------------------------------------------
   //
   // _appendIMethodResponseElementBegin()
   // _appendIMethodResponseElementEnd()
   //
   //     <!ELEMENT IMETHODRESPONSE (ERROR|IRETURNVALUE?)>
   //     <!ATTLIST IMETHODRESPONSE %CIMName;>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::_appendIMethodResponseElementBegin(
       Array<Sint8>& out,
       const char* name)
   {
       out << "<IMETHODRESPONSE NAME=\"" << name << "\">\n";
   }
   
   void XmlWriter::_appendIMethodResponseElementEnd(
       Array<Sint8>& out)
   {
       out << "</IMETHODRESPONSE>\n";
   }
   
   //------------------------------------------------------------------------------
   //
   // _appendErrorElement()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatErrorElement(  void XmlWriter::_appendErrorElement(
       Array<Sint8>& out,
     CIMStatusCode code,     CIMStatusCode code,
     const char* description)     const char* description)
 { {
     Array<Sint8> out;  
     out << "<ERROR";     out << "<ERROR";
     out << " CODE=\"" << Uint32(code) << "\"";     out << " CODE=\"" << Uint32(code) << "\"";
     out << " DESCRIPTION=\"";     out << " DESCRIPTION=\"";
     appendSpecial(out, description);     appendSpecial(out, description);
     out << "\"/>";     out << "\"/>";
     return out;  
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendBooleanParameter()  // appendReturnValueElement()
   //
   // <!ELEMENT RETURNVALUE (VALUE|VALUE.REFERENCE)>
   // <!ATTLIST RETURNVALUE
   //     %ParamType;>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendBooleanParameter(  void XmlWriter::appendReturnValueElement(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* name,      const CIMValue& value)
     Boolean flag)  
 { {
     Array<Sint8> tmp;      out << "<RETURNVALUE";
     tmp << "<VALUE>" << (flag ? "TRUE" : "FALSE") << "</VALUE>\n";  
     return formatIParamValueElement(out, name, tmp);      CIMType type = value.getType();
       if (type != CIMType::NONE)
       {
           out << " PARAMTYPE=\"" << TypeToString(type) << "\"";
       }
   
       out << ">\n";
   
       // Add value. If no value is Null, do not put <VALUE> tags on
       value.toXml(out, false);
       out << "</RETURNVALUE>\n";
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendStringIParameter()  // _appendIReturnValueElementBegin()
   // _appendIReturnValueElementEnd()
   //
   //      <!ELEMENT IRETURNVALUE (CLASSNAME*|INSTANCENAME*|VALUE*|
   //          VALUE.OBJECTWITHPATH*|VALUE.OBJECTWITHLOCALPATH*|VALUE.OBJECT*|
   //          OBJECTPATH*|QUALIFIER.DECLARATION*|VALUE.ARRAY?|VALUE.REFERENCE?|
   //          CLASS*|INSTANCE*|VALUE.NAMEDINSTANCE*)>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::_appendIReturnValueElementBegin(
       Array<Sint8>& out)
   {
       out << "<IRETURNVALUE>\n";
   }
   
   void XmlWriter::_appendIReturnValueElementEnd(
       Array<Sint8>& out)
   {
       out << "</IRETURNVALUE>\n";
   }
   
   //------------------------------------------------------------------------------
   //
   // appendBooleanIParameter()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendStringIParameter(  void XmlWriter::appendBooleanIParameter(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* name,     const char* name,
     const String& str)      Boolean flag)
 { {
     Array<Sint8> tmp;      _appendIParamValueElementBegin(out, name);
     tmp << "<VALUE>";      out << "<VALUE>" << (flag ? "TRUE" : "FALSE") << "</VALUE>\n";
     appendSpecial(tmp, str);      _appendIParamValueElementEnd(out);
     tmp << "</VALUE>\n";  
     return formatIParamValueElement(out, name, tmp);  
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendClassNameParameter()  // appendStringIParameter()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendClassNameParameter(  void XmlWriter::appendStringIParameter(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* name,     const char* name,
     const String& className)      const String& str)
 { {
     Array<Sint8> tmp;      _appendIParamValueElementBegin(out, name);
     appendClassNameElement(tmp, className);      out << "<VALUE>";
     return formatIParamValueElement(out, name, tmp);      appendSpecial(out, str);
       out << "</VALUE>\n";
       _appendIParamValueElementEnd(out);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendQualifierNameParameter()  // appendQualifierNameIParameter()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendQualifierNameParameter(  void XmlWriter::appendQualifierNameIParameter(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* name,     const char* name,
     const String& qualifierName)     const String& qualifierName)
Line 481 
Line 879 
     // as an IPARAMVALUE element according to the spec (look above). So we     // as an IPARAMVALUE element according to the spec (look above). So we
     // just pass it as a class name. An answer must be obtained later.     // just pass it as a class name. An answer must be obtained later.
  
     Array<Sint8> tmp;      _appendIParamValueElementBegin(out, name);
     appendClassNameElement(tmp, qualifierName);      appendClassNameElement(out, qualifierName);
     return formatIParamValueElement(out, name, tmp);      _appendIParamValueElementEnd(out);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendClassParameter()  // appendClassNameIParameter()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendClassParameter(  void XmlWriter::appendClassNameIParameter(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* parameterName,      const char* name,
     const CIMConstClass& cimClass)      const String& className)
 { {
     Array<Sint8> tmp;      _appendIParamValueElementBegin(out, name);
     cimClass.toXml(tmp);      appendClassNameElement(out, className);
     return formatIParamValueElement(out, parameterName, tmp);      _appendIParamValueElementEnd(out);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendInstanceNameParameter()  // appendInstanceNameIParameter()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendInstanceNameParameter(  void XmlWriter::appendInstanceNameIParameter(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* parameterName,      const char* name,
     const CIMReference& instanceName)     const CIMReference& instanceName)
 { {
     Array<Sint8> tmp;      _appendIParamValueElementBegin(out, name);
     instanceName.instanceNameToXml(tmp);      appendInstanceNameElement(out, instanceName);
     return formatIParamValueElement(out, parameterName, tmp);      _appendIParamValueElementEnd(out);
   }
   
   void XmlWriter::appendObjectNameIParameter(
       Array<Sint8>& out,
       const char* name,
       const CIMReference& objectName)
   {
       if (objectName.isClassName())
       {
           XmlWriter::appendClassNameIParameter(
               out, name, objectName.getClassName());
       }
       else
       {
           XmlWriter::appendInstanceNameIParameter(
               out, name, objectName);
       }
   }
   
   //------------------------------------------------------------------------------
   //
   // appendClassIParameter()
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendClassIParameter(
       Array<Sint8>& out,
       const char* name,
       const CIMConstClass& cimClass)
   {
       _appendIParamValueElementBegin(out, name);
       cimClass.toXml(out);
       _appendIParamValueElementEnd(out);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendInstanceParameter()  // appendInstanceIParameter()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendInstanceParameter(  void XmlWriter::appendInstanceIParameter(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* parameterName,      const char* name,
     const CIMConstInstance& instance)     const CIMConstInstance& instance)
 { {
     Array<Sint8> tmp;      _appendIParamValueElementBegin(out, name);
     instance.toXml(tmp);      instance.toXml(out);
     return formatIParamValueElement(out, parameterName, tmp);      _appendIParamValueElementEnd(out);
   }
   
   //------------------------------------------------------------------------------
   //
   // appendNamedInstanceIParameter()
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendNamedInstanceIParameter(
       Array<Sint8>& out,
       const char* name,
       const CIMNamedInstance& namedInstance)
   {
       _appendIParamValueElementBegin(out, name);
       namedInstance.toXml(out);
       _appendIParamValueElementEnd(out);
 } }
  
 //---------------------------------------------------------- //----------------------------------------------------------
 // //
 //  appendPropertyNameParameter()  //  appendPropertyNameIParameter()
 // //
 //     </IPARAMVALUE> //     </IPARAMVALUE>
 //     <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
 //========================================================== //==========================================================
 Array<Sint8>& XmlWriter::appendPropertyNameParameter(  void XmlWriter::appendPropertyNameIParameter(
     Array<Sint8>& out,     Array<Sint8>& out,
     const String& propertyName)     const String& propertyName)
 { {
     Array<Sint8> tmp;      _appendIParamValueElementBegin(out, "PropertyName");
     tmp << "<VALUE>" << propertyName << "</VALUE>\n";      out << "<VALUE>" << propertyName << "</VALUE>\n";
     return formatIParamValueElement(out,"PropertyName", tmp);}      _appendIParamValueElementEnd(out);
   }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendPropertyValueParameter()  // appendPropertyValueIParameter()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendPropertyValueParameter(  void XmlWriter::appendPropertyValueIParameter(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* parameterName,      const char* name,
     const CIMValue& value)     const CIMValue& value)
 { {
     Array<Sint8> tmp;      _appendIParamValueElementBegin(out, name);
     value.toXml(tmp);      value.toXml(out, false);
     return formatIParamValueElement(out, parameterName, tmp);      _appendIParamValueElementEnd(out);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendPropertyListParameter()  // appendPropertyListIParameter()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendPropertyListParameter(  void XmlWriter::appendPropertyListIParameter(
     Array<Sint8>& out,     Array<Sint8>& out,
     const Array<String>& propertyList)      const CIMPropertyList& propertyList)
 { {
     Array<Sint8> tmp;      // ATTN: P3 KS 4 Mar 2002 - As check shouldn't we check for null property list
       _appendIParamValueElementBegin(out, "PropertyList");
     tmp << "<VALUE.ARRAY>\n";  
  
     for (Uint32 i = 0; i < propertyList.size(); i++)      out << "<VALUE.ARRAY>\n";
       for (Uint32 i = 0; i < propertyList.getNumProperties(); i++)
     {     {
         tmp << "<VALUE>" << propertyList[i] << "</VALUE>\n";          out << "<VALUE>" << propertyList.getPropertyName(i) << "</VALUE>\n";
     }     }
       out << "</VALUE.ARRAY>\n";
  
     tmp << "</VALUE.ARRAY>\n";      _appendIParamValueElementEnd(out);
     return formatIParamValueElement(out, "PropertyList", tmp);  
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendQualifierDeclarationParameter()  // appendQualifierDeclarationIParameter()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendQualifierDeclarationParameter(  void XmlWriter::appendQualifierDeclarationIParameter(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* parameterName,      const char* name,
     const CIMConstQualifierDecl& qualifierDecl)     const CIMConstQualifierDecl& qualifierDecl)
 { {
     Array<Sint8> tmp;      _appendIParamValueElementBegin(out, name);
     qualifierDecl.toXml(tmp);      qualifierDecl.toXml(out);
     return formatIParamValueElement(out, parameterName, tmp);      _appendIParamValueElementEnd(out);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendClassNameElement()  // XmlWriter::formatSimpleMethodReqMessage()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendClassNameElement(  // ATTN-RK-P1-20020228: Need to complete copy elimination optimization
     Array<Sint8>& out,  Array<Sint8> XmlWriter::formatSimpleMethodReqMessage(
     const String& className)      const char* host,
       const CIMReference& path,
       const char* methodName,
       const Array<CIMParamValue>& parameters,
       const String& messageId,
       const String& authenticationHeader)
 { {
     return out << "<CLASSNAME NAME=\"" << className << "\"/>\n";      Array<Sint8> out;
 }      Array<Sint8> tmp;
  
 //------------------------------------------------------------------------------      _appendMessageElementBegin(out, messageId);
 //      _appendSimpleReqElementBegin(out);
 // appendInstanceNameElement()      _appendMethodCallElementBegin(out, methodName);
 //      appendLocalObjectPathElement(out, path);
 //------------------------------------------------------------------------------      for (Uint32 i=0; i < parameters.size(); i++)
       {
           parameters[i].toXml(out);
       }
       _appendMethodCallElementEnd(out);
       _appendSimpleReqElementEnd(out);
       _appendMessageElementEnd(out);
  
 Array<Sint8>& XmlWriter::appendInstanceNameElement(      appendMethodCallHeader(
     Array<Sint8>& out,          tmp,
     const CIMReference& instanceName)          host,
 {          methodName,
     instanceName.instanceNameToXml(out);          path.toString(false),
     return out;          authenticationHeader,
 }          out.size());
       tmp << out;
  
 //------------------------------------------------------------------------------      return tmp;
 //  }
 // _printAttributes()  
 //  
 //------------------------------------------------------------------------------  
  
 static void _printAttributes(  Array<Sint8> XmlWriter::formatSimpleMethodRspMessage(
     PEGASUS_STD(ostream)& os,      const char* methodName,
     const XmlAttribute* attributes,      const String& messageId,
     Uint32 attributeCount)      const Array<Sint8>& body)
 {  
     for (Uint32 i = 0; i < attributeCount; i++)  
     {     {
         os << attributes[i].name << "=";      Array<Sint8> out;
       Array<Sint8> tmp;
  
         os << '"';      _appendMessageElementBegin(out, messageId);
         AppendSpecial(os, attributes[i].value);      _appendSimpleRspElementBegin(out);
         os << '"';      _appendMethodResponseElementBegin(out, methodName);
       out << body;
       _appendMethodResponseElementEnd(out);
       _appendSimpleRspElementEnd(out);
       _appendMessageElementEnd(out);
  
         if (i + 1 != attributeCount)      appendMethodResponseHeader(tmp, out.size());
             os << ' ';      tmp << out;
     }  
       return tmp;
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // _indent()  // XmlWriter::formatSimpleMethodErrorRspMessage()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 static void _indent(PEGASUS_STD(ostream)& os, Uint32 level, Uint32 indentChars)  Array<Sint8> XmlWriter::formatSimpleMethodErrorRspMessage(
       const String& methodName,
       const String& messageId,
       CIMStatusCode code,
       const String& description)
 { {
     Uint32 n = level * indentChars;      ArrayDestroyer<char> tmp1(methodName.allocateCString());
       ArrayDestroyer<char> tmp2(description.allocateCString());
       Array<Sint8> out;
       Array<Sint8> tmp;
  
     for (Uint32 i = 0; i < n; i++)      _appendMessageElementBegin(out, messageId);
         os << ' ';      _appendSimpleRspElementBegin(out);
       _appendMethodResponseElementBegin(out, tmp1.getPointer());
       _appendErrorElement(out, code, tmp2.getPointer());
       _appendMethodResponseElementEnd(out);
       _appendSimpleRspElementEnd(out);
       _appendMessageElementEnd(out);
   
       appendMethodResponseHeader(tmp, out.size());
       tmp << out;
   
       return tmp;
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // indentedPrint()  // XmlWriter::formatSimpleIMethodReqMessage()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::indentedPrint(  Array<Sint8> XmlWriter::formatSimpleIMethodReqMessage(
     PEGASUS_STD(ostream)& os,      const char* host,
     const char* text,      const String& nameSpace,
     Uint32 indentChars)      const char* iMethodName,
       const String& messageId,
       const String& authenticationHeader,
       const Array<Sint8>& body)
 { {
     char* tmp = strcpy(new char[strlen(text) + 1], text);      Array<Sint8> out;
       Array<Sint8> tmp;
  
     XmlParser parser(tmp);      _appendMessageElementBegin(out, messageId);
     XmlEntry entry;      _appendSimpleReqElementBegin(out);
     Stack<const char*> stack;      _appendIMethodCallElementBegin(out, iMethodName);
       appendLocalNameSpacePathElement(out, nameSpace);
       out << body;
       _appendIMethodCallElementEnd(out);
       _appendSimpleReqElementEnd(out);
       _appendMessageElementEnd(out);
  
     while (parser.next(entry))      appendMethodCallHeader(
     {          tmp,
         switch (entry.type)          host,
         {          iMethodName,
             case XmlEntry::XML_DECLARATION:          nameSpace,
             {          authenticationHeader,
                 _indent(os, stack.size(), indentChars);          out.size());
       tmp << out;
  
                 os << "<?" << entry.text << " ";      return tmp;
                 _printAttributes(os, entry.attributes, entry.attributeCount);  
                 os << "?>";  
                 break;  
             }             }
  
             case XmlEntry::START_TAG:  //------------------------------------------------------------------------------
   //
   // XmlWriter::formatSimpleIMethodRspMessage()
   //
   //------------------------------------------------------------------------------
   
   Array<Sint8> XmlWriter::formatSimpleIMethodRspMessage(
       const char* iMethodName,
       const String& messageId,
       const Array<Sint8>& body)
             {             {
                 _indent(os, stack.size(), indentChars);      Array<Sint8> out;
       Array<Sint8> tmp;
  
                 os << "<" << entry.text;      _appendMessageElementBegin(out, messageId);
       _appendSimpleRspElementBegin(out);
       _appendIMethodResponseElementBegin(out, iMethodName);
       _appendIReturnValueElementBegin(out);
       out << body;
       _appendIReturnValueElementEnd(out);
       _appendIMethodResponseElementEnd(out);
       _appendSimpleRspElementEnd(out);
       _appendMessageElementEnd(out);
  
                 if (entry.attributeCount)      appendMethodResponseHeader(tmp, out.size());
                     os << ' ';      tmp << out;
  
                 _printAttributes(os, entry.attributes, entry.attributeCount);      return tmp;
                 os << ">";  
                 stack.push(entry.text);  
                 break;  
             }             }
  
             case XmlEntry::EMPTY_TAG:  //------------------------------------------------------------------------------
             {  //
                 _indent(os, stack.size(), indentChars);  // XmlWriter::formatSimpleIMethodErrorRspMessage()
   //
                 os << "<" << entry.text << " ";  //------------------------------------------------------------------------------
                 _printAttributes(os, entry.attributes, entry.attributeCount);  
                 os << "/>";  
                 break;  
             }  
  
             case XmlEntry::END_TAG:  Array<Sint8> XmlWriter::formatSimpleIMethodErrorRspMessage(
       const String& iMethodName,
       const String& messageId,
       CIMStatusCode code,
       const String& description)
             {             {
                 if (!stack.isEmpty() && strcmp(stack.top(), entry.text) == 0)      ArrayDestroyer<char> tmp1(iMethodName.allocateCString());
                     stack.pop();      ArrayDestroyer<char> tmp2(description.allocateCString());
       Array<Sint8> out;
                 _indent(os, stack.size(), indentChars);      Array<Sint8> tmp;
  
                 os << "</" << entry.text << ">";      _appendMessageElementBegin(out, messageId);
                 break;      _appendSimpleRspElementBegin(out);
             }      _appendIMethodResponseElementBegin(out, tmp1.getPointer());
       _appendErrorElement(out, code, tmp2.getPointer());
       _appendIMethodResponseElementEnd(out);
       _appendSimpleRspElementEnd(out);
       _appendMessageElementEnd(out);
  
             case XmlEntry::COMMENT:      appendMethodResponseHeader(tmp, out.size());
             {      tmp << out;
  
                 _indent(os, stack.size(), indentChars);      return tmp;
                 os << "<!--";  
                 AppendSpecial(os, entry.text);  
                 os << "-->";  
                 break;  
             }             }
  
             case XmlEntry::CONTENT:  //******************************************************************************
             {  //
                 _indent(os, stack.size(), indentChars);  // Export Messages (used for indications)
                 AppendSpecial(os, entry.text);  //
                 break;  //******************************************************************************
             }  
  
             case XmlEntry::CDATA:  //------------------------------------------------------------------------------
             {  //
                 _indent(os, stack.size(), indentChars);  // appendEMethodRequestHeader()
                 os << "<![CDATA[...]]>";  //
                 break;  //     Build HTTP request header for export operation.
             }  //
   //------------------------------------------------------------------------------
  
             case XmlEntry::DOCTYPE:  void XmlWriter::appendEMethodRequestHeader(
       Array<Sint8>& out,
       const char* host,
       const char* cimMethod,
       const String& authenticationHeader,
       Uint32 contentLength)
             {             {
                 _indent(os, stack.size(), indentChars);      char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
                 os << "<!DOCTYPE...>";  
                 break;  
             }  
         }  
  
         os << PEGASUS_STD(endl);      out << "M-POST /cimom HTTP/1.1\r\n";
       out << "HOST: " << host << "\r\n";
       out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";
       out << "Content-Length: " << contentLength << "\r\n";
       out << "Man: http://www.hp.com; ns=";
       out << nn <<"\r\n";
       out << nn << "-CIMExport: MethodRequest\r\n";
       out << nn << "-CIMExportMethod: " << cimMethod << "\r\n";
       if (authenticationHeader.size())
       {
           out << authenticationHeader << "\r\n";
     }     }
       out << "\r\n";
     delete [] tmp;  
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // XmlWriter::getNextMessageId()  // appendEMethodResponseHeader()
   //
   //     Build HTTP response header for export operation.
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 String XmlWriter::getNextMessageId()  void XmlWriter::appendEMethodResponseHeader(
       Array<Sint8>& out,
       Uint32 contentLength)
 { {
     // ATTN: make thread-safe:      char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
     static Uint32 messageId = 1000;  
   
     messageId++;  
   
     if (messageId < 1000)  
         messageId = 1001;  
  
     char buffer[16];      out << "HTTP/1.1 200 OK\r\n";
     sprintf(buffer, "%d", messageId);      out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";
     return buffer;      out << "Content-Length: " << contentLength << "\r\n";
       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 << "-CIMExport: MethodResponse\r\n\r\n";
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // XmlWriter::formatSimpleIMethodReqMessage()  // _appendSimpleExportReqElementBegin()
   // _appendSimpleExportReqElementEnd()
   //
   //     <!ELEMENT SIMPLEEXPREQ (EXPMETHODCALL)>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleIMethodReqMessage(  void XmlWriter::_appendSimpleExportReqElementBegin(
     const char* host,      Array<Sint8>& out)
     const String& nameSpace,  
     const char* iMethodName,  
     const String& messageId,  
     const Array<Sint8>& body)  
 { {
     return XmlWriter::formatMPostHeader(      out << "<SIMPLEEXPREQ>\n";
         host,  
         "MethodCall",  
         iMethodName,  
         nameSpace,  
         XmlWriter::formatMessageElement(  
             messageId,  
             XmlWriter::formatSimpleReqElement(  
                 XmlWriter::formatIMethodCallElement(  
                     iMethodName,  
                     nameSpace,  
                     body))));  
 } }
  
 Array<Sint8> XmlWriter::formatSimpleRspMessage(  void XmlWriter::_appendSimpleExportReqElementEnd(
     const char* iMethodName,      Array<Sint8>& out)
     const String& messageId,  
     const Array<Sint8>& body)  
 { {
     return XmlWriter::formatMethodResponseHeader(      out << "</SIMPLEEXPREQ>\n";
         XmlWriter::formatMessageElement(  
             messageId,  
             XmlWriter::formatSimpleRspElement(  
                 XmlWriter::formatIMethodResponseElement(  
                     iMethodName,  
                     XmlWriter::formatIReturnValueElement(body)))));  
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, const char* x)  //------------------------------------------------------------------------------
 {  //
     XmlWriter::append(out, x);  // _appendEMethodCallElementBegin()
     return out;  // _appendEMethodCallElementEnd()
 }  //
   //     <!ELEMENT EXPMETHODCALL (IPARAMVALUE*)>
   //     <!ATTLIST EXPMETHODCALL %CIMName;>
   //
   //------------------------------------------------------------------------------
  
 Array<Sint8>& operator<<(Array<Sint8>& out, char x)  void XmlWriter::_appendEMethodCallElementBegin(
       Array<Sint8>& out,
       const char* name)
 { {
     XmlWriter::append(out, x);      out << "<EXPMETHODCALL NAME=\"" << name << "\">\n";
     return out;  
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, Char16 x)  void XmlWriter::_appendEMethodCallElementEnd(
       Array<Sint8>& out)
 { {
     XmlWriter::append(out, x);      out << "</EXPMETHODCALL>\n";
     return out;  
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, const String& x)  //------------------------------------------------------------------------------
 {  //
     XmlWriter::append(out, x);  // _appendSimpleExportRspElementBegin()
     return out;  // _appendSimpleExportRspElementEnd()
 }  //
   //     <!ELEMENT SIMPLEEXPRSP (EXPMETHODRESPONSE)>
   //
   //------------------------------------------------------------------------------
  
 Array<Sint8>& operator<<(Array<Sint8>& out, const Indentor& x)  void XmlWriter::_appendSimpleExportRspElementBegin(
       Array<Sint8>& out)
 { {
     XmlWriter::append(out, x);      out << "<SIMPLEEXPRSP>\n";
     return out;  
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, const Array<Sint8>& x)  void XmlWriter::_appendSimpleExportRspElementEnd(
       Array<Sint8>& out)
 { {
     out.appendArray(x);      out << "</SIMPLEEXPRSP>\n";
     return out;  
 } }
  
 Array<Sint8>& operator<<(Array<Sint8>& out, Uint32 x)  //------------------------------------------------------------------------------
 {  //
     XmlWriter::append(out, x);  // _appendEMethodResponseElementBegin()
     return out;  // _appendEMethodResponseElementEnd()
 }  //
   //     <!ELEMENT EXPMETHODRESPONSE (ERROR|IRETURNVALUE?)>
   //     <!ATTLIST EXPMETHODRESPONSE %CIMName;>
   //
   //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendObjectNameParameter(  void XmlWriter::_appendEMethodResponseElementBegin(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* name,      const char* name)
     const CIMReference& objectName)  
 {  
     if (objectName.isClassName())  
     {     {
         XmlWriter::appendClassNameParameter(      out << "<EXPMETHODRESPONSE NAME=\"" << name << "\">\n";
             out, name, objectName.getClassName());  
     }  
     else  
     {  
         XmlWriter::appendInstanceNameParameter(  
             out, name, objectName);  
     }  
   
     return out;  
 } }
  
 Array<Sint8> XmlWriter::formatEMethodCallElement(  void XmlWriter::_appendEMethodResponseElementEnd(
     const char* name,      Array<Sint8>& out)
     const Array<Sint8>& iParamValues)  
 { {
     Array<Sint8> out;      out << "</EXPMETHODRESPONSE>\n";
     out << "<EXPMETHODCALL NAME=\"" << name << "\">\n";  
     out << iParamValues;  
     out << "</EXPMETHODCALL>\n";  
     return out;  
 } }
  
 Array<Sint8> XmlWriter::formatSimpleIndicationReqMessage(  //------------------------------------------------------------------------------
   //
   // XmlWriter::formatSimpleEMethodReqMessage()
   //
   //------------------------------------------------------------------------------
   
   Array<Sint8> XmlWriter::formatSimpleEMethodReqMessage(
     const char* host,     const char* host,
     const char* iMethodName,      const char* eMethodName,
     const String& messageId,     const String& messageId,
       const String& authenticationHeader,
     const Array<Sint8>& body)     const Array<Sint8>& body)
 { {
     return XmlWriter::formatMPostIndicationHeader(  
         host,  
         "MethodRequest",  
         iMethodName,  
         XmlWriter::formatMessageElement(  
             messageId,  
             XmlWriter::formatSimpleExportReqElement(  
                 XmlWriter::formatEMethodCallElement(  
                     iMethodName,  
                     body))));  
 }  
   
 Array<Sint8> XmlWriter::formatMPostIndicationHeader(  
     const char* host,  
     const char* cimOperation,  
     const char* cimMethod,  
     const Array<Sint8>& content)  
 {  
     Array<Sint8> out;     Array<Sint8> out;
     out.reserve(1024);      Array<Sint8> tmp;
     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };  
  
     out << "M-POST /cimom HTTP/1.1\r\n";      _appendMessageElementBegin(out, messageId);
     out << "HOST: " << host << "\r\n";      _appendSimpleExportReqElementBegin(out);
     out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";      _appendEMethodCallElementBegin(out, eMethodName);
     out << "Content-Length: " << content.size() << "\r\n";      out << body;
     out << "Man: http://www.hp.com; ns=";      _appendEMethodCallElementEnd(out);
     out << nn <<"\r\n";      _appendSimpleExportReqElementEnd(out);
     out << nn << "-CIMExport: " << cimOperation << "\r\n";      _appendMessageElementEnd(out);
     out << nn << "-CIMExportMethod: " << cimMethod << "\r\n\r\n";  
     out << content;  
     return out;  
 }  
  
 Array<Sint8> XmlWriter::formatSimpleExportReqElement(      appendEMethodRequestHeader(
     const Array<Sint8>& body)          tmp,
 {          host,
     Array<Sint8> out;          eMethodName,
     return out << "<SIMPLEEXPREQ>\n" << body << "</SIMPLEEXPREQ>\n";          authenticationHeader,
 }          out.size());
       tmp << out;
  
 Array<Sint8> XmlWriter::formatSimpleIndicationRspMessage(      return out;
     const char* iMethodName,  
     const String& messageId,  
     const Array<Sint8>& body)  
 {  
     return XmlWriter::formatEMethodResponseHeader(  
         XmlWriter::formatMessageElement(  
             messageId,  
             XmlWriter::formatSimpleExportRspElement(  
                 XmlWriter::formatEMethodResponseElement(  
                     iMethodName,  
                     XmlWriter::formatIReturnValueElement(body)))));  
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatSimpleExportRspElement()  // XmlWriter::formatSimpleEMethodRspMessage()
 //  
 //     <!ELEMENT SIMPLEEXPRSP (METHODRESPONSE|EXPMETHODRESPONSE)>  
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleExportRspElement(  Array<Sint8> XmlWriter::formatSimpleEMethodRspMessage(
       const char* eMethodName,
       const String& messageId,
     const Array<Sint8>& body)     const Array<Sint8>& body)
 { {
     Array<Sint8> out;     Array<Sint8> out;
     return out << "<SIMPLEEXPRSP>\n" << body << "</SIMPLEEXPRSP>\n";      Array<Sint8> tmp;
   
       _appendMessageElementBegin(out, messageId);
       _appendSimpleExportRspElementBegin(out);
       _appendEMethodResponseElementBegin(out, eMethodName);
       out << body;
       _appendEMethodResponseElementEnd(out);
       _appendSimpleExportRspElementEnd(out);
       _appendMessageElementEnd(out);
   
       appendEMethodResponseHeader(tmp, out.size());
       tmp << out;
   
       return tmp;
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatIMethodResponseElement()  // XmlWriter::formatSimpleEMethodErrorRspMessage()
 //  
 //     <!ELEMENT EXPMETHODRESPONSE (ERROR|IRETURNVALUE?)>  
 //     <!ATTLIST EXPMETHODRESPONSE %CIMName;>  
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatEMethodResponseElement(  Array<Sint8> XmlWriter::formatSimpleEMethodErrorRspMessage(
     const char* name,      const String& eMethodName,
     const Array<Sint8>& body)      const String& messageId,
       CIMStatusCode code,
       const String& description)
 { {
       ArrayDestroyer<char> tmp1(eMethodName.allocateCString());
       ArrayDestroyer<char> tmp2(description.allocateCString());
     Array<Sint8> out;     Array<Sint8> out;
     out << "<EXPMETHODRESPONSE NAME=\"" << name << "\">\n";      Array<Sint8> tmp;
     out << body;  
     out << "</EXPMETHODRESPONSE>\n";      _appendMessageElementBegin(out, messageId);
     return out;      _appendSimpleExportRspElementBegin(out);
       _appendEMethodResponseElementBegin(out, tmp1.getPointer());
       _appendErrorElement(out, code, tmp2.getPointer());
       _appendEMethodResponseElementEnd(out);
       _appendSimpleExportRspElementEnd(out);
       _appendMessageElementEnd(out);
   
       appendEMethodResponseHeader(tmp, out.size());
       tmp << out;
   
       return tmp;
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatMethodResponseHeader()  // _printAttributes()
 //  
 //     Build HTTP response header.  
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatEMethodResponseHeader(  static void _printAttributes(
     const Array<Sint8>& content)      PEGASUS_STD(ostream)& os,
       const XmlAttribute* attributes,
       Uint32 attributeCount)
 { {
     Array<Sint8> out;      for (Uint32 i = 0; i < attributeCount; i++)
     out.reserve(1024);      {
     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };          os << attributes[i].name << "=";
  
     out << "HTTP/1.1 200 OK\r\n";          os << '"';
     out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";          _appendSpecial(os, attributes[i].value);
     out << "Content-Length: " << content.size() << "\r\n";          os << '"';
     out << "Ext:\r\n";  
     out << "Cache-Control: no-cache\r\n";          if (i + 1 != attributeCount)
     out << "Man:  http://www.dmtf.org/cim/mapping/http/v1.0; ns=";              os << ' ';
     out << nn <<"\r\n";      }
     out << nn << "-CIMExport: MethodResponse\r\n\r\n";  
     out << content;  
     return out;  
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // XmlWriter::formatSimpleMethodReqMessage()  // _indent()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleMethodReqMessage(  static void _indent(PEGASUS_STD(ostream)& os, Uint32 level, Uint32 indentChars)
     const char* host,  
     const String& nameSpace,  
     const char* iMethodName,  
     const String& messageId,  
     const Array<Sint8>& body)  
 { {
     return XmlWriter::formatMPostHeader(      Uint32 n = level * indentChars;
         host,  
         "MethodCall",      for (Uint32 i = 0; i < n; i++)
         iMethodName,          os << ' ';
         nameSpace,  
         XmlWriter::formatMessageElement(  
             messageId,  
             XmlWriter::formatSimpleReqElement(  
                 XmlWriter::formatMethodCallElement(  
                     iMethodName,  
                     nameSpace,  
                     body))));  
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatMethodCallElement()  // indentedPrint()
 //  
 //     <!ELEMENT METHODCALL (LOCALNAMESPACEPATH,IPARAMVALUE*)>  
 //     <!ATTLIST METHODCALL %CIMName;>  
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatMethodCallElement(  void XmlWriter::indentedPrint(
     const char* name,      PEGASUS_STD(ostream)& os,
     const String& nameSpace,      const char* text,
     const Array<Sint8>& iParamValues)      Uint32 indentChars)
 { {
     Array<Sint8> out;      char* tmp = strcpy(new char[strlen(text) + 1], text);
     out << "<METHODCALL NAME=\"" << name << "\">\n";  
     out << iParamValues;      XmlParser parser(tmp);
     out << "</METHODCALL>\n";      XmlEntry entry;
     return out;      Stack<const char*> stack;
   
       while (parser.next(entry))
       {
           switch (entry.type)
           {
               case XmlEntry::XML_DECLARATION:
               {
                   _indent(os, stack.size(), indentChars);
   
                   os << "<?" << entry.text << " ";
                   _printAttributes(os, entry.attributes, entry.attributeCount);
                   os << "?>";
                   break;
 } }
  
 Array<Sint8> XmlWriter::formatSimpleMethodRspMessage(              case XmlEntry::START_TAG:
     const char* iMethodName,  
     const String& messageId,  
     const Array<Sint8>& body)  
 { {
     /*return XmlWriter::formatMethodResponseHeader(                  _indent(os, stack.size(), indentChars);
         XmlWriter::formatMessageElement(  
             messageId,                  os << "<" << entry.text;
             XmlWriter::formatSimpleRspElement(  
                 XmlWriter::formatMethodResponseElement(                  if (entry.attributeCount)
                     iMethodName,                      os << ' ';
                     XmlWriter::formatReturnValueElement(body)))));*/  
     return XmlWriter::formatMethodResponseHeader(                  _printAttributes(os, entry.attributes, entry.attributeCount);
         XmlWriter::formatMessageElement(                  os << ">";
             messageId,                  stack.push(entry.text);
             XmlWriter::formatSimpleRspElement(                  break;
                 XmlWriter::formatMethodResponseElement(  
                     iMethodName,  
                     body))));  
 } }
  
 //------------------------------------------------------------------------------              case XmlEntry::EMPTY_TAG:
 //              {
 // formatMethodResponseElement()                  _indent(os, stack.size(), indentChars);
 //  
 //     <!ELEMENT METHODRESPONSE (ERROR|IRETURNVALUE?)>  
 //     <!ATTLIST METHODRESPONSE %CIMName;>  
 //  
 //------------------------------------------------------------------------------  
  
 Array<Sint8> XmlWriter::formatMethodResponseElement(                  os << "<" << entry.text << " ";
     const char* name,                  _printAttributes(os, entry.attributes, entry.attributeCount);
     const Array<Sint8>& body)                  os << "/>";
                   break;
               }
   
               case XmlEntry::END_TAG:
 { {
     Array<Sint8> out;                  if (!stack.isEmpty() && strcmp(stack.top(), entry.text) == 0)
     out << "<METHODRESPONSE NAME=\"" << name << "\">\n";                      stack.pop();
     out << body;  
     out << "</METHODRESPONSE>\n";                  _indent(os, stack.size(), indentChars);
     return out;  
                   os << "</" << entry.text << ">";
                   break;
 } }
  
 //------------------------------------------------------------------------------              case XmlEntry::COMMENT:
 //              {
 // appendStringParameter()  
 //  
 //------------------------------------------------------------------------------  
  
 Array<Sint8>& XmlWriter::appendStringParameter(                  _indent(os, stack.size(), indentChars);
     Array<Sint8>& out,                  os << "<!--";
     const char* name,                  _appendSpecial(os, entry.text);
     const String& str)                  os << "-->";
                   break;
               }
   
               case XmlEntry::CONTENT:
 { {
     Array<Sint8> tmp;                  _indent(os, stack.size(), indentChars);
     tmp << "<VALUE>";                  _appendSpecial(os, entry.text);
     appendSpecial(tmp, str);                  break;
     tmp << "</VALUE>\n";  
     return formatParamValueElement(out, name, tmp);  
 } }
  
 //------------------------------------------------------------------------------              case XmlEntry::CDATA:
 //              {
 // formatParamValueElement()                  _indent(os, stack.size(), indentChars);
 //                  os << "<![CDATA[...]]>";
 //     <!ELEMENT PARAMVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE                  break;
 //         |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION              }
 //         |CLASS|INSTANCE|VALUE.NAMEDINSTANCE)?>  
 //     <!ATTLIST PARAMVALUE %CIMName;>  
 //  
 //------------------------------------------------------------------------------  
  
 Array<Sint8>& XmlWriter::formatParamValueElement(              case XmlEntry::DOCTYPE:
     Array<Sint8>& out,  
     const char* name,  
     const Array<Sint8>& body)  
 { {
     out << "<PARAMVALUE NAME=\"" << name << "\">\n";                  _indent(os, stack.size(), indentChars);
     out << body;                  os << "<!DOCTYPE...>";
     out << "</PARAMVALUE>\n";                  break;
     return out;              }
           }
   
           os << PEGASUS_STD(endl);
       }
   
       delete [] tmp;
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatReturnValueElement()  // XmlWriter::getNextMessageId()
 //  
 //      <!ELEMENT RETURNVALUE (CLASSNAME*|INSTANCENAME*|VALUE*|  
 //          VALUE.OBJECTWITHPATH*|VALUE.OBJECTWITHLOCALPATH*|VALUE.OBJECT*|  
 //          OBJECTPATH*|QUALIFIER.DECLARATION*|VALUE.ARRAY?|VALUE.REFERENCE?|  
 //          CLASS*|INSTANCE*|VALUE.NAMEDINSTANCE*)>  
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatReturnValueElement(  String XmlWriter::getNextMessageId()
     const Array<Sint8>& body)  
 { {
     Array<Sint8> out;      // ATTN: make thread-safe:
     return out << "<RETURNVALUE>\n" << body << "</RETURNVALUE>\n";      static Uint32 messageId = 1000;
   
       messageId++;
   
       if (messageId < 1000)
           messageId = 1001;
   
       char buffer[16];
       sprintf(buffer, "%d", messageId);
       return buffer;
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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