public override void Evaluate()
{
targetVariable = ParentContext.FindOrCreateVariable(RegexMatch.Groups[1].Value);
targetCommand = Get(RegexMatch.Groups[2].Value, ParentContext);
if (!ObjToBool(targetVariable.Value, out originalValue))
{
throw new Exception("Value type error");
}
ParentContext.Lock(this);
State = ExecutionState.DONE;
}
private void RunBlock(IEnumerable <string> block)
{
foreach (var line in block.Select(StripComment))
{
commandBuffer += line + "\n";
}
string cmd;
var lineNumber = 0;
int commandLineStart;
while (ParseNext(ref commandBuffer, out cmd, ref lineNumber, out commandLineStart))
{
try
{
Line = commandLineStart;
var cmdObj = Command.Command.Get(cmd, this, commandLineStart);
commands.Add(cmdObj);
}
catch (KOSException e)
{
if (ParentContext.FindClosestParentOfType <IContextRunProgram>() != null)
{
// Error occurs in a child of another running program
StdOut("Error in '" + e.Program.Filename + "' on line " + e.LineNumber + ": " + e.Message);
State = ExecutionState.DONE;
return;
}
// Error occurs in the top level program
StdOut("Error on line " + e.LineNumber + ": " + e.Message);
State = ExecutionState.DONE;
return;
}
catch (Exception e)
{
// Non-kos exception! This is a bug, but no reason to kill the OS
StdOut("Flagrant error on line " + lineNumber);
UnityEngine.Debug.Log("Program error");
UnityEngine.Debug.Log(e);
State = ExecutionState.DONE;
return;
}
}
if (commandBuffer.Trim() != "")
{
StdOut("End of file reached inside unterminated statement");
State = ExecutionState.DONE;
}
}
internal override void SetXML(XmlElement xml, BaseClassIfc host, Dictionary <int, XmlElement> processed)
{
base.SetXML(xml, host, processed);
if (host.StepId != ParentContext.StepId)
{
xml.AppendChild(ParentContext.GetXML(xml.OwnerDocument, "ParentContext", this, processed));
}
if (!double.IsNaN(mTargetScale))
{
xml.SetAttribute("TargetScale", mTargetScale.ToString());
}
xml.SetAttribute("TargetView", mTargetView.ToString().ToLower());
setAttribute(xml, "UserDefinedTargetView", UserDefinedTargetView);
}
public override void Evaluate()
{
String varname = RegexMatch.Groups[1].Value;
if (varname.ToUpper() == "ALL")
{
ParentContext.UnlockAll();
}
else
{
ParentContext.Unlock(varname);
}
State = ExecutionState.DONE;
}
private void ObjectDifferenceFound(object expectedValue, object actualValue, ParentContext parent)
{
var result = new MatchResult
{
Success = false,
Expected = expectedValue ?? SpecialValues.Null,
Actual = actualValue ?? SpecialValues.Null
};
if (parent != null)
{
result.Parent = parent;
}
matchResults.Add(result);
}
public MatchResult Validate(PropertyInfo propertyInfo, object actualObj,
ParentContext parentContext = null)
{
var actual = GetPropertyValue(propertyInfo, actualObj);
if (parentContext != null)
{
if (parentContext.IsRecursive(actual))
{
return(new MatchResult());
}
parentContext.ActualObj = actual;
}
return(InternalValidate(propertyInfo, actualObj, parentContext));
}
/// <summary>
/// Create a new ContextRuntime.
/// </summary>
/// <param name="serviceInjector"></param>
/// <param name="contextConfiguration">the Configuration for this context.</param>
/// <param name="parentContext"></param>
public ContextRuntime(
IInjector serviceInjector,
IConfiguration contextConfiguration,
Optional <ContextRuntime> parentContext)
{
_serviceInjector = serviceInjector;
// Note that for Service objects and handlers, we are not merging them into a separate
// class (e.g. ServiceContainer) due to the inability to allow service stacking if an instance
// of such a class were to be materialized. i.e. if a ServiceContainer object were initialized
// and a child ServiceConfiguration is submitted, when the child service injector tries to
// get the relevant handlers and services set, it will get the same set of handlers as
// previously instantiated by the parent injector, and thus will not allow the stacking
// of ServiceConfigurations.
_injectedServices = serviceInjector.GetNamedInstance <ServicesSet, ISet <object> >();
_serviceContextStartHandlers =
serviceInjector.GetNamedInstance <ContextConfigurationOptions.StartHandlers, ISet <IObserver <IContextStart> > >();
_serviceContextStopHandlers =
serviceInjector.GetNamedInstance <ContextConfigurationOptions.StopHandlers, ISet <IObserver <IContextStop> > >();
_serviceTaskStartHandlers =
serviceInjector.GetNamedInstance <TaskConfigurationOptions.StartHandlers, ISet <IObserver <ITaskStart> > >();
_serviceTaskStopHandlers =
serviceInjector.GetNamedInstance <TaskConfigurationOptions.StopHandlers, ISet <IObserver <ITaskStop> > >();
_contextInjector = serviceInjector.ForkInjector(contextConfiguration);
_contextLifeCycle = _contextInjector.GetInstance <ContextLifeCycle>();
_parentContext = parentContext;
try
{
_contextLifeCycle.Start();
}
catch (Exception e)
{
const string message = "Encountered Exception in ContextStartHandler.";
if (ParentContext.IsPresent())
{
throw new ContextStartHandlerException(
Id, Optional <string> .Of(ParentContext.Value.Id), message, e);
}
throw new ContextStartHandlerException(Id, Optional <string> .Empty(), message, e);
}
}
protected override void setJSON(JObject obj, BaseClassIfc host, SetJsonOptions options)
{
if (options.Style == SetJsonOptions.JsonStyle.Repository && string.IsNullOrEmpty(mGlobalId))
{
setGlobalId(ParserIfc.EncodeGuid(Guid.NewGuid()));
options.Encountered.Add(mGlobalId);
}
base.setJSON(obj, host, options);
obj["ParentContext"] = ParentContext.getJson(this, options);
if (!double.IsNaN(mTargetScale))
{
obj["TargetScale"] = mTargetScale.ToString();
}
obj["TargetView"] = TargetView.ToString();
setAttribute(obj, "UserDefinedTargetView", UserDefinedTargetView);
}
private DeveelDbProvider CreateProvider()
{
if (Provider == null)
{
// TODO: Get all other settings as metadata
var mappingContext = new MappingContext();
OnBuildMap(mappingContext);
var model = mappingContext.CreateModel();
Provider = ParentContext.GetQueryProvider(model);
}
return((DeveelDbProvider)Provider);
}
public override void Update(float time)
{
if (triggered)
{
targetCommand.Update(time);
if (targetCommand.State == ExecutionState.DONE)
{
ParentContext.Unlock(this);
}
}
else if (expression.IsTrue())
{
triggered = true;
targetCommand.Evaluate();
}
}
/// <summary>
/// 获取本地变量值
/// </summary>
/// <param name="name">变量名</param>
/// <param name="value">输出变量值</param>
/// <returns>是否找到本地变量</returns>
protected bool FirstLocalVariableValue(string name, out object value)
{
value = null;
var result = false;
if (LocalVariables.ContainsKey(name))
{
value = LocalVariables[name];
result = true;
}
else if (ParentContext != null)
{
result = ParentContext.FirstLocalVariableValue(name, out value);
}
return result;
}
public virtual void UnsetAll()
{
for (var i = 0; i < Variables.Count; i++)
{
var currvar = Variables.ElementAt(i);
if (!(currvar.Value is BoundVariable))
{
Variables.Remove(currvar.Key);
}
}
if (ParentContext != null)
{
ParentContext.UnsetAll();
}
}
private void ValidateActualConstraints(PropertyInfo property, object actual, ParentContext parent,
ObjectPropertyValidationModel rule)
{
var strategy = rule.GetValidationStrategy(property);
if (strategy == null)
{
return;
}
var result = strategy.Validate(property, actual, parent);
if (!result.Success)
{
PropertyDifferenceFound(result.Expected, result.Actual, result.Parent); //, result.PropertyName);
}
}
/// <summary>
/// Similar to <see cref="GetOrAddSharedExpression(Type, string, Func{Type, string, Expression}, Type)" />, except this is used when expression
/// builders want to use local variables in block expressions to store the result of some operation in the expression tree built
/// for a particular target. Reusing one local variable is more efficient than declaring the same local multiple times.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="name">The name.</param>
/// <param name="requestingType">Optional - the type of the object requesting this shared expression. If this is provided,
/// then the search for an existing shared expression will only work if the same requesting type was passed previously.</param>
/// <exception cref="InvalidOperationException">Cannot add ParameterExpression: A shared expression of a different type has already been added with the same type and name.</exception>
/// <remarks>When multiple expression trees from multiple targets are brought together into one lambda, there will
/// often be many duplicate variables which could be shared. So, if an <see cref="IExpressionBuilder" /> needs a local variable
/// for a block, instead of simply declaring it directly through the <see cref="Expression.Parameter(Type, string)" /> function,
/// it can use this function instead, which will return a previously created one if available.</remarks>
public ParameterExpression GetOrAddSharedLocal(Type type, string name, Type requestingType = null)
{
// if no sharedExpressions dictionary, then we have a parent which will handle the call for us.
if (this._sharedExpressions == null)
{
return(ParentContext.GetOrAddSharedLocal(type, name, requestingType));
}
try
{
return((ParameterExpression)GetOrAddSharedExpression(type, name, (t, s) => Expression.Parameter(t, s), requestingType));
}
catch (InvalidCastException)
{
throw new InvalidOperationException("Cannot add ParameterExpression: A shared expression of a different type has already been added with the same type and name.");
}
}
public List <MatchResult> Validate(PropertyInfo actualProperty, object actualObj, object expectedObj,
ParentContext parentContext = null)
{
var expectedProp = GetExpectedProperty(expectedObj, actualProperty);
if (StartConditions.Any() &&
StartConditions.Any(x => x.CanStrategyStart(actualProperty, actualObj, expectedObj)) ==
false)
{
return(new List <MatchResult>());
}
var expected = GetPropertyValue(expectedProp, expectedObj);
var actual = GetPropertyValue(actualProperty, actualObj);
if ((expected == null && actual != null) || (expected != null && actual == null))
{
var result = new List <MatchResult>();
var fail = new MatchResult
{
Success = false,
Expected = expected ?? SpecialValues.Null,
Actual = actual ?? SpecialValues.Null
};
if (parentContext != null)
{
fail.Parent = parentContext;
}
result.Add(fail);
return(result);
}
if (expected == null)
{
return(new List <MatchResult>());
}
if (parentContext != null)
{
if (parentContext.IsRecursive(actual))
{
return(new List <MatchResult>());
}
parentContext.ActualObj = actual;
}
return(InternalValidate(actualProperty, actualObj, expectedObj, parentContext));
}
protected override List <MatchResult> InternalValidate(PropertyInfo actualProperty, object actualObj,
object expectedObj,
ParentContext parentContext = null)
{
var expectedValue = GetPropertyValue(GetExpectedProperty(expectedObj, actualProperty), expectedObj);
var actualValue = GetPropertyValue(actualProperty, actualObj);
var listMatcher = new EntityListMatchingStrategy(parentContext);
listMatcher.PositionComparison = PositionComparison;
listMatcher.ValuesComparison = ValuesComparison;
var entityListResult = listMatcher.Compare((IList)actualValue, (IList)expectedValue);
var resultList = entityListResult.ListMatchResults;
resultList.AddRange(entityListResult.EntityMatchResults.SelectMany(x => x.MemberResults).ToList());
return(resultList);
}
public override string GetStepParameters()
{
var parameters = new List <string>();
parameters.Add(ContextIdentifier != null ? ContextIdentifier.ToStepValue() : "$");
parameters.Add(ContextType != null ? ContextType.ToStepValue() : "$");
parameters.Add("*");
parameters.Add("*");
parameters.Add("*");
parameters.Add("*");
parameters.Add(ParentContext != null ? ParentContext.ToStepValue() : "$");
parameters.Add(TargetScale != null ? TargetScale.ToStepValue() : "$");
parameters.Add(TargetView.ToStepValue());
parameters.Add(UserDefinedTargetView != null ? UserDefinedTargetView.ToStepValue() : "$");
return(string.Join(", ", parameters.ToArray()));
}
private void Flush()
{
Assert.That(Shader != null);
Assert.That(_lastTexture != null);
unsafe
{
fixed(VertexPosition2TextureColor *vertexPtr = &_vertexData[0])
fixed(ushort *indexPtr = &_indexData[0])
{
//_vertexBuffer.SubData(new Span<VertexPosition2TextureColor>(vertexPtr, _count * 4), 0);
_vertexBuffer.SubData <VertexPosition2TextureColor>((IntPtr)vertexPtr, 0, _count * 4);
//_indexBuffer.SubData(new Span<ushort>(indexPtr, _count * 6), 0);
_indexBuffer.SubData <ushort>((IntPtr)indexPtr, 0, _count * 6);
}
}
ParentContext.BindVertexBuffer(_vertexBuffer);
ParentContext.BindIndexBuffer(_indexBuffer);
ParentContext.BindShaderProgram(Shader);
ParentContext.BindTexture(0, _lastTexture);
_vertexBuffer.VertexTypeInfo.Apply(Shader);
bool prevDepthTest = ParentContext.DepthTest;
ParentContext.DepthTest = false;
GL.DrawRangeElements(PrimitiveType.Triangles,
0,
_count * 4,
_count * 6,
DrawElementsType.UnsignedShort,
IntPtr.Zero);
ParentContext.DepthTest = prevDepthTest;
unchecked
{
// Metrics._drawCalls++;
// Metrics._primitiveCount += _count * 6;
}
_count = 0;
}
/// <summary>
/// Close this context. If there is a child context, this recursively closes it before closing this context. If
/// there is an Task currently running, that will be closed.
/// </summary>
public void Dispose()
{
lock (_contextLifeCycle)
{
_contextState = ContextStatusProto.State.DONE;
if (_task.IsPresent())
{
LOGGER.Log(Level.Warning, "Shutting down an task because the underlying context is being closed.");
_task.Value.Close(null);
}
if (_childContext.IsPresent())
{
LOGGER.Log(Level.Warning, "Closing a context because its parent context is being closed.");
_childContext.Value.Dispose();
}
try
{
_contextLifeCycle.Close();
}
catch (Exception e)
{
const string message = "Encountered Exception in ContextStopHandler.";
if (ParentContext.IsPresent())
{
throw new ContextStopHandlerException(
Id, Optional <string> .Of(ParentContext.Value.Id), message, e);
}
throw new ContextStopHandlerException(Id, Optional <string> .Empty(), message, e);
}
finally
{
if (_parentContext.IsPresent())
{
ParentContext.Value.ResetChildContext();
}
foreach (var injectedService in _injectedServices.OfType <IDisposable>())
{
injectedService.Dispose();
}
}
}
}
public Variable FindVariable(string varName)
{
varName = varName.ToLower();
var v = Variables.ContainsKey(varName) ? Variables[varName] : null;
if (v == null && ParentContext != null)
{
v = ParentContext.FindVariable(varName);
}
if (v != null && Locks.ContainsKey(varName.ToUpper()))
{
v.Value = Locks[varName.ToUpper()].GetValue();
}
return(v);
}
internal List <GremlinPathStepVariable> GetGremlinStepList(GremlinVariable stopVariable = null)
{
List <GremlinPathStepVariable> gremlinStepList = ParentContext?.GetGremlinStepList(HomeVariable);
if (gremlinStepList == null)
{
gremlinStepList = new List <GremlinPathStepVariable>();
}
foreach (var step in StepList)
{
if (step == stopVariable)
{
break;
}
gremlinStepList.Add(step.GetAndPopulatePath());
}
return(gremlinStepList);
}
public override void Update(float time)
{
bool newValue;
if (!objToBool(targetVariable.Value, out newValue))
{
ParentContext.Unlock(this);
throw new Exception("Value type error");
}
if (originalValue != newValue)
{
ParentContext.Unlock(this);
targetCommand.Evaluate();
ParentContext.Push(targetCommand);
}
}
internal List <GremlinVariable> Select(string label, GremlinVariable stopVariable = null)
{
List <GremlinVariable> taggedVariableList = ParentContext?.Select(label, HomeVariable);
if (taggedVariableList == null)
{
taggedVariableList = new List <GremlinVariable>();
}
var stopIndex = stopVariable == null ? VariableList.Count : VariableList.IndexOf(stopVariable);
for (var i = 0; i < stopIndex; i++)
{
if (VariableList[i].Labels.Contains(label))
{
taggedVariableList.Add(new GremlinContextVariable(VariableList[i]));
}
else
{
if (VariableList[i].ContainsLabel(label))
{
List <GremlinVariable> subContextVariableList = VariableList[i].PopulateAllTaggedVariable(label);
foreach (var subContextVar in subContextVariableList)
{
if (subContextVar is GremlinGhostVariable)
{
var ghostVar = subContextVar as GremlinGhostVariable;
var newGhostVar = GremlinGhostVariable.Create(ghostVar.RealVariable,
ghostVar.AttachedVariable, label);
taggedVariableList.Add(newGhostVar);
}
else
{
GremlinGhostVariable newVariable = GremlinGhostVariable.Create(subContextVar,
VariableList[i], label);
taggedVariableList.Add(newVariable);
}
}
}
}
}
return(taggedVariableList);
}
protected override List <MatchResult> InternalValidate(PropertyInfo actualProperty, object actualObj,
object expectedObj,
ParentContext parentContext = null)
{
var result = new List <MatchResult>();
var actualValue = GetPropertyValue(actualProperty, actualObj);
var expectedValue = GetPropertyValue(GetExpectedProperty(expectedObj, actualProperty), expectedObj);
if (!expectedValue.Equals(actualValue))
{
result.Add(new MatchResult
{
Success = false,
Expected = expectedValue,
Actual = actualValue,
Parent = parentContext
});
}
return(result);
}
public override void Update(float time)
{
try
{
base.Update(time);
if (SelectedVolume.CheckRange())
{
EvaluateNextCommand();
signalLossWarning = false;
}
else
if (!signalLossWarning)
{
StdOut("Selected Volume has gone out of range.");
signalLossWarning = true;
}
}
catch (KOSException e)
{
if (ParentContext.FindClosestParentOfType <IContextRunProgram>() != null)
{
// Error occurs in a child of another running program
StdOut("Error in '" + e.Program.Filename + "' on line " + e.LineNumber + ": " + e.Message);
State = ExecutionState.DONE;
}
else
{
// Error occurs in the top level program
StdOut("Error on line " + e.LineNumber + ": " + e.Message);
State = ExecutionState.DONE;
}
}
catch (Exception e)
{
// Non-kos exception! This is a bug, but no reason to kill the OS
StdOut("Flagrant error on line " + EXECUTION_LINE);
UnityEngine.Debug.Log("Program error");
UnityEngine.Debug.Log(e);
State = ExecutionState.DONE;
}
}
protected override MatchResult InternalValidate(PropertyInfo propertyInfo, object actualObj,
ParentContext messagePropertyPrefix = null)
{
if (!IsDefault(GetPropertyValue(propertyInfo, actualObj)))
{
return new MatchResult
{
Success = false,
Actual = SpecialValues.Null,
Expected = SpecialValues.NotNull,
Parent = new ParentContext(messagePropertyPrefix)
{
ParentName = propertyInfo.Name
}
}
}
;
return(new MatchResult {
Success = true
});
}
public override void Evaluate()
{
String targetVolume = RegexMatch.Groups[1].Value.Trim();
int volID;
if (int.TryParse(targetVolume, out volID))
{
if (!ParentContext.SwitchToVolume(volID))
{
throw new kOSException("Volume " + volID + " not found");
}
}
else
{
if (!ParentContext.SwitchToVolume(targetVolume))
{
throw new kOSException("Volume '" + targetVolume + "' not found");
}
}
State = ExecutionState.DONE;
}
/// <summary>
/// Spawns a new context.
/// The new context will have a serviceInjector that is created by forking the one in this object with the given
/// serviceConfiguration. The contextConfiguration is used to fork the contextInjector from that new serviceInjector.
/// </summary>
/// <param name="childContextConfiguration">the new context's context (local) Configuration.</param>
/// <param name="childServiceConfiguration">the new context's service Configuration.</param>
/// <returns>a child context.</returns>
public ContextRuntime SpawnChildContext(IConfiguration childContextConfiguration, IConfiguration childServiceConfiguration)
{
lock (_contextLifeCycle)
{
if (_task.IsPresent())
{
var message =
string.Format(CultureInfo.InvariantCulture, "Attempting to spawn a child context when an Task with id '{0}' is running", _task.Value.TaskId);
var e = new InvalidOperationException(message);
Utilities.Diagnostics.Exceptions.Throw(e, LOGGER);
}
AssertChildContextNotPresent("Attempting to instantiate a child context on a context that is not the topmost active context.");
try
{
var childServiceInjector = _serviceInjector.ForkInjector(childServiceConfiguration);
var childContext = new ContextRuntime(childServiceInjector, childContextConfiguration, Optional <ContextRuntime> .Of(this));
_childContext = Optional <ContextRuntime> .Of(childContext);
return(childContext);
}
catch (Exception e)
{
Utilities.Diagnostics.Exceptions.Caught(e, Level.Error, LOGGER);
Optional <string> parentId = ParentContext.IsPresent() ?
Optional <string> .Of(ParentContext.Value.Id) :
Optional <string> .Empty();
ContextClientCodeException ex = new ContextClientCodeException(ContextClientCodeException.GetId(childContextConfiguration), parentId, "Unable to spawn context", e);
Utilities.Diagnostics.Exceptions.Throw(ex, LOGGER);
}
}
return(null);
}
protected override MatchResult InternalValidate(PropertyInfo propertyInfo, object actualObj,
ParentContext messagePropertyPrefix = null)
{
var propertyValue = GetPropertyValue(propertyInfo, actualObj);
if (propertyValue == null)
{
throw new ImproperAttributeUsageException(
"ValidateActualGreaterThanAttribute should be defined only on numeric properties");
}
var result = new MatchResult
{
Success = true,
Expected = "Greater than " + number,
Actual = propertyValue,
Parent = new ParentContext(messagePropertyPrefix)
{
ParentName = propertyInfo.Name
}
};
try
{
var doubleValue = (int)propertyValue;
if (doubleValue <= number)
{
result.Success = false;
}
}
catch (Exception e)
{
throw new ImproperAttributeUsageException(e,
"ValidateActualGreaterThanAttribute should be defined only on numeric properties");
}
return(result);
}
/// <summary>
/// Retourne le préfixe représentant ce contexte.
/// Il sera associé au nom des types dans la table des types.
/// </summary>
public string GetContextPrefix()
{
if (ParentContext == null)
{
if (Container == null)
{
return("");
}
else
{
return(Container.Name);
}
}
else
if (ParentContext.Container == Container || (Container.Name == Language.SemanticConstants.StateClass)) // TODO : fix crade à rendre propre.
{
return(ParentContext.GetContextPrefix());
}
else
{
return(ParentContext.GetContextPrefix() + Container.Name + ".");
}
}
