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

version 1.28, 2002/03/01 00:59:57 version 1.67, 2002/07/30 16:14:53
Line 1 
Line 1 
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001 BMC Software, Hewlett-Packard Company, IBM,  // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,
 // The Open Group, Tivoli Systems // The Open Group, Tivoli Systems
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
Line 26 
Line 26 
 // Modified By: Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com) // Modified By: Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)
 //              Nag Boranna, Hewlett-Packard Company (nagaraja_boranna@hp.com) //              Nag Boranna, Hewlett-Packard Company (nagaraja_boranna@hp.com)
 //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com) //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
   //              Carol Ann Krug Graves, Hewlett-Packard Company
   //                  (carolann_graves@hp.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
   #include <Pegasus/Common/Config.h>
 #include <cstdlib> #include <cstdlib>
 #include <cstdio> #include <cstdio>
   #include "Constants.h"
 #include "Destroyer.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
  
Line 158 
Line 178 
     _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, Sint32 x)
   {
       char buffer[32];
       sprintf(buffer, "%d", x);
       append(out, buffer);
   }
   
   void XmlWriter::append(Array<Sint8>& out, Uint64 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::append(Array<Sint8>& out, Sint64 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::append(Array<Sint8>& out, Real64 x)
   {
       char buffer[128];
       // %e gives '[-]m.dddddde+/-xx', which seems compatible with CIM/XML spec
       sprintf(buffer, "%e", x);
       append(out, buffer);
   }
   
   void XmlWriter::append(Array<Sint8>& out, const char* str)
   {
       while (*str)
           _appendChar(out, *str++);
   }
   
   void XmlWriter::append(Array<Sint8>& out, const String& str)
   {
       for (Uint32 i = 0; i < str.size(); i++)
       {
           _appendChar(out, str[i]);
       }
   }
   
   void XmlWriter::append(Array<Sint8>& out, const Indentor& x)
   {
       for (Uint32 i = 0; i < 4 * x.getLevel(); i++)
           out.append(' ');
   }
   
   void XmlWriter::appendSpecial(Array<Sint8>& out, Char16 x)
   {
       _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,
       const String& nameSpace)
   {
       out << "<LOCALNAMESPACEPATH>\n";
   
       char* tmp = nameSpace.allocateCString();
   
       for (char* p = strtok(tmp, "/"); p; p = strtok(NULL, "/"))
       {
           out << "<NAMESPACE NAME=\"" << p << "\"/>\n";
       }
   
       delete [] tmp;
   
       out << "</LOCALNAMESPACEPATH>\n";
   }
   
   //------------------------------------------------------------------------------
   //
   // 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)
   {
       out << "<CLASSNAME NAME=\"" << className << "\"/>\n";
   }
   
   //------------------------------------------------------------------------------
   //
   // appendInstanceNameElement()
   //
   //    <!ELEMENT INSTANCENAME (KEYBINDING*|KEYVALUE?|VALUE.REFERENCE?)>
   //    <!ATTLIST INSTANCENAME
   //              %ClassName;>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendInstanceNameElement(
       Array<Sint8>& out,
       const CIMObjectPath& instanceName)
   {
       out << "<INSTANCENAME CLASSNAME=\"" << instanceName.getClassName() << "\">\n";
   
       Array<KeyBinding> keyBindings = instanceName.getKeyBindings();
       for (Uint32 i = 0, n = keyBindings.size(); i < n; i++)
       {
           out << "<KEYBINDING NAME=\"" << keyBindings[i].getName() << "\">\n";
   
           if (keyBindings[i].getType() == KeyBinding::REFERENCE)
           {
               CIMObjectPath ref = keyBindings[i].getValue();
               appendValueReferenceElement(out, ref, true);
           }
           else {
               out << "<KEYVALUE VALUETYPE=\"";
               out << KeyBinding::typeToString(keyBindings[i].getType());
               out << "\">";
   
               // fixed the special character problem - Markus
   
               appendSpecial(out, keyBindings[i].getValue());
               out << "</KEYVALUE>\n";
           }
           out << "</KEYBINDING>\n";
       }
       out << "</INSTANCENAME>\n";
   }
   
   //------------------------------------------------------------------------------
   //
   // appendClassPathElement()
   //
   //     <!ELEMENT CLASSPATH (NAMESPACEPATH,CLASSNAME)>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendClassPathElement(
       Array<Sint8>& out,
       const 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));
   }
   
   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());
           }
 } }
  
 void XmlWriter::append(Array<Sint8>& out, const char* str)      if (putValueWrapper)
           out << "</VALUE.REFERENCE>\n";
   }
   
   void XmlWriter::printValueReferenceElement(
       const CIMObjectPath& reference,
       PEGASUS_STD(ostream)& os)
 { {
     while (*str)      Array<Sint8> tmp;
         _appendChar(out, *str++);      appendValueReferenceElement(tmp, reference, true);
       tmp.append('\0');
       indentedPrint(os, tmp.getData());
 } }
  
 void XmlWriter::append(Array<Sint8>& out, const String& str)  //------------------------------------------------------------------------------
   //
   // appendValueNamedInstanceElement()
   //
   //     <!ELEMENT VALUE.NAMEDINSTANCE (INSTANCENAME,INSTANCE)>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendValueNamedInstanceElement(
       Array<Sint8>& out,
       const CIMInstance& namedInstance)
 { {
     const Char16* tmp = str.getData();      out << "<VALUE.NAMEDINSTANCE>\n";
  
     while (*tmp)      appendInstanceNameElement(out, namedInstance.getPath ());
         _appendChar(out, *tmp++);      appendInstanceElement(out, namedInstance);
   
       out << "</VALUE.NAMEDINSTANCE>\n";
 } }
  
 void XmlWriter::append(Array<Sint8>& out, const Indentor& x)  //------------------------------------------------------------------------------
   //
   // appendClassElement()
   //
   //     <!ELEMENT CLASS
   //         (QUALIFIER*,(PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*,METHOD*)>
   //     <!ATTLIST CLASS
   //         %CIMName;
   //         %SuperClass;>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendClassElement(
       Array<Sint8>& out,
       const CIMConstClass& cimclass)
 { {
     for (Uint32 i = 0; i < 4 * x.getLevel(); i++)      cimclass._checkRep();
         out.append(' ');      cimclass._rep->toXml(out);
 } }
  
 void XmlWriter::appendSpecial(Array<Sint8>& out, Char16 x)  void XmlWriter::printClassElement(
       const CIMConstClass& cimclass,
       PEGASUS_STD(ostream)& os)
 { {
     _appendSpecialChar(out, x);      Array<Sint8> tmp;
       appendClassElement(tmp, cimclass);
       tmp.append('\0');
       indentedPrint(os, tmp.getData(), 4);
 } }
  
 void XmlWriter::appendSpecial(Array<Sint8>& out, char x)  //------------------------------------------------------------------------------
   //
   // appendInstanceElement()
   //
   //     <!ELEMENT INSTANCE
   //         (QUALIFIER*,(PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*)>
   //     <!ATTLIST INSTANCE
   //         %ClassName;>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendInstanceElement(
       Array<Sint8>& out,
       const CIMConstInstance& instance)
 { {
     _appendSpecialChar(out, Char16(x));      instance._checkRep();
       instance._rep->toXml(out);
 } }
  
 void XmlWriter::appendSpecial(Array<Sint8>& out, const char* str)  void XmlWriter::printInstanceElement(
       const CIMConstInstance& instance,
       PEGASUS_STD(ostream)& os)
 { {
     while (*str)      Array<Sint8> tmp;
         _appendSpecialChar(out, *str++);      appendInstanceElement(tmp, instance);
       tmp.append('\0');
       os << tmp.getData() << PEGASUS_STD(endl);
 } }
  
 void XmlWriter::appendSpecial(Array<Sint8>& out, const String& str)  //------------------------------------------------------------------------------
   //
   // 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)
 { {
     const Char16* tmp = str.getData();      property._checkRep();
       property._rep->toXml(out);
   }
  
     while (*tmp)  void XmlWriter::printPropertyElement(
         _appendSpecialChar(out, *tmp++);      const CIMConstProperty& property,
       PEGASUS_STD(ostream)& os)
   {
       Array<Sint8> tmp;
       appendPropertyElement(tmp, property);
       tmp.append('\0');
       os << tmp.getData() << PEGASUS_STD(endl);
 } }
  
 void XmlWriter::appendLocalNameSpaceElement(  //------------------------------------------------------------------------------
   //
   // appendMethodElement()
   //
   //     <!ELEMENT METHOD (QUALIFIER*,
   //         (PARAMETER|PARAMETER.REFERENCE|PARAMETER.ARRAY|PARAMETER.REFARRAY)*)>
   //     <!ATTLIST METHOD
   //              %CIMName;
   //              %CIMType;          #IMPLIED
   //              %ClassOrigin;
   //              %Propagated;>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendMethodElement(
     Array<Sint8>& out,     Array<Sint8>& out,
     const String& nameSpace)      const CIMConstMethod& method)
 { {
     out << "<LOCALNAMESPACEPATH>\n";      method._checkRep();
       method._rep->toXml(out);
   }
  
     char* tmp = nameSpace.allocateCString();  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);
   }
  
     for (char* p = strtok(tmp, "/"); p; p = strtok(NULL, "/"))  //------------------------------------------------------------------------------
   //
   // 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)
     {     {
         out << "<NAMESPACE NAME=\"" << p << "\"/>\n";      parameter._checkRep();
       parameter._rep->toXml(out);
     }     }
  
     delete [] tmp;  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);
   }
  
     out << "</LOCALNAMESPACEPATH>\n";  //------------------------------------------------------------------------------
   //
   // 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() // appendMethodCallHeader()
 // //
 //     Build HTTP request header.  //     Build HTTP method call request header.
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
Line 247 
Line 1386 
  
     out << "M-POST /cimom HTTP/1.1\r\n";     out << "M-POST /cimom HTTP/1.1\r\n";
     out << "HOST: " << host << "\r\n";     out << "HOST: " << host << "\r\n";
     out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";      out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";
     out << "Content-Length: " << contentLength << "\r\n";     out << "Content-Length: " << contentLength << "\r\n";
     out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";     out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";
     out << nn <<"\r\n";     out << nn <<"\r\n";
Line 275 
Line 1414 
 { {
     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
  
     out << "HTTP/1.1 200 OK\r\n";      out << "HTTP/1.1 " HTTP_STATUS_OK "\r\n";
     out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";      STAT_SERVERTIME
       out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";
     out << "Content-Length: " << contentLength << "\r\n";     out << "Content-Length: " << contentLength << "\r\n";
     out << "Ext:\r\n";     out << "Ext:\r\n";
     out << "Cache-Control: no-cache\r\n";     out << "Cache-Control: no-cache\r\n";
Line 287 
Line 1427 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
   // 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() // appendUnauthorizedResponseHeader()
 // //
 //     Build HTTP authentication response header for unauthorized requests. //     Build HTTP authentication response header for unauthorized requests.
Line 308 
Line 1483 
     Array<Sint8>& out,     Array<Sint8>& out,
     const String& content)     const String& content)
 { {
     out << "HTTP/1.1 401 Unauthorized\r\n";      out << "HTTP/1.1 " HTTP_STATUS_UNAUTHORIZED "\r\n";
     out << content << "\r\n";     out << content << "\r\n";
     out << "\r\n";     out << "\r\n";
  
Line 324 
Line 1499 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendMessageElementBegin()  // _appendMessageElementBegin()
 // appendMessageElementEnd()  // _appendMessageElementEnd()
 // //
 //     <!ELEMENT MESSAGE (SIMPLEREQ|MULTIREQ|SIMPLERSP|MULTIRSP)> //     <!ELEMENT MESSAGE (SIMPLEREQ|MULTIREQ|SIMPLERSP|MULTIRSP)>
 //     <!ATTLIST MESSAGE //     <!ATTLIST MESSAGE
Line 334 
Line 1509 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendMessageElementBegin(  void XmlWriter::_appendMessageElementBegin(
     Array<Sint8>& out,     Array<Sint8>& out,
     const String& messageId)     const String& messageId)
 { {
Line 343 
Line 1518 
     out << "<MESSAGE ID=\"" << messageId << "\" PROTOCOLVERSION=\"1.0\">\n";     out << "<MESSAGE ID=\"" << messageId << "\" PROTOCOLVERSION=\"1.0\">\n";
 } }
  
 void XmlWriter::appendMessageElementEnd(  void XmlWriter::_appendMessageElementEnd(
     Array<Sint8>& out)     Array<Sint8>& out)
 { {
     out << "</MESSAGE>\n";     out << "</MESSAGE>\n";
Line 352 
Line 1527 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendSimpleReqElementBegin()  // _appendSimpleReqElementBegin()
 // appendSimpleReqElementEnd()  // _appendSimpleReqElementEnd()
 // //
 //     <!ELEMENT SIMPLEREQ (IMETHODCALL|METHODCALL)> //     <!ELEMENT SIMPLEREQ (IMETHODCALL|METHODCALL)>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendSimpleReqElementBegin(  void XmlWriter::_appendSimpleReqElementBegin(
     Array<Sint8>& out)     Array<Sint8>& out)
 { {
     out << "<SIMPLEREQ>\n";     out << "<SIMPLEREQ>\n";
 } }
  
 void XmlWriter::appendSimpleReqElementEnd(  void XmlWriter::_appendSimpleReqElementEnd(
     Array<Sint8>& out)     Array<Sint8>& out)
 { {
     out << "</SIMPLEREQ>\n";     out << "</SIMPLEREQ>\n";
Line 373 
Line 1548 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendMethodCallElementBegin()  // _appendMethodCallElementBegin()
 // appendMethodCallElementEnd()  // _appendMethodCallElementEnd()
 // //
 //     <!ELEMENT METHODCALL ((LOCALCLASSPATH|LOCALINSTANCEPATH),PARAMVALUE*)> //     <!ELEMENT METHODCALL ((LOCALCLASSPATH|LOCALINSTANCEPATH),PARAMVALUE*)>
 //     <!ATTLIST METHODCALL %CIMName;> //     <!ATTLIST METHODCALL %CIMName;>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendMethodCallElementBegin(  void XmlWriter::_appendMethodCallElementBegin(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* name)     const char* name)
 { {
     out << "<METHODCALL NAME=\"" << name << "\">\n";     out << "<METHODCALL NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::appendMethodCallElementEnd(  void XmlWriter::_appendMethodCallElementEnd(
     Array<Sint8>& out)     Array<Sint8>& out)
 { {
     out << "</METHODCALL>\n";     out << "</METHODCALL>\n";
Line 396 
Line 1571 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendIMethodCallElementBegin()  // _appendIMethodCallElementBegin()
 // appendIMethodCallElementEnd()  // _appendIMethodCallElementEnd()
 // //
 //     <!ELEMENT IMETHODCALL (LOCALNAMESPACEPATH,IPARAMVALUE*)> //     <!ELEMENT IMETHODCALL (LOCALNAMESPACEPATH,IPARAMVALUE*)>
 //     <!ATTLIST IMETHODCALL %CIMName;> //     <!ATTLIST IMETHODCALL %CIMName;>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendIMethodCallElementBegin(  void XmlWriter::_appendIMethodCallElementBegin(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* name)     const char* name)
 { {
     out << "<IMETHODCALL NAME=\"" << name << "\">\n";     out << "<IMETHODCALL NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::appendIMethodCallElementEnd(  void XmlWriter::_appendIMethodCallElementEnd(
     Array<Sint8>& out)     Array<Sint8>& out)
 { {
     out << "</IMETHODCALL>\n";     out << "</IMETHODCALL>\n";
Line 419 
Line 1594 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendIParamValueElementBegin()  // _appendIParamValueElementBegin()
 // appendIParamValueElementEnd()  // _appendIParamValueElementEnd()
 // //
 //     <!ELEMENT IPARAMVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE //     <!ELEMENT IPARAMVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE
 //         |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION //         |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION
Line 429 
Line 1604 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendIParamValueElementBegin(  void XmlWriter::_appendIParamValueElementBegin(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* name)     const char* name)
 { {
     out << "<IPARAMVALUE NAME=\"" << name << "\">\n";     out << "<IPARAMVALUE NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::appendIParamValueElementEnd(  void XmlWriter::_appendIParamValueElementEnd(
     Array<Sint8>& out)     Array<Sint8>& out)
 { {
     out << "</IPARAMVALUE>\n";     out << "</IPARAMVALUE>\n";
Line 444 
Line 1619 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendSimpleRspElementBegin()  // _appendSimpleRspElementBegin()
 // appendSimpleRspElementEnd()  // _appendSimpleRspElementEnd()
 // //
 //     <!ELEMENT SIMPLERSP (METHODRESPONSE|IMETHODRESPONSE)> //     <!ELEMENT SIMPLERSP (METHODRESPONSE|IMETHODRESPONSE)>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendSimpleRspElementBegin(  void XmlWriter::_appendSimpleRspElementBegin(
     Array<Sint8>& out)     Array<Sint8>& out)
 { {
     out << "<SIMPLERSP>\n";     out << "<SIMPLERSP>\n";
 } }
  
 void XmlWriter::appendSimpleRspElementEnd(  void XmlWriter::_appendSimpleRspElementEnd(
     Array<Sint8>& out)     Array<Sint8>& out)
 { {
     out << "</SIMPLERSP>\n";     out << "</SIMPLERSP>\n";
Line 465 
Line 1640 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendMethodResponseElementBegin()  // _appendMethodResponseElementBegin()
 // appendMethodResponseElementEnd()  // _appendMethodResponseElementEnd()
 // //
 //     <!ELEMENT METHODRESPONSE (ERROR|IRETURNVALUE?)> //     <!ELEMENT METHODRESPONSE (ERROR|IRETURNVALUE?)>
 //     <!ATTLIST METHODRESPONSE %CIMName;> //     <!ATTLIST METHODRESPONSE %CIMName;>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendMethodResponseElementBegin(  void XmlWriter::_appendMethodResponseElementBegin(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* name)     const char* name)
 { {
     out << "<METHODRESPONSE NAME=\"" << name << "\">\n";     out << "<METHODRESPONSE NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::appendMethodResponseElementEnd(  void XmlWriter::_appendMethodResponseElementEnd(
     Array<Sint8>& out)     Array<Sint8>& out)
 { {
     out << "</METHODRESPONSE>\n";     out << "</METHODRESPONSE>\n";
Line 488 
Line 1663 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendIMethodResponseElementBegin()  // _appendIMethodResponseElementBegin()
 // appendIMethodResponseElementEnd()  // _appendIMethodResponseElementEnd()
 // //
 //     <!ELEMENT IMETHODRESPONSE (ERROR|IRETURNVALUE?)> //     <!ELEMENT IMETHODRESPONSE (ERROR|IRETURNVALUE?)>
 //     <!ATTLIST IMETHODRESPONSE %CIMName;> //     <!ATTLIST IMETHODRESPONSE %CIMName;>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendIMethodResponseElementBegin(  void XmlWriter::_appendIMethodResponseElementBegin(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* name)     const char* name)
 { {
     out << "<IMETHODRESPONSE NAME=\"" << name << "\">\n";     out << "<IMETHODRESPONSE NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::appendIMethodResponseElementEnd(  void XmlWriter::_appendIMethodResponseElementEnd(
     Array<Sint8>& out)     Array<Sint8>& out)
 { {
     out << "</IMETHODRESPONSE>\n";     out << "</IMETHODRESPONSE>\n";
Line 511 
Line 1686 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendErrorElement()  // _appendErrorElement()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendErrorElement(  void XmlWriter::_appendErrorElement(
     Array<Sint8>& out,     Array<Sint8>& out,
     CIMStatusCode code,      const CIMException& cimException)
     const char* description)  
 { {
       PEG_TRACE_STRING(TRC_XML_WRITER, Tracer::LEVEL2,
                        cimException.getTraceDescription());
   
     out << "<ERROR";     out << "<ERROR";
     out << " CODE=\"" << Uint32(code) << "\"";      out << " CODE=\"" << Uint32(cimException.getCode()) << "\"";
       String description = cimException.getDescription();
       if (description != String::EMPTY)
       {
     out << " DESCRIPTION=\"";     out << " DESCRIPTION=\"";
     appendSpecial(out, description);     appendSpecial(out, description);
     out << "\"/>";          out << "\"";
       }
       out << "/>";
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 544 
Line 1726 
     out << "<RETURNVALUE";     out << "<RETURNVALUE";
  
     CIMType type = value.getType();     CIMType type = value.getType();
     if (type != CIMType::NONE)      if (type != CIMTYPE_NONE)
     {     {
         out << " PARAMTYPE=\"" << TypeToString(type) << "\"";          out << " PARAMTYPE=\"" << cimTypeToString (type) << "\"";
     }     }
  
     out << ">\n";     out << ">\n";
     value.toXml(out);  
       // Add value.
       appendValueElement(out, value);
     out << "</RETURNVALUE>\n";     out << "</RETURNVALUE>\n";
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendIReturnValueElementBegin()  // _appendIReturnValueElementBegin()
 // appendIReturnValueElementEnd()  // _appendIReturnValueElementEnd()
 // //
 //      <!ELEMENT IRETURNVALUE (CLASSNAME*|INSTANCENAME*|VALUE*| //      <!ELEMENT IRETURNVALUE (CLASSNAME*|INSTANCENAME*|VALUE*|
 //          VALUE.OBJECTWITHPATH*|VALUE.OBJECTWITHLOCALPATH*|VALUE.OBJECT*| //          VALUE.OBJECTWITHPATH*|VALUE.OBJECTWITHLOCALPATH*|VALUE.OBJECT*|
Line 566 
Line 1750 
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendIReturnValueElementBegin(  void XmlWriter::_appendIReturnValueElementBegin(
     Array<Sint8>& out)     Array<Sint8>& out)
 { {
     out << "<IRETURNVALUE>\n";     out << "<IRETURNVALUE>\n";
 } }
  
 void XmlWriter::appendIReturnValueElementEnd(  void XmlWriter::_appendIReturnValueElementEnd(
     Array<Sint8>& out)     Array<Sint8>& out)
 { {
     out << "</IRETURNVALUE>\n";     out << "</IRETURNVALUE>\n";
Line 589 
Line 1773 
     const char* name,     const char* name,
     Boolean flag)     Boolean flag)
 { {
     appendIParamValueElementBegin(out, name);      _appendIParamValueElementBegin(out, name);
     out << "<VALUE>" << (flag ? "TRUE" : "FALSE") << "</VALUE>\n";      out << "<VALUE>";
     appendIParamValueElementEnd(out);      append(out, flag);
       out << "</VALUE>\n";
       _appendIParamValueElementEnd(out);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 605 
Line 1791 
     const char* name,     const char* name,
     const String& str)     const String& str)
 { {
     appendIParamValueElementBegin(out, name);      _appendIParamValueElementBegin(out, name);
     out << "<VALUE>";     out << "<VALUE>";
     appendSpecial(out, str);     appendSpecial(out, str);
     out << "</VALUE>\n";     out << "</VALUE>\n";
     appendIParamValueElementEnd(out);      _appendIParamValueElementEnd(out);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 631 
Line 1817 
     // as an IPARAMVALUE element according to the spec (look above). So we     // as an IPARAMVALUE element according to the spec (look above). So we
     // just pass it as a class name. An answer must be obtained later.     // just pass it as a class name. An answer must be obtained later.
  
     appendIParamValueElementBegin(out, name);      _appendIParamValueElementBegin(out, name);
     appendClassNameElement(out, qualifierName);     appendClassNameElement(out, qualifierName);
     appendIParamValueElementEnd(out);      _appendIParamValueElementEnd(out);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 647 
Line 1833 
     const char* name,     const char* name,
     const String& className)     const String& className)
 { {
     appendIParamValueElementBegin(out, name);      _appendIParamValueElementBegin(out, name);
     appendClassNameElement(out, className);     appendClassNameElement(out, className);
     appendIParamValueElementEnd(out);      _appendIParamValueElementEnd(out);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 661 
Line 1847 
 void XmlWriter::appendInstanceNameIParameter( void XmlWriter::appendInstanceNameIParameter(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* name,     const char* name,
     const CIMReference& instanceName)      const CIMObjectPath& instanceName)
 { {
     appendIParamValueElementBegin(out, name);      _appendIParamValueElementBegin(out, name);
     instanceName.instanceNameToXml(out);      appendInstanceNameElement(out, instanceName);
     appendIParamValueElementEnd(out);      _appendIParamValueElementEnd(out);
 } }
  
 void XmlWriter::appendObjectNameIParameter( void XmlWriter::appendObjectNameIParameter(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* name,     const char* name,
     const CIMReference& objectName)      const CIMObjectPath& objectName)
 { {
     if (objectName.isClassName())     if (objectName.isClassName())
     {     {
Line 696 
Line 1882 
     const char* name,     const char* name,
     const CIMConstClass& cimClass)     const CIMConstClass& cimClass)
 { {
     appendIParamValueElementBegin(out, name);      _appendIParamValueElementBegin(out, name);
     cimClass.toXml(out);      appendClassElement(out, cimClass);
     appendIParamValueElementEnd(out);      _appendIParamValueElementEnd(out);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 712 
Line 1898 
     const char* name,     const char* name,
     const CIMConstInstance& instance)     const CIMConstInstance& instance)
 { {
     appendIParamValueElementBegin(out, name);      _appendIParamValueElementBegin(out, name);
     instance.toXml(out);      appendInstanceElement(out, instance);
     appendIParamValueElementEnd(out);      _appendIParamValueElementEnd(out);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 726 
Line 1912 
 void XmlWriter::appendNamedInstanceIParameter( void XmlWriter::appendNamedInstanceIParameter(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* name,     const char* name,
     const CIMNamedInstance& namedInstance)      const CIMInstance& namedInstance)
 { {
     appendIParamValueElementBegin(out, name);      _appendIParamValueElementBegin(out, name);
     namedInstance.toXml(out);      appendValueNamedInstanceElement(out, namedInstance);
     appendIParamValueElementEnd(out);      _appendIParamValueElementEnd(out);
 } }
  
 //---------------------------------------------------------- //----------------------------------------------------------
Line 746 
Line 1932 
     Array<Sint8>& out,     Array<Sint8>& out,
     const String& propertyName)     const String& propertyName)
 { {
     appendIParamValueElementBegin(out, "PropertyName");      _appendIParamValueElementBegin(out, "PropertyName");
     out << "<VALUE>" << propertyName << "</VALUE>\n";     out << "<VALUE>" << propertyName << "</VALUE>\n";
     appendIParamValueElementEnd(out);      _appendIParamValueElementEnd(out);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 762 
Line 1948 
     const char* name,     const char* name,
     const CIMValue& value)     const CIMValue& value)
 { {
     appendIParamValueElementBegin(out, name);      _appendIParamValueElementBegin(out, name);
     value.toXml(out);      appendValueElement(out, value);
     appendIParamValueElementEnd(out);      _appendIParamValueElementEnd(out);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 777 
Line 1963 
     Array<Sint8>& out,     Array<Sint8>& out,
     const CIMPropertyList& propertyList)     const CIMPropertyList& propertyList)
 { {
     appendIParamValueElementBegin(out, "PropertyList");      // ATTN: P3 KS 4 Mar 2002 - As check shouldn't we check for null property list
       _appendIParamValueElementBegin(out, "PropertyList");
  
     out << "<VALUE.ARRAY>\n";     out << "<VALUE.ARRAY>\n";
     for (Uint32 i = 0; i < propertyList.getNumProperties(); i++)      for (Uint32 i = 0; i < propertyList.size(); i++)
     {     {
         out << "<VALUE>" << propertyList.getPropertyName(i) << "</VALUE>\n";          out << "<VALUE>" << propertyList[i] << "</VALUE>\n";
     }     }
     out << "</VALUE.ARRAY>\n";     out << "</VALUE.ARRAY>\n";
  
     appendIParamValueElementEnd(out);      _appendIParamValueElementEnd(out);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 800 
Line 1987 
     const char* name,     const char* name,
     const CIMConstQualifierDecl& qualifierDecl)     const CIMConstQualifierDecl& qualifierDecl)
 { {
     appendIParamValueElementBegin(out, name);      _appendIParamValueElementBegin(out, name);
     qualifierDecl.toXml(out);      appendQualifierDeclElement(out, qualifierDecl);
     appendIParamValueElementEnd(out);      _appendIParamValueElementEnd(out);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendClassNameElement()  // XmlWriter::formatHttpErrorRspMessage()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendClassNameElement(  Array<Sint8> XmlWriter::formatHttpErrorRspMessage(
     Array<Sint8>& out,      const String& status,
     const String& className)      const String& cimError,
       const String& errorDetail)
 { {
     out << "<CLASSNAME NAME=\"" << className << "\"/>\n";      Array<Sint8> out;
 }  
  
 //------------------------------------------------------------------------------      appendHttpErrorResponseHeader(out, status, cimError, errorDetail);
 //  
 // appendInstanceNameElement()  
 //  
 //------------------------------------------------------------------------------  
  
 void XmlWriter::appendInstanceNameElement(      return out;
     Array<Sint8>& out,  
     const CIMReference& instanceName)  
 {  
     instanceName.instanceNameToXml(out);  
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 841 
Line 2020 
 Array<Sint8> XmlWriter::formatSimpleMethodReqMessage( Array<Sint8> XmlWriter::formatSimpleMethodReqMessage(
     const char* host,     const char* host,
     const String& nameSpace,     const String& nameSpace,
       const CIMObjectPath& path,
     const char* methodName,     const char* methodName,
       const Array<CIMParamValue>& parameters,
     const String& messageId,     const String& messageId,
     const String& authenticationHeader,      const String& authenticationHeader)
     const Array<Sint8>& body)  
 { {
     Array<Sint8> out;     Array<Sint8> out;
     Array<Sint8> tmp;     Array<Sint8> tmp;
       CIMObjectPath localObjectPath = path;
       localObjectPath.setNameSpace(nameSpace);
  
     appendMessageElementBegin(out, messageId);      _appendMessageElementBegin(out, messageId);
     appendSimpleReqElementBegin(out);      _appendSimpleReqElementBegin(out);
     appendMethodCallElementBegin(out, methodName);      _appendMethodCallElementBegin(out, methodName);
 //    appendLocalPathElement(out, nameSpace); // ATTN-RK-P1-20020228:  Need this      appendLocalObjectPathElement(out, localObjectPath);
     out << body;      for (Uint32 i=0; i < parameters.size(); i++)
     appendMethodCallElementEnd(out);      {
     appendSimpleReqElementEnd(out);          appendParamValueElement(out, parameters[i]);
     appendMessageElementEnd(out);      }
       _appendMethodCallElementEnd(out);
       _appendSimpleReqElementEnd(out);
       _appendMessageElementEnd(out);
  
     appendMethodCallHeader(     appendMethodCallHeader(
         tmp,         tmp,
         host,         host,
         methodName,         methodName,
         nameSpace,  // ATTN-RK: Is this right?          localObjectPath.toString(false),
         authenticationHeader,         authenticationHeader,
         out.size());         out.size());
     tmp << out;     tmp << out;
Line 878 
Line 2063 
     Array<Sint8> out;     Array<Sint8> out;
     Array<Sint8> tmp;     Array<Sint8> tmp;
  
     appendMessageElementBegin(out, messageId);      _appendMessageElementBegin(out, messageId);
     appendSimpleRspElementBegin(out);      _appendSimpleRspElementBegin(out);
     appendMethodResponseElementBegin(out, methodName);      _appendMethodResponseElementBegin(out, methodName);
     out << body;     out << body;
     appendMethodResponseElementEnd(out);      _appendMethodResponseElementEnd(out);
     appendSimpleRspElementEnd(out);      _appendSimpleRspElementEnd(out);
     appendMessageElementEnd(out);      _appendMessageElementEnd(out);
  
     appendMethodResponseHeader(tmp, out.size());     appendMethodResponseHeader(tmp, out.size());
     tmp << out;     tmp << out;
Line 901 
Line 2086 
 Array<Sint8> XmlWriter::formatSimpleMethodErrorRspMessage( Array<Sint8> XmlWriter::formatSimpleMethodErrorRspMessage(
     const String& methodName,     const String& methodName,
     const String& messageId,     const String& messageId,
     CIMStatusCode code,      const CIMException& cimException)
     const String& description)  
 { {
     ArrayDestroyer<char> tmp1(methodName.allocateCString());     ArrayDestroyer<char> tmp1(methodName.allocateCString());
     ArrayDestroyer<char> tmp2(description.allocateCString());  
     Array<Sint8> out;     Array<Sint8> out;
     Array<Sint8> tmp;     Array<Sint8> tmp;
  
     appendMessageElementBegin(out, messageId);      _appendMessageElementBegin(out, messageId);
     appendSimpleRspElementBegin(out);      _appendSimpleRspElementBegin(out);
     appendMethodResponseElementBegin(out, tmp1.getPointer());      _appendMethodResponseElementBegin(out, tmp1.getPointer());
     appendErrorElement(out, code, tmp2.getPointer());      _appendErrorElement(out, cimException);
     appendMethodResponseElementEnd(out);      _appendMethodResponseElementEnd(out);
     appendSimpleRspElementEnd(out);      _appendSimpleRspElementEnd(out);
     appendMessageElementEnd(out);      _appendMessageElementEnd(out);
  
     appendMethodResponseHeader(tmp, out.size());     appendMethodResponseHeader(tmp, out.size());
     tmp << out;     tmp << out;
Line 940 
Line 2123 
     Array<Sint8> out;     Array<Sint8> out;
     Array<Sint8> tmp;     Array<Sint8> tmp;
  
     appendMessageElementBegin(out, messageId);      _appendMessageElementBegin(out, messageId);
     appendSimpleReqElementBegin(out);      _appendSimpleReqElementBegin(out);
     appendIMethodCallElementBegin(out, iMethodName);      _appendIMethodCallElementBegin(out, iMethodName);
     appendLocalNameSpaceElement(out, nameSpace);      appendLocalNameSpacePathElement(out, nameSpace);
     out << body;     out << body;
     appendIMethodCallElementEnd(out);      _appendIMethodCallElementEnd(out);
     appendSimpleReqElementEnd(out);      _appendSimpleReqElementEnd(out);
     appendMessageElementEnd(out);      _appendMessageElementEnd(out);
  
     appendMethodCallHeader(     appendMethodCallHeader(
         tmp,         tmp,
Line 975 
Line 2158 
     Array<Sint8> out;     Array<Sint8> out;
     Array<Sint8> tmp;     Array<Sint8> tmp;
  
     appendMessageElementBegin(out, messageId);      _appendMessageElementBegin(out, messageId);
     appendSimpleRspElementBegin(out);      _appendSimpleRspElementBegin(out);
     appendIMethodResponseElementBegin(out, iMethodName);      _appendIMethodResponseElementBegin(out, iMethodName);
     appendIReturnValueElementBegin(out);      if (body.size() != 0)
       {
           _appendIReturnValueElementBegin(out);
     out << body;     out << body;
     appendIReturnValueElementEnd(out);          _appendIReturnValueElementEnd(out);
     appendIMethodResponseElementEnd(out);      }
     appendSimpleRspElementEnd(out);      _appendIMethodResponseElementEnd(out);
     appendMessageElementEnd(out);      _appendSimpleRspElementEnd(out);
       _appendMessageElementEnd(out);
  
     appendMethodResponseHeader(tmp, out.size());     appendMethodResponseHeader(tmp, out.size());
     tmp << out;     tmp << out;
Line 1000 
Line 2186 
 Array<Sint8> XmlWriter::formatSimpleIMethodErrorRspMessage( Array<Sint8> XmlWriter::formatSimpleIMethodErrorRspMessage(
     const String& iMethodName,     const String& iMethodName,
     const String& messageId,     const String& messageId,
     CIMStatusCode code,      const CIMException& cimException)
     const String& description)  
 { {
     ArrayDestroyer<char> tmp1(iMethodName.allocateCString());     ArrayDestroyer<char> tmp1(iMethodName.allocateCString());
     ArrayDestroyer<char> tmp2(description.allocateCString());  
     Array<Sint8> out;     Array<Sint8> out;
     Array<Sint8> tmp;     Array<Sint8> tmp;
  
     appendMessageElementBegin(out, messageId);      _appendMessageElementBegin(out, messageId);
     appendSimpleRspElementBegin(out);      _appendSimpleRspElementBegin(out);
     appendIMethodResponseElementBegin(out, tmp1.getPointer());      _appendIMethodResponseElementBegin(out, tmp1.getPointer());
     appendErrorElement(out, code, tmp2.getPointer());      _appendErrorElement(out, cimException);
     appendIMethodResponseElementEnd(out);      _appendIMethodResponseElementEnd(out);
     appendSimpleRspElementEnd(out);      _appendSimpleRspElementEnd(out);
     appendMessageElementEnd(out);      _appendMessageElementEnd(out);
  
     appendMethodResponseHeader(tmp, out.size());     appendMethodResponseHeader(tmp, out.size());
     tmp << out;     tmp << out;
Line 1038 
Line 2222 
  
 void XmlWriter::appendEMethodRequestHeader( void XmlWriter::appendEMethodRequestHeader(
     Array<Sint8>& out,     Array<Sint8>& out,
       const char* requestUri,
     const char* host,     const char* host,
     const char* cimMethod,     const char* cimMethod,
     const String& authenticationHeader,     const String& authenticationHeader,
Line 1045 
Line 2230 
 { {
     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
  
     out << "M-POST /cimom HTTP/1.1\r\n";      out << "M-POST " << requestUri << " HTTP/1.1\r\n";
     out << "HOST: " << host << "\r\n";     out << "HOST: " << host << "\r\n";
     out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";      out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";
     out << "Content-Length: " << contentLength << "\r\n";     out << "Content-Length: " << contentLength << "\r\n";
     out << "Man: http://www.hp.com; ns=";     out << "Man: http://www.hp.com; ns=";
     out << nn <<"\r\n";     out << nn <<"\r\n";
     out << nn << "-CIMExport: MethodRequest\r\n";  // ATTN-RK-P2-20020228: Should this be "MethodCall"?      out << nn << "-CIMExport: MethodRequest\r\n";
     out << nn << "-CIMExportMethod: " << cimMethod << "\r\n";     out << nn << "-CIMExportMethod: " << cimMethod << "\r\n";
     if (authenticationHeader.size())     if (authenticationHeader.size())
     {     {
Line 1074 
Line 2259 
 { {
     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };     char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
  
     out << "HTTP/1.1 200 OK\r\n";      out << "HTTP/1.1 " HTTP_STATUS_OK "\r\n";
     out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";      out << "Content-Type: application/xml; charset=\"utf-8\"\r\n";
     out << "Content-Length: " << contentLength << "\r\n";     out << "Content-Length: " << contentLength << "\r\n";
     out << "Ext:\r\n";     out << "Ext:\r\n";
     out << "Cache-Control: no-cache\r\n";     out << "Cache-Control: no-cache\r\n";
Line 1086 
Line 2271 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendSimpleExportReqElementBegin()  // _appendSimpleExportReqElementBegin()
 // appendSimpleExportReqElementEnd()  // _appendSimpleExportReqElementEnd()
 // //
 //     <!ELEMENT SIMPLEEXPREQ (EXPMETHODCALL)> //     <!ELEMENT SIMPLEEXPREQ (EXPMETHODCALL)>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendSimpleExportReqElementBegin(  void XmlWriter::_appendSimpleExportReqElementBegin(
     Array<Sint8>& out)     Array<Sint8>& out)
 { {
     out << "<SIMPLEEXPREQ>\n";     out << "<SIMPLEEXPREQ>\n";
 } }
  
 void XmlWriter::appendSimpleExportReqElementEnd(  void XmlWriter::_appendSimpleExportReqElementEnd(
     Array<Sint8>& out)     Array<Sint8>& out)
 { {
     out << "</SIMPLEEXPREQ>\n";     out << "</SIMPLEEXPREQ>\n";
Line 1107 
Line 2292 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendEMethodCallElementBegin()  // _appendEMethodCallElementBegin()
 // appendEMethodCallElementEnd()  // _appendEMethodCallElementEnd()
 // //
 //     <!ELEMENT EXPMETHODCALL (IPARAMVALUE*)> //     <!ELEMENT EXPMETHODCALL (IPARAMVALUE*)>
 //     <!ATTLIST EXPMETHODCALL %CIMName;> //     <!ATTLIST EXPMETHODCALL %CIMName;>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendEMethodCallElementBegin(  void XmlWriter::_appendEMethodCallElementBegin(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* name)     const char* name)
 { {
     out << "<EXPMETHODCALL NAME=\"" << name << "\">\n";     out << "<EXPMETHODCALL NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::appendEMethodCallElementEnd(  void XmlWriter::_appendEMethodCallElementEnd(
     Array<Sint8>& out)     Array<Sint8>& out)
 { {
     out << "</EXPMETHODCALL>\n";     out << "</EXPMETHODCALL>\n";
Line 1130 
Line 2315 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendSimpleExportRspElementBegin()  // _appendSimpleExportRspElementBegin()
 // appendSimpleExportRspElementEnd()  // _appendSimpleExportRspElementEnd()
 // //
 //     <!ELEMENT SIMPLEEXPRSP (EXPMETHODRESPONSE)> //     <!ELEMENT SIMPLEEXPRSP (EXPMETHODRESPONSE)>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendSimpleExportRspElementBegin(  void XmlWriter::_appendSimpleExportRspElementBegin(
     Array<Sint8>& out)     Array<Sint8>& out)
 { {
     out << "<SIMPLEEXPRSP>\n";     out << "<SIMPLEEXPRSP>\n";
 } }
  
 void XmlWriter::appendSimpleExportRspElementEnd(  void XmlWriter::_appendSimpleExportRspElementEnd(
     Array<Sint8>& out)     Array<Sint8>& out)
 { {
     out << "</SIMPLEEXPRSP>\n";     out << "</SIMPLEEXPRSP>\n";
Line 1151 
Line 2336 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // formatEMethodResponseElement()  // _appendEMethodResponseElementBegin()
   // _appendEMethodResponseElementEnd()
 // //
 //     <!ELEMENT EXPMETHODRESPONSE (ERROR|IRETURNVALUE?)> //     <!ELEMENT EXPMETHODRESPONSE (ERROR|IRETURNVALUE?)>
 //     <!ATTLIST EXPMETHODRESPONSE %CIMName;> //     <!ATTLIST EXPMETHODRESPONSE %CIMName;>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendEMethodResponseElementBegin(  void XmlWriter::_appendEMethodResponseElementBegin(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* name)     const char* name)
 { {
     out << "<EXPMETHODRESPONSE NAME=\"" << name << "\">\n";     out << "<EXPMETHODRESPONSE NAME=\"" << name << "\">\n";
 } }
  
 void XmlWriter::appendEMethodResponseElementEnd(  void XmlWriter::_appendEMethodResponseElementEnd(
     Array<Sint8>& out)     Array<Sint8>& out)
 { {
     out << "</EXPMETHODRESPONSE>\n";     out << "</EXPMETHODRESPONSE>\n";
Line 1178 
Line 2364 
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleEMethodReqMessage( Array<Sint8> XmlWriter::formatSimpleEMethodReqMessage(
       const char* requestUri,
     const char* host,     const char* host,
     const char* eMethodName,     const char* eMethodName,
     const String& messageId,     const String& messageId,
Line 1187 
Line 2374 
     Array<Sint8> out;     Array<Sint8> out;
     Array<Sint8> tmp;     Array<Sint8> tmp;
  
     appendMessageElementBegin(out, messageId);      _appendMessageElementBegin(out, messageId);
     appendSimpleExportReqElementBegin(out);      _appendSimpleExportReqElementBegin(out);
     appendEMethodCallElementBegin(out, eMethodName);      _appendEMethodCallElementBegin(out, eMethodName);
     out << body;     out << body;
     appendEMethodCallElementEnd(out);      _appendEMethodCallElementEnd(out);
     appendSimpleExportReqElementEnd(out);      _appendSimpleExportReqElementEnd(out);
     appendMessageElementEnd(out);      _appendMessageElementEnd(out);
  
     appendEMethodRequestHeader(     appendEMethodRequestHeader(
         tmp,         tmp,
           requestUri,
         host,         host,
         eMethodName,         eMethodName,
         authenticationHeader,         authenticationHeader,
         out.size());         out.size());
     tmp << out;     tmp << out;
  
     return out;      return tmp;
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 1220 
Line 2408 
     Array<Sint8> out;     Array<Sint8> out;
     Array<Sint8> tmp;     Array<Sint8> tmp;
  
     appendMessageElementBegin(out, messageId);      _appendMessageElementBegin(out, messageId);
     appendSimpleExportRspElementBegin(out);      _appendSimpleExportRspElementBegin(out);
     appendEMethodResponseElementBegin(out, eMethodName);      _appendEMethodResponseElementBegin(out, eMethodName);
     out << body;     out << body;
     appendEMethodResponseElementEnd(out);      _appendEMethodResponseElementEnd(out);
     appendSimpleExportRspElementEnd(out);      _appendSimpleExportRspElementEnd(out);
     appendMessageElementEnd(out);      _appendMessageElementEnd(out);
  
     appendEMethodResponseHeader(tmp, out.size());     appendEMethodResponseHeader(tmp, out.size());
     tmp << out;     tmp << out;
Line 1243 
Line 2431 
 Array<Sint8> XmlWriter::formatSimpleEMethodErrorRspMessage( Array<Sint8> XmlWriter::formatSimpleEMethodErrorRspMessage(
     const String& eMethodName,     const String& eMethodName,
     const String& messageId,     const String& messageId,
     CIMStatusCode code,      const CIMException& cimException)
     const String& description)  
 { {
     ArrayDestroyer<char> tmp1(eMethodName.allocateCString());     ArrayDestroyer<char> tmp1(eMethodName.allocateCString());
     ArrayDestroyer<char> tmp2(description.allocateCString());  
     Array<Sint8> out;     Array<Sint8> out;
     Array<Sint8> tmp;     Array<Sint8> tmp;
  
     appendMessageElementBegin(out, messageId);      _appendMessageElementBegin(out, messageId);
     appendSimpleExportRspElementBegin(out);      _appendSimpleExportRspElementBegin(out);
     appendEMethodResponseElementBegin(out, tmp1.getPointer());      _appendEMethodResponseElementBegin(out, tmp1.getPointer());
     appendErrorElement(out, code, tmp2.getPointer());      _appendErrorElement(out, cimException);
     appendEMethodResponseElementEnd(out);      _appendEMethodResponseElementEnd(out);
     appendSimpleExportRspElementEnd(out);      _appendSimpleExportRspElementEnd(out);
     appendMessageElementEnd(out);      _appendMessageElementEnd(out);
  
     appendEMethodResponseHeader(tmp, out.size());     appendEMethodResponseHeader(tmp, out.size());
     tmp << out;     tmp << out;

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