//----------------------------------------------------------------------------
//
// Copyright (c) Intel Corporation, 2003 - 2012  All Rights Reserved.
//
//  File:       CIM_ConcreteDependency.cs
//
//  Contents:   CIM_ConcreteDependency is a generic association used to establish dependency relationships between ManagedElements. It is defined as a concrete subclass of the abstract CIM_Dependency class, to be used in place of many specific subclasses of Dependency that add no semantics, that is subclasses that do not clarify the type of dependency, update cardinalities, or add or remove qualifiers. Note that when you define additional semantics for Dependency, this class must not be subclassed. Specific semantics continue to be defined as subclasses of the abstract CIM_Dependency. ConcreteDependency is limited in its use as a concrete form of a general dependency. 
//              
//              It was deemed more prudent to create this concrete subclass than to change Dependency from an abstract to a concrete class. Dependency already had multiple abstract subclasses in the CIM Schema, and wider industry usage and impact could not be anticipated.
//              This file was automatically generated from CIM_ConcreteDependency.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_ConcreteDependency is a generic association used to establish dependency relationships between ManagedElements. It is defined as a concrete subclass of the abstract CIM_Dependency class, to be used in place of many specific subclasses of Dependency that add no semantics, that is subclasses that do not clarify the type of dependency, update cardinalities, or add or remove qualifiers. Note that when you define additional semantics for Dependency, this class must not be subclassed. Specific semantics continue to be defined as subclasses of the abstract CIM_Dependency. ConcreteDependency is limited in its use as a concrete form of a general dependency. 
	///It was deemed more prudent to create this concrete subclass than to change Dependency from an abstract to a concrete class. Dependency already had multiple abstract subclasses in the CIM Schema, and wider industry usage and impact could not be anticipated.
	/// </summary>
	[System.SerializableAttribute()]
	[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ConcreteDependency")]
	[System.Xml.Serialization.XmlRootAttribute("CIM_ConcreteDependency", Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ConcreteDependency", IsNullable=false)]
	public class CIM_ConcreteDependency : CIM_Dependency
	{
		/// <summary>
		/// Default constructor.
		/// </summary>
		public CIM_ConcreteDependency() :base()
		{
		}
		/// <summary>
		/// Constructor that recieves an xml string for deserialization.
		/// </summary>
		/// <param name="xml">xml string to deserialize</param>
		public CIM_ConcreteDependency(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_ConcreteDependency(IWSManClient client): base(client)
		{
		}


		/// <summary>
		/// Required, Antecedent represents the independent object in this association.
		/// </summary>
		[CimField(true, false)]
		public override CimReference Antecedent
		{
			get
			{
				string innerXML = this.GetField("Antecedent")[0];
				CimReference epr = new CimReference("Antecedent", XmlNamespace, innerXML);
				return epr;
			}
			set
			{
				this.SetOrAddField("Antecedent",value.Serialize(false));
			}
		}


		/// <summary>
		/// Required, Dependent represents the object that is dependent on the Antecedent.
		/// </summary>
		[CimField(true, false)]
		public override CimReference Dependent
		{
			get
			{
				string innerXML = this.GetField("Dependent")[0];
				CimReference epr = new CimReference("Dependent", XmlNamespace, innerXML);
				return epr;
			}
			set
			{
				this.SetOrAddField("Dependent",value.Serialize(false));
			}
		}

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

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


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


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

		public new class CimKeys : CIM_Dependency.CimKeys
		{
			/// <summary>
			/// Required, Antecedent represents the independent object in this association.
			/// </summary>

			public virtual CimReference Antecedent
			{
				get
				{
					string innerXML = GetKey("Antecedent");
					CimReference epr = new CimReference("Antecedent", "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ConcreteDependency", innerXML);
					return epr;
				}
				set
				{
					SetOrAddKey("Antecedent", value);
				}
			}
			/// <summary>
			/// Required, Dependent represents the object that is dependent on the Antecedent.
			/// </summary>

			public virtual CimReference Dependent
			{
				get
				{
					string innerXML = GetKey("Dependent");
					CimReference epr = new CimReference("Dependent", "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ConcreteDependency", innerXML);
					return epr;
				}
				set
				{
					SetOrAddKey("Dependent", value);
				}
			}
		}

	}
}