//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2003 - 2012  All Rights Reserved.
//
//  File:       CIM_Memory.cs
//
//  Contents:   Capabilities and management of Memory-related LogicalDevices.
//              This file was automatically generated from CIM_Memory.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>
	///Capabilities and management of Memory-related LogicalDevices.
	/// </summary>
	[System.SerializableAttribute()]
	[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_Memory")]
	[System.Xml.Serialization.XmlRootAttribute("CIM_Memory", Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_Memory", IsNullable=false)]
	public class CIM_Memory : CIM_StorageExtent
	{
		/// <summary>
		/// Default constructor.
		/// </summary>
		public CIM_Memory() :base()
		{
		}
		/// <summary>
		/// Constructor that recieves an xml string for deserialization.
		/// </summary>
		/// <param name="xml">xml string to deserialize</param>
		public CIM_Memory(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 CIM_Memory(IWSManClient client): base(client)
		{
		}
		/// <summary>
		/// Remove AdditionalErrorData field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveAdditionalErrorData()
		{
			RemoveField("AdditionalErrorData");
		}

		/// <summary>
		/// Is true if the field AdditionalErrorData exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool AdditionalErrorDataExist
		{
			get
			{
				return ContainsField("AdditionalErrorData");
			}
		}

		/// <summary>
		/// Optional, An array of octets holding additional error information. An example is ECC Syndrome or the return of the check bits if a CRC-based ErrorMethodology is used. In the latter case, if a single bit error is recognized and the CRC algorithm is known, it is possible to determine the exact bit that failed. This type of data (ECC Syndrome, Check Bit or Parity Bit data, or other vendor supplied information) is included in this field. If the ErrorInfo property is equal to 3, "OK", then AdditionalErrorData has no meaning.
		/// </summary>
		[CimField(false, false)]
		public virtual byte[] AdditionalErrorData
		{
			get
			{
					return Convert.FromBase64String(this.GetField("AdditionalErrorData")[0]);			}
			set
			{
			this.SetOrAddField("AdditionalErrorData",Convert.ToBase64String(value));
			}
		}
		/// <summary>
		/// Remove CorrectableError field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveCorrectableError()
		{
			RemoveField("CorrectableError");
		}

		/// <summary>
		/// Is true if the field CorrectableError exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool CorrectableErrorExist
		{
			get
			{
				return ContainsField("CorrectableError");
			}
		}

		/// <summary>
		/// Optional, Boolean indicating that the most recent error was correctable. If the ErrorInfo property is equal to 3, "OK", then this property has no meaning.
		/// </summary>
		[CimField(false, false)]
		public virtual bool CorrectableError
		{
			get
			{
				return bool.Parse(this["CorrectableError"][0]);
			}
			set
			{
				this.SetOrAddField("CorrectableError",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove EndingAddress field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveEndingAddress()
		{
			RemoveField("EndingAddress");
		}

		/// <summary>
		/// Is true if the field EndingAddress exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool EndingAddressExist
		{
			get
			{
				return ContainsField("EndingAddress");
			}
		}

		/// <summary>
		/// Optional, The ending address, referenced by an application or operating system and mapped by a memory controller, for this Memory object. The ending address is specified in KBytes.
		/// </summary>
		[CimField(false, false)]
		public virtual ulong EndingAddress
		{
			get
			{
					return ulong.Parse(this["EndingAddress"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("EndingAddress",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove ErrorAccess field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveErrorAccess()
		{
			RemoveField("ErrorAccess");
		}

		/// <summary>
		/// Is true if the field ErrorAccess exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool ErrorAccessExist
		{
			get
			{
				return ContainsField("ErrorAccess");
			}
		}

		/// <summary>
		/// Optional, An integer enumeration indicating the memory access operation that caused the last error. The type of error is described by the ErrorInfo property. If the ErrorInfo property is equal to 3, "OK", then this property has no meaning.
		/// </summary>
		[CimField(false, false)]
		public virtual ushort ErrorAccess
		{
			get
			{
					return ushort.Parse(this["ErrorAccess"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("ErrorAccess",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove ErrorAddress field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveErrorAddress()
		{
			RemoveField("ErrorAddress");
		}

		/// <summary>
		/// Is true if the field ErrorAddress exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool ErrorAddressExist
		{
			get
			{
				return ContainsField("ErrorAddress");
			}
		}

		/// <summary>
		/// Optional, Specifies the address of the last memory error. The type of error is described by the ErrorInfo property. If the ErrorInfo property is equal to 3, "OK", then this property has no meaning.
		/// </summary>
		[CimField(false, false)]
		public virtual ulong ErrorAddress
		{
			get
			{
					return ulong.Parse(this["ErrorAddress"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("ErrorAddress",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove ErrorData field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveErrorData()
		{
			RemoveField("ErrorData");
		}

		/// <summary>
		/// Is true if the field ErrorData exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool ErrorDataExist
		{
			get
			{
				return ContainsField("ErrorData");
			}
		}

		/// <summary>
		/// Optional, Data captured during the last erroneous mebmory access. The data occupies the first n octets of the array necessary to hold the number of bits specified by the ErrorTransferSize property. If ErrorTransferSize is 0, then this property has no meaning.
		/// </summary>
		[CimField(false, false)]
		public virtual byte[] ErrorData
		{
			get
			{
					return Convert.FromBase64String(this.GetField("ErrorData")[0]);			}
			set
			{
			this.SetOrAddField("ErrorData",Convert.ToBase64String(value));
			}
		}
		/// <summary>
		/// Remove ErrorDataOrder field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveErrorDataOrder()
		{
			RemoveField("ErrorDataOrder");
		}

		/// <summary>
		/// Is true if the field ErrorDataOrder exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool ErrorDataOrderExist
		{
			get
			{
				return ContainsField("ErrorDataOrder");
			}
		}

		/// <summary>
		/// Optional, The ordering for data stored in the ErrorData property. "Least Significant Byte First" (value=1) or "Most Significant Byte First" (2) can be specified. If ErrorTransferSize is 0, then this property has no meaning.
		/// </summary>
		[CimField(false, false)]
		public virtual ushort ErrorDataOrder
		{
			get
			{
					return ushort.Parse(this["ErrorDataOrder"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("ErrorDataOrder",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove ErrorInfo field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveErrorInfo()
		{
			RemoveField("ErrorInfo");
		}

		/// <summary>
		/// Is true if the field ErrorInfo exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool ErrorInfoExist
		{
			get
			{
				return ContainsField("ErrorInfo");
			}
		}

		/// <summary>
		/// Optional, An integer enumeration describing the type of error that occurred most recently. For example, single (value=6) or double bit errors (7) can be specified using this property. The values, 12-14, are undefined in the CIM Schema since in DMI, they mix the semantics of the type of error and whether it was correctable or not. The latter is indicated in the property, CorrectableError.
		/// </summary>
		[CimField(false, false)]
		public virtual ushort ErrorInfo
		{
			get
			{
					return ushort.Parse(this["ErrorInfo"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("ErrorInfo",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove ErrorMethodology field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public override void RemoveErrorMethodology()
		{
			RemoveField("ErrorMethodology");
		}

		/// <summary>
		/// Is true if the field ErrorMethodology exists in the current object,
		/// otherwise is false.
		/// </summary>
		public override bool ErrorMethodologyExist
		{
			get
			{
				return ContainsField("ErrorMethodology");
			}
		}

		/// <summary>
		/// Optional, ErrorMethodology for Memory is a string property that indicates whether parity or CRC algorithms, ECC or other mechanisms are used. Details on the algorithm can also be supplied.
		/// </summary>
		[CimField(false, false)]
		public override string ErrorMethodology
		{
			get
			{
				return this.GetField("ErrorMethodology")[0];
			}
			set
			{
			this.SetOrAddField("ErrorMethodology",value);
			}
		}
		/// <summary>
		/// Remove ErrorResolution field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveErrorResolution()
		{
			RemoveField("ErrorResolution");
		}

		/// <summary>
		/// Is true if the field ErrorResolution exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool ErrorResolutionExist
		{
			get
			{
				return ContainsField("ErrorResolution");
			}
		}

		/// <summary>
		/// Optional, Specifies the range, in bytes, to which the last error can be resolved. For example, if error addresses are resolved to bit 11 (ie, on a typical page basis), then errors can be resolved to 4K boundaries and this property is set to 4000. If the ErrorInfo property is equal to 3, "OK", then this property has no meaning.
		/// </summary>
		[CimField(false, false)]
		public virtual ulong ErrorResolution
		{
			get
			{
					return ulong.Parse(this["ErrorResolution"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("ErrorResolution",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove ErrorTime field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveErrorTime()
		{
			RemoveField("ErrorTime");
		}

		/// <summary>
		/// Is true if the field ErrorTime exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool ErrorTimeExist
		{
			get
			{
				return ContainsField("ErrorTime");
			}
		}

		/// <summary>
		/// Optional, The time that the last memory error occurred. The type of error is described by the ErrorInfo property. If the Error Info property is equal to 3, "OK", then this property has no meaning.
		/// </summary>
		[CimField(false, false)]
		public virtual CimDateTime ErrorTime
		{
			get
			{
					return CimDateTime.Parse(this["ErrorTime"][0]);
			}
			set
			{
				this.SetOrAddField("ErrorTime",value.ToString());
			}
		}
		/// <summary>
		/// Remove ErrorTransferSize field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveErrorTransferSize()
		{
			RemoveField("ErrorTransferSize");
		}

		/// <summary>
		/// Is true if the field ErrorTransferSize exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool ErrorTransferSizeExist
		{
			get
			{
				return ContainsField("ErrorTransferSize");
			}
		}

		/// <summary>
		/// Optional, The size of the data transfer in bits that caused the last error. 0 indicates no error. If the ErrorInfo property is equal to 3, "OK", then this property should be set to 0.
		/// </summary>
		[CimField(false, false)]
		public virtual uint ErrorTransferSize
		{
			get
			{
					return uint.Parse(this["ErrorTransferSize"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("ErrorTransferSize",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove OtherErrorDescription field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveOtherErrorDescription()
		{
			RemoveField("OtherErrorDescription");
		}

		/// <summary>
		/// Is true if the field OtherErrorDescription exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool OtherErrorDescriptionExist
		{
			get
			{
				return ContainsField("OtherErrorDescription");
			}
		}

		/// <summary>
		/// Optional, Free form string providing more information if the Error Type property is set to 1, "Other". If not set to 1, this string has no meaning.
		/// </summary>
		[CimField(false, false)]
		public virtual string OtherErrorDescription
		{
			get
			{
				return this.GetField("OtherErrorDescription")[0];
			}
			set
			{
			this.SetOrAddField("OtherErrorDescription",value);
			}
		}
		/// <summary>
		/// Remove StartingAddress field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveStartingAddress()
		{
			RemoveField("StartingAddress");
		}

		/// <summary>
		/// Is true if the field StartingAddress exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool StartingAddressExist
		{
			get
			{
				return ContainsField("StartingAddress");
			}
		}

		/// <summary>
		/// Optional, The beginning address, referenced by an application or operating system and mapped by a memory controller, for this Memory object. The starting address is specified in KBytes.
		/// </summary>
		[CimField(false, false)]
		public virtual ulong StartingAddress
		{
			get
			{
					return ulong.Parse(this["StartingAddress"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("StartingAddress",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove SystemLevelAddress field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveSystemLevelAddress()
		{
			RemoveField("SystemLevelAddress");
		}

		/// <summary>
		/// Is true if the field SystemLevelAddress exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool SystemLevelAddressExist
		{
			get
			{
				return ContainsField("SystemLevelAddress");
			}
		}

		/// <summary>
		/// Optional, Boolean indicating whether the address information in the property, ErrorAddress, is a system-level address (TRUE) or a physical address (FALSE). If the ErrorInfo property is equal to 3, "OK", then this property has no meaning.
		/// </summary>
		[CimField(false, false)]
		public virtual bool SystemLevelAddress
		{
			get
			{
				return bool.Parse(this["SystemLevelAddress"][0]);
			}
			set
			{
				this.SetOrAddField("SystemLevelAddress",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove Volatile field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveVolatile()
		{
			RemoveField("Volatile");
		}

		/// <summary>
		/// Is true if the field Volatile exists in the current object,
		/// otherwise is false.
		/// </summary>
		public virtual bool VolatileExist
		{
			get
			{
				return ContainsField("Volatile");
			}
		}

		/// <summary>
		/// Optional, Volatile is a property that indicates whether this memory is volatile or not.
		/// </summary>
		[CimField(false, false)]
		public virtual bool Volatile
		{
			get
			{
				return bool.Parse(this["Volatile"][0]);
			}
			set
			{
				this.SetOrAddField("Volatile",value.ToString().ToLower(CultureInfo.InvariantCulture));
			}
		}

		/// <summary>
		/// Enumerate instances of CIM_Memory class at an endpoint.
		/// </summary>
		/// <param name="client">WS-Management client</param>
		/// <param name="cimKeys">Keys for selecting the instances</param>
		/// <returns>Collection of CIM_Memory objects</returns>
		public static new Collection<CIM_Memory> Enumerate(IWSManClient client, CimBase.CimKeys cimKeys)
		{
			List<CIM_Memory> ret = CimBase.Enumerate<CIM_Memory>(client, cimKeys);
			return new Collection<CIM_Memory>(ret);
		}

		/// <summary>
		/// Enumerate instances of CIM_Memory class at an endpoint.
		/// </summary>
		/// <param name="client">WS-Management client</param>
		/// <returns>Collection of CIM_Memory objects</returns>
		public static new Collection<CIM_Memory> Enumerate(IWSManClient client)
		{
			List<CIM_Memory> ret = CimBase.Enumerate<CIM_Memory>(client);
			return new Collection<CIM_Memory>(ret);
		}


		/// <summary>
		/// Delete the instance of CIM_Memory 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<CIM_Memory>(client);
		}


		/// <summary>
		/// Represents the keys of the CIM_Memory class.
		/// </summary>

		public new class CimKeys : CIM_StorageExtent.CimKeys
		{
		}

	}
}