public InstanceSubscriptionBuilder(object instance, Func<UnsubscribeAction, ISubscriptionReference> referenceFactory) { _instance = instance; _connector = InstanceConnectorCache.GetInstanceConnector(instance.GetType()); _referenceFactory = referenceFactory; }
public InstanceSubscriptionBuilder(object instance, Func <UnsubscribeAction, ISubscriptionReference> referenceFactory) { _instance = instance; _connector = InstanceConnectorCache.GetInstanceConnector(instance.GetType()); _referenceFactory = referenceFactory; }
public InstanceSubscriptionBuilder(object instance, ReferenceFactory referenceFactory) { _instance = instance; _connector = InstanceConnectorCache.GetInstanceConnector(instance.GetType()); _referenceFactory = referenceFactory; }
/// <summary> /// Connects any consumers for the component to the message dispatcher /// </summary> /// <param name="bus"></param> /// <param name="instance"></param> public static UnsubscribeAction SubscribeInstance([NotNull] this IServiceBus bus, [NotNull] object instance) { Guard.AgainstNull(instance, "instance", "A null instance cannot be subscribed"); InstanceConnector connector = InstanceConnectorCache.GetInstanceConnector(instance.GetType()); return(bus.Configure(x => connector.Connect(x, instance))); }
private void ReturnValue(InstanceConnector connector, object source, object target, Scope scope) { var @return = (Return)target; @return.Value = source is Parameter ? (source as Parameter).Name : (source as Operator).Result; }
/// <summary> /// Connects any consumers for the component to the message dispatcher /// </summary> /// <typeparam name="T">The consumer type</typeparam> /// <param name="bus"></param> /// <param name="instance"></param> public static UnsubscribeAction SubscribeInstance <T>([NotNull] this IServiceBus bus, [NotNull] T instance) where T : class { Guard.AgainstNull(instance, "instance", "A null instance cannot be subscribed"); InstanceConnector connector = InstanceConnectorCache.GetInstanceConnector <T>(); return(bus.Configure(x => connector.Connect(x, instance))); }
/// <summary> /// Subscribe a component to the pipeline that handles every message /// </summary> /// <typeparam name="TComponent"></typeparam> /// <param name="pipeline">The pipeline to configure</param> /// <param name="instance">The instance that will handle the messages</param> /// <returns></returns> public static UnsubscribeAction ConnectInstance <TComponent>(this IInboundMessagePipeline pipeline, TComponent instance) where TComponent : class { return(pipeline.Configure(x => { InstanceConnector connector = InstanceConnectorCache.GetInstanceConnector <TComponent>(); return connector.Connect(x, instance); })); }
private static void FooInput(InstanceConnector input, object source, object target, Scope scope) { var bar = source as InstanceBar; var foo = target as InstanceFoo; Assert.IsNotNull(source); Assert.IsNotNull(target); foo.Callers.Add(bar); }
private static void BarOutput(InstanceConnector output, InstanceConnection <SyntaxNode> connection, Scope scope) { Assert.IsNotNull(connection.OutputNode); Assert.IsNotNull(connection.InputNode); Assert.IsInstanceOfType(connection.InputNode, typeof(ExpressionSyntax)); Assert.IsInstanceOfType(connection.OutputNode, typeof(ExpressionSyntax)); scope.AddInstanceInitializer(FooInputInit.Get( connection.Source, CSharp.ParseExpression('"' + connection.Input.Id + '"'), CSharp.BinaryExpression(SyntaxKind.EqualsExpression, (ExpressionSyntax)connection.InputNode, (ExpressionSyntax)connection.OutputNode))); }
public IInstanceMatch <TNode> input(InstanceConnector connector, Action <InstanceConnector, object, object, Scope> dt, Action <InstanceConnector, InstanceConnection <TNode>, Scope> transform) { var id = connector.Id; if (_input.ContainsKey(id)) { throw new InvalidOperationException("duplicate input"); } if (dt != null) { _dataTransform[connector] = dt; } if (transform != null) { _nodeTransform[connector] = transform; } _input[id] = connector; return(this); }
public void A_consumer_with_consumes_all_interfaces_is_inspected() { _factory = new InstanceConnector <CorrelatedConsumer>(); }
private static void BarOutput(InstanceConnector output, InstanceConnection<SyntaxNode> connection, Scope scope) { Assert.IsNotNull(connection.OutputNode); Assert.IsNotNull(connection.InputNode); Assert.IsInstanceOfType(connection.InputNode, typeof(ExpressionSyntax)); Assert.IsInstanceOfType(connection.OutputNode, typeof(ExpressionSyntax)); scope.AddInstanceInitializer(FooInputInit.Get( connection.Source, CSharp.ParseExpression('"' + connection.Input.Id + '"'), CSharp.BinaryExpression(SyntaxKind.EqualsExpression, (ExpressionSyntax)connection.InputNode, (ExpressionSyntax)connection.OutputNode))); }
public TNode transform(IDictionary <string, object> instances, IEnumerable <Connection> connections, Scope scope) { Debug.Assert(_transform != null); //match var namedInstances = new Dictionary <string, Instance <TNode> >(); foreach (var i in instances) { Debug.Assert(i.Value != null); foreach (var mt in _mt) { var match = mt.Key; var transform = mt.Value; if (match(i.Key, i.Value, scope)) { var instance = new Instance <TNode> { Id = i.Key, Value = i.Value }; namedInstances[instance.Id] = instance; Debug.Assert(instance.Transform == null); instance.Transform = transform; } } } //apply connections, save foreach (var connection in connections) { var source = null as Instance <TNode>; var target = null as Instance <TNode>; if (!namedInstances.TryGetValue(connection.Source, out source)) { //td: error, invalid source continue; } if (!namedInstances.TryGetValue(connection.Target, out target)) { //td: error, invalid source continue; } var outputDT = null as Action <InstanceConnector, object, object, Scope>; var outputTransform = null as Action <InstanceConnector, InstanceConnection <TNode>, Scope>; var output = source.Transform.output(connection.OutputConnector, out outputDT, out outputTransform); if (output == null) { output = new InstanceConnector { Id = connection.OutputConnector } } ; var inputDT = null as Action <InstanceConnector, object, object, Scope>; var inputTransform = null as Action <InstanceConnector, InstanceConnection <TNode>, Scope>; var input = target.Transform.input(connection.InputConnector, out inputDT, out inputTransform); if (input == null) { input = new InstanceConnector { Id = connection.InputConnector } } ; var iconn = new InstanceConnection <TNode>() { Source = source.Id, Output = output, OutputModel = source.Value, OutputModelNode = source.Node, Target = target.Id, Input = input, InputModel = target.Value, InputModelNode = target.Node, }; if (outputDT != null) { outputDT(iconn.Output, iconn.InputModel, iconn.OutputModel, scope); } if (inputDT != null) { inputDT(iconn.Input, iconn.OutputModel, iconn.InputModel, scope); } iconn.InputTransform = inputTransform; iconn.OutputTransform = outputTransform; source.Connections.Add(iconn); target.Connections.Add(iconn); } foreach (var instance in namedInstances.Values) { transformInstance(instance, scope); } foreach (var instance in namedInstances.Values) { foreach (var conn in instance.Connections) { bool isInput = instance.Id == conn.Target; var inputInstance = instance; var outputInstance = instance; if (isInput) { outputInstance = namedInstances[conn.Target]; applyConnection(conn, outputInstance, isInput, conn.InputTransform, scope); } else { inputInstance = namedInstances[conn.Source]; applyConnection(conn, inputInstance, isInput, conn.OutputTransform, scope); } } } if (_hasErrors) { return(default(TNode)); } var items = new Dictionary <string, Tuple <object, TNode> >(); foreach (var item in namedInstances) { items[item.Key] = new Tuple <object, TNode>(item.Value.Value, item.Value.Node); } return(_transform(items, scope)); }