1 mike 1.23 //%/////////////////////////////////////////////////////////////////////////////
2 //
3 // Copyright (c) 2000, 2001 The Open group, BMC Software, Tivoli Systems, IBM
4 //
5 // Permission is hereby granted, free of charge, to any person obtaining a copy
6 // of this software and associated documentation files (the "Software"), to
7 // deal in the Software without restriction, including without limitation the
8 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
9 // sell copies of the Software, and to permit persons to whom the Software is
10 // furnished to do so, subject to the following conditions:
11 //
12 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
13 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
14 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
15 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
16 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
17 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
18 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
19 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
20 //
21 //==============================================================================
22 mike 1.23 //
23 // Author: Mike Brasher (mbrasher@bmc.com)
24 //
25 // Modified By:
26 //
27 //%/////////////////////////////////////////////////////////////////////////////
28
29 #include <cstdlib>
30 #include <cstdio>
31 #include "CIMClass.h"
32 #include "CIMInstance.h"
33 #include "CIMQualifierDecl.h"
34 #include "XmlWriter.h"
35 #include "XmlParser.h"
36
37 PEGASUS_NAMESPACE_BEGIN
38
39 inline void AppendChar(Array<Sint8>& out, Char16 c)
40 {
41 out.append(Sint8(c));
42 }
43 mike 1.23
44 inline void AppendSpecialChar(Array<Sint8>& out, Char16 c)
45 {
46 // ATTN-B: Only UTF-8 handled for now.
47
48 switch (c)
49 {
50 case '&':
51 out.append("&", 5);
52 break;
53
54 case '<':
55 out.append("<", 4);
56 break;
57
58 case '>':
59 out.append(">", 4);
60 break;
61
62 case '"':
63 out.append(""", 6);
64 mike 1.23 break;
65
66 case '\'':
67 out.append("'", 6);
68 break;
69
70 default:
71 out.append(Sint8(c));
72 }
73 }
74
75 void XmlWriter::append(Array<Sint8>& out, Char16 x)
76 {
77 AppendChar(out, x);
78 }
79
80 void XmlWriter::append(Array<Sint8>& out, Uint32 x)
81 {
82 char buffer[32];
83 sprintf(buffer, "%d", x);
84 append(out, buffer);
85 mike 1.23 }
86
87 void XmlWriter::append(Array<Sint8>& out, const char* str)
88 {
89 while (*str)
90 AppendChar(out, *str++);
91 }
92
93 void XmlWriter::appendSpecial(Array<Sint8>& out, Char16 x)
94 {
95 AppendSpecialChar(out, x);
96 }
97
98 void XmlWriter::appendSpecial(Array<Sint8>& out, char x)
99 {
100 AppendSpecialChar(out, Char16(x));
101 }
102
103 void XmlWriter::appendSpecial(Array<Sint8>& out, const char* str)
104 {
105 while (*str)
106 mike 1.23 AppendSpecialChar(out, *str++);
107 }
108
109 void XmlWriter::appendSpecial(Array<Sint8>& out, const String& str)
110 {
111 const Char16* tmp = str.getData();
112
113 while (*tmp)
114 AppendSpecialChar(out, *tmp++);
115 }
116
117 void XmlWriter::append(Array<Sint8>& out, const String& str)
118 {
119 const Char16* tmp = str.getData();
120
121 while (*tmp)
122 AppendChar(out, *tmp++);
123 }
124
125 void XmlWriter::append(Array<Sint8>& out, const Indentor& x)
126 {
127 mike 1.23 for (Uint32 i = 0; i < 4 * x.getLevel(); i++)
128 out.append(' ');
129 }
130
131 void XmlWriter::appendLocalNameSpaceElement(
132 Array<Sint8>& out,
133 const String& nameSpace)
134 {
135 out << "<LOCALNAMESPACEPATH>\n";
136
137 char* tmp = nameSpace.allocateCString();
138
139 for (char* p = strtok(tmp, "/"); p; p = strtok(NULL, "/"))
140 {
141 out << "<NAMESPACE NAME=\"" << p << "\"/>\n";
142 }
143
144 delete [] tmp;
145
146 out << "</LOCALNAMESPACEPATH>\n";
147 }
148 mike 1.23
149 static inline void AppendSpecialChar(PEGASUS_STD(ostream)& os, char c)
150 {
151 switch (c)
152 {
153 case '&':
154 os << "&";
155 break;
156
157 case '<':
158 os << "<";
159 break;
160
161 case '>':
162 os << ">";
163 break;
164
165 case '"':
166 os << """;
167 break;
168
169 mike 1.23 case '\'':
170 os << "'";
171 break;
172
173 default:
174 os << c;
175 }
176 }
177
178 static inline void AppendSpecial(PEGASUS_STD(ostream)& os, const char* str)
179 {
180 while (*str)
181 AppendSpecialChar(os, *str++);
182 }
183
184 //------------------------------------------------------------------------------
185 //
186 // formatGetHeader()
187 //
188 //------------------------------------------------------------------------------
189
190 mike 1.23 Array<Sint8> XmlWriter::formatGetHeader(
191 const char* documentPath)
192 {
193 Array<Sint8> out;
194 return out << "GET " << documentPath << "HTTP/1.0\r\n\r\n";
195 }
196
197 //------------------------------------------------------------------------------
198 //
199 // formatMPostHeader()
200 //
201 // Build HTTP request header.
202 //
203 //------------------------------------------------------------------------------
204
205 Array<Sint8> XmlWriter::formatMPostHeader(
206 const char* host,
207 const char* cimOperation,
208 const char* cimMethod,
209 const String& cimObject,
210 const Array<Sint8>& content)
211 mike 1.23 {
212 Array<Sint8> out;
213 out.reserve(1024);
214 char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
215
216 out << "M-POST /cimom HTTP/1.1\r\n";
217 out << "HOST: " << host << "\r\n";
218 out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";
219 out << "Content-Length: " << content.size() << "\r\n";
220 out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";
221 out << nn <<"\r\n";
222 out << nn << "-CIMOperation: " << cimOperation << "\r\n";
223 out << nn << "-CIMMethod: " << cimMethod << "\r\n";
224 out << nn << "-CIMObject: " << cimObject << "\r\n\r\n";
225 out << content;
226 return out;
227 }
228
229 //------------------------------------------------------------------------------
230 //
231 // formatMethodResponseHeader()
232 mike 1.23 //
233 // Build HTTP response header.
234 //
235 //------------------------------------------------------------------------------
236
237 Array<Sint8> XmlWriter::formatMethodResponseHeader(
238 const Array<Sint8>& content)
239 {
240 Array<Sint8> out;
241 out.reserve(1024);
242 char nn[] = { '0' + (rand() % 10), '0' + (rand() % 10), '\0' };
243
244 out << "HTTP/1.1 200 OK\r\n";
245 out << "Content-CIMType: application/xml; charset=\"utf-8\"\r\n";
246 out << "Content-Length: " << content.size() << "\r\n";
247 out << "Ext:\r\n";
248 out << "Cache-Control: no-cache\r\n";
249 out << "Man: http://www.dmtf.org/cim/mapping/http/v1.0; ns=";
250 out << nn <<"\r\n";
251 out << nn << "-CIMOperation: MethodResponse\r\n\r\n";
252 out << content;
253 mike 1.23 return out;
254 }
255
256 //------------------------------------------------------------------------------
257 //
258 // formatMessageElement()
259 //
260 // <!ELEMENT MESSAGE (SIMPLEREQ|MULTIREQ|SIMPLERSP|MULTIRSP)>
261 // <!ATTLIST MESSAGE
262 // ID CDATA #REQUIRED
263 // PROTOCOLVERSION CDATA #REQUIRED>
264 //
265 //------------------------------------------------------------------------------
266
267 Array<Sint8> XmlWriter::formatMessageElement(
268 const String& messageId,
269 const Array<Sint8>& body)
270 {
271 Array<Sint8> out;
272 out.reserve(1024);
273
274 mike 1.23 out << "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n";
275 out << "<CIM CIMVERSION=\"2.0\" DTDVERSION=\"2.0\">\n";
276 out << "<MESSAGE ID=\"" << messageId << "\" PROTOCOLVERSION=\"1.0\">\n";
277 out << body;
278 out << "</MESSAGE>\n";
279 out << "</CIM>\n";
280 return out;
281 }
282
283 //------------------------------------------------------------------------------
284 //
285 // formatSimpleReqElement()
286 //
287 // <!ELEMENT SIMPLEREQ (IMETHODCALL|METHODCALL)>
288 //
289 //------------------------------------------------------------------------------
290
291 Array<Sint8> XmlWriter::formatSimpleReqElement(
292 const Array<Sint8>& body)
293 {
294 Array<Sint8> out;
295 mike 1.23 return out << "<SIMPLEREQ>\n" << body << "</SIMPLEREQ>\n";
296 }
297
298 //------------------------------------------------------------------------------
299 //
300 // formatSimpleRspElement()
301 //
302 // <!ELEMENT SIMPLERSP (METHODRESPONSE|IMETHODRESPONSE)>
303 //
304 //------------------------------------------------------------------------------
305
306 Array<Sint8> XmlWriter::formatSimpleRspElement(
307 const Array<Sint8>& body)
308 {
309 Array<Sint8> out;
310 return out << "<SIMPLERSP>\n" << body << "</SIMPLERSP>\n";
311 }
312
313 //------------------------------------------------------------------------------
314 //
315 // formatIMethodCallElement()
316 mike 1.23 //
317 // <!ELEMENT IMETHODCALL (LOCALNAMESPACEPATH,IPARAMVALUE*)>
318 // <!ATTLIST IMETHODCALL %CIMName;>
319 //
320 //------------------------------------------------------------------------------
321
322 Array<Sint8> XmlWriter::formatIMethodCallElement(
323 const char* name,
324 const String& nameSpace,
325 const Array<Sint8>& iParamValues)
326 {
327 Array<Sint8> out;
328 out << "<IMETHODCALL NAME=\"" << name << "\">\n";
329 XmlWriter::appendLocalNameSpaceElement(out, nameSpace);
330 out << iParamValues;
331 out << "</IMETHODCALL>\n";
332 return out;
333 }
334
335 //------------------------------------------------------------------------------
336 //
337 mike 1.23 // formatIMethodResponseElement()
338 //
339 // <!ELEMENT IMETHODRESPONSE (ERROR|IRETURNVALUE?)>
340 // <!ATTLIST IMETHODRESPONSE %CIMName;>
341 //
342 //------------------------------------------------------------------------------
343
344 Array<Sint8> XmlWriter::formatIMethodResponseElement(
345 const char* name,
346 const Array<Sint8>& body)
347 {
348 Array<Sint8> out;
349 out << "<IMETHODRESPONSE NAME=\"" << name << "\">\n";
350 out << body;
351 out << "</IMETHODRESPONSE>\n";
352 return out;
353 }
354
355 //------------------------------------------------------------------------------
356 //
357 // formatIReturnValueElement()
358 mike 1.23 //
359 // <!ELEMENT IRETURNVALUE (CLASSNAME*|INSTANCENAME*|VALUE*|
360 // VALUE.OBJECTWITHPATH*|VALUE.OBJECTWITHLOCALPATH*|VALUE.OBJECT*|
361 // OBJECTPATH*|QUALIFIER.DECLARATION*|VALUE.ARRAY?|VALUE.REFERENCE?|
362 // CLASS*|INSTANCE*|VALUE.NAMEDINSTANCE*)>
363 //
364 //------------------------------------------------------------------------------
365
366 Array<Sint8> XmlWriter::formatIReturnValueElement(
367 const Array<Sint8>& body)
368 {
369 Array<Sint8> out;
370 return out << "<IRETURNVALUE>\n" << body << "</IRETURNVALUE>\n";
371 }
372
373 //------------------------------------------------------------------------------
374 //
375 // formatIParamValueElement()
376 //
377 // <!ELEMENT IPARAMVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE
378 // |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION
379 mike 1.23 // |CLASS|INSTANCE|VALUE.NAMEDINSTANCE)?>
380 // <!ATTLIST IPARAMVALUE %CIMName;>
381 //
382 //------------------------------------------------------------------------------
383
384 Array<Sint8>& XmlWriter::formatIParamValueElement(
385 Array<Sint8>& out,
386 const char* name,
387 const Array<Sint8>& body)
388 {
389 out << "<IPARAMVALUE NAME=\"" << name << "\">\n";
390 out << body;
391 out << "</IPARAMVALUE>\n";
392 return out;
393 }
394
395 //------------------------------------------------------------------------------
396 //
397 // formatErrorElement()
398 //
399 //------------------------------------------------------------------------------
400 mike 1.23
401 Array<Sint8> XmlWriter::formatErrorElement(
402 CIMStatusCode code,
403 const char* description)
404 {
405 Array<Sint8> out;
406 out << "<ERROR";
407 out << " CODE=\"" << Uint32(code) << "\"";
408 out << " DESCRIPTION=\"";
409 appendSpecial(out, description);
410 out << "\"/>";
411 return out;
412 }
413
414 //------------------------------------------------------------------------------
415 //
416 // appendBooleanParameter()
417 //
418 //------------------------------------------------------------------------------
419
420 Array<Sint8>& XmlWriter::appendBooleanParameter(
421 mike 1.23 Array<Sint8>& out,
422 const char* name,
423 Boolean flag)
424 {
425 Array<Sint8> tmp;
426 tmp << "<VALUE>" << (flag ? "TRUE" : "FALSE") << "</VALUE>\n";
427 return formatIParamValueElement(out, name, tmp);
428 }
429
430 //------------------------------------------------------------------------------
431 //
432 // appendStringParameter()
433 //
434 //------------------------------------------------------------------------------
435
436 Array<Sint8>& XmlWriter::appendStringParameter(
437 Array<Sint8>& out,
438 const char* name,
439 const String& str)
440 {
441 Array<Sint8> tmp;
442 mike 1.23 tmp << "<VALUE>";
443 appendSpecial(tmp, str);
444 tmp << "</VALUE>\n";
445 return formatIParamValueElement(out, name, tmp);
446 }
447
448 //------------------------------------------------------------------------------
449 //
450 // appendClassNameParameter()
451 //
452 //------------------------------------------------------------------------------
453
454 Array<Sint8>& XmlWriter::appendClassNameParameter(
455 Array<Sint8>& out,
456 const char* name,
457 const String& className)
458 {
459 Array<Sint8> tmp;
460 appendClassNameElement(tmp, className);
461 return formatIParamValueElement(out, name, tmp);
462 }
463 mike 1.23
464 //------------------------------------------------------------------------------
465 //
466 // appendQualifierNameParameter()
467 //
468 //------------------------------------------------------------------------------
469
470 Array<Sint8>& XmlWriter::appendQualifierNameParameter(
471 Array<Sint8>& out,
472 const char* name,
473 const String& qualifierName)
474 {
475 // <!ELEMENT IPARAMVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE
476 // |INSTANCENAME|CLASSNAME|QUALIFIER.DECLARATION
477 // |CLASS|INSTANCE|VALUE.NAMEDINSTANCE)?>
478 //
479 // ATTN: notice that there is really no way to pass a qualifier name
480 // as an IPARAMVALUE element according to the spec (look above). So we
481 // just pass it as a class name. An answer must be obtained later.
482
483 Array<Sint8> tmp;
484 mike 1.23 appendClassNameElement(tmp, qualifierName);
485 return formatIParamValueElement(out, name, tmp);
486 }
487
488 //------------------------------------------------------------------------------
489 //
490 // appendClassParameter()
491 //
492 //------------------------------------------------------------------------------
493
494 Array<Sint8>& XmlWriter::appendClassParameter(
495 Array<Sint8>& out,
496 const char* parameterName,
497 const CIMConstClass& cimClass)
498 {
499 Array<Sint8> tmp;
500 cimClass.toXml(tmp);
501 return formatIParamValueElement(out, parameterName, tmp);
502 }
503
504 //------------------------------------------------------------------------------
505 mike 1.23 //
506 // appendInstanceNameParameter()
507 //
508 //------------------------------------------------------------------------------
509
510 Array<Sint8>& XmlWriter::appendInstanceNameParameter(
511 Array<Sint8>& out,
512 const char* parameterName,
513 const CIMReference& instanceName)
514 {
515 Array<Sint8> tmp;
516 instanceName.instanceNameToXml(tmp);
517 return formatIParamValueElement(out, parameterName, tmp);
518 }
519
520 //------------------------------------------------------------------------------
521 //
522 // appendInstanceParameter()
523 //
524 //------------------------------------------------------------------------------
525
526 mike 1.23 Array<Sint8>& XmlWriter::appendInstanceParameter(
527 Array<Sint8>& out,
528 const char* parameterName,
529 const CIMConstInstance& instance)
530 {
531 Array<Sint8> tmp;
532 instance.toXml(tmp);
533 return formatIParamValueElement(out, parameterName, tmp);
534 }
535
536 //----------------------------------------------------------
537 //
538 // appendPropertyNameParameter()
539 //
540 // </IPARAMVALUE>
541 // <IPARAMVALUE NAME="PropertyName"><VALUE>FreeSpace</VALUE></IPARAMVALUE>
542 //
543 // USE: Create parameter for getProperty operation
544 //==========================================================
545 Array<Sint8>& XmlWriter::appendPropertyNameParameter(
546 Array<Sint8>& out,
547 mike 1.23 const String& propertyName)
548 {
549 Array<Sint8> tmp;
550 tmp << "<VALUE>" << propertyName << "</VALUE>\n";
551 return formatIParamValueElement(out,"PropertyName", tmp);}
552
553 //------------------------------------------------------------------------------
554 //
555 // appendClassParameter()
556 //
557 //------------------------------------------------------------------------------
558
559 Array<Sint8>& XmlWriter::appendQualifierDeclarationParameter(
560 Array<Sint8>& out,
561 const char* parameterName,
562 const CIMConstQualifierDecl& qualifierDecl)
563 {
564 Array<Sint8> tmp;
565 qualifierDecl.toXml(tmp);
566 return formatIParamValueElement(out, parameterName, tmp);
567 }
568 mike 1.23
569 //------------------------------------------------------------------------------
570 //
571 // appendClassNameElement()
572 //
573 //------------------------------------------------------------------------------
574
575 Array<Sint8>& XmlWriter::appendClassNameElement(
576 Array<Sint8>& out,
577 const String& className)
578 {
579 return out << "<CLASSNAME NAME=\"" << className << "\"/>\n";
580 }
581
582 //------------------------------------------------------------------------------
583 //
584 // appendInstanceNameElement()
585 //
586 //------------------------------------------------------------------------------
587
588 Array<Sint8>& XmlWriter::appendInstanceNameElement(
589 mike 1.23 Array<Sint8>& out,
590 const CIMReference& instanceName)
591 {
592 instanceName.instanceNameToXml(out);
593 return out;
594 }
595
596 //------------------------------------------------------------------------------
597 //
598 // _printAttributes()
599 //
600 //------------------------------------------------------------------------------
601
602 static void _printAttributes(
603 PEGASUS_STD(ostream)& os,
604 const XmlAttribute* attributes,
605 Uint32 attributeCount)
606 {
607 for (Uint32 i = 0; i < attributeCount; i++)
608 {
609 os << attributes[i].name << "=";
610 mike 1.23
611 os << '"';
612 AppendSpecial(os, attributes[i].value);
613 os << '"';
614
615 if (i + 1 != attributeCount)
616 os << ' ';
617 }
618 }
619
620 //------------------------------------------------------------------------------
621 //
622 // _indent()
623 //
624 //------------------------------------------------------------------------------
625
626 static void _indent(PEGASUS_STD(ostream)& os, Uint32 level, Uint32 indentChars)
627 {
628 Uint32 n = level * indentChars;
629
630 for (Uint32 i = 0; i < n; i++)
631 mike 1.23 os << ' ';
632 }
633
634 //------------------------------------------------------------------------------
635 //
636 // indentedPrint()
637 //
638 //------------------------------------------------------------------------------
639
640 void XmlWriter::indentedPrint(
641 PEGASUS_STD(ostream)& os,
642 const char* text,
643 Uint32 indentChars)
644 {
645 char* tmp = strcpy(new char[strlen(text) + 1], text);
646
647 XmlParser parser(tmp);
648 XmlEntry entry;
649 Stack<const char*> stack;
650
651 while (parser.next(entry))
652 mike 1.23 {
653 switch (entry.type)
654 {
655 case XmlEntry::XML_DECLARATION:
656 {
657 _indent(os, stack.size(), indentChars);
658
659 os << "<?" << entry.text << " ";
660 _printAttributes(os, entry.attributes, entry.attributeCount);
661 os << "?>";
662 break;
663 }
664
665 case XmlEntry::START_TAG:
666 {
667 _indent(os, stack.size(), indentChars);
668
669 os << "<" << entry.text;
670
671 if (entry.attributeCount)
672 os << ' ';
673 mike 1.23
674 _printAttributes(os, entry.attributes, entry.attributeCount);
675 os << ">";
676 stack.push(entry.text);
677 break;
678 }
679
680 case XmlEntry::EMPTY_TAG:
681 {
682 _indent(os, stack.size(), indentChars);
683
684 os << "<" << entry.text << " ";
685 _printAttributes(os, entry.attributes, entry.attributeCount);
686 os << "/>";
687 break;
688 }
689
690 case XmlEntry::END_TAG:
691 {
692 if (!stack.isEmpty() && strcmp(stack.top(), entry.text) == 0)
693 stack.pop();
694 mike 1.23
695 _indent(os, stack.size(), indentChars);
696
697 os << "</" << entry.text << ">";
698 break;
699 }
700
701 case XmlEntry::COMMENT:
702 {
703
704 _indent(os, stack.size(), indentChars);
705 os << "<!--";
706 AppendSpecial(os, entry.text);
707 os << "-->";
708 break;
709 }
710
711 case XmlEntry::CONTENT:
712 {
713 _indent(os, stack.size(), indentChars);
714 AppendSpecial(os, entry.text);
715 mike 1.23 break;
716 }
717
718 case XmlEntry::CDATA:
719 {
720 _indent(os, stack.size(), indentChars);
721 os << "<![CDATA[...]]>";
722 break;
723 }
724
725 case XmlEntry::DOCTYPE:
726 {
727 _indent(os, stack.size(), indentChars);
728 os << "<!DOCTYPE...>";
729 break;
730 }
731 }
732
733 os << PEGASUS_STD(endl);
734 }
735
736 mike 1.23 delete [] tmp;
737 }
738
739 //------------------------------------------------------------------------------
740 //
741 // XmlWriter::getNextMessageId()
742 //
743 //------------------------------------------------------------------------------
744
745 String XmlWriter::getNextMessageId()
746 {
747 // ATTN: make thread-safe:
748 static Uint32 messageId = 1000;
749
750 messageId++;
751
752 if (messageId < 1000)
753 messageId = 1001;
754
755 char buffer[16];
756 sprintf(buffer, "%d", messageId);
757 mike 1.23 return buffer;
758 }
759
760 //------------------------------------------------------------------------------
761 //
762 // XmlWriter::formatSimpleReqMessage()
763 //
764 //------------------------------------------------------------------------------
765
766 Array<Sint8> XmlWriter::formatSimpleReqMessage(
767 const char* host,
768 const String& nameSpace,
769 const char* iMethodName,
770 const Array<Sint8>& body)
771 {
772 return XmlWriter::formatMPostHeader(
773 host,
774 "MethodCall",
775 iMethodName,
776 nameSpace,
777 XmlWriter::formatMessageElement(
778 mike 1.23 XmlWriter::getNextMessageId(),
779 XmlWriter::formatSimpleReqElement(
780 XmlWriter::formatIMethodCallElement(
781 iMethodName,
782 nameSpace,
783 body))));
784 }
785
786 Array<Sint8> XmlWriter::formatSimpleRspMessage(
787 const char* iMethodName,
788 const String& messageId,
789 const Array<Sint8>& body)
790 {
791 return XmlWriter::formatMethodResponseHeader(
792 XmlWriter::formatMessageElement(
793 messageId,
794 XmlWriter::formatSimpleRspElement(
795 XmlWriter::formatIMethodResponseElement(
796 iMethodName,
797 XmlWriter::formatIReturnValueElement(body)))));
798 }
799 mike 1.23
800 Array<Sint8>& operator<<(Array<Sint8>& out, const char* x)
801 {
802 XmlWriter::append(out, x);
803 return out;
804 }
805
806 Array<Sint8>& operator<<(Array<Sint8>& out, char x)
807 {
808 XmlWriter::append(out, x);
809 return out;
810 }
811
812 Array<Sint8>& operator<<(Array<Sint8>& out, Char16 x)
813 {
814 XmlWriter::append(out, x);
815 return out;
816 }
817
818 Array<Sint8>& operator<<(Array<Sint8>& out, const String& x)
819 {
820 mike 1.23 XmlWriter::append(out, x);
821 return out;
822 }
823
824 Array<Sint8>& operator<<(Array<Sint8>& out, const Indentor& x)
825 {
826 XmlWriter::append(out, x);
827 return out;
828 }
829
830 Array<Sint8>& operator<<(Array<Sint8>& out, const Array<Sint8>& x)
831 {
832 out.appendArray(x);
833 return out;
834 }
835
836 Array<Sint8>& operator<<(Array<Sint8>& out, Uint32 x)
837 {
838 XmlWriter::append(out, x);
839 return out;
840 }
841 mike 1.23
842 Array<Sint8>& XmlWriter::appendObjectNameParameter(
843 Array<Sint8>& out,
844 const char* name,
845 const CIMReference& objectName)
846 {
847 if (objectName.isClassName())
848 {
849 XmlWriter::appendClassNameParameter(
850 out, name, objectName.getClassName());
851 }
852 else
853 {
854 XmlWriter::appendInstanceNameParameter(
855 out, name, objectName);
856 }
857
858 return out;
859 }
860
861 PEGASUS_NAMESPACE_END
|
Return to
XmlWriter.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common