611 lines
22 KiB
C#
611 lines
22 KiB
C#
#region Copyright (c) 2011-2023 Technosoftware GmbH. All rights reserved
|
|
//-----------------------------------------------------------------------------
|
|
// Copyright (c) 2011-2023 Technosoftware GmbH. All rights reserved
|
|
// Web: https://www.technosoftware.com
|
|
//
|
|
// The source code in this file is covered under a dual-license scenario:
|
|
// - Owner of a purchased license: SCLA 1.0
|
|
// - GPL V3: everybody else
|
|
//
|
|
// SCLA license terms accompanied with this source code.
|
|
// See SCLA 1.0: https://technosoftware.com/license/Source_Code_License_Agreement.pdf
|
|
//
|
|
// GNU General Public License as published by the Free Software Foundation;
|
|
// version 3 of the License are accompanied with this source code.
|
|
// See https://technosoftware.com/license/GPLv3License.txt
|
|
//
|
|
// This source code is distributed in the hope that it will be useful, but
|
|
// WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
|
// or FITNESS FOR A PARTICULAR PURPOSE.
|
|
//-----------------------------------------------------------------------------
|
|
#endregion Copyright (c) 2011-2023 Technosoftware GmbH. All rights reserved
|
|
|
|
#region Using Directives
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Runtime.Serialization;
|
|
|
|
#endregion
|
|
|
|
namespace Technosoftware.DaAeHdaClient.Ae
|
|
{
|
|
/// <summary>
|
|
/// An in-process object which provides access to AE subscription objects.
|
|
/// </summary>
|
|
[Serializable]
|
|
public class TsCAeSubscription : ITsCAeSubscription, ISerializable, ICloneable
|
|
{
|
|
#region CategoryCollection Class
|
|
/// <summary>
|
|
/// Contains a read-only collection category ids.
|
|
/// </summary>
|
|
public class CategoryCollection : OpcReadOnlyCollection
|
|
{
|
|
#region Constructors, Destructor, Initialization
|
|
/// <summary>
|
|
/// Creates an empty collection.
|
|
/// </summary>
|
|
internal CategoryCollection() : base(new int[0]) { }
|
|
|
|
/// <summary>
|
|
/// Creates a collection containing the list of category ids.
|
|
/// </summary>
|
|
internal CategoryCollection(int[] categoryIDs) : base(categoryIDs) { }
|
|
#endregion
|
|
|
|
#region Public Methods
|
|
/// <summary>
|
|
/// An indexer for the collection.
|
|
/// </summary>
|
|
public new int this[int index] => (int)Array.GetValue(index);
|
|
|
|
/// <summary>
|
|
/// Returns a copy of the collection as an array.
|
|
/// </summary>
|
|
public new int[] ToArray()
|
|
{
|
|
return (int[])OpcConvert.Clone(Array);
|
|
}
|
|
#endregion
|
|
}
|
|
#endregion
|
|
|
|
#region StringCollection Class
|
|
/// <summary>
|
|
/// Contains a read-only collection of strings.
|
|
/// </summary>
|
|
public class StringCollection : OpcReadOnlyCollection
|
|
{
|
|
#region Constructors, Destructor, Initialization
|
|
/// <summary>
|
|
/// Creates an empty collection.
|
|
/// </summary>
|
|
internal StringCollection() : base(new string[0]) { }
|
|
|
|
/// <summary>
|
|
/// Creates a collection containing the specified strings.
|
|
/// </summary>
|
|
internal StringCollection(string[] strings) : base(strings) { }
|
|
#endregion
|
|
|
|
#region Public Methods
|
|
/// <summary>
|
|
/// An indexer for the collection.
|
|
/// </summary>
|
|
public new string this[int index] => (string)Array.GetValue(index);
|
|
|
|
/// <summary>
|
|
/// Returns a copy of the collection as an array.
|
|
/// </summary>
|
|
public new string[] ToArray()
|
|
{
|
|
return (string[])OpcConvert.Clone(Array);
|
|
}
|
|
#endregion
|
|
}
|
|
#endregion
|
|
|
|
#region AttributeDictionary Class
|
|
/// <summary>
|
|
/// Contains a read-only dictionary of attribute lists indexed by category id.
|
|
/// </summary>
|
|
[Serializable]
|
|
public class AttributeDictionary : OpcReadOnlyDictionary
|
|
{
|
|
#region Constructors, Destructor, Initialization
|
|
/// <summary>
|
|
/// Creates an empty collection.
|
|
/// </summary>
|
|
internal AttributeDictionary() : base(null) { }
|
|
|
|
/// <summary>
|
|
/// Constructs an dictionary from a set of category ids.
|
|
/// </summary>
|
|
internal AttributeDictionary(Hashtable dictionary) : base(dictionary) { }
|
|
#endregion
|
|
|
|
#region Public Methods
|
|
/// <summary>
|
|
/// Gets or sets the attribute collection for the specified category.
|
|
/// </summary>
|
|
public AttributeCollection this[int categoryId] => (AttributeCollection)base[categoryId];
|
|
|
|
/// <summary>
|
|
/// Adds or replaces the set of attributes associated with the category.
|
|
/// </summary>
|
|
internal void Update(int categoryId, int[] attributeIDs)
|
|
{
|
|
Dictionary[categoryId] = new AttributeCollection(attributeIDs);
|
|
}
|
|
#endregion
|
|
|
|
#region ISerializable Members
|
|
/// <summary>
|
|
/// Constructs an object by deserializing it from a stream.
|
|
/// </summary>
|
|
protected AttributeDictionary(SerializationInfo info, StreamingContext context) : base(info, context) { }
|
|
#endregion
|
|
}
|
|
#endregion
|
|
|
|
#region AttributeCollection Class
|
|
/// <summary>
|
|
/// Contains a read-only collection attribute ids.
|
|
/// </summary>
|
|
[Serializable]
|
|
public class AttributeCollection : OpcReadOnlyCollection
|
|
{
|
|
#region Constructors, Destructor, Initialization
|
|
/// <summary>
|
|
/// Creates an empty collection.
|
|
/// </summary>
|
|
internal AttributeCollection() : base(new int[0]) { }
|
|
|
|
/// <summary>
|
|
/// Creates a collection containing the specified attribute ids.
|
|
/// </summary>
|
|
internal AttributeCollection(int[] attributeIDs) : base(attributeIDs) { }
|
|
#endregion
|
|
|
|
#region Public Methods
|
|
/// <summary>
|
|
/// An indexer for the collection.
|
|
/// </summary>
|
|
public new int this[int index] => (int)Array.GetValue(index);
|
|
|
|
/// <summary>
|
|
/// Returns a copy of the collection as an array.
|
|
/// </summary>
|
|
public new int[] ToArray()
|
|
{
|
|
return (int[])OpcConvert.Clone(Array);
|
|
}
|
|
#endregion
|
|
|
|
#region ISerializable Members
|
|
/// <summary>
|
|
/// Constructs an object by deserializing it from a stream.
|
|
/// </summary>
|
|
protected AttributeCollection(SerializationInfo info, StreamingContext context) : base(info, context) { }
|
|
#endregion
|
|
}
|
|
#endregion
|
|
|
|
#region Names Class
|
|
/// <summary>
|
|
/// A set of names for fields used in serialization.
|
|
/// </summary>
|
|
private class Names
|
|
{
|
|
internal const string State = "ST";
|
|
internal const string Filters = "FT";
|
|
internal const string Attributes = "AT";
|
|
}
|
|
#endregion
|
|
|
|
#region Fields
|
|
private bool disposed_;
|
|
private TsCAeServer server_;
|
|
private ITsCAeSubscription subscription_;
|
|
|
|
// state
|
|
private TsCAeSubscriptionState state_;
|
|
private string name_;
|
|
|
|
// filters
|
|
private TsCAeSubscriptionFilters subscriptionFilters_ = new TsCAeSubscriptionFilters();
|
|
private CategoryCollection categories_ = new CategoryCollection();
|
|
private StringCollection areas_ = new StringCollection();
|
|
private StringCollection sources_ = new StringCollection();
|
|
|
|
// returned attributes
|
|
private AttributeDictionary attributes_ = new AttributeDictionary();
|
|
#endregion
|
|
|
|
#region Constructors, Destructor, Initialization
|
|
/// <summary>
|
|
/// Initializes object with default values.
|
|
/// </summary>
|
|
public TsCAeSubscription(TsCAeServer server, ITsCAeSubscription subscription, TsCAeSubscriptionState state)
|
|
{
|
|
server_ = server ?? throw new ArgumentNullException(nameof(server));
|
|
subscription_ = subscription ?? throw new ArgumentNullException(nameof(subscription));
|
|
state_ = (TsCAeSubscriptionState)state.Clone();
|
|
name_ = state.Name;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The finalizer implementation.
|
|
/// </summary>
|
|
~TsCAeSubscription()
|
|
{
|
|
Dispose(false);
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public virtual void Dispose()
|
|
{
|
|
Dispose(true);
|
|
// Take yourself off the Finalization queue
|
|
// to prevent finalization code for this object
|
|
// from executing a second time.
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Dispose(bool disposing) executes in two distinct scenarios.
|
|
/// If disposing equals true, the method has been called directly
|
|
/// or indirectly by a user's code. Managed and unmanaged resources
|
|
/// can be disposed.
|
|
/// If disposing equals false, the method has been called by the
|
|
/// runtime from inside the finalizer and you should not reference
|
|
/// other objects. Only unmanaged resources can be disposed.
|
|
/// </summary>
|
|
/// <param name="disposing">If true managed and unmanaged resources can be disposed. If false only unmanaged resources.</param>
|
|
protected virtual void Dispose(bool disposing)
|
|
{
|
|
// Check to see if Dispose has already been called.
|
|
if (!disposed_)
|
|
{
|
|
// If disposing equals true, dispose all managed
|
|
// and unmanaged resources.
|
|
if (disposing)
|
|
{
|
|
if (subscription_ != null)
|
|
{
|
|
server_.SubscriptionDisposed(this);
|
|
subscription_.Dispose();
|
|
}
|
|
}
|
|
// Release unmanaged resources. If disposing is false,
|
|
// only the following code is executed.
|
|
}
|
|
disposed_ = true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Properties
|
|
|
|
/// <summary>
|
|
/// The server that the subscription object belongs to.
|
|
/// </summary>
|
|
public TsCAeServer Server => server_;
|
|
|
|
/// <summary>
|
|
/// A descriptive name for the subscription.
|
|
/// </summary>
|
|
public string Name => state_.Name;
|
|
|
|
/// <summary>
|
|
/// A unique identifier for the subscription assigned by the client.
|
|
/// </summary>
|
|
public object ClientHandle => state_.ClientHandle;
|
|
|
|
/// <summary>
|
|
/// Whether the subscription is monitoring for events to send to the client.
|
|
/// </summary>
|
|
public bool Active => state_.Active;
|
|
|
|
/// <summary>
|
|
/// The maximum rate at which the server send event notifications.
|
|
/// The <see cref="ApplicationInstance.TimeAsUtc">ApplicationInstance.TimeAsUtc</see> property defines
|
|
/// the time format (UTC or local time).
|
|
/// </summary>
|
|
public int BufferTime => state_.BufferTime;
|
|
|
|
/// <summary>
|
|
/// The requested maximum number of events that will be sent in a single callback.
|
|
/// </summary>
|
|
public int MaxSize => state_.MaxSize;
|
|
|
|
/// <summary>
|
|
/// The maximum period between updates sent to the client.
|
|
/// </summary>
|
|
public int KeepAlive => state_.KeepAlive;
|
|
|
|
/// <summary>
|
|
/// A mask indicating which event types should be sent to the client.
|
|
/// </summary>
|
|
public int EventTypes => subscriptionFilters_.EventTypes;
|
|
|
|
/// <summary>
|
|
/// The highest severity for the events that should be sent to the client.
|
|
/// </summary>
|
|
// ReSharper disable once UnusedMember.Global
|
|
public int HighSeverity => subscriptionFilters_.HighSeverity;
|
|
|
|
/// <summary>
|
|
/// The lowest severity for the events that should be sent to the client.
|
|
/// </summary>
|
|
// ReSharper disable once UnusedMember.Global
|
|
public int LowSeverity => subscriptionFilters_.LowSeverity;
|
|
|
|
/// <summary>
|
|
/// The event category ids monitored by this subscription.
|
|
/// </summary>
|
|
public CategoryCollection Categories => categories_;
|
|
|
|
/// <summary>
|
|
/// A list of full-qualified ids for process areas of interest - only events or conditions in these areas will be reported.
|
|
/// </summary>
|
|
public StringCollection Areas => areas_;
|
|
|
|
/// <summary>
|
|
/// A list of full-qualified ids for sources of interest - only events or conditions from these sources will be reported.
|
|
/// </summary>
|
|
public StringCollection Sources => sources_;
|
|
|
|
/// <summary>
|
|
/// The list of attributes returned for each event category.
|
|
/// </summary>
|
|
public AttributeDictionary Attributes => attributes_;
|
|
#endregion
|
|
|
|
#region Public Methods
|
|
/// <summary>
|
|
/// Returns a writable copy of the current attributes.
|
|
/// </summary>
|
|
public TsCAeAttributeDictionary GetAttributes()
|
|
{
|
|
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
|
|
var attributes = new TsCAeAttributeDictionary();
|
|
|
|
var enumerator = attributes_.GetEnumerator();
|
|
|
|
while (enumerator.MoveNext())
|
|
{
|
|
if (enumerator.Key != null)
|
|
{
|
|
var categoryId = (int)enumerator.Key;
|
|
var attributeIDs = (AttributeCollection)enumerator.Value;
|
|
|
|
attributes.Add(categoryId, attributeIDs.ToArray());
|
|
}
|
|
}
|
|
|
|
return attributes;
|
|
}
|
|
#endregion
|
|
|
|
#region ISerializable Members
|
|
/// <summary>
|
|
/// Constructs a server by de-serializing its OpcUrl from the stream.
|
|
/// </summary>
|
|
protected TsCAeSubscription(SerializationInfo info, StreamingContext context)
|
|
{
|
|
state_ = (TsCAeSubscriptionState)info.GetValue(Names.State, typeof(TsCAeSubscriptionState));
|
|
subscriptionFilters_ = (TsCAeSubscriptionFilters)info.GetValue(Names.Filters, typeof(TsCAeSubscriptionFilters));
|
|
attributes_ = (AttributeDictionary)info.GetValue(Names.Attributes, typeof(AttributeDictionary));
|
|
|
|
name_ = state_.Name;
|
|
|
|
categories_ = new CategoryCollection(subscriptionFilters_.Categories.ToArray());
|
|
areas_ = new StringCollection(subscriptionFilters_.Areas.ToArray());
|
|
sources_ = new StringCollection(subscriptionFilters_.Sources.ToArray());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Serializes a server into a stream.
|
|
/// </summary>
|
|
public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
|
|
{
|
|
info.AddValue(Names.State, state_);
|
|
info.AddValue(Names.Filters, subscriptionFilters_);
|
|
info.AddValue(Names.Attributes, attributes_);
|
|
}
|
|
#endregion
|
|
|
|
#region ICloneable Members
|
|
/// <summary>
|
|
/// Returns an unconnected copy of the subscription with the same items.
|
|
/// </summary>
|
|
public virtual object Clone()
|
|
{
|
|
// do a memberwise clone.
|
|
var clone = (TsCAeSubscription)MemberwiseClone();
|
|
|
|
/*
|
|
// place clone in disconnected state.
|
|
clone.server = null;
|
|
clone.subscription = null;
|
|
clone.state = (SubscriptionState)state.Clone();
|
|
|
|
// clear server handles.
|
|
clone.state.ServerHandle = null;
|
|
|
|
// always make cloned subscriptions inactive.
|
|
clone.state.Active = false;
|
|
|
|
// clone items.
|
|
if (clone.items != null)
|
|
{
|
|
ArrayList items = new ArrayList();
|
|
|
|
foreach (Item item in clone.items)
|
|
{
|
|
items.Add(item.Clone());
|
|
}
|
|
|
|
clone.items = (Item[])items.ToArray(typeof(Item));
|
|
}
|
|
*/
|
|
|
|
// return clone.
|
|
return clone;
|
|
}
|
|
#endregion
|
|
|
|
#region ISubscription Members
|
|
/// <summary>
|
|
/// An event to receive data change updates.
|
|
/// </summary>
|
|
public event TsCAeDataChangedEventHandler DataChangedEvent
|
|
{
|
|
add => subscription_.DataChangedEvent += value;
|
|
remove => subscription_.DataChangedEvent -= value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the current state of the subscription.
|
|
/// </summary>
|
|
/// <returns>The current state of the subscription.</returns>
|
|
public TsCAeSubscriptionState GetState()
|
|
{
|
|
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
|
|
if (subscription_ == null) throw new NotConnectedException();
|
|
|
|
state_ = subscription_.GetState();
|
|
state_.Name = name_;
|
|
|
|
return (TsCAeSubscriptionState)state_.Clone();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Changes the state of a subscription.
|
|
/// </summary>
|
|
/// <param name="masks">A bit mask that indicates which elements of the subscription state are changing.</param>
|
|
/// <param name="state">The new subscription state.</param>
|
|
/// <returns>The actual subscription state after applying the changes.</returns>
|
|
public TsCAeSubscriptionState ModifyState(int masks, TsCAeSubscriptionState state)
|
|
{
|
|
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
|
|
if (subscription_ == null) throw new NotConnectedException();
|
|
|
|
state_ = subscription_.ModifyState(masks, state);
|
|
|
|
if ((masks & (int)TsCAeStateMask.Name) != 0)
|
|
{
|
|
state_.Name = name_ = state.Name;
|
|
}
|
|
else
|
|
{
|
|
state_.Name = name_;
|
|
}
|
|
|
|
return (TsCAeSubscriptionState)state_.Clone();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the current filters for the subscription.
|
|
/// </summary>
|
|
/// <returns>The current filters for the subscription.</returns>
|
|
public TsCAeSubscriptionFilters GetFilters()
|
|
{
|
|
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
|
|
if (subscription_ == null) throw new NotConnectedException();
|
|
|
|
subscriptionFilters_ = subscription_.GetFilters();
|
|
categories_ = new CategoryCollection(subscriptionFilters_.Categories.ToArray());
|
|
areas_ = new StringCollection(subscriptionFilters_.Areas.ToArray());
|
|
sources_ = new StringCollection(subscriptionFilters_.Sources.ToArray());
|
|
|
|
return (TsCAeSubscriptionFilters)subscriptionFilters_.Clone();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the current filters for the subscription.
|
|
/// </summary>
|
|
/// <param name="filters">The new filters to use for the subscription.</param>
|
|
public void SetFilters(TsCAeSubscriptionFilters filters)
|
|
{
|
|
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
|
|
if (subscription_ == null) throw new NotConnectedException();
|
|
|
|
subscription_.SetFilters(filters);
|
|
|
|
GetFilters();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the set of attributes to return with event notifications.
|
|
/// </summary>
|
|
/// <returns>The set of attributes to returned with event notifications.</returns>
|
|
public int[] GetReturnedAttributes(int eventCategory)
|
|
{
|
|
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
|
|
if (subscription_ == null) throw new NotConnectedException();
|
|
|
|
var attributeIDs = subscription_.GetReturnedAttributes(eventCategory);
|
|
|
|
attributes_.Update(eventCategory, (int[])OpcConvert.Clone(attributeIDs));
|
|
|
|
return attributeIDs;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Selects the set of attributes to return with event notifications.
|
|
/// </summary>
|
|
/// <param name="eventCategory">The specific event category for which the attributes apply.</param>
|
|
/// <param name="attributeIDs">The list of attribute ids to return.</param>
|
|
public void SelectReturnedAttributes(int eventCategory, int[] attributeIDs)
|
|
{
|
|
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
|
|
if (subscription_ == null) throw new NotConnectedException();
|
|
|
|
subscription_.SelectReturnedAttributes(eventCategory, attributeIDs);
|
|
|
|
attributes_.Update(eventCategory, (int[])OpcConvert.Clone(attributeIDs));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Force a refresh for all active conditions and inactive, unacknowledged conditions whose event notifications match the filter of the event subscription.
|
|
/// </summary>
|
|
public void Refresh()
|
|
{
|
|
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
|
|
if (subscription_ == null) throw new NotConnectedException();
|
|
|
|
subscription_.Refresh();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Cancels an outstanding refresh request.
|
|
/// </summary>
|
|
public void CancelRefresh()
|
|
{
|
|
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
|
|
if (subscription_ == null) throw new NotConnectedException();
|
|
|
|
subscription_.CancelRefresh();
|
|
}
|
|
#endregion
|
|
|
|
#region Internal Properties
|
|
/// <summary>
|
|
/// The current state.
|
|
/// </summary>
|
|
internal TsCAeSubscriptionState State => state_;
|
|
|
|
/// <summary>
|
|
/// The current filters.
|
|
/// </summary>
|
|
internal TsCAeSubscriptionFilters Filters => subscriptionFilters_;
|
|
|
|
#endregion
|
|
}
|
|
}
|