public ToolCoverage(
ITool tool,
ImmutableList <MeasurementPoint> measurementPoints,
ImmutableList <MeasurementPoint> measurablePoints,
NodeError nodeError)
{
Tool = tool;
PercentCoverage = (double)measurablePoints.Count / measurementPoints.Count;
MeasurementPoints = measurementPoints;
MeasurablePoints = measurablePoints;
NodeError = nodeError;
}
private IEnumerator __TrySignup()
{
SetBusy(true);
API.Users.Signup(signupFullname.text, signupUsername.text, signupEmail.text, signupPassword.text)
.Then(res => {
trace("Signup Success!!!!!!");
this.Wait(1.0f, () => {
SetBusy(false);
Hide();
});
})
.Catch(err => {
NodeError nodeErr = (NodeError)err;
JSONNode data = nodeErr.json["data"];
if (data.Exists() && data["duplicates"].Exists())
{
JSONArray fields = data["duplicates"]["fields"].AsArray;
ShowError("Found duplicate user on field(s):\n" + fields.Join(", "));
}
else
{
ShowError(nodeErr.json["error"]);
traceError(nodeErr.response.text);
traceError(nodeErr.Message);
}
ShowPanel(signupPanel);
SetBusy(false);
});
while (_isBusy)
{
yield return(new WaitForSeconds(1.0f));
}
yield break;
}
private static void NotifyError(NodeRequest req, string errMessage, string text = null, JSONNode json = null)
{
//traceError("NodeJSManager - Error loading from URL: " + req.fullURL);
var err = new NodeError(req.fullURL + " : " + errMessage);
err.json = json;
err.text = text;
err.request = req;
err.response = req.res;
#if UNITY_EDITOR
if (err.Message.Contains("Generic"))
{
traceError("Error Response: " + req.www.downloadHandler.text +
"\n==========\n" + req.GetStackTrace() + "\n==========\n");
}
else
{
traceError(err.Message + "\n" + req.GetStackTrace());
}
#endif
req.promise.Reject(err);
}
public override bool Equals(object obj)
{
NodeError NE = obj as NodeError;
return((NE == null) ? base.Equals(obj):NE.type == type);
}
public override Action GetStepAction(CancellationToken cancel)
{
return(() =>
{
var sourceFile = Unit.SourceFile;
// verify that the source file exists
if (!sourceFile.Exists)
{
Unit.AddError <NodeError>(string.Format(ErrorMessages.E_0006_Compiler_InvalidSourceFile, sourceFile.Name));
if (Context.AbortOnError)
{
return;
}
}
if (cancel.IsCancellationRequested)
{
throw new OperationCanceledException(cancel);
}
// parse
try
{
if (Unit.Parser == null)
{
lock (this)
{
if (Unit.Parser == null)
{
Unit.Parser = new ApteridParser(handle_left_recursion: true);
}
}
}
var parser = Unit.Parser;
parser.SourceFile = sourceFile;
sourceFile.Parser = parser;
var result = parser.GetMatch(sourceFile.Buffer, parser.ApteridSource);
sourceFile.MatchResult = result;
sourceFile.MatchState = result.MatchState;
if (cancel.IsCancellationRequested)
{
throw new OperationCanceledException(cancel);
}
if (result.Success)
{
// check for error sections
sourceFile.ParseTree = result.Result;
var errorSections = sourceFile.GetNodes <Parse.Syntax.ErrorSection>();
foreach (var es in errorSections)
{
var error = new NodeError
{
SourceFile = sourceFile,
Message = ErrorMessages.E_0007_Parser_SyntaxError,
ErrorNode = es,
ErrorIndex = es.StartIndex
};
Unit.AddError(error);
}
}
else
{
var error = new NodeError
{
SourceFile = sourceFile,
Message = result.Error,
ErrorIndex = result.ErrorIndex
};
Unit.AddError(error);
}
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception e)
{
Unit.AddError(new NodeError {
Exception = e
});
}
});
}
public MeasurementSetNodeResult(NodeError nodeError, IImmutableList <MeasurementSetNode> measurementSetNodes)
{
NodeError = nodeError;
MeasurementSetNodes = measurementSetNodes;
}
