WebSVN - OpenConcerto - Diff - Rev 149 and 177 - /trunk/OpenConcerto/src/org/openconcerto/utils/cc/IncludeExclude.java


/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 * 
 * Copyright 2011 OpenConcerto, by ILM Informatique. All rights reserved.
 * 
 * The contents of this file are subject to the terms of the GNU General Public License Version 3
 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a
 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific
 * language governing permissions and limitations under the License.
 * 
 * When distributing the software, include this License Header Notice in each file.
 */
 
 package org.openconcerto.utils.cc;
 
import org.openconcerto.utils.CollectionUtils;
import org.openconcerto.utils.CompareUtils;
import org.openconcerto.utils.Tuple2;
 
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
 
import net.jcip.annotations.Immutable;
 
/**
 * A class to specify which objects to include or exclude.
 *
 * @author Sylvain
 * @param <T> type of items
 * @see #isIncluded(Object)
 */
@Immutable
public class IncludeExclude<T> {
 
    static private final IncludeExclude<Object> EMPTY = new IncludeExclude<Object>(Collections.<Object> emptySet(), Collections.<Object> emptySet(), true);
    static private final IncludeExclude<Object> FULL = new IncludeExclude<Object>(null, Collections.<Object> emptySet(), true);
 
    @SuppressWarnings("unchecked")
    public static <T> IncludeExclude<T> getEmpty() {
        return (IncludeExclude<T>) EMPTY;
    }
 
    @SuppressWarnings("unchecked")
    public static <T> IncludeExclude<T> getFull() {
        return (IncludeExclude<T>) FULL;
    }
 
    @SafeVarargs
    public static <T> IncludeExclude<T> getNormalized(final T... includes) {
        return getNormalized(Arrays.asList(includes));
    }
 
    public static <T> IncludeExclude<T> getNormalized(final Collection<? extends T> includes) {
        return getNormalized(includes, Collections.<T> emptySet());
    }
 
    public static <T> IncludeExclude<T> getNormalized(final Collection<? extends T> includes, final Collection<? extends T> excludes) {
        return new IncludeExclude<T>(includes, excludes).normal;
    }
 
    private final Set<T> includes;
    private final Set<T> excludes;
    private final IncludeExclude<T> normal;
 
    public IncludeExclude(final Collection<? extends T> includes) {
        this(includes, Collections.<T> emptySet());
    }
 
    /**
     * Create a new instance.
     *
     * @param includes which objects to include, <code>null</code> meaning all.
     * @param excludes which objects to exclude, <code>null</code> meaning all.
     */
    public IncludeExclude(final Collection<? extends T> includes, final Collection<? extends T> excludes) {
        this(includes, excludes, false);
    }
 
    private IncludeExclude(final Collection<? extends T> includes, final Collection<? extends T> excludes, final boolean isNormal) {
        this(includes == null ? null : Collections.unmodifiableSet(new HashSet<T>(includes)), excludes == null ? null : Collections.unmodifiableSet(new HashSet<T>(excludes)), false, isNormal);
    }
 
    private IncludeExclude(final Set<T> includes, final Set<T> excludes, final boolean areMutable, final boolean isNormal) {
        super();
        // parameter just to overload constructor
        if (areMutable)
            throw new IllegalStateException();
        this.includes = includes;
        this.excludes = excludes;
        this.normal = isNormal ? this : this.normalize();
        assert this.normal.excludes.isEmpty() || this.normal.includes == null;
    }
 
    private final IncludeExclude<T> normalize() {
        if (this.excludes == null || (this.includes != null && this.includes.isEmpty()))
            return getEmpty();
        if (this.excludes.isEmpty() && this.includes == null)
            return getFull();
        if (this.excludes.isEmpty() || this.includes == null)
            return this;
        return new IncludeExclude<T>(CollectionUtils.substract(this.includes, this.excludes), Collections.<T> emptySet(), true);
    }
 
    public final IncludeExclude<T> getNormal() {
        return this.normal;
    }
 
    /**
     * Whether the passed object is included or excluded by this.
     *
     * @param s an object to test.
     * @return <code>true</code> if is in include and not in exclude.
     */
    public final boolean isIncluded(final T s) {
        // "if" order is irrelevant since those methods use getNormal() and it can't be both "all"
        // and "none".
        if (this.isAllIncluded())
            return true;
        else if (this.isNoneIncluded())
            return false;
        else
            return (this.normal.includes == null || this.normal.includes.contains(s)) && !this.normal.excludes.contains(s);
    }
 
    public final <S extends T> Collection<S> getExcluded(final Collection<S> items) {
        if (this.areNoneIncluded(items))
            return items;
        else if (this.areAllIncluded(items))
            return Collections.emptySet();
 
        final Set<S> res = new HashSet<>(items);
        // avoid checks of getIncluded()
        res.removeAll(this.createIncluded(items));
        return res;
    }
 
    public final <S extends T> Collection<S> getIncluded(final Collection<S> items) {
        if (this.areAllIncluded(items))
            return items;
        else if (this.isNoneIncluded())
            return Collections.emptySet();
        else
            return createIncluded(items);
    }
 
    private <S extends T> Collection<S> createIncluded(final Collection<S> items) {
        final Set<S> res = new HashSet<>(items);
        if (this.normal.includes != null)
            res.retainAll(this.normal.includes);
        res.removeAll(this.normal.excludes);
        return res;
    }
 
    public final boolean areAllIncluded(final Collection<? extends T> items) {
        if (this.isAllIncluded() || items.isEmpty())
            return true;
        else if (this.isNoneIncluded())
            return false;
        else
            return (this.normal.includes == null || this.normal.includes.containsAll(items)) && Collections.disjoint(this.normal.excludes, items);
    }
 
    public final boolean areNoneIncluded(final Collection<? extends T> items) {
        if (this.isNoneIncluded() || items.isEmpty())
            return true;
        else if (this.isAllIncluded())
            return false;
        else
            return (this.normal.includes != null && Collections.disjoint(this.normal.includes, items)) || this.normal.excludes.containsAll(items);
    }
 
    /**
     * Whether this includes all objects.
     *
     * @return <code>true</code> if {@link #isIncluded(Object)} always return <code>true</code>
     */
    public final boolean isAllIncluded() {
        // use normalized value to avoid ambiguous "include all" and "exclude all"
        return this.normal == FULL;
    }
 
    /**
     * Whether this includes no objects.
     *
     * @return <code>true</code> if {@link #isIncluded(Object)} always return <code>false</code>
     */
    public final boolean isNoneIncluded() {
        // use normalized value to avoid ambiguous "include all" and "exclude all"
        return this.normal == EMPTY;
    }
 
    /**
     * The one and only object included by this.
     *
     * @return <code>true</code> if {@link #isIncluded(Object)} returns <code>true</code> for one
     *         and only one object.
     */
    public final Tuple2<Boolean, T> getSole() {
        if (this.normal.includes == null) {
            return Tuple2.create(false, null);
        } else {
            assert this.normal.excludes.isEmpty();
            final boolean res = this.normal.includes.size() == 1;
            return Tuple2.create(res, res ? this.normal.includes.iterator().next() : null);
        }
    }
 
    /**
     * Return the one and only object included by this, or the passed object.
     *
     * @param ifNoSole the object to return if this doesn't include exactly one object.
     * @return {@link #getSole()} or <code>ifNoSole</code>.
     */
    public final T getSole(final T ifNoSole) {
        final Tuple2<Boolean, T> sole = this.getSole();
        if (sole.get0())
            return sole.get1();
        else
            return ifNoSole;
    }
 
    @SafeVarargs
    public final IncludeExclude<T> include(final T... items) {
        return this.include(Arrays.asList(items));
    }
 
    public final IncludeExclude<T> include(final Collection<? extends T> items) {
        if (this.areAllIncluded(items))
            return this;
        else if (this.excludes == null)
            throw new IllegalStateException("Cannot include an item when excluding all");
 
        Set<T> newIncludes;
        if (this.includes == null || this.includes.containsAll(items)) {
            newIncludes = this.includes;
        } else {
            newIncludes = new HashSet<>(this.includes);
            newIncludes.addAll(items);
            newIncludes = Collections.unmodifiableSet(newIncludes);
        }
        Set<T> newExcludes;
        if (Collections.disjoint(this.excludes, items)) {
            newExcludes = this.excludes;
        } else {
            newExcludes = new HashSet<>(this.excludes);
            newExcludes.removeAll(items);
            newExcludes = Collections.unmodifiableSet(newExcludes);
        }
 
        return new IncludeExclude<T>(newIncludes, newExcludes, false, false);
    }
 
    @SafeVarargs
    public final IncludeExclude<T> exclude(final T... items) {
        return this.exclude(Arrays.asList(items));
    }
 
    public final IncludeExclude<T> exclude(final Collection<? extends T> items) {
        if (this.areNoneIncluded(items))
            return this;
 
        assert this.excludes != null : "!areNoneIncluded() but this.excludes == null";
        Set<T> newExcludes = new HashSet<>(this.excludes);
        newExcludes.addAll(items);
        newExcludes = Collections.unmodifiableSet(newExcludes);
        return new IncludeExclude<T>(this.includes, Collections.unmodifiableSet(newExcludes), false, false);
    }
 
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((this.excludes == null) ? 0 : this.excludes.hashCode());
        result = prime * result + ((this.includes == null) ? 0 : this.includes.hashCode());
        return result;
    }
 
    @Override
    public boolean equals(final Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        final IncludeExclude<?> other = (IncludeExclude<?>) obj;
        return CompareUtils.equals(this.includes, other.includes) && CompareUtils.equals(this.excludes, other.excludes);
    }
 
    @Override
    public String toString() {
        final String suffix;
        if (this == FULL)
            suffix = " ALL";
        else if (this == EMPTY)
            suffix = " NONE";
        else
            suffix = " includes " + this.includes + " except " + this.excludes;
        return this.getClass().getSimpleName() + suffix;
    }
}

Dépôt officiel du code source de l'ERP OpenConcerto

svn://code.openconcerto.org/openconcerto

(root)/trunk/OpenConcerto/src/org/openconcerto/utils/cc/IncludeExclude.java - Rev 149 → 177

Rev 149		Rev 177
1	`/*`	1	`/*`
2	`* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.`	2	`* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.`
3	`*`	3	`*`
4	`* Copyright 2011 OpenConcerto, by ILM Informatique. All rights reserved.`	4	`* Copyright 2011 OpenConcerto, by ILM Informatique. All rights reserved.`
5	`*`	5	`*`
6	`* The contents of this file are subject to the terms of the GNU General Public License Version 3`	6	`* The contents of this file are subject to the terms of the GNU General Public License Version 3`
7	`* only ("GPL"). You may not use this file except in compliance with the License. You can obtain a`	7	`* only ("GPL"). You may not use this file except in compliance with the License. You can obtain a`
8	`* copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific`	8	`* copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific`
9	`* language governing permissions and limitations under the License.`	9	`* language governing permissions and limitations under the License.`
10	`*`	10	`*`
11	`* When distributing the software, include this License Header Notice in each file.`	11	`* When distributing the software, include this License Header Notice in each file.`
12	`*/`	12	`*/`
13		13
14	`package org.openconcerto.utils.cc;`	14	`package org.openconcerto.utils.cc;`
15		15
16	`import org.openconcerto.utils.CollectionUtils;`	16	`import org.openconcerto.utils.CollectionUtils;`
17	`import org.openconcerto.utils.CompareUtils;`	17	`import org.openconcerto.utils.CompareUtils;`
18	`import org.openconcerto.utils.Tuple2;`	18	`import org.openconcerto.utils.Tuple2;`
19		19
-		20	`import java.util.Arrays;`
20	`import java.util.Collection;`	21	`import java.util.Collection;`
21	`import java.util.Collections;`	22	`import java.util.Collections;`
22	`import java.util.HashSet;`	23	`import java.util.HashSet;`
23	`import java.util.Set;`	24	`import java.util.Set;`
24		25
25	`import net.jcip.annotations.Immutable;`	26	`import net.jcip.annotations.Immutable;`
26		27
27	`/**`	28	`/**`
28	`* A class to specify which objects to include or exclude.`	29	`* A class to specify which objects to include or exclude.`
29	`*`	30	`*`
30	`* @author Sylvain`	31	`* @author Sylvain`
31	`* @param <T> type of items`	32	`* @param <T> type of items`
32	`* @see #isIncluded(Object)`	33	`* @see #isIncluded(Object)`
33	`*/`	34	`*/`
34	`@Immutable`	35	`@Immutable`
35	`public class IncludeExclude<T> {`	36	`public class IncludeExclude<T> {`
36		37
37	`static private final IncludeExclude<Object> EMPTY = new IncludeExclude<Object>(Collections.<Object> emptySet(), Collections.<Object> emptySet(), true);`	38	`static private final IncludeExclude<Object> EMPTY = new IncludeExclude<Object>(Collections.<Object> emptySet(), Collections.<Object> emptySet(), true);`
38	`static private final IncludeExclude<Object> FULL = new IncludeExclude<Object>(null, Collections.<Object> emptySet(), true);`	39	`static private final IncludeExclude<Object> FULL = new IncludeExclude<Object>(null, Collections.<Object> emptySet(), true);`
39		40