You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucene.apache.org by us...@apache.org on 2012/08/31 00:43:59 UTC
svn commit: r1379200 [6/11] - in /lucene/dev/branches/lucene3312: ./
dev-tools/ dev-tools/eclipse/ dev-tools/idea/.idea/libraries/
dev-tools/maven/ dev-tools/maven/lucene/core/
dev-tools/maven/lucene/test-framework/ dev-tools/scripts/ lucene/
lucene/an...
Modified: lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked20.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked20.java?rev=1379200&r1=1379199&r2=1379200&view=diff
==============================================================================
--- lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked20.java (original)
+++ lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked20.java Thu Aug 30 22:43:41 2012
@@ -22,15 +22,12 @@ package org.apache.lucene.util.packed;
/**
* Efficient sequential read/write of packed integers.
*/
-final class BulkOperationPacked20 extends BulkOperation {
- @Override
- public int blockCount() {
- return 5;
- }
+final class BulkOperationPacked20 extends BulkOperationPacked {
- @Override
- public int valueCount() {
- return 16;
+ public BulkOperationPacked20() {
+ super(20);
+ assert blockCount() == 5;
+ assert valueCount() == 16;
}
@Override
@@ -219,30 +216,4 @@ final class BulkOperationPacked20 extend
}
}
- @Override
- public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 44) | ((values[valuesOffset++] & 0xffffffffL) << 24) | ((values[valuesOffset++] & 0xffffffffL) << 4) | ((values[valuesOffset] & 0xffffffffL) >>> 16);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 48) | ((values[valuesOffset++] & 0xffffffffL) << 28) | ((values[valuesOffset++] & 0xffffffffL) << 8) | ((values[valuesOffset] & 0xffffffffL) >>> 12);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 52) | ((values[valuesOffset++] & 0xffffffffL) << 32) | ((values[valuesOffset++] & 0xffffffffL) << 12) | ((values[valuesOffset] & 0xffffffffL) >>> 8);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 56) | ((values[valuesOffset++] & 0xffffffffL) << 36) | ((values[valuesOffset++] & 0xffffffffL) << 16) | ((values[valuesOffset] & 0xffffffffL) >>> 4);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 60) | ((values[valuesOffset++] & 0xffffffffL) << 40) | ((values[valuesOffset++] & 0xffffffffL) << 20) | (values[valuesOffset++] & 0xffffffffL);
- }
- }
-
- @Override
- public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = (values[valuesOffset++] << 44) | (values[valuesOffset++] << 24) | (values[valuesOffset++] << 4) | (values[valuesOffset] >>> 16);
- blocks[blocksOffset++] = (values[valuesOffset++] << 48) | (values[valuesOffset++] << 28) | (values[valuesOffset++] << 8) | (values[valuesOffset] >>> 12);
- blocks[blocksOffset++] = (values[valuesOffset++] << 52) | (values[valuesOffset++] << 32) | (values[valuesOffset++] << 12) | (values[valuesOffset] >>> 8);
- blocks[blocksOffset++] = (values[valuesOffset++] << 56) | (values[valuesOffset++] << 36) | (values[valuesOffset++] << 16) | (values[valuesOffset] >>> 4);
- blocks[blocksOffset++] = (values[valuesOffset++] << 60) | (values[valuesOffset++] << 40) | (values[valuesOffset++] << 20) | values[valuesOffset++];
- }
- }
-
}
Modified: lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked21.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked21.java?rev=1379200&r1=1379199&r2=1379200&view=diff
==============================================================================
--- lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked21.java (original)
+++ lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked21.java Thu Aug 30 22:43:41 2012
@@ -22,15 +22,12 @@ package org.apache.lucene.util.packed;
/**
* Efficient sequential read/write of packed integers.
*/
-final class BulkOperationPacked21 extends BulkOperation {
- @Override
- public int blockCount() {
- return 21;
- }
+final class BulkOperationPacked21 extends BulkOperationPacked {
- @Override
- public int valueCount() {
- return 64;
+ public BulkOperationPacked21() {
+ super(21);
+ assert blockCount() == 21;
+ assert valueCount() == 64;
}
@Override
@@ -699,62 +696,4 @@ final class BulkOperationPacked21 extend
}
}
- @Override
- public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 43) | ((values[valuesOffset++] & 0xffffffffL) << 22) | ((values[valuesOffset++] & 0xffffffffL) << 1) | ((values[valuesOffset] & 0xffffffffL) >>> 20);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 44) | ((values[valuesOffset++] & 0xffffffffL) << 23) | ((values[valuesOffset++] & 0xffffffffL) << 2) | ((values[valuesOffset] & 0xffffffffL) >>> 19);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 45) | ((values[valuesOffset++] & 0xffffffffL) << 24) | ((values[valuesOffset++] & 0xffffffffL) << 3) | ((values[valuesOffset] & 0xffffffffL) >>> 18);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 46) | ((values[valuesOffset++] & 0xffffffffL) << 25) | ((values[valuesOffset++] & 0xffffffffL) << 4) | ((values[valuesOffset] & 0xffffffffL) >>> 17);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 47) | ((values[valuesOffset++] & 0xffffffffL) << 26) | ((values[valuesOffset++] & 0xffffffffL) << 5) | ((values[valuesOffset] & 0xffffffffL) >>> 16);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 48) | ((values[valuesOffset++] & 0xffffffffL) << 27) | ((values[valuesOffset++] & 0xffffffffL) << 6) | ((values[valuesOffset] & 0xffffffffL) >>> 15);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 49) | ((values[valuesOffset++] & 0xffffffffL) << 28) | ((values[valuesOffset++] & 0xffffffffL) << 7) | ((values[valuesOffset] & 0xffffffffL) >>> 14);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 50) | ((values[valuesOffset++] & 0xffffffffL) << 29) | ((values[valuesOffset++] & 0xffffffffL) << 8) | ((values[valuesOffset] & 0xffffffffL) >>> 13);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 51) | ((values[valuesOffset++] & 0xffffffffL) << 30) | ((values[valuesOffset++] & 0xffffffffL) << 9) | ((values[valuesOffset] & 0xffffffffL) >>> 12);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 52) | ((values[valuesOffset++] & 0xffffffffL) << 31) | ((values[valuesOffset++] & 0xffffffffL) << 10) | ((values[valuesOffset] & 0xffffffffL) >>> 11);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 53) | ((values[valuesOffset++] & 0xffffffffL) << 32) | ((values[valuesOffset++] & 0xffffffffL) << 11) | ((values[valuesOffset] & 0xffffffffL) >>> 10);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 54) | ((values[valuesOffset++] & 0xffffffffL) << 33) | ((values[valuesOffset++] & 0xffffffffL) << 12) | ((values[valuesOffset] & 0xffffffffL) >>> 9);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 55) | ((values[valuesOffset++] & 0xffffffffL) << 34) | ((values[valuesOffset++] & 0xffffffffL) << 13) | ((values[valuesOffset] & 0xffffffffL) >>> 8);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 56) | ((values[valuesOffset++] & 0xffffffffL) << 35) | ((values[valuesOffset++] & 0xffffffffL) << 14) | ((values[valuesOffset] & 0xffffffffL) >>> 7);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 57) | ((values[valuesOffset++] & 0xffffffffL) << 36) | ((values[valuesOffset++] & 0xffffffffL) << 15) | ((values[valuesOffset] & 0xffffffffL) >>> 6);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 58) | ((values[valuesOffset++] & 0xffffffffL) << 37) | ((values[valuesOffset++] & 0xffffffffL) << 16) | ((values[valuesOffset] & 0xffffffffL) >>> 5);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 59) | ((values[valuesOffset++] & 0xffffffffL) << 38) | ((values[valuesOffset++] & 0xffffffffL) << 17) | ((values[valuesOffset] & 0xffffffffL) >>> 4);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 60) | ((values[valuesOffset++] & 0xffffffffL) << 39) | ((values[valuesOffset++] & 0xffffffffL) << 18) | ((values[valuesOffset] & 0xffffffffL) >>> 3);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 61) | ((values[valuesOffset++] & 0xffffffffL) << 40) | ((values[valuesOffset++] & 0xffffffffL) << 19) | ((values[valuesOffset] & 0xffffffffL) >>> 2);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 62) | ((values[valuesOffset++] & 0xffffffffL) << 41) | ((values[valuesOffset++] & 0xffffffffL) << 20) | ((values[valuesOffset] & 0xffffffffL) >>> 1);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 63) | ((values[valuesOffset++] & 0xffffffffL) << 42) | ((values[valuesOffset++] & 0xffffffffL) << 21) | (values[valuesOffset++] & 0xffffffffL);
- }
- }
-
- @Override
- public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = (values[valuesOffset++] << 43) | (values[valuesOffset++] << 22) | (values[valuesOffset++] << 1) | (values[valuesOffset] >>> 20);
- blocks[blocksOffset++] = (values[valuesOffset++] << 44) | (values[valuesOffset++] << 23) | (values[valuesOffset++] << 2) | (values[valuesOffset] >>> 19);
- blocks[blocksOffset++] = (values[valuesOffset++] << 45) | (values[valuesOffset++] << 24) | (values[valuesOffset++] << 3) | (values[valuesOffset] >>> 18);
- blocks[blocksOffset++] = (values[valuesOffset++] << 46) | (values[valuesOffset++] << 25) | (values[valuesOffset++] << 4) | (values[valuesOffset] >>> 17);
- blocks[blocksOffset++] = (values[valuesOffset++] << 47) | (values[valuesOffset++] << 26) | (values[valuesOffset++] << 5) | (values[valuesOffset] >>> 16);
- blocks[blocksOffset++] = (values[valuesOffset++] << 48) | (values[valuesOffset++] << 27) | (values[valuesOffset++] << 6) | (values[valuesOffset] >>> 15);
- blocks[blocksOffset++] = (values[valuesOffset++] << 49) | (values[valuesOffset++] << 28) | (values[valuesOffset++] << 7) | (values[valuesOffset] >>> 14);
- blocks[blocksOffset++] = (values[valuesOffset++] << 50) | (values[valuesOffset++] << 29) | (values[valuesOffset++] << 8) | (values[valuesOffset] >>> 13);
- blocks[blocksOffset++] = (values[valuesOffset++] << 51) | (values[valuesOffset++] << 30) | (values[valuesOffset++] << 9) | (values[valuesOffset] >>> 12);
- blocks[blocksOffset++] = (values[valuesOffset++] << 52) | (values[valuesOffset++] << 31) | (values[valuesOffset++] << 10) | (values[valuesOffset] >>> 11);
- blocks[blocksOffset++] = (values[valuesOffset++] << 53) | (values[valuesOffset++] << 32) | (values[valuesOffset++] << 11) | (values[valuesOffset] >>> 10);
- blocks[blocksOffset++] = (values[valuesOffset++] << 54) | (values[valuesOffset++] << 33) | (values[valuesOffset++] << 12) | (values[valuesOffset] >>> 9);
- blocks[blocksOffset++] = (values[valuesOffset++] << 55) | (values[valuesOffset++] << 34) | (values[valuesOffset++] << 13) | (values[valuesOffset] >>> 8);
- blocks[blocksOffset++] = (values[valuesOffset++] << 56) | (values[valuesOffset++] << 35) | (values[valuesOffset++] << 14) | (values[valuesOffset] >>> 7);
- blocks[blocksOffset++] = (values[valuesOffset++] << 57) | (values[valuesOffset++] << 36) | (values[valuesOffset++] << 15) | (values[valuesOffset] >>> 6);
- blocks[blocksOffset++] = (values[valuesOffset++] << 58) | (values[valuesOffset++] << 37) | (values[valuesOffset++] << 16) | (values[valuesOffset] >>> 5);
- blocks[blocksOffset++] = (values[valuesOffset++] << 59) | (values[valuesOffset++] << 38) | (values[valuesOffset++] << 17) | (values[valuesOffset] >>> 4);
- blocks[blocksOffset++] = (values[valuesOffset++] << 60) | (values[valuesOffset++] << 39) | (values[valuesOffset++] << 18) | (values[valuesOffset] >>> 3);
- blocks[blocksOffset++] = (values[valuesOffset++] << 61) | (values[valuesOffset++] << 40) | (values[valuesOffset++] << 19) | (values[valuesOffset] >>> 2);
- blocks[blocksOffset++] = (values[valuesOffset++] << 62) | (values[valuesOffset++] << 41) | (values[valuesOffset++] << 20) | (values[valuesOffset] >>> 1);
- blocks[blocksOffset++] = (values[valuesOffset++] << 63) | (values[valuesOffset++] << 42) | (values[valuesOffset++] << 21) | values[valuesOffset++];
- }
- }
-
}
Modified: lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked22.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked22.java?rev=1379200&r1=1379199&r2=1379200&view=diff
==============================================================================
--- lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked22.java (original)
+++ lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked22.java Thu Aug 30 22:43:41 2012
@@ -22,15 +22,12 @@ package org.apache.lucene.util.packed;
/**
* Efficient sequential read/write of packed integers.
*/
-final class BulkOperationPacked22 extends BulkOperation {
- @Override
- public int blockCount() {
- return 11;
- }
+final class BulkOperationPacked22 extends BulkOperationPacked {
- @Override
- public int valueCount() {
- return 32;
+ public BulkOperationPacked22() {
+ super(22);
+ assert blockCount() == 11;
+ assert valueCount() == 32;
}
@Override
@@ -391,42 +388,4 @@ final class BulkOperationPacked22 extend
}
}
- @Override
- public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 42) | ((values[valuesOffset++] & 0xffffffffL) << 20) | ((values[valuesOffset] & 0xffffffffL) >>> 2);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 62) | ((values[valuesOffset++] & 0xffffffffL) << 40) | ((values[valuesOffset++] & 0xffffffffL) << 18) | ((values[valuesOffset] & 0xffffffffL) >>> 4);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 60) | ((values[valuesOffset++] & 0xffffffffL) << 38) | ((values[valuesOffset++] & 0xffffffffL) << 16) | ((values[valuesOffset] & 0xffffffffL) >>> 6);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 58) | ((values[valuesOffset++] & 0xffffffffL) << 36) | ((values[valuesOffset++] & 0xffffffffL) << 14) | ((values[valuesOffset] & 0xffffffffL) >>> 8);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 56) | ((values[valuesOffset++] & 0xffffffffL) << 34) | ((values[valuesOffset++] & 0xffffffffL) << 12) | ((values[valuesOffset] & 0xffffffffL) >>> 10);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 54) | ((values[valuesOffset++] & 0xffffffffL) << 32) | ((values[valuesOffset++] & 0xffffffffL) << 10) | ((values[valuesOffset] & 0xffffffffL) >>> 12);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 52) | ((values[valuesOffset++] & 0xffffffffL) << 30) | ((values[valuesOffset++] & 0xffffffffL) << 8) | ((values[valuesOffset] & 0xffffffffL) >>> 14);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 50) | ((values[valuesOffset++] & 0xffffffffL) << 28) | ((values[valuesOffset++] & 0xffffffffL) << 6) | ((values[valuesOffset] & 0xffffffffL) >>> 16);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 48) | ((values[valuesOffset++] & 0xffffffffL) << 26) | ((values[valuesOffset++] & 0xffffffffL) << 4) | ((values[valuesOffset] & 0xffffffffL) >>> 18);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 46) | ((values[valuesOffset++] & 0xffffffffL) << 24) | ((values[valuesOffset++] & 0xffffffffL) << 2) | ((values[valuesOffset] & 0xffffffffL) >>> 20);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 44) | ((values[valuesOffset++] & 0xffffffffL) << 22) | (values[valuesOffset++] & 0xffffffffL);
- }
- }
-
- @Override
- public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = (values[valuesOffset++] << 42) | (values[valuesOffset++] << 20) | (values[valuesOffset] >>> 2);
- blocks[blocksOffset++] = (values[valuesOffset++] << 62) | (values[valuesOffset++] << 40) | (values[valuesOffset++] << 18) | (values[valuesOffset] >>> 4);
- blocks[blocksOffset++] = (values[valuesOffset++] << 60) | (values[valuesOffset++] << 38) | (values[valuesOffset++] << 16) | (values[valuesOffset] >>> 6);
- blocks[blocksOffset++] = (values[valuesOffset++] << 58) | (values[valuesOffset++] << 36) | (values[valuesOffset++] << 14) | (values[valuesOffset] >>> 8);
- blocks[blocksOffset++] = (values[valuesOffset++] << 56) | (values[valuesOffset++] << 34) | (values[valuesOffset++] << 12) | (values[valuesOffset] >>> 10);
- blocks[blocksOffset++] = (values[valuesOffset++] << 54) | (values[valuesOffset++] << 32) | (values[valuesOffset++] << 10) | (values[valuesOffset] >>> 12);
- blocks[blocksOffset++] = (values[valuesOffset++] << 52) | (values[valuesOffset++] << 30) | (values[valuesOffset++] << 8) | (values[valuesOffset] >>> 14);
- blocks[blocksOffset++] = (values[valuesOffset++] << 50) | (values[valuesOffset++] << 28) | (values[valuesOffset++] << 6) | (values[valuesOffset] >>> 16);
- blocks[blocksOffset++] = (values[valuesOffset++] << 48) | (values[valuesOffset++] << 26) | (values[valuesOffset++] << 4) | (values[valuesOffset] >>> 18);
- blocks[blocksOffset++] = (values[valuesOffset++] << 46) | (values[valuesOffset++] << 24) | (values[valuesOffset++] << 2) | (values[valuesOffset] >>> 20);
- blocks[blocksOffset++] = (values[valuesOffset++] << 44) | (values[valuesOffset++] << 22) | values[valuesOffset++];
- }
- }
-
}
Modified: lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked23.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked23.java?rev=1379200&r1=1379199&r2=1379200&view=diff
==============================================================================
--- lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked23.java (original)
+++ lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked23.java Thu Aug 30 22:43:41 2012
@@ -22,15 +22,12 @@ package org.apache.lucene.util.packed;
/**
* Efficient sequential read/write of packed integers.
*/
-final class BulkOperationPacked23 extends BulkOperation {
- @Override
- public int blockCount() {
- return 23;
- }
+final class BulkOperationPacked23 extends BulkOperationPacked {
- @Override
- public int valueCount() {
- return 64;
+ public BulkOperationPacked23() {
+ super(23);
+ assert blockCount() == 23;
+ assert valueCount() == 64;
}
@Override
@@ -735,66 +732,4 @@ final class BulkOperationPacked23 extend
}
}
- @Override
- public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 41) | ((values[valuesOffset++] & 0xffffffffL) << 18) | ((values[valuesOffset] & 0xffffffffL) >>> 5);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 59) | ((values[valuesOffset++] & 0xffffffffL) << 36) | ((values[valuesOffset++] & 0xffffffffL) << 13) | ((values[valuesOffset] & 0xffffffffL) >>> 10);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 54) | ((values[valuesOffset++] & 0xffffffffL) << 31) | ((values[valuesOffset++] & 0xffffffffL) << 8) | ((values[valuesOffset] & 0xffffffffL) >>> 15);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 49) | ((values[valuesOffset++] & 0xffffffffL) << 26) | ((values[valuesOffset++] & 0xffffffffL) << 3) | ((values[valuesOffset] & 0xffffffffL) >>> 20);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 44) | ((values[valuesOffset++] & 0xffffffffL) << 21) | ((values[valuesOffset] & 0xffffffffL) >>> 2);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 62) | ((values[valuesOffset++] & 0xffffffffL) << 39) | ((values[valuesOffset++] & 0xffffffffL) << 16) | ((values[valuesOffset] & 0xffffffffL) >>> 7);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 57) | ((values[valuesOffset++] & 0xffffffffL) << 34) | ((values[valuesOffset++] & 0xffffffffL) << 11) | ((values[valuesOffset] & 0xffffffffL) >>> 12);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 52) | ((values[valuesOffset++] & 0xffffffffL) << 29) | ((values[valuesOffset++] & 0xffffffffL) << 6) | ((values[valuesOffset] & 0xffffffffL) >>> 17);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 47) | ((values[valuesOffset++] & 0xffffffffL) << 24) | ((values[valuesOffset++] & 0xffffffffL) << 1) | ((values[valuesOffset] & 0xffffffffL) >>> 22);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 42) | ((values[valuesOffset++] & 0xffffffffL) << 19) | ((values[valuesOffset] & 0xffffffffL) >>> 4);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 60) | ((values[valuesOffset++] & 0xffffffffL) << 37) | ((values[valuesOffset++] & 0xffffffffL) << 14) | ((values[valuesOffset] & 0xffffffffL) >>> 9);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 55) | ((values[valuesOffset++] & 0xffffffffL) << 32) | ((values[valuesOffset++] & 0xffffffffL) << 9) | ((values[valuesOffset] & 0xffffffffL) >>> 14);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 50) | ((values[valuesOffset++] & 0xffffffffL) << 27) | ((values[valuesOffset++] & 0xffffffffL) << 4) | ((values[valuesOffset] & 0xffffffffL) >>> 19);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 45) | ((values[valuesOffset++] & 0xffffffffL) << 22) | ((values[valuesOffset] & 0xffffffffL) >>> 1);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 63) | ((values[valuesOffset++] & 0xffffffffL) << 40) | ((values[valuesOffset++] & 0xffffffffL) << 17) | ((values[valuesOffset] & 0xffffffffL) >>> 6);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 58) | ((values[valuesOffset++] & 0xffffffffL) << 35) | ((values[valuesOffset++] & 0xffffffffL) << 12) | ((values[valuesOffset] & 0xffffffffL) >>> 11);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 53) | ((values[valuesOffset++] & 0xffffffffL) << 30) | ((values[valuesOffset++] & 0xffffffffL) << 7) | ((values[valuesOffset] & 0xffffffffL) >>> 16);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 48) | ((values[valuesOffset++] & 0xffffffffL) << 25) | ((values[valuesOffset++] & 0xffffffffL) << 2) | ((values[valuesOffset] & 0xffffffffL) >>> 21);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 43) | ((values[valuesOffset++] & 0xffffffffL) << 20) | ((values[valuesOffset] & 0xffffffffL) >>> 3);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 61) | ((values[valuesOffset++] & 0xffffffffL) << 38) | ((values[valuesOffset++] & 0xffffffffL) << 15) | ((values[valuesOffset] & 0xffffffffL) >>> 8);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 56) | ((values[valuesOffset++] & 0xffffffffL) << 33) | ((values[valuesOffset++] & 0xffffffffL) << 10) | ((values[valuesOffset] & 0xffffffffL) >>> 13);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 51) | ((values[valuesOffset++] & 0xffffffffL) << 28) | ((values[valuesOffset++] & 0xffffffffL) << 5) | ((values[valuesOffset] & 0xffffffffL) >>> 18);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 46) | ((values[valuesOffset++] & 0xffffffffL) << 23) | (values[valuesOffset++] & 0xffffffffL);
- }
- }
-
- @Override
- public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = (values[valuesOffset++] << 41) | (values[valuesOffset++] << 18) | (values[valuesOffset] >>> 5);
- blocks[blocksOffset++] = (values[valuesOffset++] << 59) | (values[valuesOffset++] << 36) | (values[valuesOffset++] << 13) | (values[valuesOffset] >>> 10);
- blocks[blocksOffset++] = (values[valuesOffset++] << 54) | (values[valuesOffset++] << 31) | (values[valuesOffset++] << 8) | (values[valuesOffset] >>> 15);
- blocks[blocksOffset++] = (values[valuesOffset++] << 49) | (values[valuesOffset++] << 26) | (values[valuesOffset++] << 3) | (values[valuesOffset] >>> 20);
- blocks[blocksOffset++] = (values[valuesOffset++] << 44) | (values[valuesOffset++] << 21) | (values[valuesOffset] >>> 2);
- blocks[blocksOffset++] = (values[valuesOffset++] << 62) | (values[valuesOffset++] << 39) | (values[valuesOffset++] << 16) | (values[valuesOffset] >>> 7);
- blocks[blocksOffset++] = (values[valuesOffset++] << 57) | (values[valuesOffset++] << 34) | (values[valuesOffset++] << 11) | (values[valuesOffset] >>> 12);
- blocks[blocksOffset++] = (values[valuesOffset++] << 52) | (values[valuesOffset++] << 29) | (values[valuesOffset++] << 6) | (values[valuesOffset] >>> 17);
- blocks[blocksOffset++] = (values[valuesOffset++] << 47) | (values[valuesOffset++] << 24) | (values[valuesOffset++] << 1) | (values[valuesOffset] >>> 22);
- blocks[blocksOffset++] = (values[valuesOffset++] << 42) | (values[valuesOffset++] << 19) | (values[valuesOffset] >>> 4);
- blocks[blocksOffset++] = (values[valuesOffset++] << 60) | (values[valuesOffset++] << 37) | (values[valuesOffset++] << 14) | (values[valuesOffset] >>> 9);
- blocks[blocksOffset++] = (values[valuesOffset++] << 55) | (values[valuesOffset++] << 32) | (values[valuesOffset++] << 9) | (values[valuesOffset] >>> 14);
- blocks[blocksOffset++] = (values[valuesOffset++] << 50) | (values[valuesOffset++] << 27) | (values[valuesOffset++] << 4) | (values[valuesOffset] >>> 19);
- blocks[blocksOffset++] = (values[valuesOffset++] << 45) | (values[valuesOffset++] << 22) | (values[valuesOffset] >>> 1);
- blocks[blocksOffset++] = (values[valuesOffset++] << 63) | (values[valuesOffset++] << 40) | (values[valuesOffset++] << 17) | (values[valuesOffset] >>> 6);
- blocks[blocksOffset++] = (values[valuesOffset++] << 58) | (values[valuesOffset++] << 35) | (values[valuesOffset++] << 12) | (values[valuesOffset] >>> 11);
- blocks[blocksOffset++] = (values[valuesOffset++] << 53) | (values[valuesOffset++] << 30) | (values[valuesOffset++] << 7) | (values[valuesOffset] >>> 16);
- blocks[blocksOffset++] = (values[valuesOffset++] << 48) | (values[valuesOffset++] << 25) | (values[valuesOffset++] << 2) | (values[valuesOffset] >>> 21);
- blocks[blocksOffset++] = (values[valuesOffset++] << 43) | (values[valuesOffset++] << 20) | (values[valuesOffset] >>> 3);
- blocks[blocksOffset++] = (values[valuesOffset++] << 61) | (values[valuesOffset++] << 38) | (values[valuesOffset++] << 15) | (values[valuesOffset] >>> 8);
- blocks[blocksOffset++] = (values[valuesOffset++] << 56) | (values[valuesOffset++] << 33) | (values[valuesOffset++] << 10) | (values[valuesOffset] >>> 13);
- blocks[blocksOffset++] = (values[valuesOffset++] << 51) | (values[valuesOffset++] << 28) | (values[valuesOffset++] << 5) | (values[valuesOffset] >>> 18);
- blocks[blocksOffset++] = (values[valuesOffset++] << 46) | (values[valuesOffset++] << 23) | values[valuesOffset++];
- }
- }
-
}
Modified: lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked24.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked24.java?rev=1379200&r1=1379199&r2=1379200&view=diff
==============================================================================
--- lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked24.java (original)
+++ lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked24.java Thu Aug 30 22:43:41 2012
@@ -22,15 +22,12 @@ package org.apache.lucene.util.packed;
/**
* Efficient sequential read/write of packed integers.
*/
-final class BulkOperationPacked24 extends BulkOperation {
- @Override
- public int blockCount() {
- return 3;
- }
+final class BulkOperationPacked24 extends BulkOperationPacked {
- @Override
- public int valueCount() {
- return 8;
+ public BulkOperationPacked24() {
+ super(24);
+ assert blockCount() == 3;
+ assert valueCount() == 8;
}
@Override
@@ -151,26 +148,4 @@ final class BulkOperationPacked24 extend
}
}
- @Override
- public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 40) | ((values[valuesOffset++] & 0xffffffffL) << 16) | ((values[valuesOffset] & 0xffffffffL) >>> 8);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 56) | ((values[valuesOffset++] & 0xffffffffL) << 32) | ((values[valuesOffset++] & 0xffffffffL) << 8) | ((values[valuesOffset] & 0xffffffffL) >>> 16);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 48) | ((values[valuesOffset++] & 0xffffffffL) << 24) | (values[valuesOffset++] & 0xffffffffL);
- }
- }
-
- @Override
- public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = (values[valuesOffset++] << 40) | (values[valuesOffset++] << 16) | (values[valuesOffset] >>> 8);
- blocks[blocksOffset++] = (values[valuesOffset++] << 56) | (values[valuesOffset++] << 32) | (values[valuesOffset++] << 8) | (values[valuesOffset] >>> 16);
- blocks[blocksOffset++] = (values[valuesOffset++] << 48) | (values[valuesOffset++] << 24) | values[valuesOffset++];
- }
- }
-
}
Modified: lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked3.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked3.java?rev=1379200&r1=1379199&r2=1379200&view=diff
==============================================================================
--- lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked3.java (original)
+++ lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked3.java Thu Aug 30 22:43:41 2012
@@ -22,15 +22,12 @@ package org.apache.lucene.util.packed;
/**
* Efficient sequential read/write of packed integers.
*/
-final class BulkOperationPacked3 extends BulkOperation {
- @Override
- public int blockCount() {
- return 3;
- }
+final class BulkOperationPacked3 extends BulkOperationPacked {
- @Override
- public int valueCount() {
- return 64;
+ public BulkOperationPacked3() {
+ super(3);
+ assert blockCount() == 3;
+ assert valueCount() == 64;
}
@Override
@@ -375,26 +372,4 @@ final class BulkOperationPacked3 extends
}
}
- @Override
- public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 61) | ((values[valuesOffset++] & 0xffffffffL) << 58) | ((values[valuesOffset++] & 0xffffffffL) << 55) | ((values[valuesOffset++] & 0xffffffffL) << 52) | ((values[valuesOffset++] & 0xffffffffL) << 49) | ((values[valuesOffset++] & 0xffffffffL) << 46) | ((values[valuesOffset++] & 0xffffffffL) << 43) | ((values[valuesOffset++] & 0xffffffffL) << 40) | ((values[valuesOffset++] & 0xffffffffL) << 37) | ((values[valuesOffset++] & 0xffffffffL) << 34) | ((values[valuesOffset++] & 0xffffffffL) << 31) | ((values[valuesOffset++] & 0xffffffffL) << 28) | ((values[valuesOffset++] & 0xffffffffL) << 25) | ((values[valuesOffset++] & 0xffffffffL) << 22) | ((values[valuesOffset++] & 0xffffffffL) << 19) | ((values[valuesOffset++] & 0xffffffffL) << 16) | ((values[valuesOffset++] & 0xffffffffL) << 13) | ((values[valuesOffset++] & 0xffffffffL) << 10) | ((values[valuesOffset++] & 0xffffffffL) << 7) | ((values[valuesOffset++] &
0xffffffffL) << 4) | ((values[valuesOffset++] & 0xffffffffL) << 1) | ((values[valuesOffset] & 0xffffffffL) >>> 2);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 62) | ((values[valuesOffset++] & 0xffffffffL) << 59) | ((values[valuesOffset++] & 0xffffffffL) << 56) | ((values[valuesOffset++] & 0xffffffffL) << 53) | ((values[valuesOffset++] & 0xffffffffL) << 50) | ((values[valuesOffset++] & 0xffffffffL) << 47) | ((values[valuesOffset++] & 0xffffffffL) << 44) | ((values[valuesOffset++] & 0xffffffffL) << 41) | ((values[valuesOffset++] & 0xffffffffL) << 38) | ((values[valuesOffset++] & 0xffffffffL) << 35) | ((values[valuesOffset++] & 0xffffffffL) << 32) | ((values[valuesOffset++] & 0xffffffffL) << 29) | ((values[valuesOffset++] & 0xffffffffL) << 26) | ((values[valuesOffset++] & 0xffffffffL) << 23) | ((values[valuesOffset++] & 0xffffffffL) << 20) | ((values[valuesOffset++] & 0xffffffffL) << 17) | ((values[valuesOffset++] & 0xffffffffL) << 14) | ((values[valuesOffset++] & 0xffffffffL) << 11) | ((values[valuesOffset++] & 0xffffffffL) << 8) | ((values[valuesOffset++] &
0xffffffffL) << 5) | ((values[valuesOffset++] & 0xffffffffL) << 2) | ((values[valuesOffset] & 0xffffffffL) >>> 1);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 63) | ((values[valuesOffset++] & 0xffffffffL) << 60) | ((values[valuesOffset++] & 0xffffffffL) << 57) | ((values[valuesOffset++] & 0xffffffffL) << 54) | ((values[valuesOffset++] & 0xffffffffL) << 51) | ((values[valuesOffset++] & 0xffffffffL) << 48) | ((values[valuesOffset++] & 0xffffffffL) << 45) | ((values[valuesOffset++] & 0xffffffffL) << 42) | ((values[valuesOffset++] & 0xffffffffL) << 39) | ((values[valuesOffset++] & 0xffffffffL) << 36) | ((values[valuesOffset++] & 0xffffffffL) << 33) | ((values[valuesOffset++] & 0xffffffffL) << 30) | ((values[valuesOffset++] & 0xffffffffL) << 27) | ((values[valuesOffset++] & 0xffffffffL) << 24) | ((values[valuesOffset++] & 0xffffffffL) << 21) | ((values[valuesOffset++] & 0xffffffffL) << 18) | ((values[valuesOffset++] & 0xffffffffL) << 15) | ((values[valuesOffset++] & 0xffffffffL) << 12) | ((values[valuesOffset++] & 0xffffffffL) << 9) | ((values[valuesOffset++] &
0xffffffffL) << 6) | ((values[valuesOffset++] & 0xffffffffL) << 3) | (values[valuesOffset++] & 0xffffffffL);
- }
- }
-
- @Override
- public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = (values[valuesOffset++] << 61) | (values[valuesOffset++] << 58) | (values[valuesOffset++] << 55) | (values[valuesOffset++] << 52) | (values[valuesOffset++] << 49) | (values[valuesOffset++] << 46) | (values[valuesOffset++] << 43) | (values[valuesOffset++] << 40) | (values[valuesOffset++] << 37) | (values[valuesOffset++] << 34) | (values[valuesOffset++] << 31) | (values[valuesOffset++] << 28) | (values[valuesOffset++] << 25) | (values[valuesOffset++] << 22) | (values[valuesOffset++] << 19) | (values[valuesOffset++] << 16) | (values[valuesOffset++] << 13) | (values[valuesOffset++] << 10) | (values[valuesOffset++] << 7) | (values[valuesOffset++] << 4) | (values[valuesOffset++] << 1) | (values[valuesOffset] >>> 2);
- blocks[blocksOffset++] = (values[valuesOffset++] << 62) | (values[valuesOffset++] << 59) | (values[valuesOffset++] << 56) | (values[valuesOffset++] << 53) | (values[valuesOffset++] << 50) | (values[valuesOffset++] << 47) | (values[valuesOffset++] << 44) | (values[valuesOffset++] << 41) | (values[valuesOffset++] << 38) | (values[valuesOffset++] << 35) | (values[valuesOffset++] << 32) | (values[valuesOffset++] << 29) | (values[valuesOffset++] << 26) | (values[valuesOffset++] << 23) | (values[valuesOffset++] << 20) | (values[valuesOffset++] << 17) | (values[valuesOffset++] << 14) | (values[valuesOffset++] << 11) | (values[valuesOffset++] << 8) | (values[valuesOffset++] << 5) | (values[valuesOffset++] << 2) | (values[valuesOffset] >>> 1);
- blocks[blocksOffset++] = (values[valuesOffset++] << 63) | (values[valuesOffset++] << 60) | (values[valuesOffset++] << 57) | (values[valuesOffset++] << 54) | (values[valuesOffset++] << 51) | (values[valuesOffset++] << 48) | (values[valuesOffset++] << 45) | (values[valuesOffset++] << 42) | (values[valuesOffset++] << 39) | (values[valuesOffset++] << 36) | (values[valuesOffset++] << 33) | (values[valuesOffset++] << 30) | (values[valuesOffset++] << 27) | (values[valuesOffset++] << 24) | (values[valuesOffset++] << 21) | (values[valuesOffset++] << 18) | (values[valuesOffset++] << 15) | (values[valuesOffset++] << 12) | (values[valuesOffset++] << 9) | (values[valuesOffset++] << 6) | (values[valuesOffset++] << 3) | values[valuesOffset++];
- }
- }
-
}
Modified: lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked4.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked4.java?rev=1379200&r1=1379199&r2=1379200&view=diff
==============================================================================
--- lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked4.java (original)
+++ lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked4.java Thu Aug 30 22:43:41 2012
@@ -22,15 +22,12 @@ package org.apache.lucene.util.packed;
/**
* Efficient sequential read/write of packed integers.
*/
-final class BulkOperationPacked4 extends BulkOperation {
- @Override
- public int blockCount() {
- return 1;
- }
+final class BulkOperationPacked4 extends BulkOperationPacked {
- @Override
- public int valueCount() {
- return 16;
+ public BulkOperationPacked4() {
+ super(4);
+ assert blockCount() == 1;
+ assert valueCount() == 16;
}
@Override
@@ -147,22 +144,4 @@ final class BulkOperationPacked4 extends
}
}
- @Override
- public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 60) | ((values[valuesOffset++] & 0xffffffffL) << 56) | ((values[valuesOffset++] & 0xffffffffL) << 52) | ((values[valuesOffset++] & 0xffffffffL) << 48) | ((values[valuesOffset++] & 0xffffffffL) << 44) | ((values[valuesOffset++] & 0xffffffffL) << 40) | ((values[valuesOffset++] & 0xffffffffL) << 36) | ((values[valuesOffset++] & 0xffffffffL) << 32) | ((values[valuesOffset++] & 0xffffffffL) << 28) | ((values[valuesOffset++] & 0xffffffffL) << 24) | ((values[valuesOffset++] & 0xffffffffL) << 20) | ((values[valuesOffset++] & 0xffffffffL) << 16) | ((values[valuesOffset++] & 0xffffffffL) << 12) | ((values[valuesOffset++] & 0xffffffffL) << 8) | ((values[valuesOffset++] & 0xffffffffL) << 4) | (values[valuesOffset++] & 0xffffffffL);
- }
- }
-
- @Override
- public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = (values[valuesOffset++] << 60) | (values[valuesOffset++] << 56) | (values[valuesOffset++] << 52) | (values[valuesOffset++] << 48) | (values[valuesOffset++] << 44) | (values[valuesOffset++] << 40) | (values[valuesOffset++] << 36) | (values[valuesOffset++] << 32) | (values[valuesOffset++] << 28) | (values[valuesOffset++] << 24) | (values[valuesOffset++] << 20) | (values[valuesOffset++] << 16) | (values[valuesOffset++] << 12) | (values[valuesOffset++] << 8) | (values[valuesOffset++] << 4) | values[valuesOffset++];
- }
- }
-
}
Modified: lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked5.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked5.java?rev=1379200&r1=1379199&r2=1379200&view=diff
==============================================================================
--- lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked5.java (original)
+++ lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked5.java Thu Aug 30 22:43:41 2012
@@ -22,15 +22,12 @@ package org.apache.lucene.util.packed;
/**
* Efficient sequential read/write of packed integers.
*/
-final class BulkOperationPacked5 extends BulkOperation {
- @Override
- public int blockCount() {
- return 5;
- }
+final class BulkOperationPacked5 extends BulkOperationPacked {
- @Override
- public int valueCount() {
- return 64;
+ public BulkOperationPacked5() {
+ super(5);
+ assert blockCount() == 5;
+ assert valueCount() == 64;
}
@Override
@@ -411,30 +408,4 @@ final class BulkOperationPacked5 extends
}
}
- @Override
- public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 59) | ((values[valuesOffset++] & 0xffffffffL) << 54) | ((values[valuesOffset++] & 0xffffffffL) << 49) | ((values[valuesOffset++] & 0xffffffffL) << 44) | ((values[valuesOffset++] & 0xffffffffL) << 39) | ((values[valuesOffset++] & 0xffffffffL) << 34) | ((values[valuesOffset++] & 0xffffffffL) << 29) | ((values[valuesOffset++] & 0xffffffffL) << 24) | ((values[valuesOffset++] & 0xffffffffL) << 19) | ((values[valuesOffset++] & 0xffffffffL) << 14) | ((values[valuesOffset++] & 0xffffffffL) << 9) | ((values[valuesOffset++] & 0xffffffffL) << 4) | ((values[valuesOffset] & 0xffffffffL) >>> 1);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 63) | ((values[valuesOffset++] & 0xffffffffL) << 58) | ((values[valuesOffset++] & 0xffffffffL) << 53) | ((values[valuesOffset++] & 0xffffffffL) << 48) | ((values[valuesOffset++] & 0xffffffffL) << 43) | ((values[valuesOffset++] & 0xffffffffL) << 38) | ((values[valuesOffset++] & 0xffffffffL) << 33) | ((values[valuesOffset++] & 0xffffffffL) << 28) | ((values[valuesOffset++] & 0xffffffffL) << 23) | ((values[valuesOffset++] & 0xffffffffL) << 18) | ((values[valuesOffset++] & 0xffffffffL) << 13) | ((values[valuesOffset++] & 0xffffffffL) << 8) | ((values[valuesOffset++] & 0xffffffffL) << 3) | ((values[valuesOffset] & 0xffffffffL) >>> 2);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 62) | ((values[valuesOffset++] & 0xffffffffL) << 57) | ((values[valuesOffset++] & 0xffffffffL) << 52) | ((values[valuesOffset++] & 0xffffffffL) << 47) | ((values[valuesOffset++] & 0xffffffffL) << 42) | ((values[valuesOffset++] & 0xffffffffL) << 37) | ((values[valuesOffset++] & 0xffffffffL) << 32) | ((values[valuesOffset++] & 0xffffffffL) << 27) | ((values[valuesOffset++] & 0xffffffffL) << 22) | ((values[valuesOffset++] & 0xffffffffL) << 17) | ((values[valuesOffset++] & 0xffffffffL) << 12) | ((values[valuesOffset++] & 0xffffffffL) << 7) | ((values[valuesOffset++] & 0xffffffffL) << 2) | ((values[valuesOffset] & 0xffffffffL) >>> 3);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 61) | ((values[valuesOffset++] & 0xffffffffL) << 56) | ((values[valuesOffset++] & 0xffffffffL) << 51) | ((values[valuesOffset++] & 0xffffffffL) << 46) | ((values[valuesOffset++] & 0xffffffffL) << 41) | ((values[valuesOffset++] & 0xffffffffL) << 36) | ((values[valuesOffset++] & 0xffffffffL) << 31) | ((values[valuesOffset++] & 0xffffffffL) << 26) | ((values[valuesOffset++] & 0xffffffffL) << 21) | ((values[valuesOffset++] & 0xffffffffL) << 16) | ((values[valuesOffset++] & 0xffffffffL) << 11) | ((values[valuesOffset++] & 0xffffffffL) << 6) | ((values[valuesOffset++] & 0xffffffffL) << 1) | ((values[valuesOffset] & 0xffffffffL) >>> 4);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 60) | ((values[valuesOffset++] & 0xffffffffL) << 55) | ((values[valuesOffset++] & 0xffffffffL) << 50) | ((values[valuesOffset++] & 0xffffffffL) << 45) | ((values[valuesOffset++] & 0xffffffffL) << 40) | ((values[valuesOffset++] & 0xffffffffL) << 35) | ((values[valuesOffset++] & 0xffffffffL) << 30) | ((values[valuesOffset++] & 0xffffffffL) << 25) | ((values[valuesOffset++] & 0xffffffffL) << 20) | ((values[valuesOffset++] & 0xffffffffL) << 15) | ((values[valuesOffset++] & 0xffffffffL) << 10) | ((values[valuesOffset++] & 0xffffffffL) << 5) | (values[valuesOffset++] & 0xffffffffL);
- }
- }
-
- @Override
- public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = (values[valuesOffset++] << 59) | (values[valuesOffset++] << 54) | (values[valuesOffset++] << 49) | (values[valuesOffset++] << 44) | (values[valuesOffset++] << 39) | (values[valuesOffset++] << 34) | (values[valuesOffset++] << 29) | (values[valuesOffset++] << 24) | (values[valuesOffset++] << 19) | (values[valuesOffset++] << 14) | (values[valuesOffset++] << 9) | (values[valuesOffset++] << 4) | (values[valuesOffset] >>> 1);
- blocks[blocksOffset++] = (values[valuesOffset++] << 63) | (values[valuesOffset++] << 58) | (values[valuesOffset++] << 53) | (values[valuesOffset++] << 48) | (values[valuesOffset++] << 43) | (values[valuesOffset++] << 38) | (values[valuesOffset++] << 33) | (values[valuesOffset++] << 28) | (values[valuesOffset++] << 23) | (values[valuesOffset++] << 18) | (values[valuesOffset++] << 13) | (values[valuesOffset++] << 8) | (values[valuesOffset++] << 3) | (values[valuesOffset] >>> 2);
- blocks[blocksOffset++] = (values[valuesOffset++] << 62) | (values[valuesOffset++] << 57) | (values[valuesOffset++] << 52) | (values[valuesOffset++] << 47) | (values[valuesOffset++] << 42) | (values[valuesOffset++] << 37) | (values[valuesOffset++] << 32) | (values[valuesOffset++] << 27) | (values[valuesOffset++] << 22) | (values[valuesOffset++] << 17) | (values[valuesOffset++] << 12) | (values[valuesOffset++] << 7) | (values[valuesOffset++] << 2) | (values[valuesOffset] >>> 3);
- blocks[blocksOffset++] = (values[valuesOffset++] << 61) | (values[valuesOffset++] << 56) | (values[valuesOffset++] << 51) | (values[valuesOffset++] << 46) | (values[valuesOffset++] << 41) | (values[valuesOffset++] << 36) | (values[valuesOffset++] << 31) | (values[valuesOffset++] << 26) | (values[valuesOffset++] << 21) | (values[valuesOffset++] << 16) | (values[valuesOffset++] << 11) | (values[valuesOffset++] << 6) | (values[valuesOffset++] << 1) | (values[valuesOffset] >>> 4);
- blocks[blocksOffset++] = (values[valuesOffset++] << 60) | (values[valuesOffset++] << 55) | (values[valuesOffset++] << 50) | (values[valuesOffset++] << 45) | (values[valuesOffset++] << 40) | (values[valuesOffset++] << 35) | (values[valuesOffset++] << 30) | (values[valuesOffset++] << 25) | (values[valuesOffset++] << 20) | (values[valuesOffset++] << 15) | (values[valuesOffset++] << 10) | (values[valuesOffset++] << 5) | values[valuesOffset++];
- }
- }
-
}
Modified: lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked6.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked6.java?rev=1379200&r1=1379199&r2=1379200&view=diff
==============================================================================
--- lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked6.java (original)
+++ lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked6.java Thu Aug 30 22:43:41 2012
@@ -22,15 +22,12 @@ package org.apache.lucene.util.packed;
/**
* Efficient sequential read/write of packed integers.
*/
-final class BulkOperationPacked6 extends BulkOperation {
- @Override
- public int blockCount() {
- return 3;
- }
+final class BulkOperationPacked6 extends BulkOperationPacked {
- @Override
- public int valueCount() {
- return 32;
+ public BulkOperationPacked6() {
+ super(6);
+ assert blockCount() == 3;
+ assert valueCount() == 32;
}
@Override
@@ -247,26 +244,4 @@ final class BulkOperationPacked6 extends
}
}
- @Override
- public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 58) | ((values[valuesOffset++] & 0xffffffffL) << 52) | ((values[valuesOffset++] & 0xffffffffL) << 46) | ((values[valuesOffset++] & 0xffffffffL) << 40) | ((values[valuesOffset++] & 0xffffffffL) << 34) | ((values[valuesOffset++] & 0xffffffffL) << 28) | ((values[valuesOffset++] & 0xffffffffL) << 22) | ((values[valuesOffset++] & 0xffffffffL) << 16) | ((values[valuesOffset++] & 0xffffffffL) << 10) | ((values[valuesOffset++] & 0xffffffffL) << 4) | ((values[valuesOffset] & 0xffffffffL) >>> 2);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 62) | ((values[valuesOffset++] & 0xffffffffL) << 56) | ((values[valuesOffset++] & 0xffffffffL) << 50) | ((values[valuesOffset++] & 0xffffffffL) << 44) | ((values[valuesOffset++] & 0xffffffffL) << 38) | ((values[valuesOffset++] & 0xffffffffL) << 32) | ((values[valuesOffset++] & 0xffffffffL) << 26) | ((values[valuesOffset++] & 0xffffffffL) << 20) | ((values[valuesOffset++] & 0xffffffffL) << 14) | ((values[valuesOffset++] & 0xffffffffL) << 8) | ((values[valuesOffset++] & 0xffffffffL) << 2) | ((values[valuesOffset] & 0xffffffffL) >>> 4);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 60) | ((values[valuesOffset++] & 0xffffffffL) << 54) | ((values[valuesOffset++] & 0xffffffffL) << 48) | ((values[valuesOffset++] & 0xffffffffL) << 42) | ((values[valuesOffset++] & 0xffffffffL) << 36) | ((values[valuesOffset++] & 0xffffffffL) << 30) | ((values[valuesOffset++] & 0xffffffffL) << 24) | ((values[valuesOffset++] & 0xffffffffL) << 18) | ((values[valuesOffset++] & 0xffffffffL) << 12) | ((values[valuesOffset++] & 0xffffffffL) << 6) | (values[valuesOffset++] & 0xffffffffL);
- }
- }
-
- @Override
- public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = (values[valuesOffset++] << 58) | (values[valuesOffset++] << 52) | (values[valuesOffset++] << 46) | (values[valuesOffset++] << 40) | (values[valuesOffset++] << 34) | (values[valuesOffset++] << 28) | (values[valuesOffset++] << 22) | (values[valuesOffset++] << 16) | (values[valuesOffset++] << 10) | (values[valuesOffset++] << 4) | (values[valuesOffset] >>> 2);
- blocks[blocksOffset++] = (values[valuesOffset++] << 62) | (values[valuesOffset++] << 56) | (values[valuesOffset++] << 50) | (values[valuesOffset++] << 44) | (values[valuesOffset++] << 38) | (values[valuesOffset++] << 32) | (values[valuesOffset++] << 26) | (values[valuesOffset++] << 20) | (values[valuesOffset++] << 14) | (values[valuesOffset++] << 8) | (values[valuesOffset++] << 2) | (values[valuesOffset] >>> 4);
- blocks[blocksOffset++] = (values[valuesOffset++] << 60) | (values[valuesOffset++] << 54) | (values[valuesOffset++] << 48) | (values[valuesOffset++] << 42) | (values[valuesOffset++] << 36) | (values[valuesOffset++] << 30) | (values[valuesOffset++] << 24) | (values[valuesOffset++] << 18) | (values[valuesOffset++] << 12) | (values[valuesOffset++] << 6) | values[valuesOffset++];
- }
- }
-
}
Modified: lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked7.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked7.java?rev=1379200&r1=1379199&r2=1379200&view=diff
==============================================================================
--- lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked7.java (original)
+++ lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked7.java Thu Aug 30 22:43:41 2012
@@ -22,15 +22,12 @@ package org.apache.lucene.util.packed;
/**
* Efficient sequential read/write of packed integers.
*/
-final class BulkOperationPacked7 extends BulkOperation {
- @Override
- public int blockCount() {
- return 7;
- }
+final class BulkOperationPacked7 extends BulkOperationPacked {
- @Override
- public int valueCount() {
- return 64;
+ public BulkOperationPacked7() {
+ super(7);
+ assert blockCount() == 7;
+ assert valueCount() == 64;
}
@Override
@@ -447,34 +444,4 @@ final class BulkOperationPacked7 extends
}
}
- @Override
- public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 57) | ((values[valuesOffset++] & 0xffffffffL) << 50) | ((values[valuesOffset++] & 0xffffffffL) << 43) | ((values[valuesOffset++] & 0xffffffffL) << 36) | ((values[valuesOffset++] & 0xffffffffL) << 29) | ((values[valuesOffset++] & 0xffffffffL) << 22) | ((values[valuesOffset++] & 0xffffffffL) << 15) | ((values[valuesOffset++] & 0xffffffffL) << 8) | ((values[valuesOffset++] & 0xffffffffL) << 1) | ((values[valuesOffset] & 0xffffffffL) >>> 6);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 58) | ((values[valuesOffset++] & 0xffffffffL) << 51) | ((values[valuesOffset++] & 0xffffffffL) << 44) | ((values[valuesOffset++] & 0xffffffffL) << 37) | ((values[valuesOffset++] & 0xffffffffL) << 30) | ((values[valuesOffset++] & 0xffffffffL) << 23) | ((values[valuesOffset++] & 0xffffffffL) << 16) | ((values[valuesOffset++] & 0xffffffffL) << 9) | ((values[valuesOffset++] & 0xffffffffL) << 2) | ((values[valuesOffset] & 0xffffffffL) >>> 5);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 59) | ((values[valuesOffset++] & 0xffffffffL) << 52) | ((values[valuesOffset++] & 0xffffffffL) << 45) | ((values[valuesOffset++] & 0xffffffffL) << 38) | ((values[valuesOffset++] & 0xffffffffL) << 31) | ((values[valuesOffset++] & 0xffffffffL) << 24) | ((values[valuesOffset++] & 0xffffffffL) << 17) | ((values[valuesOffset++] & 0xffffffffL) << 10) | ((values[valuesOffset++] & 0xffffffffL) << 3) | ((values[valuesOffset] & 0xffffffffL) >>> 4);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 60) | ((values[valuesOffset++] & 0xffffffffL) << 53) | ((values[valuesOffset++] & 0xffffffffL) << 46) | ((values[valuesOffset++] & 0xffffffffL) << 39) | ((values[valuesOffset++] & 0xffffffffL) << 32) | ((values[valuesOffset++] & 0xffffffffL) << 25) | ((values[valuesOffset++] & 0xffffffffL) << 18) | ((values[valuesOffset++] & 0xffffffffL) << 11) | ((values[valuesOffset++] & 0xffffffffL) << 4) | ((values[valuesOffset] & 0xffffffffL) >>> 3);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 61) | ((values[valuesOffset++] & 0xffffffffL) << 54) | ((values[valuesOffset++] & 0xffffffffL) << 47) | ((values[valuesOffset++] & 0xffffffffL) << 40) | ((values[valuesOffset++] & 0xffffffffL) << 33) | ((values[valuesOffset++] & 0xffffffffL) << 26) | ((values[valuesOffset++] & 0xffffffffL) << 19) | ((values[valuesOffset++] & 0xffffffffL) << 12) | ((values[valuesOffset++] & 0xffffffffL) << 5) | ((values[valuesOffset] & 0xffffffffL) >>> 2);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 62) | ((values[valuesOffset++] & 0xffffffffL) << 55) | ((values[valuesOffset++] & 0xffffffffL) << 48) | ((values[valuesOffset++] & 0xffffffffL) << 41) | ((values[valuesOffset++] & 0xffffffffL) << 34) | ((values[valuesOffset++] & 0xffffffffL) << 27) | ((values[valuesOffset++] & 0xffffffffL) << 20) | ((values[valuesOffset++] & 0xffffffffL) << 13) | ((values[valuesOffset++] & 0xffffffffL) << 6) | ((values[valuesOffset] & 0xffffffffL) >>> 1);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 63) | ((values[valuesOffset++] & 0xffffffffL) << 56) | ((values[valuesOffset++] & 0xffffffffL) << 49) | ((values[valuesOffset++] & 0xffffffffL) << 42) | ((values[valuesOffset++] & 0xffffffffL) << 35) | ((values[valuesOffset++] & 0xffffffffL) << 28) | ((values[valuesOffset++] & 0xffffffffL) << 21) | ((values[valuesOffset++] & 0xffffffffL) << 14) | ((values[valuesOffset++] & 0xffffffffL) << 7) | (values[valuesOffset++] & 0xffffffffL);
- }
- }
-
- @Override
- public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = (values[valuesOffset++] << 57) | (values[valuesOffset++] << 50) | (values[valuesOffset++] << 43) | (values[valuesOffset++] << 36) | (values[valuesOffset++] << 29) | (values[valuesOffset++] << 22) | (values[valuesOffset++] << 15) | (values[valuesOffset++] << 8) | (values[valuesOffset++] << 1) | (values[valuesOffset] >>> 6);
- blocks[blocksOffset++] = (values[valuesOffset++] << 58) | (values[valuesOffset++] << 51) | (values[valuesOffset++] << 44) | (values[valuesOffset++] << 37) | (values[valuesOffset++] << 30) | (values[valuesOffset++] << 23) | (values[valuesOffset++] << 16) | (values[valuesOffset++] << 9) | (values[valuesOffset++] << 2) | (values[valuesOffset] >>> 5);
- blocks[blocksOffset++] = (values[valuesOffset++] << 59) | (values[valuesOffset++] << 52) | (values[valuesOffset++] << 45) | (values[valuesOffset++] << 38) | (values[valuesOffset++] << 31) | (values[valuesOffset++] << 24) | (values[valuesOffset++] << 17) | (values[valuesOffset++] << 10) | (values[valuesOffset++] << 3) | (values[valuesOffset] >>> 4);
- blocks[blocksOffset++] = (values[valuesOffset++] << 60) | (values[valuesOffset++] << 53) | (values[valuesOffset++] << 46) | (values[valuesOffset++] << 39) | (values[valuesOffset++] << 32) | (values[valuesOffset++] << 25) | (values[valuesOffset++] << 18) | (values[valuesOffset++] << 11) | (values[valuesOffset++] << 4) | (values[valuesOffset] >>> 3);
- blocks[blocksOffset++] = (values[valuesOffset++] << 61) | (values[valuesOffset++] << 54) | (values[valuesOffset++] << 47) | (values[valuesOffset++] << 40) | (values[valuesOffset++] << 33) | (values[valuesOffset++] << 26) | (values[valuesOffset++] << 19) | (values[valuesOffset++] << 12) | (values[valuesOffset++] << 5) | (values[valuesOffset] >>> 2);
- blocks[blocksOffset++] = (values[valuesOffset++] << 62) | (values[valuesOffset++] << 55) | (values[valuesOffset++] << 48) | (values[valuesOffset++] << 41) | (values[valuesOffset++] << 34) | (values[valuesOffset++] << 27) | (values[valuesOffset++] << 20) | (values[valuesOffset++] << 13) | (values[valuesOffset++] << 6) | (values[valuesOffset] >>> 1);
- blocks[blocksOffset++] = (values[valuesOffset++] << 63) | (values[valuesOffset++] << 56) | (values[valuesOffset++] << 49) | (values[valuesOffset++] << 42) | (values[valuesOffset++] << 35) | (values[valuesOffset++] << 28) | (values[valuesOffset++] << 21) | (values[valuesOffset++] << 14) | (values[valuesOffset++] << 7) | values[valuesOffset++];
- }
- }
-
}
Modified: lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked8.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked8.java?rev=1379200&r1=1379199&r2=1379200&view=diff
==============================================================================
--- lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked8.java (original)
+++ lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked8.java Thu Aug 30 22:43:41 2012
@@ -22,15 +22,12 @@ package org.apache.lucene.util.packed;
/**
* Efficient sequential read/write of packed integers.
*/
-final class BulkOperationPacked8 extends BulkOperation {
- @Override
- public int blockCount() {
- return 1;
- }
+final class BulkOperationPacked8 extends BulkOperationPacked {
- @Override
- public int valueCount() {
- return 8;
+ public BulkOperationPacked8() {
+ super(8);
+ assert blockCount() == 1;
+ assert valueCount() == 8;
}
@Override
@@ -115,22 +112,4 @@ final class BulkOperationPacked8 extends
}
}
- @Override
- public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 56) | ((values[valuesOffset++] & 0xffffffffL) << 48) | ((values[valuesOffset++] & 0xffffffffL) << 40) | ((values[valuesOffset++] & 0xffffffffL) << 32) | ((values[valuesOffset++] & 0xffffffffL) << 24) | ((values[valuesOffset++] & 0xffffffffL) << 16) | ((values[valuesOffset++] & 0xffffffffL) << 8) | (values[valuesOffset++] & 0xffffffffL);
- }
- }
-
- @Override
- public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = (values[valuesOffset++] << 56) | (values[valuesOffset++] << 48) | (values[valuesOffset++] << 40) | (values[valuesOffset++] << 32) | (values[valuesOffset++] << 24) | (values[valuesOffset++] << 16) | (values[valuesOffset++] << 8) | values[valuesOffset++];
- }
- }
-
}
Modified: lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked9.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked9.java?rev=1379200&r1=1379199&r2=1379200&view=diff
==============================================================================
--- lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked9.java (original)
+++ lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked9.java Thu Aug 30 22:43:41 2012
@@ -22,15 +22,12 @@ package org.apache.lucene.util.packed;
/**
* Efficient sequential read/write of packed integers.
*/
-final class BulkOperationPacked9 extends BulkOperation {
- @Override
- public int blockCount() {
- return 9;
- }
+final class BulkOperationPacked9 extends BulkOperationPacked {
- @Override
- public int valueCount() {
- return 64;
+ public BulkOperationPacked9() {
+ super(9);
+ assert blockCount() == 9;
+ assert valueCount() == 64;
}
@Override
@@ -483,38 +480,4 @@ final class BulkOperationPacked9 extends
}
}
- @Override
- public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 55) | ((values[valuesOffset++] & 0xffffffffL) << 46) | ((values[valuesOffset++] & 0xffffffffL) << 37) | ((values[valuesOffset++] & 0xffffffffL) << 28) | ((values[valuesOffset++] & 0xffffffffL) << 19) | ((values[valuesOffset++] & 0xffffffffL) << 10) | ((values[valuesOffset++] & 0xffffffffL) << 1) | ((values[valuesOffset] & 0xffffffffL) >>> 8);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 56) | ((values[valuesOffset++] & 0xffffffffL) << 47) | ((values[valuesOffset++] & 0xffffffffL) << 38) | ((values[valuesOffset++] & 0xffffffffL) << 29) | ((values[valuesOffset++] & 0xffffffffL) << 20) | ((values[valuesOffset++] & 0xffffffffL) << 11) | ((values[valuesOffset++] & 0xffffffffL) << 2) | ((values[valuesOffset] & 0xffffffffL) >>> 7);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 57) | ((values[valuesOffset++] & 0xffffffffL) << 48) | ((values[valuesOffset++] & 0xffffffffL) << 39) | ((values[valuesOffset++] & 0xffffffffL) << 30) | ((values[valuesOffset++] & 0xffffffffL) << 21) | ((values[valuesOffset++] & 0xffffffffL) << 12) | ((values[valuesOffset++] & 0xffffffffL) << 3) | ((values[valuesOffset] & 0xffffffffL) >>> 6);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 58) | ((values[valuesOffset++] & 0xffffffffL) << 49) | ((values[valuesOffset++] & 0xffffffffL) << 40) | ((values[valuesOffset++] & 0xffffffffL) << 31) | ((values[valuesOffset++] & 0xffffffffL) << 22) | ((values[valuesOffset++] & 0xffffffffL) << 13) | ((values[valuesOffset++] & 0xffffffffL) << 4) | ((values[valuesOffset] & 0xffffffffL) >>> 5);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 59) | ((values[valuesOffset++] & 0xffffffffL) << 50) | ((values[valuesOffset++] & 0xffffffffL) << 41) | ((values[valuesOffset++] & 0xffffffffL) << 32) | ((values[valuesOffset++] & 0xffffffffL) << 23) | ((values[valuesOffset++] & 0xffffffffL) << 14) | ((values[valuesOffset++] & 0xffffffffL) << 5) | ((values[valuesOffset] & 0xffffffffL) >>> 4);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 60) | ((values[valuesOffset++] & 0xffffffffL) << 51) | ((values[valuesOffset++] & 0xffffffffL) << 42) | ((values[valuesOffset++] & 0xffffffffL) << 33) | ((values[valuesOffset++] & 0xffffffffL) << 24) | ((values[valuesOffset++] & 0xffffffffL) << 15) | ((values[valuesOffset++] & 0xffffffffL) << 6) | ((values[valuesOffset] & 0xffffffffL) >>> 3);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 61) | ((values[valuesOffset++] & 0xffffffffL) << 52) | ((values[valuesOffset++] & 0xffffffffL) << 43) | ((values[valuesOffset++] & 0xffffffffL) << 34) | ((values[valuesOffset++] & 0xffffffffL) << 25) | ((values[valuesOffset++] & 0xffffffffL) << 16) | ((values[valuesOffset++] & 0xffffffffL) << 7) | ((values[valuesOffset] & 0xffffffffL) >>> 2);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 62) | ((values[valuesOffset++] & 0xffffffffL) << 53) | ((values[valuesOffset++] & 0xffffffffL) << 44) | ((values[valuesOffset++] & 0xffffffffL) << 35) | ((values[valuesOffset++] & 0xffffffffL) << 26) | ((values[valuesOffset++] & 0xffffffffL) << 17) | ((values[valuesOffset++] & 0xffffffffL) << 8) | ((values[valuesOffset] & 0xffffffffL) >>> 1);
- blocks[blocksOffset++] = ((values[valuesOffset++] & 0xffffffffL) << 63) | ((values[valuesOffset++] & 0xffffffffL) << 54) | ((values[valuesOffset++] & 0xffffffffL) << 45) | ((values[valuesOffset++] & 0xffffffffL) << 36) | ((values[valuesOffset++] & 0xffffffffL) << 27) | ((values[valuesOffset++] & 0xffffffffL) << 18) | ((values[valuesOffset++] & 0xffffffffL) << 9) | (values[valuesOffset++] & 0xffffffffL);
- }
- }
-
- @Override
- public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = (values[valuesOffset++] << 55) | (values[valuesOffset++] << 46) | (values[valuesOffset++] << 37) | (values[valuesOffset++] << 28) | (values[valuesOffset++] << 19) | (values[valuesOffset++] << 10) | (values[valuesOffset++] << 1) | (values[valuesOffset] >>> 8);
- blocks[blocksOffset++] = (values[valuesOffset++] << 56) | (values[valuesOffset++] << 47) | (values[valuesOffset++] << 38) | (values[valuesOffset++] << 29) | (values[valuesOffset++] << 20) | (values[valuesOffset++] << 11) | (values[valuesOffset++] << 2) | (values[valuesOffset] >>> 7);
- blocks[blocksOffset++] = (values[valuesOffset++] << 57) | (values[valuesOffset++] << 48) | (values[valuesOffset++] << 39) | (values[valuesOffset++] << 30) | (values[valuesOffset++] << 21) | (values[valuesOffset++] << 12) | (values[valuesOffset++] << 3) | (values[valuesOffset] >>> 6);
- blocks[blocksOffset++] = (values[valuesOffset++] << 58) | (values[valuesOffset++] << 49) | (values[valuesOffset++] << 40) | (values[valuesOffset++] << 31) | (values[valuesOffset++] << 22) | (values[valuesOffset++] << 13) | (values[valuesOffset++] << 4) | (values[valuesOffset] >>> 5);
- blocks[blocksOffset++] = (values[valuesOffset++] << 59) | (values[valuesOffset++] << 50) | (values[valuesOffset++] << 41) | (values[valuesOffset++] << 32) | (values[valuesOffset++] << 23) | (values[valuesOffset++] << 14) | (values[valuesOffset++] << 5) | (values[valuesOffset] >>> 4);
- blocks[blocksOffset++] = (values[valuesOffset++] << 60) | (values[valuesOffset++] << 51) | (values[valuesOffset++] << 42) | (values[valuesOffset++] << 33) | (values[valuesOffset++] << 24) | (values[valuesOffset++] << 15) | (values[valuesOffset++] << 6) | (values[valuesOffset] >>> 3);
- blocks[blocksOffset++] = (values[valuesOffset++] << 61) | (values[valuesOffset++] << 52) | (values[valuesOffset++] << 43) | (values[valuesOffset++] << 34) | (values[valuesOffset++] << 25) | (values[valuesOffset++] << 16) | (values[valuesOffset++] << 7) | (values[valuesOffset] >>> 2);
- blocks[blocksOffset++] = (values[valuesOffset++] << 62) | (values[valuesOffset++] << 53) | (values[valuesOffset++] << 44) | (values[valuesOffset++] << 35) | (values[valuesOffset++] << 26) | (values[valuesOffset++] << 17) | (values[valuesOffset++] << 8) | (values[valuesOffset] >>> 1);
- blocks[blocksOffset++] = (values[valuesOffset++] << 63) | (values[valuesOffset++] << 54) | (values[valuesOffset++] << 45) | (values[valuesOffset++] << 36) | (values[valuesOffset++] << 27) | (values[valuesOffset++] << 18) | (values[valuesOffset++] << 9) | values[valuesOffset++];
- }
- }
-
}
Modified: lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock1.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock1.java?rev=1379200&r1=1379199&r2=1379200&view=diff
==============================================================================
--- lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock1.java (original)
+++ lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock1.java Thu Aug 30 22:43:41 2012
@@ -22,15 +22,10 @@ package org.apache.lucene.util.packed;
/**
* Efficient sequential read/write of packed integers.
*/
-final class BulkOperationPackedSingleBlock1 extends BulkOperation {
- @Override
- public int blockCount() {
- return 1;
- }
+final class BulkOperationPackedSingleBlock1 extends BulkOperationPackedSingleBlock {
- @Override
- public int valueCount() {
- return 64;
+ public BulkOperationPackedSingleBlock1() {
+ super(1);
}
@Override
@@ -339,22 +334,4 @@ final class BulkOperationPackedSingleBlo
}
}
- @Override
- public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = (values[valuesOffset++] & 0xffffffffL) | ((values[valuesOffset++] & 0xffffffffL) << 1) | ((values[valuesOffset++] & 0xffffffffL) << 2) | ((values[valuesOffset++] & 0xffffffffL) << 3) | ((values[valuesOffset++] & 0xffffffffL) << 4) | ((values[valuesOffset++] & 0xffffffffL) << 5) | ((values[valuesOffset++] & 0xffffffffL) << 6) | ((values[valuesOffset++] & 0xffffffffL) << 7) | ((values[valuesOffset++] & 0xffffffffL) << 8) | ((values[valuesOffset++] & 0xffffffffL) << 9) | ((values[valuesOffset++] & 0xffffffffL) << 10) | ((values[valuesOffset++] & 0xffffffffL) << 11) | ((values[valuesOffset++] & 0xffffffffL) << 12) | ((values[valuesOffset++] & 0xffffffffL) << 13) | ((values[valuesOffset++] & 0xffffffffL) << 14) | ((values[valuesOffset++] & 0xffffffffL) << 15) | ((values[valuesOffset++] & 0xffffffffL) << 16) | ((values[valuesOffset++] & 0xffffffffL) << 17) | ((values[valuesOffset++] & 0xffffffffL) << 18) | ((values[valuesOffset++] & 0xffffffffL) <<
19) | ((values[valuesOffset++] & 0xffffffffL) << 20) | ((values[valuesOffset++] & 0xffffffffL) << 21) | ((values[valuesOffset++] & 0xffffffffL) << 22) | ((values[valuesOffset++] & 0xffffffffL) << 23) | ((values[valuesOffset++] & 0xffffffffL) << 24) | ((values[valuesOffset++] & 0xffffffffL) << 25) | ((values[valuesOffset++] & 0xffffffffL) << 26) | ((values[valuesOffset++] & 0xffffffffL) << 27) | ((values[valuesOffset++] & 0xffffffffL) << 28) | ((values[valuesOffset++] & 0xffffffffL) << 29) | ((values[valuesOffset++] & 0xffffffffL) << 30) | ((values[valuesOffset++] & 0xffffffffL) << 31) | ((values[valuesOffset++] & 0xffffffffL) << 32) | ((values[valuesOffset++] & 0xffffffffL) << 33) | ((values[valuesOffset++] & 0xffffffffL) << 34) | ((values[valuesOffset++] & 0xffffffffL) << 35) | ((values[valuesOffset++] & 0xffffffffL) << 36) | ((values[valuesOffset++] & 0xffffffffL) << 37) | ((values[valuesOffset++] & 0xffffffffL) << 38) | ((values[valuesOffset++] & 0xffffffffL) << 39) | ((
values[valuesOffset++] & 0xffffffffL) << 40) | ((values[valuesOffset++] & 0xffffffffL) << 41) | ((values[valuesOffset++] & 0xffffffffL) << 42) | ((values[valuesOffset++] & 0xffffffffL) << 43) | ((values[valuesOffset++] & 0xffffffffL) << 44) | ((values[valuesOffset++] & 0xffffffffL) << 45) | ((values[valuesOffset++] & 0xffffffffL) << 46) | ((values[valuesOffset++] & 0xffffffffL) << 47) | ((values[valuesOffset++] & 0xffffffffL) << 48) | ((values[valuesOffset++] & 0xffffffffL) << 49) | ((values[valuesOffset++] & 0xffffffffL) << 50) | ((values[valuesOffset++] & 0xffffffffL) << 51) | ((values[valuesOffset++] & 0xffffffffL) << 52) | ((values[valuesOffset++] & 0xffffffffL) << 53) | ((values[valuesOffset++] & 0xffffffffL) << 54) | ((values[valuesOffset++] & 0xffffffffL) << 55) | ((values[valuesOffset++] & 0xffffffffL) << 56) | ((values[valuesOffset++] & 0xffffffffL) << 57) | ((values[valuesOffset++] & 0xffffffffL) << 58) | ((values[valuesOffset++] & 0xffffffffL) << 59) | ((values[va
luesOffset++] & 0xffffffffL) << 60) | ((values[valuesOffset++] & 0xffffffffL) << 61) | ((values[valuesOffset++] & 0xffffffffL) << 62) | ((values[valuesOffset++] & 0xffffffffL) << 63);
- }
- }
-
- @Override
- public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = values[valuesOffset++] | (values[valuesOffset++] << 1) | (values[valuesOffset++] << 2) | (values[valuesOffset++] << 3) | (values[valuesOffset++] << 4) | (values[valuesOffset++] << 5) | (values[valuesOffset++] << 6) | (values[valuesOffset++] << 7) | (values[valuesOffset++] << 8) | (values[valuesOffset++] << 9) | (values[valuesOffset++] << 10) | (values[valuesOffset++] << 11) | (values[valuesOffset++] << 12) | (values[valuesOffset++] << 13) | (values[valuesOffset++] << 14) | (values[valuesOffset++] << 15) | (values[valuesOffset++] << 16) | (values[valuesOffset++] << 17) | (values[valuesOffset++] << 18) | (values[valuesOffset++] << 19) | (values[valuesOffset++] << 20) | (values[valuesOffset++] << 21) | (values[valuesOffset++] << 22) | (values[valuesOffset++] << 23) | (values[valuesOffset++] << 24) | (values[valuesOffset++] << 25) | (values[valuesOffset++] << 26) | (values[valuesOffset++] << 27) | (values[valuesOffset++] << 28) | (values[valuesOf
fset++] << 29) | (values[valuesOffset++] << 30) | (values[valuesOffset++] << 31) | (values[valuesOffset++] << 32) | (values[valuesOffset++] << 33) | (values[valuesOffset++] << 34) | (values[valuesOffset++] << 35) | (values[valuesOffset++] << 36) | (values[valuesOffset++] << 37) | (values[valuesOffset++] << 38) | (values[valuesOffset++] << 39) | (values[valuesOffset++] << 40) | (values[valuesOffset++] << 41) | (values[valuesOffset++] << 42) | (values[valuesOffset++] << 43) | (values[valuesOffset++] << 44) | (values[valuesOffset++] << 45) | (values[valuesOffset++] << 46) | (values[valuesOffset++] << 47) | (values[valuesOffset++] << 48) | (values[valuesOffset++] << 49) | (values[valuesOffset++] << 50) | (values[valuesOffset++] << 51) | (values[valuesOffset++] << 52) | (values[valuesOffset++] << 53) | (values[valuesOffset++] << 54) | (values[valuesOffset++] << 55) | (values[valuesOffset++] << 56) | (values[valuesOffset++] << 57) | (values[valuesOffset++] << 58) | (values[valuesO
ffset++] << 59) | (values[valuesOffset++] << 60) | (values[valuesOffset++] << 61) | (values[valuesOffset++] << 62) | (values[valuesOffset++] << 63);
- }
- }
-
}
Modified: lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock10.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock10.java?rev=1379200&r1=1379199&r2=1379200&view=diff
==============================================================================
--- lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock10.java (original)
+++ lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock10.java Thu Aug 30 22:43:41 2012
@@ -22,15 +22,10 @@ package org.apache.lucene.util.packed;
/**
* Efficient sequential read/write of packed integers.
*/
-final class BulkOperationPackedSingleBlock10 extends BulkOperation {
- @Override
- public int blockCount() {
- return 1;
- }
+final class BulkOperationPackedSingleBlock10 extends BulkOperationPackedSingleBlock {
- @Override
- public int valueCount() {
- return 6;
+ public BulkOperationPackedSingleBlock10() {
+ super(10);
}
@Override
@@ -107,22 +102,4 @@ final class BulkOperationPackedSingleBlo
}
}
- @Override
- public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = (values[valuesOffset++] & 0xffffffffL) | ((values[valuesOffset++] & 0xffffffffL) << 10) | ((values[valuesOffset++] & 0xffffffffL) << 20) | ((values[valuesOffset++] & 0xffffffffL) << 30) | ((values[valuesOffset++] & 0xffffffffL) << 40) | ((values[valuesOffset++] & 0xffffffffL) << 50);
- }
- }
-
- @Override
- public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = values[valuesOffset++] | (values[valuesOffset++] << 10) | (values[valuesOffset++] << 20) | (values[valuesOffset++] << 30) | (values[valuesOffset++] << 40) | (values[valuesOffset++] << 50);
- }
- }
-
}
Modified: lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock12.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock12.java?rev=1379200&r1=1379199&r2=1379200&view=diff
==============================================================================
--- lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock12.java (original)
+++ lucene/dev/branches/lucene3312/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock12.java Thu Aug 30 22:43:41 2012
@@ -22,15 +22,10 @@ package org.apache.lucene.util.packed;
/**
* Efficient sequential read/write of packed integers.
*/
-final class BulkOperationPackedSingleBlock12 extends BulkOperation {
- @Override
- public int blockCount() {
- return 1;
- }
+final class BulkOperationPackedSingleBlock12 extends BulkOperationPackedSingleBlock {
- @Override
- public int valueCount() {
- return 5;
+ public BulkOperationPackedSingleBlock12() {
+ super(12);
}
@Override
@@ -103,22 +98,4 @@ final class BulkOperationPackedSingleBlo
}
}
- @Override
- public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = (values[valuesOffset++] & 0xffffffffL) | ((values[valuesOffset++] & 0xffffffffL) << 12) | ((values[valuesOffset++] & 0xffffffffL) << 24) | ((values[valuesOffset++] & 0xffffffffL) << 36) | ((values[valuesOffset++] & 0xffffffffL) << 48);
- }
- }
-
- @Override
- public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
- assert blocksOffset + iterations * blockCount() <= blocks.length;
- assert valuesOffset + iterations * valueCount() <= values.length;
- for (int i = 0; i < iterations; ++i) {
- blocks[blocksOffset++] = values[valuesOffset++] | (values[valuesOffset++] << 12) | (values[valuesOffset++] << 24) | (values[valuesOffset++] << 36) | (values[valuesOffset++] << 48);
- }
- }
-
}