(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.7 and 1.67

version 1.7, 2001/02/20 07:25:57 version 1.67, 2002/07/30 16:14:53
Line 1 
Line 1 
 //BEGIN_LICENSE  //%/////////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000 The Open Group, BMC Software, Tivoli Systems, IBM  // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,
   // The Open Group, Tivoli Systems
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a  // Permission is hereby granted, free of charge, to any person obtaining a copy
 // copy of this software and associated documentation files (the "Software"),  // of this software and associated documentation files (the "Software"), to
 // to deal in the Software without restriction, including without limitation  // deal in the Software without restriction, including without limitation the
 // the rights to use, copy, modify, merge, publish, distribute, sublicense,  // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 // and/or sell copies of the Software, and to permit persons to whom the  // sell copies of the Software, and to permit persons to whom the Software is
 // Software is furnished to do so, subject to the following conditions:  // furnished to do so, subject to the following conditions:
   //
   // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
   // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
   // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
   // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
   // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
   // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
   // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
   // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
   //
   //==============================================================================
   //
   // Author: Mike Brasher (mbrasher@bmc.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)
   //              Carol Ann Krug Graves, Hewlett-Packard Company
   //                  (carolann_graves@hp.com)
 // //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR  //%/////////////////////////////////////////////////////////////////////////////
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,  
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL  
 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER  
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING  
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER  
 // DEALINGS IN THE SOFTWARE.  
 //  
 //END_LICENSE  
 //BEGIN_HISTORY  
 //  
 // Author:  
 //  
 // $Log$  
 // Revision 1.7  2001/02/20 07:25:57  mike  
 // Added basic create-instance in repository and in client.  
 //  
 // Revision 1.6  2001/02/19 01:47:17  mike  
 // Renamed names of the form CIMConst to ConstCIM.  
 //  
 // Revision 1.5  2001/02/18 03:56:01  mike  
 // Changed more class names (e.g., ConstClassDecl -> ConstCIMClass)  
 //  
 // Revision 1.4  2001/02/16 02:06:07  mike  
 // Renamed many classes and headers.  
 //  
 // Revision 1.3  2001/01/31 08:20:51  mike  
 // Added dispatcher framework.  
 // Added enumerateInstanceNames.  
 //  
 // Revision 1.2  2001/01/29 02:23:44  mike  
 // Added support for GetInstance operation  
 //  
 // Revision 1.1.1.1  2001/01/14 19:53:36  mike  
 // Pegasus import  
 //  
 //  
 //END_HISTORY  
  
   #include <Pegasus/Common/Config.h>
 #include <cstdlib> #include <cstdlib>
 #include <cstdio> #include <cstdio>
   #include "Constants.h"
   #include "Destroyer.h"
 #include "CIMClass.h" #include "CIMClass.h"
   #include "CIMClassRep.h"
 #include "CIMInstance.h" #include "CIMInstance.h"
   #include "CIMInstanceRep.h"
   #include "CIMProperty.h"
   #include "CIMPropertyRep.h"
   #include "CIMMethod.h"
   #include "CIMMethodRep.h"
   #include "CIMParameter.h"
   #include "CIMParameterRep.h"
   #include "CIMParamValue.h"
   #include "CIMParamValueRep.h"
   #include "CIMQualifier.h"
   #include "CIMQualifierRep.h"
 #include "CIMQualifierDecl.h" #include "CIMQualifierDecl.h"
   #include "CIMQualifierDeclRep.h"
   #include "CIMValue.h"
 #include "XmlWriter.h" #include "XmlWriter.h"
 #include "XmlParser.h" #include "XmlParser.h"
   #include "Tracer.h"
   #include <Pegasus/Common/StatisticalData.h>
  
 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 94 
Line 138 
     }     }
 } }
  
   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, Boolean x)
   {
       append(out, (x ? "TRUE" : "FALSE"));
 } }
  
 void XmlWriter::append(Array<Sint8>& out, Uint32 x) void XmlWriter::append(Array<Sint8>& out, Uint32 x)
 { {
     char buffer[32];     char buffer[32];
     sprintf(buffer, "%d", x);      sprintf(buffer, "%u", x);
     append(out, buffer);     append(out, buffer);
 } }
  
 void XmlWriter::append(Array<Sint8>& out, const char* str)  void XmlWriter::append(Array<Sint8>& out, Sint32 x)
 { {
     while (*str)      char buffer[32];
         AppendChar(out, *str++);      sprintf(buffer, "%d", x);
       append(out, buffer);
 } }
  
 void XmlWriter::appendSpecial(Array<Sint8>& out, Char16 x)  void XmlWriter::append(Array<Sint8>& out, Uint64 x)
 { {
     AppendSpecialChar(out, x);      char buffer[32];  // Should need 21 chars max
       // I know I shouldn't put platform flags here, but the other way is too hard
   #if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)
       sprintf(buffer, "%I64u", x);
   #else
       sprintf(buffer, "%llu", x);
   #endif
       append(out, buffer);
 } }
  
 void XmlWriter::appendSpecial(Array<Sint8>& out, char x)  void XmlWriter::append(Array<Sint8>& out, Sint64 x)
 { {
     AppendSpecialChar(out, Char16(x));      char buffer[32];  // Should need 21 chars max
       // I know I shouldn't put platform flags here, but the other way is too hard
   #if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)
       sprintf(buffer, "%I64d", x);
   #else
       sprintf(buffer, "%lld", x);
   #endif
       append(out, buffer);
 } }
  
 void XmlWriter::appendSpecial(Array<Sint8>& out, const char* str)  void XmlWriter::append(Array<Sint8>& out, Real64 x)
 { {
     while (*str)      char buffer[128];
         AppendSpecialChar(out, *str++);      // %e gives '[-]m.dddddde+/-xx', which seems compatible with CIM/XML spec
       sprintf(buffer, "%e", x);
       append(out, buffer);
 } }
  
 void XmlWriter::appendSpecial(Array<Sint8>& out, const String& str)  void XmlWriter::append(Array<Sint8>& out, const char* str)
 { {
     const Char16* tmp = str.getData();      while (*str)
           _appendChar(out, *str++);
     while (*tmp)  
         AppendSpecialChar(out, *tmp++);  
 } }
  
 void XmlWriter::append(Array<Sint8>& out, const String& str) void XmlWriter::append(Array<Sint8>& out, const String& str)
 { {
     const Char16* tmp = str.getData();      for (Uint32 i = 0; i < str.size(); i++)
       {
     while (*tmp)          _appendChar(out, str[i]);
         AppendChar(out, *tmp++);      }
 } }
  
 void XmlWriter::append(Array<Sint8>& out, const Indentor& x) void XmlWriter::append(Array<Sint8>& out, const Indentor& x)
Line 150 
Line 249 
         out.append(' ');         out.append(' ');
 } }
  
 void XmlWriter::appendLocalNameSpaceElement(  void XmlWriter::appendSpecial(Array<Sint8>& out, Char16 x)
   {
       _appendSpecialChar(out, x);
   }
   
   void XmlWriter::appendSpecial(Array<Sint8>& out, char x)
   {
       _appendSpecialChar(out, Char16(x));
   }
   
   void XmlWriter::appendSpecial(Array<Sint8>& out, const char* str)
   {
       while (*str)
           _appendSpecialChar(out, *str++);
   }
   
   void XmlWriter::appendSpecial(Array<Sint8>& out, const String& str)
   {
       for (Uint32 i = 0; i < str.size(); i++)
       {
           _appendSpecialChar(out, str[i]);
       }
   }
   
   //------------------------------------------------------------------------------
   //
   // appendLocalNameSpacePathElement()
   //
   //     <!ELEMENT LOCALNAMESPACEPATH (NAMESPACE+)>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendLocalNameSpacePathElement(
     Array<Sint8>& out,     Array<Sint8>& out,
     const String& nameSpace)     const String& nameSpace)
 { {
Line 163 
Line 294 
         out << "<NAMESPACE NAME=\"" << p << "\"/>\n";         out << "<NAMESPACE NAME=\"" << p << "\"/>\n";
     }     }
  
       delete [] tmp;
   
     out << "</LOCALNAMESPACEPATH>\n";     out << "</LOCALNAMESPACEPATH>\n";
 } }
  
 static inline void AppendSpecialChar(std::ostream& os, char c)  //------------------------------------------------------------------------------
   //
   // appendNameSpacePathElement()
   //
   //     <!ELEMENT NAMESPACEPATH (HOST,LOCALNAMESPACEPATH)>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendNameSpacePathElement(
       Array<Sint8>& out,
       const String& host,
       const String& nameSpace)
   {
       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)
 { {
     switch (c)      out << "<CLASSNAME NAME=\"" << className << "\"/>\n";
   }
   
   //------------------------------------------------------------------------------
   //
   // appendInstanceNameElement()
   //
   //    <!ELEMENT INSTANCENAME (KEYBINDING*|KEYVALUE?|VALUE.REFERENCE?)>
   //    <!ATTLIST INSTANCENAME
   //              %ClassName;>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendInstanceNameElement(
       Array<Sint8>& out,
       const CIMObjectPath& instanceName)
     {     {
         case '&':      out << "<INSTANCENAME CLASSNAME=\"" << instanceName.getClassName() << "\">\n";
             os << "&amp;";  
             break;  
  
         case '<':      Array<KeyBinding> keyBindings = instanceName.getKeyBindings();
             os << "&lt;";      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 << "&gt;";          {
             break;              CIMObjectPath ref = keyBindings[i].getValue();
               appendValueReferenceElement(out, ref, true);
           }
           else {
               out << "<KEYVALUE VALUETYPE=\"";
               out << KeyBinding::typeToString(keyBindings[i].getType());
               out << "\">";
  
         case '"':              // fixed the special character problem - Markus
             os << "&quot;";  
             break;  
  
         case '\'':              appendSpecial(out, keyBindings[i].getValue());
             os << "&apos;";              out << "</KEYVALUE>\n";
             break;          }
           out << "</KEYBINDING>\n";
       }
       out << "</INSTANCENAME>\n";
   }
  
         default:  //------------------------------------------------------------------------------
             os << c;  //
   // appendClassPathElement()
   //
   //     <!ELEMENT CLASSPATH (NAMESPACEPATH,CLASSNAME)>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendClassPathElement(
       Array<Sint8>& out,
       const CIMObjectPath& 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 CIMObjectPath& instancePath)
   {
       out << "<INSTANCEPATH>\n";
       appendNameSpacePathElement(out,
                                  instancePath.getHost(),
                                  instancePath.getNameSpace());
       appendInstanceNameElement(out, instancePath);
       out << "</INSTANCEPATH>\n";
   }
   
   //------------------------------------------------------------------------------
   //
   // appendLocalClassPathElement()
   //
   //     <!ELEMENT LOCALCLASSPATH (LOCALNAMESPACEPATH, CLASSNAME)>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendLocalClassPathElement(
       Array<Sint8>& out,
       const CIMObjectPath& classPath)
   {
       out << "<LOCALCLASSPATH>\n";
       appendLocalNameSpacePathElement(out, classPath.getNameSpace());
       appendClassNameElement(out, classPath.getClassName());
       out << "</LOCALCLASSPATH>\n";
   }
   
   //------------------------------------------------------------------------------
   //
   // appendLocalInstancePathElement()
   //
   //     <!ELEMENT LOCALINSTANCEPATH (LOCALNAMESPACEPATH, INSTANCENAME)>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendLocalInstancePathElement(
       Array<Sint8>& out,
       const CIMObjectPath& instancePath)
   {
       out << "<LOCALINSTANCEPATH>\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 CIMObjectPath& objectPath)
   {
       if (objectPath.isInstanceName())
       {
           appendLocalInstancePathElement(out, objectPath);
     }     }
       else
       {
           appendLocalClassPathElement(out, objectPath);
       }
   }
   
   //------------------------------------------------------------------------------
   //
   // Helper functions for appendValueElement()
   //
   //------------------------------------------------------------------------------
   
   inline void _appendValue(Array<Sint8>& out, Boolean x)
   {
       XmlWriter::append(out, x);
   }
   
   inline void _appendValue(Array<Sint8>& out, Uint8 x)
   {
       XmlWriter::append(out, Uint32(x));
   }
   
   inline void _appendValue(Array<Sint8>& out, Sint8 x)
   {
       XmlWriter::append(out, Sint32(x));
 } }
  
 static inline void AppendSpecial(std::ostream& os, const char* str)  inline void _appendValue(Array<Sint8>& out, Uint16 x)
   {
       XmlWriter::append(out, Uint32(x));
   }
   
   inline void _appendValue(Array<Sint8>& out, Sint16 x)
   {
       XmlWriter::append(out, Sint32(x));
   }
   
   inline void _appendValue(Array<Sint8>& out, Uint32 x)
   {
       XmlWriter::append(out, x);
   }
   
   inline void _appendValue(Array<Sint8>& out, Sint32 x)
   {
       XmlWriter::append(out, x);
   }
   
   inline void _appendValue(Array<Sint8>& out, Uint64 x)
   {
       XmlWriter::append(out, x);
   }
   
   inline void _appendValue(Array<Sint8>& out, Sint64 x)
   {
       XmlWriter::append(out, x);
   }
   
   inline void _appendValue(Array<Sint8>& out, Real32 x)
   {
       XmlWriter::append(out, Real64(x));
   }
   
   inline void _appendValue(Array<Sint8>& out, Real64 x)
   {
       XmlWriter::append(out, x);
   }
   
   inline void _appendValue(Array<Sint8>& out, Char16 x)
   {
       XmlWriter::appendSpecial(out, x);
   }
   
   inline void _appendValue(Array<Sint8>& out, const String& x)
   {
       XmlWriter::appendSpecial(out, x);
   }
   
   inline void _appendValue(Array<Sint8>& out, const CIMDateTime& x)
   {
       out << x.getString();  //ATTN: append() method?
   }
   
   inline void _appendValue(Array<Sint8>& out, const CIMObjectPath& x)
   {
       XmlWriter::appendValueReferenceElement(out, x, true);
   }
   
   void _appendValueArray(Array<Sint8>& out, const CIMObjectPath* p, Uint32 size)
   {
       out << "<VALUE.REFARRAY>\n";
       while (size--)
       {
           _appendValue(out, *p++);
       }
       out << "</VALUE.REFARRAY>\n";
   }
   
   template<class T>
   void _appendValueArray(Array<Sint8>& out, const T* p, Uint32 size)
   {
       out << "<VALUE.ARRAY>\n";
   
       while (size--)
       {
           out << "<VALUE>";
           _appendValue(out, *p++);
           out << "</VALUE>\n";
       }
   
       out << "</VALUE.ARRAY>\n";
   }
   
   //------------------------------------------------------------------------------
   //
   // appendValueElement()
   //
   //    <!ELEMENT VALUE (#PCDATA)>
   //    <!ELEMENT VALUE.ARRAY (VALUE*)>
   //    <!ELEMENT VALUE.REFERENCE
   //        (CLASSPATH|LOCALCLASSPATH|CLASSNAME|INSTANCEPATH|LOCALINSTANCEPATH|
   //         INSTANCENAME)>
   //    <!ELEMENT VALUE.REFARRAY (VALUE.REFERENCE*)>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendValueElement(
       Array<Sint8>& out,
       const CIMValue& value)
   {
       if (value.isNull())
       {
           return;
       }
       if (value.isArray())
       {
           switch (value.getType())
           {
               case CIMTYPE_BOOLEAN:
               {
                   Array<Boolean> a;
                   value.get(a);
                   _appendValueArray(out, a.getData(), a.size());
                   break;
               }
   
               case CIMTYPE_UINT8:
               {
                   Array<Uint8> a;
                   value.get(a);
                   _appendValueArray(out, a.getData(), a.size());
                   break;
               }
   
               case CIMTYPE_SINT8:
               {
                   Array<Sint8> a;
                   value.get(a);
                   _appendValueArray(out, a.getData(), a.size());
                   break;
               }
   
               case CIMTYPE_UINT16:
               {
                   Array<Uint16> a;
                   value.get(a);
                   _appendValueArray(out, a.getData(), a.size());
                   break;
               }
   
               case CIMTYPE_SINT16:
               {
                   Array<Sint16> a;
                   value.get(a);
                   _appendValueArray(out, a.getData(), a.size());
                   break;
               }
   
               case CIMTYPE_UINT32:
               {
                   Array<Uint32> a;
                   value.get(a);
                   _appendValueArray(out, a.getData(), a.size());
                   break;
               }
   
               case CIMTYPE_SINT32:
               {
                   Array<Sint32> a;
                   value.get(a);
                   _appendValueArray(out, a.getData(), a.size());
                   break;
               }
   
               case CIMTYPE_UINT64:
               {
                   Array<Uint64> a;
                   value.get(a);
                   _appendValueArray(out, a.getData(), a.size());
                   break;
               }
   
               case CIMTYPE_SINT64:
               {
                   Array<Sint64> a;
                   value.get(a);
                   _appendValueArray(out, a.getData(), a.size());
                   break;
               }
   
               case CIMTYPE_REAL32:
               {
                   Array<Real32> a;
                   value.get(a);
                   _appendValueArray(out, a.getData(), a.size());
                   break;
               }
   
               case CIMTYPE_REAL64:
               {
                   Array<Real64> a;
                   value.get(a);
                   _appendValueArray(out, a.getData(), a.size());
                   break;
               }
   
               case CIMTYPE_CHAR16:
               {
                   Array<Char16> a;
                   value.get(a);
                   _appendValueArray(out, a.getData(), a.size());
                   break;
               }
   
               case CIMTYPE_STRING:
               {
                   Array<String> a;
                   value.get(a);
                   _appendValueArray(out, a.getData(), a.size());
                   break;
               }
   
               case CIMTYPE_DATETIME:
               {
                   Array<CIMDateTime> a;
                   value.get(a);
                   _appendValueArray(out, a.getData(), a.size());
                   break;
               }
   
               case CIMTYPE_REFERENCE:
               {
                   Array<CIMObjectPath> a;
                   value.get(a);
                   _appendValueArray(out, a.getData(), a.size());
                   break;
               }
   
               default:
                   throw CIMValueInvalidType();
           }
       }
       else if (value.getType() == CIMTYPE_REFERENCE)
       {
           // Has to be separate because it uses VALUE.REFERENCE tag
           CIMObjectPath v;
           value.get(v);
           _appendValue(out, v);
       }
       else
       {
           out << "<VALUE>";
   
           switch (value.getType())
           {
               case CIMTYPE_BOOLEAN:
               {
                   Boolean v;
                   value.get(v);
                   _appendValue(out, v);
                   break;
               }
   
               case CIMTYPE_UINT8:
               {
                   Uint8 v;
                   value.get(v);
                   _appendValue(out, v);
                   break;
               }
   
               case CIMTYPE_SINT8:
               {
                   Sint8 v;
                   value.get(v);
                   _appendValue(out, v);
                   break;
               }
   
               case CIMTYPE_UINT16:
               {
                   Uint16 v;
                   value.get(v);
                   _appendValue(out, v);
                   break;
               }
   
               case CIMTYPE_SINT16:
               {
                   Sint16 v;
                   value.get(v);
                   _appendValue(out, v);
                   break;
               }
   
               case CIMTYPE_UINT32:
               {
                   Uint32 v;
                   value.get(v);
                   _appendValue(out, v);
                   break;
               }
   
               case CIMTYPE_SINT32:
               {
                   Sint32 v;
                   value.get(v);
                   _appendValue(out, v);
                   break;
               }
   
               case CIMTYPE_UINT64:
               {
                   Uint64 v;
                   value.get(v);
                   _appendValue(out, v);
                   break;
               }
   
               case CIMTYPE_SINT64:
               {
                   Sint64 v;
                   value.get(v);
                   _appendValue(out, v);
                   break;
               }
   
               case CIMTYPE_REAL32:
               {
                   Real32 v;
                   value.get(v);
                   _appendValue(out, v);
                   break;
               }
   
               case CIMTYPE_REAL64:
               {
                   Real64 v;
                   value.get(v);
                   _appendValue(out, v);
                   break;
               }
   
               case CIMTYPE_CHAR16:
               {
                   Char16 v;
                   value.get(v);
                   _appendValue(out, v);
                   break;
               }
   
               case CIMTYPE_STRING:
               {
                   String v;
                   value.get(v);
                   _appendValue(out, v);
                   break;
               }
   
               case CIMTYPE_DATETIME:
               {
                   CIMDateTime v;
                   value.get(v);
                   _appendValue(out, v);
                   break;
               }
   
               default:
                   throw CIMValueInvalidType();
           }
   
           out << "</VALUE>\n";
       }
   }
   
   void XmlWriter::printValueElement(
       const CIMValue& value,
       PEGASUS_STD(ostream)& os)
   {
       Array<Sint8> tmp;
       appendValueElement(tmp, value);
       tmp.append('\0');
       os << tmp.getData() << PEGASUS_STD(endl);
   }
   
   //------------------------------------------------------------------------------
   //
   // appendValueObjectWithPathElement()
   //
   //     <!ELEMENT VALUE.OBJECTWITHPATH
   //         ((CLASSPATH,CLASS)|(INSTANCEPATH,INSTANCE))>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendValueObjectWithPathElement(
       Array<Sint8>& out,
       const CIMObject& objectWithPath)
   {
       out << "<VALUE.OBJECTWITHPATH>\n";
   
       appendValueReferenceElement(out, objectWithPath.getPath (), false);
       appendObjectElement(out, objectWithPath);
   
       out << "</VALUE.OBJECTWITHPATH>\n";
   }
   
   //------------------------------------------------------------------------------
   //
   // appendValueReferenceElement()
   //
   //    <!ELEMENT VALUE.REFERENCE
   //        (CLASSPATH|LOCALCLASSPATH|CLASSNAME|INSTANCEPATH|LOCALINSTANCEPATH|
   //         INSTANCENAME)>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendValueReferenceElement(
       Array<Sint8>& out,
       const CIMObjectPath& reference,
       Boolean putValueWrapper)
   {
       if (putValueWrapper)
           out << "<VALUE.REFERENCE>\n";
   
       // See if it is a class or instance reference (instance references have
       // key-bindings; class references do not).
   
       //KeyBindingArray kbs = reference.getKeyBindingArray();
       KeyBindingArray kbs = reference.getKeyBindings();
   
       if (kbs.size())
       {
           if (reference.getHost().size())
           {
               appendInstancePathElement(out, reference);
           }
           else if (!reference.getNameSpace().isNull())
           {
               appendLocalInstancePathElement(out, reference);
           }
           else
           {
               appendInstanceNameElement(out, reference);
           }
       }
       else
       {
           if (reference.getHost().size())
           {
               appendClassPathElement(out, reference);
           }
           else if (!reference.getNameSpace().isNull())
           {
               appendLocalClassPathElement(out, reference);
           }
           else
           {
               appendClassNameElement(out, reference.getClassName());
           }
       }
   
       if (putValueWrapper)
           out << "</VALUE.REFERENCE>\n";
   }
   
   void XmlWriter::printValueReferenceElement(
       const CIMObjectPath& reference,
       PEGASUS_STD(ostream)& os)
   {
       Array<Sint8> tmp;
       appendValueReferenceElement(tmp, reference, true);
       tmp.append('\0');
       indentedPrint(os, tmp.getData());
   }
   
   //------------------------------------------------------------------------------
   //
   // appendValueNamedInstanceElement()
   //
   //     <!ELEMENT VALUE.NAMEDINSTANCE (INSTANCENAME,INSTANCE)>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendValueNamedInstanceElement(
       Array<Sint8>& out,
       const CIMInstance& namedInstance)
   {
       out << "<VALUE.NAMEDINSTANCE>\n";
   
       appendInstanceNameElement(out, namedInstance.getPath ());
       appendInstanceElement(out, namedInstance);
   
       out << "</VALUE.NAMEDINSTANCE>\n";
   }
   
   //------------------------------------------------------------------------------
   //
   // appendClassElement()
   //
   //     <!ELEMENT CLASS
   //         (QUALIFIER*,(PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*,METHOD*)>
   //     <!ATTLIST CLASS
   //         %CIMName;
   //         %SuperClass;>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendClassElement(
       Array<Sint8>& out,
       const CIMConstClass& cimclass)
   {
       cimclass._checkRep();
       cimclass._rep->toXml(out);
   }
   
   void XmlWriter::printClassElement(
       const CIMConstClass& cimclass,
       PEGASUS_STD(ostream)& os)
   {
       Array<Sint8> tmp;
       appendClassElement(tmp, cimclass);
       tmp.append('\0');
       indentedPrint(os, tmp.getData(), 4);
   }
   
   //------------------------------------------------------------------------------
   //
   // appendInstanceElement()
   //
   //     <!ELEMENT INSTANCE
   //         (QUALIFIER*,(PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*)>
   //     <!ATTLIST INSTANCE
   //         %ClassName;>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendInstanceElement(
       Array<Sint8>& out,
       const CIMConstInstance& instance)
   {
       instance._checkRep();
       instance._rep->toXml(out);
   }
   
   void XmlWriter::printInstanceElement(
       const CIMConstInstance& instance,
       PEGASUS_STD(ostream)& os)
   {
       Array<Sint8> tmp;
       appendInstanceElement(tmp, instance);
       tmp.append('\0');
       os << tmp.getData() << PEGASUS_STD(endl);
   }
   
   //------------------------------------------------------------------------------
   //
   // appendObjectElement()
   //
   // May refer to a CLASS or an INSTANCE
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendObjectElement(
       Array<Sint8>& out,
       const CIMConstObject& object)
   {
       // ATTN-RK-P3-20020515: This could use some work
       try
       {
           CIMConstClass c(object);
           appendClassElement(out, c);
       }
       catch (DynamicCastFailed)
       {
           try
           {
               CIMConstInstance i(object);
               appendInstanceElement(out, i);
           }
           catch (DynamicCastFailed)
           {
               PEGASUS_ASSERT(0);
           }
       }
   }
   
   //------------------------------------------------------------------------------
   //
   // appendPropertyElement()
   //
   //     <!ELEMENT PROPERTY (QUALIFIER*,VALUE?)>
   //     <!ATTLIST PROPERTY
   //              %CIMName;
   //              %CIMType;           #REQUIRED
   //              %ClassOrigin;
   //              %Propagated;>
   //
   //     <!ELEMENT PROPERTY.ARRAY (QUALIFIER*,VALUE.ARRAY?)>
   //     <!ATTLIST PROPERTY.ARRAY
   //              %CIMName;
   //              %CIMType;           #REQUIRED
   //              %ArraySize;
   //              %ClassOrigin;
   //              %Propagated;>
   //
   //     <!ELEMENT PROPERTY.REFERENCE (QUALIFIER*,VALUE.REFERENCE?)>
   //     <!ATTLIST PROPERTY.REFERENCE
   //              %CIMName;
   //              %ReferenceClass;
   //              %ClassOrigin;
   //              %Propagated;>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendPropertyElement(
       Array<Sint8>& out,
       const CIMConstProperty& property)
   {
       property._checkRep();
       property._rep->toXml(out);
   }
   
   void XmlWriter::printPropertyElement(
       const CIMConstProperty& property,
       PEGASUS_STD(ostream)& os)
   {
       Array<Sint8> tmp;
       appendPropertyElement(tmp, property);
       tmp.append('\0');
       os << tmp.getData() << PEGASUS_STD(endl);
   }
   
   //------------------------------------------------------------------------------
   //
   // appendMethodElement()
   //
   //     <!ELEMENT METHOD (QUALIFIER*,
   //         (PARAMETER|PARAMETER.REFERENCE|PARAMETER.ARRAY|PARAMETER.REFARRAY)*)>
   //     <!ATTLIST METHOD
   //              %CIMName;
   //              %CIMType;          #IMPLIED
   //              %ClassOrigin;
   //              %Propagated;>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendMethodElement(
       Array<Sint8>& out,
       const CIMConstMethod& method)
   {
       method._checkRep();
       method._rep->toXml(out);
   }
   
   void XmlWriter::printMethodElement(
       const CIMConstMethod& method,
       PEGASUS_STD(ostream)& os)
   {
       Array<Sint8> tmp;
       appendMethodElement(tmp, method);
       tmp.append('\0');
       os << tmp.getData() << PEGASUS_STD(endl);
   }
   
   //------------------------------------------------------------------------------
   //
   // appendParameterElement()
   //
   //     <!ELEMENT PARAMETER (QUALIFIER*)>
   //     <!ATTLIST PARAMETER
   //              %CIMName;
   //              %CIMType;      #REQUIRED>
   //
   //     <!ELEMENT PARAMETER.REFERENCE (QUALIFIER*)>
   //     <!ATTLIST PARAMETER.REFERENCE
   //              %CIMName;
   //              %ReferenceClass;>
   //
   //     <!ELEMENT PARAMETER.ARRAY (QUALIFIER*)>
   //     <!ATTLIST PARAMETER.ARRAY
   //              %CIMName;
   //              %CIMType;           #REQUIRED
   //              %ArraySize;>
   //
   //     <!ELEMENT PARAMETER.REFARRAY (QUALIFIER*)>
   //     <!ATTLIST PARAMETER.REFARRAY
   //              %CIMName;
   //              %ReferenceClass;
   //              %ArraySize;>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendParameterElement(
       Array<Sint8>& out,
       const CIMConstParameter& parameter)
   {
       parameter._checkRep();
       parameter._rep->toXml(out);
   }
   
   void XmlWriter::printParameterElement(
       const CIMConstParameter& parameter,
       PEGASUS_STD(ostream)& os)
   {
       Array<Sint8> tmp;
       appendParameterElement(tmp, parameter);
       tmp.append('\0');
       os << tmp.getData() << PEGASUS_STD(endl);
   }
   
   //------------------------------------------------------------------------------
   //
   // appendParamValueElement()
   //
   //     <!ELEMENT PARAMVALUE (VALUE|VALUE.REFERENCE|VALUE.ARRAY|VALUE.REFARRAY)?>
   //     <!ATTLIST PARAMVALUE
   //              %CIMName;>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendParamValueElement(
       Array<Sint8>& out,
       const CIMParamValue& paramValue)
   {
       paramValue._checkRep();
       paramValue._rep->toXml(out);
   }
   
   void XmlWriter::printParamValueElement(
       const CIMParamValue& paramValue,
       PEGASUS_STD(ostream)& os)
   {
       Array<Sint8> tmp;
       appendParamValueElement(tmp, paramValue);
       tmp.append('\0');
       os << tmp.getData() << PEGASUS_STD(endl);
   }
   
   //------------------------------------------------------------------------------
   //
   // appendQualifierElement()
   //
   //     <!ELEMENT QUALIFIER (VALUE|VALUE.ARRAY)>
   //     <!ATTLIST QUALIFIER
   //              %CIMName;
   //              %CIMType;               #REQUIRED
   //              %Propagated;
   //              %QualifierFlavor;>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendQualifierElement(
       Array<Sint8>& out,
       const CIMConstQualifier& qualifier)
   {
       qualifier._checkRep();
       qualifier._rep->toXml(out);
   }
   
   void XmlWriter::printQualifierElement(
       const CIMConstQualifier& qualifier,
       PEGASUS_STD(ostream)& os)
   {
       Array<Sint8> tmp;
       appendQualifierElement(tmp, qualifier);
       tmp.append('\0');
       os << tmp.getData() << PEGASUS_STD(endl);
   }
   
   //------------------------------------------------------------------------------
   //
   // appendQualifierDeclElement()
   //
   //     <!ELEMENT QUALIFIER.DECLARATION (SCOPE?,(VALUE|VALUE.ARRAY)?)>
   //     <!ATTLIST QUALIFIER.DECLARATION
   //              %CIMName;
   //              %CIMType;                       #REQUIRED
   //              ISARRAY        (true|false)     #IMPLIED
   //              %ArraySize;
   //              %QualifierFlavor;>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendQualifierDeclElement(
       Array<Sint8>& out,
       const CIMConstQualifierDecl& qualifierDecl)
   {
       qualifierDecl._checkRep();
       qualifierDecl._rep->toXml(out);
   }
   
   void XmlWriter::printQualifierDeclElement(
       const CIMConstQualifierDecl& qualifierDecl,
       PEGASUS_STD(ostream)& os)
   {
       Array<Sint8> tmp;
       appendQualifierDeclElement(tmp, qualifierDecl);
       tmp.append('\0');
       os << tmp.getData() << PEGASUS_STD(endl);
   }
   
   //------------------------------------------------------------------------------
   //
   // appendQualifierFlavorEntity()
   //
   //     <!ENTITY % QualifierFlavor "OVERRIDABLE  (true|false)   'true'
   //                                 TOSUBCLASS   (true|false)   'true'
   //                                 TOINSTANCE   (true|false)   'false'
   //                                 TRANSLATABLE (true|false)   'false'">
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendQualifierFlavorEntity(
       Array<Sint8>& out,
       Uint32 flavor)
   {
       if (!(flavor & CIMFlavor::OVERRIDABLE))
           out << " OVERRIDABLE=\"false\"";
   
       if (!(flavor & CIMFlavor::TOSUBCLASS))
           out << " TOSUBCLASS=\"false\"";
   
       if (flavor & CIMFlavor::TOINSTANCE)
           out << " TOINSTANCE=\"true\"";
   
       if (flavor & CIMFlavor::TRANSLATABLE)
           out << " TRANSLATABLE=\"true\"";
   }
   
   //------------------------------------------------------------------------------
   //
   // appendScopeElement()
   //
   //     <!ELEMENT SCOPE EMPTY>
   //     <!ATTLIST SCOPE
   //              CLASS        (true|false)      'false'
   //              ASSOCIATION  (true|false)      'false'
   //              REFERENCE    (true|false)      'false'
   //              PROPERTY     (true|false)      'false'
   //              METHOD       (true|false)      'false'
   //              PARAMETER    (true|false)      'false'
   //              INDICATION   (true|false)      'false'>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendScopeElement(
       Array<Sint8>& out,
       Uint32 scope)
   {
       if (scope)
       {
           out << "<SCOPE";
   
           if (scope & CIMScope::CLASS)
               out << " CLASS=\"true\"";
   
           if (scope & CIMScope::ASSOCIATION)
               out << " ASSOCIATION=\"true\"";
   
           if (scope & CIMScope::REFERENCE)
               out << " REFERENCE=\"true\"";
   
           if (scope & CIMScope::PROPERTY)
               out << " PROPERTY=\"true\"";
   
           if (scope & CIMScope::METHOD)
               out << " METHOD=\"true\"";
   
           if (scope & CIMScope::PARAMETER)
               out << " PARAMETER=\"true\"";
   
           if (scope & CIMScope::INDICATION)
               out << " INDICATION=\"true\"";
   
           out << "/>";
       }
   }
   
   //------------------------------------------------------------------------------
   //
   // appendMethodCallHeader()
   //
   //     Build HTTP method call request header.
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendMethodCallHeader(
       Array<Sint8>& out,
       const char* host,
       const char* cimMethod,
       const String& cimObject,
       const String& authenticationHeader,
       Uint32 contentLength)
   {
       char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
   
       out << "M-POST /cimom HTTP/1.1\r\n";
       out << "HOST: " << host << "\r\n";
       out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";
       out << "Content-Length: " << contentLength << "\r\n";
       out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";
       out << nn <<"\r\n";
       out << nn << "-CIMOperation: MethodCall\r\n";
       out << nn << "-CIMMethod: " << cimMethod << "\r\n";
       out << nn << "-CIMObject: " << cimObject << "\r\n";
       if (authenticationHeader.size())
       {
           out << authenticationHeader << "\r\n";
       }
       out << "\r\n";
   }
   
   //------------------------------------------------------------------------------
   //
   // appendMethodResponseHeader()
   //
   //     Build HTTP response header.
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendMethodResponseHeader(
       Array<Sint8>& out,
       Uint32 contentLength)
   {
       char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
   
       out << "HTTP/1.1 " HTTP_STATUS_OK "\r\n";
       STAT_SERVERTIME
       out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";
       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 << "-CIMOperation: MethodResponse\r\n\r\n";
   }
   
   //------------------------------------------------------------------------------
   //
   // appendHttpErrorResponseHeader()
   //
   //     Build HTTP error response header.
   //
   //     Returns error response message in the following format:
   //
   //        HTTP/1.1 400 Bad Request       (using specified status code)
   //        CIMError: <error type>         (if specified by caller)
   //        PGErrorDetail: <error text>    (if specified by caller)
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendHttpErrorResponseHeader(
       Array<Sint8>& out,
       const String& status,
       const String& cimError,
       const String& errorDetail)
   {
       out << "HTTP/1.1 " << status << "\r\n";
       if (cimError != String::EMPTY)
       {
           out << "CIMError: " << cimError << "\r\n";
       }
       if (errorDetail != String::EMPTY)
       {
           // ATTN-RK-P3-20020404: It is critical that this text not contain '\n'
           // ATTN-RK-P3-20020404: Need to encode this value properly.  (See
           // CIM/HTTP Specification section 3.3.2
           out << PEGASUS_HTTPHEADERTAG_ERRORDETAIL ": " << errorDetail << "\r\n";
       }
       out << "\r\n";
   }
   
   //------------------------------------------------------------------------------
   //
   // appendUnauthorizedResponseHeader()
   //
   //     Build HTTP authentication response header for unauthorized requests.
   //
   //     Returns unauthorized message in the following format:
   //
   //        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>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendUnauthorizedResponseHeader(
       Array<Sint8>& out,
       const String& content)
   {
       out << "HTTP/1.1 " HTTP_STATUS_UNAUTHORIZED "\r\n";
       out << content << "\r\n";
       out << "\r\n";
   
   //ATTN: We may need to include the following line, so that the browsers
   //      can display the error message.
   //    out << "<HTML><HEAD>\r\n";
   //    out << "<TITLE>" << "401 Unauthorized" <<  "</TITLE>\r\n";
   //    out << "</HEAD><BODY BGCOLOR=\"#99cc99\">\r\n";
   //    out << "<H2>TEST" << "401 Unauthorized" << "</H2>\r\n";
   //    out << "<HR>\r\n";
   //    out << "</BODY></HTML>\r\n";
   }
   
   //------------------------------------------------------------------------------
   //
   // _appendMessageElementBegin()
   // _appendMessageElementEnd()
   //
   //     <!ELEMENT MESSAGE (SIMPLEREQ|MULTIREQ|SIMPLERSP|MULTIRSP)>
   //     <!ATTLIST MESSAGE
   //         ID CDATA #REQUIRED
   //         PROTOCOLVERSION CDATA #REQUIRED>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::_appendMessageElementBegin(
       Array<Sint8>& out,
       const String& messageId)
   {
       out << "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";
       out << "<CIM CIMVERSION=\"2.0\" DTDVERSION=\"2.0\">\n";
       out << "<MESSAGE ID=\"" << messageId << "\" PROTOCOLVERSION=\"1.0\">\n";
   }
   
   void XmlWriter::_appendMessageElementEnd(
       Array<Sint8>& out)
   {
       out << "</MESSAGE>\n";
       out << "</CIM>\n";
   }
   
   //------------------------------------------------------------------------------
   //
   // _appendSimpleReqElementBegin()
   // _appendSimpleReqElementEnd()
   //
   //     <!ELEMENT SIMPLEREQ (IMETHODCALL|METHODCALL)>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::_appendSimpleReqElementBegin(
       Array<Sint8>& out)
   {
       out << "<SIMPLEREQ>\n";
   }
   
   void XmlWriter::_appendSimpleReqElementEnd(
       Array<Sint8>& out)
   {
       out << "</SIMPLEREQ>\n";
   }
   
   //------------------------------------------------------------------------------
   //
   // _appendMethodCallElementBegin()
   // _appendMethodCallElementEnd()
   //
   //     <!ELEMENT METHODCALL ((LOCALCLASSPATH|LOCALINSTANCEPATH),PARAMVALUE*)>
   //     <!ATTLIST METHODCALL %CIMName;>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::_appendMethodCallElementBegin(
       Array<Sint8>& out,
       const char* name)
   {
       out << "<METHODCALL NAME=\"" << name << "\">\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";
   }
   
   //------------------------------------------------------------------------------
   //
   // _appendIParamValueElementBegin()
   // _appendIParamValueElementEnd()
   //
   //     <!ELEMENT IPARAMVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE
   //         |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION
   //         |CLASS|INSTANCE|VALUE.NAMEDINSTANCE)?>
   //     <!ATTLIST IPARAMVALUE %CIMName;>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::_appendIParamValueElementBegin(
       Array<Sint8>& out,
       const char* name)
   {
       out << "<IPARAMVALUE NAME=\"" << name << "\">\n";
   }
   
   void XmlWriter::_appendIParamValueElementEnd(
       Array<Sint8>& out)
   {
       out << "</IPARAMVALUE>\n";
   }
   
   //------------------------------------------------------------------------------
   //
   // _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()
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::_appendErrorElement(
       Array<Sint8>& out,
       const CIMException& cimException)
   {
       PEG_TRACE_STRING(TRC_XML_WRITER, Tracer::LEVEL2,
                        cimException.getTraceDescription());
   
       out << "<ERROR";
       out << " CODE=\"" << Uint32(cimException.getCode()) << "\"";
       String description = cimException.getDescription();
       if (description != String::EMPTY)
       {
           out << " DESCRIPTION=\"";
           appendSpecial(out, description);
           out << "\"";
       }
       out << "/>";
   }
   
   //------------------------------------------------------------------------------
   //
   // appendReturnValueElement()
   //
   // <!ELEMENT RETURNVALUE (VALUE|VALUE.REFERENCE)>
   // <!ATTLIST RETURNVALUE
   //     %ParamType;>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendReturnValueElement(
       Array<Sint8>& out,
       const CIMValue& value)
   {
       out << "<RETURNVALUE";
   
       CIMType type = value.getType();
       if (type != CIMTYPE_NONE)
       {
           out << " PARAMTYPE=\"" << cimTypeToString (type) << "\"";
       }
   
       out << ">\n";
   
       // Add value.
       appendValueElement(out, value);
       out << "</RETURNVALUE>\n";
   }
   
   //------------------------------------------------------------------------------
   //
   // _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()
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendBooleanIParameter(
       Array<Sint8>& out,
       const char* name,
       Boolean flag)
   {
       _appendIParamValueElementBegin(out, name);
       out << "<VALUE>";
       append(out, flag);
       out << "</VALUE>\n";
       _appendIParamValueElementEnd(out);
   }
   
   //------------------------------------------------------------------------------
   //
   // appendStringIParameter()
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendStringIParameter(
       Array<Sint8>& out,
       const char* name,
       const String& str)
   {
       _appendIParamValueElementBegin(out, name);
       out << "<VALUE>";
       appendSpecial(out, str);
       out << "</VALUE>\n";
       _appendIParamValueElementEnd(out);
   }
   
   //------------------------------------------------------------------------------
   //
   // appendQualifierNameIParameter()
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendQualifierNameIParameter(
       Array<Sint8>& out,
       const char* name,
       const String& qualifierName)
   {
       // <!ELEMENT IPARAMVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE
       //     |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION
       //     |CLASS|INSTANCE|VALUE.NAMEDINSTANCE)?>
       //
       // ATTN: notice that there is really no way to pass a qualifier name
       // 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.
   
       _appendIParamValueElementBegin(out, name);
       appendClassNameElement(out, qualifierName);
       _appendIParamValueElementEnd(out);
   }
   
   //------------------------------------------------------------------------------
   //
   // appendClassNameIParameter()
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendClassNameIParameter(
       Array<Sint8>& out,
       const char* name,
       const String& className)
   {
       _appendIParamValueElementBegin(out, name);
       appendClassNameElement(out, className);
       _appendIParamValueElementEnd(out);
   }
   
   //------------------------------------------------------------------------------
   //
   // appendInstanceNameIParameter()
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendInstanceNameIParameter(
       Array<Sint8>& out,
       const char* name,
       const CIMObjectPath& instanceName)
   {
       _appendIParamValueElementBegin(out, name);
       appendInstanceNameElement(out, instanceName);
       _appendIParamValueElementEnd(out);
   }
   
   void XmlWriter::appendObjectNameIParameter(
       Array<Sint8>& out,
       const char* name,
       const CIMObjectPath& 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)
 { {
     while (*str)      _appendIParamValueElementBegin(out, name);
         AppendSpecialChar(os, *str++);      appendClassElement(out, cimClass);
       _appendIParamValueElementEnd(out);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatGetHeader()  // appendInstanceIParameter()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatGetHeader(  void XmlWriter::appendInstanceIParameter(
     const char* documentPath)      Array<Sint8>& out,
       const char* name,
       const CIMConstInstance& instance)
 { {
     Array<Sint8> out;      _appendIParamValueElementBegin(out, name);
     return out << "GET " << documentPath << "HTTP/1.0\r\n\r\n";      appendInstanceElement(out, instance);
       _appendIParamValueElementEnd(out);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatMPostHeader()  // appendNamedInstanceIParameter()
 //  
 //     Build HTTP request header.  
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatMPostHeader(  void XmlWriter::appendNamedInstanceIParameter(
     const char* host,      Array<Sint8>& out,
     const char* cimOperation,      const char* name,
     const char* cimMethod,      const CIMInstance& namedInstance)
     const String& cimObject,  
     const Array<Sint8>& content)  
 { {
     Array<Sint8> out;      _appendIParamValueElementBegin(out, name);
     out.reserve(1024);      appendValueNamedInstanceElement(out, namedInstance);
     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };      _appendIParamValueElementEnd(out);
   }
  
     out << "M-POST /cimom HTTP/1.1\r\n";  //----------------------------------------------------------
     out << "HOST: " << host << "\r\n";  //
     out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";  //  appendPropertyNameIParameter()
     out << "Content-Length: " << content.getSize() << "\r\n";  //
     out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";  //     </IPARAMVALUE>
     out << nn <<"\r\n";  //     <IPARAMVALUE NAME="PropertyName"><VALUE>FreeSpace</VALUE></IPARAMVALUE>
     out << nn << "-CIMOperation: " << cimOperation << "\r\n";  //
     out << nn << "-CIMMethod: " << cimMethod << "\r\n";  //     USE: Create parameter for getProperty operation
     out << nn << "-CIMObject: " << cimObject << "\r\n\r\n";  //==========================================================
     out << content;  void XmlWriter::appendPropertyNameIParameter(
     return out;      Array<Sint8>& out,
       const String& propertyName)
   {
       _appendIParamValueElementBegin(out, "PropertyName");
       out << "<VALUE>" << propertyName << "</VALUE>\n";
       _appendIParamValueElementEnd(out);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatMethodResponseHeader()  // appendPropertyValueIParameter()
 //  
 //     Build HTTP response header.  
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatMethodResponseHeader(  void XmlWriter::appendPropertyValueIParameter(
     const Array<Sint8>& content)      Array<Sint8>& out,
       const char* name,
       const CIMValue& value)
 { {
     Array<Sint8> out;      _appendIParamValueElementBegin(out, name);
     out.reserve(1024);      appendValueElement(out, value);
     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };      _appendIParamValueElementEnd(out);
   
     out << "HTTP/1.1 200 OK\r\n";  
     out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";  
     out << "Content-Length: " << content.getSize() << "\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 << "-CIMOperation: MethodResponse\r\n\r\n";  
     out << content;  
     return out;  
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatMessageElement()  // appendPropertyListIParameter()
 //  
 //     <!ELEMENT MESSAGE (SIMPLEREQ|MULTIREQ|SIMPLERSP|MULTIRSP)>  
 //     <!ATTLIST MESSAGE  
 //         ID CDATA #REQUIRED  
 //         PROTOCOLVERSION CDATA #REQUIRED>  
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatMessageElement(  void XmlWriter::appendPropertyListIParameter(
     Uint32 messageId,      Array<Sint8>& out,
     const Array<Sint8>& body)      const CIMPropertyList& propertyList)
 { {
     Array<Sint8> out;      // ATTN: P3 KS 4 Mar 2002 - As check shouldn't we check for null property list
     out.reserve(1024);      _appendIParamValueElementBegin(out, "PropertyList");
  
     out << "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";      out << "<VALUE.ARRAY>\n";
     out << "<CIM CIMVERSION=\"2.0\" DTDVERSION=\"2.0\">\n";      for (Uint32 i = 0; i < propertyList.size(); i++)
     out << "<MESSAGE ID=\"" << messageId << "\" PROTOCOLVERSION=\"1.0\">\n";      {
     out << body;          out << "<VALUE>" << propertyList[i] << "</VALUE>\n";
     out << "</MESSAGE>\n";      }
     out << "</CIM>\n";      out << "</VALUE.ARRAY>\n";
     return out;  
       _appendIParamValueElementEnd(out);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatSimpleReqElement()  // appendQualifierDeclarationIParameter()
 //  
 //     <!ELEMENT SIMPLEREQ (IMETHODCALL|METHODCALL)>  
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleReqElement(  void XmlWriter::appendQualifierDeclarationIParameter(
     const Array<Sint8>& body)      Array<Sint8>& out,
       const char* name,
       const CIMConstQualifierDecl& qualifierDecl)
 { {
     Array<Sint8> out;      _appendIParamValueElementBegin(out, name);
     return out << "<SIMPLEREQ>\n" << body << "</SIMPLEREQ>\n";      appendQualifierDeclElement(out, qualifierDecl);
       _appendIParamValueElementEnd(out);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatSimpleRspElement()  // XmlWriter::formatHttpErrorRspMessage()
 //  
 //     <!ELEMENT SIMPLERSP (METHODRESPONSE|IMETHODRESPONSE)>  
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleRspElement(  Array<Sint8> XmlWriter::formatHttpErrorRspMessage(
     const Array<Sint8>& body)      const String& status,
       const String& cimError,
       const String& errorDetail)
 { {
     Array<Sint8> out;     Array<Sint8> out;
     return out << "<SIMPLERSP>\n" << body << "</SIMPLERSP>\n";  
       appendHttpErrorResponseHeader(out, status, cimError, errorDetail);
   
       return out;
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatIMethodCallElement()  // XmlWriter::formatSimpleMethodReqMessage()
 //  
 //     <!ELEMENT IMETHODCALL (LOCALNAMESPACEPATH,IPARAMVALUE*)>  
 //     <!ATTLIST IMETHODCALL %CIMName;>  
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatIMethodCallElement(  // ATTN-RK-P1-20020228: Need to complete copy elimination optimization
     const char* name,  Array<Sint8> XmlWriter::formatSimpleMethodReqMessage(
       const char* host,
     const String& nameSpace,     const String& nameSpace,
     const Array<Sint8>& iParamValues)      const CIMObjectPath& path,
       const char* methodName,
       const Array<CIMParamValue>& parameters,
       const String& messageId,
       const String& authenticationHeader)
 { {
     Array<Sint8> out;     Array<Sint8> out;
     out << "<IMETHODCALL NAME=\"" << name << "\">\n";      Array<Sint8> tmp;
     XmlWriter::appendLocalNameSpaceElement(out, nameSpace);      CIMObjectPath localObjectPath = path;
     out << iParamValues;      localObjectPath.setNameSpace(nameSpace);
     out << "</IMETHODCALL>\n";  
     return out;      _appendMessageElementBegin(out, messageId);
       _appendSimpleReqElementBegin(out);
       _appendMethodCallElementBegin(out, methodName);
       appendLocalObjectPathElement(out, localObjectPath);
       for (Uint32 i=0; i < parameters.size(); i++)
       {
           appendParamValueElement(out, parameters[i]);
       }
       _appendMethodCallElementEnd(out);
       _appendSimpleReqElementEnd(out);
       _appendMessageElementEnd(out);
   
       appendMethodCallHeader(
           tmp,
           host,
           methodName,
           localObjectPath.toString(false),
           authenticationHeader,
           out.size());
       tmp << out;
   
       return tmp;
   }
   
   Array<Sint8> XmlWriter::formatSimpleMethodRspMessage(
       const char* methodName,
       const String& messageId,
       const Array<Sint8>& body)
   {
       Array<Sint8> out;
       Array<Sint8> tmp;
   
       _appendMessageElementBegin(out, messageId);
       _appendSimpleRspElementBegin(out);
       _appendMethodResponseElementBegin(out, methodName);
       out << body;
       _appendMethodResponseElementEnd(out);
       _appendSimpleRspElementEnd(out);
       _appendMessageElementEnd(out);
   
       appendMethodResponseHeader(tmp, out.size());
       tmp << out;
   
       return tmp;
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatIMethodResponseElement()  // XmlWriter::formatSimpleMethodErrorRspMessage()
 //  
 //     <!ELEMENT IMETHODRESPONSE (ERROR|IRETURNVALUE?)>  
 //     <!ATTLIST IMETHODRESPONSE %CIMName;>  
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatIMethodResponseElement(  Array<Sint8> XmlWriter::formatSimpleMethodErrorRspMessage(
     const char* name,      const String& methodName,
     const Array<Sint8>& body)      const String& messageId,
       const CIMException& cimException)
 { {
       ArrayDestroyer<char> tmp1(methodName.allocateCString());
     Array<Sint8> out;     Array<Sint8> out;
     out << "<IMETHODRESPONSE NAME=\"" << name << "\">\n";      Array<Sint8> tmp;
     out << body;  
     out << "</IMETHODRESPONSE>\n";      _appendMessageElementBegin(out, messageId);
     return out;      _appendSimpleRspElementBegin(out);
       _appendMethodResponseElementBegin(out, tmp1.getPointer());
       _appendErrorElement(out, cimException);
       _appendMethodResponseElementEnd(out);
       _appendSimpleRspElementEnd(out);
       _appendMessageElementEnd(out);
   
       appendMethodResponseHeader(tmp, out.size());
       tmp << out;
   
       return tmp;
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatIReturnValueElement()  // XmlWriter::formatSimpleIMethodReqMessage()
 //  
 //      <!ELEMENT IRETURNVALUE (CLASSNAME*|INSTANCENAME*|VALUE*|  
 //          VALUE.OBJECTWITHPATH*|VALUE.OBJECTWITHLOCALPATH*|VALUE.OBJECT*|  
 //          OBJECTPATH*|QUALIFIER.DECLARATION*|VALUE.ARRAY?|VALUE.REFERENCE?|  
 //          CLASS*|INSTANCE*|VALUE.NAMEDINSTANCE*)>  
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatIReturnValueElement(  Array<Sint8> XmlWriter::formatSimpleIMethodReqMessage(
       const char* host,
       const String& nameSpace,
       const char* iMethodName,
       const String& messageId,
       const String& authenticationHeader,
     const Array<Sint8>& body)     const Array<Sint8>& body)
 { {
     Array<Sint8> out;     Array<Sint8> out;
     return out << "<IRETURNVALUE>\n" << body << "</IRETURNVALUE>\n";      Array<Sint8> tmp;
   
       _appendMessageElementBegin(out, messageId);
       _appendSimpleReqElementBegin(out);
       _appendIMethodCallElementBegin(out, iMethodName);
       appendLocalNameSpacePathElement(out, nameSpace);
       out << body;
       _appendIMethodCallElementEnd(out);
       _appendSimpleReqElementEnd(out);
       _appendMessageElementEnd(out);
   
       appendMethodCallHeader(
           tmp,
           host,
           iMethodName,
           nameSpace,
           authenticationHeader,
           out.size());
       tmp << out;
   
       return tmp;
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatIParamValueElement()  // XmlWriter::formatSimpleIMethodRspMessage()
 //  
 //     <!ELEMENT IPARAMVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE  
 //         |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION  
 //         |CLASS|INSTANCE|VALUE.NAMEDINSTANCE)?>  
 //     <!ATTLIST IPARAMVALUE %CIMName;>  
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::formatIParamValueElement(  Array<Sint8> XmlWriter::formatSimpleIMethodRspMessage(
     Array<Sint8>& out,      const char* iMethodName,
     const char* name,      const String& messageId,
     const Array<Sint8>& body)     const Array<Sint8>& body)
 { {
     out << "<IPARAMVALUE NAME=\"" << name << "\">\n";      Array<Sint8> out;
       Array<Sint8> tmp;
   
       _appendMessageElementBegin(out, messageId);
       _appendSimpleRspElementBegin(out);
       _appendIMethodResponseElementBegin(out, iMethodName);
       if (body.size() != 0)
       {
           _appendIReturnValueElementBegin(out);
     out << body;     out << body;
     out << "</IPARAMVALUE>\n";          _appendIReturnValueElementEnd(out);
     return out;      }
       _appendIMethodResponseElementEnd(out);
       _appendSimpleRspElementEnd(out);
       _appendMessageElementEnd(out);
   
       appendMethodResponseHeader(tmp, out.size());
       tmp << out;
   
       return tmp;
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatErrorElement()  // XmlWriter::formatSimpleIMethodErrorRspMessage()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatErrorElement(  Array<Sint8> XmlWriter::formatSimpleIMethodErrorRspMessage(
     CimException::Code code,      const String& iMethodName,
     const char* description)      const String& messageId,
       const CIMException& cimException)
 { {
       ArrayDestroyer<char> tmp1(iMethodName.allocateCString());
     Array<Sint8> out;     Array<Sint8> out;
     out << "<ERROR";      Array<Sint8> tmp;
     out << " CODE=\"" << Uint32(code) << "\"";  
     out << " DESCRIPTION=\"";      _appendMessageElementBegin(out, messageId);
     appendSpecial(out, description);      _appendSimpleRspElementBegin(out);
     out << "\"/>";      _appendIMethodResponseElementBegin(out, tmp1.getPointer());
     return out;      _appendErrorElement(out, cimException);
       _appendIMethodResponseElementEnd(out);
       _appendSimpleRspElementEnd(out);
       _appendMessageElementEnd(out);
   
       appendMethodResponseHeader(tmp, out.size());
       tmp << out;
   
       return tmp;
 } }
  
   //******************************************************************************
   //
   // Export Messages (used for indications)
   //
   //******************************************************************************
   
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendBooleanParameter()  // appendEMethodRequestHeader()
   //
   //     Build HTTP request header for export operation.
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendBooleanParameter(  void XmlWriter::appendEMethodRequestHeader(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* name,      const char* requestUri,
     Boolean flag)      const char* host,
       const char* cimMethod,
       const String& authenticationHeader,
       Uint32 contentLength)
 { {
     Array<Sint8> tmp;      char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
     tmp << "<VALUE>" << (flag ? "TRUE" : "FALSE") << "</VALUE>\n";  
     return formatIParamValueElement(out, name, tmp);      out << "M-POST " << requestUri << " HTTP/1.1\r\n";
       out << "HOST: " << host << "\r\n";
       out << "Content-Type: 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";
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendClassNameParameter()  // appendEMethodResponseHeader()
   //
   //     Build HTTP response header for export operation.
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendClassNameParameter(  void XmlWriter::appendEMethodResponseHeader(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* name,      Uint32 contentLength)
     const String& className)  
 { {
     Array<Sint8> tmp;      char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
     appendClassNameElement(tmp, className);  
     return formatIParamValueElement(out, name, tmp);      out << "HTTP/1.1 " HTTP_STATUS_OK "\r\n";
       out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";
       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";
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendQualifierNameParameter()  // _appendSimpleExportReqElementBegin()
   // _appendSimpleExportReqElementEnd()
   //
   //     <!ELEMENT SIMPLEEXPREQ (EXPMETHODCALL)>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendQualifierNameParameter(  void XmlWriter::_appendSimpleExportReqElementBegin(
     Array<Sint8>& out,      Array<Sint8>& out)
     const char* name,  
     const String& qualifierName)  
 { {
     // <!ELEMENT IPARAMVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE      out << "<SIMPLEEXPREQ>\n";
     //     |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION  }
     //     |CLASS|INSTANCE|VALUE.NAMEDINSTANCE)?>  
     //  
     // ATTN: notice that there is really no way to pass a qualifier name  
     // 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.  
  
     Array<Sint8> tmp;  void XmlWriter::_appendSimpleExportReqElementEnd(
     appendClassNameElement(tmp, qualifierName);      Array<Sint8>& out)
     return formatIParamValueElement(out, name, tmp);  {
       out << "</SIMPLEEXPREQ>\n";
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendClassParameter()  // _appendEMethodCallElementBegin()
   // _appendEMethodCallElementEnd()
   //
   //     <!ELEMENT EXPMETHODCALL (IPARAMVALUE*)>
   //     <!ATTLIST EXPMETHODCALL %CIMName;>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendClassParameter(  void XmlWriter::_appendEMethodCallElementBegin(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* parameterName,      const char* name)
     const ConstCIMClass& cimClass)  
 { {
     Array<Sint8> tmp;      out << "<EXPMETHODCALL NAME=\"" << name << "\">\n";
     cimClass.toXml(tmp);  }
     return formatIParamValueElement(out, parameterName, tmp);  
   void XmlWriter::_appendEMethodCallElementEnd(
       Array<Sint8>& out)
   {
       out << "</EXPMETHODCALL>\n";
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendInstanceNameParameter()  // _appendSimpleExportRspElementBegin()
   // _appendSimpleExportRspElementEnd()
   //
   //     <!ELEMENT SIMPLEEXPRSP (EXPMETHODRESPONSE)>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendInstanceNameParameter(  void XmlWriter::_appendSimpleExportRspElementBegin(
     Array<Sint8>& out,      Array<Sint8>& out)
     const char* parameterName,  
     const CIMReference& instanceName)  
 { {
     Array<Sint8> tmp;      out << "<SIMPLEEXPRSP>\n";
     instanceName.instanceNameToXml(tmp);  }
     return formatIParamValueElement(out, parameterName, tmp);  
   void XmlWriter::_appendSimpleExportRspElementEnd(
       Array<Sint8>& out)
   {
       out << "</SIMPLEEXPRSP>\n";
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendInstanceParameter()  // _appendEMethodResponseElementBegin()
   // _appendEMethodResponseElementEnd()
   //
   //     <!ELEMENT EXPMETHODRESPONSE (ERROR|IRETURNVALUE?)>
   //     <!ATTLIST EXPMETHODRESPONSE %CIMName;>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendInstanceParameter(  void XmlWriter::_appendEMethodResponseElementBegin(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* parameterName,      const char* name)
     const ConstCIMInstance& instance)  
 { {
     Array<Sint8> tmp;      out << "<EXPMETHODRESPONSE NAME=\"" << name << "\">\n";
     instance.toXml(tmp);  }
     return formatIParamValueElement(out, parameterName, tmp);  
   void XmlWriter::_appendEMethodResponseElementEnd(
       Array<Sint8>& out)
   {
       out << "</EXPMETHODRESPONSE>\n";
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendClassParameter()  // XmlWriter::formatSimpleEMethodReqMessage()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendQualifierDeclarationParameter(  Array<Sint8> XmlWriter::formatSimpleEMethodReqMessage(
     Array<Sint8>& out,      const char* requestUri,
     const char* parameterName,      const char* host,
     const CIMConstQualifierDecl& qualifierDecl)      const char* eMethodName,
       const String& messageId,
       const String& authenticationHeader,
       const Array<Sint8>& body)
 { {
       Array<Sint8> out;
     Array<Sint8> tmp;     Array<Sint8> tmp;
     qualifierDecl.toXml(tmp);  
     return formatIParamValueElement(out, parameterName, tmp);      _appendMessageElementBegin(out, messageId);
       _appendSimpleExportReqElementBegin(out);
       _appendEMethodCallElementBegin(out, eMethodName);
       out << body;
       _appendEMethodCallElementEnd(out);
       _appendSimpleExportReqElementEnd(out);
       _appendMessageElementEnd(out);
   
       appendEMethodRequestHeader(
           tmp,
           requestUri,
           host,
           eMethodName,
           authenticationHeader,
           out.size());
       tmp << out;
   
       return tmp;
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendClassNameElement()  // XmlWriter::formatSimpleEMethodRspMessage()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendClassNameElement(  Array<Sint8> XmlWriter::formatSimpleEMethodRspMessage(
     Array<Sint8>& out,      const char* eMethodName,
     const String& className)      const String& messageId,
       const Array<Sint8>& body)
 { {
     return out << "<CLASSNAME NAME=\"" << className << "\"/>\n";      Array<Sint8> out;
       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;
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendInstanceNameElement()  // XmlWriter::formatSimpleEMethodErrorRspMessage()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendInstanceNameElement(  Array<Sint8> XmlWriter::formatSimpleEMethodErrorRspMessage(
     Array<Sint8>& out,      const String& eMethodName,
     const CIMReference& instanceName)      const String& messageId,
       const CIMException& cimException)
 { {
     instanceName.instanceNameToXml(out);      ArrayDestroyer<char> tmp1(eMethodName.allocateCString());
     return out;      Array<Sint8> out;
       Array<Sint8> tmp;
   
       _appendMessageElementBegin(out, messageId);
       _appendSimpleExportRspElementBegin(out);
       _appendEMethodResponseElementBegin(out, tmp1.getPointer());
       _appendErrorElement(out, cimException);
       _appendEMethodResponseElementEnd(out);
       _appendSimpleExportRspElementEnd(out);
       _appendMessageElementEnd(out);
   
       appendEMethodResponseHeader(tmp, out.size());
       tmp << out;
   
       return tmp;
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 585 
Line 2458 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 static void _printAttributes( static void _printAttributes(
     std::ostream& os,      PEGASUS_STD(ostream)& os,
     const XmlAttribute* attributes,     const XmlAttribute* attributes,
     Uint32 attributeCount)     Uint32 attributeCount)
 { {
Line 594 
Line 2467 
         os << attributes[i].name << "=";         os << attributes[i].name << "=";
  
         os << '"';         os << '"';
         AppendSpecial(os, attributes[i].value);          _appendSpecial(os, attributes[i].value);
         os << '"';         os << '"';
  
         if (i + 1 != attributeCount)         if (i + 1 != attributeCount)
Line 608 
Line 2481 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 static void _indent(std::ostream& os, Uint32 level, Uint32 indentChars)  static void _indent(PEGASUS_STD(ostream)& os, Uint32 level, Uint32 indentChars)
 { {
     Uint32 n = level * indentChars;     Uint32 n = level * indentChars;
  
Line 623 
Line 2496 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::indentedPrint( void XmlWriter::indentedPrint(
     std::ostream& os,      PEGASUS_STD(ostream)& os,
     const char* text,     const char* text,
     Uint32 indentChars)     Uint32 indentChars)
 { {
Line 639 
Line 2512 
         {         {
             case XmlEntry::XML_DECLARATION:             case XmlEntry::XML_DECLARATION:
             {             {
                 _indent(os, stack.getSize(), indentChars);                  _indent(os, stack.size(), indentChars);
  
                 os << "<?" << entry.text << " ";                 os << "<?" << entry.text << " ";
                 _printAttributes(os, entry.attributes, entry.attributeCount);                 _printAttributes(os, entry.attributes, entry.attributeCount);
Line 649 
Line 2522 
  
             case XmlEntry::START_TAG:             case XmlEntry::START_TAG:
             {             {
                 _indent(os, stack.getSize(), indentChars);                  _indent(os, stack.size(), indentChars);
  
                 os << "<" << entry.text;                 os << "<" << entry.text;
  
Line 664 
Line 2537 
  
             case XmlEntry::EMPTY_TAG:             case XmlEntry::EMPTY_TAG:
             {             {
                 _indent(os, stack.getSize(), indentChars);                  _indent(os, stack.size(), indentChars);
  
                 os << "<" << entry.text << " ";                 os << "<" << entry.text << " ";
                 _printAttributes(os, entry.attributes, entry.attributeCount);                 _printAttributes(os, entry.attributes, entry.attributeCount);
Line 677 
Line 2550 
                 if (!stack.isEmpty() && strcmp(stack.top(), entry.text) == 0)                 if (!stack.isEmpty() && strcmp(stack.top(), entry.text) == 0)
                     stack.pop();                     stack.pop();
  
                 _indent(os, stack.getSize(), indentChars);                  _indent(os, stack.size(), indentChars);
  
                 os << "</" << entry.text << ">";                 os << "</" << entry.text << ">";
                 break;                 break;
Line 686 
Line 2559 
             case XmlEntry::COMMENT:             case XmlEntry::COMMENT:
             {             {
  
                 _indent(os, stack.getSize(), indentChars);                  _indent(os, stack.size(), indentChars);
                 os << "<!--";                 os << "<!--";
                 AppendSpecial(os, entry.text);                  _appendSpecial(os, entry.text);
                 os << "-->";                 os << "-->";
                 break;                 break;
             }             }
  
             case XmlEntry::CONTENT:             case XmlEntry::CONTENT:
             {             {
                 _indent(os, stack.getSize(), indentChars);                  _indent(os, stack.size(), indentChars);
                 AppendSpecial(os, entry.text);                  _appendSpecial(os, entry.text);
                 break;                 break;
             }             }
  
             case XmlEntry::CDATA:             case XmlEntry::CDATA:
             {             {
                 _indent(os, stack.getSize(), indentChars);                  _indent(os, stack.size(), indentChars);
                 os << "<![CDATA[...]]>";                 os << "<![CDATA[...]]>";
                 break;                 break;
             }             }
  
             case XmlEntry::DOCTYPE:             case XmlEntry::DOCTYPE:
             {             {
                 _indent(os, stack.getSize(), indentChars);                  _indent(os, stack.size(), indentChars);
                 os << "<!DOCTYPE...>";                 os << "<!DOCTYPE...>";
                 break;                 break;
             }             }
         }         }
  
         os << std::endl;          os << PEGASUS_STD(endl);
     }     }
  
     delete [] tmp;     delete [] tmp;
Line 727 
Line 2600 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Uint32 XmlWriter::getNextMessageId()  String XmlWriter::getNextMessageId()
 { {
     // ATTN: make thread-safe:     // ATTN: make thread-safe:
     static Uint32 messageId = 1000;     static Uint32 messageId = 1000;
Line 737 
Line 2610 
     if (messageId < 1000)     if (messageId < 1000)
         messageId = 1001;         messageId = 1001;
  
     return messageId;      char buffer[16];
 }      sprintf(buffer, "%d", messageId);
       return buffer;
 //------------------------------------------------------------------------------  
 //  
 // XmlWriter::formatSimpleReqMessage()  
 //  
 //------------------------------------------------------------------------------  
   
 Array<Sint8> XmlWriter::formatSimpleReqMessage(  
     const char* host,  
     const String& nameSpace,  
     const char* iMethodName,  
     const Array<Sint8>& body)  
 {  
     return XmlWriter::formatMPostHeader(  
         host,  
         "MethodCall",  
         iMethodName,  
         nameSpace,  
         XmlWriter::formatMessageElement(  
             XmlWriter::getNextMessageId(),  
             XmlWriter::formatSimpleReqElement(  
                 XmlWriter::formatIMethodCallElement(  
                     iMethodName,  
                     nameSpace,  
                     body))));  
 }  
   
 Array<Sint8> XmlWriter::formatSimpleRspMessage(  
     const char* iMethodName,  
     const Array<Sint8>& body)  
 {  
     return XmlWriter::formatMethodResponseHeader(  
         XmlWriter::formatMessageElement(  
             XmlWriter::getNextMessageId(),  
             XmlWriter::formatSimpleRspElement(  
                 XmlWriter::formatIMethodResponseElement(  
                     iMethodName,  
                     XmlWriter::formatIReturnValueElement(body)))));  
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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