}// Data
//-
#endregion
#region // Public Methods
//----------------------
/// <summary>
/// Returns the string representation of a <see cref="ValueData"/> object.
/// </summary>
/// <returns>A string that represents the textual representation of a <see cref="ValueData"/> object.</returns>
/// <include
/// file='TBN.doc.xml'
/// path='//class[@name="ValueData"]/method[@name="ToString"]/doc/*'
/// />
public override string ToString()
{
if (Data == null)
{
return string.Empty;
} // end if
IntPtr pData = Marshal.AllocCoTaskMem(ValueQT.VARIANT_SIZE);
Marshal.GetNativeVariantForObject(Data, pData);
IntPtr pInput = Marshal.AllocCoTaskMem(Marshal.SystemDefaultCharSize*(int) MAX_LENGTH_OF_VARIANT_TO_STRING);
IntPtr pOutput = OTBFunctions.OTVariantToString(
pData,
MAX_LENGTH_OF_VARIANT_TO_STRING,
pInput);
string output = Marshal.PtrToStringUni(pOutput);
Marshal.FreeCoTaskMem(pInput);
OTBFunctions.OTVariantClear(pData);
Marshal.FreeCoTaskMem(pData);
return output;
} // end ToString()
/// <summary>
/// retrieves the parent from a handle
/// </summary>
internal AddressSpaceElement GetParent(uint aHandle)
{
if (aHandle == 0)
{
return m_root;
} // end if
OTObjectData parent = new OTObjectData();
IntPtr pParent = Marshal.AllocCoTaskMem(Marshal.SizeOf(parent));
Marshal.StructureToPtr(parent, pParent, false);
if ((uint) EnumResultCode.S_OK != OTBFunctions.OTSGetParent(aHandle, pParent))
{
return null;
} // end if
parent = (OTObjectData) Marshal.PtrToStructure(pParent, typeof (OTObjectData));
Marshal.FreeCoTaskMem(pParent);
AddressSpaceElement elementParent = GetElementFromArray(parent.m_userData);
if (elementParent == null)
{
return m_root;
} // end if
return elementParent;
} // end getParent
} // end GetParent
/// <summary>
/// Returns a list of children. This list is empty in case of an error or if no children are there to be delivered
/// </summary>
/// <returns>
/// List of this element's children. If the element has no children, the list is empty
/// </returns>
/// <include
/// file='TBNS.doc.xml'
/// path='//class[@name="DaAddressSpaceElement"]/
/// method[@name="GetChildren"]/doc/*'
/// />
public override ArrayList GetChildren()
{
ArrayList children = new ArrayList();
IntPtr ptrData = IntPtr.Zero;
int count = 0;
int res = OTBFunctions.OTSGetChildren(m_objectHandle, (byte) EnumAddressSpaceElementType.DA, out count, out ptrData);
if (ResultCode.SUCCEEDED(res))
{
if (count > 0)
{
int size = Marshal.SizeOf(typeof (OTObjectData));
lock (Application.Instance.DaAddressSpaceRoot.ElementSyncRoot)
{
for (int i = 0; i < count; i++)
{
IntPtr currentPtr = new IntPtr(ptrData.ToInt64() + size*i);
OTObjectData myData = (OTObjectData) Marshal.PtrToStructure(currentPtr, typeof (OTObjectData));
children.Add(
Application.Instance.DaAddressSpaceRoot.GetElementFromArray(myData.m_userData) as DaAddressSpaceElement);
} // end for
}
} // end if
OTBFunctions.OTFreeMemory(ptrData);
} // end if
return children;
} // end GetChildren
} // end RemoveChild
/// <summary>
/// Gets the current value in the element's cache
/// </summary>
/// <param name="aValue">out parameter to be filled in with the <see cref="ValueQT"/> instance of the cache value</param>
/// <returns>
/// returns a result code that should be checked for success. If S_OK, the value provided is valid.
/// </returns>
/// <include
/// file='TBNS.doc.xml'
/// path='//class[@name="DaAddressSpaceElement"]/
/// method[@name="GetCacheValue"]/doc/*'
/// />
public virtual int GetCacheValue(ref ValueQT aValue)
{
aValue = null;
int result = (int) EnumResultCode.E_FAIL;
if (m_objectHandle != 0 && IoMode != EnumIoMode.NONE)
{
OTValueData valueData = new OTValueData();
// Allocate space and reset the reserved space
valueData.m_value = Marshal.AllocCoTaskMem(ValueQT.VARIANT_SIZE);
Marshal.GetNativeVariantForObject(null, valueData.m_value);
result = OTBFunctions.OTSGetCacheValue(this.m_objectHandle, ref valueData);
if (ResultCode.SUCCEEDED(result))
{
aValue = new ValueQT(ref valueData);
} // end if
OTBFunctions.OTVariantClear(valueData.m_value);
Marshal.FreeCoTaskMem(valueData.m_value);
} // end if
return result;
} // end GetCacheValue
/// <summary>
/// Removes the connection to a server.
/// </summary>
/// <param name="executionOptions">Specifies the modality of execution for disconnecting from a server.</param>
/// <returns>The result of disconnecting from a server.</returns>
/// <include
/// file='TBNC.doc.xml'
/// path='//class[@name="ObjectSpaceElement"]/method[@name="Disconnect"]/doc/*'
/// />
public virtual int Disconnect(ExecutionOptions executionOptions)
{
int res = (int)EnumResultCode.E_FAIL;
try
{
OTCExecutionOptions options = new OTCExecutionOptions();
if (executionOptions != null)
{
options.m_executionType = (byte)executionOptions.ExecutionType;
options.m_executionContext = (uint)executionOptions.ExecutionContext;
}
else
{
options.m_executionType = (byte)EnumExecutionType.SYNCHRONOUS;
options.m_executionContext = 0;
}
EnumObjectState m_targetState = EnumObjectState.DISCONNECTED;
OTBFunctions.OTCChangeTargetState(this.Handle, (byte)m_targetState, 1);
res = OTBFunctions.OTCPerformStateTransition(this.Handle, 1, ref options);
}
catch (Exception exc)
{
Application.Instance.Trace(
EnumTraceLevel.ERR,
EnumTraceGroup.CLIENT,
"ObjectSpaceElement.Disconnect",
exc.ToString());
}
return(res);
}
} // end ctr
//-
#endregion
#region // Public Methods
//------------------------
/// <summary>
/// Adds a namespace element as child to a namespace element
/// </summary>
/// <param name="aChild">Child to be added. Checks if the child provided is a <see cref="DaAddressSpaceElement"/></param>
/// <returns>
/// <line>true - Child successfully. </line>
/// <line>false - Child was not added. If fails, the Child should be released by the user.</line>
/// </returns>
/// <include
/// file='TBNS.doc.xml'
/// path='//class[@name="DaAddressSpaceElement"]/
/// method[@name="AddChild"]/doc/*'
/// />
public override bool AddChild(AddressSpaceElement aChild)
{
if (!HasChildren)
{
Application.Instance.Trace(
EnumTraceLevel.WRN, EnumTraceGroup.OPCSERVER,
"DaAddressSpaceElement.AddChild", "This element does not allow childred");
return false;
} // end if
DaAddressSpaceElement child = aChild as DaAddressSpaceElement;
if (child == null)
{
Application.Instance.Trace(
EnumTraceLevel.WRN, EnumTraceGroup.OPCSERVER,
"DaAddressSpaceElement.AddChild", "Invalid child provided");
return false;
} // end if
// only add the child if no handle assigned
if (child.ObjectHandle == 0)
{
OTSAddressSpaceElementData data = new OTSAddressSpaceElementData();
data.m_name = Marshal.StringToCoTaskMemUni(child.Name);
data.m_itemID = Marshal.StringToCoTaskMemUni(
Name + Application.Instance.AddressSpaceDelimiter + child.Name);
data.m_accessRights = (byte) child.AccessRights;
data.m_ioMode = (byte) child.IoMode;
data.m_datatype = ValueQT.GetVartype(child.Datatype);
data.m_hasChildren = Convert.ToByte(child.HasChildren);
data.m_isBrowsable = Convert.ToByte(child.IsBrowsable);
data.m_elementType = (byte) EnumAddressSpaceElementType.DA;
data.m_userData = child.UserData;
Application.Instance.DaAddressSpaceRoot.AddElementToArray(child);
int result = OTBFunctions.OTSAddAddressSpaceElement(m_objectHandle, data, out child.m_objectHandle);
Marshal.FreeCoTaskMem(data.m_name);
Marshal.FreeCoTaskMem(data.m_itemID);
if (!ResultCode.SUCCEEDED(result))
{
result = Application.Instance.DaAddressSpaceRoot.RemoveElementFromArray(child);
System.Diagnostics.Debug.Assert(ResultCode.SUCCEEDED(result),
"RemoveElementFromArray has failed");
return false;
} // end if ... else
}
else
{
Application.Instance.DaAddressSpaceRoot.AddElementToArray(child);
} // end if ... else
// end if
return base.AddChild(aChild);
} // end AddChild
/// <summary>
/// Releases the resources used by the <see cref="AddressSpaceElement"/> object.
/// </summary>
/// <include
/// file='TBNC.doc.xml'
/// path='//class[@name="AddressSpaceElement"]/method[@name="Dispose"]/doc/*'
/// />
public void Dispose()
{
if (m_objectElementHandle != 0)
{
OTBFunctions.OTCReleaseAddressSpaceElement(m_objectElementHandle, 0);
}
}
} // end SetTraceOptions
//-
#endregion
#region // Public Static Methods
//------------------------
/// <summary>
/// Writes a given message, of a given level, assigned to a given group in the current trace file.
/// </summary>
/// <param name="level">The level of tracing. It can be one of the EnumTraceLevel values.</param>
/// <param name="mask">The group to be traced. It can be one of the EnumTraceGroup values.</param>
/// <param name="objectID">The identifier for the traced object. (it could be the name of the method
/// where the trace message is inserted).</param>
/// <param name="message">The tracing message. It is a free text and denotes the reason of the trace.</param>
/// <include
/// file='TBN.doc.xml'
/// path='//class[@name="Trace"]/method[@name="WriteLine_1"]/doc/*'
/// />
public static void WriteLine(
byte level,
uint mask,
string objectID,
string message)
{
string FormattedString = message;
OTBFunctions.OTTrace(level, mask, objectID, FormattedString);
} // end WriteLine
} // end ctr
/// <summary>
/// AddressSpaceRoot constructor: Used to build a specialised root type
/// </summary>
/// <param name="anAddressSpaceType">
/// The type of address space
/// </param>
/// <param name="aRoot">
/// An address space element to impersonate the root. This element is not visible in the namespace
/// </param>
/// <include
/// file='TBNS.doc.xml'
/// path='//class[@name="AddressSpaceRoot"]/
/// ctor[@name="AddressSpaceRoot.typed"]/doc/*'
/// />
protected AddressSpaceRoot(
EnumAddressSpaceType anAddressSpaceType,
AddressSpaceElement aRoot)
{
this.m_root = aRoot;
m_root.HasChildren = true;
m_namespaceType = anAddressSpaceType;
int result = OTBFunctions.OTSInitAddressSpace((byte) this.m_namespaceType);
} // end ctr
} // end WriteLine
/// <summary>
/// Writes a given message, of a given level, assigned to a given group in the current trace file.
/// The line is written based on a given text format.
/// </summary>
/// <param name="level">The level of tracing. It can be one of the EnumTraceLevel values.</param>
/// <param name="mask">The group to be traced. It can be one of the EnumTraceGroup values.</param>
/// <param name="objectID">The identifier for the traced object. (it could be the name of the method
/// where the trace message is inserted).</param>
/// <param name="message">The tracing message. It is a free text and denotes the reason of the trace.</param>
/// <param name="args">Parameter list for formatted message string.</param>
/// <include
/// file='TBN.doc.xml'
/// path='//class[@name="Trace"]/method[@name="WriteLine_2"]/doc/*'
/// />
public static void WriteLine(
byte level,
uint mask,
string objectID,
string message,
params object[] args)
{
string FormattedString = String.Format(message, args);
OTBFunctions.OTTrace(level, mask, objectID, FormattedString);
} // end WriteLine
} // end GetConditionDefinition
/// <summary>
/// Adds a subcondition to a condition in the AeCategory.
/// </summary>
/// <param name="aConditionName">The existing condition.</param>
/// <param name="aSubconditionName">New subcondition name.</param>
/// <returns>
/// S_OK - if succeeded
/// E_FAIL - if failure
/// </returns>
/// <include
/// file='TBNS.doc.xml'
/// path='//class[@name="AeCategory"]/
/// method[@name="AddSubConditionDefinition"]/doc/*'
/// />
public virtual int AddSubConditionDefinition(
string aConditionName,
string aSubconditionName)
{
try
{
if (aConditionName.Length == 0 || aSubconditionName.Length == 0)
{
return (int) EnumResultCode.E_FAIL;
} // end if
if (Handle == 0)
{
return (int) EnumResultCode.E_FAIL;
} // end if
System.Diagnostics.Debug.Assert(Handle != 0, "Called for Null handle");
Hashtable syncConditions = Hashtable.Synchronized(this.m_conditions);
int result = (int) EnumResultCode.S_OK;
AeConditionDefinition condition = syncConditions[aConditionName] as AeConditionDefinition;
if (condition == null)
{
result = AddConditionDefinition(aConditionName);
syncConditions = Hashtable.Synchronized(this.m_conditions);
condition = syncConditions[aConditionName] as AeConditionDefinition;
} // end if
if (ResultCode.SUCCEEDED(result))
{
// at this time the condition should have been be registered
result = OTBFunctions.OTSAddSubCondition(this.Handle, aConditionName, aSubconditionName);
if (ResultCode.SUCCEEDED(result))
{
result = condition.AddSubConditonData(aSubconditionName);
} // end if
} // end if
return result;
}
catch (Exception e)
{
Application.Instance.Trace(EnumTraceLevel.ERR,
EnumTraceGroup.OPCSERVER,
"Category.AddCondition",
"Exception caught:" + e.ToString());
return (int) EnumResultCode.E_FAIL;
} // end try ... catch
} // end AddSubConditionDefinition
} // end AddChild
/// <summary>
/// Removes the child if there is any. The entire branch of the aChild will be removed as well from the address space.
/// </summary>
/// <param name="aChild">AddressSpaceElement child to be removed from this instance</param>
/// <returns>
/// true - aChild removed
/// false - aChild was not removed
/// </returns>
/// <include
/// file='TBNS.doc.xml'
/// path='//class[@name="DaAddressSpaceElement"]/
/// method[@name="RemoveChild"]/doc/*'
/// />
public override bool RemoveChild(AddressSpaceElement aChild)
{
if (!HasChildren)
{
// just log a warning, but proceed then with the removal attempt
Application.Instance.Trace(
EnumTraceLevel.WRN, EnumTraceGroup.OPCSERVER,
"DaAddressSpaceElement.RemoveChild", "This element does not allow childred");
} // end if
DaAddressSpaceElement child = aChild as DaAddressSpaceElement;
if (child == null)
{
Application.Instance.Trace(EnumTraceLevel.WRN, EnumTraceGroup.OPCSERVER,
"DaAddressSpaceElement.RemoveChild", "Invalid child provided");
return false;
} // end if
if (child.HasChildren)
{
// Remove the clildren of the child
ArrayList otherChildren = child.GetChildren();
foreach (AddressSpaceElement element in otherChildren)
{
child.RemoveChild(element);
} // end for
} // end if
int result = OTBFunctions.OTSRemoveAddressSpaceElement(child.ObjectHandle);
if (!ResultCode.SUCCEEDED(result))
{
Application.Instance.Trace(EnumTraceLevel.WRN, EnumTraceGroup.OPCSERVER,
"DaAddressSpaceElement.RemoveChild",
"OTSRemoveAddressSpaceElement has failed with code" + result.ToString());
return false;
} // end if
result = Application.Instance.DaAddressSpaceRoot.RemoveElementFromArray(child);
if (!ResultCode.SUCCEEDED(result))
{
Application.Instance.Trace(EnumTraceLevel.WRN, EnumTraceGroup.OPCSERVER,
"DaAddressSpaceElement.RemoveChild",
"RemoveElementFromArray has failed with code" + result.ToString());
return false;
} // end if
return base.RemoveChild(aChild);
} // end RemoveChild
/// <summary>
/// Updates some object attributes to the server.
/// </summary>
/// <param name="whatAttributes">A list with all the object attributes to be updated to the server.</param>
/// <param name="results">A list with the result of the update for each object attribute. </param>
/// <param name="executionOptions">Specifies the modality of execution for updating attributes to a server.</param>
/// <returns>The result of updating attributes to a server.</returns>
/// <include
/// file='TBNC.doc.xml'
/// path='//class[@name="ObjectSpaceElement"]/method[@name="SetAttributesToServer"]/doc/*'
/// />
public virtual int SetAttributesToServer(
EnumObjectAttribute[] whatAttributes,
out int[] results,
ExecutionOptions executionOptions)
{
int res = (int)EnumResultCode.E_FAIL;
results = null;
try
{
OTCExecutionOptions options = new OTCExecutionOptions();
if (executionOptions != null)
{
options.m_executionType = (byte)executionOptions.ExecutionType;
options.m_executionContext = (uint)executionOptions.ExecutionContext;
}
else
{
options.m_executionType = (byte)EnumExecutionType.SYNCHRONOUS;
options.m_executionContext = 0;
}
int count = whatAttributes.Length;
uint[] whatAttributesToChange = new uint[count];
for (int i = 0; i < whatAttributes.Length; i++)
{
whatAttributesToChange[i] = (uint)whatAttributes[i];
}
results = new int[count];
res = OTBFunctions.OTCUpdateAttributes(
this.Handle,
0,
(uint)count,
whatAttributesToChange,
results,
ref options);
}
catch (Exception exc)
{
Application.Instance.Trace(
EnumTraceLevel.ERR,
EnumTraceGroup.CLIENT,
"ObjectSpaceElement.SetAttributesToServer",
exc.ToString());
}
return(res);
}
} // end GetSubConditionDefinition
/// <summary>
/// CreateOTSConditionDefinitionData
/// </summary>
internal OTSConditionDefinitionData CreateOTSConditionDefinitionData()
{
OTSConditionDefinitionData conditionDefinitionData = new OTSConditionDefinitionData();
conditionDefinitionData.m_definition = OTBFunctions.AllocateOTBString(this.m_definition);
Hashtable syncSubconditions = Hashtable.Synchronized(m_subconditions);
conditionDefinitionData.m_subConditionCount = (uint) syncSubconditions.Count;
if (syncSubconditions.Count > 0)
{
conditionDefinitionData.m_subConditionDefinitions =
OTBFunctions.OTAllocateMemory(syncSubconditions.Count*Marshal.SizeOf(typeof (IntPtr)));
conditionDefinitionData.m_subConditionDescriptions =
OTBFunctions.OTAllocateMemory(syncSubconditions.Count*Marshal.SizeOf(typeof (IntPtr)));
conditionDefinitionData.m_subConditionSeverities =
OTBFunctions.OTAllocateMemory(syncSubconditions.Count*Marshal.SizeOf(typeof (uint)));
int index = 0;
foreach (AeSubConditionDefinition subCondition in syncSubconditions.Values)
{
IntPtr definitionPointer = OTBFunctions.AllocateOTBString(subCondition.Definition);
Marshal.WriteIntPtr(
conditionDefinitionData.m_subConditionDefinitions,
index*Marshal.SizeOf(typeof (IntPtr)),
definitionPointer);
IntPtr descriptionPointer = OTBFunctions.AllocateOTBString(subCondition.Description);
Marshal.WriteIntPtr(
conditionDefinitionData.m_subConditionDescriptions,
index*Marshal.SizeOf(typeof (IntPtr)),
descriptionPointer);
Marshal.WriteInt32(conditionDefinitionData.m_subConditionSeverities,
index*Marshal.SizeOf(typeof (uint)),
(int) subCondition.Severity);
index++;
} // end foreach
} // end if
return conditionDefinitionData;
} // end CreateOTSConditionDefinitionData
public IntPtr m_pEventAttrs = IntPtr.Zero; // array with all event attributes
public void Release()
{
Marshal.FreeCoTaskMem(this.m_sourcePath);
Marshal.FreeCoTaskMem(this.m_message);
Marshal.FreeCoTaskMem(this.m_actorID);
if (this.m_eventAttrCount != 0 &&
this.m_pEventAttrs != IntPtr.Zero)
{
IntPtr currentPointer = this.m_pEventAttrs;
for (int index = 0; index < this.m_eventAttrCount; index++)
{
OTBFunctions.OTVariantClear(currentPointer);
currentPointer = new IntPtr(currentPointer.ToInt64() + ValueQT.VARIANT_SIZE);
} // end for
Marshal.FreeCoTaskMem(this.m_pEventAttrs);
} // end if
} // end Release
/// <summary>
/// Establishes a connection to a server.
/// </summary>
/// <param name="deep">Indicates if connecting to the server should be propagated down to the chlid objects or not.</param>
/// <param name="active">Indicates if the <see cref=" ObjectSpaceElement"/> and the server communicate with each other via callbacks. </param>
/// <param name="executionOptions">Specifies the modality of execution for connecting to a server.</param>
/// <returns>The result of connecting to a server.</returns>
/// <include
/// file='TBNC.doc.xml'
/// path='//class[@name="ObjectSpaceElement"]/method[@name="Connect"]/doc/*'
/// />
public virtual int Connect(bool deep, bool active, ExecutionOptions executionOptions)
{
int res = (int)EnumResultCode.E_FAIL;
try
{
if (deep == true)
{
if (active == true)
{
OTBFunctions.OTCChangeTargetState(this.Handle, (byte)EnumObjectState.ACTIVATED, 1);
res = PerformStateTransition(deep, executionOptions);
}
if (active == false)
{
OTBFunctions.OTCChangeTargetState(this.Handle, (byte)EnumObjectState.CONNECTED, 1);
res = PerformStateTransition(deep, executionOptions);
}
}
if (deep == false)
{
if (active == true)
{
OTBFunctions.OTCChangeTargetState(this.Handle, (byte)EnumObjectState.ACTIVATED, 0);
res = PerformStateTransition(deep, executionOptions);
}
if (active == false)
{
OTBFunctions.OTCChangeTargetState(this.Handle, (byte)EnumObjectState.CONNECTED, 0);
res = PerformStateTransition(deep, executionOptions);
}
}
}
catch (Exception exc)
{
Application.Instance.Trace(
EnumTraceLevel.ERR,
EnumTraceGroup.CLIENT,
"ObjectSpaceElement.Connect",
exc.ToString());
}
return(res);
}
} // end QueryProperties
/// <summary>
/// Changes value cache value of this element instance
/// </summary>
/// <param name="aNewValue"></param>
/// <returns>
/// E_INVALIDARG - Invalid valueQT was passed
/// S_OK - Value changed
/// OTS_E_EXCEPTION - Unexpected error occurred
/// </returns>
/// <include
/// file='TBNS.doc.xml'
/// path='//class[@name="DaAddressSpaceElement"]/
/// method[@name="ValueChanged"]/doc/*'
/// />
public virtual int ValueChanged(ValueQT aNewValue)
{
if (this.ObjectHandle == 0)
{
return (int) EnumResultCode.E_FAIL;
} // end if
OTValueData valueData = new OTValueData();
valueData.m_quality = (ushort) aNewValue.Quality;
valueData.m_timestamp = new OTDateTime(aNewValue.TimeStamp);
valueData.m_value = Marshal.AllocCoTaskMem(ValueQT.VARIANT_SIZE);
Marshal.GetNativeVariantForObject(aNewValue.Data, valueData.m_value);
int result = OTBFunctions.OTSValuesChanged(1, new uint[1] {ObjectHandle}, new OTValueData[1] {valueData});
OTBFunctions.OTVariantClear(valueData.m_value);
Marshal.FreeCoTaskMem(valueData.m_value);
return result;
} // end ValueChanged
//-----------------------------
/// <summary>
/// Default public constructor
/// </summary>
/// <include
/// file='TBNS.doc.xml'
/// path='//class[@name="DaRequest"]/
/// ctor[@name="DaRequest"]/doc/*'
/// />
public DaRequest(
EnumTransactionType aTransactionType,
uint aSessionHandle,
DaAddressSpaceElement anElement,
int aPropertyId,
uint aRequestHandle)
{
m_transactionType = aTransactionType;
m_sessionHandle = aSessionHandle;
m_requestHandle = aRequestHandle;
m_propertyId = aPropertyId;
m_addressSpaceElement = anElement;
m_transactionKey = 0;
m_result = EnumResultCode.E_NOTIMPL;
m_requestState = EnumRequestState.CREATED;
if (m_addressSpaceElement != null)
{
OTBFunctions.OTSAckRequestElement(m_addressSpaceElement.ObjectHandle);
}
} // end ctr
//-
#endregion
/// <summary>
/// Performs the transition from the current state to the target state.
/// </summary>
/// <param name="deep">Indicates if changing the target state should be propagated down to the child objects or not.</param>
/// <param name="executionOptions">Specifies the modality of execution for state transition.</param>
/// <returns>The result of performing the state transition.</returns>
/// <include
/// file='TBNC.doc.xml'
/// path='//class[@name="ObjectSpaceElement"]/method[@name="PerformStateTransition"]/doc/*'
/// />
public virtual int PerformStateTransition(bool deep, ExecutionOptions executionOptions)
{
int res = (int)EnumResultCode.E_FAIL;
try
{
OTCExecutionOptions options = new OTCExecutionOptions();
if (executionOptions != null)
{
options.m_executionType = (byte)executionOptions.ExecutionType;
options.m_executionContext = (uint)executionOptions.ExecutionContext;
}
else
{
options.m_executionType = (byte)EnumExecutionType.SYNCHRONOUS;
options.m_executionContext = 0;
}
if (deep == false)
{
// performs the state transition for the object itself
res = OTBFunctions.OTCPerformStateTransition(this.Handle, 0, ref options);
}
if (deep == true)
{
// performs the state transition for the whole subtree of the object
res = OTBFunctions.OTCPerformStateTransition(this.Handle, 1, ref options);
}
}
catch (Exception exc)
{
Application.Instance.Trace(
EnumTraceLevel.ERR,
EnumTraceGroup.CLIENT,
"ObjectSpaceElement.PerformStateTransition",
exc.ToString());
}
return(res);
}
} // end AddAttribute
/// <summary>
/// adds a new condition definition object with the name provided as aConditionDefinition
/// </summary>
/// <param name="aConditionName">the condition name</param>
/// <returns>
/// S_OK - if succeeded
/// E_FAIL - if failure
/// </returns>
/// <include
/// file='TBNS.doc.xml'
/// path='//class[@name="AeCategory"]/
/// method[@name="AddConditionDefinition"]/doc/*'
/// />
public virtual int AddConditionDefinition(string aConditionName)
{
try
{
if (aConditionName.Length == 0)
{
return (int) EnumResultCode.E_FAIL;
} // end if
if (Handle == 0)
{
return (int) EnumResultCode.E_FAIL;
} // end if
int result = OTBFunctions.OTSAddCondition(this.Handle, aConditionName);
if (ResultCode.SUCCEEDED(result))
{
Hashtable syncConditions = Hashtable.Synchronized(this.m_conditions);
// Check for a duplicate condition
AeConditionDefinition condition = syncConditions[aConditionName] as AeConditionDefinition;
if (condition == null)
{
condition = new AeConditionDefinition(aConditionName);
syncConditions.Add(aConditionName, condition);
} // end if
} // end if
return result;
}
catch (Exception e)
{
Application.Instance.Trace(EnumTraceLevel.ERR,
EnumTraceGroup.OPCSERVER,
"Category.AddCondition",
"Exception caught:" + e.ToString());
return (int) EnumResultCode.E_FAIL;
} // enc try ... catch
} // end AddConditionDefinition
public void Release()
{
if (this.m_tpCredentialsNumber > 0)
{
for (int index = 0; index < m_tpCredentialsNumber; index++)
{
IntPtr stringPointer = Marshal.ReadIntPtr(
m_tpUsers,
index*Marshal.SizeOf(typeof (IntPtr)));
OTBFunctions.OTFreeMemory(stringPointer);
stringPointer = Marshal.ReadIntPtr(
m_tpPasswords,
index*Marshal.SizeOf(typeof (IntPtr)));
OTBFunctions.OTFreeMemory(stringPointer);
} // end for
m_tpCredentialsNumber = 0;
m_tpUsers = IntPtr.Zero;
m_tpPasswords = IntPtr.Zero;
} // end if
} // end Release
} // end QueryAddressSpaceElementChildren
/// <summary>
/// Changes the cache value for the Address space elements provided
/// </summary>
/// <param name="anElementList">the namespace elements</param>
/// <param name="aValueList">the corresponding values</param>
/// <returns>
/// E_INVALIDARG - Invalid valueQT was passed
/// S_OK - Value changed
/// OTS_E_EXCEPTION - Unexpected error occurred
/// </returns>
/// <include
/// file='TBNS.doc.xml'
/// path='//class[@name="DaAddressSpaceRoot"]/
/// method[@name="ValuesChanged.array"]/doc/*'
/// />
public int ValuesChanged(DaAddressSpaceElement[] anElementList, ValueQT[] aValueList)
{
if (anElementList.Length != aValueList.Length)
{
return (int) EnumResultCode.E_INVALIDARG;
} // end if
int count = anElementList.Length;
if (count == 0)
{
return (int) EnumResultCode.S_FALSE;
} // end if
OTValueData[] aoValues = new OTValueData[count];
uint[] ahObjects = new uint[count];
for (int i = 0; i < count; i++)
{
ahObjects[i] = anElementList[i].ObjectHandle;
aoValues[i] = new OTValueData();
aoValues[i].m_quality = (ushort) aValueList[i].Quality;
aoValues[i].m_timestamp = new OTDateTime(aValueList[i].TimeStamp);
aoValues[i].m_value = Marshal.AllocCoTaskMem(ValueQT.VARIANT_SIZE);
Marshal.GetNativeVariantForObject(aValueList[i].Data, aoValues[i].m_value);
} // end for
int result = OTBFunctions.OTSValuesChanged(count, ahObjects, aoValues);
for (int i = 0; i < count; i++)
{
OTBFunctions.OTVariantClear(aoValues[i].m_value);
Marshal.FreeCoTaskMem(aoValues[i].m_value);
} // end for
return result;
} // end ValuesChanged
} // end GetConditionDefinition
//-
#endregion
#region // Protected Methods
//---------------------------
/// <summary>
/// Adds an existing attribute object to the category internal hashtable
/// </summary>
/// <param name="anAttribute"> an already created instance of the attribute</param>
/// <returns>
/// S_OK - if succeeded
/// E_FAIL - if failure
/// </returns>
/// <include
/// file='TBNS.doc.xml'
/// path='//class[@name="AeCategory"]/
/// method[@name="AddAttribute.existing"]/doc/*'
/// />
protected virtual int AddAttribute(AeAttribute anAttribute)
{
try
{
if (anAttribute == null)
{
return (int) EnumResultCode.E_FAIL;
} // end if
if (Handle == 0)
{
return (int) EnumResultCode.E_FAIL;
} // end if
int result = OTBFunctions.OTSAddEventAttribute(
this.Handle,
anAttribute.Id,
anAttribute.Name,
ValueQT.GetVartype(anAttribute.DataType));
if (ResultCode.SUCCEEDED(result))
{
Hashtable syncAttributeList = Hashtable.Synchronized(this.m_attributes);
syncAttributeList.Add(anAttribute.Id, anAttribute);
} // end if
return result;
}
catch (Exception e)
{
Application.Instance.Trace(EnumTraceLevel.ERR,
EnumTraceGroup.OPCSERVER,
"Category.AddAttribute",
"Exception caught:" + e.ToString());
return (int) EnumResultCode.E_FAIL;
} // end try ... catch
} // end AddAttribute
} // end MaximumBackups
//-
#endregion
#region // Internal Static Methods
//------------------------
/// <summary>
/// Forwards to the OTB the trace settings call.
/// </summary>
/// <param name="aTraceDataMask">
/// The trace settings mask to be changed within OTB.
/// </param>
internal static void SetTraceOptions(EnumTraceData aTraceDataMask)
{
#if !NET20 && !NET35 && !NET40 && !NET45 && !NET46
string osVersion = Environment.OSVersion.Version.ToString();
#else
string osVersion = Environment.OSVersion.VersionString;
#endif
string apiData = "TBN " + System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString() +
", built with .NET " + Environment.Version.ToString() + ", running on " + osVersion;
if (IntPtr.Size == 8)
{
apiData += " x64";
}
else
{
apiData += " x86";
}
m_traceData.m_apiVersion = apiData;
OTBFunctions.OTEnableTracing((uint)aTraceDataMask, m_traceData);
} // end SetTraceOptions
public void Release()
{
OTBFunctions.OTFreeMemory(this.m_definition);
if (this.m_subConditionCount > 0)
{
for (int index = 0; index < m_subConditionCount; index++)
{
IntPtr stringPointer = Marshal.ReadIntPtr(
m_subConditionDefinitions,
index*Marshal.SizeOf(typeof (IntPtr)));
OTBFunctions.OTFreeMemory(stringPointer);
stringPointer = Marshal.ReadIntPtr(
m_subConditionDescriptions,
index*Marshal.SizeOf(typeof (IntPtr)));
OTBFunctions.OTFreeMemory(stringPointer);
} // end for
OTBFunctions.OTFreeMemory(this.m_subConditionDefinitions);
OTBFunctions.OTFreeMemory(this.m_subConditionDescriptions);
OTBFunctions.OTFreeMemory(this.m_subConditionSeverities);
} // end if
} // end Release
/// <summary>
/// Completes a single request and removes it from the transaction
/// </summary>
/// <returns>
/// S_OK - Everything was OK
/// S_FALSE - Everything was OK
/// The Result should be checked with ResultCode.SUCCEEDED
/// or with ResultCode.FAILED
/// </returns>
/// <include
/// file='TBNS.doc.xml'
/// path='//class[@name="DaTransaction"]/
/// method[@name="CompleteRequest"]/doc/*'
/// />
public int CompleteRequest(DaRequest aRequest)
{
int result = (int) EnumResultCode.E_FAIL;
OTValueData[] values = new OTValueData[1];
OTSRequestData[] requests = new OTSRequestData[1];
int[] results = new int[1];
try
{
DaRequest request = aRequest as DaRequest;
if (request != null)
{
request.RequestState = EnumRequestState.COMPLETED;
// remove the request from the list
RemoveRequest(request);
requests[0].m_sessionHandle = request.SessionHandle;
requests[0].m_propertyID = request.PropertyId;
requests[0].m_requestHandle = request.RequestHandle;
if (request.AddressSpaceElement != null)
{
requests[0].m_object.m_userData = (uint) request.AddressSpaceElement.UserData;
requests[0].m_object.m_objectHandle = request.AddressSpaceElement.ObjectHandle;
}
else
{
requests[0].m_object.m_userData = 0;
requests[0].m_object.m_objectHandle = 0;
} // end if ... else
values[0] = new OTValueData();
if (request.Value != null)
{
values[0].m_timestamp = new OTDateTime(request.Value.TimeStamp);
values[0].m_quality = (ushort) request.Value.Quality;
values[0].m_value = Marshal.AllocCoTaskMem(ValueQT.VARIANT_SIZE);
Marshal.GetNativeVariantForObject(request.Value.Data, values[0].m_value);
results[0] = (int) request.Result;
}
else
{
values[0].m_quality = (ushort) EnumQuality.BAD;
values[0].m_value = Marshal.AllocCoTaskMem(ValueQT.VARIANT_SIZE);
Marshal.GetNativeVariantForObject(null, values[0].m_value);
results[0] = (int) EnumResultCode.E_UNEXPECTED;
} // end if ... else
}
else
{
requests[0].m_sessionHandle = 0;
requests[0].m_propertyID = 0;
requests[0].m_requestHandle = 0;
requests[0].m_object.m_userData = 0;
requests[0].m_object.m_objectHandle = 0;
values[0] = new OTValueData();
values[0].m_quality = (ushort) EnumQuality.BAD;
values[0].m_value = Marshal.AllocCoTaskMem(ValueQT.VARIANT_SIZE);
Marshal.GetNativeVariantForObject(null, values[0].m_value);
results[0] = (int) EnumResultCode.E_UNEXPECTED;
} // end if ... else
result = OTBFunctions.OTSCompleteRequests(1, requests, results, values);
}
catch (Exception e)
{
Application.Instance.Trace(
EnumTraceLevel.ERR, EnumTraceGroup.OPCSERVER,
"DaTransaction.CompleteRequest", "Exception caught: " + e.ToString());
result = (int) EnumResultCode.E_FAIL;
}
finally
{
if (this.IsEmpty)
{
Application.Instance.ReleaseTransaction(m_key);
}
OTBFunctions.OTVariantClear(values[0].m_value);
Marshal.FreeCoTaskMem(values[0].m_value);
} // end try ... catch ... finally
return result;
} // end CompleteRequest
//-
#endregion
/// <summary>
/// Browses all the servers that support a specified interface specification.
/// The server information to be returned after browsing is specified using the <see cref="EnumServerBrowserData"/> object.
/// After browsing, a list of <see cref="ServerBrowserData"/> objects that contain the requested information will be returned.
/// </summary>
/// <param name="whatOPCspecification">An OPC specification.</param>
/// <param name="whatServerData">Indicates what information about the server to be returned.</param>
/// <param name="serverData">A list with requested information about the available servers on the computer.</param>
/// <param name="someExecutionOptions">Specifies the modality of execution for browsing servers on the computer.</param>
/// <returns>The result of browsing servers on the computer.
/// </returns>
/// <include
/// file='TBNC.doc.xml'
/// path='//class[@name="ServerBrowser"]/method[@name="Browse"]/doc/*'
/// />
public virtual int Browse(
EnumOPCSpecification whatOPCspecification,
EnumServerBrowserData whatServerData,
out ServerBrowserData[] serverData,
ExecutionOptions someExecutionOptions)
{
int res = (int)EnumResultCode.E_FAIL;
serverData = null;
try
{
byte whatSpecification = (byte)whatOPCspecification;
byte whatData = (byte)whatServerData;
uint serverDataCount = 0;
IntPtr pServerData = new IntPtr();
OTCExecutionOptions options = new OTCExecutionOptions();
if (someExecutionOptions != null)
{
options.m_executionType = (byte)someExecutionOptions.ExecutionType;
options.m_executionContext = (uint)someExecutionOptions.ExecutionContext;
}
else
{
options.m_executionType = (byte)EnumExecutionType.SYNCHRONOUS;
options.m_executionContext = 0;
}
res = OTBFunctions.OTCBrowseServer(
m_ipAddress,
whatSpecification,
whatData,
ref serverDataCount,
out pServerData,
ref options);
if (someExecutionOptions.ExecutionType == EnumExecutionType.SYNCHRONOUS)
{
if (ResultCode.SUCCEEDED(res))
{
uint dataCount = serverDataCount;
serverData = new ServerBrowserData[dataCount];
OTCServerData[] serverDataOTC = new OTCServerData[dataCount];
OTCServerData typeOfServerData = new OTCServerData();
for (int i = 0; i < dataCount; i++)
{
int structSize = Marshal.SizeOf(typeOfServerData);
OTCServerData myData =
(OTCServerData)
Marshal.PtrToStructure(OTBFunctions.GetIntPtrOffset(pServerData, structSize * i), typeof(OTCServerData));
serverData[i] = new ServerBrowserData(
Marshal.PtrToStringUni(myData.m_clsid),
Marshal.PtrToStringUni(myData.m_progId),
Marshal.PtrToStringUni(myData.m_description),
Marshal.PtrToStringUni(myData.m_vProgId),
(EnumOPCSpecification)myData.m_opcSpecification,
Marshal.PtrToStringUni(myData.m_url));
OTBFunctions.OTFreeMemory(myData.m_clsid);
OTBFunctions.OTFreeMemory(myData.m_progId);
OTBFunctions.OTFreeMemory(myData.m_description);
OTBFunctions.OTFreeMemory(myData.m_vProgId);
OTBFunctions.OTFreeMemory(myData.m_url);
} // end for
OTBFunctions.OTFreeMemory(pServerData);
} // end if
} // end if
}
catch (Exception exc)
{
Application.Instance.Trace(
EnumTraceLevel.ERR,
EnumTraceGroup.CLIENT,
"ServerBrowser.Browse",
exc.ToString());
}
return(res);
}
} // end SetEUInfoAnalog
/// <summary>
///
/// </summary>
/// <param name="enumeratedValues"></param>
/// <returns></returns>
/// <include
/// file='TBNS.doc.xml'
/// path='//class[@name="DaAddressSpaceElement"]/
/// method[@name="SetEUInfoEnumerated"]/doc/*'
/// />
public int SetEUInfoEnumerated(string[] enumeratedValues)
{
return OTBFunctions.OTSSetEUInfo(m_objectHandle, true, enumeratedValues.Length, enumeratedValues, 0, 0);
} // end SetEUInfoEnumerated
} // end Change
/// <summary>
/// Used to add the Engineering Units related properties as Analog EU type
/// </summary>
/// <param name="lowEULimit">Low value for the property 102</param>
/// <param name="highEULimit">High value for the property 103</param>
/// <returns>result code</returns>
/// <include
/// file='TBNS.doc.xml'
/// path='//class[@name="DaAddressSpaceElement"]/
/// method[@name="SetEUInfoAnalog"]/doc/*'
/// />
public int SetEUInfoAnalog(double lowEULimit, double highEULimit)
{
return OTBFunctions.OTSSetEUInfo(m_objectHandle, false, 0, null, lowEULimit, highEULimit);
} // end SetEUInfoAnalog
} // end CompleteRequest
/// <summary>
/// Changes the cache value for the Address space elements provided
/// </summary>
/// <returns>
/// E_INVALIDARG - Invalid valueQT was passed
/// S_OK - Value changed
/// OTS_E_EXCEPTION - Unexpected error occurred
/// The Result should be checked with ResultCode.SUCCEEDED
/// or with ResultCode.FAILED
/// </returns>
/// <include
/// file='TBNS.doc.xml'
/// path='//class[@name="DaTransaction"]/
/// method[@name="ValuesChanged"]/doc/*'
/// />
public int ValuesChanged()
{
int result;
int count = 0;
OTValueData[] values = null;
uint[] handles = null;
try
{
lock (m_requestListJanitor)
{
count = m_requestList.Count;
values = new OTValueData[count];
handles = new uint[count];
for (int i = 0; i < count; i++)
{
OTValueData valueData = new OTValueData();
DaRequest request = m_requestList[i] as DaRequest;
if (request != null)
{
valueData.m_quality = (ushort) request.Value.Quality;
valueData.m_timestamp = new OTDateTime(request.Value.TimeStamp);
valueData.m_value = Marshal.AllocCoTaskMem(ValueQT.VARIANT_SIZE);
Marshal.GetNativeVariantForObject(request.Value.Data, valueData.m_value);
handles[i] = request.AddressSpaceElement.ObjectHandle;
request.Result = EnumResultCode.S_OK;
}
else
{
valueData.m_quality = (ushort) EnumQuality.BAD;
valueData.m_value = Marshal.AllocCoTaskMem(ValueQT.VARIANT_SIZE);
Marshal.GetNativeVariantForObject(null, valueData.m_value);
handles[i] = 0;
} // end if ... else
values[i] = valueData;
} // end for
result = OTBFunctions.OTSValuesChanged(count, handles, values);
} // end lock
}
catch (Exception e)
{
Application.Instance.Trace(
EnumTraceLevel.ERR, EnumTraceGroup.OPCSERVER,
"DaTransaction.ValuesChanged", "Exception caught: " + e.ToString());
result = (int) EnumResultCode.E_FAIL;
}
finally
{
for (int i = 0; i < count; i++)
{
OTBFunctions.OTVariantClear(values[i].m_value);
Marshal.FreeCoTaskMem(values[i].m_value);
} // end for
} // end try ... catch ... finally
return result;
} // end ValuesChanged
