public object alterRoot(IFn fn, ISeq args)
{
object newRoot = fn.applyTo(RT.cons(_root, args));
Validate(getValidator(), newRoot);
object oldroot = _root;
_root = newRoot;
++_rev;
NotifyWatches(oldroot, newRoot);
return(newRoot);
}
public object swap(IFn f, Object x, Object y, ISeq args)
{
for (; ;)
{
object v = deref();
object newv = f.applyTo(RT.listStar(v, x, y, args));
Validate(newv);
if (_state.CompareAndSet(v, newv))
{
NotifyWatches(v, newv);
return(newv);
}
}
}
public IPersistentVector swapVals(IFn f, object x, object y, ISeq args)
{
for (; ;)
{
object oldv = deref();
object newv = f.applyTo(RT.listStar(oldv, x, y, args));
Validate(newv);
if (_state.CompareAndSet(oldv, newv))
{
NotifyWatches(oldv, newv);
return(LazilyPersistentVector.createOwning(oldv, newv));
}
}
}
/// <summary>
/// Worker method to execute the action on a thread.
/// </summary>
/// <param name="state">(not used)</param>
/// <remarks>corresponds to doRun in Java version</remarks>
void ExecuteAction(object state)
{
try
{
Var.pushThreadBindings(RT.map(RT.AGENT, _agent));
Agent.Nested = PersistentVector.EMPTY;
bool hadError = false;
try
{
object oldval = _agent.State;
object newval = _fn.applyTo(RT.cons(_agent.State, _args));
_agent.SetState(newval);
_agent.notifyWatches(oldval, newval);
}
catch (Exception e)
{
// TODO: report/callback (Java TODO)
_agent.AddError(e);
hadError = true;
}
if (!hadError)
{
releasePendingSends();
}
bool popped = false;
IPersistentStack next = null;
while (!popped)
{
IPersistentStack prior = _agent._q.Get();
next = prior.pop();
popped = _agent._q.CompareAndSet(prior, next);
}
if (next.count() > 0)
{
((Action)next.peek()).execute();
}
}
finally
{
Nested = null;
Var.popThreadBindings();
}
}
public void AlterMeta_changes_meta()
{
MockRepository mocks = new MockRepository();
IPersistentMap meta = mocks.StrictMock <IPersistentMap>();
IFn fn = mocks.StrictMock <IFn>();
RMExpect.Call(fn.applyTo(null)).IgnoreArguments().Return(meta);
mocks.ReplayAll();
ConcreteAReference c = new ConcreteAReference();
c.alterMeta(fn, null);
Expect(c.meta(), EqualTo(meta));
mocks.VerifyAll();
}
public void step(LazyTransformer lt)
{
while (lt._stepper != null && MoveNext())
{
if (RT.isReduced(_xform.applyTo(RT.cons(lt, Current()))))
{
if (lt._rest != null)
{
lt._rest._stepper = null;
}
break;
}
}
if (lt._stepper != null)
{
_xform.invoke(lt);
}
}
private bool Step()
{
_next = NONE;
while (_next == NONE)
{
if (_buffer.IsEmpty())
{
if (_completed)
{
return(false);
}
else if (_sourceEnum.MoveNext())
{
object iter;
if (_multi)
{
iter = _xf.applyTo(RT.cons(null, _sourceEnum.Current));
}
else
{
iter = _xf.invoke(null, _sourceEnum.Current);
}
if (RT.isReduced(iter))
{
_xf.invoke(null);
_completed = true;
}
}
else
{
_xf.invoke(null);
_completed = true;
}
}
else
{
_next = _buffer.Remove();
}
}
return(true);
}
public object Eval()
{
try
{
IFn fn = (IFn)_fexpr.Eval();
IPersistentVector argvs = PersistentVector.EMPTY;
for (int i = 0; i < _args.count(); i++)
{
argvs = (IPersistentVector)argvs.cons(((Expr)_args.nth(i)).Eval());
}
return(fn.applyTo(RT.seq(Util.Ret1(argvs, argvs = null))));
}
catch (Compiler.CompilerException)
{
throw;
}
catch (Exception e)
{
throw new Compiler.CompilerException(_source, Compiler.GetLineFromSpanMap(_spanMap), Compiler.GetColumnFromSpanMap(_spanMap), e);
}
}
public void step(LazyTransformer lt)
{
while (lt._stepper != null && MoveNext())
{
if (RT.isReduced(_xform.applyTo(RT.cons(lt, Current()))))
{
lt._stepper = null;
LazyTransformer et = lt;
while (et._rest != null)
{
et = et._rest;
et._stepper = null;
}
_xform.invoke(et);
return;
}
}
if (lt._stepper != null)
{
_xform.invoke(lt);
}
}
public IPersistentMap alterMeta(IFn alter, ISeq args)
{
_meta = (IPersistentMap)alter.applyTo(new Cons(_meta, args));
return(_meta);
}
public object alterRoot(IFn fn, ISeq args)
{
object newRoot = fn.applyTo(RT.cons(_root, args));
Validate(getValidator(), newRoot);
object oldroot = _root;
_root = newRoot;
++_rev;
NotifyWatches(oldroot,newRoot);
return newRoot;
}
void ExecuteAction(object state)
{
try
{
Agent.Nested = PersistentVector.EMPTY;
Exception error = null;
try
{
object oldval = _agent.State;
object newval = _fn.applyTo(RT.cons(_agent.State, _args));
_agent.SetState(newval);
_agent.NotifyWatches(oldval, newval);
}
catch (Exception e)
{
error = e;
}
if (error == null)
{
releasePendingSends();
}
else
{
Nested = null; // allow errorHandler to send
if (_agent._errorHandler != null)
{
try
{
_agent._errorHandler.invoke(_agent, error);
}
catch (Exception)
{
// ignore error handler errors
}
}
if (_agent._errorMode == ContinueKeyword)
{
error = null;
}
}
bool popped = false;
ActionQueue next = null;
while (!popped)
{
ActionQueue prior = _agent._aq.Get();
next = new ActionQueue(prior._q.pop(), error);
popped = _agent._aq.CompareAndSet(prior, next);
}
if (error == null && next._q.count() > 0)
{
((Action)next._q.peek()).execute();
}
}
finally
{
Nested = null;
}
}
public object alter(IFn fn, ISeq args)
{
set(fn.applyTo(RT.cons(deref(), args)));
return this;
}
public IPersistentMap alterMeta(IFn alter, ISeq args)
{
_meta = (IPersistentMap)alter.applyTo(new Cons(_meta, args));
return _meta;
}
/// <summary>
/// Post a commute on a ref in this transaction.
/// </summary>
/// <param name="r">The ref.</param>
/// <param name="fn">The commuting function.</param>
/// <param name="args">Additional arguments to the function.</param>
/// <returns>The computed value.</returns>
internal object DoCommute(Ref r, IFn fn, ISeq args)
{
if (!_info.IsRunning)
throw _retryex;
if (!_vals.ContainsKey(r))
{
object val = null;
try
{
r.EnterReadLock();
val = r.TryGetVal();
}
finally
{
r.ExitReadLock();
}
_vals[r] = val;
}
List<CFn> fns;
if (! _commutes.TryGetValue(r, out fns))
_commutes[r] = fns = new List<CFn>();
fns.Add(new CFn(fn, args));
object ret = fn.applyTo(RT.cons(_vals[r], args));
_vals[r] = ret;
return ret;
}
public static void Main(string[] args)
{
new Mono.Terminal.LineEditor("#force-mono.terminal-assembly-load#");
BootClojureAndNostrand();
if (args.Length > 0)
{
AppDomain.CurrentDomain.AssemblyResolve += AssemblyResolver.Resolve;
if (File.Exists("project.edn"))
{
var projectEdn = EdnReader.readString(File.ReadAllText("project.edn"), PersistentHashMap.EMPTY);
RT.var("nostrand.core", "establish-environment").invoke(projectEdn);
}
RT.PostBootstrapInit();
var input = ReadArguments(args);
var inputString = input.first().ToString();
if (inputString.IndexOf("./", StringComparison.InvariantCulture) == 0)
{
inputString = inputString.Substring(2);
}
Var.pushThreadBindings(RT.mapUniqueKeys(RT.CurrentNSVar, Namespace.find(Symbol.intern("nostrand.core"))));
try
{
Var fn = FindFunction(inputString);
if (fn != null)
{
//referAll.invoke(fn.Namespace, nostrandCore);
fn.applyTo(input.next());
return;
}
if (File.Exists(inputString))
{
try
{
IFn mainFn = FindFunction(FileToRelativePath(inputString) + "/-main");
if (mainFn != null)
{
mainFn.applyTo(input.next());
}
return;
}
catch (FileNotFoundException)
{
}
}
Terminal.Message("Quiting", "could not find function or file named `" + args[0] + "'", ConsoleColor.Yellow);
}
finally
{
Var.popThreadBindings();
}
}
else
{
Terminal.Message("Nostrand", Version(), ConsoleColor.White);
// Terminal.Message("Mono", GetRuntimeVersion(), ConsoleColor.White);
Terminal.Message("Clojure", RT.var("clojure.core", "clojure-version").invoke(), ConsoleColor.White);
}
}
public object alter(IFn fn, ISeq args)
{
LockingTransaction t = LockingTransaction.GetEx();
return(t.DoSet(this, fn.applyTo(RT.cons(t.DoGet(this), args))));
}
public object swap(IFn f, Object x, Object y, ISeq args)
{
for (; ; )
{
object v = deref();
object newv = f.applyTo(RT.listStar(v, x, y, args));
Validate(newv);
if (_state.CompareAndSet(v, newv))
{
NotifyWatches(v, newv);
return newv;
}
}
}
public object alter(IFn fn, ISeq args)
{
set(fn.applyTo(RT.cons(deref(), args)));
return(this);
}