/// <summary>
/// Constructs a object by specifying each property.
/// </summary>
public ServiceResult(
StatusCode code,
ServiceResult innerResult)
:
this(code, null, null, null, null, innerResult)
{
}
/// <summary>
/// Checks if the status code is bad.
/// </summary>
public static bool IsBad(StatusCode statusCode)
{
if ((ToCode(statusCode) & 0x80000000) != 0)
{
return true;
}
return false;
}
/// <summary>
/// Converts a code to a numeric value.
/// </summary>
public static uint ToCode(StatusCode statusCode)
{
if (statusCode == null)
{
return StatusCodes.Good;
}
return statusCode.Code;
}
/// <summary>
/// Constructs a object by specifying each property.
/// </summary>
public ServiceResult(
StatusCode code,
string symbolicId,
string namespaceUri,
LocalizedText localizedText,
string additionalInfo)
:
this(code, symbolicId, namespaceUri, localizedText, additionalInfo, (ServiceResult)null)
{
}
/// <summary>
/// Updates the variable after receiving a notification that it has changed in the underlying system.
/// </summary>
public void OnDataChange(BaseVariableState variable, object value, StatusCode statusCode, DateTime timestamp)
{
lock (Lock)
{
variable.Value = value;
variable.StatusCode = statusCode;
variable.Timestamp = timestamp;
// notifies any monitored items that the value has changed.
variable.ClearChangeMasks(SystemContext, false);
}
}
/// <summary>
/// Constructs a object by specifying each property.
/// </summary>
public ServiceResult(
StatusCode code,
string symbolicId,
string namespaceUri,
LocalizedText localizedText,
string additionalInfo,
ServiceResult innerResult)
{
StatusCode = code;
SymbolicId = symbolicId;
NamespaceUri = namespaceUri;
LocalizedText = localizedText;
AdditionalInfo = additionalInfo;
InnerResult = innerResult;
}
/// <summary>
/// Constructs a object by specifying each property.
/// </summary>
/// <remarks>
/// The innerException is used to construct the innerResult.
/// </remarks>
public ServiceResult(StatusCode code, Exception innerException)
:
this(code, null, null, null, null, innerException)
{
}
/// <summary>
/// Constructs a object by specifying each property.
/// </summary>
/// <remarks>
/// The innerException is used to construct the innerResult.
/// </remarks>
public ServiceResult(
StatusCode code,
string symbolicId,
string namespaceUri,
Exception innerException)
:
this(code, symbolicId, namespaceUri, null, null, innerException)
{
}
/// <summary>
/// Constructs a object from a StatusCode.
/// </summary>
public ServiceResult(StatusCode status)
{
m_code = status.Code;
}
/// <summary>
/// Initializes the object with a status code.
/// </summary>
/// <remarks>
/// Initializes the object with a status code.
/// </remarks>
/// <param name="statusCode">The StatusCode to set</param>
public DataValue(StatusCode statusCode)
{
Initialize();
m_statusCode = statusCode;
}
/// <summary>
/// Adds a value to the grid.
/// </summary>
private void AddValue(DataValue value, ModificationInfo modificationInfo)
{
DataRow row = m_dataset.Tables[0].NewRow();
row[0] = m_nextId++;
row[1] = value.SourceTimestamp.ToLocalTime().ToString("HH:mm:ss.fff");
row[2] = value.WrappedValue;
row[3] = new StatusCode(value.StatusCode.Code);
if (value.WrappedValue.TypeInfo != null)
{
row[4] = value.WrappedValue.TypeInfo.BuiltInType.ToString();
}
else
{
row[4] = String.Empty;
}
m_dataset.Tables[0].Rows.Add(row);
}
/// <summary>
/// Returns true if the status is good or uncertain.
/// </summary>
/// <remarks>
/// Returns true if the status is good or uncertain.
/// </remarks>
/// <param name="code">The code to check</param>
public static bool IsNotUncertain(StatusCode code)
{
return((code.m_code & 0x40000000) != 0x40000000);
}
/// <summary>
/// Creates a new instance of a ServiceResultException
/// </summary>
public static ServiceResultException Create(StatusCode code, int index, DiagnosticInfoCollection diagnosticInfos, IList <string> stringTable)
{
return(new ServiceResultException(new ServiceResult(code, index, diagnosticInfos, stringTable)));
}
/// <summary>
/// Applies the multidimensional index range.
/// </summary>
private StatusCode ApplyMultiRange(ref object value)
{
Array array = value as Array;
TypeInfo typeInfo = null;
// check for matrix.
if (array == null)
{
Matrix matrix = value as Matrix;
if (matrix == null || matrix.Dimensions.Length != m_subranges.Length)
{
value = null;
return(StatusCodes.BadIndexRangeNoData);
}
array = matrix.ToArray();
}
typeInfo = TypeInfo.Construct(array);
// check for matching dimensions.
NumericRange?finalRange = null;
if (m_subranges.Length > typeInfo.ValueRank)
{
if (typeInfo.BuiltInType == BuiltInType.ByteString || typeInfo.BuiltInType == BuiltInType.String)
{
if (m_subranges.Length == typeInfo.ValueRank + 1)
{
finalRange = m_subranges[m_subranges.Length - 1];
}
}
if (finalRange == null)
{
value = null;
return(StatusCodes.BadIndexRangeNoData);
}
}
// create the dimensions of the target.
int[] dimensions = new int[typeInfo.ValueRank];
for (int ii = 0; ii < dimensions.Length; ii++)
{
if (m_subranges.Length > ii)
{
if (m_subranges[ii].m_begin >= array.GetLength(ii))
{
value = null;
return(StatusCodes.BadIndexRangeNoData);
}
dimensions[ii] = m_subranges[ii].Count;
}
else
{
dimensions[ii] = array.GetLength(ii);
}
}
Array subset = TypeInfo.CreateArray(typeInfo.BuiltInType, dimensions);
int length = subset.Length;
int[] dstIndexes = new int[dimensions.Length];
int[] srcIndexes = new int[dimensions.Length];
bool dataFound = false;
for (int ii = 0; ii < length; ii++)
{
int divisor = subset.Length;
bool outOfRange = false;
for (int jj = 0; jj < dstIndexes.Length; jj++)
{
divisor /= dimensions[jj];
dstIndexes[jj] = (ii / divisor) % dimensions[jj];
srcIndexes[jj] = dstIndexes[jj] + m_subranges[jj].m_begin;
if (array.GetLength(jj) <= srcIndexes[jj])
{
outOfRange = true;
break;
}
}
if (outOfRange)
{
continue;
}
object element = array.GetValue(srcIndexes);
if (element != null)
{
if (finalRange != null)
{
StatusCode result = finalRange.Value.ApplyRange(ref element);
if (StatusCode.IsBad(result))
{
if (result != StatusCodes.BadIndexRangeNoData)
{
value = null;
return(result);
}
continue;
}
}
dataFound = true;
subset.SetValue(element, dstIndexes);
}
}
if (!dataFound)
{
value = null;
return(StatusCodes.BadIndexRangeNoData);
}
value = subset;
return(StatusCodes.Good);
}
/// <summary>
/// Returns the certificate information for a trusted issuer certificate.
/// </summary>
private async Task <CertificateIdentifier> GetIssuer(
X509Certificate2 certificate,
CertificateIdentifierCollection explicitList,
CertificateStoreIdentifier certificateStore,
bool checkRecovationStatus)
{
string subjectName = certificate.IssuerName.Name;
string keyId = null;
string serialNumber = null;
// find the authority key identifier.
X509AuthorityKeyIdentifierExtension authority = FindAuthorityKeyIdentifier(certificate);
if (authority != null)
{
keyId = authority.KeyId;
serialNumber = authority.SerialNumber;
}
// check in explicit list.
if (explicitList != null)
{
for (int ii = 0; ii < explicitList.Count; ii++)
{
X509Certificate2 issuer = await explicitList[ii].Find(false);
if (issuer != null)
{
if (!IsIssuerAllowed(issuer))
{
continue;
}
if (Match(issuer, subjectName, serialNumber, keyId))
{
// can't check revocation.
return(new CertificateIdentifier(issuer, CertificateValidationOptions.SuppressRevocationStatusUnknown));
}
}
}
}
// check in certificate store.
if (certificateStore != null)
{
ICertificateStore store = certificateStore.OpenStore();
try
{
X509Certificate2Collection certificates = await store.Enumerate();
for (int ii = 0; ii < certificates.Count; ii++)
{
X509Certificate2 issuer = certificates[ii];
if (issuer != null)
{
if (!IsIssuerAllowed(issuer))
{
continue;
}
if (Match(issuer, subjectName, serialNumber, keyId))
{
CertificateValidationOptions options = certificateStore.ValidationOptions;
// already checked revocation for file based stores. windows based stores always suppress.
options |= CertificateValidationOptions.SuppressRevocationStatusUnknown;
if (checkRecovationStatus)
{
StatusCode status = store.IsRevoked(issuer, certificate);
if (StatusCode.IsBad(status))
{
if (status != StatusCodes.BadNotSupported && status != StatusCodes.BadCertificateRevocationUnknown)
{
throw new ServiceResultException(status);
}
}
}
return(new CertificateIdentifier(certificates[ii], options));
}
}
}
}
finally
{
store.Close();
}
}
// not a trusted issuer.
return(null);
}
/// <summary>
/// Constructs a object by specifying each property.
/// </summary>
/// <remarks>
/// The innerException is used to construct the innerResult.
/// </remarks>
public ServiceResult(StatusCode code, Exception innerException)
:
this(code, null, null, null, null, innerException)
{
}
/// <summary>
/// Constructs a object from a StatusCode.
/// </summary>
public ServiceResult(StatusCode status)
{
m_code = status.Code;
}
/// <summary>
/// Initializes the object with a status code and a server timestamp.
/// </summary>
/// <remarks>
/// Initializes the object with a status code and a server timestamp.
/// </remarks>
/// <param name="statusCode">The status code associated with the value.</param>
/// <param name="serverTimestamp">The timestamp associated with the status code.</param>
public DataValue(StatusCode statusCode, DateTime serverTimestamp)
{
Initialize();
m_statusCode = statusCode;
m_serverTimestamp = serverTimestamp;
}
/// <summary>
/// Constructs a object by specifying each property.
/// </summary>
public ServiceResult(
StatusCode code,
string symbolicId,
string namespaceUri)
:
this(code, symbolicId, namespaceUri, (string)null, (string)null, (ServiceResult)null)
{
}
/// <summary>
/// Reads an StatusCode from the stream.
/// </summary>
public StatusCode ReadStatusCode(string fieldName)
{
StatusCode value = new StatusCode();
if (BeginField(fieldName, true))
{
PushNamespace(Namespaces.OpcUaXsd);
value.Code = ReadUInt32("Code");
PopNamespace();
EndField(fieldName);
}
return value;
}
private ServiceResult OnUserArrayValue2(
ISystemContext context,
MethodState method,
NodeId objectId,
DateTime[] dateTimeIn,
Uuid[] guidIn,
byte[][] byteStringIn,
XmlElement[] xmlElementIn,
NodeId[] nodeIdIn,
ExpandedNodeId[] expandedNodeIdIn,
QualifiedName[] qualifiedNameIn,
LocalizedText[] localizedTextIn,
StatusCode[] statusCodeIn,
Variant[] variantIn,
ref DateTime[] dateTimeOut,
ref Uuid[] guidOut,
ref byte[][] byteStringOut,
ref XmlElement[] xmlElementOut,
ref NodeId[] nodeIdOut,
ref ExpandedNodeId[] expandedNodeIdOut,
ref QualifiedName[] qualifiedNameOut,
ref LocalizedText[] localizedTextOut,
ref StatusCode[] statusCodeOut,
ref Variant[] variantOut)
{
dateTimeOut = dateTimeIn;
guidOut = guidIn;
byteStringOut = byteStringIn;
xmlElementOut = xmlElementIn;
nodeIdOut = nodeIdIn;
expandedNodeIdOut = expandedNodeIdIn;
qualifiedNameOut = qualifiedNameIn;
localizedTextOut = localizedTextIn;
statusCodeOut = statusCodeIn;
variantOut = variantIn;
return ServiceResult.Good;
}
/// <summary>
/// Constructs a object by specifying each property.
/// </summary>
public ServiceResult(
StatusCode code,
XmlQualifiedName symbolicId,
LocalizedText localizedText)
:
this(code, (symbolicId != null) ? symbolicId.Name : null, (symbolicId != null) ? symbolicId.Namespace : null, localizedText, (string)null, (ServiceResult)null)
{
}
/// <summary>
/// Formats a StatusCide as string for serilization or display.
/// </summary>
public static string FormatQuality(StatusCode statusCode)
{
StringBuilder buffer = new StringBuilder();
buffer.AppendFormat(System.Globalization.CultureInfo.InvariantCulture, "{0}", new StatusCode(statusCode.CodeBits));
if ((statusCode.AggregateBits & AggregateBits.Interpolated) != 0)
{
buffer.Append(", Interpolated");
}
if ((statusCode.AggregateBits & AggregateBits.Calculated) != 0)
{
buffer.Append(", Calculated");
}
if ((statusCode.AggregateBits & AggregateBits.Partial) != 0)
{
buffer.Append(", Partial");
}
if ((statusCode.AggregateBits & AggregateBits.MultipleValues) != 0)
{
buffer.Append(", MultipleValues");
}
return buffer.ToString();
}
/// <summary>
/// Returns true if the status is good or uncertain.
/// </summary>
/// <remarks>
/// Returns true if the status is good or uncertain.
/// </remarks>
/// <param name="code">The code to check</param>
public static bool IsNotBad(StatusCode code)
{
return((code.m_code & 0x80000000) == 0);
}
/// <summary>
/// Writes an StatusCode to the stream.
/// </summary>
public void WriteStatusCode(string fieldName, StatusCode value)
{
if (BeginField(fieldName, false, false))
{
PushNamespace(Namespaces.OpcUaXsd);
if (value != null)
{
WriteUInt32("Code", value.Code);
}
PopNamespace();
EndField(fieldName);
}
}
/// <summary>
/// Write the value for the value attribute.
/// </summary>
protected override ServiceResult WriteValueAttribute(
ISystemContext context,
NumericRange indexRange,
object value,
StatusCode statusCode,
DateTime sourceTimestamp)
{
ServiceResult result = null;
if ((WriteMask & AttributeWriteMask.ValueForVariableType) == 0)
{
return StatusCodes.BadNotWritable;
}
// ensure the source timestamp has a valid value.
if (sourceTimestamp == DateTime.MinValue)
{
sourceTimestamp = DateTime.UtcNow;
}
// index range writes not supported.
if (indexRange != NumericRange.Empty)
{
return StatusCodes.BadIndexRangeInvalid;
}
// verify data type.
TypeInfo typeInfo = TypeInfo.IsInstanceOfDataType(
value,
m_dataType,
m_valueRank,
context.NamespaceUris,
context.TypeTable);
if (typeInfo == null || typeInfo == TypeInfo.Unknown)
{
return StatusCodes.BadTypeMismatch;
}
// check for simple write value handler.
if (OnSimpleWriteValue != null)
{
result = OnSimpleWriteValue(
context,
this,
ref value);
if (ServiceResult.IsBad(result))
{
return result;
}
}
// update cached values.
Value = value;
return ServiceResult.Good;
}
/// <summary>
/// Constructs a object by specifying each property.
/// </summary>
public ServiceResult(
StatusCode code,
LocalizedText localizedText)
:
this(code, (string)null, (string)null, localizedText, (string)null, (ServiceResult)null)
{
}
/// <summary>
/// Generates a new value each time the value is read.
/// </summary>
private ServiceResult DoDeviceRead(
ISystemContext context,
NodeState node,
NumericRange indexRange,
QualifiedName dataEncoding,
ref object value,
ref StatusCode statusCode,
ref DateTime timestamp)
{
BaseVariableState variable = node as BaseVariableState;
if (variable == null)
{
return ServiceResult.Good;
}
if (!SimulationActive.Value)
{
return ServiceResult.Good;
}
TestDataSystem system = context.SystemHandle as TestDataSystem;
if (system == null)
{
return StatusCodes.BadOutOfService;
}
try
{
value = system.ReadValue(variable);
statusCode = StatusCodes.Good;
timestamp = DateTime.UtcNow;
ServiceResult error = BaseVariableState.ApplyIndexRangeAndDataEncoding(
context,
indexRange,
dataEncoding,
ref value);
if (ServiceResult.IsBad(error))
{
statusCode = error.StatusCode;
}
return ServiceResult.Good;
}
catch (Exception e)
{
return new ServiceResult(e);
}
}
/// <summary>
/// Constructs a object by specifying each property.
/// </summary>
/// <remarks>
/// The innerException is used to construct the inner result.
/// </remarks>
public ServiceResult(
StatusCode code,
string symbolicId,
string namespaceUri,
LocalizedText localizedText,
string additionalInfo,
Exception innerException)
{
ServiceResult innerResult = new ServiceResult(innerException);
// check if no new information provided.
if (code.Code == innerResult.Code && symbolicId == null && localizedText == null && additionalInfo == null)
{
m_code = innerResult.Code;
m_symbolicId = innerResult.SymbolicId;
m_namespaceUri = innerResult.NamespaceUri;
m_localizedText = innerResult.LocalizedText;
m_additionalInfo = innerResult.AdditionalInfo;
m_innerResult = innerResult.InnerResult;
}
// make the exception the inner result.
else
{
m_code = code.Code;
m_symbolicId = symbolicId;
m_namespaceUri = namespaceUri;
m_localizedText = localizedText;
m_additionalInfo = additionalInfo;
m_innerResult = innerResult;
}
}
private ServiceResult OnChangePhaseByWrite(
ISystemContext context,
NodeState node,
NumericRange indexRange,
QualifiedName dataEncoding,
ref object value,
ref StatusCode statusCode,
ref DateTime timestamp)
{
string phase = value as string;
if (phase == null)
{
return StatusCodes.BadTypeMismatch;
}
List<IReference> references = new List<IReference>();
m_rig.Phases.GetReferences(context, references, Opc.Ua.ReferenceTypeIds.Organizes, false);
foreach (IReference reference in references)
{
if (reference.TargetId.ToString().Contains(phase))
{
return OnChangePhase(context, m_rig.ChangePhase, m_rig.NodeId, (NodeId)reference.TargetId);
}
}
return StatusCodes.BadTypeMismatch;
}
/// <summary>
/// Constructs a object by specifying each property.
/// </summary>
/// <remarks>
/// The innerException is used to construct the innerResult.
/// </remarks>
public ServiceResult(
StatusCode code,
LocalizedText localizedText,
Exception innerException)
:
this(code, null, null, localizedText, null, innerException)
{
}
public ServiceResult OnChangeLockByWrite(
ISystemContext context,
NodeState node,
NumericRange indexRange,
QualifiedName dataEncoding,
ref object value,
ref StatusCode statusCode,
ref DateTime timestamp)
{
DsatsDemo.LockConditionState condition = null;
BaseInstanceState instance = node as BaseInstanceState;
if (instance.Parent != null)
{
condition = instance.Parent as DsatsDemo.LockConditionState;
}
if (condition == null)
{
return StatusCodes.BadNotWritable;
}
string lockState = value as string;
if (lockState == null)
{
return StatusCodes.BadTypeMismatch;
}
if (lockState == "Locked")
{
ServiceResult result = OnRequestLock(context, condition.Request, condition.NodeId, new object[0], new object[0]);
value = condition.LockStateAsString.Value;
return result;
}
else if (lockState == "Unlocked")
{
ServiceResult result = OnReleaseLock(context, condition.Request, condition.NodeId, new object[0], new object[0]);
value = condition.LockStateAsString.Value;
return result;
}
return StatusCodes.BadTypeMismatch;
}
/// <summary>
/// Initializes the object with a status code and a diagnostic info structure.
/// </summary>
public ServiceResult(StatusCode code, int index, DiagnosticInfoCollection diagnosticInfos, IList<string> stringTable)
{
m_code = (uint)code;
if (index >= 0 && diagnosticInfos != null && index < diagnosticInfos.Count)
{
DiagnosticInfo diagnosticInfo = diagnosticInfos[index];
if (diagnosticInfo != null)
{
m_namespaceUri = LookupString(stringTable, diagnosticInfo.NamespaceUri);
m_symbolicId = LookupString(stringTable, diagnosticInfo.SymbolicId);
string locale = LookupString(stringTable, diagnosticInfo.Locale);
string localizedText = LookupString(stringTable, diagnosticInfo.LocalizedText);
m_localizedText = new LocalizedText(locale, localizedText);
m_additionalInfo = diagnosticInfo.AdditionalInfo;
if (!StatusCode.IsGood(diagnosticInfo.InnerStatusCode))
{
m_innerResult = new ServiceResult(diagnosticInfo.InnerStatusCode, diagnosticInfo.InnerDiagnosticInfo, stringTable);
}
}
}
}
/// <summary>
/// Writes an StatusCode to the stream.
/// </summary>
public void WriteStatusCode(string fieldName, StatusCode value)
{
if (value == StatusCodes.Good)
{
WriteSimpleField(fieldName, null, false);
return;
}
var text = StatusCode.LookupSymbolicId(value.CodeBits);
text += ":0x";
text += value.Code.ToString("X8", CultureInfo.InvariantCulture);
WriteSimpleField(fieldName, text, true);
}
/// <summary>
/// Handles the read operation for an invidual tag.
/// </summary>
public ServiceResult ReadTagValue(
ISystemContext context,
NodeState node,
NumericRange indexRange,
QualifiedName dataEncoding,
ref object value,
ref StatusCode statusCode,
ref DateTime timestamp)
{
MemoryTagState tag = node as MemoryTagState;
if (tag == null)
{
return StatusCodes.BadNodeIdUnknown;
}
if (NumericRange.Empty != indexRange)
{
return StatusCodes.BadIndexRangeInvalid;
}
if (!QualifiedName.IsNull(dataEncoding))
{
return StatusCodes.BadDataEncodingInvalid;
}
int offset = (int)tag.Offset;
lock (m_dataLock)
{
if (offset < 0 || offset >= m_buffer.Length)
{
return StatusCodes.BadNodeIdUnknown;
}
if (m_buffer == null)
{
return StatusCodes.BadOutOfService;
}
value = GetValueAtOffset(offset).Value;
}
statusCode = StatusCodes.Good;
timestamp = m_lastScanTime;
return ServiceResult.Good;
}
/// <summary>
/// Handles a write operation for an individual tag.
/// </summary>
public ServiceResult WriteTagValue(
ISystemContext context,
NodeState node,
NumericRange indexRange,
QualifiedName dataEncoding,
ref object value,
ref StatusCode statusCode,
ref DateTime timestamp)
{
MemoryTagState tag = node as MemoryTagState;
if (tag == null)
{
return StatusCodes.BadNodeIdUnknown;
}
if (NumericRange.Empty != indexRange)
{
return StatusCodes.BadIndexRangeInvalid;
}
if (!QualifiedName.IsNull(dataEncoding))
{
return StatusCodes.BadDataEncodingInvalid;
}
if (statusCode != StatusCodes.Good)
{
return StatusCodes.BadWriteNotSupported;
}
if (timestamp != DateTime.MinValue)
{
return StatusCodes.BadWriteNotSupported;
}
bool changed = false;
int offset = (int)tag.Offset;
lock (m_dataLock)
{
if (offset < 0 || offset >= m_buffer.Length)
{
return StatusCodes.BadNodeIdUnknown;
}
if (m_buffer == null)
{
return StatusCodes.BadOutOfService;
}
byte[] bytes = null;
switch (m_elementType)
{
case BuiltInType.UInt32:
{
uint? valueToWrite = value as uint?;
if (valueToWrite == null)
{
return StatusCodes.BadTypeMismatch;
}
bytes = BitConverter.GetBytes(valueToWrite.Value);
break;
}
case BuiltInType.Double:
{
double? valueToWrite = value as double?;
if (valueToWrite == null)
{
return StatusCodes.BadTypeMismatch;
}
bytes = BitConverter.GetBytes(valueToWrite.Value);
break;
}
default:
{
return StatusCodes.BadNodeIdUnknown;
}
}
for (int ii = 0; ii < bytes.Length; ii++)
{
if (!changed)
{
if (m_buffer[offset + ii] != bytes[ii])
{
changed = true;
}
}
m_buffer[offset + ii] = bytes[ii];
}
}
if (changed)
{
OnBufferChanged(offset);
}
return ServiceResult.Good;
}
/// <summary>
/// Constructs a object by specifying each property.
/// </summary>
public ServiceResult(
StatusCode code,
string symbolicId,
string namespaceUri,
LocalizedText localizedText)
:
this(code, symbolicId, namespaceUri, localizedText, (string)null, (ServiceResult)null)
{
}
private ServiceResult OnUserScalarValue2(
ISystemContext context,
MethodState method,
NodeId objectId,
DateTime dateTimeIn,
Uuid guidIn,
byte[] byteStringIn,
XmlElement xmlElementIn,
NodeId nodeIdIn,
ExpandedNodeId expandedNodeIdIn,
QualifiedName qualifiedNameIn,
LocalizedText localizedTextIn,
StatusCode statusCodeIn,
object variantIn,
ref DateTime dateTimeOut,
ref Uuid guidOut,
ref byte[] byteStringOut,
ref XmlElement xmlElementOut,
ref NodeId nodeIdOut,
ref ExpandedNodeId expandedNodeIdOut,
ref QualifiedName qualifiedNameOut,
ref LocalizedText localizedTextOut,
ref StatusCode statusCodeOut,
ref object variantOut)
{
dateTimeOut = dateTimeIn;
guidOut = guidIn;
byteStringOut = byteStringIn;
xmlElementOut = xmlElementIn;
nodeIdOut = nodeIdIn;
expandedNodeIdOut = expandedNodeIdIn;
qualifiedNameOut = qualifiedNameIn;
localizedTextOut = localizedTextIn;
statusCodeOut = statusCodeIn;
variantOut = variantIn;
return ServiceResult.Good;
}
/// <summary>
/// Converts a value to a StatusCode
/// </summary>
private static object ToStatusCode(object value, BuiltInType sourceType)
{
// check for array conversions.
Array array = value as Array;
if (array != null)
{
StatusCode[] output = new StatusCode[array.Length];
for (int ii = 0; ii < array.Length; ii++)
{
output[ii] = (StatusCode)Cast(array.GetValue(ii), BuiltInType.StatusCode);
}
return output;
}
// handle for supported conversions.
switch (sourceType)
{
case BuiltInType.StatusCode:
{
return (StatusCode)value;
}
case BuiltInType.UInt16:
{
uint code = Convert.ToUInt32((ushort)value);
code <<= 16;
return (StatusCode)code;
}
case BuiltInType.Int32:
{
return (StatusCode)Convert.ToUInt32((int)value);
}
case BuiltInType.UInt32:
{
return (StatusCode)(uint)value;
}
case BuiltInType.Int64:
{
return (StatusCode)Convert.ToUInt32((long)value);
}
case BuiltInType.UInt64:
{
return (StatusCode)Convert.ToUInt32((ulong)value);
}
}
// conversion not supported.
return null;
}
/// <summary>
/// Returns true if the status is bad or uncertain.
/// </summary>
/// <remarks>
/// Returns true if the status is bad or uncertain.
/// </remarks>
/// <param name="code">The code to check</param>
public static bool IsNotGood(StatusCode code)
{
return((code.m_code & 0xC0000000) != 0);
}