public bool ClearError(SensorError error)
{
if (!error.ProgramaticallyClearable)
{
return(false);
}
if (!this._errorCollection.UserNotifyError.Contains(error))
{
return(true);
}
bool flag = false;
foreach (SensorError clearError in (IEnumerable <SensorError>) this._command.ClearError(error).ClearedError.UserNotifyError)
{
if (this._errorCollection.UserNotifyError.Contains(clearError))
{
this._errorCollection.Remove(clearError);
}
if (clearError.Equals((object)error))
{
flag = true;
}
}
if (flag)
{
this.RaiseErrorStatusChangedEvent((object)this, (ErrorDetectedEventArgs) new ConcreteErrorDetectedEventArgs());
}
return(flag);
}
static internal Exception CheckAndThrowException(int error, string msg)
{
SensorError e = (SensorError)error;
switch (e)
{
case SensorError.None:
return(null);
case SensorError.IOError:
return(new InvalidOperationException("I/O Error: " + msg));
case SensorError.InvalidParameter:
return(new ArgumentException("Invalid Parameter: " + msg));
case SensorError.NotSupported:
return(new NotSupportedException("Not Supported: " + msg));
case SensorError.PermissionDenied:
return(new UnauthorizedAccessException("Permission Denied: " + msg));
case SensorError.OutOfMemory:
return(new InvalidOperationException("Out of Memory: " + msg));
case SensorError.NotNeedCalibration:
return(new InvalidOperationException("Sensor doesn't need calibration: " + msg));
case SensorError.OperationFailed:
return(new InvalidOperationException("Operation Failed: " + msg));
default:
return(new InvalidOperationException("Unknown Error Code: " + msg));
}
}
public IClearErrorResult ClearError(SensorError clearError)
{
IClearErrorResult clearErrorResult = this._command.ClearError(clearError);
this.VerifyCommandResponse((ICauseError)clearErrorResult);
return(clearErrorResult);
}
public void Remove(SensorError clearError)
{
if (!this._errors.Contains(clearError))
{
return;
}
this._errors.Remove(clearError);
}
public void Yes_Should_Be_Error_1()
{
// Act
var error = new SensorError();
// Assert
error.ToXElement().ToString(SaveOptions.DisableFormatting).Should().Be("<error>1</error>");
}
public unsafe IClearErrorResult ClearError(SensorError clearTargetError)
{
WorkSpace workSpace = TcpCommand.GetWorkSpace(typeof(RequestForClearError));
RequestForClearError *address = (RequestForClearError *)(void *)workSpace.Address;
address->header.wCommHeaderId = (ushort)4427;
address->header.byCommandKind = (byte)12;
if (!clearTargetError.ProgramaticallyClearable)
{
throw new ArgumentException("This Error can't clear programatically.");
}
new SensorErrorCollection(clearTargetError).WriteVal(&address->header.uOption0.dwCode, &address->header.uOption1.dwCode, &address->header.uOption2.dwCode, &address->header.uOption3.dwCode);
address->header.lBodyLength = 0;
this.SendRequest(workSpace);
TcpCommand.ReleaseWorkSpace(workSpace);
WorkSpace fixedLengthReply = this.ReceiveFixedLengthReply(typeof(ReplyForClearError));
ClearErrorResult clearErrorResult = new ClearErrorResult((ReplyForClearError *)(void *)fixedLengthReply.Address);
TcpCommand.ReleaseReceiveBuffer(fixedLengthReply);
return((IClearErrorResult)clearErrorResult);
}
private void DisruptionSense(object sender, SensorError error)
{
SetText(error.ErrorMessage);
}
/// <summary>
/// Creates a new SensorErrorException based on the error value provided by
/// the sensor.
/// </summary>
/// <param name="error">
/// The error value received from the sensor.
/// </param>
public SensorErrorException(SensorError error)
{
Error = error;
}
public SensorErrorCollection(SensorError error)
{
this._errors = new List <SensorError>();
this._errors.Add(error);
}
public void ClearError(SensorError occurredError)
{
this.ErrorRepository.ClearError(occurredError);
}
