/// <summary> /// Validate that our Type selector is not null /// </summary> /// <param name="selector">The TypeSelector instance</param> public static void IsNotNull(ITypeSelector selector) { if (selector == null) { throw new ArgumentNullException("selector"); } }
public IEnumerable <Type> RetrieveTypes(ITypeSelector selector) { var choosenSelector = selector ?? new AllSelector(); var typesToRegistration = _sourceTypes.Where(choosenSelector.DoesSelect).ToList(); return(typesToRegistration); }
private IList CreateaArrayInstance(Type propertyType, Type targetType = null) { //Get the underlying type used int he array //var elementType = propertyType.GetElementType(); //Works only for arrays var elementType = propertyType.IsGenericType ? propertyType.GetGenericArguments()[0] : propertyType.GetElementType(); //Works for IList<T> / IEnumerable<T> //Get a number of elements we want to create //Note: (between 1 and 10 for now) var elementCount = Numbers.Int(1, 10); //Create an instance of our target array IList arrayInstance = null; //If we're working with a generic list or any other sort of collection if (propertyType.IsGenericTypeDefinition) { arrayInstance = (IList)GenericHelper.CreateGeneric(propertyType, elementType); } else { arrayInstance = (IList)GenericHelper.CreateGeneric(typeof(List <>), elementType); } //Determine if there's a selector available for this type var hasSelector = TypeMap.CountSelectors(elementType) > 0; ITypeSelector selector = null; //So we have a type available for this selector.. if (hasSelector) { selector = TypeMap.GetBaseSelector(elementType); } //If the element in the array isn't the same type as the parent object (recursive objects, like trees) if (elementType != targetType) { for (var i = 0; i < elementCount; i++) { //Create a new element instance var element = SafeObjectCreate(elementType); if (hasSelector) { selector.Generate(ref element); } //If the element type is a class populate it recursively else if (elementType.IsClass) { var subProperties = elementType.GetProperties(); //Populate all of the properties on this object ProcessProperties(subProperties, element); } arrayInstance.Add(element); } } return(arrayInstance); }
public CombinedSelector AddSelector(ITypeSelector selector) { if (selector.SupportedType != SupportedType) { throw new ArgumentException(nameof(selector)); } _selectors.Add(selector); return(this); }
// Draws a representation of the property's value. public override void PaintValue(System.Drawing.Design.PaintValueEventArgs e) { ITypeSelector ts = (ITypeSelector)MathNode.GetService(typeof(ITypeSelector)); if (ts != null) { ts.PaintValue(e); } }
// Indicates whether the UITypeEditor supports painting a // representation of a property's value. public override bool GetPaintValueSupported(System.ComponentModel.ITypeDescriptorContext context) { ITypeSelector ts = (ITypeSelector)MathNode.GetService(typeof(ITypeSelector)); if (ts != null) { return(ts.GetPaintValueSupported(context)); } return(false); }
private static IEnumerable<Type> SelectPotentialTypes(IEnumerable<ITypesProvider> typesProviders, ITypeSelector convention) { try { var potentialTypes = typesProviders.AsParallel().SelectMany(provider => provider.RetrieveTypes(convention)); return potentialTypes.ToList(); } catch (AggregateException e) { throw e.FlattenTryBubbleUp(); } }
public override System.Drawing.Design.UITypeEditorEditStyle GetEditStyle(System.ComponentModel.ITypeDescriptorContext context) { if (context != null) { ITypeSelector ts = (ITypeSelector)MathNode.GetService(typeof(ITypeSelector)); if (ts != null) { return(ts.GetUIEditorStyle(context)); } } return(UITypeEditorEditStyle.None); }
/// <summary> /// Clone a deep copy of <see cref="TypeTable"/> with the same settings as this instance. /// /// Any modifications made to the new instance returned should not affect the parent instance. /// </summary> /// <returns>A deep copy of the current <see cref="TypeTable"/>.</returns> public TypeTable Clone() { // create a deep copy var newTypeMap = new Dictionary <Type, LinkedList <ITypeSelector> >(); foreach (var pair in _typeMap) { var newList = new ITypeSelector[pair.Value.Count]; pair.Value.CopyTo(newList, 0); newTypeMap.Add(pair.Key, new LinkedList <ITypeSelector>(newList)); } return(new TypeTable(false, newTypeMap)); }
public ITypeConfig Create(ITypeSelector selector) { switch (selector.SelectorType) { case TypeSelectorType.Details: return(this.Create(selector.Type, selector.Size, selector.Precision, selector.Scale, selector.IsNullable)); case TypeSelectorType.Property: return(this.Create(selector.Property)); default: throw new NotImplementedException(); } }
/// <summary> /// Add a strongly typed selector to the /// </summary> /// <param name="selector">A ITypeSelector implementation for Type T</param> /// <param name="position"> /// Optional parameter - indicates whether you want this type selector to be used first or last in /// the sequence of available selectors for this type /// </param> public void AddSelector(ITypeSelector selector, SelectorPosition position = SelectorPosition.First) { var activeType = selector.TargetType; CreateTypeIfNotExists(activeType); if (position == SelectorPosition.First) { //If the user wants to add this selector to the front of the list (default), do that _typeMap[activeType].AddFirst(selector); } else //Otherwise, add this type to the back of the list { _typeMap[activeType].AddLast(selector); } }
public DefaultTypeMapper( IDictionary <ITypeDescription, IGeneratedType> typeDescritpions, ITypeSelector typeSelector) { if (typeDescritpions == null) { throw new ArgumentNullException("typeDescritpions"); } if (typeSelector == null) { throw new ArgumentNullException("typeSelector"); } this.typeDescritpions = typeDescritpions; this.typeSelector = typeSelector; }
public DefaultTypeMapper( IDictionary<ITypeDescription, IGeneratedType> typeDescritpions, ITypeSelector typeSelector) { if (typeDescritpions == null) { throw new ArgumentNullException("typeDescritpions"); } if (typeSelector == null) { throw new ArgumentNullException("typeSelector"); } this.typeDescritpions = typeDescritpions; this.typeSelector = typeSelector; }
static ITypeSelector GetTypeSelector(Type parameterType) { ITypeSelector typeSelector = null; if (parameterType.Equals(typeof(object))) { typeSelector = new FullTypeSelector(); } else { typeSelector = new TypeSelector { BaseType = parameterType }; //typeSelector.BaseType = parameterType; } typeSelector.Title = "Choose the type to instantiate"; typeSelector.WindowStartupLocation = WindowStartupLocation.CenterScreen; return(typeSelector); }
public SerializationSettings AddTypeSelector(ITypeSelector selector) { if (TypeSelectors.TryGetValue(selector.SupportedType, out var existing)) { if (existing is CombinedSelector combined) { combined.AddSelector(existing); } else { TypeSelectors[selector.SupportedType] = new CombinedSelector(selector.SupportedType) .AddSelector(existing) .AddSelector(selector); } } else { TypeSelectors[selector.SupportedType] = selector; } return(this); }
public override object EditValue(System.ComponentModel.ITypeDescriptorContext context, System.IServiceProvider provider, object value) { IWindowsFormsEditorService edSvc = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService)); if (edSvc != null) { edSvc.CloseDropDown(); ITypeSelector ts = (ITypeSelector)MathNode.GetService(typeof(ITypeSelector)); if (ts != null) { UITypeEditorEditStyle style = ts.GetUIEditorStyle(context); if (style == UITypeEditorEditStyle.DropDown) { IDataSelectionControl dropdown = ts.GetUIEditorDropdown(context, provider, value); if (dropdown != null) { edSvc.DropDownControl((Control)dropdown); object v = dropdown.UITypeEditorSelectedValue; if (v != null) { return(v); } } } else if (style == UITypeEditorEditStyle.Modal) { IDataSelectionControl modal = ts.GetUIEditorModal(context, provider, value); if (modal != null) { if (edSvc.ShowDialog((Form)modal) == DialogResult.OK) { return(modal.UITypeEditorSelectedValue); } } } } } return(value); }
public DefaultTypeService(ITypeActivator typesActivator, ITypeSelector typeDiscovery, IAssemblyProvider assemblyProvider) { _typesActivator = typesActivator; _typeDiscovery = typeDiscovery; _assemblyProvider = assemblyProvider; }
public IEnumerable<Type> RetrieveTypes(ITypeSelector selector) { return _existingServiceCollection.Where(x => x.ImplementationType != null).Select(x => x.ImplementationType); }
public RegisterSelectorOnOriginal(Func <ITypeSelector> selector) { _selector = selector(); }
public RegisterSelectorOnClone(Func <ITypeSelector> selector) { _selector = selector(); }
public RegisterSelectorBeforeAnyClones(Func <ITypeSelector> selector) { Selector = selector(); }
public static IServiceTypeSelector AddTypes <T1, T2, T3>(this ITypeSelector selector) { Preconditions.NotNull(selector, nameof(selector)); return(selector.AddTypes(typeof(T1), typeof(T2), typeof(T3))); }
public IEnumerable<Type> RetrieveTypes(ITypeSelector selector) { var choosenSelector = selector ?? new AllSelector(); var typesToRegistration = _sourceTypes.Where(choosenSelector.DoesSelect).ToList(); return typesToRegistration; }
public static IServiceTypeSelector AddType <T>(this ITypeSelector selector) { Preconditions.NotNull(selector, nameof(selector)); return(selector.AddTypes(typeof(T))); }
/// <summary> /// Initializes a new instance of the <see cref="ConventionBindingBuilder"/> class. /// </summary> /// <param name="bindingRoot">The binding root.</param> /// <param name="typeSelector">The type selector.</param> public ConventionBindingBuilder(IBindingRoot bindingRoot, ITypeSelector typeSelector) { this.bindingRoot = bindingRoot; this.typeSelector = typeSelector; }
private static IEnumerable <DeferredEntry> ReadProperties(object target, DeserializationContext context, IReadOnlyDictionary <string, PropertyBinding> all) { var bufferPart = new BufferPart(); var reader = context.Reader; List <DeferredEntry> deferred = null; while (true) { var token = reader.Read(ref bufferPart, out var propertyName); if (token == JsonToken.ObjectEnd) { return(deferred); } if (token != JsonToken.String) { throw Exceptions.BadToken(reader, token, JsonToken.String); } var hasProperty = all.TryGetValue(propertyName, out var property); token = reader.Read(ref bufferPart, out var _); if (token != JsonToken.NameSeparator) { throw Exceptions.BadToken(reader, token, JsonToken.NameSeparator); } if (hasProperty) { ITypeSelector typeSelector = null; var shouldDeffer = context.TypeSelectors?.TryGetValue(property.Descriptor.Type, out typeSelector) == true; if (!shouldDeffer) { property.Setter(target, property.Descriptor.Reader(context)); } else { var entry = new DeferredEntry { Selector = typeSelector, Binding = property, Snapshot = reader.TakeSnapshot() }; ValueSkipper.SkipNext(reader); if (deferred == null) { deferred = new List <DeferredEntry>(); } deferred.Add(entry); } } else { ValueSkipper.SkipNext(reader); } token = reader.Read(ref bufferPart, out var _); if (token == JsonToken.ObjectEnd) { return(deferred); } if (token != JsonToken.ValueSeparator) { throw Exceptions.BadToken(reader, token, JsonToken.ValueSeparator); } } }
/// <summary> /// Protected method used to implement our selector-matching strategy. Uses a greedy approach. /// </summary> /// <param name="property">The meta-data about the property for which we will be finding a match</param> /// <param name="targetObject">The object which will receive the property injection</param> protected virtual void ProcessProperty(PropertyInfo property, object targetObject) { //Get the type of the property var propertyType = property.PropertyType; //Determine if we have a selector-on-hand for this data type var selectorCount = TypeMap.CountSelectors(propertyType); //We have some matching selectors, so we'll evaluate and return the best match if (selectorCount > 0) { //Evaluate all of the possible selectors and find the first available match var selector = EvaluateSelectors(property, TypeMap.GetSelectors(propertyType)); //We found a matching selector if (!(selector is MissingSelector)) { selector.Generate(targetObject, property); //Bind the property return; //Exit } } //Check to see if the type is a class and has a default constructor if (propertyType.IsClass && propertyType.GetConstructor(Type.EmptyTypes) != null) { var subProperties = propertyType.GetProperties(); //Create an instance of the underlying subclass var subClassInstance = Activator.CreateInstance(propertyType); //Match all of the properties on the subclass ProcessProperties(subProperties, subClassInstance); //Bind the sub-class back onto the original target object property.SetValue(targetObject, subClassInstance, null); return; //Exit } //Check to see if the type is an array or any other sort of collection if (typeof(IList).IsAssignableFrom(propertyType)) { //Get the underlying type used int he array var elementType = propertyType.GetElementType(); //Get a number of elements we want to create //Note: (between 0 and 10 for now) var elementCount = Numbers.Int(0, 10); //Create an instance of our target array IList arrayInstance = null; //If we're working with a generic list or any other sort of collection if (propertyType.IsGenericType) { arrayInstance = (IList)GenericHelper.CreateGeneric(propertyType, elementType); } else { arrayInstance = (IList)GenericHelper.CreateGeneric(typeof(List <>), elementType); } //Determine if there's a selector available for this type var hasSelector = TypeMap.CountSelectors(elementType) > 0; ITypeSelector selector = null; if (hasSelector) { //selector = EvaluateSelectors(ele) } for (var i = 0; i < elementCount; i++) { //Create a new element instance var element = Activator.CreateInstance(elementType); if (hasSelector) { } //If the element type is a sub-class, then populate it recursively if (elementType.IsClass) { var subProperties = propertyType.GetProperties(); //Populate all of the properties on this object ProcessProperties(subProperties, element); } arrayInstance.Add(element); } } }
private static IEnumerable <Type> SelectPotentialTypes(IEnumerable <ITypesProvider> typesProviders, ITypeSelector convention) { try { var potentialTypes = typesProviders.AsParallel().SelectMany(provider => provider.RetrieveTypes(convention)); return(potentialTypes.ToList()); } catch (AggregateException e) { throw e.FlattenTryBubbleUp(); } }
public IEnumerable <Type> RetrieveTypes(ITypeSelector selector) { return(_existingServiceCollection.Where(x => x.ImplementationType != null).Select(x => x.ImplementationType)); }
internal static void ValidateExpression <T>(ITypeSelector selector, Func <T> setter) { ExpressionValidator.IsNotNull(() => setter, setter); ExpressionValidator.IsNotNull(selector); }