/// <inheritdocs />
public override string ToString()
{
var result = Type.Name.Split('`').First() + ": " + Nullability + "\n " +
string.Join("\n", GenericArguments.Select(a => a.ToString())).Replace("\n", "\n ");
return(result.Trim());
}
public MethodModel ToModel()
{
MethodModel methodModel = new MethodModel
{
Name = Name,
GenericArguments =
GenericArguments?.Select(typeModel => typeModel.ToModel()),
Modifiers = new Tuple<AccessLevelEnum, AbstractEnum, StaticEnum,
VirtualEnum, OverrideEnum>(
EnumMapper.ConvertEnum<AccessLevelEnum, AccessLevelEnumMetadata>(Modifiers.Item1),
EnumMapper.ConvertEnum<AbstractEnum, AbstractEnumMetadata>(Modifiers.Item2),
EnumMapper.ConvertEnum<StaticEnum, StaticEnumMetadata>(Modifiers.Item3),
EnumMapper.ConvertEnum<VirtualEnum, VirtualEnumMetadata>(Modifiers.Item4),
EnumMapper.ConvertEnum<OverrideEnum, OverrideEnumMetadata>(Modifiers.Item5)
),
ReturnType = ReturnType,
Extension = Extension,
Parameters =
Parameters?.Select(parameterModel => parameterModel.ToModel())
};
return methodModel;
}
public TypeModel ToModel()
{
TypeModel model = new TypeModel();
model.TypeEnum = EnumMapper.ConvertEnum <TypeTypesEnum, TypeTypesSerializationModelEnum>(TypeEnum);
model.TypeName = TypeName;
model.NamespaceName = NamespaceName;
model.GenericArguments = GenericArguments?.Select(EmitTypeModel);
model.Modifiers = new Tuple <AccessLevelEnum, SealedEnum, AbstractEnum>(
EnumMapper.ConvertEnum <AccessLevelEnum, AccessLevelSerializationModelEnum>(Modifiers.Item1),
EnumMapper.ConvertEnum <SealedEnum, SealedSerializationModelEnum>(Modifiers.Item2),
EnumMapper.ConvertEnum <AbstractEnum, AbstractSerializationModelEnum>(Modifiers.Item3));
model.Attributes = Attributes?.Select(attributeMetadata => attributeMetadata.ToModel());
model.FullTypeName = FullTypeName;
model.DeclaringType = DeclaringType == null ? null : EmitTypeModel(DeclaringType);
model.BaseType = DeclaringType == null ? null : EmitTypeModel(BaseType);
model.ImplementedInterfaces = ImplementedInterfaces?.Select(EmitTypeModel);
model.Fields = Fields?.Select(typeModel => typeModel.ToModel());
model.Methods = Methods?.Select(typeModel => typeModel.ToModel());
model.Properties = Properties?.Select(typeModel => typeModel.ToModel());
model.Indexers = Indexers?.Select(typeModel => typeModel.ToModel());
model.Events = Events?.Select(typeModel => typeModel.ToModel());
model.Constructors = Constructors?.Select(typeModel => typeModel.ToModel());
model.NestedTypes = NestedTypes?.Select(EmitTypeModel);
return(model);
}
public MethodModel ToModel()
{
MethodModel methodModel = new MethodModel();
methodModel.Name = Name;
methodModel.GenericArguments =
GenericArguments?.Select(typeModel => typeModel.ToModel());
methodModel.Modifiers = new Tuple <AccessLevelEnum, AbstractEnum, StaticEnum,
VirtualEnum, OverrideEnum> (
EnumMapper.ConvertEnum <AccessLevelEnum, AccessLevelDbModelEnum>(Item1),
EnumMapper.ConvertEnum <AbstractEnum, AbstractDbModelEnum>(Item2),
EnumMapper.ConvertEnum <StaticEnum, StaticDbModelEnum>(Item3),
EnumMapper.ConvertEnum <VirtualEnum, VirtualDbModelEnum>(Item4),
EnumMapper.ConvertEnum <OverrideEnum, OverrideDbModelEnum>(Item5)
);
methodModel.ReturnType = ReturnType;
methodModel.Extension = Extension;
methodModel.Parameters =
Parameters?.Select(parameterModel => parameterModel.ToModel());
return(methodModel);
}
string FormatForDisplay(Func <TypeIdentifier, string> displayNameSelector)
{
string languageName;
if (LanguageNames.TryGetValue(FullName, out languageName))
{
return(languageName);
}
if (IsAnonymous)
{
return("Anonymous");
}
var result = displayNameSelector(this);
if (GenericArguments.Length > 0)
{
result += "<";
result += string.Join(", ", GenericArguments.Select(a => a.FormatForDisplay(displayNameSelector)));
result += ">";
}
result += Modifiers;
return(result);
}
public override ObjectFragment Build()
{
var result = new ObjectFragment()
{
Name = Name,
ModuleName = ModuleName,
GenericArguments = GenericArguments.Select(a => new GenericArgumentDefinition(a)).ToArray(),
};
foreach (var constant in Constants)
{
result.Constants.Add(constant.Build());
}
foreach (var field in Fields)
{
result.Fields.Add(field.Build());
}
foreach (var hint in Hints)
{
result.Hints.Add(hint);
}
return(result);
}
/// <summary>
/// Returns the CLR <see cref="MemberInfo"/>.
/// </summary>
/// <returns>Returns the CLR <see cref="MemberInfo"/>.</returns>
public override MemberInfo GetClrVersion()
{
InterLinqTypeSystem tsInstance = InterLinqTypeSystem.Instance;
lock (tsInstance)
{
if (tsInstance.IsInterLinqMemberInfoRegistered(this))
{
return(tsInstance.GetClrVersion <MethodInfo>(this));
}
Type declaringType = (Type)DeclaringType.GetClrVersion();
Type[] genericArgumentTypes = GenericArguments.Select(p => (Type)p.GetClrVersion()).ToArray();
MethodInfo foundMethod = null;
foreach (MethodInfo method in declaringType.GetMethods().Where(m => m.Name == Name))
{
MethodInfo currentMethod = method;
if (currentMethod.IsGenericMethod)
{
if (currentMethod.GetGenericArguments().Length == genericArgumentTypes.Length)
{
currentMethod = currentMethod.MakeGenericMethod(genericArgumentTypes);
}
else
{
continue;
}
}
ParameterInfo[] currentParameters = currentMethod.GetParameters();
if (ParameterTypes.Count == currentParameters.Length)
{
bool allArumentsFit = true;
for (int i = 0; i < ParameterTypes.Count && i < currentParameters.Length; i++)
{
Type currentArg = (Type)ParameterTypes[i].GetClrVersion();
Type currentParamType = currentParameters[i].ParameterType;
if (!currentParamType.IsAssignableFrom(currentArg))
{
allArumentsFit = false;
break;
}
}
if (allArumentsFit)
{
foundMethod = currentMethod;
}
}
}
if (foundMethod == null)
{
throw new Exception(string.Format("Method \"{0}.{1}\" not found.", declaringType, Name));
}
tsInstance.SetClrVersion(this, foundMethod);
return(foundMethod);
}
}
private string CreateFullName()
{
if (!GenericArguments.Any())
{
return(Mapping.Name);
}
var genericArguments = string.Join(", ", GenericArguments.Select(a => a.Name));
return($"{Mapping.Name}<{genericArguments}>");
}
private MethodInfo GetMethodInfo()
{
MethodInfo mi;
if (GenericArguments != null && GenericArguments.Length > 0)
{
mi = FindGenericMethod(MethodType, MethodName,
GenericArguments.Select(p => p.GetSystemType()).ToArray(),
ParameterTypes.Select(p => p.GetSystemType()).ToArray());
}
else
{
mi = MethodType.GetMethod(MethodName, ParameterTypes.Select(p => p.GetSystemType()).ToArray());
}
if (mi == null)
{
throw new MissingMethodException(MethodType.FullName, MethodName);
}
return(mi);
}
public string MakeGenericName(string openBracket, string closeBracket, string commaSeparator)
{
if (!IsGenericType)
{
return(this.Name.ToString());
}
if (IsGenericDefinition)
{
return(
this.Name +
openBracket +
string.Join(commaSeparator, GenericParameters.Select(t => t.Name)) +
closeBracket);
}
else
{
return(
this.Name +
openBracket +
string.Join(commaSeparator, GenericArguments.Select(t => t.MakeGenericName(openBracket, closeBracket, commaSeparator))) +
closeBracket);
}
}
public TypeDefinition(Type type)
{
Type = type;
Name = type.Name;
var typeInfo = type.GetTypeInfo();
if (typeInfo.IsGenericType)
{
Type[] types = type.GetGenericArguments();
if (type.GetGenericTypeDefinition() == typeof(Nullable <>))
{
Type = type.GetGenericArguments()[0];
}
Name = Name.Replace("`" + types.Length, "Of" + string.Join("", types.Select(p => p.Name)));
}
FullName = type.FullName;
GetPrimitiveInfo(Type);
IsArray = typeInfo.IsArray;
if (!IsPrimitive && typeof(IEnumerable).IsAssignableFrom(type))
{
IsEnumerable = true;
}
if (IsEnumerable)
{
if (typeof(IDictionary).IsAssignableFrom(type))
{
IsDictionary = true;
}
var elementType = type.GetElementType();
if (elementType != null)
{
Name = "ArrayOf" + elementType.Name;
}
if (typeInfo.IsGenericType)
{
GenericArguments = type.GetGenericArguments();
if (elementType == null)
{
Name = "ArrayOf" + string.Join("", GenericArguments.Select(p => p.Name));
}
if (IsDictionary)
{
MethodAddToDictionary = ObjectAccessors.CreateMethodAddToDictionary(type);
}
else
{
MethodAddToCollection = ObjectAccessors.CreateMethodAddCollection(type);
}
}
}
IsObjectToSerialize = // !typeInfo.IsPrimitive && !typeInfo.IsValueType &&
!IsPrimitive &&
!typeInfo.IsEnum && type != typeof(string) &&
//not generic or generic but not List<> and Set<>
(!typeInfo.IsGenericType ||
(typeInfo.IsGenericType && !typeof(IEnumerable).IsAssignableFrom(type)));
if (IsObjectToSerialize)
{
Properties = GetPropertieToSerialze(type);
}
ObjectActivator = ObjectAccessors.CreateObjectActivator(type, IsPrimitive);
}
public string ToGenericArgumentsString()
{
return(IsGeneric ? $"<{string.Join(", ", GenericArguments.Select(a => a.ToString()))}>" : "");
}
public TypeName GetGenericTypeDefinition()
{
return(Create(rawName, AssemblyName,
GenericArguments.Select(t => Maybe <TypeName> .Empty), OrderOfArray));
}
public TypeDefinition(Type type)
{
Type = type;
Name = type.Name;
var typeInfo = type.GetTypeInfo();
var isGenericType = typeInfo.IsGenericType;
if (isGenericType)
{
var types = type.GetGenericArguments();
if (type.GetGenericTypeDefinition() == typeof(Nullable <>))
{
Type = type.GetGenericArguments()[0];
}
Name = Name.Replace("`" + types.Length, "Of" + string.Join("", types.Select(p => p.Name)));
}
FullName = type.FullName;
GetPrimitiveInfo(Type);
IsArray = typeInfo.IsArray;
IsEnumerable = !IsPrimitive && typeof(IEnumerable).IsAssignableFrom(type);
if (IsEnumerable)
{
IsDictionary = typeof(IDictionary).IsAssignableFrom(type);
var elementType = ElementTypeLocator.Default.Locate(type);
if (isGenericType)
{
GenericArguments = type.GetGenericArguments();
}
else if (elementType != null)
{
GenericArguments = new[] { elementType };
}
Name = IsArray || isGenericType
? $"ArrayOf{string.Join(string.Empty, GenericArguments.Select(p => p.Name))}"
: type.Name;
if (IsDictionary)
{
MethodAddToDictionary = ObjectAccessors.CreateMethodAddToDictionary(type);
}
else if (elementType != null && !IsArray)
{
MethodAddToCollection = ObjectAccessors.CreateMethodAddCollection(type, elementType);
}
}
var attribute = typeInfo.GetCustomAttribute <XmlRootAttribute>();
if (attribute != null)
{
Name = attribute.ElementName;
}
IsObjectToSerialize = // !typeInfo.IsPrimitive && !typeInfo.IsValueType &&
!IsPrimitive &&
!typeInfo.IsEnum && type != typeof(string) &&
//not generic or generic but not List<> and Set<>
(!isGenericType || !IsEnumerable);
_properties = new Lazy <IEnumerable <PropertieDefinition> >(GetPropertieToSerialze);
ObjectActivator = ObjectAccessors.CreateObjectActivator(type, IsPrimitive);
}
