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