public void InitTestContext() { ruleT1 = new TestRuleT1(); ruleT2 = new TestRuleT2(); ruleTN = new TestRuleTN(); ruleDependent = new OtherRuleT1(); transformation = new MockTransformation(ruleT1, ruleT2, ruleTN, ruleDependent); transformation.Initialize(); context = CreateContext(transformation); trace = context.Trace; c_a = context.CallTransformation(ruleT1, new object[] { "a" }); c_b = context.CallTransformation(ruleT1, new object[] { "b" }); c_ab = context.CallTransformation(ruleT2, new object[] { "a", "b" }); c_bc = context.CallTransformation(ruleT2, new object[] { "b", "c" }); c_abc = context.CallTransformation(ruleTN, new object[] { "a", "b", "c" }); c_bcd = context.CallTransformation(ruleTN, new object[] { "b", "c", "d" }); c_a.InitializeOutput("b"); c_b.InitializeOutput(null); c_ab.InitializeOutput("c"); c_bc.InitializeOutput(null); c_abc.InitializeOutput("d"); c_bcd.InitializeOutput(null); }
public static IEnumerable <TOut> FindWhere <TIn1, TIn2, TOut>(this ITransformationTrace trace, Predicate <TOut> filter) where TIn1 : class where TIn2 : class where TOut : class { return(FindWhere <TOut>(trace, new Type[] { typeof(TIn1), typeof(TIn2) }, filter)); }
private void AssertSimilar(FSM.FiniteStateMachine fsm, PN.PetriNet pn, ITransformationTrace trace) { Assert.AreEqual(fsm.ID, pn.ID, "The ID of the petri net is not set correctly"); Assert.AreEqual(fsm.States.Count, pn.Places.Count, "The number of places is incorrect"); Assert.AreEqual(fsm.Transitions.Count + fsm.States.Where(s => s.IsEndState).Count(), pn.Transitions.Count, "The number of transitions is incorrect"); foreach (var state in fsm.States) { var place = trace.Resolve <FSM.State, PN.Place>(state); Assert.IsNotNull(place, "A state has not been transformed"); Assert.AreEqual(state.Name, place.ID, "The name of a place has not been set correctly"); Assert.IsTrue(pn.Places.Contains(place), "A corresponding place has not been added to the states of the Petri net"); if (state.IsStartState) { Assert.AreEqual(1, place.TokenCount, "The number of tokens has not been set"); } else { Assert.AreEqual(0, place.TokenCount, "The number of tokens has not been set"); } foreach (var t in state.Transitions) { var t2 = trace.Resolve <FSM.Transition, PN.Transition>(t); Assert.IsNotNull(t2, "A transition has not been transformed"); Assert.IsTrue(pn.Transitions.Contains(t2), "A transition has not been added to the transitions of the Petri net"); } } }
private void AssertSimilar(FSM.FiniteStateMachine fsm, PN.PetriNet pn, ITransformationTrace trace) { Assert.AreEqual(fsm.ID, pn.ID, "The ID of the petri net is not set correctly"); Assert.AreEqual(fsm.States.Count, pn.Places.Count, "The number of places is incorrect"); Assert.AreEqual(fsm.Transitions.Count + fsm.States.Where(s => s.IsEndState).Count(), pn.Transitions.Count, "The number of transitions is incorrect"); foreach (var state in fsm.States) { var place = trace.Resolve<FSM.State, PN.Place>(state); Assert.IsNotNull(place, "A state has not been transformed"); Assert.AreEqual(state.Name, place.ID, "The name of a place has not been set correctly"); Assert.IsTrue(pn.Places.Contains(place), "A corresponding place has not been added to the states of the Petri net"); if (state.IsStartState) { Assert.AreEqual(1, place.TokenCount, "The number of tokens has not been set"); } else { Assert.AreEqual(0, place.TokenCount, "The number of tokens has not been set"); } foreach (var t in state.Transitions) { var t2 = trace.Resolve<FSM.Transition, PN.Transition>(t); Assert.IsNotNull(t2, "A transition has not been transformed"); Assert.IsTrue(pn.Transitions.Contains(t2), "A transition has not been added to the transitions of the Petri net"); } } }
/// <summary> /// Creates a new transformation context for the given transformation /// </summary> /// <param name="transformation">The transformation, a context should be generated for</param> public TransformationContext(Transformation transformation) { if (transformation == null) { throw new ArgumentNullException("transformation"); } Transformation = transformation; trace = new TransformationContextTrace(this); }
public static IEnumerable <TOut> FindAllIn <TOut>(this ITransformationTrace trace, TransformationRuleBase <TOut> rule) where TOut : class { if (trace == null) { throw new ArgumentNullException("trace"); } return(trace.TraceAllIn(rule).Select(c => c.Output as TOut)); }
/// <summary> /// Finds all outputs of computations of from the specified source type to the specified target type that match the given filter /// </summary> /// <param name="trace">The trace component that is used as basis</param> /// <typeparam name="TOut">The output type of the transformation rule</typeparam> /// <param name="filter">The filter that should be applied to the transformation outputs</param> /// <param name="inputTypes">The input types for the transformation rule</param> /// <returns>A collection with all suitable outputs</returns> public static IEnumerable <TOut> FindWhere <TOut>(this ITransformationTrace trace, Type[] inputTypes, Predicate <TOut> filter) where TOut : class { if (trace == null) { throw new ArgumentNullException("trace"); } return(trace.TraceAll(inputTypes, typeof(TOut)).Select(c => c.Output as TOut).Where(o => filter == null || filter(o))); }
public static IEnumerable <TOut> FindInWhere <TOut>(this ITransformationTrace trace, TransformationRuleBase <TOut> rule, Predicate <TOut> filter) where TOut : class { if (trace == null) { throw new ArgumentNullException("trace"); } return(trace.TraceAllIn(rule).Select(c => c.Output as TOut).Where(o => filter == null || filter(o))); }
/// <summary> /// Trace the output of the computation that transformed any input that matches the filter with the given transformation type /// </summary> /// <param name="trace">The trace component that is used as basis</param> /// <typeparam name="TOut">The output that is returned by the transformation rule</typeparam> /// <returns>All outputs of computations</returns> /// <param name="inputTypes">The input types of the trace request</param> public static IEnumerable <TOut> FindAll <TOut>(this ITransformationTrace trace, Type[] inputTypes) where TOut : class { if (trace == null) { throw new ArgumentNullException("trace"); } return(from Computation c in trace.TraceAll(inputTypes, typeof(TOut)) select c.Output as TOut); }
/// <summary> /// Trace the output of the computation that transformed any input that matches the filter with the given transformation type /// </summary> /// <param name="trace">The trace component that is used as basis</param> /// <param name="rule">The transformation rule that was used to transform the outputs</param> /// <param name="filter">The filter that should filter the inputs</param> /// <returns>All outputs of computations with suitable input arguments or null, if there are none</returns> public static IEnumerable <object> ResolveInWhere(this ITransformationTrace trace, GeneralTransformationRule rule, Predicate <ITraceEntry> filter) { if (trace == null) { throw new ArgumentNullException("trace"); } return(from ITraceEntry c in trace.TraceAllIn(rule) where filter == null || filter(c) select c.Output); }
/// <summary> /// Trace the output of the computation that transformed the given input with the given transformation type /// </summary> /// <param name="rule">The rule that transformed the argument</param> /// <param name="input">The input arguments</param> /// <param name="trace">The trace component that is used as basis</param> /// <returns>The output of the computation with the specified input argument or null, if there is none such</returns> public static object ResolveIn(this ITransformationTrace trace, GeneralTransformationRule rule, object[] input) { if (trace == null) { throw new ArgumentNullException("trace"); } var comp = trace.TraceIn(rule, input).FirstOrDefault(); return(comp != null ? comp.Output : null); }
public static IEnumerable <TOut> FindAll <TIn, TOut>(this ITransformationTrace trace) where TOut : class where TIn : class { if (trace == null) { throw new ArgumentNullException("trace"); } return(trace.TraceAll(new Type[] { typeof(TIn) }, typeof(TOut)).Select(c => c.Output as TOut)); }
public static IEnumerable <ITraceEntry> TraceInWhere <TIn>(this ITransformationTrace trace, GeneralTransformationRule <TIn> rule, Predicate <TIn> filter) where TIn : class { if (trace == null) { throw new ArgumentNullException("trace"); } return(from ITraceEntry c in trace.TraceAllIn(rule) where filter == null || filter(c.GetInput(0) as TIn) select c); }
public static TOut ResolveIn <TOut>(this ITransformationTrace trace, TransformationRuleBase <TOut> rule, object[] input) where TOut : class { if (trace == null) { throw new ArgumentNullException("trace"); } var comp = trace.TraceIn(rule, input).FirstOrDefault(); return(comp != null ? comp.Output as TOut : null); }
public static IEnumerable <TOut> ResolveMany <TIn, TOut>(this ITransformationTrace trace, TIn input) where TIn : class where TOut : class { if (trace == null) { throw new ArgumentNullException("trace"); } return(from ITraceEntry c in trace.Trace(input) select c.Output as TOut); }
public static IEnumerable <TOut> ResolveWhere <TOut>(this ITransformationTrace trace, Type[] inputTypes, Predicate <object[]> filter) where TOut : class { if (trace == null) { throw new ArgumentNullException("trace"); } return(from ITraceEntry c in trace.TraceAll(inputTypes, typeof(TOut)) where filter == null || filter(c.CreateInputArray()) select c.Output as TOut); }
public static TOut Resolve <TIn, TOut>(this ITransformationTrace trace, TIn input) where TIn : class where TOut : class { if (trace == null) { throw new ArgumentNullException("trace"); } var comp = trace.Trace(input).FirstOrDefault(); return(comp != null ? comp.Output as TOut : null); }
public static IEnumerable <TOut> ResolveWhere <TIn, TOut>(this ITransformationTrace trace, Predicate <TIn> filter) where TIn : class where TOut : class { if (trace == null) { throw new ArgumentNullException("trace"); } return(from ITraceEntry c in trace.TraceAll(new Type[] { typeof(TIn) }, typeof(TOut)) where filter == null || filter(c.GetInput(0) as TIn) select c.Output as TOut); }
public static IEnumerable <TOut> ResolveInWhere <TIn1, TIn2, TOut>(this ITransformationTrace trace, TransformationRuleBase <TIn1, TIn2, TOut> rule, Func <TIn1, TIn2, bool> filter) where TIn1 : class where TIn2 : class where TOut : class { if (trace == null) { throw new ArgumentNullException("trace"); } return(from ITraceEntry c in trace.TraceAllIn(rule) where (filter == null || filter(c.GetInput(0) as TIn1, c.GetInput(1) as TIn2)) select c.Output as TOut); }
public static TOut Resolve <TIn1, TIn2, TOut>(this ITransformationTrace trace, TIn1 input1, TIn2 input2) where TIn1 : class where TIn2 : class where TOut : class { if (trace == null) { throw new ArgumentNullException("trace"); } var outputType = typeof(TOut); var comp = trace.Trace(input1, input2).FirstOrDefault(c => c.TransformationRule.OutputType == outputType); return(comp != null ? comp.Output as TOut : null); }
/// <summary> /// Trace the output of the computation that transformed any input that matches the filter with the given transformation type /// </summary> /// <param name="trace">The trace component that is used as basis</param> /// <param name="filter">The filter that should filter the inputs</param> /// <returns>All outputs of computations with suitable input arguments or null, if there are none</returns> public static IEnumerable <TOut> ResolveWhere <TIn1, TIn2, TOut>(this ITransformationTrace trace, Func <TIn1, TIn2, bool> filter) where TIn1 : class where TIn2 : class where TOut : class { if (trace == null) { throw new ArgumentNullException("trace"); } Type[] types = { typeof(TIn1), typeof(TIn2) }; return(from Computation c in trace.TraceAll(types, typeof(TOut)) where (filter == null || filter(c.GetInput(0) as TIn1, c.GetInput(1) as TIn2)) select c.Output as TOut); }
public static IEnumerable <TOut> ResolveMany <TIn, TOut>(this ITransformationTrace trace, IEnumerable <TIn> list) where TIn : class where TOut : class { if (trace == null) { throw new ArgumentNullException("trace"); } if (list == null) { return(Enumerable.Empty <TOut>()); } return(from ITraceEntry c in trace.TraceMany(new Type[] { typeof(TIn) }, typeof(TOut), list.Select(input => new object[] { input })) select c.Output as TOut); }
/// <summary> /// Creates a new transformation context for the given transformation /// </summary> /// <param name="transformation">The transformation, a context should be generated for</param> public ParallelTransformationContext(Transformation transformation) { if (transformation == null) throw new ArgumentNullException("transformation"); Transformation = transformation; trace = new TransformationContextTrace(this); }
/// <summary> /// Trace the output of the computation that transformed any input that matches the filter into the desired type /// </summary> /// <param name="trace">The trace component that is used as basis</param> /// <typeparam name="TIn">The input type that is looked for</typeparam> /// <typeparam name="TOut">The desired output type</typeparam> /// <param name="list">A list of allowed input arguments</param> /// <returns>All outputs of computations with suitable input arguments or null, if there are none</returns> public static IEnumerable <TOut> ResolveMany <TIn, TOut>(this ITransformationTrace trace, params TIn[] list) where TIn : class where TOut : class { return(ResolveMany <TIn, TOut>(trace, list as IEnumerable <TIn>)); }