001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.kernel.util;
016    
017    /**
018     * @author Marcellus Tavares
019     */
020    public class AggregatePredicateFilter<T> implements PredicateFilter<T> {
021    
022            public AggregatePredicateFilter(PredicateFilter<T> predicateFilter) {
023                    _predicateFilter = new IdentityPredicateFilter(predicateFilter);
024            }
025    
026            public AggregatePredicateFilter<T> and(PredicateFilter<T> predicateFilter) {
027                    _predicateFilter = new AndPredicateFilter(
028                            _predicateFilter, new IdentityPredicateFilter(predicateFilter));
029    
030                    return this;
031            }
032    
033            @Override
034            public boolean filter(T t) {
035                    return _predicateFilter.filter(t);
036            }
037    
038            public AggregatePredicateFilter<T> negate() {
039                    _predicateFilter = new NegatePredicateFilter(_predicateFilter);
040    
041                    return this;
042            }
043    
044            public AggregatePredicateFilter<T> or(PredicateFilter<T> predicateFilter) {
045                    _predicateFilter = new OrPredicateFilter(
046                            _predicateFilter, new IdentityPredicateFilter(predicateFilter));
047    
048                    return this;
049            }
050    
051            private PredicateFilter<T> _predicateFilter;
052    
053            private class AndPredicateFilter implements PredicateFilter<T> {
054    
055                    public AndPredicateFilter(
056                            PredicateFilter<T> leftPredicateFilter,
057                            PredicateFilter<T> rightPredicateFilter) {
058    
059                            _leftPredicateFilter = leftPredicateFilter;
060                            _rightPredicateFilter = rightPredicateFilter;
061                    }
062    
063                    @Override
064                    public boolean filter(T t) {
065                            if (_leftPredicateFilter.filter(t) &&
066                                    _rightPredicateFilter.filter(t)) {
067    
068                                    return true;
069                            }
070    
071                            return false;
072                    }
073    
074                    private PredicateFilter<T> _leftPredicateFilter;
075                    private PredicateFilter<T> _rightPredicateFilter;
076    
077            }
078    
079            private class IdentityPredicateFilter implements PredicateFilter<T> {
080    
081                    public IdentityPredicateFilter(PredicateFilter<T> predicateFilter) {
082                            _predicateFilter = predicateFilter;
083                    }
084    
085                    @Override
086                    public boolean filter(T t) {
087                            return _predicateFilter.filter(t);
088                    }
089    
090                    private final PredicateFilter<T> _predicateFilter;
091    
092            }
093    
094            private class NegatePredicateFilter implements PredicateFilter<T> {
095    
096                    public NegatePredicateFilter(PredicateFilter<T> predicateFilter) {
097                            _predicateFilter = predicateFilter;
098                    }
099    
100                    @Override
101                    public boolean filter(T t) {
102                            return !_predicateFilter.filter(t);
103                    }
104    
105                    private PredicateFilter<T> _predicateFilter;
106    
107            }
108    
109            private class OrPredicateFilter implements PredicateFilter<T> {
110    
111                    public OrPredicateFilter(
112                            PredicateFilter<T> leftPredicateFilter,
113                            PredicateFilter<T> rightPredicateFilter) {
114    
115                            _leftPredicateFilter = leftPredicateFilter;
116                            _rightPredicateFilter = rightPredicateFilter;
117                    }
118    
119                    @Override
120                    public boolean filter(T t) {
121                            if (_leftPredicateFilter.filter(t) ||
122                                    _rightPredicateFilter.filter(t)) {
123    
124                                    return true;
125                            }
126    
127                            return false;
128                    }
129    
130                    private PredicateFilter<T> _leftPredicateFilter;
131                    private PredicateFilter<T> _rightPredicateFilter;
132    
133            }
134    
135    }