public OneWaySynchronizationMultipleDependency(TransformationRuleBase <TSource, TTarget> parentRule, TransformationRuleBase <TSourceDep, TTargetDep> childRule, Expression <Func <TSource, IEnumerableExpression <TSourceDep> > > leftSelector, Expression <Func <TTarget, ICollection <TTargetDep> > > rightSelector) { if (parentRule == null) { throw new ArgumentNullException("parentRule"); } if (childRule == null) { throw new ArgumentNullException("childRule"); } if (leftSelector == null) { throw new ArgumentNullException("leftSelector"); } if (rightSelector == null) { throw new ArgumentNullException("rightSelector"); } this.parentRule = parentRule; this.childRule = childRule; this.__sourceGetter = ExpressionCompileRewriter.Compile(leftSelector); this.__targetGetter = ExpressionCompileRewriter.Compile(rightSelector); }
public MockComputation Add <TOut>(TransformationRuleBase <TOut> transformationRule, object[] input, TOut output) where TOut : class { var c = new MockComputation(input, transformationRule, CreateComputationContext(), output); Add(c); return(c); }
/// <summary> /// Creates a dependency to generate the code for the base classes of the current class /// </summary> /// <typeparam name="TClass">The model element type from which to generate the base class</typeparam> /// <param name="rule">The transformation rule that is used to generate the class</param> /// <param name="selector">A function used to select the model element from which to generate a base class</param> /// <returns>The transformation rule dependency</returns> public ITransformationRuleDependency RequireBaseClass <TClass>(TransformationRuleBase <TClass, CodeTypeDeclaration> rule, Func <T, TClass> selector) where TClass : class { return(Require(rule, selector, (cl, baseClass) => { var typeRef = CodeDomHelper.GetOrCreateUserItem <CodeTypeReference>(baseClass, CodeDomHelper.TypeReferenceKey, () => new CodeTypeReference()); cl.BaseTypes.Add(typeRef); })); }
public MissingItemInconsistency(ISynchronizationContext context, TransformationRuleBase <TSource, TTarget> rule, ICollection <TSource> sourceCollection, ICollection <TTarget> targetCollection, TSource source, bool isLeftMissing) { this.Context = context; this.Rule = rule; this.SourceCollection = sourceCollection; this.TargetCollection = targetCollection; this.Source = source; this.IsLeftMissing = isLeftMissing; }
public MockComputation Add <TIn1, TIn2, TOut>(TransformationRuleBase <TIn1, TIn2, TOut> transformationRule, TIn1 input1, TIn2 input2, TOut output) where TIn1 : class where TIn2 : class where TOut : class { var c = new MockComputation(new object[] { input1, input2 }, transformationRule, CreateComputationContext(), output); Add(c); return(c); }
/// <summary> /// Creates a dependency that the given subsequent model elements are transformed to types /// </summary> /// <typeparam name="TType">The model elements input type</typeparam> /// <param name="rule">The transformation rule used to generate the types</param> /// <param name="selector">A function that selects the subsequent model elements</param> /// <returns>The created transformation rule dependency</returns> public ITransformationRuleDependency RequireTypes <TType>(TransformationRuleBase <TType, CodeTypeDeclaration> rule, Func <T, IEnumerable <TType> > selector) where TType : class { return(RequireMany(rule, selector, (ns, types) => { foreach (var decl in types) { AddType(ns, decl); } })); }
/// <summary> /// Creates a new TransformationRuleSource instance for the given transformation rule in the given context /// </summary> /// <param name="rule">The transformation rule that should be used as source</param> /// <param name="context">The context in which the computations should be used by the current instance</param> public TransformationRuleSource(TransformationRuleBase <TIn, TOut> rule, ITransformationContext context) { if (rule == null) { throw new ArgumentNullException("rule"); } if (context == null) { throw new ArgumentNullException("context"); } TransformationRule = rule; Context = context; rule.Dependencies.Add(this); foreach (var c in context.Trace.TraceAllIn(rule).OfType <Computation>()) { items.Add(new TransformationComputationWrapper <TIn, TOut>(c)); } }
/// <summary> /// Creates a new computation source from a transformation rule /// </summary> /// <typeparam name="TInput">The type of the input arguments for the transformation rule</typeparam> /// <typeparam name="TOutput">The output type of the transformation rule</typeparam> /// <param name="rule">The rule that should be taken as a source of computation objects</param> /// <returns>A source of computations that can further be dealt with</returns> public static Func <ITransformationContext, INotifyEnumerable <TransformationComputationWrapper <TInput, TOutput> > > ToComputationSource <TInput, TOutput>(this TransformationRuleBase <TInput, TOutput> rule) where TInput : class where TOutput : class { if (rule == null) { throw new ArgumentNullException("rule"); } return(context => rule.ToComputationSource(context)); }
/// <summary> /// Creates a dependency to generate events from given subsequent model elements /// </summary> /// <typeparam name="TEvent">The model element type from which to generate events</typeparam> /// <param name="rule">The transformation rule to generate events</param> /// <param name="selector">The selector function that selects the model elements from which to generate events</param> /// <returns>The transformation rule dependency</returns> public ITransformationRuleDependency RequireEvents <TEvent>(TransformationRuleBase <TEvent, CodeMemberEvent> rule, Func <T, IEnumerable <TEvent> > selector) where TEvent : class { return(RequireMany(rule, selector, (cl, events) => cl.DependentMembers(true).AddRange(events))); }
/// <summary> /// Creates a dependency to generate an event from a given subsequent model element /// </summary> /// <typeparam name="TEvent">The model element type from which to generate an event</typeparam> /// <param name="rule">The transformation rule that is used to generate the event</param> /// <param name="selector">The selector function that selects the model element from which to generate an event</param> /// <returns>The transformation rule dependency</returns> public ITransformationRuleDependency RequireEvent <TEvent>(TransformationRuleBase <TEvent, CodeMemberEvent> rule, Func <T, TEvent> selector) where TEvent : class { return(Require(rule, selector, (cl, ev) => cl.DependentMembers(true).Add(ev))); }
public SynchronizationComputation(TransformationRuleBase <TIn, TOut> rule, TransformationRuleBase <TOut, TIn> reverseRule, IComputationContext context, TIn input) : base(rule, context) { Opposite = new OppositeComputation(this, reverseRule); Input = input; }
public static INotifyEnumerable <TransformationComputationWrapper <TInput, TOutput> > ToComputationSource <TInput, TOutput>(this TransformationRuleBase <TInput, TOutput> rule, ITransformationContext context, Func <TransformationComputationWrapper <TInput, TOutput>, bool> filter) where TInput : class where TOutput : class { if (rule == null) { throw new ArgumentNullException("rule"); } return(new TransformationRuleSource <TInput, TOutput>(rule, context) { Filter = filter }); }
/// <summary> /// Creates a dependency to generate a property from a given subsequent model element /// </summary> /// <typeparam name="TProp">The model element type from which to generate a property</typeparam> /// <param name="rule">The property generator</param> /// <param name="selector">The selector function that selects the model element from which to generate the property</param> /// <returns>The transformation rule dependency</returns> public ITransformationRuleDependency RequireGenerateProperty <TProp>(TransformationRuleBase <TProp, CodeMemberProperty> rule, Func <T, TProp> selector) where TProp : class { return(Require(rule, selector, persistor: (cl, prop) => cl.DependentMembers(true).Add(prop))); }
/// <summary> /// Creates a dependency that the given subsequent model element is transformed to a type /// </summary> /// <typeparam name="TType">The model element of the input type</typeparam> /// <param name="rule">The transformation rule used to generate the type</param> /// <param name="selector">A function selecting the correct subsequent model element</param> /// <returns>The created transformation rule dependency</returns> public ITransformationRuleDependency RequireType <TType>(TransformationRuleBase <TType, CodeTypeDeclaration> rule, Func <T, TType> selector) where TType : class { return(Require(rule, selector, AddType)); }
/// <summary> /// Creates a new computation source from a transformation rule /// </summary> /// <typeparam name="TInput1">The type of the first input arguments for the transformation rule</typeparam> /// <typeparam name="TInput2">The type of the second input arguments for the transformation rule</typeparam> /// <typeparam name="TOutput">The output type of the transformation rule</typeparam> /// <param name="rule">The rule that should be taken as a source of computation objects</param> /// <param name="allowNull">A boolean value indicating whether null values should be allowed</param> /// <param name="filter">A method or lambda expression to filter the computation objects</param> /// <returns>A source of computations that can further be dealt with</returns> public static Func <ITransformationContext, INotifyEnumerable <TransformationComputationWrapper <TInput1, TInput2, TOutput> > > ToComputationSource <TInput1, TInput2, TOutput>(this TransformationRuleBase <TInput1, TInput2, TOutput> rule, bool allowNull, Func <TransformationComputationWrapper <TInput1, TInput2, TOutput>, bool> filter) where TInput1 : class where TInput2 : class where TOutput : class { if (rule == null) { throw new ArgumentNullException("rule"); } return(context => rule.ToComputationSource(context, allowNull, filter)); }
public static INotifyEnumerable <TransformationComputationWrapper <TInput, TOutput> > ToComputationSource <TInput, TOutput>(this TransformationRuleBase <TInput, TOutput> rule, ITransformationContext context, bool allowNull) where TInput : class where TOutput : class { if (rule == null) { throw new ArgumentNullException("rule"); } var trs = new TransformationRuleSource <TInput, TOutput>(rule, context); if (allowNull) { trs.AddNullItem(); } return(trs); }
/// <summary> /// Creates a dependency to generate properties from subsequent model elements /// </summary> /// <typeparam name="TProp">The model element type from which to generate a property</typeparam> /// <param name="rule">The transformation rule for the property generation rule</param> /// <param name="selector">The selector function to select the subsequent model elements</param> /// <returns>The created transformation rule dependency</returns> public ITransformationRuleDependency RequireGenerateProperties <TProp>(TransformationRuleBase <TProp, CodeMemberProperty> rule, Func <T, IEnumerable <TProp> > selector) where TProp : class { return(RequireMany(rule, selector, persistor: (cl, props) => cl.DependentMembers(true).AddRange(props))); }
public OppositeComputation(SynchronizationComputation <TIn, TOut> opposite, TransformationRuleBase <TOut, TIn> rule) : base(rule, opposite) { }
/// <summary> /// Cregates a dependency to generate a method from a given subsequent model element /// </summary> /// <typeparam name="TMeth">The model element type from which to generate a method</typeparam> /// <param name="rule">The method generator</param> /// <param name="selector">The selector function that selects the model element from which to generate the method</param> /// <returns>The transformation rule dependency</returns> public ITransformationRuleDependency RequireGenerateMethod <TMeth>(TransformationRuleBase <TMeth, CodeMemberMethod> rule, Func <T, TMeth> selector) where TMeth : class { return(Require(rule, selector, (cl, meth) => cl.DependentMembers(true).Add(meth))); }
private SynchronizationComputation(TransformationRuleBase <TIn, TOut> rule, SynchronizationComputation <TOut, TIn> opposite) : base(rule, opposite.Context) { Opposite = opposite; }
/// <summary> /// Creates a dependency to generate methods from subsequent model elements /// </summary> /// <typeparam name="TMeth">The model elements type from which to generate methods</typeparam> /// <param name="rule">The method generator</param> /// <param name="selector">The selector function that selects the model elements from which to generate the methods</param> /// <returns>The transformation rule dependency</returns> public ITransformationRuleDependency RequireGenerateMethods <TMeth>(TransformationRuleBase <TMeth, CodeMemberMethod> rule, Func <T, IEnumerable <TMeth> > selector) where TMeth : class { return(RequireMany(rule, selector, (cl, methods) => cl.DependentMembers(true).AddRange(methods))); }