595 lines
29 KiB
C#
595 lines
29 KiB
C#
//----------------------------------------------------------------------------
|
|
//
|
|
// Copyright (c) Intel Corporation, 2003 - 2012 All Rights Reserved.
|
|
//
|
|
// File: AMT_MessageLog.cs
|
|
//
|
|
// Contents: Extends MessageLog with multiple record fetching
|
|
// This file was automatically generated from AMT_MessageLog.mof
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Text;
|
|
using System.Globalization;
|
|
using System.Xml.Serialization;
|
|
using System.IO;
|
|
using Intel.Manageability.WSManagement;
|
|
using Intel.Manageability.Cim.Untyped;
|
|
|
|
|
|
namespace Intel.Manageability.Cim.Typed
|
|
{
|
|
/// <summary>
|
|
///Extends MessageLog with multiple record fetching
|
|
/// </summary>
|
|
[System.SerializableAttribute()]
|
|
[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_MessageLog")]
|
|
[System.Xml.Serialization.XmlRootAttribute("AMT_MessageLog", Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_MessageLog", IsNullable=false)]
|
|
public class AMT_MessageLog : CIM_MessageLog
|
|
{
|
|
/// <summary>
|
|
/// Default constructor.
|
|
/// </summary>
|
|
public AMT_MessageLog() :base()
|
|
{
|
|
}
|
|
/// <summary>
|
|
/// Constructor that recieves an xml string for deserialization.
|
|
/// </summary>
|
|
/// <param name="xml">xml string to deserialize</param>
|
|
public AMT_MessageLog(string xml): base((IWSManClient)null)
|
|
{
|
|
this.Deserialize(xml);
|
|
}
|
|
/// <summary>
|
|
/// Constructor which recieves a Ws-Management client object.
|
|
/// </summary>
|
|
/// <param name="client">Ws-Management client</param>
|
|
public AMT_MessageLog(IWSManClient client): base(client)
|
|
{
|
|
}
|
|
/// <summary>
|
|
///Retrieves multiple records from event log
|
|
/// </summary>
|
|
[System.SerializableAttribute()]
|
|
[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
|
|
[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_MessageLog", IsNullable=false)]
|
|
private class GetRecords_INPUT : CimParams
|
|
{
|
|
public GetRecords_INPUT(string ns) : base(ns)
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Required,
|
|
/// </summary>
|
|
[CimField(false,true)]
|
|
public virtual string IterationIdentifier
|
|
{
|
|
set
|
|
{
|
|
this.SetOrAddField("IterationIdentifier",value);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Required, Maximum number of records to read
|
|
/// </summary>
|
|
[CimField(false,true)]
|
|
public virtual uint MaxReadRecords
|
|
{
|
|
set
|
|
{
|
|
this.SetOrAddField("MaxReadRecords",value.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
///Retrieves multiple records from event log
|
|
/// </summary>
|
|
[System.SerializableAttribute()]
|
|
[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
|
|
[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_MessageLog", IsNullable=false)]
|
|
private class GetRecords_OUTPUT : CimParams
|
|
{
|
|
public GetRecords_OUTPUT() : base("")
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Required,
|
|
/// </summary>
|
|
[CimField(false,true)]
|
|
public virtual string IterationIdentifier
|
|
{
|
|
get
|
|
{
|
|
return this.GetField("IterationIdentifier")[0];
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Optional, Indicates that there are no more records to read
|
|
/// </summary>
|
|
[CimField(false,false)]
|
|
public virtual bool NoMoreRecords
|
|
{
|
|
get
|
|
{
|
|
return bool.Parse(this["NoMoreRecords"][0]);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Optional, Array of records encoded as Base64
|
|
/// </summary>
|
|
[CimField(false,false)]
|
|
public virtual string[] RecordArray
|
|
{
|
|
get
|
|
{
|
|
return this["RecordArray"];
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
///Retrieves multiple records from event log
|
|
/// </summary>
|
|
/// <param name="inIterationIdentifier">Required, IN -</param>
|
|
/// <param name="inMaxReadRecords">Required, IN -Maximum number of records to read</param>
|
|
/// <param name="outIterationIdentifier">OUT - </param>
|
|
/// <param name="outNoMoreRecords">OUT - Indicates that there are no more records to read</param>
|
|
/// <param name="outRecordArray">OUT - Array of records encoded as Base64</param>
|
|
/// <returns>
|
|
/// Legal values:
|
|
/// Completed with No Error : 0
|
|
/// Not Supported : 1
|
|
/// Invalid record pointed : 2
|
|
/// No record exists in log : 3
|
|
/// </returns>
|
|
public virtual uint GetRecords(string inIterationIdentifier,uint? inMaxReadRecords,out string outIterationIdentifier,out bool outNoMoreRecords,out string[] outRecordArray)
|
|
{
|
|
GetRecords_INPUT input = new GetRecords_INPUT(this.XmlNamespace);
|
|
if (inIterationIdentifier != null)
|
|
input.IterationIdentifier=inIterationIdentifier;
|
|
if (inMaxReadRecords.HasValue)
|
|
input.MaxReadRecords=inMaxReadRecords.Value;
|
|
GetRecords_OUTPUT output = new GetRecords_OUTPUT();
|
|
uint returnValue = base.Invoke("GetRecords",input,out output);
|
|
outIterationIdentifier=null;
|
|
outNoMoreRecords=false;
|
|
outRecordArray=null;
|
|
if (returnValue == 0)
|
|
{
|
|
if (output.ContainsField("IterationIdentifier"))
|
|
outIterationIdentifier = output.IterationIdentifier;
|
|
if (output.ContainsField("NoMoreRecords"))
|
|
outNoMoreRecords = output.NoMoreRecords;
|
|
if (output.ContainsField("RecordArray"))
|
|
outRecordArray = output.RecordArray;
|
|
}
|
|
return returnValue;
|
|
}
|
|
/// <summary>
|
|
///Requests that the record indicated by the IterationIdentifier be retrieved from the MessageLog. After retrieval, the IterationIdentifier may be advanced to the next record by setting the PositionToNext input parameter to TRUE. Two output parameters are defined for the method - RecordData which holds the contents of the Log entry (as an array of bytes that can be recast to an appropriate format), and RecordNumber which returns the current record number addressed via the Iteration Identifier. The RecordNumber parameter is only defined/valid when the Capabilities array indicates that ordinal record number addressing is supported (a value of 7).
|
|
///IterationIdentifier is defined as an Input/Output method parameter to allow the Log to embed state information in the Identifier and potentially let the identifier be maintained by the using application.
|
|
/// </summary>
|
|
[System.SerializableAttribute()]
|
|
[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
|
|
[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_MessageLog", IsNullable=false)]
|
|
private class GetRecord_INPUT : CimParams
|
|
{
|
|
public GetRecord_INPUT(string ns) : base(ns)
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Required, An identifier for the iterator.
|
|
/// </summary>
|
|
[CimField(false,true)]
|
|
public virtual string IterationIdentifier
|
|
{
|
|
set
|
|
{
|
|
this.SetOrAddField("IterationIdentifier",value);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Optional, Boolean indicating that the Iteration Identifier should be advanced to the next record, after retrieving the current Log entry.
|
|
/// </summary>
|
|
[CimField(false,false)]
|
|
public virtual bool PositionToNext
|
|
{
|
|
set
|
|
{
|
|
this.SetOrAddField("PositionToNext",value.ToString().ToLower(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
///Requests that the record indicated by the IterationIdentifier be retrieved from the MessageLog. After retrieval, the IterationIdentifier may be advanced to the next record by setting the PositionToNext input parameter to TRUE. Two output parameters are defined for the method - RecordData which holds the contents of the Log entry (as an array of bytes that can be recast to an appropriate format), and RecordNumber which returns the current record number addressed via the Iteration Identifier. The RecordNumber parameter is only defined/valid when the Capabilities array indicates that ordinal record number addressing is supported (a value of 7).
|
|
///IterationIdentifier is defined as an Input/Output method parameter to allow the Log to embed state information in the Identifier and potentially let the identifier be maintained by the using application.
|
|
/// </summary>
|
|
[System.SerializableAttribute()]
|
|
[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
|
|
[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_MessageLog", IsNullable=false)]
|
|
private class GetRecord_OUTPUT : CimParams
|
|
{
|
|
public GetRecord_OUTPUT() : base("")
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Required, An identifier for the iterator.
|
|
/// </summary>
|
|
[CimField(false,true)]
|
|
public virtual string IterationIdentifier
|
|
{
|
|
get
|
|
{
|
|
return this.GetField("IterationIdentifier")[0];
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Required, The record number.
|
|
/// </summary>
|
|
[CimField(false,true)]
|
|
public virtual ulong RecordNumber
|
|
{
|
|
get
|
|
{
|
|
return ulong.Parse(this["RecordNumber"][0], CultureInfo.InvariantCulture);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Optional, The record data.
|
|
/// </summary>
|
|
[CimField(false,false)]
|
|
public virtual byte[] RecordData
|
|
{
|
|
get
|
|
{
|
|
string[] arr = this["RecordData"];
|
|
List<byte> newArr = new List<byte>();
|
|
foreach (string str in arr)
|
|
{
|
|
newArr.Add(byte.Parse(str, CultureInfo.InvariantCulture));
|
|
}
|
|
return newArr.ToArray();
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
///Requests that the record indicated by the IterationIdentifier be retrieved from the MessageLog. After retrieval, the IterationIdentifier may be advanced to the next record by setting the PositionToNext input parameter to TRUE. Two output parameters are defined for the method - RecordData which holds the contents of the Log entry (as an array of bytes that can be recast to an appropriate format), and RecordNumber which returns the current record number addressed via the Iteration Identifier. The RecordNumber parameter is only defined/valid when the Capabilities array indicates that ordinal record number addressing is supported (a value of 7).
|
|
///IterationIdentifier is defined as an Input/Output method parameter to allow the Log to embed state information in the Identifier and potentially let the identifier be maintained by the using application.
|
|
/// </summary>
|
|
/// <param name="inIterationIdentifier">Required, IN -An identifier for the iterator.</param>
|
|
/// <param name="inPositionToNext">Optional, IN -Boolean indicating that the Iteration Identifier should be advanced to the next record, after retrieving the current Log entry.</param>
|
|
/// <param name="outIterationIdentifier">OUT - An identifier for the iterator.</param>
|
|
/// <param name="outRecordNumber">OUT - The record number.</param>
|
|
/// <param name="outRecordData">OUT - The record data.</param>
|
|
/// <returns>
|
|
/// Legal values:
|
|
/// Completed with No Error : 0
|
|
/// Not Supported : 1
|
|
/// Invalid record pointed : 2
|
|
/// No record exists in log : 3
|
|
/// </returns>
|
|
public override uint GetRecord(string inIterationIdentifier,bool? inPositionToNext,out string outIterationIdentifier,out ulong outRecordNumber,out byte[] outRecordData)
|
|
{
|
|
GetRecord_INPUT input = new GetRecord_INPUT(this.XmlNamespace);
|
|
if (inIterationIdentifier != null)
|
|
input.IterationIdentifier=inIterationIdentifier;
|
|
if (inPositionToNext.HasValue)
|
|
input.PositionToNext=inPositionToNext.Value;
|
|
GetRecord_OUTPUT output = new GetRecord_OUTPUT();
|
|
uint returnValue = base.Invoke("GetRecord",input,out output);
|
|
outIterationIdentifier=null;
|
|
outRecordNumber=0;
|
|
outRecordData=null;
|
|
if (returnValue == 0)
|
|
{
|
|
if (output.ContainsField("IterationIdentifier"))
|
|
outIterationIdentifier = output.IterationIdentifier;
|
|
if (output.ContainsField("RecordNumber"))
|
|
outRecordNumber = output.RecordNumber;
|
|
if (output.ContainsField("RecordData"))
|
|
outRecordData = output.RecordData;
|
|
}
|
|
return returnValue;
|
|
}
|
|
/// <summary>
|
|
///Requests that the Log's iteration identifier be advanced or retreated a specific number of records, or set to the entry at a specified numeric location. These two different behaviors are accomplished using the input parameters of the method. Advancing or retreating is achieved by setting the MoveAbsolute boolean to FALSE, and then specifying the number of entries to advance or retreat as positive or negative values in the RecordNumber parameter. Moving to a specific record number is accomplished by setting the MoveAbsolute input parameter to TRUE, and then placing the record number into the RecordNumber parameter. This can only be done if the Capabilities array includes a value of 7, "Supports Addressing by Ordinal Record Number".
|
|
///After the method completes and if ordinal record numbers are supported (the Capabilities array includes a 7), the current record number is returned in the RecordNumber output parameter. Otherwise, the value of the parameter is undefined.
|
|
///IterationIdentifier is defined as an Input/Output method parameter to allow the Log to embed state information in the Identifier and potentially let the identifier be maintained by the using application.
|
|
///Note: In a subclass, the set of possible return codes could be described using a ValueMap qualifier on the method. The strings to which the ValueMap contents are 'translated' may also be specified in the subclass as a Values array qualifier.
|
|
/// </summary>
|
|
[System.SerializableAttribute()]
|
|
[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
|
|
[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_MessageLog", IsNullable=false)]
|
|
private class PositionAtRecord_INPUT : CimParams
|
|
{
|
|
public PositionAtRecord_INPUT(string ns) : base(ns)
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Required, An identifier for the iterator.
|
|
/// </summary>
|
|
[CimField(false,true)]
|
|
public virtual string IterationIdentifier
|
|
{
|
|
set
|
|
{
|
|
this.SetOrAddField("IterationIdentifier",value);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Required, Advancing or retreating the IterationIdentifier is achieved by setting the MoveAbsolute boolean to FALSE, and specifying the number of entries to advance or retreat as positive or negative values in the RecordNumber parameter. Moving to a specific record number is accomplished by setting the MoveAbsolute parameter to TRUE, and placing the record number into the RecordNumber parameter.
|
|
/// </summary>
|
|
[CimField(false,true)]
|
|
public virtual bool MoveAbsolute
|
|
{
|
|
set
|
|
{
|
|
this.SetOrAddField("MoveAbsolute",value.ToString().ToLower(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Required, The relative or absolute record number.
|
|
/// </summary>
|
|
[CimField(false,true)]
|
|
public virtual long RecordNumber
|
|
{
|
|
set
|
|
{
|
|
this.SetOrAddField("RecordNumber",value.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
///Requests that the Log's iteration identifier be advanced or retreated a specific number of records, or set to the entry at a specified numeric location. These two different behaviors are accomplished using the input parameters of the method. Advancing or retreating is achieved by setting the MoveAbsolute boolean to FALSE, and then specifying the number of entries to advance or retreat as positive or negative values in the RecordNumber parameter. Moving to a specific record number is accomplished by setting the MoveAbsolute input parameter to TRUE, and then placing the record number into the RecordNumber parameter. This can only be done if the Capabilities array includes a value of 7, "Supports Addressing by Ordinal Record Number".
|
|
///After the method completes and if ordinal record numbers are supported (the Capabilities array includes a 7), the current record number is returned in the RecordNumber output parameter. Otherwise, the value of the parameter is undefined.
|
|
///IterationIdentifier is defined as an Input/Output method parameter to allow the Log to embed state information in the Identifier and potentially let the identifier be maintained by the using application.
|
|
///Note: In a subclass, the set of possible return codes could be described using a ValueMap qualifier on the method. The strings to which the ValueMap contents are 'translated' may also be specified in the subclass as a Values array qualifier.
|
|
/// </summary>
|
|
[System.SerializableAttribute()]
|
|
[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
|
|
[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_MessageLog", IsNullable=false)]
|
|
private class PositionAtRecord_OUTPUT : CimParams
|
|
{
|
|
public PositionAtRecord_OUTPUT() : base("")
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Required, An identifier for the iterator.
|
|
/// </summary>
|
|
[CimField(false,true)]
|
|
public virtual string IterationIdentifier
|
|
{
|
|
get
|
|
{
|
|
return this.GetField("IterationIdentifier")[0];
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Required, The relative or absolute record number.
|
|
/// </summary>
|
|
[CimField(false,true)]
|
|
public virtual long RecordNumber
|
|
{
|
|
get
|
|
{
|
|
return long.Parse(this["RecordNumber"][0], CultureInfo.InvariantCulture);
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
///Requests that the Log's iteration identifier be advanced or retreated a specific number of records, or set to the entry at a specified numeric location. These two different behaviors are accomplished using the input parameters of the method. Advancing or retreating is achieved by setting the MoveAbsolute boolean to FALSE, and then specifying the number of entries to advance or retreat as positive or negative values in the RecordNumber parameter. Moving to a specific record number is accomplished by setting the MoveAbsolute input parameter to TRUE, and then placing the record number into the RecordNumber parameter. This can only be done if the Capabilities array includes a value of 7, "Supports Addressing by Ordinal Record Number".
|
|
///After the method completes and if ordinal record numbers are supported (the Capabilities array includes a 7), the current record number is returned in the RecordNumber output parameter. Otherwise, the value of the parameter is undefined.
|
|
///IterationIdentifier is defined as an Input/Output method parameter to allow the Log to embed state information in the Identifier and potentially let the identifier be maintained by the using application.
|
|
///Note: In a subclass, the set of possible return codes could be described using a ValueMap qualifier on the method. The strings to which the ValueMap contents are 'translated' may also be specified in the subclass as a Values array qualifier.
|
|
/// </summary>
|
|
/// <param name="inIterationIdentifier">Required, IN -An identifier for the iterator.</param>
|
|
/// <param name="inMoveAbsolute">Required, IN -Advancing or retreating the IterationIdentifier is achieved by setting the MoveAbsolute boolean to FALSE, and specifying the number of entries to advance or retreat as positive or negative values in the RecordNumber parameter. Moving to a specific record number is accomplished by setting the MoveAbsolute parameter to TRUE, and placing the record number into the RecordNumber parameter.</param>
|
|
/// <param name="inRecordNumber">Required, IN -The relative or absolute record number.</param>
|
|
/// <param name="outIterationIdentifier">OUT - An identifier for the iterator.</param>
|
|
/// <param name="outRecordNumber">OUT - The relative or absolute record number.</param>
|
|
/// <returns>
|
|
/// Legal values:
|
|
/// Completed with No Error : 0
|
|
/// Not Supported : 1
|
|
/// Invalid record pointed : 2
|
|
/// </returns>
|
|
public override uint PositionAtRecord(string inIterationIdentifier,bool? inMoveAbsolute,long? inRecordNumber,out string outIterationIdentifier,out long outRecordNumber)
|
|
{
|
|
PositionAtRecord_INPUT input = new PositionAtRecord_INPUT(this.XmlNamespace);
|
|
if (inIterationIdentifier != null)
|
|
input.IterationIdentifier=inIterationIdentifier;
|
|
if (inMoveAbsolute.HasValue)
|
|
input.MoveAbsolute=inMoveAbsolute.Value;
|
|
if (inRecordNumber.HasValue)
|
|
input.RecordNumber=inRecordNumber.Value;
|
|
PositionAtRecord_OUTPUT output = new PositionAtRecord_OUTPUT();
|
|
uint returnValue = base.Invoke("PositionAtRecord",input,out output);
|
|
outIterationIdentifier=null;
|
|
outRecordNumber=0;
|
|
if (returnValue == 0)
|
|
{
|
|
if (output.ContainsField("IterationIdentifier"))
|
|
outIterationIdentifier = output.IterationIdentifier;
|
|
if (output.ContainsField("RecordNumber"))
|
|
outRecordNumber = output.RecordNumber;
|
|
}
|
|
return returnValue;
|
|
}
|
|
/// <summary>
|
|
///Requests that an iteration of the MessageLog be established and that the iterator be set to the first entry in the Log. An identifier for the iterator is returned as an output parameter of the method.
|
|
///Regarding iteration, you have 2 choices: 1) Embed iteration data in the method call, and allow implementations to track/ store this data manually; or, 2) Iterate using a separate object (for example, class ActiveIterator) as an iteration agent. The first approach is used here for interoperability. The second requires an instance of the Iterator object for EACH iteration in progress. 2's functionality could be implemented underneath 1.
|
|
/// </summary>
|
|
[System.SerializableAttribute()]
|
|
[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
|
|
[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_MessageLog", IsNullable=false)]
|
|
private class PositionToFirstRecord_INPUT : CimParams
|
|
{
|
|
public PositionToFirstRecord_INPUT(string ns) : base(ns)
|
|
{
|
|
}
|
|
|
|
}
|
|
/// <summary>
|
|
///Requests that an iteration of the MessageLog be established and that the iterator be set to the first entry in the Log. An identifier for the iterator is returned as an output parameter of the method.
|
|
///Regarding iteration, you have 2 choices: 1) Embed iteration data in the method call, and allow implementations to track/ store this data manually; or, 2) Iterate using a separate object (for example, class ActiveIterator) as an iteration agent. The first approach is used here for interoperability. The second requires an instance of the Iterator object for EACH iteration in progress. 2's functionality could be implemented underneath 1.
|
|
/// </summary>
|
|
[System.SerializableAttribute()]
|
|
[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
|
|
[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_MessageLog", IsNullable=false)]
|
|
private class PositionToFirstRecord_OUTPUT : CimParams
|
|
{
|
|
public PositionToFirstRecord_OUTPUT() : base("")
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional, An identifier for the iterator.
|
|
/// </summary>
|
|
[CimField(false,false)]
|
|
public virtual string IterationIdentifier
|
|
{
|
|
get
|
|
{
|
|
return this.GetField("IterationIdentifier")[0];
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
///Requests that an iteration of the MessageLog be established and that the iterator be set to the first entry in the Log. An identifier for the iterator is returned as an output parameter of the method.
|
|
///Regarding iteration, you have 2 choices: 1) Embed iteration data in the method call, and allow implementations to track/ store this data manually; or, 2) Iterate using a separate object (for example, class ActiveIterator) as an iteration agent. The first approach is used here for interoperability. The second requires an instance of the Iterator object for EACH iteration in progress. 2's functionality could be implemented underneath 1.
|
|
/// </summary>
|
|
/// <param name="outIterationIdentifier">OUT - An identifier for the iterator.</param>
|
|
/// <returns>
|
|
/// Legal values:
|
|
/// Completed with No Error : 0
|
|
/// Not Supported : 1
|
|
/// No record exists : 2
|
|
/// </returns>
|
|
public override uint PositionToFirstRecord(out string outIterationIdentifier)
|
|
{
|
|
PositionToFirstRecord_INPUT input = new PositionToFirstRecord_INPUT(this.XmlNamespace);
|
|
PositionToFirstRecord_OUTPUT output = new PositionToFirstRecord_OUTPUT();
|
|
uint returnValue = base.Invoke("PositionToFirstRecord",input,out output);
|
|
outIterationIdentifier=null;
|
|
if (returnValue == 0)
|
|
{
|
|
if (output.ContainsField("IterationIdentifier"))
|
|
outIterationIdentifier = output.IterationIdentifier;
|
|
}
|
|
return returnValue;
|
|
}
|
|
/// <summary>
|
|
///Requests that the MessageLog be placed in a frozen state ("Freeze" input parameter = TRUE) or 'unfrozen' (= FALSE). If frozen, modifications to the Log will not be allowed. If successful, the Log's IsFrozen boolean property will be updated to reflect the desired state.
|
|
///The method's return code should be 0 if the request was successfully executed, 1 if the request is not supported and some other value if an error occurred. If the request is not supported, check the Capabilities array that a value of 5 ("Freeze Log Supported") is specified.
|
|
///Note: In a subclass, the set of possible return codes could be described using a ValueMap qualifier on the method. The strings to which the ValueMap contents are 'translated' may also be specified in the subclass as a Values array qualifier.
|
|
/// </summary>
|
|
[System.SerializableAttribute()]
|
|
[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
|
|
[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_MessageLog", IsNullable=false)]
|
|
private class FreezeLog_INPUT : CimParams
|
|
{
|
|
public FreezeLog_INPUT(string ns) : base(ns)
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Required, If TRUE then freeze the log, if FALSE 'unfreeze' the log.
|
|
/// </summary>
|
|
[CimField(false,true)]
|
|
public virtual bool Freeze
|
|
{
|
|
set
|
|
{
|
|
this.SetOrAddField("Freeze",value.ToString().ToLower(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
///Requests that the MessageLog be placed in a frozen state ("Freeze" input parameter = TRUE) or 'unfrozen' (= FALSE). If frozen, modifications to the Log will not be allowed. If successful, the Log's IsFrozen boolean property will be updated to reflect the desired state.
|
|
///The method's return code should be 0 if the request was successfully executed, 1 if the request is not supported and some other value if an error occurred. If the request is not supported, check the Capabilities array that a value of 5 ("Freeze Log Supported") is specified.
|
|
///Note: In a subclass, the set of possible return codes could be described using a ValueMap qualifier on the method. The strings to which the ValueMap contents are 'translated' may also be specified in the subclass as a Values array qualifier.
|
|
/// </summary>
|
|
[System.SerializableAttribute()]
|
|
[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
|
|
[System.Xml.Serialization.XmlRootAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_MessageLog", IsNullable=false)]
|
|
private class FreezeLog_OUTPUT : CimParams
|
|
{
|
|
public FreezeLog_OUTPUT() : base("")
|
|
{
|
|
}
|
|
|
|
}
|
|
/// <summary>
|
|
///Requests that the MessageLog be placed in a frozen state ("Freeze" input parameter = TRUE) or 'unfrozen' (= FALSE). If frozen, modifications to the Log will not be allowed. If successful, the Log's IsFrozen boolean property will be updated to reflect the desired state.
|
|
///The method's return code should be 0 if the request was successfully executed, 1 if the request is not supported and some other value if an error occurred. If the request is not supported, check the Capabilities array that a value of 5 ("Freeze Log Supported") is specified.
|
|
///Note: In a subclass, the set of possible return codes could be described using a ValueMap qualifier on the method. The strings to which the ValueMap contents are 'translated' may also be specified in the subclass as a Values array qualifier.
|
|
/// </summary>
|
|
/// <param name="inFreeze">Required, IN -If TRUE then freeze the log, if FALSE 'unfreeze' the log.</param>
|
|
/// <returns>
|
|
/// </returns>
|
|
public override uint FreezeLog(bool? inFreeze)
|
|
{
|
|
FreezeLog_INPUT input = new FreezeLog_INPUT(this.XmlNamespace);
|
|
if (inFreeze.HasValue)
|
|
input.Freeze=inFreeze.Value;
|
|
FreezeLog_OUTPUT output = new FreezeLog_OUTPUT();
|
|
uint returnValue = base.Invoke("FreezeLog",input,out output);
|
|
return returnValue;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Enumerate instances of AMT_MessageLog class at an endpoint.
|
|
/// </summary>
|
|
/// <param name="client">WS-Management client</param>
|
|
/// <param name="cimKeys">Keys for selecting the instances</param>
|
|
/// <returns>Collection of AMT_MessageLog objects</returns>
|
|
public static new Collection<AMT_MessageLog> Enumerate(IWSManClient client, CimBase.CimKeys cimKeys)
|
|
{
|
|
List<AMT_MessageLog> ret = CimBase.Enumerate<AMT_MessageLog>(client, cimKeys);
|
|
return new Collection<AMT_MessageLog>(ret);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Enumerate instances of AMT_MessageLog class at an endpoint.
|
|
/// </summary>
|
|
/// <param name="client">WS-Management client</param>
|
|
/// <returns>Collection of AMT_MessageLog objects</returns>
|
|
public static new Collection<AMT_MessageLog> Enumerate(IWSManClient client)
|
|
{
|
|
List<AMT_MessageLog> ret = CimBase.Enumerate<AMT_MessageLog>(client);
|
|
return new Collection<AMT_MessageLog>(ret);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Delete the instance of AMT_MessageLog if it is singular.
|
|
/// Note: This method will succeed only if a single instance of the class exists.
|
|
/// </summary>
|
|
/// <param name="client">WS-Management client</param>
|
|
public static new void Delete(IWSManClient client)
|
|
{
|
|
CimBase.Delete<AMT_MessageLog>(client);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Represents the keys of the AMT_MessageLog class.
|
|
/// </summary>
|
|
|
|
public new class CimKeys : CIM_MessageLog.CimKeys
|
|
{
|
|
}
|
|
|
|
}
|
|
}
|
|
|