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

version 1.31, 2002/03/02 00:15: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, "%u", x);
       append(out, buffer);
   }
   
   void XmlWriter::append(Array<Sint8>& out, Sint32 x)
   {
       char buffer[32];
     sprintf(buffer, "%d", x);     sprintf(buffer, "%d", x);
     append(out, buffer);     append(out, buffer);
 } }
  
 void XmlWriter::append(Array<Sint8>& out, const char* str)  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)
 { {
     while (*str)      out << "<VALUE.OBJECTWITHPATH>\n";
         _appendChar(out, *str++);  
       appendValueReferenceElement(out, objectWithPath.getPath (), false);
       appendObjectElement(out, objectWithPath);
   
       out << "</VALUE.OBJECTWITHPATH>\n";
 } }
  
 void XmlWriter::append(Array<Sint8>& out, const String& str)  //------------------------------------------------------------------------------
   //
   // appendValueReferenceElement()
   //
   //    <!ELEMENT VALUE.REFERENCE
   //        (CLASSPATH|LOCALCLASSPATH|CLASSNAME|INSTANCEPATH|LOCALINSTANCEPATH|
   //         INSTANCENAME)>
   //
   //------------------------------------------------------------------------------
   
   void XmlWriter::appendValueReferenceElement(
       Array<Sint8>& out,
       const CIMObjectPath& reference,
       Boolean putValueWrapper)
 { {
     const Char16* tmp = str.getData();      if (putValueWrapper)
           out << "<VALUE.REFERENCE>\n";
  
     while (*tmp)      // See if it is a class or instance reference (instance references have
         _appendChar(out, *tmp++);      // key-bindings; class references do not).
 }  
  
 void XmlWriter::append(Array<Sint8>& out, const Indentor& x)      //KeyBindingArray kbs = reference.getKeyBindingArray();
       KeyBindingArray kbs = reference.getKeyBindings();
   
       if (kbs.size())
 { {
     for (Uint32 i = 0; i < 4 * x.getLevel(); i++)          if (reference.getHost().size())
         out.append(' ');          {
               appendInstancePathElement(out, reference);
 } }
           else if (!reference.getNameSpace().isNull())
 void XmlWriter::appendSpecial(Array<Sint8>& out, Char16 x)  
 { {
     _appendSpecialChar(out, x);              appendLocalInstancePathElement(out, reference);
 } }
           else
 void XmlWriter::appendSpecial(Array<Sint8>& out, char x)  
 { {
     _appendSpecialChar(out, Char16(x));              appendInstanceNameElement(out, reference);
 } }
       }
 void XmlWriter::appendSpecial(Array<Sint8>& out, const char* str)      else
 { {
     while (*str)          if (reference.getHost().size())
         _appendSpecialChar(out, *str++);          {
               appendClassPathElement(out, reference);
 } }
           else if (!reference.getNameSpace().isNull())
 void XmlWriter::appendSpecial(Array<Sint8>& out, const String& str)          {
               appendLocalClassPathElement(out, reference);
           }
           else
 { {
     const Char16* tmp = str.getData();              appendClassNameElement(out, reference.getClassName());
           }
       }
   
       if (putValueWrapper)
           out << "</VALUE.REFERENCE>\n";
   }
  
     while (*tmp)  void XmlWriter::printValueReferenceElement(
         _appendSpecialChar(out, *tmp++);      const CIMObjectPath& reference,
       PEGASUS_STD(ostream)& os)
   {
       Array<Sint8> tmp;
       appendValueReferenceElement(tmp, reference, true);
       tmp.append('\0');
       indentedPrint(os, tmp.getData());
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendLocalNameSpacePathElement()  // appendValueNamedInstanceElement()
 // //
 //     <!ELEMENT LOCALNAMESPACEPATH (NAMESPACE+)>  //     <!ELEMENT VALUE.NAMEDINSTANCE (INSTANCENAME,INSTANCE)>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendLocalNameSpacePathElement(  void XmlWriter::appendValueNamedInstanceElement(
     Array<Sint8>& out,     Array<Sint8>& out,
     const String& nameSpace)      const CIMInstance& namedInstance)
 { {
     out << "<LOCALNAMESPACEPATH>\n";      out << "<VALUE.NAMEDINSTANCE>\n";
  
     char* tmp = nameSpace.allocateCString();      appendInstanceNameElement(out, namedInstance.getPath ());
       appendInstanceElement(out, namedInstance);
  
     // ATTN-RK-P3-20020301: Is it necessary/helpful to break this into parts?      out << "</VALUE.NAMEDINSTANCE>\n";
     for (char* p = strtok(tmp, "/"); p; p = strtok(NULL, "/"))  
     {  
         out << "<NAMESPACE NAME=\"" << p << "\"/>\n";  
     }     }
  
     delete [] tmp;  //------------------------------------------------------------------------------
   //
   // appendClassElement()
   //
   //     <!ELEMENT CLASS
   //         (QUALIFIER*,(PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*,METHOD*)>
   //     <!ATTLIST CLASS
   //         %CIMName;
   //         %SuperClass;>
   //
   //------------------------------------------------------------------------------
  
     out << "</LOCALNAMESPACEPATH>\n";  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);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendNameSpacePathElement()  // appendInstanceElement()
 // //
 //     <!ELEMENT NAMESPACEPATH (HOST,LOCALNAMESPACEPATH)>  //     <!ELEMENT INSTANCE
   //         (QUALIFIER*,(PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*)>
   //     <!ATTLIST INSTANCE
   //         %ClassName;>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendNameSpacePathElement(  void XmlWriter::appendInstanceElement(
     Array<Sint8>& out,     Array<Sint8>& out,
     const String& host,      const CIMConstInstance& instance)
     const String& nameSpace)  
 { {
     out << "<NAMESPACEPATH>\n";      instance._checkRep();
     out << "<HOST>" << host << "</HOST>\n";      instance._rep->toXml(out);
     appendLocalNameSpacePathElement(out, nameSpace);  }
     out << "</NAMESPACEPATH>\n";  
   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);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendClassNameElement()  // appendObjectElement()
 // //
 //     <!ELEMENT CLASSNAME EMPTY>  // May refer to a CLASS or an INSTANCE
 //     <!ATTLIST CLASSNAME  
 //              %CIMName;>  
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendClassNameElement(  void XmlWriter::appendObjectElement(
     Array<Sint8>& out,     Array<Sint8>& out,
     const String& className)      const CIMConstObject& object)
 { {
     out << "<CLASSNAME NAME=\"" << className << "\"/>\n";      // 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);
           }
       }
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendInstanceNameElement()  // appendPropertyElement()
 // //
 //    <!ELEMENT INSTANCENAME (KEYBINDING*|KEYVALUE?|VALUE.REFERENCE?)>  //     <!ELEMENT PROPERTY (QUALIFIER*,VALUE?)>
 //    <!ATTLIST INSTANCENAME  //     <!ATTLIST PROPERTY
 //              %ClassName;>  //              %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::appendInstanceNameElement(  void XmlWriter::appendPropertyElement(
     Array<Sint8>& out,     Array<Sint8>& out,
     const CIMReference& instanceName)      const CIMConstProperty& property)
 { {
     out << "<INSTANCENAME CLASSNAME=\"" << instanceName.getClassName() << "\">\n";      property._checkRep();
       property._rep->toXml(out);
   }
  
     Array<KeyBinding> keyBindings = instanceName.getKeyBindings();  void XmlWriter::printPropertyElement(
     for (Uint32 i = 0, n = keyBindings.size(); i < n; i++)      const CIMConstProperty& property,
       PEGASUS_STD(ostream)& os)
     {     {
         out << "<KEYBINDING NAME=\"" << keyBindings[i].getName() << "\">\n";      Array<Sint8> tmp;
       appendPropertyElement(tmp, property);
       tmp.append('\0');
       os << tmp.getData() << PEGASUS_STD(endl);
   }
  
         if (keyBindings[i].getType() == KeyBinding::REFERENCE)  //------------------------------------------------------------------------------
   //
   // 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)
         {         {
             CIMReference ref = keyBindings[i].getValue();      method._checkRep();
             ref.toXml(out, true);      method._rep->toXml(out);
         }         }
         else {  
             out << "<KEYVALUE VALUETYPE=\"";  
             out << KeyBinding::typeToString(keyBindings[i].getType());  
             out << "\">";  
   
             // fixed the special character problem - Markus  
  
             appendSpecial(out, keyBindings[i].getValue());  void XmlWriter::printMethodElement(
             out << "</KEYVALUE>\n";      const CIMConstMethod& method,
       PEGASUS_STD(ostream)& os)
   {
       Array<Sint8> tmp;
       appendMethodElement(tmp, method);
       tmp.append('\0');
       os << tmp.getData() << PEGASUS_STD(endl);
         }         }
         out << "</KEYBINDING>\n";  
   //------------------------------------------------------------------------------
   //
   // 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);
     }     }
     out << "</INSTANCENAME>\n";  
   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);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendClassPathElement()  // appendParamValueElement()
 // //
 //     <!ELEMENT CLASSPATH (NAMESPACEPATH,CLASSNAME)>  //     <!ELEMENT PARAMVALUE (VALUE|VALUE.REFERENCE|VALUE.ARRAY|VALUE.REFARRAY)?>
   //     <!ATTLIST PARAMVALUE
   //              %CIMName;>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendClassPathElement(  void XmlWriter::appendParamValueElement(
     Array<Sint8>& out,     Array<Sint8>& out,
     const CIMReference& classPath)      const CIMParamValue& paramValue)
 { {
     out << "<CLASSPATH>\n";      paramValue._checkRep();
     appendNameSpacePathElement(out,      paramValue._rep->toXml(out);
                                classPath.getHost(),  }
                                classPath.getNameSpace());  
     appendClassNameElement(out, classPath.getClassName());  void XmlWriter::printParamValueElement(
     out << "</CLASSPATH>\n";      const CIMParamValue& paramValue,
       PEGASUS_STD(ostream)& os)
   {
       Array<Sint8> tmp;
       appendParamValueElement(tmp, paramValue);
       tmp.append('\0');
       os << tmp.getData() << PEGASUS_STD(endl);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendInstancePathElement()  // appendQualifierElement()
 // //
 //     <!ELEMENT INSTANCEPATH (NAMESPACEPATH,INSTANCENAME)>  //     <!ELEMENT QUALIFIER (VALUE|VALUE.ARRAY)>
   //     <!ATTLIST QUALIFIER
   //              %CIMName;
   //              %CIMType;               #REQUIRED
   //              %Propagated;
   //              %QualifierFlavor;>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendInstancePathElement(  void XmlWriter::appendQualifierElement(
     Array<Sint8>& out,     Array<Sint8>& out,
     const CIMReference& instancePath)      const CIMConstQualifier& qualifier)
 { {
     out << "<INSTANCEPATH>\n";      qualifier._checkRep();
     appendNameSpacePathElement(out,      qualifier._rep->toXml(out);
                                instancePath.getHost(),  }
                                instancePath.getNameSpace());  
     appendInstanceNameElement(out, instancePath);  void XmlWriter::printQualifierElement(
     out << "</INSTANCEPATH>\n";      const CIMConstQualifier& qualifier,
       PEGASUS_STD(ostream)& os)
   {
       Array<Sint8> tmp;
       appendQualifierElement(tmp, qualifier);
       tmp.append('\0');
       os << tmp.getData() << PEGASUS_STD(endl);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendLocalClassPathElement()  // appendQualifierDeclElement()
 // //
 //     <!ELEMENT LOCALCLASSPATH (LOCALNAMESPACEPATH, CLASSNAME)>  //     <!ELEMENT QUALIFIER.DECLARATION (SCOPE?,(VALUE|VALUE.ARRAY)?)>
   //     <!ATTLIST QUALIFIER.DECLARATION
   //              %CIMName;
   //              %CIMType;                       #REQUIRED
   //              ISARRAY        (true|false)     #IMPLIED
   //              %ArraySize;
   //              %QualifierFlavor;>
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendLocalClassPathElement(  void XmlWriter::appendQualifierDeclElement(
     Array<Sint8>& out,     Array<Sint8>& out,
     const CIMReference& classPath)      const CIMConstQualifierDecl& qualifierDecl)
 { {
     out << "<LOCALCLASSPATH>\n";      qualifierDecl._checkRep();
     appendLocalNameSpacePathElement(out, classPath.getNameSpace());      qualifierDecl._rep->toXml(out);
     appendClassNameElement(out, classPath.getClassName());  }
     out << "</LOCALCLASSPATH>\n";  
   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);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendLocalInstancePathElement()  // appendQualifierFlavorEntity()
 // //
 //     <!ELEMENT LOCALINSTANCEPATH (LOCALNAMESPACEPATH, INSTANCENAME)>  //     <!ENTITY % QualifierFlavor "OVERRIDABLE  (true|false)   'true'
   //                                 TOSUBCLASS   (true|false)   'true'
   //                                 TOINSTANCE   (true|false)   'false'
   //                                 TRANSLATABLE (true|false)   'false'">
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 void XmlWriter::appendLocalInstancePathElement(  void XmlWriter::appendQualifierFlavorEntity(
     Array<Sint8>& out,     Array<Sint8>& out,
     const CIMReference& instancePath)      Uint32 flavor)
 { {
     out << "<LOCALINSTANCEPATH>\n";      if (!(flavor & CIMFlavor::OVERRIDABLE))
     appendLocalNameSpacePathElement(out, instancePath.getNameSpace());          out << " OVERRIDABLE=\"false\"";
     appendInstanceNameElement(out, instancePath);  
     out << "</LOCALINSTANCEPATH>\n";      if (!(flavor & CIMFlavor::TOSUBCLASS))
           out << " TOSUBCLASS=\"false\"";
   
       if (flavor & CIMFlavor::TOINSTANCE)
           out << " TOINSTANCE=\"true\"";
   
       if (flavor & CIMFlavor::TRANSLATABLE)
           out << " TRANSLATABLE=\"true\"";
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendLocalObjectPathElement()  // appendScopeElement()
 // //
 //     If the reference refers to an instance, write a LOCALINSTANCEPATH;  //     <!ELEMENT SCOPE EMPTY>
 //     otherwise write a LOCALCLASSPATH.  //     <!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::appendLocalObjectPathElement(  void XmlWriter::appendScopeElement(
     Array<Sint8>& out,     Array<Sint8>& out,
     const CIMReference& objectPath)      Uint32 scope)
 {  
     if (objectPath.isInstanceName())  
     {     {
         appendLocalInstancePathElement(out, objectPath);      if (scope)
     }  
     else  
     {     {
         appendLocalClassPathElement(out, objectPath);          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 << "/>";
     }     }
 } }
  
Line 432 
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 460 
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 472 
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 493 
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 702 
Line 1692 
  
 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 729 
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";
 } }
  
Line 775 
Line 1774 
     Boolean flag)     Boolean flag)
 { {
     _appendIParamValueElementBegin(out, name);     _appendIParamValueElementBegin(out, name);
     out << "<VALUE>" << (flag ? "TRUE" : "FALSE") << "</VALUE>\n";      out << "<VALUE>";
       append(out, flag);
       out << "</VALUE>\n";
     _appendIParamValueElementEnd(out);     _appendIParamValueElementEnd(out);
 } }
  
Line 846 
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);
     appendInstanceNameElement(out, instanceName);     appendInstanceNameElement(out, instanceName);
Line 856 
Line 1857 
 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 882 
Line 1883 
     const CIMConstClass& cimClass)     const CIMConstClass& cimClass)
 { {
     _appendIParamValueElementBegin(out, name);     _appendIParamValueElementBegin(out, name);
     cimClass.toXml(out);      appendClassElement(out, cimClass);
     _appendIParamValueElementEnd(out);     _appendIParamValueElementEnd(out);
 } }
  
Line 898 
Line 1899 
     const CIMConstInstance& instance)     const CIMConstInstance& instance)
 { {
     _appendIParamValueElementBegin(out, name);     _appendIParamValueElementBegin(out, name);
     instance.toXml(out);      appendInstanceElement(out, instance);
     _appendIParamValueElementEnd(out);     _appendIParamValueElementEnd(out);
 } }
  
Line 911 
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 948 
Line 1949 
     const CIMValue& value)     const CIMValue& value)
 { {
     _appendIParamValueElementBegin(out, name);     _appendIParamValueElementBegin(out, name);
     value.toXml(out);      appendValueElement(out, value);
     _appendIParamValueElementEnd(out);     _appendIParamValueElementEnd(out);
 } }
  
Line 962 
Line 1963 
     Array<Sint8>& out,     Array<Sint8>& out,
     const CIMPropertyList& propertyList)     const CIMPropertyList& propertyList)
 { {
       // ATTN: P3 KS 4 Mar 2002 - As check shouldn't we check for null property list
     _appendIParamValueElementBegin(out, "PropertyList");     _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";
  
Line 986 
Line 1988 
     const CIMConstQualifierDecl& qualifierDecl)     const CIMConstQualifierDecl& qualifierDecl)
 { {
     _appendIParamValueElementBegin(out, name);     _appendIParamValueElementBegin(out, name);
     qualifierDecl.toXml(out);      appendQualifierDeclElement(out, qualifierDecl);
     _appendIParamValueElementEnd(out);     _appendIParamValueElementEnd(out);
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
   // XmlWriter::formatHttpErrorRspMessage()
   //
   //------------------------------------------------------------------------------
   
   Array<Sint8> XmlWriter::formatHttpErrorRspMessage(
       const String& status,
       const String& cimError,
       const String& errorDetail)
   {
       Array<Sint8> out;
   
       appendHttpErrorResponseHeader(out, status, cimError, errorDetail);
   
       return out;
   }
   
   //------------------------------------------------------------------------------
   //
 // XmlWriter::formatSimpleMethodReqMessage() // XmlWriter::formatSimpleMethodReqMessage()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 999 
Line 2019 
 // ATTN-RK-P1-20020228: Need to complete copy elimination optimization // ATTN-RK-P1-20020228: Need to complete copy elimination optimization
 Array<Sint8> XmlWriter::formatSimpleMethodReqMessage( Array<Sint8> XmlWriter::formatSimpleMethodReqMessage(
     const char* host,     const char* host,
     const CIMReference& path,      const String& nameSpace,
       const CIMObjectPath& path,
     const char* methodName,     const char* methodName,
     const Array<CIMParamValue>& parameters,     const Array<CIMParamValue>& parameters,
     const String& messageId,     const String& messageId,
Line 1007 
Line 2028 
 { {
     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);
     appendLocalObjectPathElement(out, path);      appendLocalObjectPathElement(out, localObjectPath);
     for (Uint32 i=0; i < parameters.size(); i++)     for (Uint32 i=0; i < parameters.size(); i++)
     {     {
         parameters[i].toXml(out);          appendParamValueElement(out, parameters[i]);
     }     }
     _appendMethodCallElementEnd(out);     _appendMethodCallElementEnd(out);
     _appendSimpleReqElementEnd(out);     _appendSimpleReqElementEnd(out);
Line 1024 
Line 2047 
         tmp,         tmp,
         host,         host,
         methodName,         methodName,
         path.toString(false),          localObjectPath.toString(false),
         authenticationHeader,         authenticationHeader,
         out.size());         out.size());
     tmp << out;     tmp << out;
Line 1063 
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);
Line 1140 
Line 2161 
     _appendMessageElementBegin(out, messageId);     _appendMessageElementBegin(out, messageId);
     _appendSimpleRspElementBegin(out);     _appendSimpleRspElementBegin(out);
     _appendIMethodResponseElementBegin(out, iMethodName);     _appendIMethodResponseElementBegin(out, iMethodName);
       if (body.size() != 0)
       {
     _appendIReturnValueElementBegin(out);     _appendIReturnValueElementBegin(out);
     out << body;     out << body;
     _appendIReturnValueElementEnd(out);     _appendIReturnValueElementEnd(out);
       }
     _appendIMethodResponseElementEnd(out);     _appendIMethodResponseElementEnd(out);
     _appendSimpleRspElementEnd(out);     _appendSimpleRspElementEnd(out);
     _appendMessageElementEnd(out);     _appendMessageElementEnd(out);
Line 1162 
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);
Line 1200 
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 1207 
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 1236 
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 1341 
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 1360 
Line 2384 
  
     appendEMethodRequestHeader(     appendEMethodRequestHeader(
         tmp,         tmp,
           requestUri,
         host,         host,
         eMethodName,         eMethodName,
         authenticationHeader,         authenticationHeader,
         out.size());         out.size());
     tmp << out;     tmp << out;
  
     return out;      return tmp;
 } }
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
Line 1406 
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);

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