// /// <summary> // /// Looks up the <see cref="IConvertFrom"/> for the target type. // /// </summary> // /// <param name="target">The type to lookup the converter for.</param> // /// <returns>The converter for the specified type.</returns> // public static IConvertFrom GetTypeConverter(Type target) // { // IConvertFrom converter = ConverterRegistry.GetConverter(target); // if (converter == null) // { // throw new InvalidOperationException("No type converter defined for [" + target + "]"); // } // return converter; // } /// <summary> /// Checks if there is an appropriate type conversion from the source type to the target type. /// </summary> /// <param name="sourceType">The type to convert from.</param> /// <param name="targetType">The type to convert to.</param> /// <returns><c>true</c> if there is a conversion from the source type to the target type.</returns> /// <remarks> /// Checks if there is an appropriate type conversion from the source type to the target type. /// <para> /// </para> /// </remarks> public static bool CanConvertTypeTo(Type sourceType, Type targetType) { if (sourceType == null || targetType == null) { return(false); } // Check if we can assign directly from the source type to the target type if (targetType.IsAssignableFrom(sourceType)) { return(true); } // Look for a To converter IConvertTo tcSource = ConverterRegistry.GetConvertTo(sourceType, targetType); if (tcSource != null) { if (tcSource.CanConvertTo(targetType)) { return(true); } } // Look for a From converter IConvertFrom tcTarget = ConverterRegistry.GetConvertFrom(targetType); if (tcTarget != null) { if (tcTarget.CanConvertFrom(sourceType)) { return(true); } } return(false); }
/// <summary> /// Converts an object to the target type. /// </summary> /// <param name="sourceInstance">The object to convert to the target type.</param> /// <param name="targetType">The type to convert to.</param> /// <returns>The converted object.</returns> /// <remarks> /// <para> /// Converts an object to the target type. /// </para> /// </remarks> public static object ConvertTypeTo(object sourceInstance, Type targetType) { Type sourceType = sourceInstance.GetType(); // Check if we can assign directly from the source type to the target type if (targetType.IsAssignableFrom(sourceType)) { return(sourceInstance); } // Look for a TO converter IConvertTo tcSource = ConverterRegistry.GetConvertTo(sourceType, targetType); if (tcSource != null) { if (tcSource.CanConvertTo(targetType)) { return(tcSource.ConvertTo(sourceInstance, targetType)); } } // Look for a FROM converter IConvertFrom tcTarget = ConverterRegistry.GetConvertFrom(targetType); if (tcTarget != null) { if (tcTarget.CanConvertFrom(sourceType)) { return(tcTarget.ConvertFrom(sourceInstance)); } } throw new ArgumentException( "Cannot convert source object [" + sourceInstance + "] to target type [" + targetType.Name + "]", "sourceInstance"); }
/// <summary> /// Checks if there is an appropriate type conversion from the source type to the target type. /// </summary> /// <param name="sourceType">The type to convert from.</param> /// <param name="targetType">The type to convert to.</param> /// <returns><c>true</c> if there is a conversion from the source type to the target type.</returns> /// <remarks> /// Checks if there is an appropriate type conversion from the source type to the target type. /// <para> /// </para> /// </remarks> public static bool CanConvertTypeTo(Type sourceType, Type targetType) { if ((object)sourceType == null || (object)targetType == null) { return(false); } if (CompatibilityExtensions.IsAssignableFrom(targetType, sourceType)) { return(true); } IConvertTo convertTo = ConverterRegistry.GetConvertTo(sourceType, targetType); if (convertTo != null && convertTo.CanConvertTo(targetType)) { return(true); } IConvertFrom convertFrom = ConverterRegistry.GetConvertFrom(targetType); if (convertFrom != null && convertFrom.CanConvertFrom(sourceType)) { return(true); } return(false); }
public TypeAndConverter(NameKey key, IConvertTo <TypeProblem2.Type, IOrType <WeakTypeDefinition, WeakGenericTypeDefinition, IPrimitiveType> > converter) { this.key = key ?? throw new ArgumentNullException(nameof(key)); this.converter = converter ?? throw new ArgumentNullException(nameof(converter)); }
public (Method, IOrType <TypeReference, IError>, IOrType <TypeReference, IError>) CreateGenericMethod(IStaticScope parent, Func <IStaticScope, IOrType <TypeReference, IError> > inputTypeBuilder, Func <IStaticScope, IOrType <TypeReference, IError> > outputTypeBuilder, string inputName, IConvertTo <Method, IOrType <WeakMethodDefinition, WeakImplementationDefinition, WeakEntryPointDefinition, WeakGenericMethodDefinition> > converter, IReadOnlyList <TypeAndConverter> placeholders) { var(method, inputType, outputType) = CreateMethod(parent, inputTypeBuilder, outputTypeBuilder, inputName, converter); var i = 0; foreach (var placeholder in placeholders) { var placeholderType = new GenericTypeParameter(this, $"generic-parameter-{placeholder.key}", i++, Prototypist.Toolbox.OrType.Make <MethodType, Type, Method, InferredType>(method)); HasGenericType(Prototypist.Toolbox.OrType.Make <MethodType, Type, Method>(method), placeholder.key, placeholderType); } // why doesn't this have genericOverlays ({4BFD0274-B70F-4BD8-B290-63B69FF74FE7}) // the overlays are t1 and t2 of the base method "method [t1,t2]" // they are never references anywhere so we don't care to overlay them // we build the right MethodType // at {2E20DFFB-7BD2-4351-9CAF-10A63491ABCF} // this isn't great // it would be a little work to build the genericOverlays // genericOverlays take a looked up type not a key return(method, inputType, outputType); }
public OrType CreateOrType(IStaticScope s, IKey key, IOrType <TypeReference, IError> setUpSideNode1, IOrType <TypeReference, IError> setUpSideNode2, IConvertTo <OrType, IFrontendType <IVerifiableType> > converter) { if (!setUpSideNode1.Is1(out var node1)) { throw new NotImplementedException(); } if (!setUpSideNode2.Is1(out var node2)) { throw new NotImplementedException(); } var res = new OrType(this, $"{node1.DebugName} || {node2.DebugName}", converter); Ors(res, node1, node2); HasOrType(s, key, res); return(res); }
// why do objects have keys? // that is wierd public Object CreateObjectOrModule(IStaticScope parent, IKey key, IConvertTo <Object, IOrType <WeakObjectDefinition, WeakRootScope> > converter, IConvertTo <Scope, IOrType <WeakBlockDefinition, WeakScope, WeakEntryPointDefinition> > innerConverter) { var res = new Object(this, key.ToString() !, converter, innerConverter); IsChildOf(parent, res); HasObject(parent, key, res); return(res); }
public Type CreateGenericType(IStaticScope parent, IOrType <NameKey, ImplicitKey> key, IReadOnlyList <TypeAndConverter> placeholders, IConvertTo <Type, IOrType <WeakTypeDefinition, WeakGenericTypeDefinition, Tac.SyntaxModel.Elements.AtomicTypes.IPrimitiveType> > converter) { var res = new Type( this, $"generic-{key}-{placeholders.Aggregate("", (x, y) => x + "-" + y)}", Possibly.Is(key), converter, Possibly.IsNot <Guid>(), Possibly.IsNot <IInterfaceType>()); IsChildOf(parent, res); HasType(parent, key.SwitchReturns <IKey>(x => x, x => x), res); var i = 0; foreach (var placeholder in placeholders) { var placeholderType = new TypeProblem2.GenericTypeParameter(this, $"generic-parameter-{placeholder.key}", i++, Prototypist.Toolbox.OrType.Make <MethodType, Type, Method, InferredType>(res)); //var placeholderType = new Type( // this, // $"generic-parameter-{placeholder.key}", // Possibly.Is(placeholder.key), // placeholder.converter, // Possibly.IsNot<Guid>(), // Possibly.IsNot<IInterfaceType>()); HasGenericType(Prototypist.Toolbox.OrType.Make <MethodType, Type, Method>(res), placeholder.key, placeholderType); } return(res); }
public Type CreateType(IStaticScope parent, IOrType <NameKey, ImplicitKey> key, IConvertTo <Type, IOrType <WeakTypeDefinition, WeakGenericTypeDefinition, Tac.SyntaxModel.Elements.AtomicTypes.IPrimitiveType> > converter, IIsPossibly <Guid> primitive) { var res = new Type(this, key.ToString() !, Possibly.Is(key), converter, primitive, Possibly.IsNot <IInterfaceType>()); IsChildOf(parent, res); HasType(parent, key.SwitchReturns <IKey>(x => x, x => x), res); return(res); }
public Type CreateType(IStaticScope parent, IOrType <NameKey, ImplicitKey> key, IConvertTo <Type, IOrType <WeakTypeDefinition, WeakGenericTypeDefinition, Tac.SyntaxModel.Elements.AtomicTypes.IPrimitiveType> > converter) { return(CreateType(parent, key, converter, Possibly.IsNot <Guid>())); }
public TypeReference CreateTypeReference(IStaticScope context, IKey typeKey, IConvertTo <TypeReference, IFrontendType <IVerifiableType> > converter) { var res = new TypeReference(this, typeKey.ToString() !, converter); HasReference(context, res); res.Context = Possibly.Is(context); res.TypeKey = Prototypist.Toolbox.OrType.Make <IKey, IError, Unset>(typeKey); return(res); }