ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/extra166y/AbstractParallelAnyArray.java
(Generate patch)

Comparing jsr166/src/extra166y/AbstractParallelAnyArray.java (file contents):
Revision 1.11 by jsr166, Sat Dec 29 23:55:19 2012 UTC vs.
Revision 1.17 by jsr166, Wed Dec 31 19:18:52 2014 UTC

# Line 132 | Line 132 | public abstract class AbstractParallelAn
132       */
133      Object[] ogetArray() { return null; }
134      double[] dgetArray() { return null; }
135 <    long[]  lgetArray() { return null; }
135 >    long[]   lgetArray() { return null; }
136      abstract Object oget(int index);
137      abstract double dget(int index);
138      abstract long lget(int index);
# Line 145 | Line 145 | public abstract class AbstractParallelAn
145       * oget, dget, etc. But most are overridden in most concrete
146       * classes to avoid per-element dispatching.
147       */
148 +
149      void leafApply(int lo, int hi, Procedure procedure) {
150          for (int i = lo; i < hi; ++i)
151              if (isSelected(i))
# Line 274 | Line 275 | public abstract class AbstractParallelAn
275      /**
276       * Shared support for select/map all -- probe filter, map, and
277       * type to start selection driver, or do parallel mapping, or
278 <     * just copy,
278 >     * just copy.
279       */
280      final Object[] allObjects(Class elementType) {
281          if (hasFilter()) {
# Line 403 | Line 404 | public abstract class AbstractParallelAn
404                              int otherOffset, BinaryLongOp combiner) {}
405  
406      // Base of object ref array classes
407 <    static abstract class OPap<T> extends AbstractParallelAnyArray {
407 >    abstract static class OPap<T> extends AbstractParallelAnyArray {
408          T[] array;
409          OPap(ForkJoinPool ex, int origin, int fence, T[] array) {
410              super(ex, origin, fence);
# Line 433 | Line 434 | public abstract class AbstractParallelAn
434      }
435  
436      // Base of double array classes
437 <    static abstract class DPap extends AbstractParallelAnyArray {
437 >    abstract static class DPap extends AbstractParallelAnyArray {
438          double[] array;
439          DPap(ForkJoinPool ex, int origin, int fence, double[] array) {
440              super(ex, origin, fence);
# Line 463 | Line 464 | public abstract class AbstractParallelAn
464      }
465  
466      // Base of long array classes
467 <    static abstract class LPap extends AbstractParallelAnyArray {
467 >    abstract static class LPap extends AbstractParallelAnyArray {
468          long[] array;
469          LPap(ForkJoinPool ex, int origin, int fence, long[] array) {
470              super(ex, origin, fence);
# Line 513 | Line 514 | public abstract class AbstractParallelAn
514              return new ORPap<T>(ex, origin, fence, array, selector);
515          }
516  
517 <        public <U> ParallelArrayWithMapping<T, U> withMapping
517 >        public <U> ParallelArrayWithMapping<T,U> withMapping
518              (Op<? super T, ? extends U> op) {
519              return new OUOMPap<T,U>(ex, origin, fence, array, op);
520          }
# Line 1169 | Line 1170 | public abstract class AbstractParallelAn
1170                   compoundIndexedSelector(this.selector, selector));
1171          }
1172  
1173 <        public <U> ParallelArrayWithMapping<T, U> withMapping
1173 >        public <U> ParallelArrayWithMapping<T,U> withMapping
1174              (Op<? super T, ? extends U> op) {
1175              return new OFOMPap<T,U>(ex, origin, fence, array, selector, op);
1176          }
# Line 1710 | Line 1711 | public abstract class AbstractParallelAn
1711                   compoundIndexedSelector(this.selector, selector));
1712          }
1713  
1714 <        public <U> ParallelArrayWithMapping<T, U> withMapping
1714 >        public <U> ParallelArrayWithMapping<T,U> withMapping
1715              (Op<? super T, ? extends U> op) {
1716              return new OROMPap<T,U>(ex, origin, fence, array, selector, op);
1717          }
# Line 2228 | Line 2229 | public abstract class AbstractParallelAn
2229  
2230      // Object-mapped
2231  
2232 <    static abstract class OOMPap<T,U> extends ParallelArrayWithMapping<T,U> {
2232 >    abstract static class OOMPap<T,U> extends ParallelArrayWithMapping<T,U> {
2233          final Op<? super T, ? extends U> op;
2234          OOMPap(ForkJoinPool ex, int origin, int fence,
2235                 T[] array,
# Line 2258 | Line 2259 | public abstract class AbstractParallelAn
2259          }
2260      }
2261  
2262 <    static abstract class DOMPap<U> extends ParallelDoubleArrayWithMapping<U> {
2262 >    abstract static class DOMPap<U> extends ParallelDoubleArrayWithMapping<U> {
2263          final DoubleToObject<? extends U> op;
2264          DOMPap(ForkJoinPool ex, int origin, int fence,
2265                 double[] array, DoubleToObject<? extends U> op) {
# Line 2287 | Line 2288 | public abstract class AbstractParallelAn
2288          }
2289      }
2290  
2291 <    static abstract class LOMPap<U> extends ParallelLongArrayWithMapping<U> {
2291 >    abstract static class LOMPap<U> extends ParallelLongArrayWithMapping<U> {
2292          final LongToObject<? extends U> op;
2293          LOMPap(ForkJoinPool ex, int origin, int fence,
2294                 long[] array, LongToObject<? extends U> op) {
# Line 2324 | Line 2325 | public abstract class AbstractParallelAn
2325              super(ex, origin, fence, array, op);
2326          }
2327  
2328 <        public <V> ParallelArrayWithMapping<T, V> withMapping
2328 >        public <V> ParallelArrayWithMapping<T,V> withMapping
2329              (Op<? super U, ? extends V> op) {
2330              return new OUOMPap<T,V>(ex, origin, fence, array,
2331                                      CommonOps.compoundOp(this.op, op));
# Line 2518 | Line 2519 | public abstract class AbstractParallelAn
2519          boolean hasFilter() { return true; }
2520          boolean isSelected(int i) { return selector.op(this.array[i]); }
2521  
2522 <        public <V> ParallelArrayWithMapping<T, V> withMapping
2522 >        public <V> ParallelArrayWithMapping<T,V> withMapping
2523              (Op<? super U, ? extends V> op) {
2524              return new OFOMPap<T,V>
2525                  (ex, origin, fence, array, selector,
# Line 2773 | Line 2774 | public abstract class AbstractParallelAn
2774          boolean hasFilter() { return true; }
2775          boolean isSelected(int i) { return selector.op(i, this.array[i]); }
2776  
2777 <        public <V> ParallelArrayWithMapping<T, V> withMapping
2777 >        public <V> ParallelArrayWithMapping<T,V> withMapping
2778              (Op<? super U, ? extends V> op) {
2779              return new OROMPap<T,V>
2780                  (ex, origin, fence, array, selector,
# Line 3013 | Line 3014 | public abstract class AbstractParallelAn
3014  
3015      // Object-combined
3016  
3017 <    static abstract class OOCPap<T,U> extends ParallelArrayWithMapping<T,U> {
3017 >    abstract static class OOCPap<T,U> extends ParallelArrayWithMapping<T,U> {
3018          final IntAndObjectToObject<? super T, ? extends U> op;
3019          OOCPap(ForkJoinPool ex, int origin, int fence,
3020                 T[] array,
# Line 3045 | Line 3046 | public abstract class AbstractParallelAn
3046          }
3047      }
3048  
3049 <    static abstract class DOCPap<U> extends ParallelDoubleArrayWithMapping<U> {
3049 >    abstract static class DOCPap<U> extends ParallelDoubleArrayWithMapping<U> {
3050          final IntAndDoubleToObject<? extends U> op;
3051          DOCPap(ForkJoinPool ex, int origin, int fence,
3052                 double[] array, IntAndDoubleToObject<? extends U> op) {
# Line 3076 | Line 3077 | public abstract class AbstractParallelAn
3077          }
3078      }
3079  
3080 <    static abstract class LOCPap<U> extends ParallelLongArrayWithMapping<U> {
3080 >    abstract static class LOCPap<U> extends ParallelLongArrayWithMapping<U> {
3081          final IntAndLongToObject<? extends U> op;
3082          LOCPap(ForkJoinPool ex, int origin, int fence,
3083                 long[] array, IntAndLongToObject<? extends U> op) {
# Line 3115 | Line 3116 | public abstract class AbstractParallelAn
3116              super(ex, origin, fence, array, op);
3117          }
3118  
3119 <        public <V> ParallelArrayWithMapping<T, V> withMapping
3119 >        public <V> ParallelArrayWithMapping<T,V> withMapping
3120              (Op<? super U, ? extends V> op) {
3121              return new OUOCPap<T,V>(ex, origin, fence, array,
3122                                      compoundIndexedOp(this.op, op));
# Line 3309 | Line 3310 | public abstract class AbstractParallelAn
3310          boolean hasFilter() { return true; }
3311          boolean isSelected(int i) { return selector.op(this.array[i]); }
3312  
3313 <        public <V> ParallelArrayWithMapping<T, V> withMapping
3313 >        public <V> ParallelArrayWithMapping<T,V> withMapping
3314              (Op<? super U, ? extends V> op) {
3315              return new OFOCPap<T,V>(ex, origin, fence, array, selector,
3316                                      compoundIndexedOp(this.op, op));
# Line 3552 | Line 3553 | public abstract class AbstractParallelAn
3553          boolean hasFilter() { return true; }
3554          boolean isSelected(int i) { return selector.op(i, this.array[i]); }
3555  
3556 <        public <V> ParallelArrayWithMapping<T, V> withMapping
3556 >        public <V> ParallelArrayWithMapping<T,V> withMapping
3557              (Op<? super U, ? extends V> op) {
3558              return new OROCPap<T,V>(ex, origin, fence, array, selector,
3559                                      compoundIndexedOp(this.op, op));
# Line 3784 | Line 3785 | public abstract class AbstractParallelAn
3785  
3786      // Double-mapped
3787  
3788 <    static abstract class ODMPap<T> extends ParallelArrayWithDoubleMapping<T> {
3788 >    abstract static class ODMPap<T> extends ParallelArrayWithDoubleMapping<T> {
3789          final ObjectToDouble<? super T> op;
3790          ODMPap(ForkJoinPool ex, int origin, int fence,
3791                 T[] array, ObjectToDouble<? super T> op) {
# Line 3814 | Line 3815 | public abstract class AbstractParallelAn
3815  
3816      }
3817  
3818 <    static abstract class DDMPap extends ParallelDoubleArrayWithDoubleMapping {
3818 >    abstract static class DDMPap extends ParallelDoubleArrayWithDoubleMapping {
3819          final DoubleOp op;
3820          DDMPap
3821              (ForkJoinPool ex, int origin, int fence,
# Line 3844 | Line 3845 | public abstract class AbstractParallelAn
3845          }
3846      }
3847  
3848 <    static abstract class LDMPap extends ParallelLongArrayWithDoubleMapping {
3848 >    abstract static class LDMPap extends ParallelLongArrayWithDoubleMapping {
3849          final LongToDouble op;
3850          LDMPap(ForkJoinPool ex, int origin, int fence,
3851                 long[] array, LongToDouble op) {
# Line 3892 | Line 3893 | public abstract class AbstractParallelAn
3893                                    CommonOps.compoundOp(this.op, op));
3894          }
3895  
3896 <        public <U> ParallelArrayWithMapping<T, U> withMapping
3896 >        public <U> ParallelArrayWithMapping<T,U> withMapping
3897              (DoubleToObject<? extends U> op) {
3898              return new OUOMPap<T,U>(ex, origin, fence, array,
3899                                      CommonOps.compoundOp(this.op, op));
# Line 4080 | Line 4081 | public abstract class AbstractParallelAn
4081                                    CommonOps.compoundOp(this.op, op));
4082          }
4083  
4084 <        public <U> ParallelArrayWithMapping<T, U> withMapping
4084 >        public <U> ParallelArrayWithMapping<T,U> withMapping
4085              (DoubleToObject<? extends U> op) {
4086              return new OFOMPap<T,U>(ex, origin, fence, array, selector,
4087                                      CommonOps.compoundOp(this.op, op));
# Line 4316 | Line 4317 | public abstract class AbstractParallelAn
4317                                    CommonOps.compoundOp(this.op, op));
4318          }
4319  
4320 <        public <U> ParallelArrayWithMapping<T, U> withMapping
4320 >        public <U> ParallelArrayWithMapping<T,U> withMapping
4321              (DoubleToObject<? extends U> op) {
4322              return new OROMPap<T,U>(ex, origin, fence, array, selector,
4323                                      CommonOps.compoundOp(this.op, op));
# Line 4530 | Line 4531 | public abstract class AbstractParallelAn
4531      }
4532  
4533      // double-combined
4534 <    static abstract class ODCPap<T> extends ParallelArrayWithDoubleMapping<T> {
4534 >    abstract static class ODCPap<T> extends ParallelArrayWithDoubleMapping<T> {
4535          final IntAndObjectToDouble<? super T> op;
4536          ODCPap(ForkJoinPool ex, int origin, int fence,
4537                 T[] array, IntAndObjectToDouble<? super T> op) {
# Line 4562 | Line 4563 | public abstract class AbstractParallelAn
4563  
4564      }
4565  
4566 <    static abstract class DDCPap extends ParallelDoubleArrayWithDoubleMapping {
4566 >    abstract static class DDCPap extends ParallelDoubleArrayWithDoubleMapping {
4567          final IntAndDoubleToDouble op;
4568          DDCPap(ForkJoinPool ex, int origin, int fence,
4569                 double[] array, IntAndDoubleToDouble op) {
# Line 4593 | Line 4594 | public abstract class AbstractParallelAn
4594          }
4595      }
4596  
4597 <    static abstract class LDCPap extends ParallelLongArrayWithDoubleMapping {
4597 >    abstract static class LDCPap extends ParallelLongArrayWithDoubleMapping {
4598          final IntAndLongToDouble op;
4599          LDCPap(ForkJoinPool ex, int origin, int fence,
4600                 long[] array, IntAndLongToDouble op) {
# Line 4641 | Line 4642 | public abstract class AbstractParallelAn
4642                                    compoundIndexedOp(this.op, op));
4643          }
4644  
4645 <        public <U> ParallelArrayWithMapping<T, U> withMapping
4645 >        public <U> ParallelArrayWithMapping<T,U> withMapping
4646              (DoubleToObject<? extends U> op) {
4647              return new OUOCPap<T,U>(ex, origin, fence, array,
4648                                      compoundIndexedOp(this.op, op));
# Line 4828 | Line 4829 | public abstract class AbstractParallelAn
4829                                    compoundIndexedOp(this.op, op));
4830          }
4831  
4832 <        public <U> ParallelArrayWithMapping<T, U> withMapping
4832 >        public <U> ParallelArrayWithMapping<T,U> withMapping
4833              (DoubleToObject<? extends U> op) {
4834              return new OFOCPap<T,U>(ex, origin, fence, array, selector,
4835                                      compoundIndexedOp(this.op, op));
# Line 5066 | Line 5067 | public abstract class AbstractParallelAn
5067                                    compoundIndexedOp(this.op, op));
5068          }
5069  
5070 <        public <U> ParallelArrayWithMapping<T, U> withMapping
5070 >        public <U> ParallelArrayWithMapping<T,U> withMapping
5071              (DoubleToObject<? extends U> op) {
5072              return new OROCPap<T,U>(ex, origin, fence, array, selector,
5073                                      compoundIndexedOp(this.op, op));
# Line 5281 | Line 5282 | public abstract class AbstractParallelAn
5282      }
5283  
5284      // long-combined
5285 <    static abstract class OLMPap<T> extends ParallelArrayWithLongMapping<T> {
5285 >    abstract static class OLMPap<T> extends ParallelArrayWithLongMapping<T> {
5286          final ObjectToLong<? super T> op;
5287          OLMPap(ForkJoinPool ex, int origin, int fence,
5288                 T[] array, final ObjectToLong<? super T> op) {
# Line 5310 | Line 5311 | public abstract class AbstractParallelAn
5311          }
5312      }
5313  
5314 <    static abstract class DLMPap extends ParallelDoubleArrayWithLongMapping {
5314 >    abstract static class DLMPap extends ParallelDoubleArrayWithLongMapping {
5315          final DoubleToLong op;
5316          DLMPap(ForkJoinPool ex, int origin, int fence,
5317                 double[] array, DoubleToLong op) {
# Line 5340 | Line 5341 | public abstract class AbstractParallelAn
5341  
5342      }
5343  
5344 <    static abstract class LLMPap extends ParallelLongArrayWithLongMapping {
5344 >    abstract static class LLMPap extends ParallelLongArrayWithLongMapping {
5345          final LongOp op;
5346          LLMPap(ForkJoinPool ex, int origin, int fence,
5347                 long[] array, LongOp op) {
# Line 5387 | Line 5388 | public abstract class AbstractParallelAn
5388                                    CommonOps.compoundOp(this.op, op));
5389          }
5390  
5391 <        public <U> ParallelArrayWithMapping<T, U> withMapping
5391 >        public <U> ParallelArrayWithMapping<T,U> withMapping
5392              (LongToObject<? extends U> op) {
5393              return new OUOMPap<T,U>(ex, origin, fence, array,
5394                                      CommonOps.compoundOp(this.op, op));
# Line 5576 | Line 5577 | public abstract class AbstractParallelAn
5577                                    CommonOps.compoundOp(this.op, op));
5578          }
5579  
5580 <        public <U> ParallelArrayWithMapping<T, U> withMapping
5580 >        public <U> ParallelArrayWithMapping<T,U> withMapping
5581              (LongToObject<? extends U> op) {
5582              return new OFOMPap<T,U>(ex, origin, fence, array, selector,
5583                                      CommonOps.compoundOp(this.op, op));
# Line 5816 | Line 5817 | public abstract class AbstractParallelAn
5817                                    CommonOps.compoundOp(this.op, op));
5818          }
5819  
5820 <        public <U> ParallelArrayWithMapping<T, U> withMapping
5820 >        public <U> ParallelArrayWithMapping<T,U> withMapping
5821              (LongToObject<? extends U> op) {
5822              return new OROMPap<T,U>(ex, origin, fence, array, selector,
5823                                      CommonOps.compoundOp(this.op, op));
# Line 6032 | Line 6033 | public abstract class AbstractParallelAn
6033      }
6034  
6035      // long-combined
6036 <    static abstract class OLCPap<T> extends ParallelArrayWithLongMapping<T> {
6036 >    abstract static class OLCPap<T> extends ParallelArrayWithLongMapping<T> {
6037          final IntAndObjectToLong<? super T> op;
6038          OLCPap(ForkJoinPool ex, int origin, int fence,
6039                 T[] array, IntAndObjectToLong<? super T> op) {
# Line 6063 | Line 6064 | public abstract class AbstractParallelAn
6064          }
6065      }
6066  
6067 <    static abstract class DLCPap extends ParallelDoubleArrayWithLongMapping {
6067 >    abstract static class DLCPap extends ParallelDoubleArrayWithLongMapping {
6068          final IntAndDoubleToLong op;
6069          DLCPap(ForkJoinPool ex, int origin, int fence,
6070                 double[] array, IntAndDoubleToLong op) {
# Line 6094 | Line 6095 | public abstract class AbstractParallelAn
6095          }
6096      }
6097  
6098 <    static abstract class LLCPap extends ParallelLongArrayWithLongMapping {
6098 >    abstract static class LLCPap extends ParallelLongArrayWithLongMapping {
6099          final IntAndLongToLong op;
6100          LLCPap(ForkJoinPool ex, int origin, int fence,
6101                 long[] array, IntAndLongToLong op) {
# Line 6142 | Line 6143 | public abstract class AbstractParallelAn
6143                                    compoundIndexedOp(this.op, op));
6144          }
6145  
6146 <        public <U> ParallelArrayWithMapping<T, U> withMapping
6146 >        public <U> ParallelArrayWithMapping<T,U> withMapping
6147              (LongToObject<? extends U> op) {
6148              return new OUOCPap<T,U>(ex, origin, fence, array,
6149                                      compoundIndexedOp(this.op, op));
# Line 6327 | Line 6328 | public abstract class AbstractParallelAn
6328                                    compoundIndexedOp(this.op, op));
6329          }
6330  
6331 <        public <U> ParallelArrayWithMapping<T, U> withMapping
6331 >        public <U> ParallelArrayWithMapping<T,U> withMapping
6332              (LongToObject<? extends U> op) {
6333              return new OFOCPap<T,U>(ex, origin, fence, array,
6334                                      selector,
# Line 6569 | Line 6570 | public abstract class AbstractParallelAn
6570                                    compoundIndexedOp(this.op, op));
6571          }
6572  
6573 <        public <U> ParallelArrayWithMapping<T, U> withMapping
6573 >        public <U> ParallelArrayWithMapping<T,U> withMapping
6574              (LongToObject<? extends U> op) {
6575              return new OROCPap<T,U>(ex, origin, fence, array,
6576                                      selector,
# Line 6819 | Line 6820 | public abstract class AbstractParallelAn
6820          int cursor;
6821          FilteredAsDoubleIterator() {
6822              cursor = origin;
6823 <            advance() ;
6823 >            advance();
6824          }
6825          private void advance() {
6826              while (cursor < fence) {
# Line 6872 | Line 6873 | public abstract class AbstractParallelAn
6873          int cursor;
6874          FilteredAsLongIterator() {
6875              cursor = origin;
6876 <            advance() ;
6876 >            advance();
6877          }
6878          private void advance() {
6879              while (cursor < fence) {
# Line 6925 | Line 6926 | public abstract class AbstractParallelAn
6926          int cursor;
6927          FilteredIterator() {
6928              cursor = origin;
6929 <            advance() ;
6929 >            advance();
6930          }
6931          private void advance() {
6932              while (cursor < fence) {

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines