src/extra166y/ParallelLongArrayWithFilter.java

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 */

package extra166y;
import jsr166y.*;
import static extra166y.Ops.*;
import java.util.*;
import java.util.concurrent.atomic.*;
import java.lang.reflect.Array;


/**
 * A prefix view of ParallelLongArray that causes operations to apply
 * only to elements for which a selector returns true.  Instances of
 * this class may be constructed only via prefix methods of
 * ParallelLongArray or its other prefix classes.
 */
public abstract class ParallelLongArrayWithFilter extends ParallelLongArrayWithLongMapping {
    ParallelLongArrayWithFilter
        (ForkJoinPool ex, int origin, int fence, long[] array) {
        super(ex, origin, fence, array);
    }

    /**
     * Replaces elements with the results of applying the given
     * op to their current values.
     * @param op the op
     * @return this (to simplify use in expressions)
     */
    public ParallelLongArrayWithFilter replaceWithMapping(LongOp op) {
        ex.invoke(new PAS.FJLTransform
                  (this, origin, fence, null, op));
        return this;
    }

    /**
     * Replaces elements with the results of applying the given
     * op to their indices.
     * @param op the op
     * @return this (to simplify use in expressions)
     */
    public ParallelLongArrayWithFilter replaceWithMappedIndex(IntToLong op) {
        ex.invoke(new PAS.FJLIndexMap
                  (this, origin, fence, null, op));
        return this;
    }

    /**
     * Replaces elements with the results of applying the given
     * mapping to each index and current element value.
     * @param op the op
     * @return this (to simplify use in expressions)
     */
    public ParallelLongArrayWithFilter replaceWithMappedIndex(IntAndLongToLong op) {
        ex.invoke(new PAS.FJLBinaryIndexMap
                  (this, origin, fence, null, op));
        return this;
    }

    /**
     * Replaces elements with results of applying the given
     * generator.
     * @param generator the generator
     * @return this (to simplify use in expressions)
     */
    public ParallelLongArrayWithFilter replaceWithGeneratedValue(LongGenerator generator) {
        ex.invoke(new PAS.FJLGenerate
                  (this, origin, fence, null, generator));
        return this;
    }

    /**
     * Replaces elements with the given value.
     * @param value the value
     * @return this (to simplify use in expressions)
     */
    public ParallelLongArrayWithFilter replaceWithValue(long value) {
        ex.invoke(new PAS.FJLFill
                  (this, origin, fence, null, value));
        return this;
    }

    /**
     * Replaces elements with results of applying
     * <tt>op(thisElement, otherElement)</tt>.
     * @param other the other array
     * @param combiner the combiner
     * @return this (to simplify use in expressions)
     */
    public ParallelLongArrayWithFilter replaceWithMapping(BinaryLongOp combiner,
                                   ParallelLongArrayWithLongMapping other) {
        ex.invoke(new PAS.FJLPACombineInPlace
                  (this, origin, fence, null,
                   other, other.origin - origin, combiner));
        return this;
    }

    /**
     * Replaces elements with results of applying
     * <tt>op(thisElement, otherElement)</tt>.
     * @param other the other array
     * @param combiner the combiner
     * @return this (to simplify use in expressions)
     */
    public ParallelLongArrayWithFilter replaceWithMapping(BinaryLongOp combiner,
                                   long[] other) {
        ex.invoke(new PAS.FJLCombineInPlace
                  (this, origin, fence, null, other,
                   -origin, combiner));
        return this;
    }

    /**
     * Returns a new ParallelLongArray containing only unique
     * elements (that is, without any duplicates).
     * @return the new ParallelLongArray
     */
    public ParallelLongArray allUniqueElements() {
        PAS.UniquifierTable tab = new PAS.UniquifierTable
            (fence - origin, this, false);
        PAS.FJLUniquifier f = new PAS.FJLUniquifier
            (this, origin, fence, null, tab);
        ex.invoke(f);
        long[] res = tab.uniqueLongs(f.count);
        return new ParallelLongArray(ex, res);
    }


    /**
     * Returns an operation prefix that causes a method to operate
     * only on elements for which the current selector (if
     * present) and the given selector returns true.
     * @param selector the selector
     * @return operation prefix
     */
    public abstract ParallelLongArrayWithFilter withFilter(LongPredicate selector);

    /**
     * Returns an operation prefix that causes a method to operate
     * only on elements for which the current selector (if
     * present) and the given binary selector returns true.
     * @param selector the selector
     * @return operation prefix
     */
    public ParallelLongArrayWithFilter withFilter
        (BinaryLongPredicate selector,
         ParallelLongArrayWithLongMapping other) {
        return withIndexedFilter(AbstractParallelAnyArray.indexedSelector(selector, other, origin));
    }

    /**
     * Returns an operation prefix that causes a method to operate
     * only on elements for which the current selector (if
     * present) and the given indexed selector returns true.
     * @param selector the selector
     * @return operation prefix
     */
    public abstract ParallelLongArrayWithFilter withIndexedFilter
        (IntAndLongPredicate selector);

    /**
     * Returns true if all elements at the same relative positions
     * of this and other array are equal.
     * @param other the other array
     * @return true if equal
     */
    public boolean hasAllEqualElements(ParallelLongArrayWithLongMapping other) {
        return withFilter(CommonOps.longInequalityPredicate(),
                          other).anyIndex() < 0;
    }

    final void leafTransfer(int lo, int hi, long[] dest, int offset) {
        final long[] a = this.array;
        for (int i = lo; i < hi; ++i)
            dest[offset++] = (a[i]);
    }

    final void leafTransferByIndex(int[] indices, int loIdx, int hiIdx,
                                   long[] dest, int offset) {
        final long[] a = this.array;
        for (int i = loIdx; i < hiIdx; ++i)
            dest[offset++] = (a[indices[i]]);
    }

    final long lget(int i) { return this.array[i]; }
}
Revision:	1.6
Committed:	Mon Dec 5 04:08:47 2011 UTC (12 years, 5 months ago) by jsr166
Branch:	MAIN
Changes since 1.5:	+1 -1 lines
Log Message:	whitespace
#	User	Rev	Content
1	dl	1.1	/*
2			* Written by Doug Lea with assistance from members of JCP JSR-166
3			* Expert Group and released to the public domain, as explained at
4	jsr166	1.2	* http://creativecommons.org/publicdomain/zero/1.0/
5	dl	1.1	*/
6
7			package extra166y;
8			import jsr166y.*;
9			import static extra166y.Ops.*;
10			import java.util.*;
11			import java.util.concurrent.atomic.*;
12			import java.lang.reflect.Array;
13
14
15			/**
16			* A prefix view of ParallelLongArray that causes operations to apply
17			* only to elements for which a selector returns true. Instances of
18			* this class may be constructed only via prefix methods of
19			* ParallelLongArray or its other prefix classes.
20			*/
21			public abstract class ParallelLongArrayWithFilter extends ParallelLongArrayWithLongMapping {
22			ParallelLongArrayWithFilter
23			(ForkJoinPool ex, int origin, int fence, long[] array) {
24			super(ex, origin, fence, array);
25			}
26
27			/**
28			* Replaces elements with the results of applying the given
29			* op to their current values.
30			* @param op the op
31			* @return this (to simplify use in expressions)
32			*/
33	jsr166	1.6	public ParallelLongArrayWithFilter replaceWithMapping(LongOp op) {
34	dl	1.1	ex.invoke(new PAS.FJLTransform
35			(this, origin, fence, null, op));
36			return this;
37			}
38
39			/**
40			* Replaces elements with the results of applying the given
41	jsr166	1.5	* op to their indices.
42	dl	1.1	* @param op the op
43			* @return this (to simplify use in expressions)
44			*/
45			public ParallelLongArrayWithFilter replaceWithMappedIndex(IntToLong op) {
46			ex.invoke(new PAS.FJLIndexMap
47			(this, origin, fence, null, op));
48			return this;
49			}
50
51	jsr166	1.4	/**
52			* Replaces elements with the results of applying the given
53	jsr166	1.5	* mapping to each index and current element value.
54	jsr166	1.4	* @param op the op
55			* @return this (to simplify use in expressions)
56			*/
57	jsr166	1.3	public ParallelLongArrayWithFilter replaceWithMappedIndex(IntAndLongToLong op) {
58	dl	1.1	ex.invoke(new PAS.FJLBinaryIndexMap
59			(this, origin, fence, null, op));
60			return this;
61			}
62
63			/**
64			* Replaces elements with results of applying the given
65			* generator.
66			* @param generator the generator
67			* @return this (to simplify use in expressions)
68			*/
69			public ParallelLongArrayWithFilter replaceWithGeneratedValue(LongGenerator generator) {
70			ex.invoke(new PAS.FJLGenerate
71			(this, origin, fence, null, generator));
72			return this;
73			}
74
75			/**
76			* Replaces elements with the given value.
77			* @param value the value
78			* @return this (to simplify use in expressions)
79			*/
80			public ParallelLongArrayWithFilter replaceWithValue(long value) {
81			ex.invoke(new PAS.FJLFill
82			(this, origin, fence, null, value));
83			return this;
84			}
85
86			/**
87			* Replaces elements with results of applying
88	jsr166	1.5	* <tt>op(thisElement, otherElement)</tt>.
89	dl	1.1	* @param other the other array
90			* @param combiner the combiner
91			* @return this (to simplify use in expressions)
92			*/
93			public ParallelLongArrayWithFilter replaceWithMapping(BinaryLongOp combiner,
94			ParallelLongArrayWithLongMapping other) {
95			ex.invoke(new PAS.FJLPACombineInPlace
96			(this, origin, fence, null,
97			other, other.origin - origin, combiner));
98			return this;
99			}
100
101			/**
102			* Replaces elements with results of applying
103	jsr166	1.5	* <tt>op(thisElement, otherElement)</tt>.
104	dl	1.1	* @param other the other array
105			* @param combiner the combiner
106			* @return this (to simplify use in expressions)
107			*/
108			public ParallelLongArrayWithFilter replaceWithMapping(BinaryLongOp combiner,
109			long[] other) {
110			ex.invoke(new PAS.FJLCombineInPlace
111			(this, origin, fence, null, other,
112			-origin, combiner));
113			return this;
114			}
115
116			/**
117			* Returns a new ParallelLongArray containing only unique
118			* elements (that is, without any duplicates).
119			* @return the new ParallelLongArray
120			*/
121			public ParallelLongArray allUniqueElements() {
122			PAS.UniquifierTable tab = new PAS.UniquifierTable
123			(fence - origin, this, false);
124			PAS.FJLUniquifier f = new PAS.FJLUniquifier
125			(this, origin, fence, null, tab);
126			ex.invoke(f);
127			long[] res = tab.uniqueLongs(f.count);
128			return new ParallelLongArray(ex, res);
129			}
130
131
132			/**
133			* Returns an operation prefix that causes a method to operate
134			* only on elements for which the current selector (if
135	jsr166	1.5	* present) and the given selector returns true.
136	dl	1.1	* @param selector the selector
137			* @return operation prefix
138			*/
139			public abstract ParallelLongArrayWithFilter withFilter(LongPredicate selector);
140
141			/**
142			* Returns an operation prefix that causes a method to operate
143			* only on elements for which the current selector (if
144	jsr166	1.5	* present) and the given binary selector returns true.
145	dl	1.1	* @param selector the selector
146			* @return operation prefix
147			*/
148			public ParallelLongArrayWithFilter withFilter
149			(BinaryLongPredicate selector,
150			ParallelLongArrayWithLongMapping other) {
151			return withIndexedFilter(AbstractParallelAnyArray.indexedSelector(selector, other, origin));
152			}
153
154			/**
155			* Returns an operation prefix that causes a method to operate
156			* only on elements for which the current selector (if
157	jsr166	1.5	* present) and the given indexed selector returns true.
158	dl	1.1	* @param selector the selector
159			* @return operation prefix
160			*/
161			public abstract ParallelLongArrayWithFilter withIndexedFilter
162			(IntAndLongPredicate selector);
163
164			/**
165			* Returns true if all elements at the same relative positions
166			* of this and other array are equal.
167			* @param other the other array
168			* @return true if equal
169			*/
170			public boolean hasAllEqualElements(ParallelLongArrayWithLongMapping other) {
171			return withFilter(CommonOps.longInequalityPredicate(),
172			other).anyIndex() < 0;
173			}
174
175			final void leafTransfer(int lo, int hi, long[] dest, int offset) {
176			final long[] a = this.array;
177			for (int i = lo; i < hi; ++i)
178			dest[offset++] = (a[i]);
179			}
180
181			final void leafTransferByIndex(int[] indices, int loIdx, int hiIdx,
182			long[] dest, int offset) {
183			final long[] a = this.array;
184			for (int i = loIdx; i < hiIdx; ++i)
185			dest[offset++] = (a[indices[i]]);
186			}
187
188			final long lget(int i) { return this.array[i]; }
189			}