(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.23 and 1.23.2.5

version 1.23, 2001/07/10 22:31:16 version 1.23.2.5, 2001/11/09 02:58:18
Line 1 
Line 1 
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001 The Open group, BMC Software, Tivoli Systems, IBM  // Copyright (c) 2000, 2001 BMC Software, Hewlett-Packard Company, IBM,
   // 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
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 22 
Line 23 
 // //
 // Author: Mike Brasher (mbrasher@bmc.com) // Author: Mike Brasher (mbrasher@bmc.com)
 // //
 // Modified By:  // Modified By: Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 429 
Line 430 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendStringParameter()  // appendStringIParameter()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8>& XmlWriter::appendStringParameter(  Array<Sint8>& XmlWriter::appendStringIParameter(
     Array<Sint8>& out,     Array<Sint8>& out,
     const char* name,     const char* name,
     const String& str)     const String& str)
Line 552 
Line 553 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // appendClassParameter()  // appendPropertyValueParameter()
   //
   //------------------------------------------------------------------------------
   
   Array<Sint8>& XmlWriter::appendPropertyValueParameter(
       Array<Sint8>& out,
       const char* parameterName,
       const CIMValue& value)
   {
       Array<Sint8> tmp;
       value.toXml(tmp);
       return formatIParamValueElement(out, parameterName, tmp);
   }
   
   //------------------------------------------------------------------------------
   //
   // appendPropertyListParameter()
   //
   //------------------------------------------------------------------------------
   
   Array<Sint8>& XmlWriter::appendPropertyListParameter(
       Array<Sint8>& out,
       const Array<String>& propertyList)
   {
       Array<Sint8> tmp;
   
       tmp << "<VALUE.ARRAY>\n";
       for (int i=0; i<propertyList.size();i++)
       {
           tmp << "<VALUE>" << propertyList[i] << "</VALUE>\n";
       }
       tmp << "</VALUE.ARRAY>\n";
       return formatIParamValueElement(out, "PropertyList", tmp);
   }
   
   //------------------------------------------------------------------------------
   //
   // appendQualifierDeclarationParameter()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
Line 759 
Line 797 
  
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
 // //
 // XmlWriter::formatSimpleReqMessage()  // XmlWriter::formatSimpleIMethodReqMessage()
 // //
 //------------------------------------------------------------------------------ //------------------------------------------------------------------------------
  
 Array<Sint8> XmlWriter::formatSimpleReqMessage(  Array<Sint8> XmlWriter::formatSimpleIMethodReqMessage(
     const char* host,     const char* host,
     const String& nameSpace,     const String& nameSpace,
     const char* iMethodName,     const char* iMethodName,
       const String& messageId,
     const Array<Sint8>& body)     const Array<Sint8>& body)
 { {
     return XmlWriter::formatMPostHeader(     return XmlWriter::formatMPostHeader(
Line 775 
Line 814 
         iMethodName,         iMethodName,
         nameSpace,         nameSpace,
         XmlWriter::formatMessageElement(         XmlWriter::formatMessageElement(
             XmlWriter::getNextMessageId(),              messageId,
             XmlWriter::formatSimpleReqElement(             XmlWriter::formatSimpleReqElement(
                 XmlWriter::formatIMethodCallElement(                 XmlWriter::formatIMethodCallElement(
                     iMethodName,                     iMethodName,
Line 858 
Line 897 
     return out;     return out;
 } }
  
   Array<Sint8> XmlWriter::formatEMethodCallElement(
       const char* name,
       const Array<Sint8>& iParamValues)
   {
       Array<Sint8> out;
       out << "<EXPMETHODCALL NAME=\"" << name << "\">\n";
       out << iParamValues;
       out << "</EXPMETHODCALL>\n";
       return out;
   }
   
   Array<Sint8> XmlWriter::formatSimpleIndicationReqMessage(
       const char* host,
       const char* iMethodName,
       const String& messageId,
       const Array<Sint8>& body)
   {
       return XmlWriter::formatMPostIndicationHeader(
           host,
           "MethodRequest",
           iMethodName,
           XmlWriter::formatMessageElement(
               messageId,
               XmlWriter::formatSimpleExportReqElement(
                   XmlWriter::formatEMethodCallElement(
                       iMethodName,
                       body))));
   }
   
   Array<Sint8> XmlWriter::formatMPostIndicationHeader(
       const char* host,
       const char* cimOperation,
       const char* cimMethod,
       const Array<Sint8>& content)
   {
       Array<Sint8> out;
       out.reserve(1024);
       char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
   
       out << "M-POST /cimom HTTP/1.1\r\n";
       out << "HOST: " << host << "\r\n";
       out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";
       out << "Content-Length: " << content.size() << "\r\n";
       out << "Man: http://www.hp.com; ns=";
       out << nn <<"\r\n";
       out << nn << "-CIMExport: " << cimOperation << "\r\n";
       out << nn << "-CIMExportMethod: " << cimMethod << "\r\n\r\n";
       out << content;
       return out;
   }
   
   Array<Sint8> XmlWriter::formatSimpleExportReqElement(
       const Array<Sint8>& body)
   {
       Array<Sint8> out;
       return out << "<SIMPLEEXPREQ>\n" << body << "</SIMPLEEXPREQ>\n";
   }
   
   Array<Sint8> XmlWriter::formatSimpleIndicationRspMessage(
       const char* iMethodName,
       const String& messageId,
       const Array<Sint8>& body)
   {
       return XmlWriter::formatEMethodResponseHeader(
           XmlWriter::formatMessageElement(
               messageId,
               XmlWriter::formatSimpleExportRspElement(
                   XmlWriter::formatEMethodResponseElement(
                       iMethodName,
                       XmlWriter::formatIReturnValueElement(body)))));
   }
   
   //------------------------------------------------------------------------------
   //
   // formatSimpleExportRspElement()
   //
   //     <!ELEMENT SIMPLEEXPRSP (METHODRESPONSE|EXPMETHODRESPONSE)>
   //
   //------------------------------------------------------------------------------
   
   Array<Sint8> XmlWriter::formatSimpleExportRspElement(
       const Array<Sint8>& body)
   {
       Array<Sint8> out;
       return out << "<SIMPLEEXPRSP>\n" << body << "</SIMPLEEXPRSP>\n";
   }
   
   //------------------------------------------------------------------------------
   //
   // formatIMethodResponseElement()
   //
   //     <!ELEMENT EXPMETHODRESPONSE (ERROR|IRETURNVALUE?)>
   //     <!ATTLIST EXPMETHODRESPONSE %CIMName;>
   //
   //------------------------------------------------------------------------------
   
   Array<Sint8> XmlWriter::formatEMethodResponseElement(
       const char* name,
       const Array<Sint8>& body)
   {
       Array<Sint8> out;
       out << "<EXPMETHODRESPONSE NAME=\"" << name << "\">\n";
       out << body;
       out << "</EXPMETHODRESPONSE>\n";
       return out;
   }
   
   //------------------------------------------------------------------------------
   //
   // formatMethodResponseHeader()
   //
   //     Build HTTP response header.
   //
   //------------------------------------------------------------------------------
   
   Array<Sint8> XmlWriter::formatEMethodResponseHeader(
       const Array<Sint8>& content)
   {
       Array<Sint8> out;
       out.reserve(1024);
       char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
   
       out << "HTTP/1.1 200 OK\r\n";
       out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";
       out << "Content-Length: " << content.size() << "\r\n";
       out << "Ext:\r\n";
       out << "Cache-Control: no-cache\r\n";
       out << "Man:  http://www.dmtf.org/cim/mapping/http/v1.0; ns=";
       out << nn <<"\r\n";
       out << nn << "-CIMExport: MethodResponse\r\n\r\n";
       out << content;
       return out;
   }
   
   //------------------------------------------------------------------------------
   //
   // XmlWriter::formatSimpleMethodReqMessage()
   //
   //------------------------------------------------------------------------------
   
   Array<Sint8> XmlWriter::formatSimpleMethodReqMessage(
       const char* host,
       const String& nameSpace,
       const char* iMethodName,
       const String& messageId,
       const Array<Sint8>& body)
   {
       return XmlWriter::formatMPostHeader(
           host,
           "MethodCall",
           iMethodName,
           nameSpace,
           XmlWriter::formatMessageElement(
               messageId,
               XmlWriter::formatSimpleReqElement(
                   XmlWriter::formatMethodCallElement(
                       iMethodName,
                       nameSpace,
                       body))));
   }
   
   //------------------------------------------------------------------------------
   //
   // formatMethodCallElement()
   //
   //     <!ELEMENT METHODCALL (LOCALNAMESPACEPATH,IPARAMVALUE*)>
   //     <!ATTLIST METHODCALL %CIMName;>
   //
   //------------------------------------------------------------------------------
   
   Array<Sint8> XmlWriter::formatMethodCallElement(
       const char* name,
       const String& nameSpace,
       const Array<Sint8>& iParamValues)
   {
       Array<Sint8> out;
       out << "<METHODCALL NAME=\"" << name << "\">\n";
       out << iParamValues;
       out << "</METHODCALL>\n";
       return out;
   }
   
   Array<Sint8> XmlWriter::formatSimpleMethodRspMessage(
       const char* iMethodName,
       const String& messageId,
       const Array<Sint8>& body)
   {
       /*return XmlWriter::formatMethodResponseHeader(
           XmlWriter::formatMessageElement(
               messageId,
               XmlWriter::formatSimpleRspElement(
                   XmlWriter::formatMethodResponseElement(
                       iMethodName,
                       XmlWriter::formatReturnValueElement(body)))));*/
       return XmlWriter::formatMethodResponseHeader(
           XmlWriter::formatMessageElement(
               messageId,
               XmlWriter::formatSimpleRspElement(
                   XmlWriter::formatMethodResponseElement(
                       iMethodName,
                       body))));
   }
   
   //------------------------------------------------------------------------------
   //
   // formatMethodResponseElement()
   //
   //     <!ELEMENT METHODRESPONSE (ERROR|IRETURNVALUE?)>
   //     <!ATTLIST METHODRESPONSE %CIMName;>
   //
   //------------------------------------------------------------------------------
   
   Array<Sint8> XmlWriter::formatMethodResponseElement(
       const char* name,
       const Array<Sint8>& body)
   {
       Array<Sint8> out;
       out << "<METHODRESPONSE NAME=\"" << name << "\">\n";
       out << body;
       out << "</METHODRESPONSE>\n";
       return out;
   }
   
   //------------------------------------------------------------------------------
   //
   // appendStringParameter()
   //
   //------------------------------------------------------------------------------
   
   Array<Sint8>& XmlWriter::appendStringParameter(
       Array<Sint8>& out,
       const char* name,
       const String& str)
   {
       Array<Sint8> tmp;
       tmp << "<VALUE>";
       appendSpecial(tmp, str);
       tmp << "</VALUE>\n";
       return formatParamValueElement(out, name, tmp);
   }
   
   //------------------------------------------------------------------------------
   //
   // formatParamValueElement()
   //
   //     <!ELEMENT PARAMVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE
   //         |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION
   //         |CLASS|INSTANCE|VALUE.NAMEDINSTANCE)?>
   //     <!ATTLIST PARAMVALUE %CIMName;>
   //
   //------------------------------------------------------------------------------
   
   Array<Sint8>& XmlWriter::formatParamValueElement(
       Array<Sint8>& out,
       const char* name,
       const Array<Sint8>& body)
   {
       out << "<PARAMVALUE NAME=\"" << name << "\">\n";
       out << body;
       out << "</PARAMVALUE>\n";
       return out;
   }
   
   //------------------------------------------------------------------------------
   //
   // formatReturnValueElement()
   //
   //      <!ELEMENT RETURNVALUE (CLASSNAME*|INSTANCENAME*|VALUE*|
   //          VALUE.OBJECTWITHPATH*|VALUE.OBJECTWITHLOCALPATH*|VALUE.OBJECT*|
   //          OBJECTPATH*|QUALIFIER.DECLARATION*|VALUE.ARRAY?|VALUE.REFERENCE?|
   //          CLASS*|INSTANCE*|VALUE.NAMEDINSTANCE*)>
   //
   //------------------------------------------------------------------------------
   
   Array<Sint8> XmlWriter::formatReturnValueElement(
       const Array<Sint8>& body)
   {
       Array<Sint8> out;
       return out << "<RETURNVALUE>\n" << body << "</RETURNVALUE>\n";
   }
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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