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

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

		/// <summary>
		/// Optional, Capabilities of the EthernetPort. For example, the Device might support AlertOnLan, WakeOnLan, Load Balancing, or FailOver. If failover or load balancing capabilities are listed, a SpareGroup (failover) or ExtraCapacityGroup (load balancing) should also be defined to completely describe the capability.
		/// </summary>
		[CimField(false, false)]
		public virtual ushort[] Capabilities
		{
			get
			{
					return CimTypesUtils.StringArrayToArray<ushort>(this["Capabilities"]);
			}
			set
			{
				string[] arr = CimTypesUtils.ArrayToStringArray<ushort>(value);
				this.SetOrAddField("Capabilities", arr);
			}
		}
		/// <summary>
		/// Remove CapabilityDescriptions field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveCapabilityDescriptions()
		{
			RemoveField("CapabilityDescriptions");
		}

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

		/// <summary>
		/// Optional, An array of free-form strings that provides more detailed explanations for any of the EthernetPort features that are indicated in the Capabilities array. Note, each entry of this array is related to the entry in the Capabilities array that is located at the same index.
		/// </summary>
		[CimField(false, false)]
		public virtual string[] CapabilityDescriptions
		{
			get
			{
					return CimTypesUtils.StringArrayToArray<string>(this["CapabilityDescriptions"]);
			}
			set
			{
				string[] arr = CimTypesUtils.ArrayToStringArray<string>(value);
				this.SetOrAddField("CapabilityDescriptions", arr);
			}
		}
		/// <summary>
		/// Remove EnabledCapabilities field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveEnabledCapabilities()
		{
			RemoveField("EnabledCapabilities");
		}

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

		/// <summary>
		/// Optional, Specifies which capabilities are enabled from the list of all supported ones, which are defined in the Capabilities array.
		/// </summary>
		[CimField(false, false)]
		public virtual ushort[] EnabledCapabilities
		{
			get
			{
					return CimTypesUtils.StringArrayToArray<ushort>(this["EnabledCapabilities"]);
			}
			set
			{
				string[] arr = CimTypesUtils.ArrayToStringArray<ushort>(value);
				this.SetOrAddField("EnabledCapabilities", arr);
			}
		}
		/// <summary>
		/// Remove MaxDataSize field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveMaxDataSize()
		{
			RemoveField("MaxDataSize");
		}

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

		/// <summary>
		/// Optional, The maximum size of the INFO (non-MAC) field that will be received or transmitted.
		/// </summary>
		[CimField(false, false)]
		public virtual uint MaxDataSize
		{
			get
			{
					return uint.Parse(this["MaxDataSize"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("MaxDataSize",value.ToString(CultureInfo.InvariantCulture));
			}
		}
		/// <summary>
		/// Remove NetworkAddresses field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public override void RemoveNetworkAddresses()
		{
			RemoveField("NetworkAddresses");
		}

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

		/// <summary>
		/// Optional, Ethernet/802.3 MAC addresses formatted as twelve hexadecimal digits (for example, "010203040506"), with each pair representing one of the six octets of the MAC address in "canonical" bit order. (Therefore, the Group address bit is found in the low order bit of the first character of the string.)
		/// </summary>
		[CimField(false, false)]
		public override string[] NetworkAddresses
		{
			get
			{
					return CimTypesUtils.StringArrayToArray<string>(this["NetworkAddresses"]);
			}
			set
			{
				string[] arr = CimTypesUtils.ArrayToStringArray<string>(value);
				this.SetOrAddField("NetworkAddresses", arr);
			}
		}
		/// <summary>
		/// Remove OtherEnabledCapabilities field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public virtual void RemoveOtherEnabledCapabilities()
		{
			RemoveField("OtherEnabledCapabilities");
		}

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

		/// <summary>
		/// Optional, An array of free-form strings that provides more detailed explanations for any of the enabled capabilities that are specified as 'Other'.
		/// </summary>
		[CimField(false, false)]
		public virtual string[] OtherEnabledCapabilities
		{
			get
			{
					return CimTypesUtils.StringArrayToArray<string>(this["OtherEnabledCapabilities"]);
			}
			set
			{
				string[] arr = CimTypesUtils.ArrayToStringArray<string>(value);
				this.SetOrAddField("OtherEnabledCapabilities", arr);
			}
		}
		/// <summary>
		/// Remove PortType field.
		/// Note: This method will succeed only if this field is optional in the concrete object.
		/// </summary>
		public override void RemovePortType()
		{
			RemoveField("PortType");
		}

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

		/// <summary>
		/// Optional, The specific mode that is currently enabled for the Port. When set to 1 ("Other"), the related property OtherPortType contains a string description of the type of port.
		/// </summary>
		[CimField(false, false)]
		public override ushort PortType
		{
			get
			{
					return ushort.Parse(this["PortType"][0], CultureInfo.InvariantCulture);
			}
			set
			{
				this.SetOrAddField("PortType",value.ToString(CultureInfo.InvariantCulture));
			}
		}

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

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


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


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

		public new class CimKeys : CIM_NetworkPort.CimKeys
		{
		}

	}
}