jungerl /lib/otp.net/Otp/Erlang/CloneObject.cs

Language C# Lines 113
MD5 Hash e35def62878801c510bf3a31d05e52f0 Estimated Cost $1,581 (why?)
Repository https://github.com/gebi/jungerl.git View Raw File View Project SPDX
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
using System;
using System.Reflection;
using System.Collections;

namespace Amir_Harel.Cloning
{
	/// <summary>
	/// <b>BaseObject</b> class is an abstract class for you to derive from. <br>
	/// Every class that will be dirived from this class will support the <b>Clone</b> method automaticly.<br>
	/// The class implements the interface <i>ICloneable</i> and there for every object that will be derived <br>
	/// from this object will support the <i>ICloneable</i> interface as well.
	/// </summary>
	public abstract class BaseObject : ICloneable
	{
		/// <summary>
		/// Clone the object, and returning a reference to a cloned object.
		/// </summary>
		/// <returns>Reference to the new cloned object.</returns>
		public object Clone()
		{	
			//First we create an instance of this specific type.
			object newObject  = Activator.CreateInstance( this.GetType() );

			//We get the array of fields for the new type instance.
			FieldInfo[] fields = newObject.GetType().GetFields();

			int i = 0;
			
			foreach( FieldInfo fi in this.GetType().GetFields() )
			{				
				//We query if the fiels support the ICloneable interface.
				Type ICloneType = fi.FieldType.GetInterface( "ICloneable" , true );

				if( ICloneType != null )
				{
					//Getting the ICloneable interface from the object.
					ICloneable IClone = (ICloneable)fi.GetValue(this);

					//We use the clone method to set the new value to the field.
					fields[i].SetValue( newObject , IClone.Clone() );
				}
				else
				{
					//If the field doesn't support the ICloneable interface then just set it.
					fields[i].SetValue( newObject , fi.GetValue(this) );
				}

				//Now we check if the object support the IEnumerable interface, so if it does
				//we need to enumerate all its items and check if they support the ICloneable interface.
				Type IEnumerableType = fi.FieldType.GetInterface( "IEnumerable" , true );
				if( IEnumerableType != null )
				{
					//Get the IEnumerable interface from the field.
					IEnumerable IEnum = (IEnumerable)fi.GetValue(this);

					//This version support the IList and the IDictionary interfaces to iterate
					//on collections.
					Type IListType = fields[i].FieldType.GetInterface( "IList" , true );
					Type IDicType = fields[i].FieldType.GetInterface( "IDictionary" , true );

					int j = 0;
					if( IListType != null )
					{
						//Getting the IList interface.
						IList list = (IList)fields[i].GetValue(newObject);
						
						foreach( object obj in IEnum )
						{
							//Checking to see if the current item support the ICloneable interface.
							ICloneType = obj.GetType().GetInterface( "ICloneable" , true );

							if( ICloneType != null )
							{	
								//If it does support the ICloneable interface, we use it to set the clone of
								//the object in the list.
								ICloneable clone = (ICloneable)obj;

								list[j] = clone.Clone();								
							}
							
							//NOTE: If the item in the list is not support the ICloneable interface then
							// in the cloned list this item will be the same item as in the original list
							//(as long as this type is a reference type).

							j++;
						}
					}
					else if( IDicType != null )
					{
						//Getting the dictionary interface.
						IDictionary dic = (IDictionary)fields[i].GetValue(newObject);
						j = 0;
						foreach( DictionaryEntry de in IEnum )
						{
							//Checking to see if the item support the ICloneable interface.
							ICloneType = de.Value.GetType().GetInterface( "ICloneable" , true );

							if( ICloneType != null )
							{
								ICloneable clone = (ICloneable)de.Value;

								dic[de.Key] = clone.Clone();								
							}
							j++;
						}
					}
				}
				i++;			
			}
			return newObject;
		}
	}
}
Back to Top