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