public TestActor <T> TestActorFor <T>(Definition definition)
{
var redefinition = Definition.Has(
definition.Type,
definition.Parameters(),
TestMailbox.Name,
definition.ActorName);
try
{
return(ActorProtocolFor <T>(
redefinition,
definition.ParentOr(World.DefaultParent),
null,
null,
definition.Supervisor,
definition.LoggerOr(World.DefaultLogger)).ToTestActor());
}
catch (Exception e)
{
World.DefaultLogger.Log($"vlingo-net/actors: FAILED: {e.Message}", e);
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
return(null);
}
}
public Protocols ActorFor(Definition definition, Type[] protocols)
=> new Protocols(ActorProtocolFor(
definition,
protocols,
definition.ParentOr(World.DefaultParent),
definition.Supervisor,
definition.LoggerOr(World.DefaultLogger)));
/// <summary>
/// Answers a <c>Protocols</c> that provides one or more supported <paramref name="protocols"/> for the
/// newly created <c>Actor</c> according to <paramref name="definition"/>.
/// </summary>
/// <param name="definition">The <c>Definition</c> providing parameters to the <c>Actor</c>.</param>
/// <param name="protocols">The array of protocol that the <c>Actor</c> supports.</param>
/// <returns>A <see cref="Protocols"/> instance.</returns>
public Protocols ActorFor(Definition definition, Type[] protocols)
{
var all = ActorProtocolFor(
definition,
protocols,
definition.ParentOr(World.DefaultParent),
definition.Supervisor,
definition.LoggerOr(World.DefaultLogger));
return(new Protocols(ActorProtocolActor <object> .ToActors(all)));
}
public T ActorFor <T>(Definition definition, Address address)
{
var actor = ActorProtocolFor <T>(
definition,
definition.ParentOr(World.DefaultParent),
address,
null,
definition.Supervisor,
definition.LoggerOr(World.DefaultLogger));
return(actor.ProtocolActor);
}
public T ActorThunkFor <T>(Definition definition, IAddress?address)
{
var actorMailbox = AllocateMailbox(definition, address, null);
var actor =
ActorProtocolFor <T>(
definition,
definition.ParentOr(World.DefaultParent),
address,
actorMailbox,
definition.Supervisor,
definition.LoggerOr(World.DefaultLogger));
return(actor !.ProtocolActor);
}
/// <summary>
/// Answers the <typeparamref name="T"/> protocol of the newly created <c>Actor</c> that implements the protocol and
/// that will be assigned the specific <paramref name="address"/> and <paramref name="address"/>.
/// </summary>
/// <typeparam name="T">The protocol</typeparam>
/// <param name="definition">The <c>Definition</c> used to initialize the newly created <c>Actor</c>.</param>
/// <param name="address">The <c>IAddress</c> to assign to the newly created <c>Actor</c>.</param>
/// <param name="logger">The <c>ILogger</c> to assign to the newly created <c>Actor</c>.</param>
/// <returns>The <c>Actor</c> as <typeparamref name="T"/>.</returns>
public T ActorFor <T>(Definition definition, IAddress address, ILogger logger)
{
var actorAddress = AllocateAddress(definition, address);
var actorMailbox = AllocateMailbox(definition, actorAddress, null);
var actor = ActorProtocolFor <T>(
definition,
definition.ParentOr(World.DefaultParent),
actorAddress,
actorMailbox,
definition.Supervisor,
logger);
return(actor.ProtocolActor);
}
internal Actor RawLookupOrStart(Definition definition, IAddress address)
{
var actor = Directory.ActorOf(address);
if (actor != null)
{
return(actor);
}
try
{
return(CreateRawActor(definition, definition.ParentOr(World.DefaultParent), address, null, definition.Supervisor, World.DefaultLogger));
}
catch (ActorAddressAlreadyRegisteredException)
{
return(RawLookupOrStart(definition, address));
}
}
internal Protocols TestActorFor(Definition definition, Type[] protocols)
{
var redefinition = Definition.Has(
definition.Type,
definition.Parameters(),
TestMailbox.Name,
definition.ActorName);
var all = ActorProtocolFor(
redefinition,
protocols,
definition.ParentOr(World.DefaultParent),
null,
null,
definition.Supervisor,
definition.LoggerOr(World.DefaultLogger));
return(new Protocols(ActorProtocolActor <object> .ToTestActors(all, protocols)));
}
public T ActorFor <T>(Definition definition, ILogger logger)
=> ActorFor <T>(
definition,
definition.ParentOr(World.DefaultParent),
definition.Supervisor,
logger);
public T ActorFor <T>(Definition definition)
=> ActorFor <T>(
definition,
definition.ParentOr(World.DefaultParent),
definition.Supervisor,
definition.LoggerOr(World.DefaultLogger));
