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);
}
