1 /*
2 (C) Copyright IBM Corp. 2006, 2013
3
4 THIS FILE IS PROVIDED UNDER THE TERMS OF THE ECLIPSE PUBLIC LICENSE
5 ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS FILE
6 CONSTITUTES RECIPIENTS ACCEPTANCE OF THE AGREEMENT.
7
8 You can obtain a current copy of the Eclipse Public License from
9 http://www.opensource.org/licenses/eclipse-1.0.php
10
11 @author : Endre Bak, ebak@de.ibm.com
12 *
13 * Flag Date Prog Description
14 * -------------------------------------------------------------------------------
15 * 1720707 2007-05-17 ebak Conventional Node factory for CIM-XML SAX parser
16 * 2003590 2008-06-30 blaschke-oss Change licensing from CPL to EPL
17 * 2204488 2008-10-28 raman_arora Fix code to remove compiler warnings
18 * 2210455 2008-10-30 blaschke-oss Enhance javadoc, fix potential null pointers
19 * 2524131 2009-01-21 raman_arora Upgrade client to JDK 1.5 (Phase 1)
20 * 2763216 2009-04-14 blaschke-oss Code cleanup: visible spelling/grammar errors
21 * 2845211 2009-08-27 raman_arora Pull Enumeration Feature (SAX Parser)
22 * 2666 2013-09-19 blaschke-oss CR12: Remove ENUMERATIONCONTEXT
23 * 2672 2013-09-26 blaschke-oss Remove SIMPLEREQACK support
24 * 2690 2013-10-11 blaschke-oss Remove RESPONSEDESTINATION support
25 * 2538 2013-11-28 blaschke-oss CR14: Support new CORRELATOR element
26 */
27
28 package org.metricshub.wbem.sblim.cimclient.internal.cimxml.sax;
29
30 /*-
31 * ╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲
32 * WBEM Java Client
33 * ჻჻჻჻჻჻
34 * Copyright 2023 - 2025 MetricsHub
35 * ჻჻჻჻჻჻
36 * Licensed under the Apache License, Version 2.0 (the "License");
37 * you may not use this file except in compliance with the License.
38 * You may obtain a copy of the License at
39 *
40 * http://www.apache.org/licenses/LICENSE-2.0
41 *
42 * Unless required by applicable law or agreed to in writing, software
43 * distributed under the License is distributed on an "AS IS" BASIS,
44 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
45 * See the License for the specific language governing permissions and
46 * limitations under the License.
47 * ╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱╲╱
48 */
49
50 /**
51 * Class NodeConstIf
52 *
53 */
54 public interface NodeConstIf {
55 /**
56 * The CIM element is the root element of every XML Document that is valid
57 * with respect to this schema. <br>
58 *
59 *
60 * <!ELEMENT CIM (MESSAGE|DECLARATION)>
61 * <!ATTLIST CIM
62 * CIMVERSION CDATA #REQUIRED
63 * DTDVERSION CDATA #REQUIRED>
64 *
65 *
66 * @see String
67 */
68 public static final String CIM = "CIM";
69
70 /**
71 * The DECLARATION element defines a set of one or more declarations of CIM
72 * objects. <br>
73 *
74 *
75 *
76 * <!ELEMENT DECLARATION (DECLGROUP|DECLGROUP.WITHNAME|DECLGROUP.WITHPATH)+>
77 *
78 *
79 * @see String
80 */
81 public static final String DECLARATION = "DECLARATION";
82
83 /**
84 * The DECLGROUP element defines a logical set of CIM Class, Instance and
85 * Qualifier declarations. <br>
86 *
87 *
88 * <!ELEMENT DECLGROUP ((LOCALNAMESPACEPATH|NAMESPACEPATH)?,QUALIFIER.DECLARATION*,VALUE.OBJECT*)>
89 *
90 *
91 * @see String
92 */
93 public static final String DECLGROUP = "DECLGROUP";
94
95 /**
96 * The DECLGROUP.WITHNAME element defines a logical set of CIM Class,
97 * Instance and Qualifier declarations. <br>
98 *
99 *
100 * <!ELEMENT DECLGROUP.WITHNAME ((LOCALNAMESPACEPATH|NAMESPACEPATH)?,QUALIFIER.DECLARATION*,VALUE.NAMEDOBJECT*)>
101 *
102 *
103 * @see String
104 */
105 public static final String DECLGROUP_WITHNAME = "DECLGROUP.WITHNAME";
106
107 /**
108 * The DECLGROUP.WITHPATH element defines a logical set of CIM Class and
109 * Instance declarations. <br>
110 *
111 *
112 * <!ELEMENT DECLGROUP.WITHPATH (VALUE.OBJECTWITHPATH|VALUE.OBJECTWITHLOCALPATH)*>
113 *
114 *
115 * @see String
116 */
117 public static final String DECLGROUP_WITHPATH = "DECLGROUP.WITHPATH";
118
119 /**
120 * The QUALIFIER.DECLARATION element defines a single CIM Qualifier
121 * declaration. <br>
122 *
123 *
124 * <!ELEMENT QUALIFIER.DECLARATION (SCOPE?,(VALUE|VALUE.ARRAY)?)>
125 * <!ATTLIST QUALIFIER.DECLARATION
126 * %CIMName;
127 * %CIMType; #REQUIRED
128 * ISARRAY (true|false) #IMPLIED
129 * %ArraySize;
130 * %QualifierFlavor;>
131 *
132 *
133 * @see String
134 */
135 public static final String QUALIFIER_DECLARATION = "QUALIFIER.DECLARATION";
136
137 /**
138 * The SCOPE element defines the scope of a QUALIFIER.DECLARATION in the
139 * case that there are restrictions on the scope of the Qualifier
140 * declaration. <br>
141 *
142 *
143 * <!ELEMENT SCOPE EMPTY>
144 * <!ATTLIST SCOPE
145 * CLASS (true|false) "false"
146 * ASSOCIATION (true|false) "false"
147 * REFERENCE (true|false) "false"
148 * PROPERTY (true|false) "false"
149 * METHOD (true|false) "false"
150 * PARAMETER (true|false) "false"
151 * INDICATION (true|false) "false">
152 *
153 *
154 * @see String
155 */
156 public static final String SCOPE = "SCOPE";
157
158 /**
159 * The VALUE element is used to define a single (non-array) non-reference
160 * non-NULL CIM Property value, CIM Qualifier value, CIM Method return
161 * value, or CIM Method Parameter value. <br>
162 *
163 *
164 * <!ELEMENT VALUE (#PCDATA)>
165 *
166 *
167 * @see String
168 */
169 public static final String VALUE = "VALUE";
170
171 /**
172 * The VALUE.ARRAY element is used to represent the value of a CIM Property
173 * or Qualifier that has an array type. <br>
174 *
175 *
176 *
177 * <!ELEMENT VALUE.ARRAY (VALUE|VALUE.NULL)*>
178 *
179 *
180 * @see String
181 */
182 public static final String VALUE_ARRAY = "VALUE.ARRAY";
183
184 /**
185 * The VALUE.REFERENCE element is used to define a single CIM reference
186 * Property value. <br>
187 *
188 *
189 * <!ELEMENT VALUE.REFERENCE (CLASSPATH|LOCALCLASSPATH|CLASSNAME|INSTANCEPATH|LOCALINSTANCEPATH|INSTANCENAME)>
190 *
191 *
192 * @see String
193 */
194 public static final String VALUE_REFERENCE = "VALUE.REFERENCE";
195
196 /**
197 * The VALUE.REFARRAY element is used to represent the value of an array of
198 * CIM references. <br>
199 *
200 *
201 * <!ELEMENT VALUE.REFARRAY (VALUE.REFERENCE|VALUE.NULL)*>
202 *
203 *
204 * @see String
205 */
206 public static final String VALUE_REFARRAY = "VALUE.REFARRAY";
207
208 /**
209 * The VALUE.OBJECT element is used to define a value which is comprised of
210 * a single CIM Class or Instance definition. <br>
211 *
212 *
213 * <!ELEMENT VALUE.OBJECT (CLASS|INSTANCE)>
214 *
215 *
216 * @see String
217 */
218 public static final String VALUE_OBJECT = "VALUE.OBJECT";
219
220 /**
221 * The VALUE.NAMEDINSTANCE element is used to define a value which is
222 * comprised of a single named CIM Instance definition. <br>
223 *
224 *
225 *
226 * <!ELEMENT VALUE.NAMEDINSTANCE (INSTANCENAME,INSTANCE)>
227 *
228 *
229 * @see String
230 */
231 public static final String VALUE_NAMEDINSTANCE = "VALUE.NAMEDINSTANCE";
232
233 /**
234 * The VALUE.NAMEDOBJECT element is used to define a value which is
235 * comprised of a single named CIM Class or Instance definition. <br>
236 *
237 *
238 * <!ELEMENT VALUE.NAMEDOBJECT (CLASS|(INSTANCENAME,INSTANCE))>
239 *
240 *
241 * @see String
242 */
243 public static final String VALUE_NAMEDOBJECT = "VALUE.NAMEDOBJECT";
244
245 /**
246 * The VALUE.OBJECTWITHLOCALPATH element is used to define a value which is
247 * comprised of a single CIM Object (Class or Instance) definition with
248 * additional information that defines the local path to that Object. <br>
249 *
250 *
251 * <!ELEMENT VALUE.OBJECTWITHLOCALPATH ((LOCALCLASSPATH,CLASS)|(LOCALINSTANCEPATH,INSTANCE))>
252 *
253 *
254 * @see String
255 */
256 public static final String VALUE_OBJECTWITHLOCALPATH = "VALUE.OBJECTWITHLOCALPATH";
257
258 /**
259 * The VALUE.OBJECTWITHPATH element is used to define a value which is
260 * comprised of a single CIM Object (Class or Instance) definition with
261 * additional information that defines the absolute path to that Object. <br>
262 *
263 *
264 * <!ELEMENT VALUE.OBJECTWITHPATH ((CLASSPATH,CLASS)|(INSTANCEPATH,INSTANCE))>
265 *
266 *
267 * @see String
268 */
269 public static final String VALUE_OBJECTWITHPATH = "VALUE.OBJECTWITHPATH";
270
271 /**
272 * The VALUE.NULL element is used to represent a NULL value. <br>
273 *
274 *
275 * <!ELEMENT VALUE.NULL EMPTY>
276 *
277 *
278 * @see String
279 */
280 public static final String VALUE_NULL = "VALUE.NULL";
281
282 /**
283 * The VALUE.INSTANCEWITHPATH element is used to define value that comprises
284 * a single CIM instance definition with additional information that defines
285 * the absolute path to that object. <br>
286 *
287 *
288 * <!ELEMENT VALUE.INSTANCEWITHPATH (INSTANCEPATH, INSTANCE)>
289 *
290 *
291 * @see String
292 */
293 public static final String VALUE_INSTANCEWITHPATH = "VALUE.INSTANCEWITHPATH";
294
295 /**
296 * The NAMESPACEPATH element is used to define a Namespace Path. <br>
297 *
298 *
299 * <!ELEMENT NAMESPACEPATH (HOST,LOCALNAMESPACEPATH)>
300 *
301 *
302 * @see String
303 */
304 public static final String NAMESPACEPATH = "NAMESPACEPATH";
305
306 /**
307 * The LOCALNAMESPACEPATH element is used to define a local Namespace path
308 * (one without a Host component). <br>
309 *
310 *
311 * <!ELEMENT LOCALNAMESPACEPATH (NAMESPACE+)>
312 *
313 *
314 * @see String
315 */
316 public static final String LOCALNAMESPACEPATH = "LOCALNAMESPACEPATH";
317
318 /**
319 * The HOST element is used to define a single Host. <br>
320 *
321 *
322 * <!ELEMENT HOST (#PCDATA)>
323 *
324 *
325 * @see String
326 */
327 public static final String HOST = "HOST";
328
329 /**
330 * The NAMESPACE element is used to define a single Namespace component of a
331 * Namespace path. <br>
332 *
333 *
334 * <!ELEMENT NAMESPACE EMPTY>
335 * <!ATTLIST NAMESPACE
336 * %CIMName;>
337 *
338 *
339 * @see String
340 */
341 public static final String NAMESPACE = "NAMESPACE";
342
343 /**
344 * The CLASSPATH element defines the absolute path to a CIM Class. <br>
345 *
346 *
347 * <!ELEMENT CLASSPATH (NAMESPACEPATH,CLASSNAME)>
348 *
349 *
350 * @see String
351 */
352 public static final String CLASSPATH = "CLASSPATH";
353
354 /**
355 * The LOCALCLASSPATH element defines the a local path to a CIM Class. <br>
356 *
357 *
358 *
359 * <!ELEMENT LOCALCLASSPATH (LOCALNAMESPACEPATH, CLASSNAME)>
360 *
361 *
362 *
363 * @see String
364 */
365 public static final String LOCALCLASSPATH = "LOCALCLASSPATH";
366
367 /**
368 * The CLASSNAME element defines the qualifying name of a CIM Class. <br>
369 *
370 *
371 * <!ELEMENT CLASSNAME EMPTY>
372 * <!ATTLIST CLASSNAME
373 * %CIMName;>
374 *
375 *
376 * @see String
377 */
378 public static final String CLASSNAME = "CLASSNAME";
379
380 /**
381 * The INSTANCEPATH element defines the absolute path to a CIM Instance. <br>
382 *
383 *
384 * <!ELEMENT INSTANCEPATH (NAMESPACEPATH,INSTANCENAME)>
385 *
386 *
387 * @see String
388 */
389 public static final String INSTANCEPATH = "INSTANCEPATH";
390
391 /**
392 * The LOCALINSTANCEPATH element defines the local path to a CIM Instance. <br>
393 *
394 *
395 * <!ELEMENT LOCALINSTANCEPATH (LOCALNAMESPACEPATH,INSTANCENAME)>
396 *
397 *
398 * @see String
399 */
400 public static final String LOCALINSTANCEPATH = "LOCALINSTANCEPATH";
401
402 /**
403 * The INSTANCENAME element defines the location of a CIM Instance within a
404 * Namespace. <br>
405 *
406 *
407 * <!ELEMENT INSTANCENAME (KEYBINDING*|KEYVALUE?|VALUE.REFERENCE?)>
408 * <!ATTLIST INSTANCENAME
409 * %ClassName;>
410 *
411 *
412 * @see String
413 */
414 public static final String INSTANCENAME = "INSTANCENAME";
415
416 /**
417 * The OBJECTPATH element is used to define a full path to a single CIM
418 * Object (Class or Instance). <br>
419 *
420 *
421 * <!ELEMENT OBJECTPATH (INSTANCEPATH|CLASSPATH)>
422 *
423 *
424 * @see String
425 */
426 public static final String OBJECTPATH = "OBJECTPATH";
427
428 /**
429 * The KEYBINDING element defines a single key property value binding. <br>
430 *
431 *
432 * <!ELEMENT KEYBINDING (KEYVALUE|VALUE.REFERENCE)>
433 * <!ATTLIST KEYBINDING
434 * %CIMName;>
435 *
436 *
437 * @see String
438 */
439 public static final String KEYBINDING = "KEYBINDING";
440
441 /**
442 * The KEYVALUE element defines a single property key value when the key
443 * property is a non-reference type. <br>
444 *
445 *
446 * <!ELEMENT KEYVALUE (#PCDATA)>
447 * <!ATTLIST KEYVALUE
448 * VALUETYPE (string|boolean|numeric) "string"
449 * %CIMType; #IMPLIED>
450 *
451 *
452 * @see String
453 */
454 public static final String KEYVALUE = "KEYVALUE";
455
456 /**
457 * The CLASS element defines a single CIM Class. <br>
458 *
459 *
460 * <!ELEMENT CLASS (QUALIFIER*,(PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*,METHOD*)>
461 * <!ATTLIST CLASS
462 * %CIMName;
463 * %SuperClass;>
464 *
465 *
466 * @see String
467 */
468 public static final String CLASS = "CLASS";
469
470 /**
471 * The INSTANCE element defines a single CIM Instance of a CIM Class. <br>
472 *
473 *
474 * <!ELEMENT INSTANCE (QUALIFIER*,(PROPERTY|PROPERTY.ARRAY|PROPERTY.REFERENCE)*)>
475 * <!ATTLIST INSTANCE
476 * %ClassName;
477 * xml:lang NMTOKEN #IMPLIED>
478 *
479 *
480 * @see String
481 */
482 public static final String INSTANCE = "INSTANCE";
483
484 /**
485 * The QUALIFIER element defines a single CIM Qualifier. <br>
486 *
487 *
488 * <!ELEMENT QUALIFIER ((VALUE|VALUE.ARRAY)?)>
489 * <!ATTLIST QUALIFIER
490 * %CIMName;
491 * %CIMType; #REQUIRED
492 * %Propagated;
493 * %QualifierFlavor;
494 * xml:lang NMTOKEN #IMPLIED>
495 *
496 *
497 * @see String
498 */
499 public static final String QUALIFIER = "QUALIFIER";
500
501 /**
502 * The PROPERTY element defines the value in a CIM Instance or the
503 * definition in a CIM Class of a single (non-array) CIM Property that is
504 * not a reference. <br>
505 *
506 *
507 * <!ELEMENT PROPERTY (QUALIFIER*,VALUE?)>
508 * <!ATTLIST PROPERTY
509 * %CIMName;
510 * %CIMType; #REQUIRED
511 * %ClassOrigin;
512 * %Propagated;
513 * %EmbeddedObject;
514 * xml:lang NMTOKEN #IMPLIED>
515 *
516 *
517 * @see String
518 */
519 public static final String PROPERTY = "PROPERTY";
520
521 /**
522 * The PROPERTY.ARRAY element defines the value in a CIM Instance or the
523 * definition in a CIM Class of a single CIM Property with an array type. <br>
524 *
525 *
526 * <!ELEMENT PROPERTY.ARRAY (QUALIFIER*,VALUE.ARRAY?)>
527 * <!ATTLIST PROPERTY.ARRAY
528 * %CIMName;
529 * %CIMType; #REQUIRED
530 * %ArraySize;
531 * %ClassOrigin;
532 * %Propagated;
533 * %EmbeddedObject;
534 * xml:lang NMTOKEN #IMPLIED>
535 *
536 *
537 * @see String
538 */
539 public static final String PROPERTY_ARRAY = "PROPERTY.ARRAY";
540
541 /**
542 * The PROPERTY.REFERENCE element defines the value in a CIM Instance or the
543 * definition in a CIM Class of a single CIM Property with reference
544 * semantics. <br>
545 *
546 *
547 * <!ELEMENT PROPERTY.REFERENCE (QUALIFIER*,VALUE.REFERENCE?)>
548 * <!ATTLIST PROPERTY.REFERENCE
549 * %CIMName;
550 * %ReferenceClass;
551 * %ClassOrigin;
552 * %Propagated;>
553 *
554 *
555 * @see String
556 */
557 public static final String PROPERTY_REFERENCE = "PROPERTY.REFERENCE";
558
559 /**
560 *
561 * The METHOD element defines a single CIM Method. <br>
562 *
563 *
564 * <!ELEMENT METHOD (QUALIFIER*,(PARAMETER|PARAMETER.REFERENCE|PARAMETER.ARRAY|PARAMETER.REFARRAY)*)>
565 * <!ATTLIST METHOD
566 * %CIMName;
567 * %CIMType; #IMPLIED
568 * %ClassOrigin;
569 * %Propagated;>
570 *
571 *
572 * @see String
573 */
574 public static final String METHOD = "METHOD";
575
576 /**
577 * The PARAMETER element defines a single (non-array, non-reference)
578 * Parameter to a CIM Method. <br>
579 *
580 *
581 * <!ELEMENT PARAMETER (QUALIFIER*)>
582 * <!ATTLIST PARAMETER
583 * %CIMName;
584 * %CIMType; #REQUIRED>
585 *
586 *
587 * @see String
588 */
589 public static final String PARAMETER = "PARAMETER";
590
591 /**
592 * The PARAMETER.REFERENCE element defines a single reference Parameter to a
593 * CIM Method. <br>
594 *
595 *
596 * <!ELEMENT PARAMETER.REFERENCE (QUALIFIER*)>
597 * <!ATTLIST PARAMETER.REFERENCE
598 * %CIMName;
599 * %ReferenceClass;>
600 *
601 *
602 * @see String
603 */
604 public static final String PARAMETER_REFERENCE = "PARAMETER.REFERENCE";
605
606 /**
607 * The PARAMETER.ARRAY element defines a single Parameter to a CIM Method
608 * that has an array type. <br>
609 *
610 *
611 * <!ELEMENT PARAMETER.ARRAY (QUALIFIER*)>
612 * <!ATTLIST PARAMETER.ARRAY
613 * %CIMName;
614 * %CIMType; #REQUIRED
615 * %ArraySize;>
616 *
617 *
618 * @see String
619 */
620 public static final String PARAMETER_ARRAY = "PARAMETER.ARRAY";
621
622 /**
623 * The PARAMETER.REFARRAY element defines a single Parameter to a CIM Method
624 * that has an array of references type. <br>
625 *
626 *
627 * <!ELEMENT PARAMETER.REFARRAY (QUALIFIER*)>
628 * <!ATTLIST PARAMETER.REFARRAY
629 * %CIMName;
630 * %ReferenceClass;
631 * %ArraySize;>
632 *
633 *
634 * @see String
635 */
636 public static final String PARAMETER_REFARRAY = "PARAMETER.REFARRAY";
637
638 /*
639 * TABLE stuff is missing yet
640 */
641
642 /**
643 * The MESSAGE element models a single CIM message. <br>
644 *
645 *
646 * <!ELEMENT MESSAGE (SIMPLEREQ|MULTIREQ|SIMPLERSP|MULTIRSP|SIMPLEEXPREQ|MULTIEXPREQ|SIMPLEEXPRSP|MULTIEXPRSP)>
647 * <!ATTLIST MESSAGE
648 * ID CDATA #REQUIRED
649 * PROTOCOLVERSION CDATA #REQUIRED>>
650 *
651 *
652 * @see String
653 */
654 public static final String MESSAGE = "MESSAGE";
655
656 /**
657 * The MULTIREQ element defines a Multiple CIM Operation request. <br>
658 *
659 *
660 * <!ELEMENT MULTIREQ (SIMPLEREQ,SIMPLEREQ+)>
661 *
662 *
663 * @see String
664 */
665 public static final String MULTIREQ = "MULTIREQ";
666
667 /**
668 * The MULTIEXPREQ element defines a Multiple CIM Export request. <br>
669 *
670 *
671 * <!ELEMENT MULTIEXPREQ (SIMPLEEXPREQ,SIMPLEEXPREQ+)>
672 *
673 *
674 * @see String
675 */
676 public static final String MULTIEXPREQ = "MULTIEXPREQ";
677
678 /**
679 * The SIMPLEREQ element defines a Simple CIM Operation request. <br>
680 *
681 *
682 * <!ELEMENT SIMPLEREQ (METHODCALL|IMETHODCALL)>
683 *
684 *
685 * @see String
686 */
687 public static final String SIMPLEREQ = "SIMPLEREQ";
688
689 /**
690 * The SIMPLEEXPREQ element defines a Simple CIM Export request. <br>
691 *
692 *
693 * <!ELEMENT SIMPLEEXPREQ (EXPMETHODCALL)>
694 *
695 *
696 * @see String
697 */
698 public static final String SIMPLEEXPREQ = "SIMPLEEXPREQ";
699
700 /**
701 * The IMETHODCALL element defines a single intrinsic method invocation. <br>
702 *
703 *
704 * <!ELEMENT IMETHODCALL (LOCALNAMESPACEPATH,IPARAMVALUE*)>
705 * <!ATTLIST IMETHODCALL
706 * %CIMName;>
707 *
708 *
709 * @see String
710 */
711 public static final String IMETHODCALL = "IMETHODCALL";
712
713 /**
714 * The METHODCALL element defines a single method invocation on a Class or
715 * Instance. <br>
716 *
717 *
718 * <!ELEMENT METHODCALL ((LOCALCLASSPATH|LOCALINSTANCEPATH),PARAMVALUE*)>
719 * <!ATTLIST METHODCALL
720 * %CIMName;>
721 *
722 *
723 * @see String
724 */
725 public static final String METHODCALL = "METHODCALL";
726
727 /**
728 * The EXPMETHODCALL element defines a single export method invocation. <br>
729 *
730 *
731 * <!ELEMENT EXPMETHODCALL (EXPPARAMVALUE*)>
732 * <!ATTLIST EXPMETHODCALL
733 * %CIMName;>
734 *
735 *
736 * @see String
737 */
738 public static final String EXPMETHODCALL = "EXPMETHODCALL";
739
740 /**
741 * The PARAMVALUE element defines a single extrinsic method named parameter
742 * value. <br>
743 *
744 *
745 * <!ELEMENT PARAMVALUE (VALUE|VALUE.REFERENCE|VALUE.ARRAY|VALUE.REFARRAY)?>
746 * <!ATTLIST PARAMVALUE
747 * %CIMName;
748 * %ParamType; #IMPLIED
749 * %EmbeddedObject;>
750 *
751 *
752 * @see String
753 */
754 public static final String PARAMVALUE = "PARAMVALUE";
755
756 /**
757 * The IPARAMVALUE element defines a single intrinsic method named parameter
758 * value. <br>
759 *
760 *
761 * <!ELEMENT IPARAMVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE|CLASSNAME|INSTANCENAME|QUALIFIER.DECLARATION|CLASS|INSTANCE|VALUE.NAMEDINSTANCE)?>
762 * <!ATTLIST IPARAMVALUE
763 * %CIMName;>
764 *
765 *
766 * @see String
767 */
768 public static final String IPARAMVALUE = "IPARAMVALUE";
769
770 /**
771 * The EXPPARAMVALUE element defines a single export method named parameter
772 * value. <br>
773 *
774 *
775 * <!ELEMENT EXPPARAMVALUE (INSTANCE?)>
776 * <!ATTLIST EXPPARAMVALUE
777 * %CIMName;>
778 *
779 *
780 * @see String
781 */
782 public static final String EXPPARAMVALUE = "EXPPARAMVALUE";
783
784 /**
785 * The MULTIRSP element defines a Multiple CIM Operation response. <br>
786 *
787 *
788 * <!ELEMENT MULTIRSP (SIMPLERSP,SIMPLERSP+)>
789 *
790 *
791 * @see String
792 */
793 public static final String MULTIRSP = "MULTIRSP";
794
795 /**
796 * The MULTIEXPRSP element defines a Multiple CIM Export response. <br>
797 *
798 *
799 * <!ELEMENT MULTIEXPRSP (SIMPLEEXPRSP,SIMPLEEXPRSP+)>
800 *
801 *
802 * @see String
803 */
804 public static final String MULTIEXPRSP = "MULTIEXPRSP";
805
806 /**
807 * The SIMPLERSP element defines a Simple CIM Operation response. <br>
808 *
809 *
810 * <!ELEMENT SIMPLERSP (METHODRESPONSE|IMETHODRESPONSE)>
811 *
812 *
813 * @see String
814 */
815 public static final String SIMPLERSP = "SIMPLERSP";
816
817 /**
818 * The SIMPLEEXPRSP element defines a Simple CIM Export response. <br>
819 *
820 *
821 * <!ELEMENT SIMPLEEXPRSP (EXPMETHODRESPONSE)>
822 *
823 *
824 * @see String
825 */
826 public static final String SIMPLEEXPRSP = "SIMPLEEXPRSP";
827
828 /**
829 * The METHODRESPONSE defines the response to a single CIM extrinsic method
830 * invocation. <br>
831 *
832 *
833 *
834 * <!ELEMENT METHODRESPONSE (ERROR|(RETURNVALUE?,PARAMVALUE*))>
835 * <!ATTLIST METHODRESPONSE %CIMName;>
836 *
837 *
838 *
839 * @see String
840 */
841 public static final String METHODRESPONSE = "METHODRESPONSE";
842
843 /**
844 * The EXPMETHODRESPONSE defines the response to a single export method
845 * invocation. <br>
846 *
847 *
848 * <!ELEMENT EXPMETHODRESPONSE (ERROR|IRETURNVALUE?)>
849 * <!ATTLIST EXPMETHODRESPONSE
850 * %CIMName;>
851 *
852 *
853 * @see String
854 */
855 public static final String EXPMETHODRESPONSE = "EXPMETHODRESPONSE";
856
857 /**
858 * The IMETHODRESPONSE defines the response to a single intrinsic CIM method
859 * invocation. <br>
860 *
861 *
862 * <!ELEMENT IMETHODRESPONSE (ERROR|IRETURNVALUE?)>
863 * <!ATTLIST IMETHODRESPONSE
864 * %CIMName;>
865 *
866 *
867 * @see String
868 */
869 public static final String IMETHODRESPONSE = "IMETHODRESPONSE";
870
871 /**
872 * The ERROR element is used to define a fundamental error which prevented a
873 * method from executing normally. <br>
874 *
875 *
876 * <!ELEMENT ERROR (INSTANCE*)
877 * <!ATTLIST ERROR
878 * CODE CDATA #REQUIRED
879 * DESCRIPTION CDATA #IMPLIED>
880 *
881 *
882 * @see String
883 */
884 public static final String ERROR = "ERROR";
885
886 /**
887 * The RETURNVALUE element specifies the value returned from an extrinsic
888 * method call. <br>
889 *
890 *
891 * <!ELEMENT RETURNVALUE (VALUE|VALUE.REFERENCE)?>
892 * <!ATTLIST RETURNVALUE
893 * %EmbeddedObject;
894 * %ParamType; #IMPLIED>
895 *
896 *
897 * @see String
898 */
899 public static final String RETURNVALUE = "RETURNVALUE";
900
901 /**
902 * The IRETURNVALUE element specifies the value returned from an intrinsic
903 * method call. <br>
904 *
905 *
906 * <!ELEMENT IRETURNVALUE (CLASSNAME*|INSTANCENAME*|VALUE*|VALUE.OBJECTWITHPATH*|VALUE.OBJECTWITHLOCALPATH*VALUE.OBJECT*|OBJECTPATH*|QUALIFIER.DECLARATION*|VALUE.ARRAY?|VALUE.REFERENCE?|CLASS*|INSTANCE*|VALUE.NAMEDINSTANCE*)>
907 *
908 *
909 * @see String
910 */
911 public static final String IRETURNVALUE = "IRETURNVALUE";
912
913 /**
914 * The CORRELATOR element represents a server-defined operation correlator. <br>
915 *
916 *
917 * <!ELEMENT CORRELATOR (VALUE)>
918 * <!ATTLIST CORRELATOR
919 * %CIMName;
920 * %CIMType; #REQUIRED>
921 *
922 *
923 * @see String
924 */
925 public static final String CORRELATOR = "CORRELATOR";
926 }