(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.21 and 1.82.6.2

version 1.21, 2001/07/10 22:31:16 version 1.82.6.2, 2008/02/28 00:21:08
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001 The Open group, BMC Software, Tivoli Systems, IBM  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
   // 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 20 
Line 29 
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Mike Brasher (mbrasher@bmc.com)  
 //  
 // Modified By:  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #ifndef Pegasus_XmlWriter_h #ifndef Pegasus_XmlWriter_h
Line 31 
Line 36 
  
 #include <iostream> #include <iostream>
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
 #include <Pegasus/Common/Exception.h>  #include <Pegasus/Common/InternalException.h>
 #include <Pegasus/Common/Array.h>  #include <Pegasus/Common/ArrayInternal.h>
 #include <Pegasus/Common/String.h> #include <Pegasus/Common/String.h>
 #include <Pegasus/Common/Indentor.h> #include <Pegasus/Common/Indentor.h>
 #include <Pegasus/Common/CIMReference.h>  #include <Pegasus/Common/CIMObject.h>
   #include <Pegasus/Common/CIMClass.h>
   #include <Pegasus/Common/CIMInstance.h>
   #include <Pegasus/Common/CIMProperty.h>
   #include <Pegasus/Common/CIMMethod.h>
   #include <Pegasus/Common/CIMParameter.h>
   #include <Pegasus/Common/CIMQualifier.h>
   #include <Pegasus/Common/CIMQualifierDecl.h>
   #include <Pegasus/Common/CIMValue.h>
   #include <Pegasus/Common/CIMObjectPath.h>
   #include <Pegasus/Common/CIMPropertyList.h>
   #include <Pegasus/Common/CIMParamValue.h>
   #include <Pegasus/Common/Message.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>
   #include <Pegasus/Common/XmlUtils.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 class CIMConstQualifierDecl;  // l10n - added accept language and content language support below
 class CIMConstClass;  
 class CIMConstInstance;  
  
 class PEGASUS_COMMON_LINKAGE XmlWriter class PEGASUS_COMMON_LINKAGE XmlWriter
 { {
 public: public:
  
     static void append(Array<Sint8>& out, Char16 x);      static void append(Buffer& out, const Char16& x)
       {XmlUtils::append(out, x);}
  
     static void append(Array<Sint8>& out, char x)      static void append(Buffer& out, char x)
     {      {XmlUtils::append(out, x);}
         append(out, Char16(x));  
     }  
  
     static void append(Array<Sint8>& out, const char* x);      static void append(Buffer& out, Boolean x)
       {XmlUtils::append(out, x);}
  
     static void append(Array<Sint8>& out, const String& x);      static void append(Buffer& out, Uint32 x)
       {XmlUtils::append(out, x);}
  
     static void append(Array<Sint8>& out, Uint32 x);      static void append(Buffer& out, Sint32 x)
       {XmlUtils::append(out, x);}
  
     static void appendSpecial(Array<Sint8>& out, Char16 x);      static void append(Buffer& out, Uint64 x)
       {XmlUtils::append(out, x);}
  
     static void appendSpecial(Array<Sint8>& out, char x);      static void append(Buffer& out, Sint64 x)
       {XmlUtils::append(out, x);}
  
     static void appendSpecial(Array<Sint8>& out, const char* x);      static void append(Buffer& out, Real32 x)
       {XmlUtils::append(out, x);}
  
     static void appendSpecial(Array<Sint8>& out, const String& x);      static void append(Buffer& out, Real64 x)
       {XmlUtils::append(out, x);}
  
     static void append(Array<Sint8>& out, const Indentor& x);      static void append(Buffer& out, const char* str)
       {XmlUtils::append(out, str);}
  
     static void appendLocalNameSpaceElement(      static void append(Buffer& out, const String& str)
         Array<Sint8>& out,      {XmlUtils::append(out, str);}
         const String& nameSpace);  
  
     static void appendNameSpaceElement(      static void append(Buffer& out, const Indentor& x)
         Array<Sint8>& out,      {XmlUtils::append(out, x);}
         const String& nameSpace);  
  
     static Array<Sint8> formatGetHeader(      static void appendSpecial(Buffer& out, const Char16& x)
         const char* documentPath);      {XmlUtils::appendSpecial(out, x);}
  
     static Array<Sint8> formatMPostHeader(      static void appendSpecial(Buffer& out, char x)
         const char* host,      {XmlUtils::appendSpecial(out, x);}
         const char* cimOperation,  
         const char* cimMethod,  
         const String& cimObject,  
         const Array<Sint8>& content);  
  
     static Array<Sint8> formatMethodResponseHeader(      static void appendSpecial(Buffer& out, const char* str)
         const Array<Sint8>& content);      {XmlUtils::appendSpecial(out, str);}
  
     static Array<Sint8> formatMessageElement(      static void appendSpecial(Buffer& out, const String& str)
         const String& messageId,      {XmlUtils::appendSpecial(out, str);}
         const Array<Sint8>& body);  
  
     static Array<Sint8> formatSimpleReqElement(      static void appendLocalNameSpacePathElement(
         const Array<Sint8>& body);          Buffer& out,
           const CIMNamespaceName& nameSpace);
  
     static Array<Sint8> formatSimpleRspElement(      static void appendNameSpacePathElement(
         const Array<Sint8>& body);          Buffer& out,
           const String& host,
           const CIMNamespaceName& nameSpace);
  
     static Array<Sint8> formatIMethodCallElement(      static void appendClassNameElement(
         const char* name,          Buffer& out,
         const String& nameSpace,          const CIMName& className);
         const Array<Sint8>& iParamValues);  
  
     static Array<Sint8> formatIReturnValueElement(      static void appendInstanceNameElement(
         const Array<Sint8>& body);          Buffer& out,
           const CIMObjectPath& instanceName);
  
     static Array<Sint8> formatIMethodResponseElement(      static void appendClassPathElement(
         const char* name,          Buffer& out,
         const Array<Sint8>& iParamValues);          const CIMObjectPath& classPath);
  
     static Array<Sint8>& formatIParamValueElement(      static void appendInstancePathElement(
         Array<Sint8>& out,          Buffer& out,
         const char* name,          const CIMObjectPath& instancePath);
         const Array<Sint8>& body);  
       static void appendLocalClassPathElement(
           Buffer& out,
           const CIMObjectPath& classPath);
   
       static void appendLocalInstancePathElement(
           Buffer& out,
           const CIMObjectPath& instancePath);
   
       static void appendLocalObjectPathElement(
           Buffer& out,
           const CIMObjectPath& objectPath);
   
       static void appendValueElement(
           Buffer& out,
           const CIMValue& value);
   
       static void printValueElement(
           const CIMValue& value,
           PEGASUS_STD(ostream)& os=PEGASUS_STD(cout));
   
       static void appendValueObjectWithPathElement(
           Buffer& out,
           const CIMObject& objectWithPath);
   
       static void appendValueReferenceElement(
           Buffer& out,
           const CIMObjectPath& reference,
           Boolean putValueWrapper);
  
     static Array<Sint8> formatErrorElement(      static void printValueReferenceElement(
         CIMStatusCode code,          const CIMObjectPath& reference,
         const char* description);          PEGASUS_STD(ostream)& os=PEGASUS_STD(cout));
  
     static Array<Sint8>& appendBooleanParameter(      static void appendValueNamedInstanceElement(
         Array<Sint8>& out,          Buffer& out,
         const char* parameterName,          const CIMInstance& namedInstance);
   
       static void appendClassElement(
           Buffer& out,
           const CIMConstClass& cimclass);
   
       static void printClassElement(
           const CIMConstClass& cimclass,
           PEGASUS_STD(ostream)& os=PEGASUS_STD(cout));
   
       static void appendInstanceElement(
           Buffer& out,
           const CIMConstInstance& instance);
   
       static void printInstanceElement(
           const CIMConstInstance& instance,
           PEGASUS_STD(ostream)& os=PEGASUS_STD(cout));
   
       static void appendObjectElement(
           Buffer& out,
           const CIMConstObject& object);
   
       static void appendPropertyElement(
           Buffer& out,
           const CIMConstProperty& property);
   
       static void printPropertyElement(
           const CIMConstProperty& property,
           PEGASUS_STD(ostream)& os=PEGASUS_STD(cout));
   
       static void appendMethodElement(
           Buffer& out,
           const CIMConstMethod& method);
   
       static void printMethodElement(
           const CIMConstMethod& method,
           PEGASUS_STD(ostream)& os=PEGASUS_STD(cout));
   
       static void appendParameterElement(
           Buffer& out,
           const CIMConstParameter& parameter);
   
       static void printParameterElement(
           const CIMConstParameter& parameter,
           PEGASUS_STD(ostream)& os=PEGASUS_STD(cout));
   
       static void appendParamValueElement(
           Buffer& out,
           const CIMParamValue& paramValue);
   
       static void printParamValueElement(
           const CIMParamValue& paramValue,
           PEGASUS_STD(ostream)& os=PEGASUS_STD(cout));
   
       static void appendQualifierElement(
           Buffer& out,
           const CIMConstQualifier& qualifier);
   
       static void printQualifierElement(
           const CIMConstQualifier& qualifier,
           PEGASUS_STD(ostream)& os=PEGASUS_STD(cout));
   
       static void appendQualifierDeclElement(
           Buffer& out,
           const CIMConstQualifierDecl& qualifierDecl);
   
       static void printQualifierDeclElement(
           const CIMConstQualifierDecl& qualifierDecl,
           PEGASUS_STD(ostream)& os=PEGASUS_STD(cout));
   
       static void appendQualifierFlavorEntity(
           Buffer& out,
           const CIMFlavor & flavor);
   
       static void appendScopeElement(
           Buffer& out,
           const CIMScope & scope);
   
       static void appendMethodCallHeader(
           Buffer& out,
           const char* host,
           const CIMName& cimMethod,
           const String& cimObject,
           const String& authenticationHeader,
           HttpMethod httpMethod,
           const AcceptLanguageList& acceptLanguages,
           const ContentLanguageList& contentLanguages,
           Uint32 contentLength);
   
       // added to accommodate sending WBEMServerResponseTime PEP #128
       static void appendMethodResponseHeader(
           Buffer& out,
           HttpMethod httpMethod,
           const ContentLanguageList& contentLanguages,
           Uint32 contentLength,
           Uint64 serverResponseTime = 0);
   
       static void appendHttpErrorResponseHeader(
           Buffer& out,
           const String& status,
           const String& cimError = String::EMPTY,
           const String& errorDetail = String::EMPTY);
   
       static void appendUnauthorizedResponseHeader(
           Buffer& out,
           const String& content);
   
   #ifdef PEGASUS_KERBEROS_AUTHENTICATION
       static void appendOKResponseHeader(
           Buffer& out,
           const String& content);
   #endif
   
       static void appendReturnValueElement(
           Buffer& out,
           const CIMValue& value);
   
       static void appendBooleanIParameter(
           Buffer& out,
           const char* name,
         Boolean flag);         Boolean flag);
  
     static Array<Sint8>& appendStringParameter(      static void appendStringIParameter(
         Array<Sint8>& out,          Buffer& out,
         const char* parameterName,          const char* name,
         const String& str);         const String& str);
  
     static Array<Sint8>& appendClassNameParameter(      static void appendClassNameIParameter(
         Array<Sint8>& out,          Buffer& out,
         const char* parameterName,          const char* name,
         const String& className);          const CIMName& className);
   
     static Array<Sint8>& appendQualifierNameParameter(      static void appendInstanceNameIParameter(
         Array<Sint8>& out,          Buffer& out,
         const char* parameterName,          const char* name,
         const String& qualifierName);          const CIMObjectPath& instanceName);
   
     static Array<Sint8>& appendClassParameter(      static void appendObjectNameIParameter(
         Array<Sint8>& out,          Buffer& out,
         const char* parameterName,          const char* name,
           const CIMObjectPath& objectName);
   
       static void appendClassIParameter(
           Buffer& out,
           const char* name,
         const CIMConstClass& cimClass);         const CIMConstClass& cimClass);
  
     static Array<Sint8>& appendInstanceNameParameter(      static void appendInstanceIParameter(
         Array<Sint8>& out,          Buffer& out,
         const char* parameterName,          const char* name,
         const CIMReference& instanceName);  
   
     static Array<Sint8>& appendInstanceParameter(  
         Array<Sint8>& out,  
         const char* parameterName,  
         const CIMConstInstance& instance);         const CIMConstInstance& instance);
  
     static Array<Sint8>& appendQualifierDeclarationParameter(      static void appendNamedInstanceIParameter(
         Array<Sint8>& out,          Buffer& out,
         const char* parameterName,          const char* name,
         const CIMConstQualifierDecl& qualifierDecl);          const CIMInstance& namedInstance) ;
  
     static Array<Sint8>& appendClassNameElement(      static void appendPropertyNameIParameter(
         Array<Sint8>& out,          Buffer& out,
         const String& className);          const CIMName& propertyName);
  
     static Array<Sint8>& appendInstanceNameElement(      static void appendPropertyValueIParameter(
         Array<Sint8>& out,          Buffer& out,
         const CIMReference& instanceName);          const char* name,
           const CIMValue& value);
  
     static Array<Sint8>& appendPropertyNameParameter(      static void appendPropertyListIParameter(
         Array<Sint8>& out,          Buffer& out,
         const String& propertyName);          const CIMPropertyList& propertyList);
  
     static Array<Sint8>& appendObjectNameParameter(      static void appendQualifierDeclarationIParameter(
         Array<Sint8>& out,          Buffer& out,
         const char* name,         const char* name,
         const CIMReference& objectName);          const CIMConstQualifierDecl& qualifierDecl);
  
     static void indentedPrint(      static Buffer formatHttpErrorRspMessage(
         PEGASUS_STD(ostream)& os,          const String& status,
         const char* text,          const String& cimError = String::EMPTY,
         Uint32 indentChars = 2);          const String& errorDetail = String::EMPTY);
  
     static Array<Sint8> formatSimpleReqMessage(      static Buffer formatSimpleMethodReqMessage(
         const char* host,         const char* host,
         const String& nameSpace,          const CIMNamespaceName& nameSpace,
         const char* iMethodName,          const CIMObjectPath& path,
         const Array<Sint8>& body);          const CIMName& methodName,
           const Array<CIMParamValue>& parameters,
           const String& messageId,
           HttpMethod httpMethod,
           const String& authenticationHeader,
           const AcceptLanguageList& httpAcceptLanguages,
           const ContentLanguageList& httpContentLanguages);
   
       // PEP 128 - sending serverResponseTime (WBEMServerResponseTime) in
       // response header
       static Buffer formatSimpleMethodRspMessage(
           const CIMName& methodName,
           const String& messageId,
           HttpMethod httpMethod,
           const ContentLanguageList& httpContentLanguages,
           const Buffer& body,
           Uint64 serverResponseTime,
           Boolean isFirst = true,
           Boolean isLast = true);
  
     static Array<Sint8> formatSimpleRspMessage(      static Buffer formatSimpleMethodErrorRspMessage(
         const char* iMethodName,          const CIMName& methodName,
         const String& messageId,         const String& messageId,
         const Array<Sint8>& body);          HttpMethod httpMethod,
           const CIMException& cimException);
  
     static String getNextMessageId();      static Buffer formatSimpleIMethodReqMessage(
           const char* host,
           const CIMNamespaceName& nameSpace,
           const CIMName& iMethodName,
           const String& messageId,
           HttpMethod httpMethod,
           const String& authenticationHeader,
           const AcceptLanguageList& httpAcceptLanguages,
           const ContentLanguageList& httpContentLanguages,
           const Buffer& body);
   
       // PEP 128 - sending serverResponseTime (WBEMServerResponseTime) in
       // response header
       static Buffer formatSimpleIMethodRspMessage(
           const CIMName& iMethodName,
           const String& messageId,
           HttpMethod httpMethod,
           const ContentLanguageList& httpContentLanguages,
           const Buffer& body,
           Uint64 serverResponseTime,
           Boolean isFirst = true,
           Boolean isLast = true);
  
 private:      static Buffer formatSimpleIMethodErrorRspMessage(
           const CIMName& iMethodName,
           const String& messageId,
           HttpMethod httpMethod,
           const CIMException& cimException);
  
     XmlWriter() { }      static void appendInstanceEParameter(
 };          Buffer& out,
           const char* name,
           const CIMInstance& instance);
   
       static void appendEMethodRequestHeader(
           Buffer& out,
           const char* requestUri,
           const char* host,
           const CIMName& cimMethod,
           HttpMethod httpMethod,
           const String& authenticationHeader,
           const AcceptLanguageList& acceptLanguages,
           const ContentLanguageList& contentLanguages,
           Uint32 contentLength);
   
       static void appendEMethodResponseHeader(
           Buffer& out,
           HttpMethod httpMethod,
           const ContentLanguageList& contentLanguages,
           Uint32 contentLength);
   
       static Buffer formatSimpleEMethodReqMessage(
           const char* requestUri,
           const char* host,
           const CIMName& eMethodName,
           const String& messageId,
           HttpMethod httpMethod,
           const String& authenticationHeader,
           const AcceptLanguageList& httpAcceptLanguages,
           const ContentLanguageList& httpContentLanguages,
           const Buffer& body);
  
 PEGASUS_COMMON_LINKAGE Array<Sint8>& operator<<(      static Buffer formatSimpleEMethodRspMessage(
     Array<Sint8>& out,          const CIMName& eMethodName,
     const char* x);          const String& messageId,
           HttpMethod httpMethod,
           const ContentLanguageList& httpContentLanguages,
           const Buffer& body);
   
       static Buffer formatSimpleEMethodErrorRspMessage(
           const CIMName& eMethodName,
           const String& messageId,
           HttpMethod httpMethod,
           const CIMException& cimException);
   
       static String getNextMessageId();
  
 PEGASUS_COMMON_LINKAGE Array<Sint8>& operator<<(Array<Sint8>& out, char x);      /** Converts the given CIMKeyBinding type to one of the following:
           "boolean", "string", or "numeric"
       */
       static const char* keyBindingTypeToString (CIMKeyBinding::Type type);
  
 PEGASUS_COMMON_LINKAGE Array<Sint8>& operator<<(Array<Sint8>& out, Char16 x);  private:
  
 PEGASUS_COMMON_LINKAGE Array<Sint8>& operator<<(      static void _appendMessageElementBegin(
     Array<Sint8>& out,          Buffer& out,
     const String& x);          const String& messageId);
           static void _appendMessageElementEnd(
           Buffer& out);
   
       static void _appendSimpleReqElementBegin(Buffer& out);
       static void _appendSimpleReqElementEnd(Buffer& out);
   
       static void _appendMethodCallElementBegin(
           Buffer& out,
           const CIMName& name);
   
       static void _appendMethodCallElementEnd(
           Buffer& out);
   
       static void _appendIMethodCallElementBegin(
           Buffer& out,
           const CIMName& name);
           static void _appendIMethodCallElementEnd(
           Buffer& out);
   
       static void _appendIParamValueElementBegin(
           Buffer& out,
           const char* name);
           static void _appendIParamValueElementEnd(
           Buffer& out);
   
       static void _appendSimpleRspElementBegin(Buffer& out);
       static void _appendSimpleRspElementEnd(Buffer& out);
   
       static void _appendMethodResponseElementBegin(
           Buffer& out,
           const CIMName& name);
           static void _appendMethodResponseElementEnd(
           Buffer& out);
   
       static void _appendIMethodResponseElementBegin(
           Buffer& out,
           const CIMName& name);
           static void _appendIMethodResponseElementEnd(
           Buffer& out);
   
       static void _appendErrorElement(
           Buffer& out,
           const CIMException& cimException);
   
       static void _appendIReturnValueElementBegin(Buffer& out);
       static void _appendIReturnValueElementEnd(Buffer& out);
   
       static void _appendSimpleExportReqElementBegin(Buffer& out);
       static void _appendSimpleExportReqElementEnd(Buffer& out);
   
       static void _appendEMethodCallElementBegin(
           Buffer& out,
           const CIMName& name);
   
       static void _appendEMethodCallElementEnd(
           Buffer& out);
   
       static void _appendEParamValueElementBegin(
           Buffer& out,
           const char* name);
           static void _appendEParamValueElementEnd(
           Buffer& out);
   
       static void _appendSimpleExportRspElementBegin(Buffer& out);
       static void _appendSimpleExportRspElementEnd(Buffer& out);
   
       static void _appendEMethodResponseElementBegin(
           Buffer& out,
           const CIMName& name);
  
 PEGASUS_COMMON_LINKAGE Array<Sint8>& operator<<(      static void _appendEMethodResponseElementEnd(
     Array<Sint8>& out,          Buffer& out);
     const Indentor& x);  
  
 PEGASUS_COMMON_LINKAGE Array<Sint8>& operator<<(      XmlWriter() { }
     Array<Sint8>& out,  };
     const Array<Sint8>& x);  
  
 PEGASUS_COMMON_LINKAGE Array<Sint8>& operator<<(  
     Array<Sint8>& out,  
     Uint32 x);  
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END
  

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