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