internal override MutatorsTreeBase <TData> MigratePaths <T>(ModelConfigurationNode converterTree) { var performer = new CompositionPerformer(typeof(TData), typeof(T), converterTree); var resolver = new AliasesResolver(ExtractAliases(converterTree, performer)); return(new MutatorsTree <TData>(tree, new PathFormatterWrapper(pathFormatterCollection.GetPathFormatter <T>(), pathFormatterCollection.GetPathFormatter <TData>(), converterTree, performer, resolver), pathFormatterCollection, priority)); }
private void lblRemove_Click(object sender, EventArgs e) { try { Composition temp = (Composition)lb_songs.SelectedItem; int i = 0; CompositionPerformer[] items = new CompositionPerformer[CompositionPerformer.Items.Count]; CompositionPerformer.Items.CopyTo(items); while (i < items.Length) { var cp = items[i]; if (cp.Composition == temp) { CompositionPerformer.Items.Remove(cp); } i++; } Composition.Items.Remove(((Composition)lb_songs.SelectedItem).ID); Update_labels(); pb_comp.Image = null; ListBoxRefresh(); Invalidate(); FSongs.ActiveForm.Update(); } catch { } }
private void btn_remove_Click(object sender, EventArgs e) { Performer tp = (Performer)lb_performers.SelectedItem; int i = 0; CompositionPerformer[] it = new CompositionPerformer[CompositionPerformer.Items.Count]; CompositionPerformer.Items.CopyTo(it); while (i < it.Length) { var cp = (it[i]); if ((cp).Performer == tp) { CompositionPerformer.Items.Remove(cp); } i++; } Performer.Items.Remove(((Performer)lb_performers.SelectedItem).ID); pb_performer.Image = null; if (Performer.Items.Count == 0) { lb_perfs_comps.DataSource = null; } else { lb_perfs_comps.DataSource = ((Performer)lb_performers.SelectedItem).Compositions; } ListBoxRefresh(); Invalidate(); }
public override MutatorConfiguration Mutate(Type to, Expression path, CompositionPerformer performer) { if (Validator != null) { throw new NotSupportedException(); } return(new EqualsToIfConfiguration(to, Resolve(path, performer, Condition), Resolve(path, performer, Value), Validator)); }
protected static LambdaExpression Resolve(Expression path, CompositionPerformer performer, LambdaExpression lambda) { if (lambda == null) { return(null); } var body = performer.Perform(ExpressionExtensions.ResolveAbstractPath(Expression.Lambda(path, path.ExtractParameters()), lambda).Body).CanonizeParameters(); return(body == null ? null : Expression.Lambda(body, body.ExtractParameters())); }
internal override MutatorConfiguration Mutate(Type to, Expression path, CompositionPerformer performer) { var resolvedPath = Resolve(path, performer, Path); if (resolvedPath.Body.NodeType == ExpressionType.Constant) { return(null); } return(new RequiredIfConfiguration(to, Creator, Priority, Resolve(path, performer, Condition), resolvedPath, Resolve(path, performer, Message), validationResultType)); }
private static void ExtractAliases(ModelConfigurationNode node, CompositionPerformer performer, List <KeyValuePair <Expression, Expression> > aliases) { if (node.GetMutators().Any()) { var conditionalSetters = performer.GetConditionalSetters(node.Path); if (conditionalSetters != null && conditionalSetters.Count == 1) { var setter = conditionalSetters.Single(); if (setter.Value == null) { var chains = setter.Key.CutToChains(true, true); if (chains.Length == 1) { var chain = chains.Single(); aliases.Add(new KeyValuePair <Expression, Expression>(node.Path, chain)); if (IsEachOrCurrent(node.Path)) { aliases.Add(new KeyValuePair <Expression, Expression>(Expression.Call(MutatorsHelperFunctions.CurrentIndexMethod.MakeGenericMethod(node.Path.Type), node.Path), Expression.Call(MutatorsHelperFunctions.CurrentIndexMethod.MakeGenericMethod(chain.Type), chain))); } } } } } else if (IsEachOrCurrent(node.Path)) { var conditionalSetters = performer.GetConditionalSetters(((MethodCallExpression)node.Path).Arguments.Single()); if (conditionalSetters != null && conditionalSetters.Count == 1) { var setter = conditionalSetters.Single(); if (setter.Value == null) { var chains = setter.Key.CutToChains(true, true); if (chains.Length == 1) { var chain = chains.Single(); chain = Expression.Call(MutatorsHelperFunctions.CurrentMethod.MakeGenericMethod(chain.Type.GetItemType()), chain); aliases.Add(new KeyValuePair <Expression, Expression>(Expression.Call(MutatorsHelperFunctions.CurrentIndexMethod.MakeGenericMethod(node.Path.Type), node.Path), Expression.Call(MutatorsHelperFunctions.CurrentIndexMethod.MakeGenericMethod(chain.Type), chain))); } } } } foreach (var child in node.Children) { ExtractAliases(child, performer, aliases); } }
public override MutatorConfiguration Mutate(Type to, Expression path, CompositionPerformer performer) { return(new NullifyIfConfiguration(to, Resolve(path, performer, Condition))); }
public override MutatorConfiguration Mutate(Type to, Expression path, CompositionPerformer performer) { return(new InvalidIfConfiguration(to, Creator, Priority, Resolve(path, performer, Condition), Resolve(path, performer, Message), validationResultType)); }
internal override MutatorConfiguration Mutate(Type to, Expression path, CompositionPerformer performer) { return(new DisableIfConfiguration(to, Resolve(path, performer, Condition))); }
private static List <KeyValuePair <Expression, Expression> > ExtractAliases(ModelConfigurationNode converterTree, CompositionPerformer performer) { var aliases = new List <KeyValuePair <Expression, Expression> >(); ExtractAliases(converterTree, performer, aliases); return(aliases); }
public abstract MutatorConfiguration Mutate(Type to, Expression path, CompositionPerformer performer);
public override MutatorConfiguration Mutate(Type to, Expression path, CompositionPerformer performer) { return(new StaticValidatorConfiguration(to, Creator, Name, Priority, Resolve(path, performer, Condition), Resolve(path, performer, PathToNode), Resolve(path, performer, PathToValue), validator)); }
public override MutatorConfiguration Mutate(Type to, Expression path, CompositionPerformer performer) { return(new SetArrayLengthConfiguration(to, Resolve(path, performer, Condition), Resolve(path, performer, Length))); }
private static void ExtractValidationsFromConvertersInternal(this ModelConfigurationNode node, ModelConfigurationNode validationsTree, CompositionPerformer performer) { foreach (var mutator in node.Mutators) { var equalsToConfiguration = mutator.Value as EqualsToConfiguration; if (equalsToConfiguration != null && equalsToConfiguration.Validator != null) { var path = equalsToConfiguration.Validator.PathToNode; var primaryDependencies = path.ExtractPrimaryDependencies().Select(lambda => lambda.Body); var commonPath = primaryDependencies.FindLCP(); var validationsNode = commonPath == null ? validationsTree : validationsTree.Traverse(commonPath, true); var mutatedValidator = equalsToConfiguration.Validator.Mutate(node.RootType, commonPath, performer); if (mutatedValidator != null) { validationsNode.mutators.Add(new KeyValuePair <Expression, MutatorConfiguration>(equalsToConfiguration.Validator.PathToValue.Body, mutatedValidator)); } } } foreach (var child in node.Children) { child.ExtractValidationsFromConvertersInternal(validationsTree, performer); } }
internal override MutatorConfiguration Mutate(Type to, Expression path, CompositionPerformer performer) { return(new RegexValidatorConfiguration(to, Creator, Priority, Resolve(path, performer, Path), Resolve(path, performer, Condition), Resolve(path, performer, Message), Pattern, regex, validationResultType)); }
internal override MutatorConfiguration Mutate(Type to, Expression path, CompositionPerformer performer) { return(new ConditionalAggregatorConfiguration(to, Resolve(path, performer, Condition), Name)); }
private static void Qxx(ModelConfigurationNode destTree, List <KeyValuePair <Expression, Expression> > conditionalSetters, MutatorConfiguration mutatedMutator, CompositionPerformer performer, Expression resolvedKey) { var unconditionalSetter = conditionalSetters.SingleOrDefault(pair => pair.Value == null); Expression invertedCondition = null; foreach (var setter in conditionalSetters) { var mutatedPath = setter.Key; var condition = setter.Value; if (condition == null) { continue; } Expression currentInvertedCondition = Expression.Not(condition); invertedCondition = invertedCondition == null ? currentInvertedCondition : Expression.AndAlso(invertedCondition, currentInvertedCondition); var primaryDependencies = Expression.Lambda(mutatedPath, mutatedPath.ExtractParameters()).ExtractPrimaryDependencies().Select(lambda => lambda.Body); var commonPath = primaryDependencies.FindLCP(); var destNode = commonPath == null ? destTree : destTree.Traverse(commonPath, true); destNode.mutators.Add(PurgeFilters(mutatedPath, mutatedMutator.If(Expression.Lambda(condition, condition.ExtractParameters())))); } { var mutatedPath = unconditionalSetter.Key ?? performer.Perform(resolvedKey); var primaryDependencies = Expression.Lambda(mutatedPath, mutatedPath.ExtractParameters()).ExtractPrimaryDependencies().Select(lambda => lambda.Body); var commonPath = primaryDependencies.FindLCP(); var destNode = commonPath == null ? destTree : destTree.Traverse(commonPath, true); destNode.mutators.Add(PurgeFilters(mutatedPath, invertedCondition == null ? mutatedMutator : mutatedMutator.If(Expression.Lambda(invertedCondition, invertedCondition.ExtractParameters())))); } }
private static void MigrateNode(this ModelConfigurationNode node, Type to, ModelConfigurationNode destTree, ModelConfigurationNode convertationRoot, Expression path) { var performer = new CompositionPerformer(node.RootType, to, convertationRoot); var parameters = new List <PathPrefix> { new PathPrefix(path, path.ExtractParameters().Single()) }; var abstractPathResolver = new AbstractPathResolver(parameters, false); foreach (var mutator in node.Mutators) { var mutatedMutator = mutator.Value.Mutate(to, path, performer); if (mutatedMutator == null) { continue; } var resolvedKey = abstractPathResolver.Resolve(mutator.Key); var conditionalSetters = performer.GetConditionalSetters(resolvedKey); if (conditionalSetters != null) { Qxx(destTree, conditionalSetters, mutatedMutator, performer, resolvedKey); } else { Expression mutatedPath = Expression.Constant(null); if (resolvedKey.NodeType == ExpressionType.NewArrayInit && resolvedKey.Type == typeof(object[])) { var paths = new List <Expression>(); // Mutator is set to a number of nodes foreach (var item in ((NewArrayExpression)resolvedKey).Expressions) { var mutatedItem = performer.Perform(item); if (mutatedItem.NodeType != ExpressionType.Constant || ((ConstantExpression)mutatedItem).Value != null) { paths.Add(mutatedItem); } else { // Mutator is set to a node that is either not a leaf or a leaf that is not convertible var primaryDependencies = Expression.Lambda(item, item.ExtractParameters()).ExtractPrimaryDependencies().Select(lambda => lambda.Body).ToArray(); if (primaryDependencies.Length > 1) { throw new NotSupportedException("More than one primary dependency is not supported while migrating a mutator from a non-leaf node"); } var subRoot = convertationRoot.Traverse(primaryDependencies[0], false); if (subRoot != null) { var keyLeaf = subRoot.FindKeyLeaf(); if (keyLeaf != null) { var keyLeafPath = abstractPathResolver.Resolve(keyLeaf.Path); conditionalSetters = performer.GetConditionalSetters(keyLeafPath); if (conditionalSetters != null) { paths.Add(performer.Perform(keyLeafPath)); continue; } } // The key leaf is missing or is not convertible - list all convertible subnodes var subNodes = new List <ModelConfigurationNode>(); subRoot.FindSubNodes(subNodes); paths.AddRange(subNodes.Select(subNode => performer.Perform(abstractPathResolver.Resolve(subNode.Path)))); } } } if (paths.Count > 0) { mutatedPath = Expression.NewArrayInit(typeof(object), paths.Select(exp => Expression.Convert(exp, typeof(object)))); } } else { mutatedPath = performer.Perform(resolvedKey); if (mutatedPath.NodeType == ExpressionType.Constant && ((ConstantExpression)mutatedPath).Value == null) { // Mutator is set to a node that is either not a leaf or a leaf that is not convertible var primaryDependencies = Expression.Lambda(resolvedKey, resolvedKey.ExtractParameters()).ExtractPrimaryDependencies().Select(lambda => lambda.Body).ToArray(); if (primaryDependencies.Length > 1) { throw new NotSupportedException("More than one primary dependency is not supported while migrating a mutator from a non-leaf node"); } if (primaryDependencies.Length > 0) { var subRoot = convertationRoot.Traverse(primaryDependencies[0], false); if (subRoot != null) { var keyLeaf = subRoot.FindKeyLeaf(); if (keyLeaf != null) { conditionalSetters = performer.GetConditionalSetters(abstractPathResolver.Resolve(keyLeaf.Path)); } if (conditionalSetters != null) { Qxx(destTree, conditionalSetters, mutatedMutator, performer, resolvedKey); continue; } // The key leaf is missing or is not convertible - list all convertible subnodes var subNodes = new List <ModelConfigurationNode>(); subRoot.FindSubNodes(subNodes); mutatedPath = Expression.NewArrayInit(typeof(object), subNodes.Select(subNode => Expression.Convert(performer.Perform(abstractPathResolver.Resolve(subNode.Path)), typeof(object)))); } } } } var commonPath = Expression.Lambda(mutatedPath, mutatedPath.ExtractParameters()).ExtractPrimaryDependencies().Select(lambda => lambda.Body).FindLCP(); var destNode = commonPath == null ? destTree : destTree.Traverse(commonPath, true); destNode.mutators.Add(new KeyValuePair <Expression, MutatorConfiguration>(mutatedPath, mutatedMutator)); } } }
public PathFormatterWrapper(IPathFormatter pathFormatter, IPathFormatter basePathFormatter, ModelConfigurationNode converterTree, CompositionPerformer performer, AliasesResolver resolver) { this.pathFormatter = pathFormatter; this.basePathFormatter = basePathFormatter; this.converterTree = converterTree; this.performer = performer; this.resolver = resolver; }
public override MutatorConfiguration Mutate(Type to, Expression path, CompositionPerformer performer) { return(new SetSourceArrayConfiguration(to, Resolve(path, performer, SourceArray))); }
public static void ExtractValidationsFromConverters(this ModelConfigurationNode node, ModelConfigurationNode validationsTree) { var performer = new CompositionPerformer(node.RootType, validationsTree.RootType, node); node.ExtractValidationsFromConvertersInternal(validationsTree, performer); }