(file) Return to XmlWriter.h CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/XmlWriter.h between version 1.56 and 1.81.4.1

version 1.56, 2002/08/26 21:53:45 version 1.81.4.1, 2008/02/11 16:52:12
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // The Open Group, Tivoli Systems  // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec Corporation; The Open Group.
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 21 
Line 29 
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Mike Brasher (mbrasher@bmc.com)  
 //  
 // Modified By:  
 //         Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)  
 //         Nag Boranna, Hewlett-Packard Company (nagaraja_boranna@hp.com)  
 //         Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)  
 //         Carol Ann Krug Graves, Hewlett-Packard Company  
 //             (carolann_graves@hp.com)  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #ifndef Pegasus_XmlWriter_h #ifndef Pegasus_XmlWriter_h
Line 53 
Line 52 
 #include <Pegasus/Common/CIMObjectPath.h> #include <Pegasus/Common/CIMObjectPath.h>
 #include <Pegasus/Common/CIMPropertyList.h> #include <Pegasus/Common/CIMPropertyList.h>
 #include <Pegasus/Common/CIMParamValue.h> #include <Pegasus/Common/CIMParamValue.h>
   #include <Pegasus/Common/Message.h>
 #include <Pegasus/Common/Linkage.h> #include <Pegasus/Common/Linkage.h>
   #include <Pegasus/Common/ContentLanguageList.h>
   #include <Pegasus/Common/AcceptLanguageList.h>
   #include <Pegasus/Common/Buffer.h>
   #include <Pegasus/Common/StrLit.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
   // l10n - added accept language and content language support below
   
 class PEGASUS_COMMON_LINKAGE XmlWriter class PEGASUS_COMMON_LINKAGE XmlWriter
 { {
 public: public:
  
     static void append(Array<Sint8>& out, const Char16& x);      static void append(Buffer& out, const Char16& x);
  
     static void append(Array<Sint8>& out, char x)      static void append(Buffer& out, char x)
     {     {
         append(out, Char16(x));        out.append(x);
     }     }
  
     static void append(Array<Sint8>& out, Boolean x);      static void append(Buffer& out, Boolean x);
   
       static void append(Buffer& out, Uint32 x);
  
     static void append(Array<Sint8>& out, Uint32 x);      static void append(Buffer& out, Sint32 x);
  
     static void append(Array<Sint8>& out, Sint32 x);      static void append(Buffer& out, Uint64 x);
  
     static void append(Array<Sint8>& out, Uint64 x);      static void append(Buffer& out, Sint64 x);
  
     static void append(Array<Sint8>& out, Sint64 x);      static void append(Buffer& out, Real32 x);
  
     static void append(Array<Sint8>& out, Real64 x);      static void append(Buffer& out, Real64 x);
  
     static void append(Array<Sint8>& out, const char* str);      static void append(Buffer& out, const char* str);
  
     static void append(Array<Sint8>& out, const String& str);      static void append(Buffer& out, const String& str);
  
     static void append(Array<Sint8>& out, const Indentor& x);      static void append(Buffer& out, const Indentor& x);
  
     static void appendSpecial(Array<Sint8>& out, const Char16& x);      static void appendSpecial(Buffer& out, const Char16& x);
  
     static void appendSpecial(Array<Sint8>& out, char x);      static void appendSpecial(Buffer& out, char x);
  
     static void appendSpecial(Array<Sint8>& out, const char* str);      static void appendSpecial(Buffer& out, const char* str);
  
     static void appendSpecial(Array<Sint8>& out, const String& str);      static void appendSpecial(Buffer& out, const String& str);
   
       static String encodeURICharacters(const Buffer& uriString);
       static String encodeURICharacters(const String& uriString);
  
     static void appendLocalNameSpacePathElement(     static void appendLocalNameSpacePathElement(
         Array<Sint8>& out,          Buffer& out,
         const String& nameSpace);          const CIMNamespaceName& nameSpace);
  
     static void appendNameSpacePathElement(     static void appendNameSpacePathElement(
         Array<Sint8>& out,          Buffer& out,
         const String& host,         const String& host,
         const String& nameSpace);          const CIMNamespaceName& nameSpace);
  
     static void appendClassNameElement(     static void appendClassNameElement(
         Array<Sint8>& out,          Buffer& out,
         const String& className);          const CIMName& className);
  
     static void appendInstanceNameElement(     static void appendInstanceNameElement(
         Array<Sint8>& out,          Buffer& out,
         const CIMObjectPath& instanceName);         const CIMObjectPath& instanceName);
  
     static void appendClassPathElement(     static void appendClassPathElement(
         Array<Sint8>& out,          Buffer& out,
         const CIMObjectPath& classPath);         const CIMObjectPath& classPath);
  
     static void appendInstancePathElement(     static void appendInstancePathElement(
         Array<Sint8>& out,          Buffer& out,
         const CIMObjectPath& instancePath);         const CIMObjectPath& instancePath);
  
     static void appendLocalClassPathElement(     static void appendLocalClassPathElement(
         Array<Sint8>& out,          Buffer& out,
         const CIMObjectPath& classPath);         const CIMObjectPath& classPath);
  
     static void appendLocalInstancePathElement(     static void appendLocalInstancePathElement(
         Array<Sint8>& out,          Buffer& out,
         const CIMObjectPath& instancePath);         const CIMObjectPath& instancePath);
  
     static void appendLocalObjectPathElement(     static void appendLocalObjectPathElement(
         Array<Sint8>& out,          Buffer& out,
         const CIMObjectPath& objectPath);         const CIMObjectPath& objectPath);
  
     static void appendValueElement(     static void appendValueElement(
         Array<Sint8>& out,          Buffer& out,
         const CIMValue& value);         const CIMValue& value);
  
     static void printValueElement(     static void printValueElement(
Line 140 
Line 151 
         PEGASUS_STD(ostream)& os=PEGASUS_STD(cout));         PEGASUS_STD(ostream)& os=PEGASUS_STD(cout));
  
     static void appendValueObjectWithPathElement(     static void appendValueObjectWithPathElement(
         Array<Sint8>& out,          Buffer& out,
         const CIMObject& objectWithPath);         const CIMObject& objectWithPath);
  
     static void appendValueReferenceElement(     static void appendValueReferenceElement(
         Array<Sint8>& out,          Buffer& out,
         const CIMObjectPath& reference,         const CIMObjectPath& reference,
         Boolean putValueWrapper);         Boolean putValueWrapper);
  
Line 153 
Line 164 
         PEGASUS_STD(ostream)& os=PEGASUS_STD(cout));         PEGASUS_STD(ostream)& os=PEGASUS_STD(cout));
  
     static void appendValueNamedInstanceElement(     static void appendValueNamedInstanceElement(
         Array<Sint8>& out,          Buffer& out,
         const CIMInstance& namedInstance);         const CIMInstance& namedInstance);
  
     static void appendClassElement(     static void appendClassElement(
         Array<Sint8>& out,          Buffer& out,
         const CIMConstClass& cimclass);         const CIMConstClass& cimclass);
  
     static void printClassElement(     static void printClassElement(
Line 165 
Line 176 
         PEGASUS_STD(ostream)& os=PEGASUS_STD(cout));         PEGASUS_STD(ostream)& os=PEGASUS_STD(cout));
  
     static void appendInstanceElement(     static void appendInstanceElement(
         Array<Sint8>& out,          Buffer& out,
         const CIMConstInstance& instance);         const CIMConstInstance& instance);
  
     static void printInstanceElement(     static void printInstanceElement(
Line 173 
Line 184 
         PEGASUS_STD(ostream)& os=PEGASUS_STD(cout));         PEGASUS_STD(ostream)& os=PEGASUS_STD(cout));
  
     static void appendObjectElement(     static void appendObjectElement(
         Array<Sint8>& out,          Buffer& out,
         const CIMConstObject& object);         const CIMConstObject& object);
  
     static void appendPropertyElement(     static void appendPropertyElement(
         Array<Sint8>& out,          Buffer& out,
         const CIMConstProperty& property);         const CIMConstProperty& property);
  
     static void printPropertyElement(     static void printPropertyElement(
Line 185 
Line 196 
         PEGASUS_STD(ostream)& os=PEGASUS_STD(cout));         PEGASUS_STD(ostream)& os=PEGASUS_STD(cout));
  
     static void appendMethodElement(     static void appendMethodElement(
         Array<Sint8>& out,          Buffer& out,
         const CIMConstMethod& method);         const CIMConstMethod& method);
  
     static void printMethodElement(     static void printMethodElement(
Line 193 
Line 204 
         PEGASUS_STD(ostream)& os=PEGASUS_STD(cout));         PEGASUS_STD(ostream)& os=PEGASUS_STD(cout));
  
     static void appendParameterElement(     static void appendParameterElement(
         Array<Sint8>& out,          Buffer& out,
         const CIMConstParameter& parameter);         const CIMConstParameter& parameter);
  
     static void printParameterElement(     static void printParameterElement(
Line 201 
Line 212 
         PEGASUS_STD(ostream)& os=PEGASUS_STD(cout));         PEGASUS_STD(ostream)& os=PEGASUS_STD(cout));
  
     static void appendParamValueElement(     static void appendParamValueElement(
         Array<Sint8>& out,          Buffer& out,
         const CIMParamValue& paramValue);         const CIMParamValue& paramValue);
  
     static void printParamValueElement(     static void printParamValueElement(
Line 209 
Line 220 
         PEGASUS_STD(ostream)& os=PEGASUS_STD(cout));         PEGASUS_STD(ostream)& os=PEGASUS_STD(cout));
  
     static void appendQualifierElement(     static void appendQualifierElement(
         Array<Sint8>& out,          Buffer& out,
         const CIMConstQualifier& qualifier);         const CIMConstQualifier& qualifier);
  
     static void printQualifierElement(     static void printQualifierElement(
Line 217 
Line 228 
         PEGASUS_STD(ostream)& os=PEGASUS_STD(cout));         PEGASUS_STD(ostream)& os=PEGASUS_STD(cout));
  
     static void appendQualifierDeclElement(     static void appendQualifierDeclElement(
         Array<Sint8>& out,          Buffer& out,
         const CIMConstQualifierDecl& qualifierDecl);         const CIMConstQualifierDecl& qualifierDecl);
  
     static void printQualifierDeclElement(     static void printQualifierDeclElement(
Line 225 
Line 236 
         PEGASUS_STD(ostream)& os=PEGASUS_STD(cout));         PEGASUS_STD(ostream)& os=PEGASUS_STD(cout));
  
     static void appendQualifierFlavorEntity(     static void appendQualifierFlavorEntity(
         Array<Sint8>& out,          Buffer& out,
         const CIMFlavor & flavor);         const CIMFlavor & flavor);
  
     static void appendScopeElement(     static void appendScopeElement(
         Array<Sint8>& out,          Buffer& out,
         const CIMScope & scope);         const CIMScope & scope);
  
     static void appendMethodCallHeader(     static void appendMethodCallHeader(
         Array<Sint8>& out,          Buffer& out,
         const char* host,         const char* host,
         const char* cimMethod,          const CIMName& cimMethod,
         const String& cimObject,         const String& cimObject,
         const String& authenticationHeader,         const String& authenticationHeader,
           HttpMethod httpMethod,
           const AcceptLanguageList& acceptLanguages,
           const ContentLanguageList& contentLanguages,
         Uint32 contentLength);         Uint32 contentLength);
  
       // added to accommodate sending WBEMServerResponseTime PEP #128
     static void appendMethodResponseHeader(     static void appendMethodResponseHeader(
         Array<Sint8>& out,          Buffer& out,
         Uint32 contentLength);          HttpMethod httpMethod,
           const ContentLanguageList& contentLanguages,
           Uint32 contentLength,
           Uint64 serverResponseTime = 0);
  
     static void appendHttpErrorResponseHeader(     static void appendHttpErrorResponseHeader(
         Array<Sint8>& out,          Buffer& out,
         const String& status,         const String& status,
         const String& cimError = String::EMPTY,         const String& cimError = String::EMPTY,
         const String& errorDetail = String::EMPTY);         const String& errorDetail = String::EMPTY);
  
     static void appendUnauthorizedResponseHeader(     static void appendUnauthorizedResponseHeader(
         Array<Sint8>& out,          Buffer& out,
         const String& content);         const String& content);
  
   #ifdef PEGASUS_KERBEROS_AUTHENTICATION
       static void appendOKResponseHeader(
           Buffer& out,
           const String& content);
   #endif
       static void appendParamTypeAndEmbeddedObjAttrib(
           Buffer& out,
           const CIMType& type);
   
     static void appendReturnValueElement(     static void appendReturnValueElement(
         Array<Sint8>& out,          Buffer& out,
         const CIMValue& value);         const CIMValue& value);
  
     static void appendBooleanIParameter(     static void appendBooleanIParameter(
         Array<Sint8>& out,          Buffer& out,
         const char* name,         const char* name,
         Boolean flag);         Boolean flag);
  
     static void appendStringIParameter(     static void appendStringIParameter(
         Array<Sint8>& out,          Buffer& out,
         const char* name,         const char* name,
         const String& str);         const String& str);
  
     static void appendQualifierNameIParameter(  
         Array<Sint8>& out,  
         const char* name,  
         const String& qualifierName);  
   
     static void appendClassNameIParameter(     static void appendClassNameIParameter(
         Array<Sint8>& out,          Buffer& out,
         const char* name,         const char* name,
         const String& className);          const CIMName& className);
  
     static void appendInstanceNameIParameter(     static void appendInstanceNameIParameter(
         Array<Sint8>& out,          Buffer& out,
         const char* name,         const char* name,
         const CIMObjectPath& instanceName);         const CIMObjectPath& instanceName);
  
     static void appendObjectNameIParameter(     static void appendObjectNameIParameter(
         Array<Sint8>& out,          Buffer& out,
         const char* name,         const char* name,
         const CIMObjectPath& objectName);         const CIMObjectPath& objectName);
  
     static void appendClassIParameter(     static void appendClassIParameter(
         Array<Sint8>& out,          Buffer& out,
         const char* name,         const char* name,
         const CIMConstClass& cimClass);         const CIMConstClass& cimClass);
  
     static void appendInstanceIParameter(     static void appendInstanceIParameter(
         Array<Sint8>& out,          Buffer& out,
         const char* name,         const char* name,
         const CIMConstInstance& instance);         const CIMConstInstance& instance);
  
     static void appendNamedInstanceIParameter(     static void appendNamedInstanceIParameter(
         Array<Sint8>& out,          Buffer& out,
         const char* name,         const char* name,
         const CIMInstance& namedInstance) ;         const CIMInstance& namedInstance) ;
  
     static void appendPropertyNameIParameter(     static void appendPropertyNameIParameter(
         Array<Sint8>& out,          Buffer& out,
         const String& propertyName);          const CIMName& propertyName);
  
     static void appendPropertyValueIParameter(     static void appendPropertyValueIParameter(
         Array<Sint8>& out,          Buffer& out,
         const char* name,         const char* name,
         const CIMValue& value);         const CIMValue& value);
  
     static void appendPropertyListIParameter(     static void appendPropertyListIParameter(
         Array<Sint8>& out,          Buffer& out,
         const CIMPropertyList& propertyList);         const CIMPropertyList& propertyList);
  
     static void appendQualifierDeclarationIParameter(     static void appendQualifierDeclarationIParameter(
         Array<Sint8>& out,          Buffer& out,
         const char* name,         const char* name,
         const CIMConstQualifierDecl& qualifierDecl);         const CIMConstQualifierDecl& qualifierDecl);
  
     static Array<Sint8> formatHttpErrorRspMessage(      static Buffer formatHttpErrorRspMessage(
         const String& status,         const String& status,
         const String& cimError = String::EMPTY,         const String& cimError = String::EMPTY,
         const String& errorDetail = String::EMPTY);         const String& errorDetail = String::EMPTY);
  
     static Array<Sint8> formatSimpleMethodReqMessage(      static Buffer formatSimpleMethodReqMessage(
         const char* host,         const char* host,
         const String& nameSpace,          const CIMNamespaceName& nameSpace,
         const CIMObjectPath& path,         const CIMObjectPath& path,
         const char* methodName,          const CIMName& methodName,
         const Array<CIMParamValue>& parameters,         const Array<CIMParamValue>& parameters,
         const String& messageId,         const String& messageId,
         const String& authenticationHeader);          HttpMethod httpMethod,
           const String& authenticationHeader,
           const AcceptLanguageList& httpAcceptLanguages,
           const ContentLanguageList& httpContentLanguages);
  
     static Array<Sint8> formatSimpleMethodRspMessage(      // PEP 128 - sending serverResponseTime (WBEMServerResponseTime) in
         const char* methodName,      // response header
       static Buffer formatSimpleMethodRspMessage(
           const CIMName& methodName,
         const String& messageId,         const String& messageId,
         const Array<Sint8>& body);          HttpMethod httpMethod,
           const ContentLanguageList& httpContentLanguages,
           const Buffer& body,
           Uint64 serverResponseTime,
           Boolean isFirst = true,
           Boolean isLast = true);
  
     static Array<Sint8> formatSimpleMethodErrorRspMessage(      static Buffer formatSimpleMethodErrorRspMessage(
         const String& methodName,          const CIMName& methodName,
         const String& messageId,         const String& messageId,
           HttpMethod httpMethod,
         const CIMException& cimException);         const CIMException& cimException);
  
     static Array<Sint8> formatSimpleIMethodReqMessage(      static Buffer formatSimpleIMethodReqMessage(
         const char* host,         const char* host,
         const String& nameSpace,          const CIMNamespaceName& nameSpace,
         const char* iMethodName,          const CIMName& iMethodName,
         const String& messageId,         const String& messageId,
           HttpMethod httpMethod,
         const String& authenticationHeader,         const String& authenticationHeader,
         const Array<Sint8>& body);          const AcceptLanguageList& httpAcceptLanguages,
           const ContentLanguageList& httpContentLanguages,
     static Array<Sint8> formatSimpleIMethodRspMessage(          const Buffer& body);
         const char* iMethodName,  
       // PEP 128 - sending serverResponseTime (WBEMServerResponseTime) in
       // response header
       static Buffer formatSimpleIMethodRspMessage(
           const CIMName& iMethodName,
         const String& messageId,         const String& messageId,
         const Array<Sint8>& body);          HttpMethod httpMethod,
           const ContentLanguageList& httpContentLanguages,
           const Buffer& body,
           Uint64 serverResponseTime,
           Boolean isFirst = true,
           Boolean isLast = true);
  
     static Array<Sint8> formatSimpleIMethodErrorRspMessage(      static Buffer formatSimpleIMethodErrorRspMessage(
         const String& iMethodName,          const CIMName& iMethodName,
         const String& messageId,         const String& messageId,
           HttpMethod httpMethod,
         const CIMException& cimException);         const CIMException& cimException);
  
       static void appendInstanceEParameter(
           Buffer& out,
           const char* name,
           const CIMInstance& instance);
   
     static void appendEMethodRequestHeader(     static void appendEMethodRequestHeader(
         Array<Sint8>& out,          Buffer& out,
         const char* requestUri,         const char* requestUri,
         const char* host,         const char* host,
         const char* cimMethod,          const CIMName& cimMethod,
           HttpMethod httpMethod,
         const String& authenticationHeader,         const String& authenticationHeader,
           const AcceptLanguageList& acceptLanguages,
           const ContentLanguageList& contentLanguages,
         Uint32 contentLength);         Uint32 contentLength);
  
     static void appendEMethodResponseHeader(     static void appendEMethodResponseHeader(
         Array<Sint8>& out,          Buffer& out,
           HttpMethod httpMethod,
           const ContentLanguageList& contentLanguages,
         Uint32 contentLength);         Uint32 contentLength);
  
     static Array<Sint8> formatSimpleEMethodReqMessage(      static Buffer formatSimpleEMethodReqMessage(
         const char* requestUri,         const char* requestUri,
         const char* host,         const char* host,
         const char* eMethodName,          const CIMName& eMethodName,
         const String& messageId,         const String& messageId,
           HttpMethod httpMethod,
         const String& authenticationHeader,         const String& authenticationHeader,
         const Array<Sint8>& body);          const AcceptLanguageList& httpAcceptLanguages,
           const ContentLanguageList& httpContentLanguages,
           const Buffer& body);
  
     static Array<Sint8> formatSimpleEMethodRspMessage(      static Buffer formatSimpleEMethodRspMessage(
         const char* eMethodName,          const CIMName& eMethodName,
         const String& messageId,         const String& messageId,
         const Array<Sint8>& body);          HttpMethod httpMethod,
           const ContentLanguageList& httpContentLanguages,
           const Buffer& body);
  
     static Array<Sint8> formatSimpleEMethodErrorRspMessage(      static Buffer formatSimpleEMethodErrorRspMessage(
         const String& eMethodName,          const CIMName& eMethodName,
         const String& messageId,         const String& messageId,
           HttpMethod httpMethod,
         const CIMException& cimException);         const CIMException& cimException);
  
     static void indentedPrint(     static void indentedPrint(
Line 400 
Line 460 
  
     static String getNextMessageId();     static String getNextMessageId();
  
     /** Converts the given KeyBinding type to one of the following:      /** Converts the given CIMKeyBinding type to one of the following:
         "boolean", "string", or "numeric"         "boolean", "string", or "numeric"
     */     */
     static const char* keyBindingTypeToString (KeyBinding::Type type);      static const char* keyBindingTypeToString (CIMKeyBinding::Type type);
  
 private: private:
  
     static void _appendMessageElementBegin(     static void _appendMessageElementBegin(
         Array<Sint8>& out,          Buffer& out,
         const String& messageId);         const String& messageId);
     static void _appendMessageElementEnd(     static void _appendMessageElementEnd(
         Array<Sint8>& out);          Buffer& out);
  
     static void _appendSimpleReqElementBegin(Array<Sint8>& out);      static void _appendSimpleReqElementBegin(Buffer& out);
     static void _appendSimpleReqElementEnd(Array<Sint8>& out);      static void _appendSimpleReqElementEnd(Buffer& out);
  
     static void _appendMethodCallElementBegin(     static void _appendMethodCallElementBegin(
         Array<Sint8>& out,          Buffer& out,
         const char* name);          const CIMName& name);
   
     static void _appendMethodCallElementEnd(     static void _appendMethodCallElementEnd(
         Array<Sint8>& out);          Buffer& out);
  
     static void _appendIMethodCallElementBegin(     static void _appendIMethodCallElementBegin(
         Array<Sint8>& out,          Buffer& out,
         const char* name);          const CIMName& name);
     static void _appendIMethodCallElementEnd(     static void _appendIMethodCallElementEnd(
         Array<Sint8>& out);          Buffer& out);
  
     static void _appendIParamValueElementBegin(     static void _appendIParamValueElementBegin(
         Array<Sint8>& out,          Buffer& out,
         const char* name);         const char* name);
     static void _appendIParamValueElementEnd(     static void _appendIParamValueElementEnd(
         Array<Sint8>& out);          Buffer& out);
  
     static void _appendSimpleRspElementBegin(Array<Sint8>& out);      static void _appendSimpleRspElementBegin(Buffer& out);
     static void _appendSimpleRspElementEnd(Array<Sint8>& out);      static void _appendSimpleRspElementEnd(Buffer& out);
  
     static void _appendMethodResponseElementBegin(     static void _appendMethodResponseElementBegin(
         Array<Sint8>& out,          Buffer& out,
         const char* name);          const CIMName& name);
     static void _appendMethodResponseElementEnd(     static void _appendMethodResponseElementEnd(
         Array<Sint8>& out);          Buffer& out);
  
     static void _appendIMethodResponseElementBegin(     static void _appendIMethodResponseElementBegin(
         Array<Sint8>& out,          Buffer& out,
         const char* name);          const CIMName& name);
     static void _appendIMethodResponseElementEnd(     static void _appendIMethodResponseElementEnd(
         Array<Sint8>& out);          Buffer& out);
  
     static void _appendErrorElement(     static void _appendErrorElement(
         Array<Sint8>& out,          Buffer& out,
         const CIMException& cimException);         const CIMException& cimException);
  
     static void _appendIReturnValueElementBegin(Array<Sint8>& out);      static void _appendIReturnValueElementBegin(Buffer& out);
     static void _appendIReturnValueElementEnd(Array<Sint8>& out);      static void _appendIReturnValueElementEnd(Buffer& out);
  
     static void _appendSimpleExportReqElementBegin(Array<Sint8>& out);      static void _appendSimpleExportReqElementBegin(Buffer& out);
     static void _appendSimpleExportReqElementEnd(Array<Sint8>& out);      static void _appendSimpleExportReqElementEnd(Buffer& out);
  
     static void _appendEMethodCallElementBegin(     static void _appendEMethodCallElementBegin(
         Array<Sint8>& out,          Buffer& out,
         const char* name);          const CIMName& name);
   
     static void _appendEMethodCallElementEnd(     static void _appendEMethodCallElementEnd(
         Array<Sint8>& out);          Buffer& out);
   
       static void _appendEParamValueElementBegin(
           Buffer& out,
           const char* name);
           static void _appendEParamValueElementEnd(
           Buffer& out);
  
     static void _appendSimpleExportRspElementBegin(Array<Sint8>& out);      static void _appendSimpleExportRspElementBegin(Buffer& out);
     static void _appendSimpleExportRspElementEnd(Array<Sint8>& out);      static void _appendSimpleExportRspElementEnd(Buffer& out);
  
     static void _appendEMethodResponseElementBegin(     static void _appendEMethodResponseElementBegin(
         Array<Sint8>& out,          Buffer& out,
         const char* name);          const CIMName& name);
   
     static void _appendEMethodResponseElementEnd(     static void _appendEMethodResponseElementEnd(
         Array<Sint8>& out);          Buffer& out);
  
     XmlWriter() { }     XmlWriter() { }
 }; };
  
 PEGASUS_COMMON_LINKAGE Array<Sint8>& operator<<(  PEGASUS_COMMON_LINKAGE Buffer& operator<<(
     Array<Sint8>& out,      Buffer& out,
     const char* x);     const char* x);
  
 PEGASUS_COMMON_LINKAGE Array<Sint8>& operator<<(Array<Sint8>& out, char x);  inline Buffer& operator<<(Buffer& out, char x)
   {
       out.append(x);
       return out;
   }
  
 PEGASUS_COMMON_LINKAGE Array<Sint8>& operator<<(Array<Sint8>& out, const Char16& x);  inline Buffer& operator<<(Buffer& out, const char* s)
   {
       out.append(s, strlen(s));
       return out;
   }
   
   PEGASUS_COMMON_LINKAGE Buffer& operator<<(Buffer& out, const Char16& x);
  
 PEGASUS_COMMON_LINKAGE Array<Sint8>& operator<<(  PEGASUS_COMMON_LINKAGE Buffer& operator<<(
     Array<Sint8>& out,      Buffer& out,
     const String& x);     const String& x);
  
 PEGASUS_COMMON_LINKAGE Array<Sint8>& operator<<(  PEGASUS_COMMON_LINKAGE Buffer& operator<<(
     Array<Sint8>& out,      Buffer& out,
     const Indentor& x);     const Indentor& x);
  
 PEGASUS_COMMON_LINKAGE Array<Sint8>& operator<<(  PEGASUS_COMMON_LINKAGE Buffer& operator<<(
     Array<Sint8>& out,      Buffer& out,
     const Array<Sint8>& x);      const Buffer& x);
  
 PEGASUS_COMMON_LINKAGE Array<Sint8>& operator<<(  PEGASUS_COMMON_LINKAGE Buffer& operator<<(
     Array<Sint8>& out,      Buffer& out,
     Uint32 x);     Uint32 x);
  
   PEGASUS_COMMON_LINKAGE Buffer& operator<<(
       Buffer& out,
       const CIMName& name);
   
 PEGASUS_COMMON_LINKAGE PEGASUS_STD(ostream)& operator<<( PEGASUS_COMMON_LINKAGE PEGASUS_STD(ostream)& operator<<(
     PEGASUS_STD(ostream)& os,     PEGASUS_STD(ostream)& os,
     const CIMDateTime& x);     const CIMDateTime& x);
  
   PEGASUS_COMMON_LINKAGE PEGASUS_STD(ostream)& operator<<(
       PEGASUS_STD(ostream)& os,
       const CIMName& name);
   
   PEGASUS_COMMON_LINKAGE PEGASUS_STD(ostream)& operator<<(
       PEGASUS_STD(ostream)& os,
       const CIMNamespaceName& name);
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END
  
 #endif /* Pegasus_XmlWriter_h */ #endif /* Pegasus_XmlWriter_h */

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