pegasus/src/Pegasus/Common/XmlWriter.h - diff

Return to XmlWriter.h CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/XmlWriter.h between version 1.8 and 1.87

version 1.8, 2001/03/05 04:29:02

version 1.87, 2008/10/17 07:16:35

Line 1

//BEGIN_LICENSE

//%2006////////////////////////////////////////////////////////////////////////

// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.

// IBM Corp.; EMC Corporation, The Open Group.

// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; Symantec Corporation; The Open Group.

// Permission is hereby granted, free of charge, to any person obtaining a copy

// of this software and associated documentation files (the "Software"), to

// deal in the Software without restriction, including without limitation the

// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

// sell copies of the Software, and to permit persons to whom the Software is

// furnished to do so, subject to the following conditions:

// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN

// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED

// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT

// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR

// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

// Permission is hereby granted, free of charge, to any person obtaining a

//==============================================================================

// copy of this software and associated documentation files (the "Software"),

// to deal in the Software without restriction, including without limitation

// the rights to use, copy, modify, merge, publish, distribute, sublicense,

// and/or sell copies of the Software, and to permit persons to whom the

// Software is furnished to do so, subject to the following conditions:

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

//%/////////////////////////////////////////////////////////////////////////////

// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

// DEALINGS IN THE SOFTWARE.

//END_LICENSE

//BEGIN_HISTORY

// Author:

// $Log$

// Revision 1.8 2001/03/05 04:29:02 mike

// renamed CimException to CIMException

// Revision 1.7 2001/02/20 07:25:57 mike

// Added basic create-instance in repository and in client.

// Revision 1.6 2001/02/19 01:47:17 mike

// Renamed names of the form CIMConst to ConstCIM.

// Revision 1.5 2001/02/18 03:56:01 mike

// Changed more class names (e.g., ConstClassDecl -> ConstCIMClass)

// Revision 1.4 2001/02/16 02:06:07 mike

// Renamed many classes and headers.

// Revision 1.3 2001/01/31 08:20:51 mike

// Added dispatcher framework.

// Added enumerateInstanceNames.

// Revision 1.2 2001/01/29 02:23:44 mike

// Added support for GetInstance operation

// Revision 1.1.1.1 2001/01/14 19:53:36 mike

// Pegasus import

//END_HISTORY

////////////////////////////////////////////////////////////////////////////////

// XmlWriter.h

////////////////////////////////////////////////////////////////////////////////

#ifndef Pegasus_XmlWriter_h

#define Pegasus_XmlWriter_h

#include <iostream>

#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/Indentor.h>

#include <Pegasus/Common/CIMObject.h>

#include <Pegasus/Common/CIMReference.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/XmlGenerator.h>

PEGASUS_NAMESPACE_BEGIN

class CIMConstQualifierDecl;

class PEGASUS_COMMON_LINKAGE XmlWriter : public XmlGenerator

class ConstCIMClass;

class ConstCIMInstance;

class PEGASUS_COMMON_LINKAGE XmlWriter

{

public:

static void append(Array<Sint8>& out, Char16 x);

static void appendLocalNameSpacePathElement(

Buffer& out,

static void append(Array<Sint8>& out, char x)

const CIMNamespaceName& nameSpace);

{

append(out, Char16(x));

static void appendNameSpacePathElement(

}

Buffer& out,

const String& host,

static void append(Array<Sint8>& out, const char* x);

const CIMNamespaceName& nameSpace);

static void append(Array<Sint8>& out, const String& x);

static void appendClassNameElement(

Buffer& out,

static void append(Array<Sint8>& out, Uint32 x);

const CIMName& className);

static void appendSpecial(Array<Sint8>& out, Char16 x);

static void appendInstanceNameElement(

Buffer& out,

static void appendSpecial(Array<Sint8>& out, char x);

const CIMObjectPath& instanceName);

static void appendSpecial(Array<Sint8>& out, const char* x);

static void appendClassPathElement(

Buffer& out,

static void appendSpecial(Array<Sint8>& out, const String& x);

const CIMObjectPath& classPath);

static void append(Array<Sint8>& out, const Indentor& x);

static void appendInstancePathElement(

Buffer& out,

static void appendLocalNameSpaceElement(

const CIMObjectPath& instancePath);

Array<Sint8>& out,

const String& nameSpace);

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 void printValueReferenceElement(

const CIMObjectPath& reference,

PEGASUS_STD(ostream)& os=PEGASUS_STD(cout));

static void appendValueNamedInstanceElement(

Buffer& out,

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 appendNameSpaceElement(

static void appendQualifierDeclElement(

Array<Sint8>& out,

Buffer& out,

const String& nameSpace);

const CIMConstQualifierDecl& qualifierDecl);

static Array<Sint8> formatGetHeader(

static void printQualifierDeclElement(

const char* documentPath);

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 Array<Sint8> formatMPostHeader(

static void appendMethodCallHeader(

Buffer& out,

const char* host,

const char* cimOperation,

const CIMName& cimMethod,

const char* cimMethod,

const String& cimObject,

const Array<Sint8>& content);

const String& authenticationHeader,

HttpMethod httpMethod,

const AcceptLanguageList& acceptLanguages,

const ContentLanguageList& contentLanguages,

Uint32 contentLength);

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 appendParamTypeAndEmbeddedObjAttrib(

Buffer& out,

const CIMType& type);

static void appendReturnValueElement(

Buffer& out,

const CIMValue& value);

static Array<Sint8> formatMethodResponseHeader(

static void appendBooleanIParameter(

const Array<Sint8>& content);

Buffer& out,

const char* name,

Boolean flag);

static Array<Sint8> formatMessageElement(

static void appendStringIParameter(

Uint32 messageId,

Buffer& out,

const Array<Sint8>& body);

const char* name,

const String& str);

static Array<Sint8> formatSimpleReqElement(

static void appendClassNameIParameter(

const Array<Sint8>& body);

Buffer& out,

const char* name,

const CIMName& className);

static Array<Sint8> formatSimpleRspElement(

static void appendInstanceNameIParameter(

const Array<Sint8>& body);

Buffer& out,

const char* name,

const CIMObjectPath& instanceName);

static Array<Sint8> formatIMethodCallElement(

static void appendObjectNameIParameter(

Buffer& out,

const char* name,

const String& nameSpace,

const CIMObjectPath& objectName);

const Array<Sint8>& iParamValues);

static Array<Sint8> formatIReturnValueElement(

static void appendClassIParameter(

const Array<Sint8>& body);

Buffer& out,

const char* name,

const CIMConstClass& cimClass);

static Array<Sint8> formatIMethodResponseElement(

static void appendInstanceIParameter(

Buffer& out,

const char* name,

const Array<Sint8>& iParamValues);

const CIMConstInstance& instance);

static Array<Sint8>& formatIParamValueElement(

static void appendNamedInstanceIParameter(

Array<Sint8>& out,

Buffer& out,

const char* name,

const Array<Sint8>& body);

const CIMInstance& namedInstance) ;

static Array<Sint8> formatErrorElement(

static void appendPropertyNameIParameter(

CIMException::Code code,

Buffer& out,

const char* description);

const CIMName& propertyName);

static Array<Sint8>& appendBooleanParameter(

static void appendPropertyValueIParameter(

Array<Sint8>& out,

Buffer& out,

const char* parameterName,

const char* name,

Boolean flag);

const CIMValue& value);

static Array<Sint8>& appendClassNameParameter(

static void appendPropertyListIParameter(

Array<Sint8>& out,

Buffer& out,

const char* parameterName,

const CIMPropertyList& propertyList);

const String& className);

static void appendQualifierDeclarationIParameter(

static Array<Sint8>& appendQualifierNameParameter(

Buffer& out,

Array<Sint8>& out,

const char* name,

const char* parameterName,

const String& qualifierName);

static Array<Sint8>& appendClassParameter(

Array<Sint8>& out,

const char* parameterName,

const ConstCIMClass& cimClass);

static Array<Sint8>& appendInstanceNameParameter(

Array<Sint8>& out,

const char* parameterName,

const CIMReference& instanceName);

static Array<Sint8>& appendInstanceParameter(

Array<Sint8>& out,

const char* parameterName,

const ConstCIMInstance& instance);

static Array<Sint8>& appendQualifierDeclarationParameter(

Array<Sint8>& out,

const char* parameterName,

const CIMConstQualifierDecl& qualifierDecl);

static Array<Sint8>& appendClassNameElement(

static Buffer formatHttpErrorRspMessage(

Array<Sint8>& out,

const String& status,

const String& className);

const String& cimError = String::EMPTY,

const String& errorDetail = String::EMPTY);

static Array<Sint8>& appendInstanceNameElement(

Array<Sint8>& out,

const CIMReference& instanceName);

static void indentedPrint(

std::ostream& os,

const char* text,

Uint32 indentChars = 2);

static Array<Sint8> formatSimpleReqMessage(

static Buffer formatSimpleMethodReqMessage(

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,

static Array<Sint8> formatSimpleRspMessage(

const String& messageId,

const char* iMethodName,

HttpMethod httpMethod,

const Array<Sint8>& body);

const String& authenticationHeader,

const AcceptLanguageList& httpAcceptLanguages,

const ContentLanguageList& httpContentLanguages);

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 Buffer formatSimpleMethodErrorRspMessage(

const CIMName& methodName,

const String& messageId,

HttpMethod httpMethod,

const CIMException& cimException);

static Uint32 getNextMessageId();

static Buffer formatSimpleIMethodReqMessage(

const char* host,

private:

const CIMNamespaceName& nameSpace,

const CIMName& iMethodName,

const String& messageId,

HttpMethod httpMethod,

const String& authenticationHeader,

const AcceptLanguageList& httpAcceptLanguages,

const ContentLanguageList& httpContentLanguages,

const Buffer& body);

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);

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);

inline Array<Sint8>& operator<<(Array<Sint8>& out, const char* x)

static void appendEMethodRequestHeader(

{

Buffer& out,

XmlWriter::append(out, x);

const char* requestUri,

return out;

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);

inline Array<Sint8>& operator<<(Array<Sint8>& out, char x)

static Buffer formatSimpleEMethodReqMessage(

{

const char* requestUri,

XmlWriter::append(out, x);

const char* host,

return out;

const CIMName& eMethodName,

}

const String& messageId,

HttpMethod httpMethod,

const String& authenticationHeader,

const AcceptLanguageList& httpAcceptLanguages,

const ContentLanguageList& httpContentLanguages,

const Buffer& body);

static Buffer formatSimpleEMethodRspMessage(

const CIMName& eMethodName,

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();

/** Converts the given CIMKeyBinding type to one of the following:

"boolean", "string", or "numeric"

static const StrLit keyBindingTypeToString (CIMKeyBinding::Type type);

inline Array<Sint8>& operator<<(Array<Sint8>& out, Char16 x)

private:

{

XmlWriter::append(out, x);

return out;

}

inline Array<Sint8>& operator<<(Array<Sint8>& out, const String& x)

static void _appendMessageElementBegin(

{

Buffer& out,

XmlWriter::append(out, x);

const String& messageId);

return out;

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);

inline Array<Sint8>& operator<<(Array<Sint8>& out, const Indentor& x)

static void _appendEMethodResponseElementEnd(

{

Buffer& out);

XmlWriter::append(out, x);

return out;

}

inline Array<Sint8>& operator<<(Array<Sint8>& out, const Array<Sint8>& x)

XmlWriter();

{

};

out.appendArray(x);

return out;

}

inline Array<Sint8>& operator<<(Array<Sint8>& out, Uint32 x)

{

XmlWriter::append(out, x);

return out;

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.8
changed lines
	Added in v.1.87

No CVS admin address has been configured