/// <summary>
/// Gets a deep copy of a specified object and copies referenced files
/// Deep copying copies all primitive and enumeration properties and the properties for which MetaInfo "ObjectCopy" is set to true
/// </summary>
/// <param name="source">The object to be copied</param>
/// <param name="path">The path in which copied files will be positioned (relative to original position)</param>
/// <returns>The copied object</returns>
public static object GetCopy(object source, string path)
{
if (source == null)
{
return(null);
}
if (source is FileSystemInfo)
{
if ((path != null) && (!path.Trim().Equals("")))
{
return(CopyFile((FileSystemInfo)source, path));
}
else
{
return(ObjectSupport.GetInstance(source.GetType(), source.ToString()));
}
}
object copy = ObjectSupport.GetInstance(source.GetType(), source.ToString());
if (copy != null)
{
ObjectSupport.Copy(source, copy, path);
}
return(copy);
}
/// <summary>
/// Gets a deep copy of a specified object.
/// Deep copying copies all primitive and enumeration properties and the properties for which MetaInfo "ObjectCopy" is set to true
/// </summary>
/// <param name="source">The object to be copied</param>
/// <returns>The copied object</returns>
public static object GetCopy(object source)
{
object copy = ObjectSupport.GetInstance(source.GetType());
if (copy != null)
{
ObjectSupport.Copy(source, copy);
}
return(copy);
}
/// <summary>
/// Creates an object which is a deep copy fo a source object, including copying of referenced file
/// Deep copying copies all primitive and enumeration properties and the properties for which MetaInfo "ObjectCopy" is set to true
/// </summary>
/// <param name="source">The object to be copied</param>
/// <param name="copiedObjects">Lookup table for already copied objects</param>
/// <param name="path">Path where files are copied to</param>
/// <returns></returns>
private static object GetCopy(object source, Hashtable copiedObjects, string path)
{
if (copiedObjects[source] != null)
{
return(copiedObjects[source]);
}
else if (source is FileSystemInfo)
{
object copiedFile = CopyFile((FileSystemInfo)source, path);
copiedObjects.Add(source, copiedFile);
return(copiedFile);
}
else
{
object copy = ObjectSupport.GetInstance(source.GetType());
if (copy != null)
{
copiedObjects.Add(source, copy);
ObjectSupport.Copy(source, copy, copiedObjects, path);
}
return(copy);
}
}
/// <summary>
/// Creates a new object using a base value (e.g. a string with its value).
/// Normally primitives, enumerations and some value types can be instantiated this way.
/// Also types with constructors having one argument can be instantiated.
/// </summary>
/// <param name="type">Class type of the object to be instantiated</param>
/// <param name="baseValue">Value which is passed as argument to the constructor</param>
/// <returns>New object, null if not possible</returns>
public static object GetInstance(Type type, object baseValue)
{
return(ObjectSupport.GetInstance(type, baseValue, null));
}
/// <summary>
/// Creates a new object using a base value (e.g. a string with its value).
/// Normally primitives, enumerations and some value types can be instantiated this way.
/// Also types with constructors having one argument can be instantiated.
/// </summary>
/// <param name="classType">Full class name of the object to be instantiated</param>
/// <param name="baseValue">Value which is passed as argument to the constructor</param>
/// <returns>New object, null if not possible</returns>
public static object GetInstance(string classType, object baseValue)
{
return(ObjectSupport.GetInstance(ObjectSupport.GetType(classType), baseValue, null));
}
/// <summary>
/// Creates a new object.
/// Types with an argumentless constructor can be created this way
/// </summary>
/// <param name="classType">Full class name of the object to be instantiated</param>
/// <returns>New object, null if not possible</returns>
public static object GetInstance(string classType)
{
return(ObjectSupport.GetInstance(ObjectSupport.GetType(classType)));
}
/// <summary>
/// Gets the deep copy
/// </summary>
/// <param name="source">The object to be copied</param>
/// <param name="target">The object which will be the copy</param>
/// <param name="copiedObjects">Collection of objects and their copied equivalents. Will be populated and queried during copy.</param>
/// <param name="path">Relative path to location where files will be copied to</param>
/// <param name="copyValue">Indicates whether the new object should refer to a copy or to the same object</param>
private static void Copy(object source, object target, Hashtable copiedObjects, string path, bool copyValue)
{
if (source is IList)
{
IList copiedArray = (IList)target;
copiedArray.Clear();
for (int j = 0; j < ((IList)source).Count; j++)
{
object copiedArrayValue = ((IList)source)[j];
if (copyValue)
{
copiedArrayValue = ObjectSupport.GetCopy(copiedArrayValue, copiedObjects, path);
}
copiedArray.Add(copiedArrayValue);
}
}
else if (source is IDictionary)
{
IDictionary copiedArray = (IDictionary)target;
copiedArray.Clear();
IDictionaryEnumerator dictionaryEnumerator = ((IDictionary)source).GetEnumerator();
while (dictionaryEnumerator.MoveNext())
{
object copiedArrayKey = dictionaryEnumerator.Key;
object copiedArrayValue = dictionaryEnumerator.Value;
if (copyValue)
{
copiedArrayKey = ObjectSupport.GetCopy(copiedArrayKey, copiedObjects, path);
copiedArrayValue = ObjectSupport.GetCopy(copiedArrayValue, copiedObjects, path);
}
if (!copiedArray.Contains(copiedArrayKey))
{
copiedArray.Add(copiedArrayKey, copiedArrayValue);
}
}
}
// Special handling for files
else if (source is FileSystemInfo)
{
if (copyValue && (path != null) && (!path.Trim().Equals("")))
{
object copiedValue = CopyFile((FileSystemInfo)source, path);
}
}
else
{
PropertyInfo[] property = source.GetType().GetProperties();
for (int i = 0; i < property.Length; i++)
{
object sourceValue = property[i].GetValue(source, null);
if (sourceValue != null)
{
// Default copied value. This is just a reference to the original value
object copiedValue = sourceValue;
// If the value has been copied before, use the same copied equivalent
if (copiedObjects.ContainsKey(sourceValue))
{
copiedValue = copiedObjects[sourceValue];
}
else
{
// Determine whether the property is to be copied
bool copyPropertyValue = (Boolean)MetaInfo.GetAttributeDefault(source.GetType(), property[i].Name, "ObjectCopy", false);
if (copyPropertyValue)
{
if (property[i].CanWrite)
{
copiedValue = ObjectSupport.GetCopy(sourceValue, copiedObjects, path);
}
else
{
object targetValue = property[i].GetValue(target, null);
Copy(sourceValue, targetValue, copiedObjects, path);
}
}
else if ((sourceValue is IList) || (sourceValue is IDictionary))
{
object targetValue = property[i].GetValue(target, null);
Copy(sourceValue, targetValue, copiedObjects, path, copyPropertyValue);
}
}
// Populate the target object
if (property[i].CanWrite)
{
property[i].SetValue(target, copiedValue, null);
}
if (!copiedObjects.Contains(sourceValue))
{
copiedObjects.Add(sourceValue, copiedValue);
}
}
}
}
}
/// <summary>
/// Deep copies all properties of source into the properties of target, including files
/// Deep copying copies all primitive and enumeration properties and the properties for which MetaInfo "ObjectCopy" is set to true
/// </summary>
/// <param name="source">The source object</param>
/// <param name="target">The target object</param>
/// <param name="path">Path where files are copied to</param>
public static void Copy(object source, object target, string path)
{
ObjectSupport.Copy(source, target, new Hashtable(), path);
}
/// <summary>
/// Deep copies all properties of source into the properties of target
/// Deep copying copies all primitive and enumeration properties and the properties for which MetaInfo "ObjectCopy" is set to true
/// </summary>
/// <param name="source">The source object</param>
/// <param name="target">The target object</param>
public static void Copy(object source, object target)
{
ObjectSupport.Copy(source, target, "");
}