Distributed Management Task Force, Inc.
Specification for the Representation of CIM in XML
Version 2.0
June 2nd, 1999
This list shows the names of the companies and organizations that have participated in the Distributed Management Task Force - CIM TDC XML Sub-Committee whose contributions made this document possible.
Version 1.0a | Tuesday, July 14th, 1998 | First Draft Release |
Version 1.0b | Friday August 7th, 1998 | Draft Release |
Version 1.0c | Friday August 28th, 1998 | Updated Version during Company review |
Version 1.0 | Tuesday, September 15th, 1998 | Final version |
Version 1.0.1 | Friday, January 22nd, 1999 | METHOD subelement removed from ASSOCIATION.INSTANCE |
Version 1.1a | Wednesday, April 28th, 1999 | Changes for support of HTTP protocol |
Version 2.0b | May 7th, 1999 | Updates after first Working Group Review |
Version 2.0c | May 11th, 1999 | DTD Corrections, changes to DECLGROUP and removal of IMPLICITKEY element |
Version 2.0d | May 20th, 1999 | Corrected error in definition of LOCALINSTANCEPATH |
Version 2.0e | May 25th, 1999 |
Corrected LOCALNAMESPACEPATH definition |
Version 2.0f | May 28th, 1999 |
Corrected VALUE.REFERENCE, KEYVALUE.REFERENCE and PARAMVALUE.REFERENCE so that they could contain relative and absolute paths |
Version 2.0 | June 2nd, 1999 |
Updated document references |
The Extensible Markup Language (XML) is a simplified subset of SGML that offers powerful and extensible data modeling capabilities. An XML Document is a collection of data represented in XML. An XML Schema is a grammar that describes the format of an XML Document. An XML Document is described as valid if it has an associated XML Schema to which it conforms.
The Common Information Model (CIM) is an object-oriented information model defined by the Distributed Management Task Force (DMTF) which provides a conceptual framework for describing management data.
This document defines a standard for the representation of Common Information Model (CIM) elements and messages in XML.
This document defines an XML grammar, written in DTD (Document Type Definition), which can be used both to represent CIM declarations (Classes, Instances and Qualifiers) and CIM Messages for use by the CIM mapping onto HTTP [9].
For convenience the complete unannotated DTD is available as a separate document [11].
There are potentially many different ways in which CIM information could be represented within XML. In the interests of interoperability between different implementations of CIM there is an obvious requirement for standardization of this representation. The following criteria have been applied in the design of the representation presented here:
Whilst this document makes no restrictions on the use of this mapping, it is recognized that a number of possible usage scenarios exist for which the mapping should cater:
Currently the W3C is still investigating the mechanisms by which XML documents are rendered. The available technologies include CSS (Cascading Style Sheets) [6,7] and XSL (Extensible Style Sheet Language) [8].
CSS is already established in the HTML/SGML domain, but is limited in the nature of transformations that it can express, being essentially a formatting technology that can alter the appearance of individual elements but cannot reorganize them. The XSL proposal attempts to address the shortcomings of CSS by providing more sophisticated reordering and formatting capabilities.
The subset of the DTD for CIM presented in this specification concerned with object declarations (identified by the element DECLARATION ) is intended to allow expression of CIM objects in XML sufficient for rendering into a number of formats, of which MOF is one.
The semantic content of a MOF file is fully captured by the DTD presented herein, so that it is possible to express any MOF conformant to [1] in an equivalent XML representation using this DTD. This includes the ability to express any of the standard MOF pragmas defined in [1], with the exception of the locale and instancelocale pragmas (which is a subject for further study in the context of localization support within CIM).
Note that the Processing Instruction (PI) mechanism defined by XML is the means by which bespoke pragmas may be added to an XML document in an analagous manner to the #pragma extension mechanism defined for MOF. The format of such PIs is necessarily outside the scope of this document.
CSS alone is not sufficient to provide a rendering of CIM XML declarations into MOF. XSL is capable of doing this, but due to the fact that it is not yet a full W3C recommendation, a standard stylesheet for MOF cannot be given at this time. Instead it is the intention to publish a companion document to this document which defines a MOF stylesheet based on the latest available XSL working draft, and to continue to track XSL as it evolves to a full recommendation.
The key phrases and words MUST, MUST NOT, REQUIRED, SHALL, SHALL NOT, SHOULD, SHOULD NOT, RECOMMENDED, MAY and OPTIONAL in this document are to be interpreted as described in RFC 2119 [10].
This document uses a number of stylistic conventions to highlight examples and definitions.
Examples are displayed in this fashion:
This is an example |
Definitions are illustrated thusly:
This is a definition |
There are two fundamentally different models for mapping CIM in XML:
Although there are obvious benefits to employing a schema mapping (more validation power, and a slightly more intuitive representation of CIM in XML), the metaschema mapping is adopted here for the following reasons:
Throught this document the term CIM Element is used to describe one of the following components of the CIM meta-model: Namespace, Class, Property, Method or Qualifier.
The term XML Element is used to describe a component of XML defined using the ELEMENT construct in DTD.
This section describes each of the parameter entities used in the CIM XML Schema vocabulary. The use of Parameter Entities has been adopted to highlight common features of the DTD.
The CIMName entity describes the name of a CIM Element (Class, Instance, Method, Property,Qualifier or Parameter). The value MUST be a legal CIM element name [1].
<!ENTITY % CIMName "NAME
CDATA #REQUIRED"> |
The CIMType entity describes the allowed type descriptions for a non-reference CIM Property, CIM Qualifier or non-reference CIM Method Parameter.
<!ENTITY % CIMType "TYPE |
The QualifierFlavor entity describes the flavor settings for a CIM Qualifier, modeled as XML attributes.
<!ENTITY %
QualifierFlavor "OVERRIDABLE (true|false) 'true' TOSUBCLASS (true|false) 'true' TOINSTANCE (true|false) 'false' TRANSLATABLE (true|false) 'false'"> |
The ClassOrigin entity describes the originating Class of a CIM Property or Method.
The CLASSORIGIN attribute defines the name of the originating class (the Class in which the Property or Method was first defined) of the CIM element represented by the XML element to which the attribute is attached.
<!ENTITY % ClassOrigin "CLASSORIGIN CDATA #IMPLIED"> |
The Propagated entity is a convenient shorthand for the PROPAGATED attribute, which may apply to a CIM Property, Method or Qualifier.
This attribute indicates whether the definition of the CIM Property, Qualifier or Method is local to the CIM Class (respectively, Instance) in which it appears, or was propagated without modification from the underlying Subclass (respectively, Class), as defined by [1].
<!ENTITY % Propagated "PROPAGATED (true|false) 'false'"> |
Uses of the PROPAGATED attribute include:
The ArraySize entity is a convenient shorthand for the ARRAYSIZE attribute, which may apply to a PROPERTY.ARRAY, PARAMETER.ARRAY or PARAMETER.REFARRAY element.
<!ENTITY % ArraySize "ARRAYSIZE CDATA #IMPLIED"> |
The ARRAYSIZE attribute defines the size of the array in the case that it is constrained to a fixed number of elements. The value of this attribute (if it is present) must be a positive integer.
The SuperClass entity is a convenient shorthand for the SUPERCLASS attribute.
<!ENTITY % SuperClass "SUPERCLASS CDATA #IMPLIED"> |
This attribute defines the name of the superclass. Where it is omitted, it MUST be inferred that the owning element has no superclass.
The ClassName entity is a convenient shorthand for the CLASSNAME attribute. The value MUST be a legal CIM Class name [1].
<!ENTITY % ClassName "CLASSNAME CDATA #REQUIRED"> |
The ReferenceClass entity is a convenient shorthand for the REFERENCECLASS attribute. If present, the value MUST be a legal CIM Class name [1].
<!ENTITY % ReferenceClass "REFERENCECLASS CDATA #IMPLIED"> |
The value defines the strong type of a CIM reference type. If absent, it MUST be inferred that the owning element is not a strong reference type.
This section describes each of the elements in the CIM XML Schema.
This section defines the root element of the XML Schema for CIM.
The CIM element is the root element of every XML Document that is valid with respect to this schema.
Each document takes one of two forms; it either contains a single MESSAGE element defining a CIM message (to be used in the HTTP mapping defined in [9]), or it contains a DECLARATION element used to declare a set of CIM objects.
<!ELEMENT CIM (MESSAGE |DECLARATION)> |
The CIMVERSION attribute defines the earliest version of the CIM Specification to which the XML Document conforms. It MUST be set to "2.0".
The DTDVERSION attribute defines the version of the CIM XML Mapping to which the XML Document conforms. It MUST be set to "2.0" to conform to this version of the specification.
This section defines those elements of the Schema that are concerned with expressing the declaration of CIM objects.
The DECLARATION element defines a set of one or more declarations of CIM objects. These are partitioned into logical declaration subsets.
<!ELEMENT DECLARATION
(DECLGROUP|DECLGROUP.WITHNAME|DECLGROUP.WITHPATH)+ > |
The DECLGROUP element defines a logical set of CIM Class, Instance and Qualifier declarations. It MAY optionally include a NAMESPACEPATH or LOCALNAMESPACEPATH element which, if present, defines the common namespace in which all objects within the group are declared.
The objects within the group are CIM Classes, Instances and Qualifiers.
<!ELEMENT DECLGROUP
((LOCALNAMESPACEPATH|NAMESPACEPATH)?,QUALIFIER.DECLARATION*,VALUE.OBJECT*)> |
The DECLGROUP.WITHNAME element defines a logical set of CIM Class, Instance and Qualifier declarations. It MAY optionally include a NAMESPACEPATH or LOCALNAMESPACEPATH element which, if present, defines the common namespace in which all objects within the group are declared.
The objects within the group are CIM Classes, Instances and Qualifiers.
This element extends the DECLGROUP element in the sense that any Instance declaration contains an explicit Instance Name (i.e. a Model Path in the terms of the CIM specification [1]).
<!ELEMENT DECLGROUP.WITHNAME ((LOCALNAMESPACEPATH|NAMESPACEPATH)?,QUALIFIER.DECLARATION*, VALUE.NAMEDOBJECT*)> |
The DECLGROUP.WITHPATH element defines a logical set of CIM Class and Instance declarations. Each object is declared with its own independent naming and location information.
<!ELEMENT DECLGROUP.WITHPATH (VALUE.OBJECTWITHPATH|VALUE.OBJECT WITHLOCALPATH)*> |
The QUALIFIER.DECLARATION element defines a single CIM Qualifier declaration.
The declaration MAY include a default value. If the Qualifier has a non-array type, it contains a single VALUE element representing the value of the Qualifier. If the Qualifier has an array type, it contains a single VALUE.ARRAY element to represent the value.
The SCOPE subelement, if present, defines the valid set of scopes for this Qualifier. If absent it implies that there is no restriction on the scope at which the Qualifier may be applied (so that it has 'any' scope in the terminology of CIM [1]).
<!ELEMENT
QUALIFIER.DECLARATION (SCOPE?,(VALUE|VALUE.ARRAY)?)> <!ATTLIST QUALIFIER.DECLARATION %CIMName; %CIMType; #REQUIRED ISARRAY (true|false) #IMPLIED %QualifierFlavor;> |
The NAME attribute defines the name of the Qualifier, and the TYPE and ISARRAY attributes together define the CIM Type. The ISARRAY attribute MUST be present if the Qualifier declares no default value, in order to infer whether the Qualifier has an array type or not. The ISARRAY attribute SHOULD be absent if the Qualifier declares a default value, as in this case whether the Qualifier has an array type can be deduced from whether a VALUE or VALUE.ARRAY element is used to declare that default; if present its value MUST be consistent with the declared Qualifier default value.
The flavor attributes declared using the QualifierFlavor entity define the propogation and override semantics for the Qualifier.
The SCOPE element defines the scope of a QUALIFIER.DECLARATION in the case that there are restrictions on the scope of the Qualifier declaration.
<!ELEMENT SCOPE
EMPTY> <!ATTLIST SCOPE CLASS (true|false) 'false' INSTANCE (true|false) 'false' ASSOCIATION (true|false) 'false' REFERENCE (true|false) 'false' PROPERTY (true|false) 'false' METHOD (true|false) 'false' PARAMETER (true|false) 'false' INDICATION (true|false) 'false'>
|
The attributes define which scopes are valid. A SCOPE element MUST declare at least one attribute with a true value (otherwise the Qualifier would have no applicable scope).
This section defines those elements of the Schema that are concerned with expressing the value of CIM objects.
The VALUE element is used to define a single (non-array and non-reference) CIM Property value, CIM Qualifier value, or a CIM Method Parameter value.
<!ELEMENT VALUE
(#PCDATA)> |
Values are not type-validatable using DTD, so each value appears in PCDATA format irrespective of the type. The TYPE attribute of the parent element will determine the (CIM) type of the value. The format of the PCDATA content depends on the CIM type, and is described in what follows.
String Values
If the CIM type is string, then the PCDATA value MUST be a sequence of zero or more UCS-2 characters. The value MUST NOT be surrounded by string delimiter characters (such as double-quote or single-quote). The actual representation of characters depends on the encoding attribute defined for the <?xml> processing instruction.
If this value contains reserved XML characters, then this value MUST either be enclosed within the standard XML data escape sequence <![CDATA[ ... ]]>, or standard XML character escaping mechanisms MUST be applied to those characters.
In particular if the content contains the ]]> sequence, the CDATA escape mechanism MUST NOT be used.
Character Values
If the CIM type is char, then the PCDATA value MUST be a single UCS-2 character. The value MUST NOT be surrounded by single-quote characters. If this value is a reserved XML character, then it MUST be escaped using standard XML character escaping mechanisms. The actual representation of the character depends on the encoding attribute defined for the <?xml> processing instruction.
Real Values
If the CIM type is real32 or real64, then the PCDATA value MUST conform to the following syntax:
[ "+" | "-" ] *decimalDigit "." 1*decimalDigit [ ( "e" | "E" ) [ "+" | "-" ] 1*decimalDigit ]
where decimalDigit is any character from the set {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}.
Boolean Values
If the CIM type is boolean, then the PCDATA value MUST be either TRUE or FALSE. These values MUST be treated as case-insensitive.
Integer Values
If the CIM type belongs to the set {uint8, uint16, uint32, uint64} then the PCDATA value MUST be a valid unsigned decimal or hexadecimal value.
If the CIM type belongs to the set {sint8, sint16, sint32, sint64} then the PCDATA value MUST be a valid signed decimal or hexadecimal value.
Decimal values have the format:
[ "+" | "-" ] ( positiveDecimalDigit *decimalDigit | "0" )
Where decimalDigit is as defined above and positiveDecimalDigit is any decimal digit other than 0. The leading sign character MUST NOT be used when the CIM type is unsigned.
Hexadecimal values have the format:
[ "+" | "-" ] ( "0x" | "0X" ) 1*hexDigit
Where hexDigit is either a decimalDigit or a character from the set {a, A, b, B, c, C, d, D, e, E, f, F}. The leading sign character MUST NOT be used when the CIM type is unsigned.
Datetime Values
If the CIM type is datetime then the PCDATA value MUST be a valid datetime value as defined in detail by the CIM specification [1]. (For interval values the format is ddddddddhhmmss.mmmmmm:000, and for absolute values the format is yyyymmddhhmmss.mmmmmmsutc).
The value MUST NOT be surrounded by string delimiter characters (such as double-quote or single-quote).
The VALUE.ARRAY element is used to represent the value of a CIM Property or Qualifier that has an array type.
CIM arrays are classified as "Bag", "Ordered" or "Indexed" [1] using the ARRAYTYPE Qualifier. If the array is Ordered or Indexed then the constituent VALUE elements MUST appear in the correct order.
<!ELEMENT VALUE.ARRAY (VALUE*)>
The VALUE.REFERENCE element is used to define a single CIM reference Property value.
If a LOCALCLASSPATH or LOCALINSTANCEPATH subelement is used, the target object is assumed to be on the same host. If a CLASSNAME or INSTANCENAME is used, the target object is assumed to be in the same Namespace.
<!ELEMENT VALUE.REFERENCE (CLASSPATH|LOCALCLASSPATH|CLASSNAME|INSTANCEPATH|LOCALINSTANCEPATH|INSTANCENAME)> |
The VALUE.REFARRAY element is used to represent the value of an array of CIM references.
CIM arrays are classified as "Bag", "Ordered" or "Indexed" [1] using the ARRAYTYPE Qualifier. If the array is Ordered or Indexed then the constituent VALUE.REFERENCE elements MUST appear in the correct order.
<!ELEMENT VALUE.REFARRAY (VALUE.REFERENCE*)>
The VALUE.OBJECT element is used to define a value which is comprised of a single CIM Class or Instance definition.
<!ELEMENT VALUE.OBJECT (CLASS|ASSOCIATION.CLASS|INSTANCE|ASSOCIATION.INSTANCE )> |
The VALUE.NAMEDOBJECT element is used to define a value which is comprised of a single named CIM Class or Instance definition.
<!ELEMENT VALUE.NAMEDOBJECT (CLASS|ASSOCIATION.CLASS|(INSTANCENAME,(INSTANCE|ASSOCIATION.INSTANCE )))> |
The VALUE.OBJECTWITHPATH element is used to define a value which is comprised of a single CIM Object (Class or Instance) definition with additional information that defines the absolute path to that Object.
<!ELEMENT VALUE.OBJECTWITHPATH ((CLASSPATH,(CLASS|ASSOCIATION.CLASS))|(INSTANCEPATH,(INSTANCE|ASSOCIATION.INSTANCE))) > |
The VALUE.OBJECTWITHLOCALPATH element is used to define a value which is comprised of a single CIM Object (Class or Instance) definition with additional information that defines the local path to that Object.
<!ELEMENT VALUE.OBJECTWITHLOCALPATH
((LOCALCLASSPATH,(CLASS|ASSOCIATION.CLASS))|(LOCALINSTANCEPATH,(INSTANCE|ASSOCIATION.INSTANCE))) > |
This section defines those elements of the Schema that are concerned with expressing the name and location of CIM objects.
The NAMESPACEPATH element is used to define a Namespace Path. It consists of a HOST element and a LOCALNAMESPACE element.
The NAMESPACE elements MUST appear in heirarchy order, with the root Namespace appearing first.
<!ELEMENT NAMESPACEPATH (HOST,LOCALNAMESPACEPATH)>
|
The LOCALNAMESPACEPATH element is used to define a local Namespace path (one without a Host component). It consists of one or more NAMESPACE elements (one for each namespace in the path).
<!ELEMENT LOCALNAMESPACEPATH (NAMESPACE+)>
|
The HOST element is used to define a single Host. The element content MUST specify a legal value for a hostname in accordance with the CIM specification [1].
<!ELEMENT HOST (#PCDATA)>
|
The NAMESPACE element is used to define a single Namespace component of a Namespace path.
<!ELEMENT NAMESPACE EMPTY> |
The NAME attribute defines the name of the Namespace.
The CLASSPATH element defines the absolute path to a CIM Class. It is formed from a namespace path and Class name.
<!ELEMENT CLASSPATH (NAMESPACEPATH,CLASSNAME) > |
The LOCALCLASSPATH element defines the a local path to a CIM Class. It is formed from a local namespace path and Class name.
<!ELEMENT LOCALCLASSPATH (LOCALNAMESPACEPATH,CLASSNAME) > |
The CLASSNAME element defines the qualifying name of a CIM Class.
<!ELEMENT CLASSNAME EMPTY > |
The NAME attribute defines the name of the class.
The INSTANCEPATH element defines the absolute path to a CIM Instance. It is comprised of a Namespace path and an Instance Name (model path).
<!ELEMENT INSTANCEPATH (NAMESPACEPATH ,INSTANCENAME)> |
The LOCALINSTANCEPATH element defines the local path to a CIM Instance. It is comprised of a local Namespace path and an Instance Name (model path).
<!ELEMENT LOCALINSTANCEPATH (LOCALNAMESPACEPATH ,INSTANCENAME)> |
The INSTANCENAME element defines the location of a CIM Instance within a Namespace (it is referred to in the CIM Specification [1] as a Model Path). It is comprised of a class name and a key binding information.
If the Class has a single key property, then a single KEYVALUE or KEYVALUE.REFERENCE subelement may be used to describe the (necessarily) unique key value without a key name. Alternatively a single KEYBINDING sublement may be used instead.
If the Class has more than one key property, then a KEYBINDING subelement MUST appear for each key.
If there are no key-bindings specified, the instance is assumed to be a singleton instance of a keyless Class.
<!ELEMENT INSTANCENAME ( KEYBINDING*| KEYVALUE?|KEYVALUE.REFERENCE?)><!ATTLIST INSTANCENAME %ClassName;> |
The CLASSNAME attribute defines the name of the class for this path.
The OBJECTPATH element is used to define a full path to a single CIM Object (Class or Instance).
<!ELEMENT OBJECTPATH (INSTANCEPATH|CLASSPATH) > |
The KEYBINDING element defines a single key property value binding.
<!ELEMENT KEYBINDING ( KEYVALUE|KEYVALUE.REFERENCE)><!ATTLIST KEYBINDING %CIMName;> |
The NAME attribute indicates the name of the key property.
The KEYVALUE element defines a single property key value when the key property is a non-reference type.
<!ELEMENT KEYVALUE (#PCDATA)> |
Values are not type-validatable using DTD, so each value appears in PCDATA format irrespective of the type. The CIM Type of the underlying key property determines the format of the PCDATA value. The rules for how the content of this element is formatted depending on that CIM type are exactly the same as for the VALUE element.
The VALUETYPE attribute provides necessary and sufficient information regarding the CIM type to allow the transformation of the key value to and from its' textual equivalent (as part of a text-based CIM object path, as defined in [1]). The value of this attribute MUST conform to the following rules:
The KEYVALUE.REFERENCE element defines a single property key value when the key property is a reference type.
If a LOCALCLASSPATH or LOCALINSTANCEPATH subelement is used, the target object is assumed to be on the same host. If a CLASSNAME or INSTANCENAME is used, the target object is assumed to be in the same Namespace.
<!ELEMENT KEYVALUE.REFERENCE (CLASSPATH|LOCALCLASSPATH|CLASSNAME|INSTANCEPATH|LOCALINSTANCEPATH|INSTANCENAME)> |
This section defines those elements of the Schema that are concerned with expressing the definition of CIM objects (Classes, Instances, Properties, Methods and Qualifiers).
The CLASS element defines a single (non-Association) CIM Class.
<!ELEMENT CLASS (QUALI FIER*,(PROPERTY|PROPERTY.ARRAY)*, METHOD*)><!ATTLIST CLASS %CIMName; %SuperClass;> |
The NAME attribute defines the name of the Class.
The SUPERCLASS attribute, if present, defines the name of the superclass of this class. If absent, it should be inferred that the class in question has no superclass.
The ASSOCIATION.CLASS element defines a single CIM Association Class. This is modeled separately from a non-Association Class as only Associations can have reference properties. In future the features of XML Linking [4] may be used to identify linking elements within the XML Document; as XML Linking is currently only at Working Draft status no explicit dependencies have been made at this point.
Note that CIM mandates that an Association must have at least two references, and that references can only be used in the context of Associations.
<!ELEMENT ASSOCIATION.CLASS (QUALIFIER*,PROPERTY.REFERENCE ,PROPERTY.REFERENCE +, D*)> |
The NAME attribute defines the name of the Class.
The SUPERCLASS attribute, if present, defines the name of the superclass of this class. If absent, it should be inferred that the class in question has no superclass.
The INSTANCE element defines a single CIM Instance of a (non-Association) CIM Class.
<!ELEMENT INSTANCE (QUALIFIER *,(PROPERTY|PROPERTY.ARRAY )*)> |
The CLASSNAME attribute defines the name of the CIM Class of which this is an Instance.
The ASSOCIATION.INSTANCE element defines a single Instance of a CIM Association Class. This is modeled separately from a non-Association Class as only Associations can have reference properties. In future the features of XML Linking [4] may be used to identify linking elements within the XML Document; as XML Linking is currently only at Working Draft status no explicit dependencies have been made at this point.
Note that CIM mandates that an Association must have at least two references, and that references can only be used in the context of Associations.
<!ELEMENT
ASSOCIATION.INSTANCE (QUALIFIER*,PROPERTY.REFERENCE,PROPERTY.REFERENCE+, (PROPERTY|PROPERTY.ARRAY)*)> <!ATTLIST ASSOCIATION.INSTANCE %ClassName;> |
The CLASSNAME attribute defines the name of the CIM Class of which this is an Instance.
The QUALIFIER element defines a single CIM Qualifier. If the Qualifier has a non-array type, it contains a single VALUE element representing the value of the Qualifier. If the Qualifier has an array type, it contains a single VALUE.ARRAY element to represent the value.
<!ELEMENT QUALIFIER (VALUE|VALUE.ARRAY)> <!ATTLIST QUALIFIER %CIMName; %CIMType; #REQUIRED %Propagated; %QualifierFlavor;> |
The NAME attribute defines the name of the Qualifier, and the TYPE defines the CIM Type.
The PROPERTY element defines a single (non-array) CIM Property that is not a reference. It contains a single VALUE element representing the value of the Property.
If the Property has no assigned value then the VALUE element MUST be absent.
CIM Reference Properties are described using the PROPERTY.REFERENCE element.
<!ELEMENT PROPERTY (QUALIFIER*,VALUE?)> <!ATTLIST PROPERTY %CIMName; %CIMType; #REQUIRED %ClassOrigin; %Propagated;> |
The NAME attribute defines the name of the Property, and the TYPE defines the CIM Type.
The PROPERTY.ARRAY element defines a single CIM Property with an array type. It contains a single VALUE.ARRAY element representing the value of the Property.
If the Property has no assigned value then the VALUE.ARRAY element MUST be absent.
There is no element to model a Property that contains an array of references as this is not a valid Property type according to CIM [1].
<!ELEMENT PROPERTY.ARRAY (QUALIFIER*,VALUE.ARRAY?)> |
The NAME attribute defines the name of the Property, and the TYPE defines the CIM Type.
If the ARRAYSIZE attribute is not present on a PROPERTY.ARRAY element within a containing CLASS or ASSOCIATION.CLASS element, this indicates that the array is of variable size.
Presence or otherwise of the ARRAYSIZE attribute on a PROPERTY.ARRAY element within a containing INSTANCE or ASSOCIATION.INSTANCE element MUST NOT be taken to imply that the Property type is or is not a fixed-size array (i.e. the CLASS or ASSOCIATION.CLASS definition is always authoritative in this respect).
The PROPERTY.REFERENCE element models a single CIM Property with reference semantics. In future the features of XML Linking [4] may be used to identify linking elements within the XML Document; as XML Linking is currently only at Working Draft status no explicit dependencies have been made at this point.
<!ELEMENT
PROPERTY.REFERENCE (QUALIFIER*,VALUE.REFERENCE?)> <!ATTLIST PROPERTY.REFERENCE %CIMName; %ReferenceClass; %ClassOrigin; %Propagated;> |
The NAME attribute defines the name of the Property.
The REFERENCECLASS attribute, if present, defines the strong type of the reference. If not present it indicates that this reference is not strongly typed.
The ClassOrigin and Propagated entities are used in the same manner as for other CIM Properties.
The METHOD element defines a single CIM Method. It may have Qualifiers, and zero or more parameters.
The order of the METHODPARAMETER subelements is significant as it MUST conform to the parameter order in the formal signature of the method.
<!ELEMENT METHOD (QUALIFIER*,METHODPARAMETER*)> <!ATTLIST METHOD %CIMName; %CIMType; #IMPLIED %ClassOrigin; %Propagated;> |
The NAME attribute defines the name of the Method.
The TYPE attribute defines the method return type, if the method returns a value. If this attribute is absent then the method MUST return no value (i.e. it has the special return type void).
The METHODPARAMETER element defines a single parameter to a CIM Method. Parameters are classified by whether they are references, simple types or arrays thereof. A parameter MAY have zero or more Qualifiers.
<!ELEMENT
METHODPARAMETER (QUALIFIER*, (PARAMETER|PARAMETER.REFERENCE|PARAMETER.ARRAY|PARAMETER.REFARRAY))> <!ATTLIST METHODPARAMETER %CIMName;> |
The NAME attribute defines the name of the Parameter.
The PARAMETER element defines a single (non-array, non-reference) Parameter to a CIM Method.
<!ELEMENT PARAMETER
EMPTY> <!ATTLIST PARAMETER %CIMType; #REQUIRED> |
The TYPE attribute defines the CIM type of the parameter.
The PARAMETER.REFERENCE element defines a single reference Parameter to a CIM Method.
<!ELEMENT
PARAMETER.REFERENCE EMPTY> <!ATTLIST PARAMETER.REFERENCE %ReferenceClass;> |
The REFERENCECLASS attribute, if present, defines the strong type of the reference. If absent the parameter is assumed to a reference that is not strongly typed.
The PARAMETER.ARRAY element defines a single Parameter to a CIM Method that has an array type.
<!ELEMENT
PARAMETER.ARRAY EMPTY> <!ATTLIST PARAMETER.ARRAY %CIMType; #REQUIRED %ArraySize;> |
The TYPE attribute defines the CIM type of the parameter.
The ARRAYSIZE attribute is present if and only if the array is constrained to a fixed number of elements. If it has empty content this indicates that the array is of variable size.
The PARAMETER.REFARRAY element defines a single Parameter to a CIM Method that has an array of references type.
<!ELEMENT
PARAMETER.REFARRAY EMPTY> <!ATTLIST PARAMETER.REFARRAY %ReferenceClass; %ArraySize;> |
The REFERENCECLASS attribute defines the strong type of a reference. If absent, it is assumed that the parameter is not a strongly typed reference.
The ARRAYSIZE attribute is present if and only if the array is constrained to a fixed number of elements. If absent this indicates that the array is of variable size.
This section defines those elements of the Schema that are concerned with expressing the definition of CIM Messages for the CIM Mapping onto HTTP [9].
The MESSAGE element models a single CIM message. This element is used as the basis for CIM Operations [9].
<!ELEMENT MESSAGE (SIMPLEREQ|MULTIREQ|SIMPLERSP|MULTIRSP)> <!ATTLIST MESSAGE ID CDATA #REQUIRED PROTOCOLVERSION CDATA #REQUIRED> |
The ID attribute defines an identifier for the MESSAGE. The content of the value is not constrained by this specification, but the intention is this be used as a correlation mechanism between two CIM entities.
The PROTOCOLVERSION attribute defines the version of the CIM Mapping to which this message conforms.
The HTTP mapping specification [9] provides more details on the values that these attributes may take.
The MULTIREQ element defines a Multiple CIM Operation request. It contains two or more subelements defining the SIMPLEREQ elements that make up this multiple request.
<!ELEMENT MULTIREQ (SIMPLEREQ,SIMPLEREQ+)> |
The SIMPLEREQ element defines a Simple CIM Operation request. It contains either a METHODCALL (extrinsic method) element or an IMETHODCALL (intrinsic method) element.
<!ELEMENT SIMPLEREQ (METHODCALL|IMETHODCALL)> |
The METHODCALL element defines a single method invocation on a Class or Instance. It specifies the local path of the target Class or Instance, followed by zero or more subelements as the parameter values to be passed to the method.
<!ELEMENT METHODCALL
((LOCALCLASSPATH|LOCALINSTANCEPATH), (PARAMVALUE|PARAMVALUE.REFERENCE|PARAMVALUE.ARRAY|PARAMVALUE.REFARRAY)*)> <!ATTLIST METHODCALL %CIMName;> |
The NAME attribute defines the name of the method to be invoked.
The IMETHODCALL element defines a single intrinsic method invocation. It specifies the target local namespace, and zero or more subelements as the parameter values to be passed to the method.
<!ELEMENT IMETHODCALL
(LOCALNAMESPACEPATH, (PARAMVALUE|PARAMVALUE.ARRAY|PARAMVALUE.OBJECT|PARAMVALUE.INSTNAME| PARAMVALUE.NAMEDOBJECT|PARAMVALUE.OBJNAME|PARAMVALUE.QUALDECL)*)> <!ATTLIST IMETHODCALL %CIMName;> |
The NAME attribute defines the name of the method to be invoked.
The PARAMVALUE element defines a single method parameter value of non-array, non-reference type. If no VALUE subelement is present this indicates a NULL value.
<!ELEMENT PARAMVALUE (VALUE)?> <!ATTLIST PARAMVALUE %CIMName;> |
The NAME attribute defines the name of the parameter.
The PARAMVALUE.REFERENCE element defines a single reference method parameter value. If no VALUE.REFERENCE subelement is present this indicates a NULL value.
<!ELEMENT PARAMVALUE.REFERENCE (VALUE.REFERENCE)?> |
The NAME attribute defines the name of the parameter.
The PARAMVALUE.ARRAY element defines a single method parameter value with a non-reference array type. If the VALUE.ARRAY subelement is not present this indicates a NULL value.
<!ELEMENT PARAMVALUE.ARRAY (VALUE.ARRAY)?> |
The NAME attribute defines the name of the parameter.
The PARAMVALUE.REFARRAY element defines a single reference array method parameter value. If the VALUE.REFARRAY subelement is not present this indicates a NULL value.
<!ELEMENT
PARAMVALUE.REFARRAY (VALUE.REFARRAY)?> <!ATTLIST PARAMVALUE.REFARRAY %CIMName;> |
The NAME attribute defines the name of the parameter.
The PARAMVALUE.OBJECT element defines a single method parameter value which is a CIM Class or Instance. If there is no subelement present then this indicates a NULL value.
<!ELEMENT PARAMVALUE.OBJECT (CLASS|INSTANCE|ASSOCIATION.CLASS|ASSOCIATION.INSTANCE )?><!ATTLIST PARAMVALUE.OBJECT %CIMName;> |
The NAME attribute defines the name of the parameter.
The PARAMVALUE.NAMEDOBJECT element defines a single method parameter value which is a named CIM Class or Instance. If there is no subelement present then this indicates a NULL value.
<!ELEMENT PARAMVALUE.NAMEDOBJECT (CLASS|ASSOCIATION.CLASS|(INSTANCENAME,(INSTAN )))?><!ATTLIST PARAMVALUE.NAMEDOBJECT %CIMName;> |
The NAME attribute defines the name of the parameter.
The PARAMVALUE.INSTNAME element defines a single method parameter value that represents a CIM Instance Name (also known as a Model Path in [1]) within a Namespace. If there is no element content this indicates a NULL value.
<!ELEMENT PARAMVALUE.INSTNAME (INSTANCENAME)?> <!ATTLIST PARAMVALUE.INSTNAME %CIMName;> |
The NAME attribute defines the name of the parameter.
The PARAMVALUE.OBJNAME element defines a single method parameter value that represents a CIM Class or Instance Name (also known as a Model Path in [1]) within a Namespace. If there is no element content this indicates a NULL value.
<!ELEMENT PARAMVALUE.OBJNAME (CLASSNAME|INSTANCENAME)?> <!ATTLIST PARAMVALUE.OBJNAME %CIMName;> |
The NAME attribute defines the name of the parameter.
The PARAMVALUE.QUALDECL element defines a single method parameter value that represents a CIM Qualifier Declaration. If there is no element content this indicates a NULL value.
<!ELEMENT PARAMVALUE.QUALDECL (QUALIFIER.DECLARATION )?><!ATTLIST PARAMVALUE.QUALDECL %CIMName;> |
The NAME attribute defines the name of the parameter.
The MULTIRSP element defines a Multiple CIM Operation response. It contains two or more subelements defining the SIMPLERSP elements that make up this multiple response.
<!ELEMENT MULTIRSP (SIMPLERSP,SIMPLERSP+)> |
The SIMPLERSP element defines a Simple CIM Operation response. It contains either a METHODRESPONSE (for extrinsic methods) or IMETHODRESPONSE (for intrinsic methods).
<!ELEMENT SIMPLERSP (METHODRESPONSE|IMETHODRESPONSE)> |
The METHODRESPONSE defines the response to a single CIM
extrinsic method invocation. It contains either an ERROR subelement (to report a
fundamental error which prevented the method from executing), or a combination
of an optional return value and zero or more out parameter values.
<!ELEMENT METHODRESPONSE (ERROR|(RETURNVALUE?, |
The NAME attribute defines the name of the method that was invoked.
The IMETHODRESPONSE defines the response to a single
intrinsic CIM method invocation. It contains either an ERROR subelement (to report a
fundamental error which prevented the method from executing), or an
optional return value.
<!ELEMENT IMETHODRESPONSE (ERROR|IRETURNVALUE?)> |
The NAME attribute defines the name of the method that was invoked.
The ERROR element is used to define a fundamental error which prevented a method from executing normally.
<!ELEMENT ERROR EMPTY> |
The CODE attribute contains a numerical status code indicating the nature of the error. The valid status codes are defined in [9]. The DESCRIPTION attribute, if present, provides a human-readable description of the error.
The RETURNVALUE element specifies the value returned from an extrinsic method call.
<!ELEMENT RETURNVALUE (VALUE|VALUE.ARRAY|VALUE.REFERENCE|VALUE.REFARRAY)> |
The IRETURNVALUE element specifies the value returned from an intrinsic method call.
<!ELEMENT IRETURNVALUE (VALUE.NAMEDOBJECT*|INSTANCENAME*|VALUE*|VALUE.OBJECTWITHPATH*| VALUE.OBJECT*|OBJECTPATH*|QUALIFIER.DECLARATION*|VALUE.ARRAY?|VALUE.REFERENCE?)> |