public static IEnumerable <TestCaseData> ProjectMessageWithoutTokenCases()
{
var task = TaskFactory();
//Match
var message1 = new object();
var handler1 = new ProjectionHandler <CallRecordingConnection>(
typeof(object),
(connection, message, token) =>
{
connection.RecordCall(1, message, token);
return(task);
});
var resolver1 = new ProjectionHandlerResolver <CallRecordingConnection>(message => new[] { handler1 });
yield return(new TestCaseData(
resolver1,
message1,
new[]
{
new Tuple <int, object, CancellationToken>(1, message1, CancellationToken.None),
}));
//Mismatch
var message2 = new object();
var resolver2 = new ProjectionHandlerResolver <CallRecordingConnection>(message => new ProjectionHandler <CallRecordingConnection> [0]);
yield return(new TestCaseData(
resolver2,
message2,
new Tuple <int, object, CancellationToken> [0]));
//Multimatch
var message3 = new object();
var handler3 = new ProjectionHandler <CallRecordingConnection>(
typeof(object),
(connection, message, token) =>
{
connection.RecordCall(3, message, token);
return(task);
});
var handler4 = new ProjectionHandler <CallRecordingConnection>(
typeof(object),
(connection, message, token) =>
{
connection.RecordCall(4, message, token);
return(task);
});
var resolver3 = new ProjectionHandlerResolver <CallRecordingConnection>(message => new[] { handler3, handler4 });
yield return(new TestCaseData(
resolver3,
message3,
new[]
{
new Tuple <int, object, CancellationToken>(3, message3, CancellationToken.None),
new Tuple <int, object, CancellationToken>(4, message3, CancellationToken.None)
}));
}
public void Handle(ProjectionHandler <TMessage> projectionHandler)
{
while (_pipes.Count > 0)
{
var pipe = _pipes.Pop();
projectionHandler = pipe(projectionHandler);
}
_registerHandler(new ProjectionHandlerRegistration(typeof(ProjectionHandler <TMessage>), projectionHandler));
}
private void SetMembers(EngineManager engineState)
{
this.EngineState = engineState;
AreaCompPolyHandler = new AreaCompPolyHandler(EngineState);
DefCompPolyHandler = new DefinitiveCompPolyHandler(EngineState);
_entityBuilder = new EntityBuilder(this);
BumpersHandler = new BumpersHandler(this);
_rocketsHandler = new RocketsHandler(this);
ProjectionHandler = new ProjectionHandler(this);
}
public void ParametersArePreservedAsProperties()
{
var message = typeof(object);
Func <object, object, CancellationToken, Task> handler = (_, __, ___) => Task.FromResult <object>(null);
var sut = new ProjectionHandler <object>(message, handler);
Assert.That(sut.Message, Is.EqualTo(message));
Assert.That(sut.Handler, Is.EqualTo(handler));
}
public void ComposeProjectionHandlers()
{
// Compose projection handlers, which save snapshots of the projections to our store, improving performance when we have many events
var invProjectionHandler = new ProjectionHandler <InventoryItemListProjection>(new ProjectionRepository <InventoryItemListProjection>(new ReadEventStore(EventStorage), InventoryItemListProjectionStore));
Mediator.RegisterHandler <InventoryItemCreated>(invProjectionHandler.Handle);
var invDetailProjectionHandler = new ProjectionHandler <InventoryItemDetailsProjection>(new ProjectionRepository <InventoryItemDetailsProjection>(new ReadEventStore(EventStorage), InventoryItemDetailsProjectionStore));
Mediator.RegisterHandler <InventoryItemCreated>(invDetailProjectionHandler.Handle);
Mediator.RegisterHandler <ItemsCheckedInToInventory>(invDetailProjectionHandler.Handle);
}
public void HandlersAreCopiedOnConstruction()
{
var handler1 = new ProjectionHandler <object>(
typeof(object),
(_, __, ___) => TaskFactory());
var handler2 = new ProjectionHandler <object>(
typeof(object),
(_, __, ___) => TaskFactory());
var sut = new AnonymousProjectionBuilder <object>(new[]
{
handler1,
handler2
});
var result = sut.Build();
Assert.That(result, Is.EquivalentTo(new[]
{
handler1, handler2
}));
}
public static List <List <IntPoint> > GetDelPolysOfMe(BumperEntityPoly me, List <CompEntityPoly> adders)
{
List <List <IntPoint> > allDels = new List <List <IntPoint> >();
if (adders == null)
{
return(allDels);
}
if (adders.Count == 0)
{
return(allDels);
}
foreach (CompEntityPoly adder in adders)
{
if (adder != me)
{
//if (!(compEntityPoly is BumperEntityPoly))
{
List <List <IntPoint> > newDelPolys = new List <List <IntPoint> >();
if (adder is BumperEntityPoly)
{
var adderBump = adder as BumperEntityPoly;
if (EntraSolver.IsPolyOperation(me.GetDefPoly(),
adderBump.GetAreaPoly(),
ClipType.ctIntersection))
{
newDelPolys =
me.EntraAgentSimple.ProjectionHandler.ProjectCompOntoBumper(
adderBump.PositionXNACenter2D, me);
EntraDrawer.DrawIntoFile(newDelPolys);
}
}
else
{
if (EntraSolver.IsPolyOperation(me.GetDefPoly(),
adder.GetAreaPoly(), ClipType.ctIntersection))
{
newDelPolys =
me.EntraAgentSimple.ProjectionHandler.ProjectCompOntoBumper(
adder.PositionXNACenter2D, me);
EntraDrawer.DrawIntoFile(newDelPolys);
if (adder is RocketEntityPoly)
{
var rocket = adder as RocketEntityPoly;
ProjectionHandler.ReAddRocketTrajectoryMissingAreas(
rocket,
me, ref newDelPolys);
var dir = (rocket.CompObj as RocketCarrierService).Dir;
if (dir == Direction.North ||
dir == Direction.NorthEast ||
dir == Direction.NorthWest)
{
newDelPolys = new List <List <IntPoint> >();
}
}
else
{
if (adder is RopeEntityPoly)
{
List <BumperEntityPoly> allBumps =
me.EntraAgentSimple.AllCompsEntities.FindAll(delegate(CompEntityPoly obj)
{ return(obj is BumperEntityPoly); })
.ConvertAll(input => input as BumperEntityPoly);
List <List <BumperEntityPoly> > groups =
BumpersHandler.GroupizeCloseBumpers(allBumps);
if (IsBumperCloseToAnother(me, allBumps))
{
if (IsOnCutSide(me, adder as RopeEntityPoly, groups) || groups.Count == 0)
{
ProjectionHandler.ReAddBlowerBubbleRopeTrajectoryMissingAreas(
adder.PositionXNACenter2D,
me, ref newDelPolys);
}
else
{
var bumperCutSide = FindCutSideBumper(me,
adder as
RopeEntityPoly,
groups);
if (bumperCutSide != null)
{
ProjectionHandler.ReAddInverseCutPolygon(
adder.PositionXNACenter2D,
bumperCutSide, ref newDelPolys);
}
}
}
else
{
ProjectionHandler.ReAddBlowerBubbleRopeTrajectoryMissingAreas(
adder.PositionXNACenter2D,
me, ref newDelPolys);
}
}
else
{
ProjectionHandler.ReAddBlowerBubbleRopeTrajectoryMissingAreas(
adder.PositionXNACenter2D,
me, ref newDelPolys);
}
}
}
}
EntraDrawer.DrawIntoFile(newDelPolys);
allDels.AddRange(newDelPolys);
//result = BumpersHandler.GetDelPolysIntersection(result);
//if (result == null)
//{
// result = new List<List<IntPoint>>();
//}
}
}
}
allDels = BumpersHandler.GetDelPolysIntersection(allDels) ?? new List <List <IntPoint> >();
return(allDels);
}
public static IEnumerable <TestCaseData> ProjectMessagesWithoutTokenCases()
{
var task = TaskFactory();
//Partial match
var handler1 = new ProjectionHandler <CallRecordingConnection>(
typeof(string),
(connection, message, token) =>
{
connection.RecordCall(1, message, token);
return(task);
});
var resolver1 = Resolve.WhenEqualToHandlerMessageType(new[] { handler1 });
yield return(new TestCaseData(
resolver1,
new object[] { "123", 123 },
new[]
{
new Tuple <int, object, CancellationToken>(1, "123", CancellationToken.None)
}));
//Mismatch
var resolver2 = Resolve.WhenEqualToHandlerMessageType(new ProjectionHandler <CallRecordingConnection> [0]);
yield return(new TestCaseData(
resolver2,
new object[] { new object(), 123 },
new Tuple <int, object, CancellationToken> [0]));
//Multimatch
var message3 = new object();
var message4 = new object();
var handler3 = new ProjectionHandler <CallRecordingConnection>(
typeof(object),
(connection, message, token) =>
{
connection.RecordCall(1, message, token);
return(task);
});
var handler4 = new ProjectionHandler <CallRecordingConnection>(
typeof(object),
(connection, message, token) =>
{
connection.RecordCall(2, message, token);
return(task);
});
var resolver3 = Resolve.WhenEqualToHandlerMessageType(new[] { handler3, handler4 });
yield return(new TestCaseData(
resolver3,
new object[] { message3, message4 },
new[]
{
new Tuple <int, object, CancellationToken>(1, message3, CancellationToken.None),
new Tuple <int, object, CancellationToken>(2, message3, CancellationToken.None),
new Tuple <int, object, CancellationToken>(1, message4, CancellationToken.None),
new Tuple <int, object, CancellationToken>(2, message4, CancellationToken.None)
}));
//Multitype Match
var handler5 = new ProjectionHandler <CallRecordingConnection>(
typeof(string),
(connection, message, token) =>
{
connection.RecordCall(1, message, token);
return(task);
});
var handler6 = new ProjectionHandler <CallRecordingConnection>(
typeof(int),
(connection, message, token) =>
{
connection.RecordCall(2, message, token);
return(task);
});
var resolver4 = Resolve.WhenEqualToHandlerMessageType(new[] { handler5, handler6 });
yield return(new TestCaseData(
resolver4,
new object[] { "123", 123 },
new[]
{
new Tuple <int, object, CancellationToken>(1, "123", CancellationToken.None),
new Tuple <int, object, CancellationToken>(2, 123, CancellationToken.None)
}));
//Match
var message5 = new object();
var handler7 = new ProjectionHandler <CallRecordingConnection>(
typeof(object),
(connection, message, token) =>
{
connection.RecordCall(1, message, token);
return(task);
});
var handler8 = new ProjectionHandler <CallRecordingConnection>(
typeof(object),
(connection, message, token) =>
{
connection.RecordCall(2, message, token);
return(task);
});
var resolver5 = Resolve.WhenEqualToHandlerMessageType(new[] { handler7, handler8 });
yield return(new TestCaseData(
resolver5,
new object[] { message5 },
new[]
{
new Tuple <int, object, CancellationToken>(1, message5, CancellationToken.None),
new Tuple <int, object, CancellationToken>(2, message5, CancellationToken.None)
}));
}
