internal T LookupOrStart <T>(Definition definition, IAddress address) => ActorAs <T>(ActorLookupOrStart(definition, address));
internal T LookupOrStartThunk <T>(Definition definition, IAddress?address) => ActorAs <T>(ActorLookupOrStartThunk(definition, address) !);
/// <summary>
/// Answers the <typeparamref name="T"/> protocol for the newly created <c>Actor</c> instance. (INTERNAL ONLY)
/// </summary>
/// <typeparam name="T">The protocol of the <c>Actor</c>.</typeparam>
/// <param name="definition">The definition of the <c>Actor</c>.</param>
/// <param name="parent">The <c>Actor</c> parent of this <c>Actor</c>.</param>
/// <param name="maybeSupervisor">The possible supervisor of this <c>Actor</c>.</param>
/// <param name="logger">The logger for this <c>Actor</c>.</param>
/// <returns></returns>
internal T ActorFor <T>(Definition definition, Actor?parent, ISupervisor?maybeSupervisor, ILogger logger)
{
var actor = ActorProtocolFor <T>(definition, parent, null, null, maybeSupervisor, logger);
return(actor !.ProtocolActor);
}
internal T ActorFor <T>(Expression <Func <T> > factory, Actor?parent, ISupervisor?maybeSupervisor, ILogger logger) => ActorFor <T>(Definition.Has(factory), parent, maybeSupervisor, logger);
/// <summary>
/// Start the directory scan process in search for a given Actor instance. (INTERNAL ONLY)
/// </summary>
internal void StartDirectoryScanner()
{
directoryScanner = ActorFor <IDirectoryScanner>(
Definition.Has <DirectoryScannerActor>(
Definition.Parameters(directory)));
}
public TestActor <T>?TestActorFor <T>(Type actorType, params object[] parameters) => TestActorFor <T>(Definition.Has(actorType, parameters.ToList()));
public T ActorFor <T>(Expression <Func <T> > factory, string mailboxName, string actorName, IAddress address, ILogger logger) => ActorFor <T>(Definition.Has(factory, mailboxName, actorName), address, logger);
public T ActorFor <T>(Expression <Func <T> > factory) => ActorFor <T>(Definition.Has(factory));
public T ActorFor <T>(Expression <Func <T> > factory, ILogger logger) => ActorFor <T>(Definition.Has(factory), logger);
public T ActorFor <T>(Expression <Func <T> > factory, IAddress address) => ActorFor <T>(Definition.Has(factory), address);
/// <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="logger"/>.
/// </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="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, ILogger logger)
=> ActorFor <T>(
definition,
definition.ParentOr(World.DefaultParent),
definition.Supervisor,
logger);
/// <summary> /// Answers a Mailbox for an Actor. If maybeMailbox is allocated answer it; otherwise /// answer a newly allocated Mailbox. (INTERNAL ONLY) /// </summary> /// <param name="definition">the Definition of the newly created Actor</param> /// <param name="address">the Address allocated to the Actor</param> /// <param name="maybeMailbox">the possible Mailbox</param> /// <returns></returns> private IMailbox AllocateMailbox(Definition definition, IAddress address, IMailbox maybeMailbox) => maybeMailbox ?? ActorFactory.ActorMailbox(this, address, definition);
/// <summary> /// Answers an Address for an Actor. If maybeAddress is allocated answer it; otherwise /// answer a newly allocated Address. (INTERNAL ONLY) /// </summary> /// <param name="definition">The Definition of the newly created Actor</param> /// <param name="maybeAddress">The possible address</param> /// <returns></returns> private IAddress AllocateAddress(Definition definition, IAddress maybeAddress) => maybeAddress ?? World.AddressFactory.UniqueWith(definition.ActorName);
/// <summary> /// Answers the <code>T</code> protocol of the newly created <code>Actor</code> that implements the <code>protocol</code>. /// </summary> /// <typeparam name="T">The protocol type</typeparam> /// <param name="type">The type of <code>Actor</code> to create</param> /// <param name="parameters">Constructor parameters for the <code>Actor</code></param> /// <returns></returns> public T ActorFor <T>(Type type, params object[] parameters) => ActorFor <T>(Definition.Has(type, parameters.ToList()));
/// <summary>
/// Answers a <code>Protocols</code> that provides one or more supported <paramref name="protocols"/> for the
/// newly created <code>Actor</code> according to <paramref name="definition"/>.
/// </summary>
/// <param name="protocols">Array of protocols that the <code>Actor</code> supports.</param>
/// <param name="definition">The definition providing parameters to the <code>Actor</code>.</param>
/// <param name="parent">The actor that is this actor's parent.</param>
/// <param name="maybeSupervisor">The possible supervisor of this actor.</param>
/// <param name="logger">The logger of this actor.</param>
/// <returns></returns>
public Protocols ActorFor(Type[] protocols, Definition definition, Actor parent, ISupervisor?maybeSupervisor, ILogger logger)
{
var all = ActorProtocolFor(protocols, definition, parent, maybeSupervisor, logger);
return(new Protocols(ActorProtocolActor <object> .ToActors(all)));
}
/// <summary>
/// Answers the <typeparamref name="T"/> protocol of the newly created <c>Actor</c> that implements the protocol.
/// </summary>
/// <typeparam name="T">The protocol type.</typeparam>
/// <param name="definition">The <c>Definition</c> used to initialize the newly created <c>Actor</c>.</param>
/// <returns>The <c>Actor</c> as <typeparamref name="T"/>.</returns>
public T ActorFor <T>(Definition definition)
=> ActorFor <T>(
definition,
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> with the provided <paramref name="parameters"/>. /// </summary> /// <param name="protocols">The array of protocol that the <c>Actor</c> supports.</param> /// <param name="type">The type of the <c>Actor</c> to create.</param> /// <param name="parameters">The constructor parameters.</param> /// <returns>A <see cref="Protocols"/> instance.</returns> public Protocols ActorFor(Type[] protocols, Type type, params object[] parameters) => ActorFor(protocols, Definition.Has(type, parameters.ToList()));
public T ActorFor <T>(Expression <Func <T> > factory, string actorName) => ActorFor <T>(Definition.Has(factory, actorName));
/// <summary>
/// Answers the <c>ActorProtocolActor<object>[]</c> for the newly created Actor instance. (INTERNAL ONLY)
/// </summary>
/// <param name="protocols">The protocols of the <c>Actor</c>.</param>
/// <param name="definition">The <c>Definition</c> of the <c>Actor</c>.</param>
/// <param name="parent">The <c>Actor</c> parent of this <c>Actor</c>.</param>
/// <param name="maybeSupervisor">The possible supervisor of this <c>Actor</c>.</param>
/// <param name="logger">Teh logger for this <c>Actor</c>.</param>
/// <returns></returns>
internal ActorProtocolActor <object>[] ActorProtocolFor(Type[] protocols, Definition definition, Actor parent, ISupervisor maybeSupervisor, ILogger logger)
{
AssertProtocolCompliance(protocols);
return(ActorProtocolFor(protocols, definition, parent, null, null, maybeSupervisor, logger));
}
