gowbem

type CIM ¶

type CIM struct {
	XMLName     xml.Name        `xml:"CIM"`
	CimVersion  string          `xml:"CIMVERSION,attr"`
	DtdVersion  string          `xml:"DTDVERSION,attr"`
	Message     *CimMessage     `xml:"MESSAGE,omitempty"`
	Declaration *CimDeclaration `xml:"DECLARATION,omitempty"`
	// contains filtered or unexported fields
}

func (cim *CIM) Fault() error

type CIMElement ¶

type CIMElement interface {

	/**
	 * Returns a string representing the name of a CIM element instance.
	 *
	 * @return The name of this CIM element.
	 */
	GetName() string
}

*

• <code>CIMElement</code> is an abstract base class that represents a CIM
• Element as defined by the Distributed Management Task Force (<a
• href=http://www.dmtf.org>DMTF</a>) CIM Infrastructure Specification (<a
• href=http://www.dmtf.org/standards/published_documents/DSP0004V2.3_final.pdf
• >DSP004</a>).

type CIMInstance ¶

type CIMInstance interface {

	/**
	 * Get the name of the class that instantiates this CIM instance.
	 *
	 * @return Name of class that instantiates this CIM instance.
	 */
	GetClassName() string

	/**
	 * Retrieve an array of the properties for this instance.
	 *
	 * @return An array of the CIM properties for this instance.
	 */
	GetProperties() []CIMProperty

	/**
	 * Get a class property by index.
	 *
	 * @param pIndex
	 *            The index of the class property to retrieve.
	 * @return The <code>CIMProperty</code> at the specified index.
	 * @throws ArrayIndexOutOfBoundsException
	 */
	GetPropertyByIndex(index int) CIMProperty

	/**
	 * Returns the specified property.
	 *
	 * @param pName
	 *            The text string for the name of the property.
	 * @return The property requested or <code>null</code> if the property does
	 *         not exist.
	 */
	GetPropertyByName(name string) CIMProperty

	/**
	 * Returns the specified <code>CIMProperty</code>.
	 *
	 * @param pName
	 *            The string name of the property to get.
	 * @param pOriginClass
	 *            (Optional) The string name of the class in which the property
	 *            was defined.
	 * @return <code>null</code> if the property does not exist, otherwise
	 *         returns the CIM property.
	 */
	GetPropertyByNameAndOrigin(name, originClass string) CIMProperty

	/**
	 * Get the number of properties defined in this <code>CIMInstance</code>.
	 *
	 * @return The number of properties defined in the <code>CIMInstance</code>.
	 */
	GetPropertyCount() int
}

*

• This class represents a CIM instance as defined by the Distributed Management
• Task Force (<a href=http://www.dmtf.org>DMTF</a>) CIM Infrastructure
• Specification (<a
• href=http://www.dmtf.org/standards/published_documents/DSP0004V2.3_final.pdf
• >DSP004</a>).

type CIMInstanceName ¶

type CIMInstanceName interface {
	GetClassName() string
	GetKeyBindings() CIMKeyBindings
	String() string
}

type CIMInstanceWithName ¶

type CIMInstanceWithName interface {
	GetName() CIMInstanceName
	GetInstance() CIMInstance
}

type CIMKeyBinding ¶

type CIMKeyBinding interface {
	GetName() string
	GetType() CIMType
	GetValue() interface{}
}

type CIMKeyBindings ¶

type CIMKeyBindings interface {
	Len() int
	Get(idx int) CIMKeyBinding
	String() string
}

type CIMObjectPath ¶

type CIMObjectPath interface {

	/**
	 * Gets the host.
	 */
	GetHost() string

	/**
	 * Gets a key property by name.
	 *
	 * @param pName
	 *            The name of the key property to retrieve.
	 * @return The <code>CIMProperty</code> with the given name, or
	 *         <code>null</code> if it is not found.
	 */
	GetKey(name string) CIMValuedElement

	/**
	 * Gets all key properties.
	 *
	 * @return The container of key properties.
	 */
	GetKeys() map[string]CIMValuedElement

	/**
	 * Gets the namespace.
	 *
	 * @return The name of the namespace.
	 */
	GetNamespace() string

	/**
	 * Gets the object name. Depending on the type of CIM element referenced,
	 * this may be either a class name or a qualifier type name.
	 *
	 * @return The name of this CIM element.
	 */
	GetObjectName() string

	/**
	 * Gets the the port on the host to which the connection was established.
	 *
	 * @return The port on the host.
	 */
	GetPort() string

	/**
	 * Get the connection scheme.
	 *
	 * @return The connection scheme (e.g. http, https,...)
	 */
	GetScheme() string
}

*

• This class represents the CIM Object Path as defined by the Distributed
• Management Task Force (<a href=http://www.dmtf.org>DMTF</a>) CIM
• Infrastructure Specification (<a href=
• "http://dmtf.org/sites/default/files/standards/documents/DSP0004_2.7.0.pdf"
• >DSP004</a>). In order to uniquely identify a given object, a CIM object path
• includes the host, namespace, object name and keys (if the object is an
• instance).<br>
• <br>
• For example, the object path:<br>
• <br>
• <code>
• http://myserver/root/cimv2:My_ComputerSystem.Name=mycomputer,
• CreationClassName=My_ComputerSystem
• </code><br>
• <br>
• has two parts:<br>
• <br>
• <ul type="disc"> <li>Namespace Path</li>
• <code>http://myserver/root/cimv2</code><br>
• JSR48 defines the namespace path to include the scheme, host, port (optional)
• and namespace<br>
• The example specifies the <code>"root/cimv2"</code> namespace on the host
• <code>myserver</code>.</li> <li>Model Path</li>
• <code>My_ComputerSystem.Name=mycomputer,CreationClassName=My_ComputerSystem
• </code><br>
• DSP0004 defines the model path for a class or qualifier type as the name of
• the class/qualifier type<br>
• DSP0004 defines the model path for an instance as the class
• name.(key=value),*<br>
• The example specifies an instance for the class
• <code>My_ComputerSystem</code> which is uniquely identified by two key
• properties and values: <ul type="disc"> <li><code>Name=mycomputer</code></li>
• <li>
• <code>CreationClassName=My_ComputerSystem</code></li> </ul> </ul>

type CIMParamValue ¶

type CIMParamValue interface {
	GetName() string
	GetParamType() string
	GetValue() Valuer
}

type CIMProperty ¶

type CIMProperty interface {
	CIMValuedElement

	/**
	 * Returns the class in which this property was defined or overridden.
	 *
	 * @return Name of class where this property was defined.
	 */
	GetOriginClass() string

	/**
	 * Convenience method for determining if this property is a Key.
	 *
	 * @return <code>true</code> if this property is a key.
	 */
	IsKey() bool

	/**
	 * Determines if this property is Propagated. When this property is part of
	 * a class, this value designates that the class origin value is the same as
	 * the class name.
	 *
	 * @return <code>true</code> if this property is propagated.
	 */
	IsPropagated() bool
}

type CIMStatusCode ¶

type CIMStatusCode int

const (
	// CIMError error code constants
	CIM_ERR_FAILED                              CIMStatusCode = 1  // A general error occurred
	CIM_ERR_ACCESS_DENIED                       CIMStatusCode = 2  // Resource not available
	CIM_ERR_INVALID_NAMESPACE                   CIMStatusCode = 3  // The target namespace does not exist
	CIM_ERR_INVALID_PARAMETER                   CIMStatusCode = 4  // Parameter value(s) invalid
	CIM_ERR_INVALID_CLASS                       CIMStatusCode = 5  // The specified Class does not exist
	CIM_ERR_NOT_FOUND                           CIMStatusCode = 6  // Requested object could not be found
	CIM_ERR_NOT_SUPPORTED                       CIMStatusCode = 7  // Operation not supported
	CIM_ERR_CLASS_HAS_CHILDREN                  CIMStatusCode = 8  // Class has subclasses
	CIM_ERR_CLASS_HAS_INSTANCES                 CIMStatusCode = 9  // Class has instances
	CIM_ERR_INVALID_SUPERCLASS                  CIMStatusCode = 10 // Superclass does not exist
	CIM_ERR_ALREADY_EXISTS                      CIMStatusCode = 11 // Object already exists
	CIM_ERR_NO_SUCH_PROPERTY                    CIMStatusCode = 12 // Property does not exist
	CIM_ERR_TYPE_MISMATCH                       CIMStatusCode = 13 // Value incompatible with type
	CIM_ERR_QUERY_LANGUAGE_NOT_SUPPORTED        CIMStatusCode = 14 // Query language not supported
	CIM_ERR_INVALID_QUERY                       CIMStatusCode = 15 // Query not valid
	CIM_ERR_METHOD_NOT_AVAILABLE                CIMStatusCode = 16 // Extrinsic method not executed
	CIM_ERR_METHOD_NOT_FOUND                    CIMStatusCode = 17 // Extrinsic method does not exist
	CIM_ERR_NAMESPACE_NOT_EMPTY                 CIMStatusCode = 20
	CIM_ERR_INVALID_ENUMERATION_CONTEXT         CIMStatusCode = 21
	CIM_ERR_INVALID_OPERATION_TIMEOUT           CIMStatusCode = 22
	CIM_ERR_PULL_HAS_BEEN_ABANDONED             CIMStatusCode = 23
	CIM_ERR_PULL_CANNOT_BE_ABANDONED            CIMStatusCode = 24
	CIM_ERR_FILTERED_ENUMERATION_NOT_SUPPORTED  CIMStatusCode = 25
	CIM_ERR_CONTINUATION_ON_ERROR_NOT_SUPPORTED CIMStatusCode = 26
	CIM_ERR_SERVER_LIMITS_EXCEEDED              CIMStatusCode = 27
	CIM_ERR_SERVER_IS_SHUTTING_DOWN             CIMStatusCode = 28
)

func (code CIMStatusCode) String() string

type CIMType ¶

type CIMType struct {
	// contains filtered or unexported fields
}

func CreateCIMArrayType(t string, arraySize int) CIMType

func CreateCIMReferenceType(class string) CIMType

func CreateCIMType(t string) CIMType

func (self *CIMType) GetClassName() string

func (self *CIMType) GetSize() int

func (self *CIMType) GetType() CIMTypeCode

func (self *CIMType) IsArray() bool

type CIMTypeCode ¶

type CIMTypeCode int

const (
	INVALID CIMTypeCode = iota
	BOOLEAN
	STRING
	CHAR16
	UINT8
	SINT8
	UINT16
	SINT16
	UINT32
	SINT32
	UINT64
	SINT64
	DATETIME
	REAL32
	REAL64
	NUMERIC
	REFERENCE
)

type CIMTypedElement ¶

type CIMTypedElement interface {
	CIMElement

	/**
	 * Returns the <code>CIMDataType</code> for this CIM Element.
	 *
	 * @return <code>CIMDataType</code> of this CIM element.
	 */
	GetType() CIMType
}

*

• <code>CIMTypedElement</code> is an abstract class that represents a CIM
• element that contains just the data type, but no value.

type CIMValuedElement ¶

type CIMValuedElement interface {
	CIMTypedElement

	/**
	 * Returns the value for this CIM Element.
	 */
	GetValue() interface{}
}

*

• <code>CIMValuedElement</code> is a base class used by any element that
• contains a name, type and value.

type CimAnyDeclGroup ¶

type CimAnyDeclGroup struct {
	DeclGroup         *CimDeclGroup         `xml:"DECLGROUP,omitempty"`
	DeclGroupWithName *CimDeclGroupWithName `xml:"DECLGROUP.WITHNAME,omitempty"`
	DeclGroupWithPath *CimDeclGroupWithPath `xml:"DECLGROUP.WITHPATH,omitempty"`
}

func (self *CimAnyDeclGroup) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (self *CimAnyDeclGroup) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type CimAnyDeclGroupWithPath ¶

type CimAnyDeclGroupWithPath struct {
	ValueObjectWithPaths      *CimValueObjectWithPath      `xml:"VALUE.OBJECTWITHPATH,omitempty"`
	ValueObjectWithLocalPaths *CimValueObjectWithLocalPath `xml:"VALUE.OBJECTWITHLOCALPATH,omitempty"`
}

func (self *CimAnyDeclGroupWithPath) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (self *CimAnyDeclGroupWithPath) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type CimAnyParameter ¶

type CimAnyParameter struct {
	Parameter          *CimParameter          `xml:"PARAMETER,omitempty"`
	ParameterReference *CimParameterReference `xml:"PARAMETER.REFERENCE,omitempty"`
	ParameterArray     *CimParameterArray     `xml:"PARAMETER.ARRAY,omitempty"`
	ParameterRefArray  *CimParameterRefArray  `xml:"PARAMETER.REFARRAY,omitempty"`
}

func (self *CimAnyParameter) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (self *CimAnyParameter) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type CimAnyProperty ¶

type CimAnyProperty struct {
	Property          *CimProperty          `xml:"PROPERTY,omitempty"`
	PropertyArray     *CimPropertyArray     `xml:"PROPERTY.ARRAY,omitempty"`
	PropertyReference *CimPropertyReference `xml:"PROPERTY.REFERENCE,omitempty"`
}

func (self *CimAnyProperty) Get() CIMProperty

func (self *CimAnyProperty) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (self *CimAnyProperty) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type CimClass ¶

type CimClass struct {
	XMLName    xml.Name         `xml:"CLASS"`
	Name       string           `xml:"NAME,attr"`
	SuperClass string           `xml:"SUPERCLASS,attr,omitempty"`
	Qualifiers []CimQualifier   `xml:"QUALIFIER,omitempty"`
	Properties []CimAnyProperty `xml:",any,omitempty"`
	Methods    []CimMethod      `xml:"METHOD,omitempty"`
}

<!-- Section: Object Definition Elements -->
<xs:element name="CLASS">
    <xs:annotation>
        <xs:documentation>Defines a CIM class.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:element ref="QUALIFIER" minOccurs="0" maxOccurs="unbounded"/>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="PROPERTY"/>
                <xs:element ref="PROPERTY.ARRAY"/>
                <xs:element ref="PROPERTY.REFERENCE"/>
            </xs:choice>
            <xs:element ref="METHOD" minOccurs="0" maxOccurs="unbounded"/>
        </xs:sequence>
        <xs:attribute ref="NAME" use="required"/>
        <xs:attribute ref="SUPERCLASS"/>
    </xs:complexType>
</xs:element>

func (self *CimClass) String() string

func (self *CimClass) ToString(buf *strings.Builder)

type CimClassInnerXml ¶

type CimClassInnerXml struct {
	XMLName xml.Name `xml:"CLASS"`

	Name       string `xml:"NAME,attr"`
	SuperClass string `xml:"SUPERCLASS,attr,omitempty"`
	Text       string `xml:",innerxml"`
}

func (self *CimClassInnerXml) String() string

type CimClassName ¶

type CimClassName struct {
	XMLName xml.Name `xml:"CLASSNAME"`
	Name    string   `xml:"NAME,attr"`
}

<xs:element name="CLASSNAME">
    <xs:annotation>
        <xs:documentation>Defines the name of a CIM class.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:attribute name="NAME" type="CIMClassName_Type" use="required"/>
    </xs:complexType>
</xs:element>

func (self *CimClassName) String() string

type CimClassPath ¶

type CimClassPath struct {
	XMLName       xml.Name         `xml:"CLASSPATH"`
	NamespacePath CimNamespacePath `xml:"NAMESPACEPATH"`
	ClassName     CimClassName     `xml:"CLASSNAME"`
}

<xs:element name="CLASSPATH">
    <xs:annotation>
        <xs:documentation>Defines the absolute path to a CIM class.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:element ref="NAMESPACEPATH"/>
            <xs:element ref="CLASSNAME"/>
        </xs:sequence>
    </xs:complexType>
</xs:element>

func (self *CimClassPath) IsNil() bool

func (self *CimClassPath) String() string

func (self *CimClassPath) ToString(buf *strings.Builder)

type CimCorrelator ¶

type CimCorrelator struct {
	XMLName xml.Name `xml:"CORRELATOR"`
	Name    string   `xml:"NAME,attr"`
	Type    string   `xml:"TYPE,attr"`
	Value   CimValue `xml:"VALUE"`
}

<!-- ************************************************** CHANGE NOTE: The ENUMERATIONCONTEXT element was removed in version 2.4.0 of this document. ************************************************** -->

<xs:element name="CORRELATOR">
    <xs:annotation>
        <xs:documentation>Defines an operation correlator.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:element ref="VALUE"/>
        </xs:sequence>
        <xs:attribute ref="NAME" use="required"/>
        <xs:attribute ref="TYPE" use="required"/>
    </xs:complexType>
</xs:element>

type CimDeclGroup ¶

type CimDeclGroup struct {
	XMLName               xml.Name                  `xml:"DECLGROUP"`
	LocalNamespacePath    *CimLocalNamespacePath    `xml:"LOCALNAMESPACEPATH,omitempty"`
	NamespacePath         *CimNamespacePath         `xml:"NAMESPACEPATH,omitempty"`
	QualifierDeclarations []CimQualifierDeclaration `xml:"QUALIFIER.DECLARATION,omitempty"`
	ValueObjects          []CimValueObject          `xml:"VALUE.OBJECT,omitempty"`
}

<xs:element name="DECLGROUP">
    <xs:annotation>
        <xs:documentation>A logical group of CIM schema element declarations (classes, instances, and

qualifier types/declarations) without any path information. For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:choice minOccurs="0">
                <xs:element ref="LOCALNAMESPACEPATH"/>
                <xs:element ref="NAMESPACEPATH"/>
            </xs:choice>
            <xs:element ref="QUALIFIER.DECLARATION" minOccurs="0" maxOccurs="unbounded"/>
            <xs:element ref="VALUE.OBJECT" minOccurs="0" maxOccurs="unbounded"/>
        </xs:sequence>
    </xs:complexType>
</xs:element>

type CimDeclGroupWithName ¶

type CimDeclGroupWithName struct {
	XMLName               xml.Name                  `xml:"DECLGROUP.WITHNAME"`
	LocalNamespacePath    *CimLocalNamespacePath    `xml:"LOCALNAMESPACEPATH,omitempty"`
	NamespacePath         *CimNamespacePath         `xml:"NAMESPACEPATH,omitempty"`
	QualifierDeclarations []CimQualifierDeclaration `xml:"QUALIFIER.DECLARATION,omitempty"`
	ValueNamedObjects     []CimValueNamedObject     `xml:"VALUE.NAMEDOBJECT,omitempty"`
}

<xs:element name="DECLGROUP.WITHNAME">
    <xs:annotation>
        <xs:documentation>A logical group of CIM schema element declarations (classes, instances, and

qualifier types/declarations) with name (local path) information. For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:choice minOccurs="0">
                <xs:element ref="LOCALNAMESPACEPATH"/>
                <xs:element ref="NAMESPACEPATH"/>
            </xs:choice>
            <xs:element ref="QUALIFIER.DECLARATION" minOccurs="0" maxOccurs="unbounded"/>
            <xs:element ref="VALUE.NAMEDOBJECT" minOccurs="0" maxOccurs="unbounded"/>
        </xs:sequence>
    </xs:complexType>
</xs:element>

type CimDeclGroupWithPath ¶

type CimDeclGroupWithPath struct {
	XMLName xml.Name          `xml:"DECLGROUP.WITHPATH"`
	Values  []CimAnyDeclGroup `xml:",any,omitempty"`
}

<xs:element name="DECLGROUP.WITHPATH">
    <xs:annotation>
        <xs:documentation>A logical group of CIM schema element declarations (classes, instances, and

qualifier types/declarations) with path information. For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
            <xs:element ref="VALUE.OBJECTWITHPATH"/>
            <xs:element ref="VALUE.OBJECTWITHLOCALPATH"/>
        </xs:choice>
    </xs:complexType>
</xs:element>

type CimDeclaration ¶

type CimDeclaration struct {
	XMLName    xml.Name          `xml:"DECLARATION"`
	DeclGroups []CimAnyDeclGroup `xml:",any,omitempty"`
}

<!-- Section: Declaration Elements -->
<xs:element name="DECLARATION">
    <xs:annotation>
        <xs:documentation>A set of CIM schema element declarations, consisting of logical declaration groups.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:choice maxOccurs="unbounded">
            <xs:element ref="DECLGROUP"/>
            <xs:element ref="DECLGROUP.WITHNAME"/>
            <xs:element ref="DECLGROUP.WITHPATH"/>
        </xs:choice>
    </xs:complexType>
</xs:element>

type CimError ¶

type CimError struct {
	XMLName     xml.Name         `xml:"ERROR"`
	Code        int              `xml:"CODE,attr"`
	Description string           `xml:"DESCRIPTION,attr,omitempty"`
	Instance    CimInstanceArray `xml:"INSTANCE,omitempty"`
}

<xs:element name="ERROR">
    <xs:annotation>
        <xs:documentation>Defines a fundamental error that prevented a method from executing normally

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:element ref="INSTANCE" minOccurs="0" maxOccurs="unbounded"/>
        </xs:sequence>
        <xs:attribute name="CODE" type="CIMStatusCode_Type" use="required"/>
        <xs:attribute name="DESCRIPTION" type="xs:string"/>
    </xs:complexType>
</xs:element>

type CimExpMethodCall ¶

type CimExpMethodCall struct {
	XMLName       xml.Name           `xml:"EXPMETHODCALL"`
	Name          string             `xml:"NAME,attr"`
	ExpParamValue []CimExpParamValue // `xml:"EXPPARAMVALUE,omitempty"`
}

<xs:element name="EXPMETHODCALL">
    <xs:annotation>
        <xs:documentation>Defines a single export method (= listener operation) invocation request.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:element ref="EXPPARAMVALUE" minOccurs="0" maxOccurs="unbounded"/>
        </xs:sequence>
        <xs:attribute ref="NAME" use="required"/>
    </xs:complexType>
</xs:element>
</xs:element>

type CimExpMethodResponse ¶

type CimExpMethodResponse struct {
	XMLName     xml.Name         `xml:"EXPMETHODRESPONSE"`
	Name        string           `xml:"NAME,attr"`
	Error       *CimError        `xml:"ERROR,omitempty"`
	ReturnValue *CimIReturnValue `xml:"IRETURNVALUE,omitempty"`
}

<xs:element name="EXPMETHODRESPONSE">
    <xs:annotation>
        <xs:documentation>Defines a single export method (= listener operation) invocation response.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:choice>
            <xs:element ref="ERROR"/>
            <xs:element ref="IRETURNVALUE" minOccurs="0"/>
        </xs:choice>
        <xs:attribute ref="NAME" use="required"/>
    </xs:complexType>
</xs:element>

type CimExpParamValue ¶

type CimExpParamValue struct {
	XMLName  xml.Name     `xml:"EXPPARAMVALUE"`
	Name     string       `xml:"NAME,attr"`
	Instance *CimInstance `xml:"IRETURNVALUE,omitempty"`
}

<xs:element name="EXPPARAMVALUE">
    <xs:annotation>
        <xs:documentation>Defines a parameter value that is used in a request or response of an export method

(= listener operation). For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:choice>
            <xs:element ref="INSTANCE" minOccurs="0"/>
        </xs:choice>
        <xs:attribute ref="NAME" use="required"/>
    </xs:complexType>
</xs:element>

type CimHost ¶

type CimHost struct {
	XMLName xml.Name `xml:"HOST"`
	Value   string   `xml:",chardata"`
}

<xs:element name="HOST">
    <xs:annotation>
        <xs:documentation>Defines a host name and optionally a port number.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:simpleType>
        <xs:restriction base="xs:string"/>
    </xs:simpleType>
</xs:element>

type CimIMethodCall ¶

type CimIMethodCall struct {
	XMLName            xml.Name              `xml:"IMETHODCALL"`
	Name               string                `xml:"NAME,attr"`
	LocalNamespacePath CimLocalNamespacePath `xml:"LOCALNAMESPACEPATH"`
	ParamValues        []CimIParamValue      `xml:"IPARAMVALUE,omitempty"`
}

<xs:element name="IMETHODCALL">
    <xs:annotation>
        <xs:documentation>Defines a single intrinsic method (=operation) invocation request.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:element ref="LOCALNAMESPACEPATH"/>
            <xs:element ref="IPARAMVALUE" minOccurs="0" maxOccurs="unbounded"/>
        </xs:sequence>
        <xs:attribute ref="NAME" use="required"/>
    </xs:complexType>
</xs:element>

type CimIMethodResponse ¶

type CimIMethodResponse struct {
	XMLName     xml.Name         `xml:"IMETHODRESPONSE"`
	Name        string           `xml:"NAME,attr"`
	Error       *CimError        `xml:"ERROR,omitempty"`
	ReturnValue *CimIReturnValue `xml:"IRETURNVALUE,omitempty"`
	ParamValues []CimParamValue  `xml:"PARAMVALUE,omitempty"`
}

<xs:element name="IMETHODRESPONSE">
    <xs:annotation>
        <xs:documentation>Defines a single intrinsic method (=operation) invocation response.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:choice>
            <xs:element ref="ERROR"/>
            <xs:sequence>
                <xs:element ref="IRETURNVALUE" minOccurs="0"/>
                <xs:element ref="PARAMVALUE" minOccurs="0" maxOccurs="unbounded"/>
            </xs:sequence>
        </xs:choice>
        <xs:attribute ref="NAME" use="required"/>
    </xs:complexType>
</xs:element>

type CimIParamValue ¶

type CimIParamValue struct {
	XMLName              xml.Name                 `xml:"IPARAMVALUE"`
	Name                 string                   `xml:"NAME,attr"`
	Value                *CimValue                `xml:"VALUE,omitempty"`
	ValueReference       *CimValueReference       `xml:"VALUE.REFERENCE,omitempty"`
	ValueArray           *CimValueArray           `xml:"VALUE.ARRAY,omitempty"`
	ClassName            *CimClassName            `xml:"CLASSNAME,omitempty"`
	InstanceName         *CimInstanceName         `xml:"INSTANCENAME,omitempty"`
	QualifierDeclaration *CimQualifierDeclaration `xml:""QUALIFIER.DECLARATION,omitempty"`
	Class                *CimClass                `xml:"CLASS,omitempty"`
	Instance             *CimInstance             `xml:"INSTANCE,omitempty"`
	ValueNamedInstance   *CimValueNamedInstance   `xml:"VALUE.NAMEDINSTANCE,omitempty"`
}

<xs:element name="IPARAMVALUE">
    <xs:annotation>
        <xs:documentation>Defines a parameter value that is used in a intrinsic method (= operation) request or response.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:choice minOccurs="0">
            <xs:element ref="VALUE"/>
            <xs:element ref="VALUE.ARRAY"/>
            <xs:element ref="VALUE.REFERENCE"/>
            <xs:element ref="CLASSNAME"/>
            <xs:element ref="INSTANCENAME"/>
            <xs:element ref="QUALIFIER.DECLARATION"/>
            <xs:element ref="CLASS"/>
            <xs:element ref="INSTANCE"/>
            <xs:element ref="VALUE.NAMEDINSTANCE"/>
        </xs:choice>
        <xs:attribute ref="NAME" use="required"/>
    </xs:complexType>
</xs:element>

type CimIReturnValue ¶

type CimIReturnValue struct {
	XMLName                   xml.Name                      `xml:"IRETURNVALUE"`
	ClassNames                []CimClassName                `xml:"CLASSNAME,omitempty"`
	InstanceNames             []*CimInstanceName            `xml:"INSTANCENAME,omitempty"`
	Values                    []CimValue                    `xml:"VALUE,omitempty"`
	ValueObjectWithPaths      []CimValueObjectWithPath      `xml:"VALUE.OBJECTWITHPATH,omitempty"`
	ValueObjectWithLocalPaths []CimValueObjectWithLocalPath `xml:"VALUE.OBJECTWITHLOCALPATH,omitempty"`
	ValueObjects              []CimValueObject              `xml:"VALUE.OBJECT,omitempty"`
	ObjectPaths               []CimObjectPath               `xml:"OBJECTPATH,omitempty"`
	QualifierDeclarations     []CimQualifierDeclaration     `xml:"QUALIFIER.DECLARATION,omitempty"`
	ValueArray                *CimValueArray                `xml:"VALUE.ARRAY,omitempty"`
	ValueReference            *CimValueReference            `xml:"VALUE.REFERENCE,omitempty"`
	Classes                   []CimClassInnerXml            `xml:"CLASS,omitempty"`
	//Classes                   []CimClass            `xml:"CLASS,omitempty"`
	Instances              []CimInstance              `xml:"INSTANCE,omitempty"`
	InstancePaths          []CimInstancePath          `xml:"INSTANCEPATH,omitempty"`
	ValueNamedInstances    []CimValueNamedInstance    `xml:"VALUE.NAMEDINSTANCE,omitempty"`
	ValueInstanceWithPaths []CimValueInstanceWithPath `xml:"VALUE.INSTANCEWITHPATH,omitempty"`
}

<xs:element name="IRETURNVALUE">
    <xs:annotation>
        <xs:documentation>Defines the return value of an intrinsic (= operation) method within a response.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:choice>
            <xs:element ref="CLASSNAME" minOccurs="0" maxOccurs="unbounded"/>
            <xs:element ref="INSTANCENAME" minOccurs="0" maxOccurs="unbounded"/>
            <xs:element ref="VALUE" minOccurs="0" maxOccurs="unbounded"/>
            <xs:element ref="VALUE.OBJECTWITHPATH" minOccurs="0" maxOccurs="unbounded"/>
            <xs:element ref="VALUE.OBJECTWITHLOCALPATH" minOccurs="0" maxOccurs="unbounded"/>
            <xs:element ref="VALUE.OBJECT" minOccurs="0" maxOccurs="unbounded"/>
            <xs:element ref="OBJECTPATH" minOccurs="0" maxOccurs="unbounded"/>
            <xs:element ref="QUALIFIER.DECLARATION" minOccurs="0" maxOccurs="unbounded"/>
            <xs:element ref="VALUE.ARRAY" minOccurs="0"/>
            <xs:element ref="VALUE.REFERENCE" minOccurs="0"/>
            <xs:element ref="CLASS" minOccurs="0" maxOccurs="unbounded"/>
            <xs:element ref="INSTANCE" minOccurs="0" maxOccurs="unbounded"/>
            <xs:element ref="INSTANCEPATH" minOccurs="0" maxOccurs="unbounded"/>
            <xs:element ref="VALUE.NAMEDINSTANCE" minOccurs="0" maxOccurs="unbounded"/>
            <xs:element ref="VALUE.INSTANCEWITHPATH" minOccurs="0" maxOccurs="unbounded"/>
        </xs:choice>
    </xs:complexType>
</xs:element>

type CimInstance ¶

type CimInstance struct {
	XMLName    xml.Name         `xml:"INSTANCE"`
	ClassName  string           `xml:"CLASSNAME,attr"`
	Lang       string           `xml:"lang,attr,omitempty"`
	Qualifiers []CimQualifier   `xml:"QUALIFIER,omitempty"`
	Properties []CimAnyProperty `xml:",any,omitempty"`
}

<xs:element name="INSTANCE">
    <xs:annotation>
        <xs:documentation>Defines a CIM instance.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:element ref="QUALIFIER" minOccurs="0" maxOccurs="unbounded"/>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="PROPERTY"/>
                <xs:element ref="PROPERTY.ARRAY"/>
                <xs:element ref="PROPERTY.REFERENCE"/>
            </xs:choice>
        </xs:sequence>
        <xs:attribute ref="CLASSNAME" use="required"/>
        <xs:attribute ref="xml:lang"/>
    </xs:complexType>
</xs:element>

func ToCimInstance(instance CIMInstance) CimInstance

func (self *CimInstance) GetClassName() string

func (self *CimInstance) GetProperties() []CIMProperty

func (self *CimInstance) GetPropertyByIndex(index int) CIMProperty

func (self *CimInstance) GetPropertyByName(name string) CIMProperty

func (self *CimInstance) GetPropertyByNameAndOrigin(name, originClass string) CIMProperty

func (self *CimInstance) GetPropertyCount() int

func (self *CimInstance) String() string

func (self *CimInstance) ToString(buf *strings.Builder)

type CimInstanceArray ¶

type CimInstanceArray struct {
	XMLName  xml.Name      `xml:"INSTANCE"`
	Instance []CimInstance `xml:",any,omitempty"`
}

type CimInstanceName ¶

type CimInstanceName struct {
	XMLName        xml.Name           `xml:"INSTANCENAME"`
	ClassName      string             `xml:"CLASSNAME,attr"`
	KeyBindings    []CimKeyBinding    `xml:"KEYBINDING,omitempty"`
	KeyValue       *CimKeyValue       `xml:"KEYVALUE,omitempty"`
	ValueReference *CimValueReference `xml:"VALUE.REFERENCE,omitempty"`
}

<xs:element name="INSTANCENAME">
    <xs:annotation>
        <xs:documentation>Defines the location of a CIM instance within a namespace (it is referred to in DSP0004

as a model path). For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:choice>
            <xs:element ref="KEYBINDING" minOccurs="0" maxOccurs="unbounded"/>
            <xs:element ref="KEYVALUE" minOccurs="0"/>
            <xs:element ref="VALUE.REFERENCE" minOccurs="0"/>
        </xs:choice>
        <xs:attribute ref="CLASSNAME" use="required"/>
    </xs:complexType>
</xs:element>

func ParseInstanceName(s string) (*CimInstanceName, error)

func ToCimInstanceName(name CIMInstanceName) CimInstanceName

func (self *CimInstanceName) GetClassName() string

func (self *CimInstanceName) GetKeyBindings() CIMKeyBindings

func (self *CimInstanceName) IsNil() bool

func (self *CimInstanceName) IsTyped() bool

func (self *CimInstanceName) String() string

func (self *CimInstanceName) ToString(buf *strings.Builder)

type CimInstancePath ¶

type CimInstancePath struct {
	XMLName       xml.Name         `xml:"INSTANCEPATH"`
	NamespacePath CimNamespacePath `xml:"NAMESPACEPATH"`
	InstanceName  CimInstanceName  `xml:"INSTANCENAME"`
}

<xs:element name="INSTANCEPATH">
    <xs:annotation>
        <xs:documentation>Defines the absolute path to a CIM instance.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:element ref="NAMESPACEPATH"/>
            <xs:element ref="INSTANCENAME"/>
        </xs:sequence>
    </xs:complexType>
</xs:element>

func (self *CimInstancePath) IsNil() bool

func (self *CimInstancePath) String() string

func (self *CimInstancePath) ToString(buf *strings.Builder)

type CimKeyBinding ¶

type CimKeyBinding struct {
	XMLName        xml.Name           `xml:"KEYBINDING"`
	Name           string             `xml:"NAME,attr"`
	KeyValue       *CimKeyValue       `xml:"KEYVALUE,omitempty"`
	ValueReference *CimValueReference `xml:"VALUE.REFERENCE,omitempty"`
}

<xs:element name="KEYBINDING">
    <xs:annotation>
        <xs:documentation>Defines a key binding (= key property name and value used in an instance path).

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:choice>
            <xs:element ref="KEYVALUE"/>
            <xs:element ref="VALUE.REFERENCE"/>
        </xs:choice>
        <xs:attribute ref="NAME" use="required"/>
    </xs:complexType>
</xs:element>

func (self *CimKeyBinding) GetName() string

func (self *CimKeyBinding) GetType() CIMType

func (self *CimKeyBinding) GetValue() interface{}

func (self *CimKeyBinding) IsNil() bool

func (self *CimKeyBinding) IsTyped() bool

func (self *CimKeyBinding) String() string

func (self *CimKeyBinding) ToString(buf *strings.Builder)

type CimKeyBindings ¶

type CimKeyBindings []CimKeyBinding

func Parse(s string) (namespace string, className string, keyBindings CimKeyBindings, e error)

func ParseKeyBindings(s string) (keyBindings CimKeyBindings, e error)

func (self CimKeyBindings) Get(idx int) CIMKeyBinding

func (self CimKeyBindings) Len() int

func (self CimKeyBindings) String() string

func (self CimKeyBindings) ToString(buf *strings.Builder)

type CimKeyValue ¶

type CimKeyValue struct {
	XMLName   xml.Name `xml:"KEYVALUE"`
	ValueType string   `xml:"VALUETYPE,attr,omitempty"`
	Type      string   `xml:"TYPE,attr,omitempty"`
	Value     string   `xml:",chardata"`
}

<xs:element name="KEYVALUE">
    <xs:annotation>
        <xs:documentation>Defines the value of a non-reference (and scalar) key binding.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType mixed="true">
        <xs:attribute name="VALUETYPE" default="string">
            <xs:simpleType>
                <xs:restriction base="xs:NMTOKEN">
                    <xs:enumeration value="string"/>
                    <xs:enumeration value="boolean"/>
                    <xs:enumeration value="numeric"/>
                </xs:restriction>
            </xs:simpleType>
        </xs:attribute>
        <xs:attribute ref="TYPE" use="required"/>
    </xs:complexType>
</xs:element>

func (self *CimKeyValue) GetType() string

func (self *CimKeyValue) IsNil() bool

func (self *CimKeyValue) IsTyped() bool

func (self *CimKeyValue) String() string

func (self *CimKeyValue) ToString(buf *strings.Builder)

type CimLocalClassPath ¶

type CimLocalClassPath struct {
	XMLName       xml.Name              `xml:"LOCALCLASSPATH"`
	NamespacePath CimLocalNamespacePath `xml:"LOCALNAMESPACEPATH"`
	ClassName     CimClassName          `xml:"CLASSNAME"`
}

<xs:element name="LOCALCLASSPATH">
    <xs:annotation>
        <xs:documentation>Defines the local path to a CIM class.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:element ref="LOCALNAMESPACEPATH"/>
            <xs:element ref="CLASSNAME"/>
        </xs:sequence>
    </xs:complexType>
</xs:element>

func (self *CimLocalClassPath) IsNil() bool

func (self *CimLocalClassPath) String() string

func (self *CimLocalClassPath) ToString(buf *strings.Builder)

type CimLocalInstancePath ¶

type CimLocalInstancePath struct {
	XMLName            xml.Name              `xml:"LOCALINSTANCEPATH"`
	LocalNamespacePath CimLocalNamespacePath `xml:"LOCALNAMESPACEPATH"`
	InstanceName       CimInstanceName       `xml:"INSTANCENAME"`
}

<xs:element name="LOCALINSTANCEPATH">
    <xs:annotation>
        <xs:documentation>Defines the local path to a CIM instance.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:element ref="LOCALNAMESPACEPATH"/>
            <xs:element ref="INSTANCENAME"/>
        </xs:sequence>
    </xs:complexType>
</xs:element>

func ParseLocalInstancePath(s string) (*CimLocalInstancePath, error)

func (self *CimLocalInstancePath) IsNil() bool

func (self *CimLocalInstancePath) String() string

func (self *CimLocalInstancePath) ToString(buf *strings.Builder)

type CimLocalNamespacePath ¶

type CimLocalNamespacePath struct {
	XMLName    xml.Name       `xml:"LOCALNAMESPACEPATH"`
	Namespaces []CimNamespace `xml:"NAMESPACE"`
}

<xs:element name="LOCALNAMESPACEPATH">
    <xs:annotation>
        <xs:documentation>Defines a local namespace path (one without a host component).

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:element ref="NAMESPACE" maxOccurs="unbounded"/>
        </xs:sequence>
    </xs:complexType>
</xs:element>

func (self *CimLocalNamespacePath) IsNil() bool

func (self *CimLocalNamespacePath) String() string

func (self *CimLocalNamespacePath) ToString(buf *strings.Builder)

type CimMessage ¶

type CimMessage struct {
	XMLName         xml.Name         `xml:"MESSAGE"`
	Id              string           `xml:"ID,attr"`
	ProtocolVersion string           `xml:"PROTOCOLVERSION,attr"`
	SimpleReq       *CimSimpleReq    `xml:"SIMPLEREQ,omitempty"`
	MultiReq        *CimMultiReq     `xml:"MULTIREQ,omitempty"`
	SimpleRsp       *CimSimpleRsp    `xml:"SIMPLERSP,omitempty"`
	MultiRsp        *CimMultiRsp     `xml:"MULTIRSP,omitempty"`
	SimpleExpReq    *CimSimpleExpReq `xml:"SIMPLEEXPREQ,omitempty"`
	MultiExpReq     *CimMultiExpReq  `xml:"MULTIEXPREQ,omitempty"`
	SimpleExpRsp    *CimSimpleExpRsp `xml:"SIMPLEEXPRSP,omitempty"`
	MultiExpRsp     *CimMultiExpRsp  `xml:"MULTIEXPRSP,omitempty"`
}

<!-- Section: Message Elements -->
<xs:element name="MESSAGE">
    <xs:annotation>
        <xs:documentation>Defines a CIM message in the CIM-XML protocol.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:choice>
            <xs:element ref="SIMPLEREQ"/>
            <xs:element ref="MULTIREQ"/>
            <xs:element ref="SIMPLERSP"/>
            <xs:element ref="MULTIRSP"/>
            <xs:element ref="SIMPLEEXPREQ"/>
            <xs:element ref="MULTIEXPREQ"/>
            <xs:element ref="SIMPLEEXPRSP"/>
            <xs:element ref="MULTIEXPRSP"/>
        </xs:choice>
        <xs:attribute name="ID" type="xs:string" use="required"/>
        <xs:attribute name="PROTOCOLVERSION" type="VersionMN_Type" use="required"/>
    </xs:complexType>
</xs:element>

type CimMethod ¶

type CimMethod struct {
	XMLName     xml.Name          `xml:"METHOD"`
	Name        string            `xml:"NAME,attr"`
	Type        string            `xml:"TYPE,attr,omitempty"`
	ClassOrigin string            `xml:"CLASSORIGIN,attr,omitempty"`
	Propagated  bool              `xml:"PROPAGATED,attr,omitempty"`
	Qualifiers  []CimQualifier    `xml:"QUALIFIER,omitempty"`
	Parameters  []CimAnyParameter `xml:",any,omitempty"`
}

<xs:element name="METHOD">
    <xs:annotation>
        <xs:documentation>Defines a CIM method within a class declaration.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:element ref="QUALIFIER" minOccurs="0" maxOccurs="unbounded"/>
            <xs:choice minOccurs="0" maxOccurs="unbounded">
                <xs:element ref="PARAMETER"/>
                <xs:element ref="PARAMETER.REFERENCE"/>
                <xs:element ref="PARAMETER.ARRAY"/>
                <xs:element ref="PARAMETER.REFARRAY"/>
            </xs:choice>
        </xs:sequence>
        <xs:attribute ref="NAME" use="required"/>
        <xs:attribute ref="TYPE"/>
        <xs:attribute ref="CLASSORIGIN"/>
        <xs:attribute ref="PROPAGATED"/>
    </xs:complexType>
</xs:element>

type CimMethodCall ¶

type CimMethodCall struct {
	XMLName           xml.Name              `xml:"METHODCALL"`
	Name              string                `xml:"NAME,attr"`
	LocalClassPath    *CimLocalClassPath    `xml:"LOCALCLASSPATH,omitempty"`
	LocalInstancePath *CimLocalInstancePath `xml:"LOCALINSTANCEPATH,omitempty"`
	ParamValues       []CimParamValue       `xml:"PARAMVALUE,omitempty"`
}

<xs:element name="METHODCALL">
    <xs:annotation>
        <xs:documentation>Defines a single extrinsic (= class-defined) method invocation request.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:choice>
                <xs:element ref="LOCALCLASSPATH"/>
                <xs:element ref="LOCALINSTANCEPATH"/>
            </xs:choice>
            <xs:element ref="PARAMVALUE" minOccurs="0" maxOccurs="unbounded"/>
        </xs:sequence>
        <xs:attribute ref="NAME" use="required"/>
    </xs:complexType>
</xs:element>

type CimMethodResponse ¶

type CimMethodResponse struct {
	XMLName     xml.Name        `xml:"METHODRESPONSE"`
	Name        string          `xml:"NAME,attr"`
	Error       *CimError       `xml:"ERROR,omitempty"`
	ReturnValue *CimReturnValue `xml:"RETURNVALUE,omitempty"`
	ParamValues []CimParamValue `xml:"PARAMVALUE,omitempty"`
}

<xs:element name="METHODRESPONSE">
    <xs:annotation>
        <xs:documentation>Defines a single extrinsic (= class-defined) method invocation response.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:choice>
            <xs:element ref="ERROR"/>
            <xs:sequence>
                <xs:element ref="RETURNVALUE" minOccurs="0"/>
                <xs:element ref="PARAMVALUE" minOccurs="0" maxOccurs="unbounded"/>
            </xs:sequence>
        </xs:choice>
        <xs:attribute ref="NAME" use="required"/>
    </xs:complexType>
</xs:element>

type CimMultiExpReq ¶

type CimMultiExpReq struct {
	XMLName       xml.Name          `xml:"MULTIEXPREQ"`
	SimpleExpReqs []CimSimpleExpReq `xml:"SIMPLEEXPREQ"`
}

<xs:element name="MULTIEXPREQ">
    <xs:annotation>
        <xs:documentation>Defines a multiple CIM export (= listener operation) request.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:element ref="SIMPLEEXPREQ" minOccurs="2" maxOccurs="unbounded"/>
        </xs:sequence>
    </xs:complexType>
</xs:element>

type CimMultiExpRsp ¶

type CimMultiExpRsp struct {
	XMLName       xml.Name          `xml:"MULTIEXPRSP"`
	SimpleExpRsps []CimSimpleExpRsp // `xml:"SIMPLEEXPRSP,omitempty"`
}

<xs:element name="MULTIEXPRSP">
    <xs:annotation>
        <xs:documentation>Defines a multiple CIM export response.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:element ref="SIMPLEEXPRSP" minOccurs="2" maxOccurs="unbounded"/>
        </xs:sequence>
    </xs:complexType>
</xs:element>

type CimMultiReq ¶

type CimMultiReq struct {
	XMLName    xml.Name       `xml:"MULTIREQ"`
	SimpleReqs []CimSimpleReq `xml:"SIMPLEREQ"`
}

<xs:element name="MULTIREQ">
    <xs:annotation>
        <xs:documentation>Defines a multiple CIM operation request.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:element ref="SIMPLEREQ" minOccurs="2" maxOccurs="unbounded"/>
        </xs:sequence>
    </xs:complexType>
</xs:element>

type CimMultiRsp ¶

type CimMultiRsp struct {
	XMLName    xml.Name       `xml:"MULTIRSP"`
	SimpleRsps []CimSimpleRsp `xml:"SIMPLEREQ"`
}

<xs:element name="MULTIRSP">
    <xs:annotation>
        <xs:documentation>Defines a multiple CIM operation response.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:element ref="SIMPLERSP" minOccurs="2" maxOccurs="unbounded"/>
        </xs:sequence>
    </xs:complexType>
</xs:element>

type CimNamespace ¶

type CimNamespace struct {
	XMLName xml.Name `xml:"NAMESPACE"`
	Name    string   `xml:"NAME,attr"`
}

<xs:element name="NAMESPACE">
    <xs:annotation>
        <xs:documentation>Defines a single namespace within the namespace component of a namespace path.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:attribute ref="NAME" use="required"/>
    </xs:complexType>
</xs:element>

func ToCimNamespace(ns string) []CimNamespace

type CimNamespacePath ¶

type CimNamespacePath struct {
	XMLName            xml.Name              `xml:"NAMESPACEPATH"`
	Host               CimHost               `xml:"HOST"`
	LocalNamespacePath CimLocalNamespacePath `xml:"LOCALNAMESPACEPATH"`
}

<!-- Section: Naming and Location Elements -->
<xs:element name="NAMESPACEPATH">
    <xs:annotation>
        <xs:documentation>Defines an (absolute) namespace path.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:element ref="HOST"/>
            <xs:element ref="LOCALNAMESPACEPATH"/>
        </xs:sequence>
    </xs:complexType>
</xs:element>

func (self *CimNamespacePath) IsNil() bool

func (self *CimNamespacePath) String() string

func (self *CimNamespacePath) ToString(buf *strings.Builder)

type CimObjectPath ¶

type CimObjectPath struct {
	XMLName      xml.Name         `xml:"OBJECTPATH"`
	InstancePath *CimInstancePath `xml:"INSTANCEPATH,omitempty"`
	ClassPath    *CimClassPath    `xml:"CLASSPATH,omitempty"`
}

<xs:element name="OBJECTPATH">
    <xs:annotation>
        <xs:documentation>Defines the full path to a single CIM object (class or instance).

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:choice>
            <xs:element ref="INSTANCEPATH"/>
            <xs:element ref="CLASSPATH"/>
        </xs:choice>
    </xs:complexType>
</xs:element>

func (self *CimObjectPath) IsNil() bool

func (self *CimObjectPath) String() string

func (self *CimObjectPath) ToString(buf *strings.Builder)

type CimParamValue ¶

type CimParamValue struct {
	XMLName            xml.Name               `xml:"PARAMVALUE"`
	Name               string                 `xml:"NAME,attr"`
	ParamType          string                 `xml:"PARAMTYPE,attr,omitempty"`
	EmbeddedObject     string                 `xml:"EmbeddedObject,attr,omitempty"`
	Value              *CimValue              `xml:"VALUE,omitempty"`
	ValueReference     *CimValueReference     `xml:"VALUE.REFERENCE,omitempty"`
	ValueArray         *CimValueArray         `xml:"VALUE.ARRAY,omitempty"`
	ValueRefArray      *CimValueRefArray      `xml:"VALUE.REFARRAY,omitempty"`
	ClassName          *CimClassName          `xml:"CLASSNAME,omitempty"`
	InstanceName       *CimInstanceName       `xml:"INSTANCENAME,omitempty"`
	Class              *CimClass              `xml:"CLASS,omitempty"`
	Instance           *CimInstance           `xml:"INSTANCE,omitempty"`
	ValueNamedInstance *CimValueNamedInstance `xml:"VALUE.NAMEDINSTANCE,omitempty"`
}

<xs:element name="PARAMVALUE">
    <xs:annotation>
        <xs:documentation>Defines a parameter value that is used in an extrinsic (= class defined) and - for

historical reasons - also in an intrinsic method (= operation) request or response. For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:choice minOccurs="0">
            <xs:element ref="VALUE"/>
            <xs:element ref="VALUE.REFERENCE"/>
            <xs:element ref="VALUE.ARRAY"/>
            <xs:element ref="VALUE.REFARRAY"/>
            <xs:element ref="CLASSNAME"/>
            <xs:element ref="INSTANCENAME"/>
            <xs:element ref="CLASS"/>
            <xs:element ref="INSTANCE"/>
            <xs:element ref="VALUE.NAMEDINSTANCE"/>
        </xs:choice>
        <xs:attribute ref="NAME" use="required"/>
        <xs:attribute ref="PARAMTYPE"/>
        <xs:attribute ref="EmbeddedObject"/>
    </xs:complexType>
</xs:element>

func (paramValue *CimParamValue) GetName() string

func (paramValue *CimParamValue) GetParamType() string

func (paramValue *CimParamValue) GetValue() Valuer

type CimParameter ¶

type CimParameter struct {
	XMLName    xml.Name       `xml:"PARAMETER"`
	Name       string         `xml:"NAME,attr"`
	Type       string         `xml:"TYPE,attr"`
	Qualifiers []CimQualifier `xml:"QUALIFIER,omitempty"`
}

<xs:element name="PARAMETER">
    <xs:annotation>
        <xs:documentation>Defines a non-reference scalar CIM parameter within a method in a class declaration.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:element ref="QUALIFIER" minOccurs="0" maxOccurs="unbounded"/>
        </xs:sequence>
        <xs:attribute ref="NAME" use="required"/>
        <xs:attribute ref="TYPE" use="required"/>
    </xs:complexType>
</xs:element>

type CimParameterArray ¶

type CimParameterArray struct {
	XMLName    xml.Name       `xml:"PARAMETER.ARRAY"`
	Name       string         `xml:"NAME,attr"`
	Type       string         `xml:"TYPE,attr"`
	ArraySize  int            `xml:"ARRAYSIZE,attr,omitempty"`
	Qualifiers []CimQualifier `xml:"QUALIFIER,omitempty"`
}

<xs:element name="PARAMETER.ARRAY">
    <xs:annotation>
        <xs:documentation>Defines a non-reference array CIM parameter within a method in a class declaration.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:element ref="QUALIFIER" minOccurs="0" maxOccurs="unbounded"/>
        </xs:sequence>
        <xs:attribute ref="NAME" use="required"/>
        <xs:attribute ref="TYPE" use="required"/>
        <xs:attribute ref="ARRAYSIZE"/>
    </xs:complexType>
</xs:element>

type CimParameterRefArray ¶

type CimParameterRefArray struct {
	XMLName        xml.Name       `xml:"PARAMETER.REFARRAY"`
	Name           string         `xml:"NAME,attr"`
	ReferenceClass string         `xml:"REFERENCECLASS,attr"`
	ArraySize      int            `xml:"ARRAYSIZE,attr,omitempty"`
	Qualifiers     []CimQualifier `xml:"QUALIFIER,omitempty"`
}

<xs:element name="PARAMETER.REFARRAY">
    <xs:annotation>
        <xs:documentation>Defines a reference-typed array CIM parameter within a method in a class declaration.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:element ref="QUALIFIER" minOccurs="0" maxOccurs="unbounded"/>
        </xs:sequence>
        <xs:attribute ref="NAME" use="required"/>
        <xs:attribute ref="REFERENCECLASS"/>
        <xs:attribute ref="ARRAYSIZE"/>
    </xs:complexType>
</xs:element>

type CimParameterReference ¶

type CimParameterReference struct {
	XMLName        xml.Name       `xml:"PARAMETER.REFERENCE"`
	Name           string         `xml:"NAME,attr"`
	ReferenceClass string         `xml:"REFERENCECLASS,attr,omitempty"`
	Qualifiers     []CimQualifier `xml:"QUALIFIER,omitempty"`
}

<xs:element name="PARAMETER.REFERENCE">
    <xs:annotation>
        <xs:documentation>Defines a reference-typed scalar CIM parameter within a method in a class declaration.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:element ref="QUALIFIER" minOccurs="0" maxOccurs="unbounded"/>
        </xs:sequence>
        <xs:attribute ref="NAME" use="required"/>
        <xs:attribute ref="REFERENCECLASS"/>
    </xs:complexType>
</xs:element>

type CimProperty ¶

type CimProperty struct {
	XMLName        xml.Name       `xml:"PROPERTY"`
	Name           string         `xml:"NAME,attr"`
	Type           string         `xml:"TYPE,attr"`
	ClassOrigin    string         `xml:"CLASSORIGIN,attr,omitempty"`
	Propagated     bool           `xml:"PROPAGATED,attr,omitempty"`
	EmbeddedObject string         `xml:"EmbeddedObject,attr,omitempty"`
	Lang           string         `xml:"lang,attr,omitempty"`
	Qualifiers     []CimQualifier `xml:"QUALIFIER",omitempty`
	Value          *CimValue      `xml:"VALUE,omitempty"`
}

<xs:element name="PROPERTY">
    <xs:annotation>
        <xs:documentation>Defines a non-reference scalar property, that is used as a property value in a CIM instance

or as a property declaration in a CIM class. For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:element ref="QUALIFIER" minOccurs="0" maxOccurs="unbounded"/>
            <xs:element ref="VALUE" minOccurs="0"/>
        </xs:sequence>
        <xs:attribute ref="NAME" use="required"/>
        <xs:attribute ref="TYPE" use="required"/>
        <xs:attribute ref="CLASSORIGIN"/>
        <xs:attribute ref="PROPAGATED"/>
        <xs:attribute ref="EmbeddedObject"/>
        <xs:attribute ref="xml:lang"/>
    </xs:complexType>
</xs:element>

func (self *CimProperty) GetClassOrigin() string

func (self *CimProperty) GetEmbeddedObject() string

func (self *CimProperty) GetName() string

func (self *CimProperty) GetOriginClass() string

func (self *CimProperty) GetType() CIMType

func (self *CimProperty) GetValue() interface{}

func (self *CimProperty) IsKey() bool

func (self *CimProperty) IsPropagated() bool

type CimPropertyArray ¶

type CimPropertyArray struct {
	XMLName        xml.Name       `xml:"PROPERTY.ARRAY"`
	Name           string         `xml:"NAME,attr"`
	Type           string         `xml:"TYPE,attr"`
	ArraySize      int            `xml:"ARRAYSIZE,attr,omitempty"`
	ClassOrigin    string         `xml:"CLASSORIGIN,attr,omitempty"`
	Propagated     bool           `xml:"PROPAGATED,attr,omitempty"`
	EmbeddedObject string         `xml:"EmbeddedObject,attr,omitempty"`
	Lang           string         `xml:"lang,attr,omitempty"`
	Qualifiers     []CimQualifier `xml:"QUALIFIER,omitempty"`
	ValueArray     *CimValueArray `xml:"VALUE.ARRAY,omitempty"`
}

<xs:element name="PROPERTY.ARRAY">
    <xs:annotation>
        <xs:documentation>Defines a non-reference array property, that is used as a property value in a CIM instance

or as a property declaration in a CIM class. For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:element ref="QUALIFIER" minOccurs="0" maxOccurs="unbounded"/>
            <xs:element ref="VALUE.ARRAY" minOccurs="0"/>
        </xs:sequence>
        <xs:attribute ref="NAME" use="required"/>
        <xs:attribute ref="TYPE" use="required"/>
        <xs:attribute ref="ARRAYSIZE"/>
        <xs:attribute ref="CLASSORIGIN"/>
        <xs:attribute ref="PROPAGATED"/>
        <xs:attribute ref="EmbeddedObject"/>
        <xs:attribute ref="xml:lang"/>
    </xs:complexType>
</xs:element>

func (self *CimPropertyArray) GetClassOrigin() string

func (self *CimPropertyArray) GetEmbeddedObject() string

func (self *CimPropertyArray) GetName() string

func (self *CimPropertyArray) GetOriginClass() string

func (self *CimPropertyArray) GetType() CIMType

func (self *CimPropertyArray) GetValue() interface{}

func (self *CimPropertyArray) IsKey() bool

func (self *CimPropertyArray) IsPropagated() bool

type CimPropertyReference ¶

type CimPropertyReference struct {
	XMLName        xml.Name           `xml:"PROPERTY.REFERENCE"`
	Name           string             `xml:"NAME,attr"`
	ReferenceClass string             `xml:"REFERENCECLASS,attr,omitempty"`
	ClassOrigin    string             `xml:"CLASSORIGIN,attr,omitempty"`
	Propagated     bool               `xml:"PROPAGATED,attr,omitempty"`
	Qualifiers     []CimQualifier     `xml:"QUALIFIER,omitempty"`
	ValueReference *CimValueReference `xml:"VALUE.REFERENCE,omitempty"`
}

<xs:element name="PROPERTY.REFERENCE">
    <xs:annotation>
        <xs:documentation>Defines a scalar reference property, that is used as a property value in a CIM instance

or as a property declaration in a CIM class. For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:element ref="QUALIFIER" minOccurs="0" maxOccurs="unbounded"/>
            <xs:element ref="VALUE.REFERENCE" minOccurs="0"/>
        </xs:sequence>
        <xs:attribute ref="NAME" use="required"/>
        <xs:attribute ref="REFERENCECLASS"/>
        <xs:attribute ref="CLASSORIGIN"/>
        <xs:attribute ref="PROPAGATED"/>
    </xs:complexType>
</xs:element>

func (self *CimPropertyReference) GetClassOrigin() string

func (self *CimPropertyReference) GetEmbeddedObject() string

func (self *CimPropertyReference) GetName() string

func (self *CimPropertyReference) GetOriginClass() string

func (self *CimPropertyReference) GetType() CIMType

func (self *CimPropertyReference) GetValue() interface{}

func (self *CimPropertyReference) IsKey() bool

func (self *CimPropertyReference) IsPropagated() bool

type CimQualifier ¶

type CimQualifier struct {
	CimQualifierFlavor

	XMLName    xml.Name       `xml:"QUALIFIER"`
	Name       string         `xml:"NAME,attr"`
	Type       string         `xml:"TYPE,attr"`
	Propagated bool           `xml:"PROPAGATED,attr,omitempty"`
	Lang       string         `xml:"lang,attr,omitempty"`
	Value      *CimValue      `xml:"VALUE,omitempty"`
	ValueArray *CimValueArray `xml:"VALUE.ARRAY,omitempty"`
}

<xs:element name="QUALIFIER">
    <xs:annotation>
        <xs:documentation>Defines a CIM qualifier value.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:choice minOccurs="0">
                <xs:element ref="VALUE"/>
                <xs:element ref="VALUE.ARRAY"/>
            </xs:choice>
        </xs:sequence>
        <xs:attribute ref="NAME" use="required"/>
        <xs:attribute ref="TYPE" use="required"/>
        <xs:attribute ref="PROPAGATED"/>
        <xs:attributeGroup ref="QualifierFlavor"/>
        <xs:attribute ref="xml:lang"/>
    </xs:complexType>
</xs:element>

type CimQualifierDeclaration ¶

type CimQualifierDeclaration struct {
	CimQualifierFlavor

	XMLName   xml.Name `xml:"QUALIFIER.DECLARATION"`
	Name      string   `xml:"NAME,attr"`
	Type      string   `xml:"TYPE,attr"`
	IsArray   bool     `xml:"ISARRAY,attr,omitempty"`
	ArraySize int      `xml:"ARRAYSIZE,attr,omitempty"`

	Scope      *CimScope      `xml:"SCOPE,omitempty"`
	Value      *CimValue      `xml:"VALUE,omitempty"`
	ValueArray *CimValueArray `xml:"VALUE.ARRAY,omitempty"`
}

<xs:element name="QUALIFIER.DECLARATION">
    <xs:annotation>
        <xs:documentation>Defines a single CIM qualifier type/declaration.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:element ref="SCOPE" minOccurs="0"/>
            <xs:choice minOccurs="0">
                <xs:element ref="VALUE"/>
                <xs:element ref="VALUE.ARRAY"/>
            </xs:choice>
        </xs:sequence>
        <xs:attribute ref="NAME" use="required"/>
        <xs:attribute ref="TYPE" use="required"/>
        <xs:attribute name="ISARRAY" type="xs:boolean" default="false"/>
        <xs:attribute ref="ARRAYSIZE"/>
        <xs:attributeGroup ref="QualifierFlavor"/>
    </xs:complexType>
</xs:element>

type CimQualifierFlavor ¶

type CimQualifierFlavor struct {
	Overridable  bool `xml:"OVERRIDABLE,attr,omitempty"`
	ToSubclass   bool `xml:"TOSUBCLASS,attr,omitempty"`
	ToInstance   bool `xml:"TOINSTANCE,attr,omitempty"`
	Translatable bool `xml:"TRANSLATABLE,attr,omitempty"`
}

<xs:attributeGroup name="QualifierFlavor">
    <xs:annotation>
        <xs:documentation>Defines the flavor settings for a CIM qualifier declaration;

this attribute group corresponds to the %QualifierFlavor entity in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:attribute name="OVERRIDABLE" type="xs:boolean" default="true"/>
    <xs:attribute name="TOSUBCLASS" type="xs:boolean" default="true"/>
    <xs:attribute name="TOINSTANCE" type="xs:boolean" default="false"/>
    <xs:attribute name="TRANSLATABLE" type="xs:boolean" default="false"/>
</xs:attributeGroup>

type CimReturnValue ¶

type CimReturnValue struct {
	XMLName        xml.Name           `xml:"RETURNVALUE"`
	ParamType      string             `xml:"PARAMTYPE,attr"`
	EmbeddedObject string             `xml:"EmbeddedObject,attr"`
	Value          *CimValue          `xml:"VALUE,omitempty"`
	ValueReference *CimValueReference `xml:"VALUE.REFERENCE,omitempty"`
}

<xs:element name="RETURNVALUE">
    <xs:annotation>
        <xs:documentation>Defines the return value of an extrinsic (= class defined) method within a response.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:choice minOccurs="0">
            <xs:element ref="VALUE"/>
            <xs:element ref="VALUE.REFERENCE"/>
        </xs:choice>
        <xs:attribute ref="PARAMTYPE"/>
        <xs:attribute ref="EmbeddedObject"/>
    </xs:complexType>
</xs:element>

type CimScope ¶

type CimScope struct {
	XMLName     xml.Name `xml:"SCOPE"`
	Class       bool     `xml:"CLASS,attr,omitempty"`
	Association bool     `xml:"ASSOCIATION,attr,omitempty"`
	Reference   bool     `xml:"REFERENCE,attr,omitempty"`
	Property    bool     `xml:"PROPERTY,attr,omitempty"`
	Method      bool     `xml:"METHOD,attr,omitempty"`
	Parameter   bool     `xml:"PARAMETER,attr,omitempty"`
	Indication  bool     `xml:"INDICATION,attr,omitempty"`
}

<xs:element name="SCOPE">
    <xs:annotation>
        <xs:documentation>Defines the scope of a qualifier type/declaration.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:attribute name="CLASS" type="xs:boolean" default="false"/>
        <xs:attribute name="ASSOCIATION" type="xs:boolean" default="false"/>
        <xs:attribute name="REFERENCE" type="xs:boolean" default="false"/>
        <xs:attribute name="PROPERTY" type="xs:boolean" default="false"/>
        <xs:attribute name="METHOD" type="xs:boolean" default="false"/>
        <xs:attribute name="PARAMETER" type="xs:boolean" default="false"/>
        <xs:attribute name="INDICATION" type="xs:boolean" default="false"/>
    </xs:complexType>
</xs:element>

type CimSimpleExpReq ¶

type CimSimpleExpReq struct {
	XMLName       xml.Name         `xml:"SIMPLEEXPREQ"`
	Correlator    []CimCorrelator  `xml:"CORRELATOR,omitempty"`
	ExpMethodCall CimExpMethodCall `xml:"EXPMETHODCALL"`
}

<xs:element name="SIMPLEEXPREQ">
    <xs:annotation>
        <xs:documentation>Defines a simple CIM export (= listener operation) request.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:element ref="CORRELATOR" minOccurs="0" maxOccurs="unbounded"/>
            <xs:element ref="EXPMETHODCALL"/>
        </xs:sequence>
    </xs:complexType>
</xs:element>

type CimSimpleExpRsp ¶

type CimSimpleExpRsp struct {
	XMLName           xml.Name             `xml:"SIMPLEEXPRSP"`
	ExpMethodResponse CimExpMethodResponse `xml:"EXPMETHODRESPONSE"`
}

<xs:element name="SIMPLEEXPRSP">
    <xs:annotation>
        <xs:documentation>Defines a simple CIM export response.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:element ref="EXPMETHODRESPONSE"/>
        </xs:sequence>
    </xs:complexType>
</xs:element>

type CimSimpleReq ¶

type CimSimpleReq struct {
	XMLName     xml.Name        `xml:"SIMPLEREQ"`
	Correlators []CimCorrelator `xml:"CORRELATOR,omitempty"`
	MethodCall  *CimMethodCall  `xml:"METHODCALL,omitempty"`
	IMethodCall *CimIMethodCall `xml:"IMETHODCALL,omitempty"`
}

<xs:element name="SIMPLEREQ">
    <xs:annotation>
        <xs:documentation>Defines a simple CIM operation request.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:element ref="CORRELATOR" minOccurs="0" maxOccurs="unbounded"/>
            <xs:choice>
                <xs:element ref="METHODCALL"/>
                <xs:element ref="IMETHODCALL"/>
            </xs:choice>
        </xs:sequence>
    </xs:complexType>
</xs:element>

type CimSimpleRsp ¶

type CimSimpleRsp struct {
	XMLName         xml.Name            `xml:"SIMPLERSP"`
	MethodResponse  *CimMethodResponse  `xml:"METHODRESPONSE,omitempty"`
	IMethodResponse *CimIMethodResponse `xml:"IMETHODRESPONSE,omitempty"`
}

<xs:element name="SIMPLERSP">
    <xs:annotation>
        <xs:documentation>Defines a simple CIM operation response.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:choice>
            <xs:element ref="METHODRESPONSE"/>
            <xs:element ref="IMETHODRESPONSE"/>
        </xs:choice>
    </xs:complexType>
</xs:element>

type CimValue ¶

type CimValue struct {
	XMLName xml.Name `xml:"VALUE"`
	Value   string   `xml:",chardata"`
}

<!-- Section: Value Elements -->
<xs:element name="VALUE">
    <xs:annotation>
        <xs:documentation>Defines a non-reference, non-NULL scalar value.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:simpleType>
        <xs:union memberTypes="StringValue_Type CharacterValue_Type RealValue_Type BooleanValue_Type IntegerValue_Type DateTimeValue_Type"/>
    </xs:simpleType>
</xs:element>

func (self *CimValue) GetValue() interface{}

func (self *CimValue) IsNil() bool

func (self *CimValue) String() string

func (self *CimValue) ToString(buf *strings.Builder)

type CimValueArray ¶

type CimValueArray struct {
	XMLName xml.Name         `xml:"VALUE.ARRAY"`
	Values  []CimValueOrNull `xml:",any,omitempty"`
}

<xs:element name="VALUE.ARRAY">
    <xs:annotation>
        <xs:documentation>Defines an non-reference array value.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
            <xs:element ref="VALUE"/>
            <xs:element ref="VALUE.NULL"/>
        </xs:choice>
    </xs:complexType>
</xs:element>

func (self *CimValueArray) GetValue() interface{}

func (self *CimValueArray) IsNil() bool

func (self *CimValueArray) String() string

func (self *CimValueArray) ToString(buf *strings.Builder)

type CimValueInstanceWithPath ¶

type CimValueInstanceWithPath struct {
	XMLName      xml.Name        `xml:"VALUE.INSTANCEWITHPATH"`
	InstancePath CimInstancePath `xml:"INSTANCEPATH"`
	Instance     CimInstance     `xml:"INSTANCE"`
}

<xs:element name="VALUE.INSTANCEWITHPATH">
    <xs:annotation>
        <xs:documentation>Defines a value that comprises a CIM instance definition with additional information that

defines the absolute path to that object. For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:element ref="INSTANCEPATH"/>
            <xs:element ref="INSTANCE"/>
        </xs:sequence>
    </xs:complexType>
</xs:element>

type CimValueNamedInstance ¶

type CimValueNamedInstance struct {
	XMLName      xml.Name        `xml:"VALUE.NAMEDINSTANCE"`
	InstanceName CimInstanceName `xml:"INSTANCENAME"`
	Instance     CimInstance     `xml:"INSTANCE"`
}

<xs:element name="VALUE.NAMEDINSTANCE">
    <xs:annotation>
        <xs:documentation>Defines a value that comprises a named CIM instance definition.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:sequence>
            <xs:element ref="INSTANCENAME"/>
            <xs:element ref="INSTANCE"/>
        </xs:sequence>
    </xs:complexType>
</xs:element>

func (self *CimValueNamedInstance) GetInstance() CIMInstance

func (self *CimValueNamedInstance) GetName() CIMInstanceName

func (self *CimValueNamedInstance) String() string

func (self *CimValueNamedInstance) ToString(buf *strings.Builder)

type CimValueNamedObject ¶

type CimValueNamedObject struct {
	XMLName      xml.Name         `xml:"VALUE.NAMEDOBJECT"`
	Class        *CimClass        `xml:"CLASS,omitempty"`
	InstanceName *CimInstanceName `xml:"INSTANCENAME,omitempty"`
	Instance     *CimInstance     `xml:"INSTANCE,omitempty"`
}

<xs:element name="VALUE.NAMEDOBJECT">
    <xs:annotation>
        <xs:documentation>Defines a value that comprises a named CIM object (class or instance) definition.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:choice>
            <xs:element ref="CLASS"/>
            <xs:sequence>
                <xs:element ref="INSTANCENAME"/>
                <xs:element ref="INSTANCE"/>
            </xs:sequence>
        </xs:choice>
    </xs:complexType>
</xs:element>

type CimValueNull ¶

type CimValueNull struct {
	XMLName xml.Name `xml:"VALUE.NULL"`
}

<xs:element name="VALUE.NULL">
    <xs:annotation>
        <xs:documentation>Defines the NULL value.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType/>
</xs:element>

type CimValueObject ¶

type CimValueObject struct {
	XMLName  xml.Name     `xml:"VALUE.OBJECT"`
	Instance *CimInstance `xml:"INSTANCE,omitempty"`
	Class    *CimClass    `xml:"CLASS,omitempty"`
}

<xs:element name="VALUE.OBJECT">
    <xs:annotation>
        <xs:documentation>Defines a value that comprises a CIM object (class or instance) definition.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:choice>
            <xs:element ref="CLASS"/>
            <xs:element ref="INSTANCE"/>
        </xs:choice>
    </xs:complexType>
</xs:element>

type CimValueObjectWithLocalPath ¶

type CimValueObjectWithLocalPath struct {
	XMLName      xml.Name              `xml:"VALUE.OBJECTWITHLOCALPATH"`
	ClassPath    *CimLocalClassPath    `xml:"LOCALCLASSPATH,omitempty"`
	Class        *CimClass             `xml:"CLASS,omitempty"`
	InstancePath *CimLocalInstancePath `xml:"LOCALINSTANCEPATH,omitempty"`
	Instance     *CimInstance          `xml:"INSTANCE,omitempty"`
}

<xs:element name="VALUE.OBJECTWITHLOCALPATH">
    <xs:annotation>
        <xs:documentation>Defines a value that comprises a CIM object (class or instance) definition with additional

information that defines the local path to that object. For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:choice>
            <xs:sequence>
                <xs:element ref="LOCALCLASSPATH"/>
                <xs:element ref="CLASS"/>
            </xs:sequence>
            <xs:sequence>
                <xs:element ref="LOCALINSTANCEPATH"/>
                <xs:element ref="INSTANCE"/>
            </xs:sequence>
        </xs:choice>
    </xs:complexType>
</xs:element>

func (object CimValueObjectWithLocalPath) GetInstance() CIMInstance

func (object CimValueObjectWithLocalPath) GetName() CIMInstanceName

type CimValueObjectWithPath ¶

type CimValueObjectWithPath struct {
	XMLName      xml.Name         `xml:"VALUE.OBJECTWITHPATH"`
	ClassPath    *CimClassPath    `xml:"CLASSPATH,omitempty"`
	Class        *CimClass        `xml:"CLASS,omitempty"`
	InstancePath *CimInstancePath `xml:"INSTANCEPATH,omitempty"`
	Instance     *CimInstance     `xml:"INSTANCE,omitempty"`
}

<xs:element name="VALUE.OBJECTWITHPATH">
    <xs:annotation>
        <xs:documentation>Defines a value that comprises a CIM object (class or instance) definition with additional

information that defines the absolute path to that object. For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:choice>
            <xs:sequence>
                <xs:element ref="CLASSPATH"/>
                <xs:element ref="CLASS"/>
            </xs:sequence>
            <xs:sequence>
                <xs:element ref="INSTANCEPATH"/>
                <xs:element ref="INSTANCE"/>
            </xs:sequence>
        </xs:choice>
    </xs:complexType>
</xs:element>

func (object CimValueObjectWithPath) GetInstance() CIMInstance

func (object CimValueObjectWithPath) GetName() CIMInstanceName

type CimValueOrNull ¶

type CimValueOrNull struct {
	Value *CimValue     `xml:"VALUE,omitempty"`
	Null  *CimValueNull `xml:"VALUE.NULL,omitempty"`
}

func (self *CimValueOrNull) GetValue() interface{}

func (self *CimValueOrNull) IsNil() bool

func (self *CimValueOrNull) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (self *CimValueOrNull) String() string

func (self *CimValueOrNull) ToString(buf *strings.Builder)

func (self *CimValueOrNull) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type CimValueRefArray ¶

type CimValueRefArray struct {
	XMLName xml.Name                  `xml:"VALUE.REFARRAY"`
	Values  []CimValueReferenceOrNull `xml:",any,omitempty"`
}

<xs:element name="VALUE.REFARRAY">
    <xs:annotation>
        <xs:documentation>Defines a reference array value.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:choice minOccurs="0" maxOccurs="unbounded">
            <xs:element ref="VALUE.REFERENCE"/>
            <xs:element ref="VALUE.NULL"/>
        </xs:choice>
    </xs:complexType>
</xs:element>

func (self *CimValueRefArray) GetValue() interface{}

func (self *CimValueRefArray) IsNil() bool

func (self *CimValueRefArray) String() string

func (self *CimValueRefArray) ToString(buf *strings.Builder)

type CimValueReference ¶

type CimValueReference struct {
	XMLName           xml.Name              `xml:"VALUE.REFERENCE"`
	ClassPath         *CimClassPath         `xml:"CLASSPATH,omitempty"`
	LocalClassPath    *CimLocalClassPath    `xml:"LOCALCLASSPATH,omitempty"`
	ClassName         *CimClassName         `xml:"CLASSNAME,omitempty"`
	InstancePath      *CimInstancePath      `xml:"INSTANCEPATH,omitempty"`
	LocalInstancePath *CimLocalInstancePath `xml:"LOCALINSTANCEPATH,omitempty"`
	InstanceName      *CimInstanceName      `xml:"INSTANCENAME,omitempty"`
}

<xs:element name="VALUE.REFERENCE">
    <xs:annotation>
        <xs:documentation>Defines a non-NULL reference scalar value.

For details, see the corresponding element defined in DSP0201.</xs:documentation>

    </xs:annotation>
    <xs:complexType>
        <xs:choice>
            <xs:element ref="CLASSPATH"/>
            <xs:element ref="LOCALCLASSPATH"/>
            <xs:element ref="CLASSNAME"/>
            <xs:element ref="INSTANCEPATH"/>
            <xs:element ref="LOCALINSTANCEPATH"/>
            <xs:element ref="INSTANCENAME"/>
        </xs:choice>
    </xs:complexType>
</xs:element>

func (self *CimValueReference) GetValue() interface{}

func (self *CimValueReference) IsNil() bool

func (self *CimValueReference) String() string

func (self *CimValueReference) ToString(buf *strings.Builder)

type CimValueReferenceOrNull ¶

type CimValueReferenceOrNull struct {
	Value *CimValueReference
	Null  *CimValueNull
}

func (self *CimValueReferenceOrNull) GetValue() interface{}

func (self *CimValueReferenceOrNull) IsNil() bool

func (self *CimValueReferenceOrNull) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (self *CimValueReferenceOrNull) String() string

func (self *CimValueReferenceOrNull) ToString(buf *strings.Builder)

func (self *CimValueReferenceOrNull) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type Client ¶

type Client struct {
	http.Client
	// contains filtered or unexported fields
}

func NewClient(u *url.URL, insecure bool) *Client

func (c *Client) MarshalJSON() ([]byte, error)

func (c *Client) RoundTrip(ctx context.Context, action string, headers map[string]string, reqBody interface{}, resBody HasFault) error

func (c *Client) URL() url.URL

func (c *Client) UnmarshalJSON(b []byte) error

type ClientCIMXML ¶

type ClientCIMXML struct {
	Client

	CimVersion      string
	DtdVersion      string
	ProtocolVersion string
}

func NewClientCIMXML(u *url.URL, insecure bool) (*ClientCIMXML, error)

func (c *ClientCIMXML) AssociatorClasses(ctx context.Context, namespaceName, className, assocClass, resultClass, role, resultRole string,
	includeQualifiers, includeClassOrigin bool, propertyList []string) ([]string, error)

func (c *ClientCIMXML) AssociatorInstances(ctx context.Context, namespaceName string, instanceName CIMInstanceName,
	assocClass, resultClass, role, resultRole string, includeClassOrigin bool, propertyList []string) ([]CIMInstanceWithName, error)

func (c *ClientCIMXML) AssociatorNames(ctx context.Context, namespaceName string, instanceName CIMInstanceName,
	assocClass, resultClass, role, resultRole string) ([]CIMInstanceName, error)

func (c *ClientCIMXML) EnumerateClassNames(ctx context.Context, namespaceName, className string, deep bool) ([]string, error)

func (c *ClientCIMXML) EnumerateClasses(ctx context.Context, namespaceName string, className string, deepInheritance bool,
	localOnly bool, includeQualifiers bool, includeClassOrigin bool) ([]string, error)

func (c *ClientCIMXML) EnumerateInstanceNames(ctx context.Context, namespaceName, className string) ([]CIMInstanceName, error)

func (c *ClientCIMXML) EnumerateInstances(ctx context.Context, namespaceName, className string, deepInheritance bool,
	localOnly bool, includeQualifiers bool, includeClassOrigin bool, propertyList []string) ([]CIMInstanceWithName, error)

func (c *ClientCIMXML) EnumerateNamespaces(ctx context.Context, nsList []string, timeout time.Duration, cb func(int, int)) ([]string, error)

func (c *ClientCIMXML) EnumerateQualifierTypes(ctx context.Context, namespaceName string) ([]CimQualifierDeclaration, error)

func (c *ClientCIMXML) GetClass(ctx context.Context, namespaceName string, className string, localOnly bool,
	includeQualifiers bool, includeClassOrigin bool, propertyList []string) (string, error)

func (c *ClientCIMXML) GetInstance(ctx context.Context, namespaceName, className string, keyBindings CIMKeyBindings, localOnly bool,
	includeQualifiers bool, includeClassOrigin bool, propertyList []string) (CIMInstance, error)

func (c *ClientCIMXML) GetInstanceByInstanceName(ctx context.Context, namespaceName string, instanceName CIMInstanceName, localOnly bool,
	includeQualifiers bool, includeClassOrigin bool, propertyList []string) (CIMInstance, error)

func (c *ClientCIMXML) InvokeMethod(ctx context.Context, namespaceName string,
	instanceName CIMInstanceName, methodName string, inParams []CIMParamValue) (Valuer, []CIMParamValue, error)

func (c *ClientCIMXML) ReferenceClasses(ctx context.Context, namespaceName, className, resultClass, role string,
	includeQualifiers, includeClassOrigin bool, propertyList []string) ([]string, error)

func (c *ClientCIMXML) ReferenceInstances(ctx context.Context, namespaceName string, instanceName CIMInstanceName,
	resultClass, role string, includeClassOrigin bool, propertyList []string) ([]CIMInstance, error)

func (c *ClientCIMXML) ReferenceNames(ctx context.Context, namespaceName string, instanceName CIMInstanceName,
	resultClass, role string) ([]CIMInstanceName, error)

type DebugProvider ¶

type DebugProvider interface {
	NewFile(s string) io.WriteCloser
	Flush()
}

Provider specified the interface types must implement to be used as a debugging sink. Having multiple such sink implementations allows it to be changed externally (for example when running tests).

type DecodeError ¶

type DecodeError struct {
	// contains filtered or unexported fields
}

func (f *DecodeError) Error() string

type FaultError ¶

type FaultError struct {
	// contains filtered or unexported fields
}

func (f *FaultError) Error() string

type FileDebugProvider ¶

type FileDebugProvider struct {
	Path string
}

FileProvider implements a debugging provider that creates a real file for every call to NewFile. It maintains a list of all files that it creates, such that it can close them when its Flush function is called.

func (fp *FileDebugProvider) Flush()

func (fp *FileDebugProvider) NewFile(p string) io.WriteCloser

type HasFault ¶

type HasFault interface {
	Fault() error
}

type RoundTripper ¶

type RoundTripper interface {
	RoundTrip(action string, reqBody interface{}, resBody HasFault, cached *bytes.Buffer) error
}

type Valuer ¶

type Valuer interface {
	String() string
}

type WbemError ¶

type WbemError struct {
	// contains filtered or unexported fields
}

func (e *WbemError) Error() string