//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2003 - 2012  All Rights Reserved.
//
//  File:       CIM_System.cs
//
//  Contents:   CIM_System represents an entity made up of component parts (defined by the SystemComponent relationship), that operates as a 'functional whole'. Systems are top-level objects in the CIM hierarchy, requiring no scoping or weak relationships in order to exist and have context. It should be reasonable to uniquely name and manage a System at an enterprise level. For example, a ComputerSystem is a kind of System that can be uniquely named and independently managed in an enterprise. However, these qualities are not true for the power supply (or the power supply sub-'system') within the computer. 
//              
//              Although a System can be viewed as a Collection, this view is not the correct model. A Collection is simply a 'bag' that 'holds' its members. A System is a higher-level abstraction, built out of its individual components. It is more than the sum of its parts. Note that System is a subclass of EnabledLogicalElement which allows the entire abstraction to be functionally enabled or disabled at a higher level than enabling or disabling its component parts.
//              This file was automatically generated from CIM_System.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>
	///CIM_System represents an entity made up of component parts (defined by the SystemComponent relationship), that operates as a 'functional whole'. Systems are top-level objects in the CIM hierarchy, requiring no scoping or weak relationships in order to exist and have context. It should be reasonable to uniquely name and manage a System at an enterprise level. For example, a ComputerSystem is a kind of System that can be uniquely named and independently managed in an enterprise. However, these qualities are not true for the power supply (or the power supply sub-'system') within the computer. 
	///Although a System can be viewed as a Collection, this view is not the correct model. A Collection is simply a 'bag' that 'holds' its members. A System is a higher-level abstraction, built out of its individual components. It is more than the sum of its parts. Note that System is a subclass of EnabledLogicalElement which allows the entire abstraction to be functionally enabled or disabled at a higher level than enabling or disabling its component parts.
	/// </summary>
	[System.SerializableAttribute()]
	[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_System")]
	[System.Xml.Serialization.XmlRootAttribute("CIM_System", Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_System", IsNullable=false)]
	public class CIM_System : CIM_EnabledLogicalElement
	{
		/// <summary>
		/// Default constructor.
		/// </summary>
		public CIM_System() :base()
		{
		}
		/// <summary>
		/// Constructor that recieves an xml string for deserialization.
		/// </summary>
		/// <param name="xml">xml string to deserialize</param>
		public CIM_System(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_System(IWSManClient client): base(client)
		{
		}


		/// <summary>
		/// Key, Required, CreationClassName indicates the name of the class or the subclass used in the creation of an instance. When used with the other key properties of this class, this property allows all instances of this class and its subclasses to be uniquely identified.
		/// </summary>
		[CimField(true, true)]
		public virtual string CreationClassName
		{
			get
			{
				return this.GetField("CreationClassName")[0];
			}
			set
			{
			this.SetOrAddField("CreationClassName",value);
			}
		}
		/// <summary>
		/// Remove IdentifyingDescriptions field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveIdentifyingDescriptions()
		{
			RemoveField("IdentifyingDescriptions");
		}

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

		/// <summary>
		/// Optional, An array of free-form strings providing explanations and details behind the entries in the OtherIdentifying Info array. Note, each entry of this array is related to the entry in OtherIdentifyingInfo that is located at the same index.
		/// </summary>
		[CimField(false, false)]
		public virtual string[] IdentifyingDescriptions
		{
			get
			{
					return CimTypesUtils.StringArrayToArray<string>(this["IdentifyingDescriptions"]);
			}
			set
			{
				string[] arr = CimTypesUtils.ArrayToStringArray<string>(value);
				this.SetOrAddField("IdentifyingDescriptions", arr);
			}
		}


		/// <summary>
		/// Key, Required, The inherited Name serves as the key of a System instance in an enterprise environment.
		/// </summary>
		[CimField(true, true)]
		public override string Name
		{
			get
			{
				return this.GetField("Name")[0];
			}
			set
			{
			this.SetOrAddField("Name",value);
			}
		}
		/// <summary>
		/// Remove NameFormat field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveNameFormat()
		{
			RemoveField("NameFormat");
		}

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

		/// <summary>
		/// Optional, The System object and its derivatives are top-level objects of CIM. They provide the scope for numerous components. Having unique System keys is required. A heuristic can be defined in individual System subclasses to attempt to always generate the same System Name Key. The NameFormat property identifies how the System name was generated, using the heuristic of the subclass.
		/// </summary>
		[CimField(false, false)]
		public virtual string NameFormat
		{
			get
			{
				return this.GetField("NameFormat")[0];
			}
			set
			{
			this.SetOrAddField("NameFormat",value);
			}
		}
		/// <summary>
		/// Remove OtherIdentifyingInfo field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveOtherIdentifyingInfo()
		{
			RemoveField("OtherIdentifyingInfo");
		}

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

		/// <summary>
		/// Optional, OtherIdentifyingInfo captures additional data, beyond System Name information, that could be used to identify a ComputerSystem. One example would be to hold the Fibre Channel World-Wide Name (WWN) of a node. Note that if only the Fibre Channel name is available and is unique (able to be used as the System key), then this property would be NULL and the WWN would become the System key, its data placed in the Name property.
		/// </summary>
		[CimField(false, false)]
		public virtual string[] OtherIdentifyingInfo
		{
			get
			{
					return CimTypesUtils.StringArrayToArray<string>(this["OtherIdentifyingInfo"]);
			}
			set
			{
				string[] arr = CimTypesUtils.ArrayToStringArray<string>(value);
				this.SetOrAddField("OtherIdentifyingInfo", arr);
			}
		}
		/// <summary>
		/// Remove PrimaryOwnerContact field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemovePrimaryOwnerContact()
		{
			RemoveField("PrimaryOwnerContact");
		}

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

		/// <summary>
		/// Optional, A string that provides information on how the primary system owner can be reached (for example, phone number, e-mail address, and so on).
		/// </summary>
		[CimField(false, false)]
		public virtual string PrimaryOwnerContact
		{
			get
			{
				return this.GetField("PrimaryOwnerContact")[0];
			}
			set
			{
			this.SetOrAddField("PrimaryOwnerContact",value);
			}
		}
		/// <summary>
		/// Remove PrimaryOwnerName field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemovePrimaryOwnerName()
		{
			RemoveField("PrimaryOwnerName");
		}

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

		/// <summary>
		/// Optional, The name of the primary system owner. The system owner is the primary user of the system.
		/// </summary>
		[CimField(false, false)]
		public virtual string PrimaryOwnerName
		{
			get
			{
				return this.GetField("PrimaryOwnerName")[0];
			}
			set
			{
			this.SetOrAddField("PrimaryOwnerName",value);
			}
		}
		/// <summary>
		/// Remove Roles field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveRoles()
		{
			RemoveField("Roles");
		}

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

		/// <summary>
		/// Optional, An array (bag) of strings that specifies the administrator -defined roles this System plays in the managed environment. Examples might be 'Building 8 print server' or 'Boise user directories'. A single system may perform multiple roles. 
		/// Note that the instrumentation view of the 'roles' of a System is defined by instantiating a specific subclass of System, or by properties in a subclass, or both. For example, the purpose of a ComputerSystem is defined using the Dedicated and OtherDedicatedDescription properties.
		/// </summary>
		[CimField(false, false)]
		public virtual string[] Roles
		{
			get
			{
					return CimTypesUtils.StringArrayToArray<string>(this["Roles"]);
			}
			set
			{
				string[] arr = CimTypesUtils.ArrayToStringArray<string>(value);
				this.SetOrAddField("Roles", arr);
			}
		}

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

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


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


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

		public new class CimKeys : CIM_EnabledLogicalElement.CimKeys
		{
			/// <summary>
			/// Key, Required, CreationClassName indicates the name of the class or the subclass used in the creation of an instance. When used with the other key properties of this class, this property allows all instances of this class and its subclasses to be uniquely identified.
			/// </summary>

			public virtual string CreationClassName
			{
				get
				{
					return GetKey("CreationClassName");
				}
				set
				{
					SetOrAddKey("CreationClassName", value);
				}
			}
			/// <summary>
			/// Key, Required, The inherited Name serves as the key of a System instance in an enterprise environment.
			/// </summary>

			public virtual string Name
			{
				get
				{
					return GetKey("Name");
				}
				set
				{
					SetOrAddKey("Name", value);
				}
			}
		}

	}
}