Provides access to a COM DA server.
Inheritance: ComClient
Beispiel #1
0
        /// <summary>
        /// Creates an empty group.
        /// </summary>
        /// <param name="server">The server that the group belongs to.</param>
        /// <param name="callbacksRequired">if set to <c>true</c> if the group will received callbacks.</param>
        public ComDaGroup(ComDaClient server, bool callbacksRequired)
        {
            m_server = server;
            m_clientHandle = Utils.IncrementIdentifier(ref m_groupCounter);
            m_serverHandle = 0;
            m_items = new List<GroupItem>();

            if (callbacksRequired)
            {
                m_monitoredItems = new Dictionary<int, DataChangeInfo>();
            }

            // Utils.Trace("GROUP {0}", m_clientHandle);
        }
Beispiel #2
0
        /// <summary>
        /// Applies any changes to the groups.
        /// </summary>
        public void ApplyGroupChanges(ComDaClient client)
        {
            List<ComDaGroup> groups = null;
            List<SubscribeItemRequest> items = null;

            lock (m_lock)
            {
                items = new List<SubscribeItemRequest>(m_subscribedItems.Values);

                // modify or remove items.
                for (int ii = 0; ii < items.Count; ii++)
                {
                    SubscribeItemRequest request = items[ii];

                    // remove unused requests.
                    if (request.MonitoredItems.Count == 0)
                    {
                        if (request.Group != null && request.GroupItem != null)
                        {
                            request.Group.RemoveItem(request.GroupItem);
                        }

                        Remove(request);
                        continue;
                    }
                }

                // add any new items to groups.
                for (int ii = 0; ii < items.Count; ii++)
                {
                    SubscribeItemRequest request = items[ii];

                    if (!request.Changed)
                    {
                        continue;
                    }

                    UpdateGroup(client, request);
                }

                groups = new List<ComDaGroup>(m_groups.Count);

                // update group on the server.
                for (int ii = 0; ii < m_groups.Count; ii++)
                {
                    if (m_groups[ii].ApplyChanges())
                    {
                        groups.Add(m_groups[ii]);
                    }
                    else
                    {
                        m_groups[ii].Delete();
                    }
                }

                m_groups = groups;

                // update request.
                for (int ii = 0; ii < items.Count; ii++)
                {
                    if (items[ii].Changed)
                    {
                        items[ii].ChangesComplete();
                    }
                }

                // modify or remove items.
                List<SubscribePropertyRequest> properties = new List<SubscribePropertyRequest>(m_subscribedProperties.Values);

                for (int ii = 0; ii < properties.Count; ii++)
                {
                    SubscribePropertyRequest request = properties[ii];

                    // remove unused requests.
                    if (request.MonitoredItems == null || request.MonitoredItems.Count == 0)
                    {
                        Remove(request);
                        continue;
                    }

                    request.ChangesComplete(m_propertySamplingInterval);
                }
                
                // check if the property scanner needs to be stopped/started.
                if (m_propertyScanTimer == null)
                {
                    if (m_subscribedProperties.Count > 0)
                    {
                        m_propertyScanTimer = new Timer(OnScanProperties, null, 0, m_propertySamplingInterval);
                    }
                }
                else
                {
                    if (m_subscribedProperties.Count == 0)
                    {
                        m_propertyScanTimer.Dispose();
                        m_propertyScanTimer = null;
                    }
                }
            }
        }
Beispiel #3
0
 /// <summary>
 /// Creates a new instance of the client with the same configuration.
 /// </summary>
 /// <returns>The copy of the client.</returns>
 public ComDaClient CloneClient()
 {
     ComDaClient clone = new ComDaClient(m_configuration);
     clone.LocaleId = this.LocaleId;
     clone.UserIdentity = this.UserIdentity;
     clone.Key = this.Key;
     return clone;
 }
Beispiel #4
0
        /// <summary>
        /// Assigns a request to a group.
        /// </summary>
        /// <param name="client">The client.</param>
        /// <param name="request">The request.</param>
        public void UpdateGroup(ComDaClient client, SubscribeItemRequest request)
        {
            lock (m_lock)
            {
                // check for empty request.
                if (request.MonitoredItems.Count == 0)
                {
                    return;
                }

                request.Update();

                // check if existing group can be used.
                if (request.Group != null)
                {
                    if (request.Group.ModifyItem(request.GroupItem, request.SamplingInterval, request.Deadband, request.Active))
                    {
                        if (request.GroupItem.Active != request.Active)
                        {
                            request.GroupItem.Active = request.Active;
                            request.GroupItem.ActiveChanged = true;
                        }

                        request.Group.SetMonitoredItems(request.GroupItem, request.MonitoredItems.ToArray());
                        return;
                    }
                }

                // clear link to existing group.
                request.Group = null;
                request.GroupItem = null;
                
                // assign to an existing group.
                for (int ii = 0; ii < m_groups.Count; ii++)
                {
                    ComDaGroup group = m_groups[ii];

                    request.GroupItem = group.CreateItem(request.ItemId, request.SamplingInterval, request.Deadband, request.Active);

                    if (request.GroupItem != null)
                    {
                        request.Group = group;
                        request.Group.SetMonitoredItems(request.GroupItem, request.MonitoredItems.ToArray());
                        return; 
                    }
                }

                // create a new group.
                request.Group = new ComDaGroup(client, true);
                request.GroupItem = request.Group.CreateItem(request.ItemId, request.SamplingInterval, request.Deadband, request.Active);
                request.Group.SetMonitoredItems(request.GroupItem, request.MonitoredItems.ToArray());
                m_groups.Add(request.Group);
            }
        }
Beispiel #5
0
 /// <summary>
 /// Initializes a new instance of the <see cref="Da20ElementBrowser"/> class.
 /// </summary>
 /// <param name="client">The client.</param>
 /// <param name="itemId">The item id.</param>
 /// <param name="browseToNotSupported">if set to <c>true</c> BROWSE_TO not supported.</param>
 public Da20ElementBrowser(
     ComDaClient client, 
     string itemId,
     bool browseToNotSupported)
 {
     m_client = client;
     m_itemId = itemId;
     m_branches = false;
     m_browseToNotSupported = browseToNotSupported;
 }