#region CPL License
/*
Nuclex Framework
Copyright (C) 2002-2010 Nuclex Development Labs
This library is free software; you can redistribute it and/or
modify it under the terms of the IBM Common Public License as
published by the IBM Corporation; either version 1.0 of the
License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
IBM Common Public License for more details.
You should have received a copy of the IBM Common Public
License along with this library
*/
#endregion
#if !(XBOX360 || WINDOWS_PHONE)
using System;
using System.Collections.Concurrent;
using System.Reflection;
using System.Linq.Expressions;
using System.Collections.Generic;
namespace Nuclex.Support.Cloning {
/// An action that takes its arguments as references to a structure
/// Type of the first argument to the method
/// Type of the second argument to the method
/// First argument to the method
/// Second argument to the method
public delegate void ReferenceAction(ref TFirst first, ref TSecond second)
where TFirst : struct
where TSecond : struct;
///
/// Cloning factory which uses expression trees to improve performance when cloning
/// is a high-frequency action.
///
public class ExpressionTreeCloner : ICloneFactory {
/// Initializes the static members of the expression tree cloner
static ExpressionTreeCloner() {
shallowCloners = new ConcurrentDictionary();
deepCloners = new ConcurrentDictionary();
}
///
/// Creates a deep clone of the specified object, also creating clones of all
/// child objects being referenced
///
/// Type of the object that will be cloned
/// Object that will be cloned
///
/// Whether to clone the object based on its properties only
///
/// A deep clone of the provided object
public static TCloned DeepClone(
TCloned objectToClone, bool usePropertyBasedClone
) {
if(usePropertyBasedClone) {
throw new NotImplementedException("Not implemented yet");
} else {
Func cloner = getOrCreateDeepFieldBasedCloner();
return cloner(objectToClone);
}
}
///
/// Creates a shallow clone of the specified object, reusing any referenced objects
///
/// Type of the object that will be cloned
/// Object that will be cloned
///
/// Whether to clone the object based on its properties only
///
/// A shallow clone of the provided object
public static TCloned ShallowClone(
TCloned objectToClone, bool usePropertyBasedClone
) {
throw new NotImplementedException("Not implemented yet");
}
///
/// Creates a deep clone of the specified object, also creating clones of all
/// child objects being referenced
///
/// Type of the object that will be cloned
/// Object that will be cloned
///
/// Whether to clone the object based on its properties only
///
/// A deep clone of the provided object
TCloned ICloneFactory.DeepClone(
TCloned objectToClone, bool usePropertyBasedClone
) {
return ExpressionTreeCloner.DeepClone(objectToClone, usePropertyBasedClone);
}
///
/// Creates a shallow clone of the specified object, reusing any referenced objects
///
/// Type of the object that will be cloned
/// Object that will be cloned
///
/// Whether to clone the object based on its properties only
///
/// A shallow clone of the provided object
TCloned ICloneFactory.ShallowClone(
TCloned objectToClone, bool usePropertyBasedClone
) {
return ExpressionTreeCloner.ShallowClone(objectToClone, usePropertyBasedClone);
}
///
/// Retrieves the existing clone method for the specified type or compiles one if
/// none exists for the type yet
///
/// Type for which a clone method will be retrieved
/// The clone method for the specified type
private static Func getOrCreateDeepFieldBasedCloner() {
Type clonedType = typeof(TCloned);
Delegate clonerAsDelegate;
if(deepCloners.TryGetValue(clonedType, out clonerAsDelegate)) {
return (Func)clonerAsDelegate;
} else {
Func cloner = createDeepFieldBasedCloner();
deepCloners.TryAdd(clonedType, cloner);
return cloner;
}
}
///
/// Generates state transfer expressions to copy an array of primitive types
///
/// Type of array that will be cloned
/// Variable expression for the original array
/// Receives variables used by the transfer expressions
/// Receives the generated transfer expressions
private static void generatePrimitiveArrayTransferExpressions(
Type clonedType,
ParameterExpression original,
ICollection variables,
ICollection transferExpressions
) {
// We need a temporary variable because the IfThen expression is not suitable
// for returning values
ParameterExpression clone = Expression.Variable(clonedType, "clone");
variables.Add(clone);
// If the array referenced by 'original' is not null, call Array.Clone() on it
// and assign the result to our temporary variable
MethodInfo arrayCloneMethodInfo = typeof(Array).GetMethod("Clone");
transferExpressions.Add(
Expression.IfThen(
Expression.NotEqual(original, Expression.Constant(null)),
Expression.Assign(
clone,
Expression.Convert(
Expression.Call(original, arrayCloneMethodInfo),
clonedType
)
)
)
);
// Set the return value to the temporary variable
transferExpressions.Add(clone);
}
///
/// Generates state transfer expressions to copy an array of complex types
///
/// Type of array that will be cloned
/// Variable expression for the original array
/// Receives variables used by the transfer expressions
/// Receives the generated transfer expressions
private static void generateComplexArrayTransferExpressions(
Type clonedType,
ParameterExpression original,
IList variables,
ICollection transferExpressions
) {
// We need a temporary variable because the IfThen expression is not suitable
// for returning values
ParameterExpression clone = Expression.Variable(clonedType, "clone");
variables.Add(clone);
int dimensionCount = clonedType.GetArrayRank();
int baseVariableIndex = variables.Count;
var arrayTransferExpressions = new List();
Type elementType = clonedType.GetElementType();
// Retrieve the length of each of the array's dimensions
MethodInfo arrayGetLengthMethodInfo = typeof(Array).GetMethod("GetLength");
for(int index = 0; index < dimensionCount; ++index) {
ParameterExpression length = Expression.Variable(typeof(int));
variables.Add(length);
arrayTransferExpressions.Add(
Expression.Assign(
length,
Expression.Call(original, arrayGetLengthMethodInfo, Expression.Constant(index))
)
);
}
// Create a new array of identical size
switch(dimensionCount) {
case 1: {
MethodInfo arrayCreateInstanceMethodInfo = typeof(Array).GetMethod(
"CreateInstance", new Type[] { typeof(Type), typeof(int) }
);
arrayTransferExpressions.Add(
Expression.Assign(
clone,
Expression.Convert(
Expression.Call(
arrayCreateInstanceMethodInfo,
Expression.Constant(elementType),
variables[baseVariableIndex]
),
clonedType
)
)
);
break;
}
case 2: {
MethodInfo arrayCreateInstanceMethodInfo = typeof(Array).GetMethod(
"CreateInstance", new Type[] { typeof(Type), typeof(int), typeof(int) }
);
arrayTransferExpressions.Add(
Expression.Assign(
clone,
Expression.Convert(
Expression.Call(
arrayCreateInstanceMethodInfo,
Expression.Constant(elementType),
variables[baseVariableIndex],
variables[baseVariableIndex + 1]
),
clonedType
)
)
);
break;
}
case 3: {
MethodInfo arrayCreateInstanceMethodInfo = typeof(Array).GetMethod(
"CreateInstance", new Type[] { typeof(Type), typeof(int), typeof(int), typeof(int) }
);
arrayTransferExpressions.Add(
Expression.Assign(
clone,
Expression.Convert(
Expression.Call(
arrayCreateInstanceMethodInfo,
Expression.Constant(elementType),
variables[baseVariableIndex],
variables[baseVariableIndex + 1],
variables[baseVariableIndex + 2]
),
clonedType
)
)
);
break;
}
default: {
throw new InvalidOperationException("Unsupported array dimension count");
}
}
// Only execute the array transfer expressions if the array is not null
transferExpressions.Add(
Expression.IfThen(
Expression.NotEqual(original, Expression.Constant(null)),
Expression.Block(arrayTransferExpressions)
)
);
// Set the return value to the temporary variable
transferExpressions.Add(clone);
}
/// Generates state transfer expressions to copy a complex type
/// Complex type that will be cloned
/// Variable expression for the original instance
/// Receives variables used by the transfer expressions
/// Receives the generated transfer expressions
private static void generateComplexTypeTransferExpressions(
Type clonedType,
ParameterExpression original,
ICollection variables,
ICollection transferExpressions
) {
// We need a temporary variable because the IfThen expression is not suitable
// for returning values
ParameterExpression clone = Expression.Variable(clonedType, "clone");
variables.Add(clone);
var complexTransferExpressions = new List();
complexTransferExpressions.Add(Expression.Assign(clone, Expression.New(clonedType)));
FieldInfo[] fieldInfos = clonedType.GetFields(
BindingFlags.Public | BindingFlags.NonPublic |
BindingFlags.Instance | BindingFlags.FlattenHierarchy
);
for(int index = 0; index < fieldInfos.Length; ++index) {
FieldInfo fieldInfo = fieldInfos[index];
Type fieldType = fieldInfo.FieldType;
if(fieldType.IsPrimitive) {
complexTransferExpressions.Add(
Expression.Assign(
Expression.Field(clone, fieldInfo),
Expression.Field(original, fieldInfo)
)
);
}
}
transferExpressions.Add(
Expression.IfThen(
Expression.NotEqual(original, Expression.Constant(null)),
Expression.Block(complexTransferExpressions)
)
);
// Set the return value to the temporary variable
transferExpressions.Add(clone);
}
/// Compiles a method that creates a clone of an object
/// Type for which a clone method will be created
/// A method that clones an object of the provided type
private static Func createDeepFieldBasedCloner() {
Type clonedType = typeof(TCloned);
ParameterExpression original = Expression.Parameter(typeof(TCloned), "original");
ParameterExpression clone = Expression.Variable(typeof(TCloned), "clone");
var transferExpressions = new List();
var variables = new List();
if(clonedType.IsPrimitive || (clonedType == typeof(string))) {
transferExpressions.Add(original); // primitives are copied on assignment
} else if(clonedType.IsArray) {
Type elementType = clonedType.GetElementType();
if(elementType.IsPrimitive || (elementType == typeof(string))) {
generatePrimitiveArrayTransferExpressions(
clonedType, original, variables, transferExpressions
);
} else {
generateComplexArrayTransferExpressions(
clonedType, original, variables, transferExpressions
);
}
} else {
generateComplexTypeTransferExpressions(
clonedType, original, variables, transferExpressions
);
}
Expression> expression;
if(variables.Count > 0) {
expression = Expression.Lambda>(
Expression.Block(variables, transferExpressions), original
);
} else if(transferExpressions.Count == 1) {
expression = Expression.Lambda>(
transferExpressions[0], original
);
} else {
expression = Expression.Lambda>(
Expression.Block(transferExpressions), original
);
}
return expression.Compile();
}
#if false
///
/// Transfers the state of one object into another, creating clones of referenced objects
///
/// Type of the object whose sate will be transferred
/// Original instance the state will be taken from
/// Target instance the state will be written to
/// Whether to perform a property-based state copy
public void DeepCopyState(TState original, TState target, bool propertyBased)
where TState : class {
throw new NotImplementedException();
}
///
/// Transfers the state of one object into another, creating clones of referenced objects
///
/// Type of the object whose sate will be transferred
/// Original instance the state will be taken from
/// Target instance the state will be written to
/// Whether to perform a property-based state copy
public void DeepCopyState(ref TState original, ref TState target, bool propertyBased)
where TState : struct {
throw new NotImplementedException();
}
/// Transfers the state of one object into another
/// Type of the object whose sate will be transferred
/// Original instance the state will be taken from
/// Target instance the state will be written to
/// Whether to perform a property-based state copy
public void ShallowCopyState(TState original, TState target, bool propertyBased)
where TState : class {
throw new NotImplementedException();
}
/// Transfers the state of one object into another
/// Type of the object whose sate will be transferred
/// Original instance the state will be taken from
/// Target instance the state will be written to
/// Whether to perform a property-based state copy
public void ShallowCopyState(ref TState original, ref TState target, bool propertyBased)
where TState : struct {
throw new NotImplementedException();
}
///
/// Compiles a method that copies the state of one object into another object
///
/// Type of object whose state will be copied
/// Whether to create clones of the referenced objects
/// A method that copies the state from one object into another object
public static Action CreateReferenceCopier(bool deepClone)
where TCloned : class {
throw new NotImplementedException();
}
///
/// Compiles a method that copies the state of one object into another object
///
/// Type of object whose state will be copied
/// Whether to create clones of the referenced objects
/// A method that copies the state from one object into another object
public static ReferenceAction CreateValueCopier(bool deepClone)
where TCloned : struct {
throw new NotImplementedException();
}
/// Compiles a method that creates a clone of an object
/// Type of object that will be cloned
/// Whether to create clones of the referenced objects
/// A method that clones an object of the provided type
public static Func CreateCloner(bool deepClone)
where TCloned : class, new() {
throw new NotImplementedException();
}
#endif
/// Compiled cloners that perform shallow clone operations
private static ConcurrentDictionary shallowCloners;
/// Compiled cloners that perform deep clone operations
private static ConcurrentDictionary deepCloners;
}
} // namespace Nuclex.Support.Cloning
#endif // !(XBOX360 || WINDOWS_PHONE)