Example #1
0
        protected virtual AmbethIFilterDescriptor ComposeSimpleAndComposite(AmbethFilterDescriptor filter1, AmbethCompositeFilterDescriptor filter2, AmbethLogicalOperator logicalOperator)
        {
            if (filter2.LogicalOperator == logicalOperator)
            {
                filter2.ChildFilterDescriptors.Add(filter1);
                return(filter2);
            }
            AmbethCompositeFilterDescriptor newComposite = new AmbethCompositeFilterDescriptor();

            newComposite.LogicalOperator        = logicalOperator;
            newComposite.ChildFilterDescriptors = new List <AmbethIFilterDescriptor>();
            newComposite.ChildFilterDescriptors.Add(filter1);
            newComposite.ChildFilterDescriptors.Add(filter2);
            return(newComposite);
        }
Example #2
0
        protected virtual AmbethIFilterDescriptor ComposeTwoComposite(AmbethCompositeFilterDescriptor filter1, AmbethCompositeFilterDescriptor filter2, AmbethLogicalOperator logicalOperator)
        {
            if (filter1.LogicalOperator == logicalOperator)
            {
                // If the logical operators of both composites are equal to the logical operator that relates them, they can be combined into a single composite:
                if (filter2.LogicalOperator == logicalOperator)
                {
                    foreach (AmbethIFilterDescriptor filter in filter2.ChildFilterDescriptors)
                    {
                        filter1.ChildFilterDescriptors.Add(filter);
                    }
                    return(filter1);
                }
                // If only one of the composites has the same logical operator that relates them, the other can be added to its childs:
                filter1.ChildFilterDescriptors.Add(filter2);
                return(filter1);
            }
            if (filter2.LogicalOperator == logicalOperator)
            {
                filter2.ChildFilterDescriptors.Add(filter1);
                return(filter2);
            }
            // The logical operators do not match, hence a new composite must be created:
            AmbethCompositeFilterDescriptor newComposite = new AmbethCompositeFilterDescriptor();

            newComposite.LogicalOperator        = logicalOperator;
            newComposite.ChildFilterDescriptors = new List <AmbethIFilterDescriptor>();
            newComposite.ChildFilterDescriptors.Add(filter1);
            newComposite.ChildFilterDescriptors.Add(filter2);
            return(newComposite);
        }
Example #3
0
 // Extend an Ambeth filter descriptor by an arbitrary Telerik filter descriptor:
 public virtual AmbethIFilterDescriptor AddTelerikFilterDescriptor(AmbethIFilterDescriptor ambethFilter, TelerikIFilterDescriptor telerikFilterDescriptor, AmbethLogicalOperator logicalOperator = AmbethLogicalOperator.AND)
 {
     return(Compose(ambethFilter, ConvertTelerikFilterDescriptor(telerikFilterDescriptor), logicalOperator));
 }
Example #4
0
        // Convert a complete list of arbitrary Telerik filter descriptors into a single Ambeth filter descriptor:
        public virtual AmbethIFilterDescriptor ConvertTelerikFilterCollection(IList <TelerikIFilterDescriptor> filterCollection, AmbethLogicalOperator logicalOperator = AmbethLogicalOperator.AND)
        {
            if (filterCollection.Count < 1)
            {
                return(null);
            }
            AmbethIFilterDescriptor resultFilter = ConvertTelerikFilterDescriptor(filterCollection[0]);

            for (int i = 1; i < filterCollection.Count; ++i)
            {
                resultFilter = AddTelerikFilterDescriptor(resultFilter, filterCollection[i], logicalOperator);
            }
            return(resultFilter);
        }
Example #5
0
        public virtual AmbethIFilterDescriptor Compose(AmbethIFilterDescriptor filter1, AmbethIFilterDescriptor filter2, AmbethLogicalOperator logicalOperator = AmbethLogicalOperator.AND)
        {
            // Try to simplify both filters before combining them:
            filter1 = TryReduce(filter1);
            if (filter1 == null)
            {
                return(TryReduce(filter2));
            }
            filter2 = TryReduce(filter2);
            if (filter2 == null)
            {
                return(filter1);
            }

            if (filter1 is AmbethCompositeFilterDescriptor)
            {
                if (filter2 is AmbethCompositeFilterDescriptor)
                {
                    return(ComposeTwoComposite(filter1 as AmbethCompositeFilterDescriptor, filter2 as AmbethCompositeFilterDescriptor, logicalOperator));
                }
                return(ComposeSimpleAndComposite(filter2 as AmbethFilterDescriptor, filter1 as AmbethCompositeFilterDescriptor, logicalOperator));
            }

            if (filter2 is AmbethCompositeFilterDescriptor)
            {
                return(ComposeSimpleAndComposite(filter1 as AmbethFilterDescriptor, filter2 as AmbethCompositeFilterDescriptor, logicalOperator));
            }

            AmbethCompositeFilterDescriptor newComposite = new AmbethCompositeFilterDescriptor();

            newComposite.LogicalOperator        = logicalOperator;
            newComposite.ChildFilterDescriptors = new List <AmbethIFilterDescriptor>();
            newComposite.ChildFilterDescriptors.Add(filter1);
            newComposite.ChildFilterDescriptors.Add(filter2);
            return(newComposite);
        }