public DataConverterAttribute(Type dataConverter, Type storageType)
{
if (dataConverter == null)
{
throw new ArgumentNullException("dataConverter", "A converter must be specified.");
}
if (storageType == null)
{
throw new ArgumentNullException("storageType", "A storage type must be specified.");
}
if (!dataConverter.GetImplementedInterfaces().Contains(typeof(IDataConverter)))
{
throw new ArgumentException("The converter must inherit from IDataConverter.", "dataConverter");
}
var constructors = dataConverter.GetDeclaredConstructors();
if (constructors.All(x => !x.IsPublic || x.GetParameters().Length != 0))
{
throw new ArgumentException("The converter must have a public parameterless constructor.",
"dataConverter");
}
StorageType = storageType;
DataConverter = dataConverter;
Parameter = null;
}
public TypeInfo(Type type, IEnumerable<MethodInfo> sourceExtensionMethodSearch)
{
Type = type;
var publicReadableMembers = GetAllPublicReadableMembers();
var publicWritableMembers = GetAllPublicWritableMembers();
PublicReadAccessors = BuildPublicReadAccessors(publicReadableMembers);
PublicWriteAccessors = BuildPublicAccessors(publicWritableMembers);
PublicNoArgMethods = BuildPublicNoArgMethods();
Constructors = type.GetDeclaredConstructors().Where(ci => !ci.IsStatic).ToArray();
PublicNoArgExtensionMethods = BuildPublicNoArgExtensionMethods(sourceExtensionMethodSearch);
}
public TypeDetails(Type type, Func<PropertyInfo, bool> shouldMapProperty, Func<FieldInfo, bool> shouldMapField, IEnumerable<MethodInfo> sourceExtensionMethodSearch)
{
Type = type;
var membersToMap = MembersToMap(shouldMapProperty, shouldMapField);
var publicReadableMembers = GetAllPublicReadableMembers(membersToMap);
var publicWritableMembers = GetAllPublicWritableMembers(membersToMap);
PublicReadAccessors = BuildPublicReadAccessors(publicReadableMembers);
PublicWriteAccessors = BuildPublicAccessors(publicWritableMembers);
PublicNoArgMethods = BuildPublicNoArgMethods();
Constructors = type.GetDeclaredConstructors().Where(ci => !ci.IsStatic).ToArray();
PublicNoArgExtensionMethods = BuildPublicNoArgExtensionMethods(sourceExtensionMethodSearch);
}
public TypeDetails(Type type, IProfileConfiguration config)
{
Type = type;
var membersToMap = MembersToMap(config.ShouldMapProperty, config.ShouldMapField);
var publicReadableMembers = GetAllPublicReadableMembers(membersToMap);
var publicWritableMembers = GetAllPublicWritableMembers(membersToMap);
PublicReadAccessors = BuildPublicReadAccessors(publicReadableMembers);
PublicWriteAccessors = BuildPublicAccessors(publicWritableMembers);
PublicNoArgMethods = BuildPublicNoArgMethods();
Constructors = type.GetDeclaredConstructors().Where(ci => !ci.IsStatic).ToArray();
PublicNoArgExtensionMethods = BuildPublicNoArgExtensionMethods(config.SourceExtensionMethods);
}
public TypeDetails(Type type, ProfileMap config)
{
Type = type;
var membersToMap = MembersToMap(config.ShouldMapProperty, config.ShouldMapField);
var publicReadableMembers = GetAllPublicReadableMembers(membersToMap);
var publicWritableMembers = GetAllPublicWritableMembers(membersToMap);
PublicReadAccessors = BuildPublicReadAccessors(publicReadableMembers);
PublicWriteAccessors = BuildPublicAccessors(publicWritableMembers);
PublicNoArgMethods = BuildPublicNoArgMethods();
Constructors = type.GetDeclaredConstructors().Where(ci => !ci.IsStatic).ToArray();
PublicNoArgExtensionMethods = BuildPublicNoArgExtensionMethods(config.SourceExtensionMethods);
AllMembers = PublicReadAccessors.Concat(PublicNoArgMethods).Concat(PublicNoArgExtensionMethods).ToList();
DestinationMemberNames = AllMembers.Select(mi => new DestinationMemberName { Member = mi, Possibles = PossibleNames(mi.Name, config.Prefixes, config.Postfixes).ToArray() });
}
public LateBoundCtor CreateCtor(Type type)
{
var ctor = _ctorCache.GetOrAdd(type, t =>
{
//handle valuetypes
if (!type.IsClass())
{
var ctorExpression =
Expression.Lambda<LateBoundCtor>(Expression.Convert(Expression.New(type), typeof (object)));
return ctorExpression.Compile();
}
else
{
var constructors = type
.GetDeclaredConstructors()
.Where(ci => !ci.IsStatic);
//find a ctor with only optional args
var ctorWithOptionalArgs = constructors.FirstOrDefault(c => c.GetParameters().All(p => p.IsOptional));
if (ctorWithOptionalArgs == null)
throw new ArgumentException(
"Type needs to have a constructor with 0 args or only optional args", "type");
//get all optional default values
var args = ctorWithOptionalArgs
.GetParameters()
.Select(p => Expression.Constant(p.DefaultValue, p.ParameterType)).ToArray();
//create the ctor expression
var ctorExpression =
Expression.Lambda<LateBoundCtor>(Expression.Convert(Expression.New(ctorWithOptionalArgs, args),
typeof (object)));
return ctorExpression.Compile();
}
});
return ctor;
}
private ConstructorInfo GetConstructor(Type/*!*/ type, params Type[]/*!*/ parameterTypes) {
return type.GetDeclaredConstructors()
.WithBindingFlags(BindingFlags.Instance | BindingFlags.Public | (Context.DomainManager.Configuration.PrivateBinding ? BindingFlags.NonPublic : 0))
.WithSignature(parameterTypes)
.FirstOrDefault();
}
private IEnumerable<ReflectionOverloadInfo>/*!*/ GetConstructors(Type/*!*/ type) {
return
from ctor in type.GetDeclaredConstructors()
where !ctor.IsStatic && (Context.DomainManager.Configuration.PrivateBinding || ctor.IsPublic)
select new ReflectionOverloadInfo(ctor);
}
/*!*/
public static object CreateRange(RubyClass theClass, Type baseType, IDictionary<string, object> attributes = null)
{
object begin = null, end = null, excludeEnd = null;
BindingFlags bindingFlags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance;
ConstructorInfo ci = null;
if (attributes != null) {
if (attributes.TryGetValue("begin", out begin))
attributes.Remove("begin");
if(attributes.TryGetValue("end", out end))
attributes.Remove("end");
if(attributes.TryGetValue("excl", out excludeEnd))
attributes.Remove("excl");
if (begin is int && end is int && IsAvailable(ci = baseType.GetDeclaredConstructors().WithBindingFlags(bindingFlags).WithSignature(_ccRangeTypes1).SingleOrDefault())) {
return ci.Invoke(new object[] { begin, end, true.Equals(excludeEnd) });
} else if (begin is int && end is int && IsAvailable(ci = baseType.GetDeclaredConstructors().WithBindingFlags(bindingFlags).WithSignature(_ccRangeSubclassTypes1).SingleOrDefault())) {
return ci.Invoke(new object[] { theClass, begin, end, true.Equals(excludeEnd) });
} else if (begin is MutableString && end is MutableString && IsAvailable(ci = baseType.GetDeclaredConstructors().WithBindingFlags(bindingFlags).WithSignature(_ccRangeTypes2).SingleOrDefault())) {
return ci.Invoke(new object[] { begin, end, true.Equals(excludeEnd) });
} else if (begin is int && end is int && IsAvailable(ci = baseType.GetDeclaredConstructors().WithBindingFlags(bindingFlags).WithSignature(_ccRangeSubclassTypes2).SingleOrDefault())) {
return ci.Invoke(new object[] { theClass, begin, end, true.Equals(excludeEnd) });
}
}
if (IsAvailable(ci = baseType.GetDeclaredConstructors().WithBindingFlags(bindingFlags).WithSignature(ReflectionUtils.EmptyTypes).Single())) {
return ci.Invoke(new object[0]);
}
string message = String.Format("Class {0} does not have a valid constructor", theClass.Name);
throw new NotSupportedException(message);
}
/*!*/
public static object CreateException(RubyClass theClass, Type baseType, IDictionary<string, object> attributes = null)
{
object mesg = null, bt = null;
BindingFlags bindingFlags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance;
ConstructorInfo ci = null;
Exception result = null;
if (attributes != null) {
if (attributes.TryGetValue("mesg", out mesg))
attributes.Remove("mesg");
if (attributes.TryGetValue("bt", out bt)) {
attributes.Remove("bt");
}
if(mesg is MutableString)
mesg = ((MutableString)mesg).ToString();
}
if (mesg is string && IsAvailable(ci = baseType.GetDeclaredConstructors().WithBindingFlags(bindingFlags).WithSignature(_ccExceptionTypes1).SingleOrDefault())) {
result = (Exception)ci.Invoke(new object[] { mesg });
} else if (IsAvailable(ci = baseType.GetDeclaredConstructors().WithBindingFlags(bindingFlags).WithSignature(ReflectionUtils.EmptyTypes).SingleOrDefault())) {
result = (Exception)ci.Invoke(new object[0]);
} else {
string message = String.Format("Class {0} does not have a valid constructor", theClass.Name);
throw new NotSupportedException(message);
}
if (bt is RubyArray)
RubyExceptionData.GetInstance(result).Backtrace = (RubyArray)bt;
return result;
}
