public ICompletes <int> Port()
{
if (!_actor.IsStopped)
{
Action <IServerRequestResponseChannel> cons1657589136 = __ => __.Port();
var completes = new BasicCompletes <int>(_actor.Scheduler);
if (_mailbox.IsPreallocated)
{
_mailbox.Send(_actor, cons1657589136, completes, PortRepresentation4);
}
else
{
_mailbox.Send(
new LocalMessage <IServerRequestResponseChannel>(_actor,
cons1657589136, completes, PortRepresentation4));
}
return(completes);
}
else
{
_actor.DeadLetters?.FailedDelivery(new DeadLetter(_actor, PortRepresentation4));
}
return(null !);
}
public Vlingo.Common.ICompletes <int> Port()
{
if (!this.actor.IsStopped)
{
Action <Vlingo.Wire.Fdx.Bidirectional.IServerRequestResponseChannel> cons1657589136 = __ => __.Port();
var completes = new BasicCompletes <int>(this.actor.Scheduler);
if (this.mailbox.IsPreallocated)
{
this.mailbox.Send(this.actor, cons1657589136, completes, PortRepresentation4);
}
else
{
this.mailbox.Send(
new LocalMessage <Vlingo.Wire.Fdx.Bidirectional.IServerRequestResponseChannel>(this.actor,
cons1657589136, completes, PortRepresentation4));
}
return(completes);
}
else
{
this.actor.DeadLetters.FailedDelivery(new DeadLetter(this.actor, PortRepresentation4));
}
return(null !);
}
public ICompletes <UserState> WithName(
Name name)
{
if (!_actor.IsStopped)
{
Action <IUser> cons128873 = __ => __.WithName(name);
var completes = new BasicCompletes <UserState>(_actor.Scheduler);
if (_mailbox.IsPreallocated)
{
_mailbox.Send(_actor, cons128873, completes, WithNameRepresentation2);
}
else
{
_mailbox.Send(new LocalMessage <IUser>(_actor,
cons128873, completes, WithNameRepresentation2));
}
return(completes);
}
else
{
_actor.DeadLetters?.FailedDelivery(new DeadLetter(_actor, WithNameRepresentation2));
}
return(null);
}
public ICompletes <IEntry> ReadNext(string fromId)
{
if (!_actor.IsStopped)
{
Action <IStateStoreEntryReader> cons128873 = __ => __.ReadNext(fromId);
var completes = new BasicCompletes <IEntry>(_actor.Scheduler);
if (_mailbox.IsPreallocated)
{
_mailbox.Send(_actor, cons128873, completes, ReadNextRepresentation3);
}
else
{
_mailbox.Send(
new LocalMessage <IStateStoreEntryReader>(_actor,
cons128873, completes, ReadNextRepresentation3));
}
return(completes);
}
else
{
_actor.DeadLetters?.FailedDelivery(new DeadLetter(_actor, ReadNextRepresentation3));
}
return(null !);
}
public ICompletes <bool> StartUp()
{
if (!_actor.IsStopped)
{
Action <IServer> cons128873 = __ => __.StartUp();
var completes = new BasicCompletes <bool>(_actor.Scheduler);
if (_mailbox.IsPreallocated)
{
_mailbox.Send(_actor, cons128873, completes, StartUpRepresentation7);
}
else
{
_mailbox.Send(new LocalMessage <IServer>(_actor, cons128873, completes,
StartUpRepresentation7));
}
return(completes);
}
else
{
_actor.DeadLetters?.FailedDelivery(new DeadLetter(_actor, StartUpRepresentation7));
}
return(null !);
}
public ICompletes <string> SeekTo(string id)
{
if (!_actor.IsStopped)
{
Action <IStateStoreEntryReader> cons128873 = __ => __.SeekTo(id);
var completes = new BasicCompletes <string>(_actor.Scheduler);
if (_mailbox.IsPreallocated)
{
_mailbox.Send(_actor, cons128873, completes, SeekToRepresentation7);
}
else
{
_mailbox.Send(
new LocalMessage <IStateStoreEntryReader>(_actor,
cons128873, completes, SeekToRepresentation7));
}
return(completes);
}
else
{
_actor.DeadLetters?.FailedDelivery(new DeadLetter(_actor, SeekToRepresentation7));
}
return(null !);
}
public void TestThatFailureOutcomeFailsWhenScheduledInMiddle()
{
var andThenValue = 0;
var failedValue = -1;
var completes = new BasicCompletes <int>(new Scheduler());
completes
.AndThen(x => x * x)
.AndThen(TimeSpan.FromMilliseconds(200), 100, value => andThenValue = value * 2)
.Otherwise <int>(failedOutcome => failedValue = failedOutcome);
var thread = new Thread(() =>
{
Thread.Sleep(100);
completes.With(10);
});
thread.Start();
completes.Await();
Assert.True(completes.HasFailed);
Assert.Equal(0, andThenValue);
Assert.Equal(100, failedValue);
}
public void TestThatFailureOutcomeFailsWhenScheduledTimesOut()
{
var andThenValue = 0;
var failedValue = -1;
var completes = new BasicCompletes <int>(_testScheduler);
completes
.AndThen(TimeSpan.FromMilliseconds(1), -10, value => value * 2)
.AndThen(x => andThenValue = 100)
.Otherwise <int>(failedOutcome => failedValue = failedOutcome);
var thread = new Thread(() =>
{
Thread.Sleep(100);
completes.With(5);
});
thread.Start();
completes.Await();
Assert.True(completes.HasFailed);
Assert.Equal(0, andThenValue);
Assert.Equal(-10, failedValue);
}
internal AndThenScheduledContinuation(
BasicCompletes parent,
BasicCompletes <TAntecedentResult> antecedent,
TimeSpan timeout,
Delegate function)
: this(parent, antecedent, timeout, Optional.Empty <TResult>(), function)
{
}
public void TestCompletesAfterFluentFunction()
{
var completes = new BasicCompletes <int>(0).AndThen(value => value * 2);
completes.With(5);
Assert.Equal(10, completes.Outcome);
}
internal override void InnerInvoke(BasicCompletes completedCompletes)
{
if (TimedOut.Get() || executed.Get())
{
return;
}
base.InnerInvoke(completedCompletes);
executed.Set(true);
}
public void TestCompletesAfterSupplier()
{
var completes = new BasicCompletes <int>(0);
completes.After(() => completes.Outcome * 2);
completes.With(5);
Assert.Equal(10, completes.Outcome);
}
public void TestThatAwaitTimesOut()
{
var completes = new BasicCompletes <int>(_testScheduler);
var completed = completes.Await(TimeSpan.FromMilliseconds(10));
completes.With(5);
Assert.NotEqual(5, completed);
Assert.Equal(default, completed);
public void TestCompletesAfterConsumer()
{
int andThenValue = 0;
var completes = new BasicCompletes <int>(0);
completes.AndThen(x => andThenValue = x);
completes.With(5);
Assert.Equal(5, andThenValue);
}
public void TestThatExceptionOutcomeInvalidCast()
{
var completes = new BasicCompletes <string>(_testScheduler);
completes
.AndThen("-100", value => (2 * int.Parse(value)).ToString())
.AndThen(x => int.Parse(x))
.Otherwise <int>(x => 1000);
Assert.Throws <InvalidCastException>(() => completes.With("-100"));
}
internal override bool InnerInvoke(BasicCompletes completedCompletes)
{
if (TimedOut.Get() || _executed.Get())
{
return(false);
}
base.InnerInvoke(completedCompletes);
_executed.Set(true);
return(true);
}
internal AndThenScheduledContinuation(
BasicCompletes?parent,
BasicCompletes <TAntecedentResult> antecedent,
TimeSpan timeout,
Optional <TResult> failedOutcomeValue,
Delegate function)
: base(parent, antecedent, failedOutcomeValue, function)
{
this.timeout = timeout;
ClearTimer();
StartTimer();
}
public void TestCompletesAfterAndThen()
{
int andThenValue = 0;
var completes = new BasicCompletes <int>(0);
completes
.AndThen(value => value * 2)
.AndThen(x => andThenValue = x);
completes.With(5);
Assert.Equal(10, andThenValue);
}
internal AndThenScheduledContinuation(
Scheduler scheduler,
BasicCompletes parent,
BasicCompletes <TAntecedentResult> antecedent,
TimeSpan timeout,
Delegate function)
: base(parent, antecedent, function)
{
this.scheduler = scheduler;
this.timeout = timeout;
ClearTimer();
StartTimer();
}
public void TestOutcomeBeforeTimeout()
{
int andThenValue = 0;
var completes = new BasicCompletes <int>(new Scheduler());
completes
.After(() => completes.Outcome * 2, 1000)
.AndThen(x => andThenValue = x);
completes.With(5);
Assert.Equal(10, andThenValue);
}
internal override void InnerInvoke(BasicCompletes completedCompletes)
{
if (HasException.Get())
{
return;
}
if (Action is Action invokableAction)
{
invokableAction();
return;
}
if (Action is Action <TResult> invokableActionInput)
{
if (completedCompletes is AndThenContinuation <TResult, TResult> andThenContinuation)
{
invokableActionInput(andThenContinuation.FailedOutcomeValue.Get());
OutcomeKnown.Set();
return;
}
}
if (Action is Func <ICompletes <TAntecedentResult>, TResult> funcCompletes)
{
OutcomeValue.Set(funcCompletes(antecedent));
OutcomeKnown.Set();
return;
}
if (Action is Func <TAntecedentResult, TResult> function)
{
if (completedCompletes is AndThenContinuation <TResult, TAntecedentResult> andThenContinuation)
{
OutcomeValue.Set(function(andThenContinuation.FailedOutcomeValue.Get()));
OutcomeKnown.Set();
return;
}
if (completedCompletes is BasicCompletes <TAntecedentResult> otherwiseContinuation)
{
OutcomeValue.Set(function(otherwiseContinuation.FailedOutcomeValue.Get()));
OutcomeKnown.Set();
return;
}
}
base.InnerInvoke(completedCompletes);
throw new InvalidCastException("Cannot run 'Otherwise' function. Make sure that expecting type is the same as failedOutcomeValue type");
}
public void TestOutcomeBeforeTimeout()
{
int andThenValue = 0;
var completes = new BasicCompletes <int>(new Scheduler());
completes
.AndThen(TimeSpan.FromMilliseconds(1000), value => value * 2)
.AndThen(x => andThenValue = x);
completes.With(5);
completes.Await <int>(TimeSpan.FromMilliseconds(10));
Assert.Equal(10, andThenValue);
}
public void TestCompletesAfterAndThenAndThen()
{
var andThenValue = string.Empty;
var completes = new BasicCompletes <int>(0);
completes
.AndThen(value => value * 2)
.AndThen(value => value.ToString())
.AndThen(x => andThenValue = x);
completes.With(5);
Assert.Equal("10", andThenValue);
}
public void TestCompletesAfterAndThenMessageOut()
{
int andThenValue = 0;
var completes = new BasicCompletes <int>(0);
var sender = new Sender(x => andThenValue = x);
completes
.AndThen(value => value * 2)
.AndThen(x => { sender.Send(x); return(x); });
completes.With(5);
Assert.Equal(10, andThenValue);
}
internal override bool InnerInvoke(BasicCompletes completedCompletes)
{
if (Action is Func <Exception, TResult> function)
{
if (completedCompletes is BasicCompletes <TResult> basicCompletes)
{
OutcomeValue.Set(function(basicCompletes.Exception !));
return(true);
}
}
Action.DynamicInvoke(completedCompletes.Exception);
return(true);
}
public void TestTimeoutBeforeOutcome()
{
int andThenValue = 0;
var completes = new BasicCompletes <int>(new Scheduler());
completes
.After(() => completes.Outcome * 2, 1, 0)
.AndThen(x => andThenValue = x);
Thread.Sleep(1000);
completes.With(5);
Assert.NotEqual(10, andThenValue);
Assert.Equal(0, andThenValue);
}
public void TestThatNestedRecoverFromWithNoExceptionSetsOutput()
{
var failureValue = -1;
var completes = new BasicCompletes <int>(_testScheduler);
completes
.AndThenTo(42, value => Completes.WithSuccess(value * 2).RecoverFrom(e => 0))
.RecoverFrom(e => failureValue = int.Parse(e.Message));
completes.With(2);
completes.Await();
Assert.False(completes.HasFailed);
Assert.Equal(-1, failureValue);
Assert.Equal(4, completes.Outcome);
}
public void TestThatAwaitCompletes()
{
var completes = new BasicCompletes <int>(new Scheduler());
var thread = new Thread(new ThreadStart(() =>
{
Thread.Sleep(100);
completes.With(5);
}));
thread.Start();
var completed = completes.Await <int>();
Assert.Equal(5, completed);
}
public void TestThatExceptionOutcomeFails()
{
int failureValue = -1;
var completes = new BasicCompletes <int>(new Scheduler());
completes
.AndThen(42, value => value * 2)
.AndThen <int>(value => throw new ApplicationException((2 * value).ToString()))
.RecoverFrom(e => failureValue = int.Parse(e.Message));
completes.With(2);
completes.Await <int>();
Assert.True(completes.HasFailed);
Assert.Equal(8, failureValue);
}
public void TestThatFailureOutcomeFails()
{
int andThenValue = -1, failureValue = 0;
var completes = new BasicCompletes <int>(new Scheduler());
completes
.AndThen(-100, value => 2 * value)
.AndThen(x => andThenValue = x)
.Otherwise(x => failureValue = 1000);
completes.With(-100);
completes.Await <int>();
Assert.True(completes.HasFailed);
Assert.Equal(-1, andThenValue);
Assert.Equal(1000, failureValue);
}
