public static Continuation Folder(this IStaticSteps _,
string urlPrefix, string folder, Continuation on404)
{
on404 = on404 ?? fu.Http.NotFound();
string folderPath = null;
return step => ctx =>
{
var rawUrl = ctx.Request.Url.AbsolutePath;
folderPath = folderPath ?? ctx.ResolvePath(folder);
if (!rawUrl.StartsWith(urlPrefix)) {
on404(step)(ctx);
return;
}
var url = rawUrl.Substring(urlPrefix.Length);
var filePath = Path.Combine(folderPath, url);
if (!System.IO.File.Exists(filePath)) {
on404(step)(ctx);
return;
}
step(FileResult.From(ctx, filePath));
};
}
public static Continuation If(Reduce<bool> predicate,
Continuation trueCont, Continuation falseCont)
{
return step => ctx =>
{
if (predicate(ctx))
trueCont(step)(ctx);
else
falseCont(step)(ctx);
};
}
private static Continuation redirectStep(Continuation header, Filter<string> urlFilter)
{
return step => outerCtx =>
{
header(ctx =>
{
var targetUrl = urlFilter(ctx, ctx.Request.Url.AbsolutePath);
ctx.Response.Redirect(targetUrl);
})(outerCtx);
// step is discarded
// (we're redirecting, so no more processing should take place)
};
}
public void ContinuationChaining()
{
var o1 = new Order(false, false);
var o2 = new Order(true, false);
var o3 = new Order(true, true);
var v = new OrderValidator();
var r = new OrderRepo();
var c = new OrderConfirmationSender();
var validate = new Continuation<Order>(order => order.When(o => v.Validate(o)));
var save = new Continuation<Order>(order => order.When(o => r.Save(o)));
var send = new Continuation<Order>(order => order.Do(o => c.Send(o)));
var proc = new Continuation<Order>(
order => order.When(validate).When(save).Do(send));
proc.Execute(o1);
proc.Execute(o2);
proc.Execute(o3);
Assert.That(c.SentConfirmations.Contains(o1), Is.False);
Assert.That(c.SentConfirmations.Contains(o2), Is.False);
Assert.That(c.SentConfirmations.Contains(o3), Is.True);
}
static void Main()
{
// DateTime time1 = DateTime.Now;
int a3 = 0x3beef;
int a2 = 0x2beef;
int a1 = 0x1beef;
Continuation c = new Continuation();
int v1 = 111;
int v2 = 222;
tt(v1, v2, c, 1);
a1++;
a2++;
a3++;
tt(v1, v2, c, 2);
// DateTime time2 = DateTime.Now;
Console.WriteLine("{0:x}, {1:x}, {2:x}", a1, a2, a3);
// Console.WriteLine("total {0}", res);
// Console.WriteLine("time {0}ms", (time2 - time1).Milliseconds);
// Console.WriteLine("END");
}
public Continuation(Continuation cont, LexicalEnvironment envt, object evalStack, Template template, uint pc)
{
CONT = cont;
ENVT = envt;
EVAL_STACK = evalStack;
TEMPLATE = template;
PC = pc;
}
protected override void Map(string url,
Func<Continuation, Continuation, Continuation> wrapper,
Continuation handler)
{
handler = handler.Then(fu.Result.Render(EnableHttpCompression));
base.Map(url, wrapper, handler);
}
public static Continuation Custom(this IMapSteps _,
ContDict mappings, Reduce<string> pathReducer, Continuation on404)
{
var dict = mappings.ToDictionary(
kv => new Regex(kv.Key),
kv => kv.Value);
return _.Custom(dict, pathReducer, on404);
}
public static Continuation Hosts(this IMapSteps _,
ContDict mappings, Continuation on404)
{
var dict = mappings.ToDictionary(
kv => new Regex(kv.Key),
kv => kv.Value);
return _.Hosts(dict, on404);
}
static int tt1(Continuation c, int val)
{
Console.WriteLine("before store, {0}", val);
int ret = c.Store(0);
Console.WriteLine("after store, {0}", val);
Console.WriteLine("loop {0}", ret);
return ret;
}
public static Continuation Custom(this IMapSteps _,
ContRegexDict mappings,
Reduce<string> pathReducer, Continuation on404)
{
on404 = on404 ?? fu.Http.NotFound();
return step => ctx =>
{
var path = pathReducer(ctx);
var result = mappings
.Select(kv => new { Match = kv.Key.Match(path), Cont = kv.Value })
.FirstOrDefault(m => m.Match.Success);
if (result == null)
on404(step)(ctx);
else
result.Cont(step)(new UrlMappedContext(ctx, result.Match));
};
}
public static FSContinuation ToFSharp(Continuation cont)
{
return FuncConvert.ToFSharpFunc<FSAction, FSAction>(next =>
{
var nextAct = fu.FromFSharp(next);
nextAct = cont(nextAct);
return fu.ToFSharp(nextAct);
});
}
public override Continuation Evaluate(Continuation c, Environment env, Datum args)
{
var argList = args.ToArray();
if (argList.Length != 2)
{
throw c.error("Expected 2 arguments: (define <symbol> <expression>). Got {0} instead", argList.Length);
}
var name = argList[0].CastIdentifier();
var expression = argList[1];
c = c.PushTask(new DefineName(env, name));
return(c.Evaluate(env, expression));
}
public void ReturnsTrueIfAllContinuationsInGroupAreCompleted()
{
var continuation = new Continuation
{
Status = JobStatus.Created,
Children = new[] { new Continuation {
Status = JobStatus.Completed
} }
};
var result = continuation.CanContinue();
Assert.True(result);
}
public void ReturnsFalseIfAnyChildContinuationIsNotContinuable()
{
var continuation = new Continuation
{
Status = JobStatus.Created,
Children = new[] { new Continuation {
Status = JobStatus.Poisoned
} }
};
var result = continuation.CanContinue();
Assert.False(result);
}
public void ShouldNotReturnNextIfAllChilrenAreNotComplete()
{
var continuation = new Continuation
{
Children = new[]
{
new Continuation()
},
Next = new Continuation()
};
var pending = continuation.PendingContinuations();
Assert.DoesNotContain(continuation.Next, pending);
}
public void ReturnsNextIfAllContinuationsInGroupedIsComplete()
{
var continuation = new Continuation
{
Type = ContinuationType.Parallel,
Children = new[] { new Continuation {
Status = JobStatus.Completed
} },
Next = new Continuation()
};
var pending = continuation.PendingContinuations();
Assert.Equal(continuation.Next, pending.Single());
}
public override Continuation Evaluate(Continuation oldContinuation, Datum args)
{
// Replace the old continuation with the new continuation - but pass in the
// supplied argument as the 'return value' of the new continuation.
var argArray = args.ToArray();
// We allow calling a "continuation" with 0 args. Such a continuation
// only arises from the error function.
// TODO: we should differentiate the two with an "expected args" member which we can error check.
if (argArray.Length == 0)
{
return(c);
}
return(c.PushResult(argArray[0]));
}
public override void OnResponse(NetState sender, RelayInfo info)
{
var idx = info.ButtonID - 1;
if (idx >= 0 && idx < m_Entries.Length)
{
BodyId = m_Entries[idx].BodyId;
}
IsCompleted = true;
Continuation?.Invoke();
// Spell spell = new PolymorphSpell(m_Caster, m_Scroll, m_Entries[idx].BodyId);
// spell.Cast();
}
public Continuation Perform(Continuation c)
{
// The result datum may be a graph. This makes certain
// optimizations risky.
var expansion = c.Result;
if (macroDatum != null)
{
// Cache macro expansions. In the extremely
// common case of the same macro being used on the
// same Datum, re-use the expansion.
macroDatum.Cache = cons(macro, expansion);
}
return(c.PopResult().PopEnv().Evaluate(c.Env, expansion));
}
public void Run(bool Automatic)
{
AutomaticVerify = Automatic;
Continuation Continuation = new Continuation();
if (Automatic && Project.LastVerifyRelativePath != null && Project.LastVerifyRelativePath.Length > 0)
{
Continuation.Starting = true;
Continuation.LastRelativePath = Project.LastVerifyRelativePath;
Continuation.StartPass();
}
Run(ref Continuation);
}
public Continuation Calculate(SuperInputCalcViewModel input)
{
var continuation = new Continuation();
var model = new OverseedBagsNeededCalcViewModel();
var field = _repository.Find <Field>(Int64.Parse(input.Field));
var inventoryProduct = _repository.Find <InventoryProduct>(Int64.Parse(input.Product));
decimal bagSizeInPounds = _unitSizeTimesQuantyCalculator.CalculateLbsPerUnit(inventoryProduct);
double? bagsNeeded = ((input.SeedRate / (input.OverSeedPercent * .01)) * (Convert.ToDouble(field.Size / 1000))) / Convert.ToDouble(bagSizeInPounds);
model.BagsNeeded = Convert.ToDouble(Math.Round(Convert.ToDecimal(bagsNeeded), 2));
model.BagSize = inventoryProduct.SizeOfUnit + " " + inventoryProduct.UnitType;
model.FieldArea = field.Size.ToString();
continuation.Target = model;
return(continuation);
}
public void ContinuationWithOptionSuccess()
{
Continuation <object, int> continuation = 10;
Option <string> optionResult =
continuation
.Then(value => value % 2 == 0)
.Then(value => value ? "Even" : "Odd");
string result = optionResult.Match(
value => value,
() => string.Empty);
Assert.AreEqual(result, "Even");
}
public void ReturnsFalseIfAnyFailureHandlerIsFailed()
{
var continuation = new Continuation
{
Status = JobStatus.Poisoned,
ContinueAfterHandlingFailure = true,
OnAllFailed = new Continuation {
Status = JobStatus.Poisoned
}
};
var result = continuation.CanContinue();
Assert.False(result);
}
public Job(
Guid id,
Type type,
string method,
object[] arguments,
DateTime createdOn,
Guid?rootId = null,
Guid?parentId = null,
Guid?correlationId = null,
JobStatus status = JobStatus.Ready,
int dispatchCount = 0,
DateTime?retryOn = null,
ExceptionFilter[] exceptionFilters = null,
Continuation continuation = null,
bool?suspended = null)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (arguments == null)
{
throw new ArgumentNullException("arguments");
}
if (string.IsNullOrWhiteSpace(method))
{
throw new ArgumentException("A valid method is required.");
}
Method = method;
Id = id;
Type = type;
Arguments = arguments;
CreatedOn = createdOn;
RootId = rootId ?? id;
ParentId = parentId;
CorrelationId = correlationId ?? id;
Status = status;
DispatchCount = dispatchCount;
RetryOn = retryOn;
Properties = new Dictionary <string, object>();
ExceptionFilters = exceptionFilters ?? new ExceptionFilter[0];
Continuation = continuation;
Suspended = suspended ?? false;
}
static void Main()
{
Continuation c = new Continuation();
c.Mark();
int foo = 123;
int val = c.Store(0);
Console.WriteLine("{0} {1}", val, foo);
foo = 321;
if (val < 5)
c.Restore(val + 1);
}
public void ContinuationWithMultiplesThen()
{
Continuation <string, int> continuation = 1;
Option <int> optionResult =
continuation
.Then(value => value + 4)
.Then(value => value + 10);
int result = optionResult.Match(
value => value,
() => 0);
Assert.AreEqual(result, 15);
}
public void Should_property_manage_the_async_bits()
{
string path = Assembly.GetExecutingAssembly().Location;
var fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, true);
Continuation <string> continuation = fileStream.AsyncReadToEnd(x => { });
var result = new Future <string>();
continuation(result.Complete);
result.WaitUntilCompleted(10.Seconds()).ShouldBeTrue();
Trace.WriteLine(result.Value.Length);
}
internal void Run()
{
State = MicroThreadState.Running;
if (Continuation == null)
{
Continuation = new Continuation();
Continuation.Mark();
cb();
State = MicroThreadState.Done;
Loop.GetMicroThreadCollection().Next();
}
else
{
Continuation.Restore(1);
}
}
public override Continuation Evaluate(Continuation c, Datum args)
{
var datumArgs = args.ToArray();
if (datumArgs.Length != 2)
{
throw c.error("Apply expects 2 arguments. {0} passed", datumArgs.Length);
}
var function = datumArgs[0] as StackFunction;
if (function == null)
{
throw c.error("'{0}' is not a function", datumArgs[0]);
}
return(function.Evaluate(c, datumArgs[1]));
}
public void Yielding()
{
Continuation baseCont = new Continuation();
Continuation taskCont = new Continuation();
baseCont.Mark();
taskCont.Mark();
// Store the base continuation to start the task
if (baseCont.Store(0) == 0)
{
bool done = false;
int count = 0;
while (!done)
{
// Do stuff for the task.
++count;
// This task is counting to 100.
if (count == 100)
{
done = true;
}
// Yield every 10 loops
else if (count % 10 == 0)
{
// To yield, store the task continuation then restore
// the base continuation.
if (taskCont.Store(0) == 0)
{
baseCont.Restore(1);
}
}
}
}
// When restored, 'Store' will return what was passed to Restore, in this case 1 so fall here.
else
{
// Count the yields, then go back to the task.
++yields;
taskCont.Restore(1);
}
Assert.AreEqual(9, yields);
}
public override bool Try(TextBuffer output, BindingEnvironment e, Continuation k, MethodCallFrame predecessor)
{
var s = e.State;
var callCount = e.Frame.Task.CallCount(s);
var readyTime = ReadyTime(s);
if (callCount > readyTime)
{
var newState = ReadyTimes.SetItem(s, this, Duration == int.MaxValue ? int.MaxValue : (callCount + Duration));
if (Continue(output, new BindingEnvironment(e, e.Unifications, newState), k, predecessor))
{
return(true);
}
}
return(false);
}
public override Continuation Evaluate(Continuation c, Datum args)
{
var argArray = args.ToArray();
if (argArray.Length != 1)
{
throw DatumHelpers.error("call/cc: expect a single function as an argument. Got {0}", argArray.Length);
}
var arg = argArray[0];
var function = arg as StackFunction;
if (function == null)
{
throw DatumHelpers.error("call/cc: {0} must be a function", arg);
}
return(function.Evaluate(c, DatumHelpers.compound(new ContinuationFunction(c))));
}
public void ContinuationWithMultiplesThenOperator()
{
Continuation <string, int> continuation = 1;
Option <int> optionResult =
continuation
> (value => value + 4)
> (value => value + 10)
> (value => value * 2);
int result = optionResult.Match(
value => value,
() => 0);
Assert.AreEqual(result, 30);
}
public override Continuation Evaluate(Continuation c, LexicalEnvironment env, Datum args)
{
var argList = args.ToArray();
if (argList.Length != 2)
{
throw c.error("Expected 2 arguments: (define <symbol> <expression>). Got {0} instead", argList.Length);
}
var name = argList[0].CastSymbol();
var expression = argList[1];
c = c.PushTask(
tc => { env.Define(name, tc.Result);
return(tc); },
"define '{0}'", name);
return(c.Evaluate(env, expression));
}
public void ContinuationWithMultiplesParametersThen()
{
int extraInput = 5;
Continuation <string, int> continuation = 1;
Option <int> optionResult =
continuation
.Then(value => value + 4)
.Then <int, int>((input, value) => input + value + 10, extraInput);
int result = optionResult.Match(
value => value,
() => 0);
Assert.AreEqual(result, 20);
}
protected Continuation RhoTranslate(string rhoScript, bool trace = false, EStructure st = EStructure.Program)
{
var trans = new RhoTranslator(_Registry);
if (!trans.Translate(rhoScript, out var cont, st))
{
WriteLine($"Error: {trans.Error}");
}
if (trace)
{
WriteLine(trans.ToString());
}
Assert.IsFalse(trans.Failed, trans.Error);
return(_Continuation = cont);
}
static void Main()
{
Continuation c = new Continuation();
c.Mark();
int foo = 123;
int val = c.Store(0);
Console.WriteLine("{0} {1}", val, foo);
foo = 321;
if (val < 5)
{
c.Restore(val + 1);
}
}
public void ShouldReturnAllFailedContinuationIfAllContinuationsInGroupedIsFailed()
{
var continuation = new Continuation
{
Type = ContinuationType.Parallel,
Children = new[]
{
new Continuation {
Status = JobStatus.Poisoned
}
},
OnAllFailed = new Continuation()
};
var pending = continuation.PendingContinuations();
Assert.Equal(continuation.OnAllFailed, pending.Single());
}
public void ReturnsTrueIfAllFailureHandlersAreCompleted()
{
var continuation = new Continuation
{
Status = JobStatus.Poisoned,
ContinueAfterHandlingFailure = true,
OnAnyFailed = new Continuation {
Status = JobStatus.Completed
},
OnAllFailed = new Continuation {
Status = JobStatus.Completed
}
};
var result = continuation.CanContinue();
Assert.True(result);
}
public override bool Try(TextBuffer output, BindingEnvironment e, Continuation k, MethodCallFrame predecessor)
{
var collectionValue = e.Resolve(collectionVariable);
switch (collectionValue)
{
case Cons list:
{
return(list != Cons.Empty &&
e.Unify(element, list.First, out var bindings) &&
Continue(output,
new BindingEnvironment(e,
bindings,
e.State.Bind(collectionVariable, list.Rest)),
k, predecessor));
}
case ImmutableStack <object> stack:
{
return(!stack.IsEmpty &&
e.Unify(element, stack.Peek(), out var bindings) &&
Continue(output,
new BindingEnvironment(e,
bindings,
e.State.Bind(collectionVariable, stack.Pop())),
k, predecessor));
}
case ImmutableQueue <object> queue:
{
return(!queue.IsEmpty &&
e.Unify(element, queue.Peek(), out var bindings) &&
Continue(output,
new BindingEnvironment(e,
bindings,
e.State.Bind(collectionVariable, queue.Dequeue())),
k, predecessor));
}
default:
throw new ArgumentTypeException("removeNext", typeof(Cons), collectionValue,
new[] { "removeNext", collectionValue });
}
}
public async Task RemoveRangeAsync(IEnumerable <TResult> dtos, NotFound <TResult, int> notFound = null,
CancellationToken cancellationToken = default(CancellationToken))
{
if (dtos == null)
{
throw new ArgumentNullException(nameof(dtos));
}
var dtoArray = dtos.ToArray();
var entities = new List <T>(dtoArray.Length);
var hasError = false;
var continuation = new Continuation();
for (var index = 0; index < dtoArray.Length; index++)
{
var dto = dtoArray[index];
var entity = await _dbSet.FindAsync(GetKeyValues(dto), cancellationToken);
if (entity == null)
{
(notFound ?? NotFound).Invoke(dto, index, continuation);
hasError = true;
if (continuation.Yes)
{
continue;
}
break;
}
entities.Add(entity);
}
if (hasError)
{
return;
}
if (SoftDelete)
{
_rules.Apply(entities, DataAction.Remove);
}
else
{
_dbSet.RemoveRange(entities);
}
}
// this is expensive, but only called when continuation is invoked
static bool CheckStack(Continuation cc)
{
if (!DoCheckStack)
{
return(true);
}
var st = new StackTrace();
var c1 = cc.Stack.GetFrames();
var f1 = st.GetFrames();
if (cc.Thread != Thread.CurrentThread)
{
// can't check reliably
return(true);
}
if (IsMono)
{
// mono: for some reason the one stack is reversed... but not all the time... FFFFFUUUUUU!! 8/
if (c1[0].GetMethod().Name != "Main")
{
Array.Reverse(c1);
}
if (f1[0].GetMethod().Name != "Main")
{
Array.Reverse(f1);
}
}
else
{
Array.Reverse(c1);
Array.Reverse(f1);
}
for (int i = 0; i < c1.Length; i++)
{
if (c1[i].GetMethod() != f1[i].GetMethod())
{
return(false);
}
}
return(true);
}
public long GetNext()
{
if (m_cont == null)
{
m_cont = new Continuation();
m_cont.Mark();
for (long i = m_min; i < m_max; i++)
{
if (m_cont.Store(0) == 0)
return i;
}
return 0;
}
else
{
m_cont.Restore(1);
throw new Exception("not reached");
}
}
static void tt(int v1, int v2, Continuation c, int state)
{
if(state == 1)
{
c.Mark();
int val = tt1(c, 0);
Console.WriteLine(v1);
Console.WriteLine(v2);
v1++;
v2++;
}
else
{
tt2(c, 1);
}
}
public static Continuation Methods(this IMapSteps _,
Continuation get, Continuation put, Continuation post, Continuation delete,
Continuation on405)
{
var orDelete = _.Delete(delete, on405);
var orPut = _.Put(put, orDelete);
var orPost = _.Post(post, orPut);
return _.Get(get, orPost);
}
public static Continuation GetHead(this IMapSteps _,
Continuation getAndHead)
{
return _.GetHead(getAndHead, null);
}
public void OnCompleted(Action action)
{
Continuation newContinuation = new Continuation(action);
Continuation oldContinuation;
if (!coordinator.labels.TryGetValue(label, out oldContinuation))
{
// First time coming from this label. Always succeeds.
coordinator.labels[label] = newContinuation;
}
else
{
// Current semantics are to prohibit two different ComeFrom calls for the same label.
// An alternative would be to just replace the existing continuation with the new one,
// in which case we wouldn't need any of this - we could just use
// coordinator.labels[label] = newContinuation;
// unconditionally.
if (!oldContinuation.Equals(newContinuation))
{
throw new InvalidOperationException("Additional continuation detected for label " + label);
}
// Okay, we've seen this one before. Nothing to see here, move on.
}
// We actually want to continue from where we were: we're only really marking the
// ComeFrom point.
coordinator.stack.Push(action);
}
public static Continuation Post(this IMapSteps _,
Continuation post, Continuation on405)
{
return _.Method("POST", post, on405);
}
private void Push(Continuation continuation)
{
Debug.Assert(continuation != null);
if (_stack == null)
_stack = new Stack(6);
_stack.Push(continuation);
}
internal LabelAwaiter(Continuation continuation, Coordinator coordinator)
{
this.continuation = continuation;
this.coordinator = coordinator;
}
public static Continuation Head(this IMapSteps _,
Continuation head, Continuation on405)
{
return _.Method("HEAD", head, on405);
}
public static Continuation Method(this IMapSteps _, string method,
Continuation onMethod, Continuation on405)
{
on405 = on405 ?? fu.Http.MethodNotAllowed();
method = method.ToUpper();
return step => ctx =>
(ctx.Request.HttpMethod == method ? onMethod : on405)(step)(ctx);
}
public static Continuation GetPost(this IMapSteps _,
Continuation get, Continuation post, Continuation on405)
{
var orPost = _.Post(post, on405);
return _.Get(get, orPost);
}
public static Continuation GetPost(this IMapSteps _,
Continuation get, Continuation post)
{
return _.GetPost(get, post, null);
}
public static Continuation Delete(this IMapSteps _,
Continuation delete, Continuation on405)
{
return _.Method("DELETE", delete, on405);
}
/// <summary>
/// Yields control back to the reader's user while updating the
/// reader with the new found token, its text and the next
/// continuation point into the reader.
/// </summary>
/// <remarks>
/// By itself, this method cannot affect the stack such tha control
/// is returned back to the reader's user. This must be done by
/// Yield's caller by way of explicit return.
/// </remarks>
private JsonToken Yield(JsonToken token, Continuation continuation)
{
if (continuation != null)
_stack.Push(continuation);
return token;
}
public static Continuation Get(this IMapSteps _,
Continuation get, Continuation on405)
{
return _.Method("GET", get, on405);
}
public static Continuation Put(this IMapSteps _,
Continuation put, Continuation on405)
{
return _.Method("PUT", put, on405);
}
public static Continuation GetHead(this IMapSteps _,
Continuation getAndHead, Continuation on405)
{
var orHead = _.Head(getAndHead, on405);
return _.Get(getAndHead, orHead);
}
