Esempio n. 1
0
 private static void Analyze(SyntaxNodeAnalysisContext context, ParametersInfo parametersInfo, bool isIndexer = false)
 {
     foreach (KeyValuePair <string, NodeSymbolInfo> kvp in FindUnusedNodes(context, parametersInfo, isIndexer))
     {
         ReportDiagnostic(context, kvp.Value.Node);
     }
 }
        /// <summary>
        /// Analyze the method
        /// </summary>
        private void Analyze()
        {
            //Update basic information
            IsConstructor = Method.IsConstructor;
            IsDestructor  = Method.IsDestructor;
            Paras         = Method.Parameters;
            ReturnType    = Method.ReturnType;

            //Method.
            DeclaringClass = Method.GetAncestors <TypeDefinition>().FirstOrDefault();

            //Initilize parameters' info
            foreach (var para in Paras)
            {
                VariableInfo vi = new VariableInfo(para);
                ParametersInfo.Add(vi);
            }

            var statements = Method.GetDescendantsAndSelf();

            if (statements.Count() > 1)
            {
                HasStatements = true;
            }
            else
            {
                HasStatements = false;
            }

            //Analyze all statement in the method
            foreach (var st in statements)
            {
                AnalyzeStmt(st);
            }
        }
Esempio n. 3
0
        private void ApplyStatus(ParametersInfo info, IList <RemapAlarmResult> result)
        {
            var categoriesSet = new HashSet <AlarmCategoryAbstract>();

            for (var i = 0; i < result.Count; i++)
            {
                var p = info.Parameters[i];
                var r = result[i];
                var c = _categories[p.Item1.CategoryId];
                categoriesSet.Add(c);
                if (p.Item1.GetStatus)
                {
                    c.HasActive         = r.HasActive;
                    c.HasUnacknowledged = r.HasUnacknowledged;
                }
                else
                {
                    c.HasActive         = null;
                    c.HasUnacknowledged = null;
                }
            }
            foreach (var unAppliedCategory in _categories.Values.Where(c => !categoriesSet.Contains(c)))
            {
                unAppliedCategory.HasActive         = null;
                unAppliedCategory.HasUnacknowledged = null;
            }
            ApplyCommonStatus();
        }
Esempio n. 4
0
        public object Invoke(List <object> parameters)
        {
            if (parameters != null && parameters.Count > ParametersInfo.Count())
            {
                throw new ArgumentException("Too many parameters in input");
            }
            if (parameters != null && parameters.Count > 0 && ParametersInfo.Count() == 0)
            {
                throw new ArgumentException("Too many parameters in input");
            }

            if (ParametersInfo == null || ParametersInfo.Count() == 0)
            {
                return(MethodInfo.Invoke(callingInstance, null));
            }

            if (parameters == null || parameters.Count == 0)
            {
                return(MethodInfo.Invoke(callingInstance, new object[ParametersInfo.Count()]));
            }

            object[] realParameters = new object[ParametersInfo.Count()];
            for (int i = 0; i < parameters.Count(); i++)
            {
                realParameters[i] = TypeConvertor.ConvertObject(ParametersInfo[i].ParameterType, parameters[i]);
            }

            return(MethodInfo.Invoke(callingInstance, realParameters));
        }
Esempio n. 5
0
 private void ApplyResult(ParametersInfo info, IList <RemapAlarmResult> result)
 {
     _reporter.Report(result.SelectMany(r => r.Notifications));
     _dispatcherService.Invoke(() => ApplyStatus(info, result));
     ApplyCurrentQueries(info, result);
     ApplyHistoryQueries(info, result);
 }
        public static void AnalyzeIndexerDeclaration(SyntaxNodeAnalysisContext context)
        {
            var indexerDeclaration = (IndexerDeclarationSyntax)context.Node;

            if (indexerDeclaration.ContainsDiagnostics)
                return;

            if (indexerDeclaration.IsParentKind(SyntaxKind.InterfaceDeclaration))
                return;

            if (indexerDeclaration.Modifiers.ContainsAny(SyntaxKind.AbstractKeyword, SyntaxKind.VirtualKeyword, SyntaxKind.OverrideKeyword))
                return;

            ParametersInfo parametersInfo = SyntaxInfo.ParametersInfo(indexerDeclaration);

            if (!parametersInfo.Success)
                return;

            if (ContainsOnlyThrowNewExpression(parametersInfo.Body))
                return;

            IPropertySymbol propertySymbol = context.SemanticModel.GetDeclaredSymbol(indexerDeclaration, context.CancellationToken);

            if (propertySymbol?.ExplicitInterfaceImplementations.IsDefaultOrEmpty != true)
                return;

            if (propertySymbol.ImplementsInterfaceMember())
                return;

            Analyze(context, parametersInfo, isIndexer: true);
        }
Esempio n. 7
0
        public static void AnalyzeAnonymousMethodExpression(SyntaxNodeAnalysisContext context, INamedTypeSymbol eventArgsSymbol)
        {
            var anonymousMethod = (AnonymousMethodExpressionSyntax)context.Node;

            if (anonymousMethod.ContainsDiagnostics)
            {
                return;
            }

            ParametersInfo parametersInfo = SyntaxInfo.ParametersInfo(anonymousMethod);

            if (!parametersInfo.Success)
            {
                return;
            }

            var methodSymbol = (IMethodSymbol)context.SemanticModel.GetSymbol(anonymousMethod, context.CancellationToken);

            if (methodSymbol == null)
            {
                return;
            }

            if (SymbolUtility.IsEventHandlerMethod(methodSymbol, eventArgsSymbol))
            {
                return;
            }

            Analyze(context, parametersInfo);
        }
Esempio n. 8
0
        public static void AnalyzeLocalFunctionStatement(SyntaxNodeAnalysisContext context, INamedTypeSymbol eventArgsSymbol)
        {
            var localFunctionStatement = (LocalFunctionStatementSyntax)context.Node;

            if (localFunctionStatement.ContainsDiagnostics)
            {
                return;
            }

            ParametersInfo parametersInfo = SyntaxInfo.ParametersInfo(localFunctionStatement);

            if (!parametersInfo.Success)
            {
                return;
            }

            var methodSymbol = (IMethodSymbol)context.SemanticModel.GetDeclaredSymbol(localFunctionStatement, context.CancellationToken);

            if (methodSymbol == null)
            {
                return;
            }

            if (SymbolUtility.IsEventHandlerMethod(methodSymbol, eventArgsSymbol))
            {
                return;
            }

            Analyze(context, parametersInfo);
        }
Esempio n. 9
0
 public void Run(IService service)
 {
     _lastInfo = GetParameters();
     if (_lastInfo.Parameters.Any())
     {
         var result = service.RemapAlarms(_lastInfo.Parameters.Select(p => p.Item1).ToArray());
         ApplyResult(_lastInfo, result);
     }
     else
     {
         ApplyResult(new ParametersInfo(), new RemapAlarmResult[0]);
     }
 }
Esempio n. 10
0
 public void Run(IService service)
 {
     _lastInfo = GetParameters();
     if (_lastInfo.Parameters.Any())
     {
         var result = service.RemapAlarms(_lastInfo.Parameters.Select(p => p.Item1).ToArray());
         ApplyResult(_lastInfo, result);
     }
     else
     {
         ApplyResult(new ParametersInfo(), new RemapAlarmResult[0]);
     }
 }
Esempio n. 11
0
        private void ApplyHistoryQueries(ParametersInfo info, IList <RemapAlarmResult> result)
        {
            for (var i = 0; i < result.Count; i++)
            {
                var p = info.Parameters[i];
                RemapAlarmResult      r             = result[i];
                AlarmCategoryAbstract alarmCategory = _categories[p.Item1.CategoryId];
                foreach (Alarm a in r.History.SelectMany(alarms => alarms))
                {
                    var alarmInfo = alarmCategory.GetAlarmInfo(a.AlarmId);
                    a.SetAlarmInfo(alarmInfo.Item1, alarmInfo.Item2, alarmCategory);
                }

                var callbacks = p.Item3;
                for (var j = 0; j < callbacks.Length; j++)
                {
                    var callback = callbacks[j];
                    var alarms   = r.History[info.CommonCurrentInfo.Count + j];
                    callback(alarms);
                }
            }

            for (var i = 0; i < info.CommonHistoryInfo.Count; i++)
            {
                var historyInfo = info.CommonHistoryInfo[i];
                int i1          = i;
                var alarms      = result.SelectMany(r => r.History[i1]);
                switch (historyInfo.Item2)
                {
                case CriteriaType.DownFromInfinity:
                case CriteriaType.DownFrom:
                case CriteriaType.DownFromOrEqual:
                    alarms = alarms.OrderByDescending(a => a.StartTime).ThenByDescending(a => a.AlarmId)
                             .Take(historyInfo.Item3);
                    break;

                case CriteriaType.UpFromInfinity:
                case CriteriaType.UpFrom:
                case CriteriaType.UpFromOrEqual:
                    alarms = alarms.OrderBy(a => a.StartTime).ThenBy(a => a.AlarmId)
                             .Take(historyInfo.Item3).Reverse();
                    break;
                }

                var callback    = historyInfo.Item1;
                var alarmsArray = alarms.ToArray();
                callback(alarmsArray);
            }
        }
        public static void AnalyzeMethodDeclaration(SyntaxNodeAnalysisContext context, INamedTypeSymbol eventArgsSymbol)
        {
            var methodDeclaration = (MethodDeclarationSyntax)context.Node;

            if (methodDeclaration.ContainsDiagnostics)
                return;

            if (methodDeclaration.IsParentKind(SyntaxKind.InterfaceDeclaration))
                return;

            if (methodDeclaration.Modifiers.ContainsAny(SyntaxKind.AbstractKeyword, SyntaxKind.VirtualKeyword, SyntaxKind.OverrideKeyword))
                return;

            ParametersInfo parametersInfo = SyntaxInfo.ParametersInfo(methodDeclaration);

            if (!parametersInfo.Success)
                return;

            if (ContainsOnlyThrowNewExpression(parametersInfo.Body))
                return;

            IMethodSymbol methodSymbol = context.SemanticModel.GetDeclaredSymbol(methodDeclaration, context.CancellationToken);

            if (methodSymbol == null)
                return;

            if (SymbolUtility.IsEventHandlerMethod(methodSymbol, eventArgsSymbol))
                return;

            if (!methodSymbol.ExplicitInterfaceImplementations.IsDefaultOrEmpty)
                return;

            if (methodSymbol.ImplementsInterfaceMember())
                return;

            Dictionary<string, NodeSymbolInfo> unusedNodes = FindUnusedNodes(context, parametersInfo);

            if (unusedNodes.Count == 0)
                return;

            if (IsReferencedAsMethodGroup(context, methodDeclaration))
                return;

            foreach (KeyValuePair<string, NodeSymbolInfo> kvp in unusedNodes)
                ReportDiagnostic(context, kvp.Value.Node);
        }
        public static void AnalyzeOperatorDeclaration(SyntaxNodeAnalysisContext context)
        {
            var operatorDeclaration = (OperatorDeclarationSyntax)context.Node;

            if (operatorDeclaration.ContainsDiagnostics)
                return;

            ParametersInfo parametersInfo = SyntaxInfo.ParametersInfo(operatorDeclaration);

            if (!parametersInfo.Success)
                return;

            if (ContainsOnlyThrowNewExpression(parametersInfo.Body))
                return;

            Analyze(context, parametersInfo);
        }
Esempio n. 14
0
 protected void DeleteButton_Click(object sender, ImageClickEventArgs e)
 {
     try
     {
         ImageButton deleteButton = (ImageButton)sender;
         if (deleteButton != null)
         {
             ParametersInfo parameter = ParametersController.GetParameter(Convert.ToInt32(deleteButton.CommandArgument));
             ParametersController.DropParameter(parameter);
             BindData();
         }
     }
     catch (Exception ex)
     {
         Exceptions.ProcessModuleLoadException(this, ex);
     }
 }
Esempio n. 15
0
        public static void AnalyzeConstructorDeclaration(
            SyntaxNodeAnalysisContext context,
            INamedTypeSymbol serializationInfoSymbol,
            INamedTypeSymbol streamingContextSymbol)
        {
            var constructorDeclaration = (ConstructorDeclarationSyntax)context.Node;

            if (constructorDeclaration.ContainsDiagnostics)
            {
                return;
            }

            ParametersInfo parametersInfo = SyntaxInfo.ParametersInfo(constructorDeclaration);

            if (!parametersInfo.Success)
            {
                return;
            }

            if (ContainsOnlyThrowNewExpression(parametersInfo.Body))
            {
                return;
            }

            // Skip a constructor that is required by ISerializable interface
            if (serializationInfoSymbol != null &&
                parametersInfo.Parameters.Count == 2)
            {
                IMethodSymbol symbol = context.SemanticModel.GetDeclaredSymbol(constructorDeclaration, context.CancellationToken);

                if (symbol != null)
                {
                    ImmutableArray <IParameterSymbol> parameters = symbol.Parameters;

                    if (parameters.Length == 2 &&
                        parameters[0].Type.Equals(serializationInfoSymbol) &&
                        parameters[1].Type.Equals(streamingContextSymbol))
                    {
                        return;
                    }
                }
            }

            Analyze(context, parametersInfo);
        }
Esempio n. 16
0
 protected void EditButton_Click(object sender, ImageClickEventArgs e)
 {
     try
     {
         ImageButton    editButton = (ImageButton)sender;
         ParametersInfo parameter  = ParametersController.GetParameter(Convert.ToInt32(editButton.CommandArgument));
         ParameterTypeDropDownList.SelectedValue = Convert.ToString(Convert.ToInt32(parameter.Type));
         ParameterNameTextBox.Text             = parameter.Name;
         ParameterValueTextBox.Text            = parameter.Argument;
         UseAsHashCheckBox.Checked             = parameter.UseAsHash;
         UpdateParameterButton.Text            = Localization.GetString("UpdateParameter", LocalResourceFile);
         UpdateParameterButton.CommandArgument = editButton.CommandArgument;
         DisplayOrHideParameterFormPanels();
     }
     catch (Exception ex)
     {
         Exceptions.ProcessModuleLoadException(this, ex);
     }
 }
Esempio n. 17
0
        private void CleanQueries()
        {
            var emptyAlarms = new Alarm[0];

            foreach (AlarmCategoryAbstract c in _categories.Values)
            {
                foreach (var t in c.QueriesForCurrent())
                {
                    t.Item4(emptyAlarms);
                }
                foreach (var t in c.QueriesForHistory())
                {
                    t.Item4(emptyAlarms);
                }
            }

            if (_lastInfo != null)
            {
                foreach (var t in _lastInfo.CommonCurrentInfo)
                {
                    t.Item1(emptyAlarms);
                }
                foreach (var t in _lastInfo.CommonHistoryInfo)
                {
                    t.Item1(emptyAlarms);
                }
                foreach (var p in _lastInfo.Parameters)
                {
                    foreach (var callback in p.Item2)
                    {
                        callback(emptyAlarms);
                    }
                    foreach (var callback in p.Item3)
                    {
                        callback(emptyAlarms);
                    }
                }

                _lastInfo = null;
            }
        }
        public static void AnalyzeParenthesizedLambdaExpression(SyntaxNodeAnalysisContext context, INamedTypeSymbol eventArgsSymbol)
        {
            var lambda = (ParenthesizedLambdaExpressionSyntax)context.Node;

            if (lambda.ContainsDiagnostics)
                return;

            ParametersInfo parametersInfo = SyntaxInfo.ParametersInfo(lambda);

            if (!parametersInfo.Success)
                return;

            var methodSymbol = (IMethodSymbol)context.SemanticModel.GetSymbol(lambda, context.CancellationToken);

            if (methodSymbol == null)
                return;

            if (SymbolUtility.IsEventHandlerMethod(methodSymbol, eventArgsSymbol))
                return;

            Analyze(context, parametersInfo);
        }
        public static void AnalyzeConstructorDeclaration(SyntaxNodeAnalysisContext context)
        {
            var constructorDeclaration = (ConstructorDeclarationSyntax)context.Node;

            if (constructorDeclaration.ContainsDiagnostics)
            {
                return;
            }

            ParametersInfo parametersInfo = SyntaxInfo.ParametersInfo(constructorDeclaration);

            if (!parametersInfo.Success)
            {
                return;
            }

            if (ContainsOnlyThrowNewException(parametersInfo.Body, context.SemanticModel, context.CancellationToken))
            {
                return;
            }

            Analyze(context, parametersInfo);
        }
Esempio n. 20
0
        protected void UpdateParameterButton_Click(object sender, EventArgs e)
        {
            try
            {
                LinkButton     updateParameterButton = (LinkButton)sender;
                ParametersInfo parameter;

                if (updateParameterButton.CommandArgument == "-1")
                {
                    parameter = new ParametersInfo();
                }
                else
                {
                    parameter = ParametersController.GetParameter(Convert.ToInt32(updateParameterButton.CommandArgument));
                }
                parameter.ModuleID  = ModuleId;
                parameter.Type      = (ParameterType)Convert.ToInt32(ParameterTypeDropDownList.SelectedValue);
                parameter.Name      = ParameterNameTextBox.Text;
                parameter.Argument  = (ParameterValuePanel.Visible ? ParameterValueTextBox.Text : null);
                parameter.UseAsHash = UseAsHashCheckBox.Checked;
                if (updateParameterButton.CommandArgument == "-1")
                {
                    ParametersController.AddParameter(parameter);
                }
                else
                {
                    ParametersController.ChangeParameter(parameter);
                }

                ResetParametersForm(true);
            }
            catch (Exception ex)
            {
                Exceptions.ProcessModuleLoadException(this, ex);
            }
        }
Esempio n. 21
0
        private void CleanQueries()
        {
            var emptyAlarms = new Alarm[0];

            foreach (var c in _categories.Values)
            {
                foreach (var t in c.QueriesForCurrent())
                {
                    t.Item4(emptyAlarms);
                }
                foreach (var t in c.QueriesForHistory())
                {
                    t.Item4(emptyAlarms);
                }
            }

            if (_lastInfo != null)
            {
                foreach (var t in _lastInfo.CommonCurrentInfo)
                {
                    t.Item1(emptyAlarms);
                }
                foreach (var t in _lastInfo.CommonHistoryInfo)
                {
                    t.Item1(emptyAlarms);
                }
                foreach (var p in _lastInfo.Parameters)
                {
                    foreach (var callback in p.Item2)
                    {
                        callback(emptyAlarms);
                    }
                    foreach (var callback in p.Item3)
                    {
                        callback(emptyAlarms);
                    }
                }
                _lastInfo = null;
            }
        }
Esempio n. 22
0
 private void ApplyStatus(ParametersInfo info, IList<RemapAlarmResult> result)
 {
     var categoriesSet = new HashSet<AlarmCategoryAbstract>();
     for (var i = 0; i < result.Count; i++)
     {
         var p = info.Parameters[i];
         var r = result[i];
         var c = _categories[p.Item1.CategoryId];
         categoriesSet.Add(c);
         if (p.Item1.GetStatus)
         {
             c.HasActive = r.HasActive;
             c.HasUnacknowledged = r.HasUnacknowledged;
         }
         else
         {
             c.HasActive = null;
             c.HasUnacknowledged = null;
         }
     }
     foreach (var unAppliedCategory in _categories.Values.Where(c => !categoriesSet.Contains(c)))
     {
         unAppliedCategory.HasActive = null;
         unAppliedCategory.HasUnacknowledged = null;
     }
     ApplyCommonStatus();
 }
Esempio n. 23
0
 private void ApplyResult(ParametersInfo info, IList<RemapAlarmResult> result)
 {
     _reporter.Report(result.SelectMany(r => r.Notifications));
     _dispatcherService.Invoke(() => ApplyStatus(info, result));
     ApplyCurrentQueries(info, result);
     ApplyHistoryQueries(info, result);
 }
Esempio n. 24
0
 private void ApplyHistoryQueries(ParametersInfo info, IList<RemapAlarmResult> result)
 {
     for (var i = 0; i < result.Count; i++)
     {
         var p = info.Parameters[i];
         var r = result[i];
         var alarmCategory = _categories[p.Item1.CategoryId];
         foreach (var a in r.History.SelectMany(alarms => alarms))
         {
             var alarmInfo = alarmCategory.GetAlarmInfo(a.AlarmId);
             a.SetAlarmInfo(alarmInfo.Item1, alarmInfo.Item2, alarmCategory);
         }
         var callbacks = p.Item3;
         for (var j = 0; j < callbacks.Length; j++)
         {
             var callback = callbacks[j];
             var alarms = r.History[info.CommonCurrentInfo.Count + j];
             callback(alarms);
         }
     }
     for (var i = 0; i < info.CommonHistoryInfo.Count; i++)
     {
         var historyInfo = info.CommonHistoryInfo[i];
         var i1 = i;
         var alarms = result.SelectMany(r => r.History[i1]);
         switch (historyInfo.Item2)
         {
             case CriteriaType.DownFromInfinity:
             case CriteriaType.DownFrom:
             case CriteriaType.DownFromOrEqual:
                 alarms = alarms.OrderByDescending(a => a.StartTime).ThenByDescending(a => a.UserId).Take(historyInfo.Item3);
                 break;
             case CriteriaType.UpFromInfinity:
             case CriteriaType.UpFrom:
             case CriteriaType.UpFromOrEqual:
                 alarms = alarms.OrderBy(a => a.StartTime).ThenBy(a => a.UserId).Take(historyInfo.Item3).Reverse();
                 break;
         }
         var callback = historyInfo.Item1;
         var alarmsArray = alarms.ToArray();
         callback(alarmsArray);
     }
 }
        private static Dictionary<string, NodeSymbolInfo> FindUnusedNodes(SyntaxNodeAnalysisContext context, ParametersInfo parametersInfo, bool isIndexer = false)
        {
            UnusedParameterWalker walker = UnusedParameterWalkerCache.Acquire(context.SemanticModel, context.CancellationToken, isIndexer);

            if (parametersInfo.Parameter != null
                && !StringUtility.IsOneOrManyUnderscores(parametersInfo.Parameter.Identifier.ValueText))
            {
                walker.AddParameter(parametersInfo.Parameter);
            }
            else
            {
                foreach (ParameterSyntax parameter in parametersInfo.Parameters)
                {
                    if (!StringUtility.IsOneOrManyUnderscores(parameter.Identifier.ValueText))
                        walker.AddParameter(parameter);
                }
            }

            foreach (TypeParameterSyntax typeParameter in parametersInfo.TypeParameters)
            {
                walker.AddTypeParameter(typeParameter);
                walker.IsAnyTypeParameter = true;
            }

            if (walker.Nodes.Count == 0)
                return walker.Nodes;

            walker.Visit(parametersInfo.Node);

            return UnusedParameterWalkerCache.GetNodesAndRelease(walker);
        }
Esempio n. 26
0
 public override string ToString()
 {
     return($"{Name}({(String.Join(", ", ParametersInfo.Select(x => $"{x.ParameterType.Name} {x.Name}").ToArray()))})");
 }
Esempio n. 27
0
        private ParametersInfo GetParameters()
        {
            var r = new ParametersInfo();
            var commonAcknowledgeParameters = _commonCategory.AlarmsToAcknowledge();
            var commonCurrentQueries = _commonCategory.QueriesForCurrent();
            r.CommonCurrentInfo.AddRange(commonCurrentQueries.Select(q =>
                new Tuple<Action<Alarm[]>, CriteriaType, int>(q.Item4, q.Item1, q.Item3)));
            var commonHistoryQueries = _commonCategory.QueriesForHistory();
            r.CommonHistoryInfo.AddRange(commonHistoryQueries.Select(q =>
                new Tuple<Action<Alarm[]>, CriteriaType, int>(q.Item4, q.Item1, q.Item3)));
            var commonStatusIsRead = _commonCategory.IsRead();

            foreach (var c in _categories.Values)
            {
                var parameter = new RemapAlarmsParameter
                    {
                        CategoryId = c.Id
                    };
                var addToParameters = false;

                parameter.AcknowledgeParameters = GetAcknowledgeParameters(c, commonAcknowledgeParameters);
                if (parameter.AcknowledgeParameters.Any())
                {
                    addToParameters = true;
                }

                if (c.IsRead() || commonStatusIsRead)
                {
                    parameter.GetStatus = true;
                    addToParameters = true;
                }

                var currentQueries = c.QueriesForCurrent();
                var currentCallbacks = currentQueries.Select(q => q.Item4).ToArray();
                parameter.CurrentParameters = commonCurrentQueries.Concat(currentQueries)
                    .Select(q => new Tuple<CriteriaType, AlarmSampleId, int>(q.Item1, q.Item2, q.Item3))
                    .ToArray();
                if (parameter.CurrentParameters.Any())
                {
                    addToParameters = true;
                }

                var historyQueries = c.QueriesForHistory();
                var historyCallbacks = historyQueries.Select(q => q.Item4).ToArray();
                parameter.HistoryParameters = commonHistoryQueries.Concat(historyQueries)
                    .Select(q => new Tuple<CriteriaType, AlarmSampleId, int>(q.Item1, q.Item2, q.Item3))
                    .ToArray();
                if (parameter.HistoryParameters.Any())
                {
                    addToParameters = true;
                }

                if (addToParameters)
                {
                    r.Parameters.Add(new Tuple<RemapAlarmsParameter, Action<Alarm[]>[], Action<Alarm[]>[]>(
                        parameter, currentCallbacks, historyCallbacks));
                }
            }
            return r;
        }
Esempio n. 28
0
        private ParametersInfo GetParameters()
        {
            var r = new ParametersInfo();
            var commonAcknowledgeParameters = _commonCategory.AlarmsToAcknowledge();
            var commonCurrentQueries        = _commonCategory.QueriesForCurrent();

            r.CommonCurrentInfo.AddRange(commonCurrentQueries.Select(q =>
                                                                     new Tuple <Action <Alarm[]>, CriteriaType, int>(q.Item4, q.Item1, q.Item3)));
            var commonHistoryQueries = _commonCategory.QueriesForHistory();

            r.CommonHistoryInfo.AddRange(commonHistoryQueries.Select(q =>
                                                                     new Tuple <Action <Alarm[]>, CriteriaType, int>(q.Item4, q.Item1, q.Item3)));
            var commonStatusIsRead = _commonCategory.IsRead();

            foreach (var c in _categories.Values)
            {
                var parameter = new RemapAlarmsParameter
                {
                    CategoryId = c.Id
                };
                var addToParameters = false;

                parameter.AcknowledgeParameters = GetAcknowledgeParameters(c, commonAcknowledgeParameters);
                if (parameter.AcknowledgeParameters.Any())
                {
                    addToParameters = true;
                }

                if (c.IsRead() || commonStatusIsRead)
                {
                    parameter.GetStatus = true;
                    addToParameters     = true;
                }

                var currentQueries   = c.QueriesForCurrent();
                var currentCallbacks = currentQueries.Select(q => q.Item4).ToArray();
                parameter.CurrentParameters = commonCurrentQueries.Concat(currentQueries)
                                              .Select(q => new Tuple <CriteriaType, AlarmSampleId, int>(q.Item1, q.Item2, q.Item3))
                                              .ToArray();
                if (parameter.CurrentParameters.Any())
                {
                    addToParameters = true;
                }

                var historyQueries   = c.QueriesForHistory();
                var historyCallbacks = historyQueries.Select(q => q.Item4).ToArray();
                parameter.HistoryParameters = commonHistoryQueries.Concat(historyQueries)
                                              .Select(q => new Tuple <CriteriaType, AlarmSampleId, int>(q.Item1, q.Item2, q.Item3))
                                              .ToArray();
                if (parameter.HistoryParameters.Any())
                {
                    addToParameters = true;
                }

                if (addToParameters)
                {
                    r.Parameters.Add(new Tuple <RemapAlarmsParameter, Action <Alarm[]>[], Action <Alarm[]>[]>(
                                         parameter, currentCallbacks, historyCallbacks));
                }
            }
            return(r);
        }
        public Int32 Generation = 0; // номер поколоения, к которому относятся ОРД

        #endregion Fields

        #region Constructors

        public SharedDataInfo(OracleConnection Connection, FileLogger Log, string UpdatePath, UInt32 UpdateBlockSize, CardScriptPluginsInfo CardScripts)
            : this()
        {
            this.Log = Log;
              // Порядок создания важен. Не менять!
              this.CardScripts = CardScripts == null ? new CardScriptPluginsInfo(Connection, this) : CardScripts; // this - for Log

              PCParameters = new PCParametersInfo(Connection);

              Owners = new OwnersInfo(Connection, this);
              ProcessingCenters = new ProcessingCentersInfo(Connection, this); // this - for Owners, PCParameters

              Calc = new ScriptCalculations(ProcessingCenters.Current.Parameters.RoundingMethod);

              Devices = new DevicesInfo(Connection);
              DevicesGroups = new DevicesGroupsInfo(Connection, this); // this for Devices
              Networks = new NetworksInfo(Connection, this); // this - for Owners, DevicesGroups
              Currencies = new CurrenciesInfo(Connection);
              TimeOffsetPeriods = new TimeOffsetPeriodsInfo(Connection);
              Regions = new RegionsInfo(Connection, this); // this - for Currencies
              RetailSystems = new RetailSystemsInfo(Connection, this); // this - for Owners
              ServicePoints = new ServicePointsInfo(Connection, this); // this - for Regions, Networks, Retail systems
              Terminals = new TerminalsInfo(Connection, this); // this - for Service points, Devices
              ProductGoods = new LogicalProductGoodsInfo(Connection, this); // this - for Retail systems
              ProductGroups = new LogicalProductGroupsInfo(Connection);
              MeasureUnits = new MeasureUnitsInfo(Connection);
              Products = new LogicalProductsInfo(Connection, this); // this - for Groups, MeasureUnits
              Purses = new PursesInfo(this);
              Statuses = new CardStatusesInfo(Connection);
              Parameters = new ParametersInfo(Connection); // параметры скриптов обработки карты
              ParameterSets = new ParameterSetsInfo(Connection, this); // this - for Calc, CardScripts
              Counters = new CountersInfo(Connection, this); // this - for Calc
              Graduations = new GraduationsInfo(Connection, this); // this - for Calc, Products, ProductGroups, Counters
              GraduationGroups = new GraduationGroupsInfo(Connection, this); // this - for Graduations
              Tariffs = new TariffsInfo(Connection, this); // this - for Calc, GraduationGroups, Graduations
              CardRanges = new CardRangesInfo(Connection, this); // this - for ProcessingCenters
              DataElements = new DataElementsInfo(Connection, this); // this - for Owners
              EventActionTypes = new EventActionTypesInfo(Connection);
              Events = new EventsInfo(Connection, this); // this - for Owners, Counters, EventActionTypes
              EmailProviders = new EmailProvidersInfo(Connection, this); // this - for Owners
              SMSProviders = new SMSProvidersInfo(Connection, this); // this - for Owners
              DBVersion = new OnlineDBVersion(Connection, this); // this - for ProcessingCenters.Current

              this.UpdatePath = UpdatePath;
              this.UpdateBlockSize = UpdateBlockSize;
        }
        private static Dictionary <string, NodeSymbolInfo> FindUnusedNodes(SyntaxNodeAnalysisContext context, ParametersInfo parametersInfo, bool isIndexer = false)
        {
            UnusedParameterWalker walker = UnusedParameterWalkerCache.Acquire(context.SemanticModel, context.CancellationToken, isIndexer);

            if (parametersInfo.Parameter != null)
            {
                walker.AddParameter(parametersInfo.Parameter);
            }
            else
            {
                foreach (ParameterSyntax parameter in parametersInfo.Parameters)
                {
                    walker.AddParameter(parameter);
                }
            }

            foreach (TypeParameterSyntax typeParameter in parametersInfo.TypeParameters)
            {
                walker.AddTypeParameter(typeParameter);
                walker.IsAnyTypeParameter = true;
            }

            walker.Visit(parametersInfo.Node);

            return(UnusedParameterWalkerCache.GetNodesAndRelease(walker));
        }