Opc.Ua.Com.Client.ComHdaClientNodeManager.DoMetadataUpdate C# (CSharp) Method

DoMetadataUpdate() private method

Updates the type cache.
private DoMetadataUpdate ( object state ) : void
state object
return void
        private void DoMetadataUpdate(object state)
        {
            try
            {
                if (!Server.IsRunning)
                {
                    return;
                }

                ComHdaClientManager system = (ComHdaClientManager)SystemContext.SystemHandle;
                ComHdaClient client = (ComHdaClient)system.SelectClient(SystemContext, true);

                client.UpdateServerMetadata();
                BaseObjectState[] aggregates = client.GetSupportedAggregates(NamespaceIndex);

                lock (Lock)
                {
                    m_capabilities.MaxReturnDataValues.Value = (uint)client.GetServerCapabilities(Opc.Ua.Variables.HistoryServerCapabilitiesType_MaxReturnDataValues, 0);
                    m_capabilities.InsertDataCapability.Value = (bool)client.GetServerCapabilities(Opc.Ua.Variables.HistoryServerCapabilitiesType_InsertDataCapability, false);
                    m_capabilities.ReplaceDataCapability.Value = (bool)client.GetServerCapabilities(Opc.Ua.Variables.HistoryServerCapabilitiesType_ReplaceDataCapability, false);
                    m_capabilities.UpdateDataCapability.Value = (bool)client.GetServerCapabilities(Opc.Ua.Variables.HistoryServerCapabilitiesType_UpdateDataCapability, false);
                    m_capabilities.InsertAnnotationCapability.Value = (bool)client.GetServerCapabilities(Opc.Ua.Variables.HistoryServerCapabilitiesType_ReplaceDataCapability, false);
                    m_capabilities.DeleteRawCapability.Value = (bool)client.GetServerCapabilities(Opc.Ua.Variables.HistoryServerCapabilitiesType_DeleteRawCapability, false);
                    m_capabilities.DeleteAtTimeCapability.Value = (bool)client.GetServerCapabilities(Opc.Ua.Variables.HistoryServerCapabilitiesType_DeleteAtTimeCapability, false);

                    if (m_aggregates == null)
                    {
                        m_aggregates = aggregates;
                        m_capabilities.AggregateFunctions.RemoveReferences(Opc.Ua.ReferenceTypeIds.Organizes, false);

                        if (m_aggregates != null)
                        {
                            for (int ii = 0; ii < m_aggregates.Length; ii++)
                            {
                                AddPredefinedNode(SystemContext, m_aggregates[ii]);
                                m_capabilities.AggregateFunctions.AddReference(Opc.Ua.ReferenceTypeIds.Organizes, false, m_aggregates[ii].NodeId);
                                m_aggregates[ii].AddReference(Opc.Ua.ReferenceTypeIds.Organizes, true, m_capabilities.AggregateFunctions.NodeId);
                            }
                        }
                    }
                }

                lock (Server.DiagnosticsLock)
                {
                    HistoryServerCapabilitiesState capabilities = Server.DiagnosticsNodeManager.GetDefaultHistoryCapabilities();

                    capabilities.AccessHistoryDataCapability.Value = true;

                    if (capabilities.MaxReturnDataValues.Value < m_capabilities.MaxReturnDataValues.Value)
                    {
                        capabilities.MaxReturnDataValues.Value = m_capabilities.MaxReturnDataValues.Value;
                    }

                    if (m_capabilities.InsertDataCapability.Value)
                    {
                        capabilities.InsertDataCapability.Value = true;
                    }

                    if (m_capabilities.ReplaceDataCapability.Value)
                    {
                        capabilities.ReplaceDataCapability.Value = true;
                    }

                    if (m_capabilities.UpdateDataCapability.Value)
                    {
                        capabilities.UpdateDataCapability.Value = true;
                    }

                    if (m_capabilities.InsertAnnotationCapability.Value)
                    {
                        capabilities.InsertAnnotationCapability.Value = true;
                    }

                    if (m_capabilities.DeleteRawCapability.Value)
                    {
                        capabilities.DeleteRawCapability.Value = true;
                    }

                    if (m_capabilities.DeleteAtTimeCapability.Value)
                    {
                        capabilities.DeleteAtTimeCapability.Value = true;
                    }

                    if (m_aggregates != null)
                    {
                        for (int ii = 0; ii < m_aggregates.Length; ii++)
                        {
                            if (!capabilities.AggregateFunctions.ReferenceExists(Opc.Ua.ReferenceTypeIds.Organizes, false, aggregates[ii].NodeId))
                            {
                                capabilities.AggregateFunctions.AddReference(Opc.Ua.ReferenceTypeIds.Organizes, false, aggregates[ii].NodeId);
                            }
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Utils.Trace(e, "Unexpected error updating HDA server metadata.");
            }
        }
        #endregion