//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2003 - 2012  All Rights Reserved.
//
//  File:       CIM_ComputerSystem.cs
//
//  Contents:   A class derived from System that is a special collection of ManagedSystemElements. This collection is related to the providing of compute capabilities and MAY serve as an aggregation point to associate one or more of the following elements: FileSystem, OperatingSystem, Processor and Memory (Volatile and/or NonVolatile Storage).
//              This file was automatically generated from CIM_ComputerSystem.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>
	///A class derived from System that is a special collection of ManagedSystemElements. This collection is related to the providing of compute capabilities and MAY serve as an aggregation point to associate one or more of the following elements: FileSystem, OperatingSystem, Processor and Memory (Volatile and/or NonVolatile Storage).
	/// </summary>
	[System.SerializableAttribute()]
	[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ComputerSystem")]
	[System.Xml.Serialization.XmlRootAttribute("CIM_ComputerSystem", Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ComputerSystem", IsNullable=false)]
	public class CIM_ComputerSystem : CIM_System
	{
		/// <summary>
		/// Default constructor.
		/// </summary>
		public CIM_ComputerSystem() :base()
		{
		}
		/// <summary>
		/// Constructor that recieves an xml string for deserialization.
		/// </summary>
		/// <param name="xml">xml string to deserialize</param>
		public CIM_ComputerSystem(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_ComputerSystem(IWSManClient client): base(client)
		{
		}
		/// <summary>
		/// Remove Dedicated field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveDedicated()
		{
			RemoveField("Dedicated");
		}

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

		/// <summary>
		/// Optional, Enumeration indicating the purpose(s) to which the ComputerSystem is dedicated, if any, and what functionality is provided. For example, one could specify that the System is dedicated to "Print" (value=11) or acts as a "Hub" (value=8). 
		/// Also, one could indicate that this is a general purpose system by indicating 'Not Dedicated' (value=0) but that it also hosts 'Print' (value=11) or mobile phone 'Mobile User Device' (value=17) services. 
		/// A clarification is needed with respect to the value 17 ("Mobile User Device"). An example of a dedicated user device is a mobile phone or a barcode scanner in a store that communicates via radio frequency. These systems are quite limited in functionality and programmability, and are not considered 'general purpose' computing platforms. Alternately, an example of a mobile system that is 'general purpose' (i.e., is NOT dedicated) is a hand-held computer. Although limited in its programmability, new software can be downloaded and its functionality expanded by the user. 
		/// A value of "Management" indicates this instance is dedicated to hosting system management software.
		/// A value of "Management Controller" indicates this instance represents specialized hardware dedicated to systems management (i.e., a Baseboard Management Controller (BMC) or service processor).
		/// The management scope of a "Management Controller" is typically a single managed system in which it is contained.
		/// A value of "Chassis Manager" indicates this instance represents a system dedicated to management of a blade chassis and its contained devices. This value would be used to represent a Shelf Controller. A "Chassis Manager" is an aggregation point for management and may rely on subordinate management controllers for the management of constituent parts. A value of "Host-based RAID Controller" indicates this instance represents a RAID storage controller contained within a host computer. A value of "Storage Device Enclosure" indicates this instance represents an enclosure that contains storage devices. A "Virtual Tape Library" is the emulation of a tape library by a Virtual Library System. A "Virtual Library System" uses disk storage to emulate tape libraries.A "FC Switch" indicates this instance is dedicated to switching layer 2 fibre channel frames. An "Ethernet Switch" indicates this instance is dedicated to switching layer 2 ethernet frames.
		/// </summary>
		[CimField(false, false)]
		public virtual ushort[] Dedicated
		{
			get
			{
					return CimTypesUtils.StringArrayToArray<ushort>(this["Dedicated"]);
			}
			set
			{
				string[] arr = CimTypesUtils.ArrayToStringArray<ushort>(value);
				this.SetOrAddField("Dedicated", arr);
			}
		}
		/// <summary>
		/// Remove NameFormat field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public override void RemoveNameFormat()
		{
			RemoveField("NameFormat");
		}

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

		/// <summary>
		/// Optional, The ComputerSystem object and its derivatives are Top Level Objects of CIM. They provide the scope for numerous components. Having unique System keys is required. The NameFormat property identifies how the ComputerSystem Name is generated. The NameFormat ValueMap qualifier defines the various mechanisms for assigning the name. Note that another name can be assigned and used for the ComputerSystem that better suit a business, using the inherited ElementName property.
		/// If the NameFormat is set to "UUID", then the Name property shall be a UUID in its canonical form consisting of 32 hexadecimal digits in 5 groups separated by hyphens, in the form 8-4-4-4-12 for a total of 36 characters (32 digits and 4 hyphens). For the first three fields, the most significant digit is on the left. The last two fields are treated as eight separate bytes, each having their most significant digit on the left, and they follow each other from left to right.
		/// </summary>
		[CimField(false, false)]
		public override string NameFormat
		{
			get
			{
				return this.GetField("NameFormat")[0];
			}
			set
			{
			this.SetOrAddField("NameFormat",value);
			}
		}
		/// <summary>
		/// Remove OtherDedicatedDescriptions field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveOtherDedicatedDescriptions()
		{
			RemoveField("OtherDedicatedDescriptions");
		}

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

		/// <summary>
		/// Optional, A string describing how or why the system is dedicated when the Dedicated array includes the value 2, "Other".
		/// </summary>
		[CimField(false, false)]
		public virtual string[] OtherDedicatedDescriptions
		{
			get
			{
					return CimTypesUtils.StringArrayToArray<string>(this["OtherDedicatedDescriptions"]);
			}
			set
			{
				string[] arr = CimTypesUtils.ArrayToStringArray<string>(value);
				this.SetOrAddField("OtherDedicatedDescriptions", arr);
			}
		}
		/// <summary>
		/// Remove PowerManagementCapabilities field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemovePowerManagementCapabilities()
		{
			RemoveField("PowerManagementCapabilities");
		}

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

		/// <summary>
		/// Optional, An enumerated array describing the power management capabilities of the ComputerSystem. The use of this property has been deprecated. Instead, the Power Capabilites property in an associated PowerManagement Capabilities class should be used.
		/// </summary>
		[CimField(false, false)]
		public virtual ushort[] PowerManagementCapabilities
		{
			get
			{
					return CimTypesUtils.StringArrayToArray<ushort>(this["PowerManagementCapabilities"]);
			}
			set
			{
				string[] arr = CimTypesUtils.ArrayToStringArray<ushort>(value);
				this.SetOrAddField("PowerManagementCapabilities", arr);
			}
		}
		/// <summary>
		/// Remove ResetCapability field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveResetCapability()
		{
			RemoveField("ResetCapability");
		}

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

		/// <summary>
		/// Optional, If enabled (value = 4), the ComputerSystem can be reset via hardware (e.g. the power and reset buttons). If disabled (value = 3), hardware reset is not allowed. In addition to Enabled and Disabled, other Values for the property are also defined - "Not Implemented" (5), "Other" (1) and "Unknown" (2).
		/// </summary>
		[CimField(false, false)]
		public virtual ushort ResetCapability
		{
			get
			{
					return ushort.Parse(this["ResetCapability"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("ResetCapability",value.ToString(CultureInfo.InvariantCulture));
			}
		}

		/// <summary>
		/// Enumerate instances of CIM_ComputerSystem 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_ComputerSystem objects</returns>
		public static new Collection<CIM_ComputerSystem> Enumerate(IWSManClient client, CimBase.CimKeys cimKeys)
		{
			List<CIM_ComputerSystem> ret = CimBase.Enumerate<CIM_ComputerSystem>(client, cimKeys);
			return new Collection<CIM_ComputerSystem>(ret);
		}

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


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


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

		public new class CimKeys : CIM_System.CimKeys
		{
		}

	}
}