Opc.Ua.ContentFilterElement.Validate C# (CSharp) Method

        public virtual ContentFilter.ElementResult Validate(FilterContext context, int index)
        {
            ContentFilter.ElementResult result = new ContentFilter.ElementResult(null);

            // check the number of operands.
            int operandCount = -1;

            switch (m_filterOperator)
            {
                case FilterOperator.Not:
                case FilterOperator.IsNull:
                case FilterOperator.InView:
                case FilterOperator.OfType:
                {
                    operandCount = 1;
                    break;
                }

                case FilterOperator.And:
                case FilterOperator.Or:
                case FilterOperator.Equals:
                case FilterOperator.GreaterThan:
                case FilterOperator.GreaterThanOrEqual:
                case FilterOperator.LessThan:
                case FilterOperator.LessThanOrEqual:
                case FilterOperator.Like:
                case FilterOperator.Cast:
                {
                    operandCount = 2;
                    break;
                }

                case FilterOperator.Between:
                {
                    operandCount = 3;
                    break;
                }

                case FilterOperator.RelatedTo:
                {
                    operandCount = 6;
                    break;
                }

                case FilterOperator.InList:
                {
                    operandCount = -1;
                    break;
                }

                default:
                {
                    break;
                }
            }

            if (operandCount != -1)
            {
                if (operandCount != m_filterOperands.Count)
                {                    
                    result.Status = ServiceResult.Create(
                        StatusCodes.BadEventFilterInvalid, 
                        "ContentFilterElement does not have the correct number of operands (Operator={0} OperandCount={1}).", 
                        m_filterOperator,
                        operandCount);

                    return result;
                }
            }
            else
            {
                if (m_filterOperands.Count < 2)
                {                    
                    result.Status = ServiceResult.Create(
                        StatusCodes.BadEventFilterInvalid, 
                        "ContentFilterElement does not have the correct number of operands (Operator={0} OperandCount={1}).", 
                        m_filterOperator,
                        m_filterOperands.Count);

                    return result;
                }
            }

            // validate the operands.
            bool error = false;

            for (int ii = 0; ii < m_filterOperands.Count; ii++)
            {
                ServiceResult operandResult = null;

                ExtensionObject operand = m_filterOperands[ii];
                
                // check for null.
                if (ExtensionObject.IsNull(operand))
                {
                    operandResult = ServiceResult.Create(
                        StatusCodes.BadEventFilterInvalid,
                        "The FilterOperand cannot be Null.");
                
                    result.OperandResults.Add(operandResult);
                    error = true;
                    continue;
                }            
                
                // check that the extension object contains a filter operand.
                FilterOperand filterOperand = operand.Body  as FilterOperand;

                if (filterOperand == null)
                {
                    operandResult = ServiceResult.Create(
                        StatusCodes.BadEventFilterInvalid,
                        "The FilterOperand is not a supported type ({0}).", 
                        filterOperand.GetType());

                    result.OperandResults.Add(operandResult);
                    error = true;
                    continue;
                }

                // validate the operand.
                filterOperand.Parent = this;
                operandResult = filterOperand.Validate(context, index);

                if (ServiceResult.IsBad(operandResult))
                {
                    result.OperandResults.Add(operandResult);
                    error = true;
                    continue;
                }

                result.OperandResults.Add(null);
            }
            
            // ensure the global error code.
            if (error)
            {
                result.Status = StatusCodes.BadContentFilterInvalid;
            }
            else
            {
                result.OperandResults.Clear();
            }

            return result;
        }

        /// <summary>
        /// Validates the ContentFilter.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <returns>The result of validation.</returns>
        public Result Validate(FilterContext context)
        {
            Result result = new Result(null);

            // check for empty filter.
            if (m_elements == null || m_elements.Count == 0)
            {
                return(result);
            }

            bool error = false;

            for (int ii = 0; ii < m_elements.Count; ii++)
            {
                ContentFilterElement element = m_elements[ii];

                // check for null.
                if (element == null)
                {
                    ServiceResult nullResult = ServiceResult.Create(
                        StatusCodes.BadStructureMissing,
                        "ContentFilterElement is null (Index={0}).",
                        ii);

                    result.ElementResults.Add(new ElementResult(nullResult));
                    error = true;
                    continue;
                }

                element.Parent = this;

                // validate element.
                ElementResult elementResult = element.Validate(context, ii);

                if (ServiceResult.IsBad(elementResult.Status))
                {
                    result.ElementResults.Add(elementResult);
                    error = true;
                    continue;
                }

                result.ElementResults.Add(null);
            }

            // ensure the global error code.
            if (error)
            {
                result.Status = StatusCodes.BadContentFilterInvalid;
            }
            else
            {
                result.ElementResults.Clear();
            }

            return(result);
        }