Apache
/
lucene
mirror of https://github.com/apache/lucene.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add missing @Override 

git-svn-id: https://svn.apache.org/repos/asf/lucene/dev/trunk@1376625 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Uwe Schindler 2012-08-23 18:11:16 +00:00
parent 1ee80d804e
commit 6fa4f99658
79 changed files with 635 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked1.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked1 extends BulkOperation {
@Override
public int blockCount() {
return 1;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -103,6 +106,7 @@ final class BulkOperationPacked1 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -182,6 +186,7 @@ final class BulkOperationPacked1 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -254,6 +259,7 @@ final class BulkOperationPacked1 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -333,6 +339,7 @@ final class BulkOperationPacked1 extends BulkOperation {
}
}
@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;
@ -341,6 +348,7 @@ final class BulkOperationPacked1 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked10.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked10 extends BulkOperation {
@Override
public int blockCount() {
return 5;
}
@Override
public int valueCount() {
return 32;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -75,6 +78,7 @@ final class BulkOperationPacked10 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -154,6 +158,7 @@ final class BulkOperationPacked10 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -198,6 +203,7 @@ final class BulkOperationPacked10 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -277,6 +283,7 @@ final class BulkOperationPacked10 extends BulkOperation {
}
}
@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;
@ -289,6 +296,7 @@ final class BulkOperationPacked10 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked11.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked11 extends BulkOperation {
@Override
public int blockCount() {
return 11;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -113,6 +116,7 @@ final class BulkOperationPacked11 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -272,6 +276,7 @@ final class BulkOperationPacked11 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -354,6 +359,7 @@ final class BulkOperationPacked11 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -513,6 +519,7 @@ final class BulkOperationPacked11 extends BulkOperation {
}
}
@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;
@ -531,6 +538,7 @@ final class BulkOperationPacked11 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked12.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked12 extends BulkOperation {
@Override
public int blockCount() {
return 3;
}
@Override
public int valueCount() {
return 16;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -57,6 +60,7 @@ final class BulkOperationPacked12 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -104,6 +108,7 @@ final class BulkOperationPacked12 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -130,6 +135,7 @@ final class BulkOperationPacked12 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -177,6 +183,7 @@ final class BulkOperationPacked12 extends BulkOperation {
}
}
@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;
@ -187,6 +194,7 @@ final class BulkOperationPacked12 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked13.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked13 extends BulkOperation {
@Override
public int blockCount() {
return 13;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -115,6 +118,7 @@ final class BulkOperationPacked13 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -290,6 +294,7 @@ final class BulkOperationPacked13 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -374,6 +379,7 @@ final class BulkOperationPacked13 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -549,6 +555,7 @@ final class BulkOperationPacked13 extends BulkOperation {
}
}
@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;
@ -569,6 +576,7 @@ final class BulkOperationPacked13 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked14.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked14 extends BulkOperation {
@Override
public int blockCount() {
return 7;
}
@Override
public int valueCount() {
return 32;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -77,6 +80,7 @@ final class BulkOperationPacked14 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -172,6 +176,7 @@ final class BulkOperationPacked14 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -218,6 +223,7 @@ final class BulkOperationPacked14 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -313,6 +319,7 @@ final class BulkOperationPacked14 extends BulkOperation {
}
}
@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;
@ -327,6 +334,7 @@ final class BulkOperationPacked14 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked15.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked15 extends BulkOperation {
@Override
public int blockCount() {
return 15;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -117,6 +120,7 @@ final class BulkOperationPacked15 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -308,6 +312,7 @@ final class BulkOperationPacked15 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -394,6 +399,7 @@ final class BulkOperationPacked15 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -585,6 +591,7 @@ final class BulkOperationPacked15 extends BulkOperation {
}
}
@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;
@ -607,6 +614,7 @@ final class BulkOperationPacked15 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked16.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked16 extends BulkOperation {
@Override
public int blockCount() {
return 1;
}
@Override
public int valueCount() {
return 4;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -43,6 +46,7 @@ final class BulkOperationPacked16 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -62,6 +66,7 @@ final class BulkOperationPacked16 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -74,6 +79,7 @@ final class BulkOperationPacked16 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -93,6 +99,7 @@ final class BulkOperationPacked16 extends BulkOperation {
}
}
@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;
@ -101,6 +108,7 @@ final class BulkOperationPacked16 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked17.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked17 extends BulkOperation {
@Override
public int blockCount() {
return 17;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -119,6 +122,7 @@ final class BulkOperationPacked17 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -326,6 +330,7 @@ final class BulkOperationPacked17 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -414,6 +419,7 @@ final class BulkOperationPacked17 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -621,6 +627,7 @@ final class BulkOperationPacked17 extends BulkOperation {
}
}
@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;
@ -645,6 +652,7 @@ final class BulkOperationPacked17 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked18.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked18 extends BulkOperation {
@Override
public int blockCount() {
return 9;
}
@Override
public int valueCount() {
return 32;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -79,6 +82,7 @@ final class BulkOperationPacked18 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -190,6 +194,7 @@ final class BulkOperationPacked18 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -238,6 +243,7 @@ final class BulkOperationPacked18 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -349,6 +355,7 @@ final class BulkOperationPacked18 extends BulkOperation {
}
}
@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;
@ -365,6 +372,7 @@ final class BulkOperationPacked18 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked19.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked19 extends BulkOperation {
@Override
public int blockCount() {
return 19;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -121,6 +124,7 @@ final class BulkOperationPacked19 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -344,6 +348,7 @@ final class BulkOperationPacked19 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -434,6 +439,7 @@ final class BulkOperationPacked19 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -657,6 +663,7 @@ final class BulkOperationPacked19 extends BulkOperation {
}
}
@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;
@ -683,6 +690,7 @@ final class BulkOperationPacked19 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked2.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked2 extends BulkOperation {
@Override
public int blockCount() {
return 1;
}
@Override
public int valueCount() {
return 32;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -71,6 +74,7 @@ final class BulkOperationPacked2 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -118,6 +122,7 @@ final class BulkOperationPacked2 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -158,6 +163,7 @@ final class BulkOperationPacked2 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -205,6 +211,7 @@ final class BulkOperationPacked2 extends BulkOperation {
}
}
@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;
@ -213,6 +220,7 @@ final class BulkOperationPacked2 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked20.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked20 extends BulkOperation {
@Override
public int blockCount() {
return 5;
}
@Override
public int valueCount() {
return 16;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -59,6 +62,7 @@ final class BulkOperationPacked20 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -122,6 +126,7 @@ final class BulkOperationPacked20 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -150,6 +155,7 @@ final class BulkOperationPacked20 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -213,6 +219,7 @@ final class BulkOperationPacked20 extends BulkOperation {
}
}
@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;
@ -225,6 +232,7 @@ final class BulkOperationPacked20 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked21.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked21 extends BulkOperation {
@Override
public int blockCount() {
return 21;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -123,6 +126,7 @@ final class BulkOperationPacked21 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -362,6 +366,7 @@ final class BulkOperationPacked21 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -454,6 +459,7 @@ final class BulkOperationPacked21 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -693,6 +699,7 @@ final class BulkOperationPacked21 extends BulkOperation {
}
}
@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;
@ -721,6 +728,7 @@ final class BulkOperationPacked21 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked22.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked22 extends BulkOperation {
@Override
public int blockCount() {
return 11;
}
@Override
public int valueCount() {
return 32;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -81,6 +84,7 @@ final class BulkOperationPacked22 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -208,6 +212,7 @@ final class BulkOperationPacked22 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -258,6 +263,7 @@ final class BulkOperationPacked22 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -385,6 +391,7 @@ final class BulkOperationPacked22 extends BulkOperation {
}
}
@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;
@ -403,6 +410,7 @@ final class BulkOperationPacked22 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked23.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked23 extends BulkOperation {
@Override
public int blockCount() {
return 23;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -125,6 +128,7 @@ final class BulkOperationPacked23 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -380,6 +384,7 @@ final class BulkOperationPacked23 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -474,6 +479,7 @@ final class BulkOperationPacked23 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -729,6 +735,7 @@ final class BulkOperationPacked23 extends BulkOperation {
}
}
@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;
@ -759,6 +766,7 @@ final class BulkOperationPacked23 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked24.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked24 extends BulkOperation {
@Override
public int blockCount() {
return 3;
}
@Override
public int valueCount() {
return 8;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -49,6 +52,7 @@ final class BulkOperationPacked24 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -88,6 +92,7 @@ final class BulkOperationPacked24 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -106,6 +111,7 @@ final class BulkOperationPacked24 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -145,6 +151,7 @@ final class BulkOperationPacked24 extends BulkOperation {
}
}
@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;
@ -155,6 +162,7 @@ final class BulkOperationPacked24 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked25.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked25 extends BulkOperation {
@Override
public int blockCount() {
return 25;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -127,6 +130,7 @@ final class BulkOperationPacked25 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -398,6 +402,7 @@ final class BulkOperationPacked25 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -494,6 +499,7 @@ final class BulkOperationPacked25 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -765,6 +771,7 @@ final class BulkOperationPacked25 extends BulkOperation {
}
}
@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;
@ -797,6 +804,7 @@ final class BulkOperationPacked25 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked26.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked26 extends BulkOperation {
@Override
public int blockCount() {
return 13;
}
@Override
public int valueCount() {
return 32;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -83,6 +86,7 @@ final class BulkOperationPacked26 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -226,6 +230,7 @@ final class BulkOperationPacked26 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -278,6 +283,7 @@ final class BulkOperationPacked26 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -421,6 +427,7 @@ final class BulkOperationPacked26 extends BulkOperation {
}
}
@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;
@ -441,6 +448,7 @@ final class BulkOperationPacked26 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked27.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked27 extends BulkOperation {
@Override
public int blockCount() {
return 27;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -129,6 +132,7 @@ final class BulkOperationPacked27 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -416,6 +420,7 @@ final class BulkOperationPacked27 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -514,6 +519,7 @@ final class BulkOperationPacked27 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -801,6 +807,7 @@ final class BulkOperationPacked27 extends BulkOperation {
}
}
@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;
@ -835,6 +842,7 @@ final class BulkOperationPacked27 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked28.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked28 extends BulkOperation {
@Override
public int blockCount() {
return 7;
}
@Override
public int valueCount() {
return 16;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -61,6 +64,7 @@ final class BulkOperationPacked28 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -140,6 +144,7 @@ final class BulkOperationPacked28 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -170,6 +175,7 @@ final class BulkOperationPacked28 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -249,6 +255,7 @@ final class BulkOperationPacked28 extends BulkOperation {
}
}
@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;
@ -263,6 +270,7 @@ final class BulkOperationPacked28 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked29.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked29 extends BulkOperation {
@Override
public int blockCount() {
return 29;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -131,6 +134,7 @@ final class BulkOperationPacked29 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -434,6 +438,7 @@ final class BulkOperationPacked29 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -534,6 +539,7 @@ final class BulkOperationPacked29 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -837,6 +843,7 @@ final class BulkOperationPacked29 extends BulkOperation {
}
}
@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;
@ -873,6 +880,7 @@ final class BulkOperationPacked29 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked3.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked3 extends BulkOperation {
@Override
public int blockCount() {
return 3;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -105,6 +108,7 @@ final class BulkOperationPacked3 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -200,6 +204,7 @@ final class BulkOperationPacked3 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -274,6 +279,7 @@ final class BulkOperationPacked3 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -369,6 +375,7 @@ final class BulkOperationPacked3 extends BulkOperation {
}
}
@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;
@ -379,6 +386,7 @@ final class BulkOperationPacked3 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked30.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked30 extends BulkOperation {
@Override
public int blockCount() {
return 15;
}
@Override
public int valueCount() {
return 32;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -85,6 +88,7 @@ final class BulkOperationPacked30 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -244,6 +248,7 @@ final class BulkOperationPacked30 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -298,6 +303,7 @@ final class BulkOperationPacked30 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -457,6 +463,7 @@ final class BulkOperationPacked30 extends BulkOperation {
}
}
@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;
@ -479,6 +486,7 @@ final class BulkOperationPacked30 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked31.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked31 extends BulkOperation {
@Override
public int blockCount() {
return 31;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -133,6 +136,7 @@ final class BulkOperationPacked31 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -452,6 +456,7 @@ final class BulkOperationPacked31 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -554,6 +559,7 @@ final class BulkOperationPacked31 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -873,6 +879,7 @@ final class BulkOperationPacked31 extends BulkOperation {
}
}
@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;
@ -911,6 +918,7 @@ final class BulkOperationPacked31 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked32.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked32 extends BulkOperation {
@Override
public int blockCount() {
return 1;
}
@Override
public int valueCount() {
return 2;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -41,6 +44,7 @@ final class BulkOperationPacked32 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -58,6 +62,7 @@ final class BulkOperationPacked32 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -68,6 +73,7 @@ final class BulkOperationPacked32 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -85,6 +91,7 @@ final class BulkOperationPacked32 extends BulkOperation {
}
}
@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;
@ -93,6 +100,7 @@ final class BulkOperationPacked32 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked33.java
View File

@ -23,22 +23,27 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked33 extends BulkOperation {
@Override
public int blockCount() {
return 33;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -143,6 +148,7 @@ final class BulkOperationPacked33 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -478,6 +484,7 @@ final class BulkOperationPacked33 extends BulkOperation {
}
}
@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;
@ -518,6 +525,7 @@ final class BulkOperationPacked33 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked34.java
View File

@ -23,22 +23,27 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked34 extends BulkOperation {
@Override
public int blockCount() {
return 17;
}
@Override
public int valueCount() {
return 32;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -95,6 +100,7 @@ final class BulkOperationPacked34 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -270,6 +276,7 @@ final class BulkOperationPacked34 extends BulkOperation {
}
}
@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;
@ -294,6 +301,7 @@ final class BulkOperationPacked34 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked35.java
View File

@ -23,22 +23,27 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked35 extends BulkOperation {
@Override
public int blockCount() {
return 35;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -145,6 +150,7 @@ final class BulkOperationPacked35 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -496,6 +502,7 @@ final class BulkOperationPacked35 extends BulkOperation {
}
}
@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;
@ -538,6 +545,7 @@ final class BulkOperationPacked35 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked36.java
View File

@ -23,22 +23,27 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked36 extends BulkOperation {
@Override
public int blockCount() {
return 9;
}
@Override
public int valueCount() {
return 16;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -71,6 +76,7 @@ final class BulkOperationPacked36 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -166,6 +172,7 @@ final class BulkOperationPacked36 extends BulkOperation {
}
}
@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;
@ -182,6 +189,7 @@ final class BulkOperationPacked36 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked37.java
View File

@ -23,22 +23,27 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked37 extends BulkOperation {
@Override
public int blockCount() {
return 37;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -147,6 +152,7 @@ final class BulkOperationPacked37 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -514,6 +520,7 @@ final class BulkOperationPacked37 extends BulkOperation {
}
}
@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;
@ -558,6 +565,7 @@ final class BulkOperationPacked37 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked38.java
View File

@ -23,22 +23,27 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked38 extends BulkOperation {
@Override
public int blockCount() {
return 19;
}
@Override
public int valueCount() {
return 32;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -97,6 +102,7 @@ final class BulkOperationPacked38 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -288,6 +294,7 @@ final class BulkOperationPacked38 extends BulkOperation {
}
}
@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;
@ -314,6 +321,7 @@ final class BulkOperationPacked38 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked39.java
View File

@ -23,22 +23,27 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked39 extends BulkOperation {
@Override
public int blockCount() {
return 39;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -149,6 +154,7 @@ final class BulkOperationPacked39 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -532,6 +538,7 @@ final class BulkOperationPacked39 extends BulkOperation {
}
}
@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;
@ -578,6 +585,7 @@ final class BulkOperationPacked39 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked4.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked4 extends BulkOperation {
@Override
public int blockCount() {
return 1;
}
@Override
public int valueCount() {
return 16;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -55,6 +58,7 @@ final class BulkOperationPacked4 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -86,6 +90,7 @@ final class BulkOperationPacked4 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -110,6 +115,7 @@ final class BulkOperationPacked4 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -141,6 +147,7 @@ final class BulkOperationPacked4 extends BulkOperation {
}
}
@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;
@ -149,6 +156,7 @@ final class BulkOperationPacked4 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked40.java
View File

@ -23,22 +23,27 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked40 extends BulkOperation {
@Override
public int blockCount() {
return 5;
}
@Override
public int valueCount() {
return 8;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -59,6 +64,7 @@ final class BulkOperationPacked40 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -114,6 +120,7 @@ final class BulkOperationPacked40 extends BulkOperation {
}
}
@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;
@ -126,6 +133,7 @@ final class BulkOperationPacked40 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked41.java
View File

@ -23,22 +23,27 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked41 extends BulkOperation {
@Override
public int blockCount() {
return 41;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -151,6 +156,7 @@ final class BulkOperationPacked41 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -550,6 +556,7 @@ final class BulkOperationPacked41 extends BulkOperation {
}
}
@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;
@ -598,6 +605,7 @@ final class BulkOperationPacked41 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked42.java
View File

@ -23,22 +23,27 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked42 extends BulkOperation {
@Override
public int blockCount() {
return 21;
}
@Override
public int valueCount() {
return 32;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -99,6 +104,7 @@ final class BulkOperationPacked42 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -306,6 +312,7 @@ final class BulkOperationPacked42 extends BulkOperation {
}
}
@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;
@ -334,6 +341,7 @@ final class BulkOperationPacked42 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked43.java
View File

@ -23,22 +23,27 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked43 extends BulkOperation {
@Override
public int blockCount() {
return 43;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -153,6 +158,7 @@ final class BulkOperationPacked43 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -568,6 +574,7 @@ final class BulkOperationPacked43 extends BulkOperation {
}
}
@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;
@ -618,6 +625,7 @@ final class BulkOperationPacked43 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked44.java
View File

@ -23,22 +23,27 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked44 extends BulkOperation {
@Override
public int blockCount() {
return 11;
}
@Override
public int valueCount() {
return 16;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -73,6 +78,7 @@ final class BulkOperationPacked44 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -184,6 +190,7 @@ final class BulkOperationPacked44 extends BulkOperation {
}
}
@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;
@ -202,6 +209,7 @@ final class BulkOperationPacked44 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked45.java
View File

@ -23,22 +23,27 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked45 extends BulkOperation {
@Override
public int blockCount() {
return 45;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -155,6 +160,7 @@ final class BulkOperationPacked45 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -586,6 +592,7 @@ final class BulkOperationPacked45 extends BulkOperation {
}
}
@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;
@ -638,6 +645,7 @@ final class BulkOperationPacked45 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked46.java
View File

@ -23,22 +23,27 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked46 extends BulkOperation {
@Override
public int blockCount() {
return 23;
}
@Override
public int valueCount() {
return 32;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -101,6 +106,7 @@ final class BulkOperationPacked46 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -324,6 +330,7 @@ final class BulkOperationPacked46 extends BulkOperation {
}
}
@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;
@ -354,6 +361,7 @@ final class BulkOperationPacked46 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked47.java
View File

@ -23,22 +23,27 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked47 extends BulkOperation {
@Override
public int blockCount() {
return 47;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -157,6 +162,7 @@ final class BulkOperationPacked47 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -604,6 +610,7 @@ final class BulkOperationPacked47 extends BulkOperation {
}
}
@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;
@ -658,6 +665,7 @@ final class BulkOperationPacked47 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked48.java
View File

@ -23,22 +23,27 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked48 extends BulkOperation {
@Override
public int blockCount() {
return 3;
}
@Override
public int valueCount() {
return 4;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -53,6 +58,7 @@ final class BulkOperationPacked48 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -88,6 +94,7 @@ final class BulkOperationPacked48 extends BulkOperation {
}
}
@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;
@ -98,6 +105,7 @@ final class BulkOperationPacked48 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked49.java
View File

@ -23,22 +23,27 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked49 extends BulkOperation {
@Override
public int blockCount() {
return 49;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -159,6 +164,7 @@ final class BulkOperationPacked49 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -622,6 +628,7 @@ final class BulkOperationPacked49 extends BulkOperation {
}
}
@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;
@ -678,6 +685,7 @@ final class BulkOperationPacked49 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked5.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked5 extends BulkOperation {
@Override
public int blockCount() {
return 5;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -107,6 +110,7 @@ final class BulkOperationPacked5 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -218,6 +222,7 @@ final class BulkOperationPacked5 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -294,6 +299,7 @@ final class BulkOperationPacked5 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -405,6 +411,7 @@ final class BulkOperationPacked5 extends BulkOperation {
}
}
@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;
@ -417,6 +424,7 @@ final class BulkOperationPacked5 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked50.java
View File

@ -23,22 +23,27 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked50 extends BulkOperation {
@Override
public int blockCount() {
return 25;
}
@Override
public int valueCount() {
return 32;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -103,6 +108,7 @@ final class BulkOperationPacked50 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -342,6 +348,7 @@ final class BulkOperationPacked50 extends BulkOperation {
}
}
@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;
@ -374,6 +381,7 @@ final class BulkOperationPacked50 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked51.java
View File

@ -23,22 +23,27 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked51 extends BulkOperation {
@Override
public int blockCount() {
return 51;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -161,6 +166,7 @@ final class BulkOperationPacked51 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -640,6 +646,7 @@ final class BulkOperationPacked51 extends BulkOperation {
}
}
@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;
@ -698,6 +705,7 @@ final class BulkOperationPacked51 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked52.java
View File

@ -23,22 +23,27 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked52 extends BulkOperation {
@Override
public int blockCount() {
return 13;
}
@Override
public int valueCount() {
return 16;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -75,6 +80,7 @@ final class BulkOperationPacked52 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -202,6 +208,7 @@ final class BulkOperationPacked52 extends BulkOperation {
}
}
@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;
@ -222,6 +229,7 @@ final class BulkOperationPacked52 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked53.java
View File

@ -23,22 +23,27 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked53 extends BulkOperation {
@Override
public int blockCount() {
return 53;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -163,6 +168,7 @@ final class BulkOperationPacked53 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -658,6 +664,7 @@ final class BulkOperationPacked53 extends BulkOperation {
}
}
@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;
@ -718,6 +725,7 @@ final class BulkOperationPacked53 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked54.java
View File

@ -23,22 +23,27 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked54 extends BulkOperation {
@Override
public int blockCount() {
return 27;
}
@Override
public int valueCount() {
return 32;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -105,6 +110,7 @@ final class BulkOperationPacked54 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -360,6 +366,7 @@ final class BulkOperationPacked54 extends BulkOperation {
}
}
@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;
@ -394,6 +401,7 @@ final class BulkOperationPacked54 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked55.java
View File

@ -23,22 +23,27 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked55 extends BulkOperation {
@Override
public int blockCount() {
return 55;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -165,6 +170,7 @@ final class BulkOperationPacked55 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -676,6 +682,7 @@ final class BulkOperationPacked55 extends BulkOperation {
}
}
@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;
@ -738,6 +745,7 @@ final class BulkOperationPacked55 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked56.java
View File

@ -23,22 +23,27 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked56 extends BulkOperation {
@Override
public int blockCount() {
return 7;
}
@Override
public int valueCount() {
return 8;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -61,6 +66,7 @@ final class BulkOperationPacked56 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -132,6 +138,7 @@ final class BulkOperationPacked56 extends BulkOperation {
}
}
@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;
@ -146,6 +153,7 @@ final class BulkOperationPacked56 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked57.java
View File

@ -23,22 +23,27 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked57 extends BulkOperation {
@Override
public int blockCount() {
return 57;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -167,6 +172,7 @@ final class BulkOperationPacked57 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -694,6 +700,7 @@ final class BulkOperationPacked57 extends BulkOperation {
}
}
@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;
@ -758,6 +765,7 @@ final class BulkOperationPacked57 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked58.java
View File

@ -23,22 +23,27 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked58 extends BulkOperation {
@Override
public int blockCount() {
return 29;
}
@Override
public int valueCount() {
return 32;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -107,6 +112,7 @@ final class BulkOperationPacked58 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -378,6 +384,7 @@ final class BulkOperationPacked58 extends BulkOperation {
}
}
@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;
@ -414,6 +421,7 @@ final class BulkOperationPacked58 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked59.java
View File

@ -23,22 +23,27 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked59 extends BulkOperation {
@Override
public int blockCount() {
return 59;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -169,6 +174,7 @@ final class BulkOperationPacked59 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -712,6 +718,7 @@ final class BulkOperationPacked59 extends BulkOperation {
}
}
@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;
@ -778,6 +785,7 @@ final class BulkOperationPacked59 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked6.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked6 extends BulkOperation {
@Override
public int blockCount() {
return 3;
}
@Override
public int valueCount() {
return 32;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -73,6 +76,7 @@ final class BulkOperationPacked6 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -136,6 +140,7 @@ final class BulkOperationPacked6 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -178,6 +183,7 @@ final class BulkOperationPacked6 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -241,6 +247,7 @@ final class BulkOperationPacked6 extends BulkOperation {
}
}
@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;
@ -251,6 +258,7 @@ final class BulkOperationPacked6 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked60.java
View File

@ -23,22 +23,27 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked60 extends BulkOperation {
@Override
public int blockCount() {
return 15;
}
@Override
public int valueCount() {
return 16;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -77,6 +82,7 @@ final class BulkOperationPacked60 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -220,6 +226,7 @@ final class BulkOperationPacked60 extends BulkOperation {
}
}
@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;
@ -242,6 +249,7 @@ final class BulkOperationPacked60 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked61.java
View File

@ -23,22 +23,27 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked61 extends BulkOperation {
@Override
public int blockCount() {
return 61;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -171,6 +176,7 @@ final class BulkOperationPacked61 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -730,6 +736,7 @@ final class BulkOperationPacked61 extends BulkOperation {
}
}
@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;
@ -798,6 +805,7 @@ final class BulkOperationPacked61 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked62.java
View File

@ -23,22 +23,27 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked62 extends BulkOperation {
@Override
public int blockCount() {
return 31;
}
@Override
public int valueCount() {
return 32;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -109,6 +114,7 @@ final class BulkOperationPacked62 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -396,6 +402,7 @@ final class BulkOperationPacked62 extends BulkOperation {
}
}
@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;
@ -434,6 +441,7 @@ final class BulkOperationPacked62 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked63.java
View File

@ -23,22 +23,27 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked63 extends BulkOperation {
@Override
public int blockCount() {
return 63;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
throw new UnsupportedOperationException();
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -173,6 +178,7 @@ final class BulkOperationPacked63 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -748,6 +754,7 @@ final class BulkOperationPacked63 extends BulkOperation {
}
}
@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;
@ -818,6 +825,7 @@ final class BulkOperationPacked63 extends BulkOperation {
}
}
@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;

5
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked64.java
View File

@ -26,14 +26,17 @@ import java.nio.ByteBuffer;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked64 extends BulkOperation {
@Override
public int blockCount() {
return 1;
}
@Override
public int valueCount() {
return 1;
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
System.arraycopy(blocks, blocksOffset, values, valuesOffset, valueCount() * iterations);
}
@ -48,10 +51,12 @@ final class BulkOperationPacked64 extends BulkOperation {
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
LongBuffer.wrap(values, valuesOffset, iterations * valueCount()).put(ByteBuffer.wrap(blocks, blocksOffset, 8 * iterations * blockCount()).asLongBuffer());
}
@Override
public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
System.arraycopy(values, valuesOffset, blocks, blocksOffset, valueCount() * iterations);
}

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked7.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked7 extends BulkOperation {
@Override
public int blockCount() {
return 7;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -109,6 +112,7 @@ final class BulkOperationPacked7 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -236,6 +240,7 @@ final class BulkOperationPacked7 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -314,6 +319,7 @@ final class BulkOperationPacked7 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -441,6 +447,7 @@ final class BulkOperationPacked7 extends BulkOperation {
}
}
@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;
@ -455,6 +462,7 @@ final class BulkOperationPacked7 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked8.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked8 extends BulkOperation {
@Override
public int blockCount() {
return 1;
}
@Override
public int valueCount() {
return 8;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -47,6 +50,7 @@ final class BulkOperationPacked8 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -70,6 +74,7 @@ final class BulkOperationPacked8 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -86,6 +91,7 @@ final class BulkOperationPacked8 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -109,6 +115,7 @@ final class BulkOperationPacked8 extends BulkOperation {
}
}
@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;
@ -117,6 +124,7 @@ final class BulkOperationPacked8 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked9.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPacked9 extends BulkOperation {
@Override
public int blockCount() {
return 9;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -111,6 +114,7 @@ final class BulkOperationPacked9 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -254,6 +258,7 @@ final class BulkOperationPacked9 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -334,6 +339,7 @@ final class BulkOperationPacked9 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -477,6 +483,7 @@ final class BulkOperationPacked9 extends BulkOperation {
}
}
@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;
@ -493,6 +500,7 @@ final class BulkOperationPacked9 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock1.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPackedSingleBlock1 extends BulkOperation {
@Override
public int blockCount() {
return 1;
}
@Override
public int valueCount() {
return 64;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -103,6 +106,7 @@ final class BulkOperationPackedSingleBlock1 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -182,6 +186,7 @@ final class BulkOperationPackedSingleBlock1 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -254,6 +259,7 @@ final class BulkOperationPackedSingleBlock1 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -333,6 +339,7 @@ final class BulkOperationPackedSingleBlock1 extends BulkOperation {
}
}
@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;
@ -341,6 +348,7 @@ final class BulkOperationPackedSingleBlock1 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock10.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPackedSingleBlock10 extends BulkOperation {
@Override
public int blockCount() {
return 1;
}
@Override
public int valueCount() {
return 6;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -45,6 +48,7 @@ final class BulkOperationPackedSingleBlock10 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -66,6 +70,7 @@ final class BulkOperationPackedSingleBlock10 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -80,6 +85,7 @@ final class BulkOperationPackedSingleBlock10 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -101,6 +107,7 @@ final class BulkOperationPackedSingleBlock10 extends BulkOperation {
}
}
@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;
@ -109,6 +116,7 @@ final class BulkOperationPackedSingleBlock10 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock12.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPackedSingleBlock12 extends BulkOperation {
@Override
public int blockCount() {
return 1;
}
@Override
public int valueCount() {
return 5;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -44,6 +47,7 @@ final class BulkOperationPackedSingleBlock12 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -64,6 +68,7 @@ final class BulkOperationPackedSingleBlock12 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -77,6 +82,7 @@ final class BulkOperationPackedSingleBlock12 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -97,6 +103,7 @@ final class BulkOperationPackedSingleBlock12 extends BulkOperation {
}
}
@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;
@ -105,6 +112,7 @@ final class BulkOperationPackedSingleBlock12 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock16.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPackedSingleBlock16 extends BulkOperation {
@Override
public int blockCount() {
return 1;
}
@Override
public int valueCount() {
return 4;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -43,6 +46,7 @@ final class BulkOperationPackedSingleBlock16 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -62,6 +66,7 @@ final class BulkOperationPackedSingleBlock16 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -74,6 +79,7 @@ final class BulkOperationPackedSingleBlock16 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -93,6 +99,7 @@ final class BulkOperationPackedSingleBlock16 extends BulkOperation {
}
}
@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;
@ -101,6 +108,7 @@ final class BulkOperationPackedSingleBlock16 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock2.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPackedSingleBlock2 extends BulkOperation {
@Override
public int blockCount() {
return 1;
}
@Override
public int valueCount() {
return 32;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -71,6 +74,7 @@ final class BulkOperationPackedSingleBlock2 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -118,6 +122,7 @@ final class BulkOperationPackedSingleBlock2 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -158,6 +163,7 @@ final class BulkOperationPackedSingleBlock2 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -205,6 +211,7 @@ final class BulkOperationPackedSingleBlock2 extends BulkOperation {
}
}
@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;
@ -213,6 +220,7 @@ final class BulkOperationPackedSingleBlock2 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock21.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPackedSingleBlock21 extends BulkOperation {
@Override
public int blockCount() {
return 1;
}
@Override
public int valueCount() {
return 3;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -42,6 +45,7 @@ final class BulkOperationPackedSingleBlock21 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -60,6 +64,7 @@ final class BulkOperationPackedSingleBlock21 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -71,6 +76,7 @@ final class BulkOperationPackedSingleBlock21 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -89,6 +95,7 @@ final class BulkOperationPackedSingleBlock21 extends BulkOperation {
}
}
@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;
@ -97,6 +104,7 @@ final class BulkOperationPackedSingleBlock21 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock3.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPackedSingleBlock3 extends BulkOperation {
@Override
public int blockCount() {
return 1;
}
@Override
public int valueCount() {
return 21;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -60,6 +63,7 @@ final class BulkOperationPackedSingleBlock3 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -96,6 +100,7 @@ final class BulkOperationPackedSingleBlock3 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -125,6 +130,7 @@ final class BulkOperationPackedSingleBlock3 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -161,6 +167,7 @@ final class BulkOperationPackedSingleBlock3 extends BulkOperation {
}
}
@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;
@ -169,6 +176,7 @@ final class BulkOperationPackedSingleBlock3 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock32.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPackedSingleBlock32 extends BulkOperation {
@Override
public int blockCount() {
return 1;
}
@Override
public int valueCount() {
return 2;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -41,6 +44,7 @@ final class BulkOperationPackedSingleBlock32 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -58,6 +62,7 @@ final class BulkOperationPackedSingleBlock32 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -68,6 +73,7 @@ final class BulkOperationPackedSingleBlock32 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -85,6 +91,7 @@ final class BulkOperationPackedSingleBlock32 extends BulkOperation {
}
}
@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;
@ -93,6 +100,7 @@ final class BulkOperationPackedSingleBlock32 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock4.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPackedSingleBlock4 extends BulkOperation {
@Override
public int blockCount() {
return 1;
}
@Override
public int valueCount() {
return 16;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -55,6 +58,7 @@ final class BulkOperationPackedSingleBlock4 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -86,6 +90,7 @@ final class BulkOperationPackedSingleBlock4 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -110,6 +115,7 @@ final class BulkOperationPackedSingleBlock4 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -141,6 +147,7 @@ final class BulkOperationPackedSingleBlock4 extends BulkOperation {
}
}
@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;
@ -149,6 +156,7 @@ final class BulkOperationPackedSingleBlock4 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock5.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPackedSingleBlock5 extends BulkOperation {
@Override
public int blockCount() {
return 1;
}
@Override
public int valueCount() {
return 12;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -51,6 +54,7 @@ final class BulkOperationPackedSingleBlock5 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -78,6 +82,7 @@ final class BulkOperationPackedSingleBlock5 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -98,6 +103,7 @@ final class BulkOperationPackedSingleBlock5 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -125,6 +131,7 @@ final class BulkOperationPackedSingleBlock5 extends BulkOperation {
}
}
@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;
@ -133,6 +140,7 @@ final class BulkOperationPackedSingleBlock5 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock6.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPackedSingleBlock6 extends BulkOperation {
@Override
public int blockCount() {
return 1;
}
@Override
public int valueCount() {
return 10;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -49,6 +52,7 @@ final class BulkOperationPackedSingleBlock6 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -74,6 +78,7 @@ final class BulkOperationPackedSingleBlock6 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -92,6 +97,7 @@ final class BulkOperationPackedSingleBlock6 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -117,6 +123,7 @@ final class BulkOperationPackedSingleBlock6 extends BulkOperation {
}
}
@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;
@ -125,6 +132,7 @@ final class BulkOperationPackedSingleBlock6 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock7.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPackedSingleBlock7 extends BulkOperation {
@Override
public int blockCount() {
return 1;
}
@Override
public int valueCount() {
return 9;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -48,6 +51,7 @@ final class BulkOperationPackedSingleBlock7 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -72,6 +76,7 @@ final class BulkOperationPackedSingleBlock7 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -89,6 +94,7 @@ final class BulkOperationPackedSingleBlock7 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -113,6 +119,7 @@ final class BulkOperationPackedSingleBlock7 extends BulkOperation {
}
}
@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;
@ -121,6 +128,7 @@ final class BulkOperationPackedSingleBlock7 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock8.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPackedSingleBlock8 extends BulkOperation {
@Override
public int blockCount() {
return 1;
}
@Override
public int valueCount() {
return 8;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -47,6 +50,7 @@ final class BulkOperationPackedSingleBlock8 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -70,6 +74,7 @@ final class BulkOperationPackedSingleBlock8 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -86,6 +91,7 @@ final class BulkOperationPackedSingleBlock8 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -109,6 +115,7 @@ final class BulkOperationPackedSingleBlock8 extends BulkOperation {
}
}
@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;
@ -117,6 +124,7 @@ final class BulkOperationPackedSingleBlock8 extends BulkOperation {
}
}
@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;

8
lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock9.java
View File

@ -23,14 +23,17 @@ package org.apache.lucene.util.packed;
* Efficient sequential read/write of packed integers.
*/
final class BulkOperationPackedSingleBlock9 extends BulkOperation {
@Override
public int blockCount() {
return 1;
}
@Override
public int valueCount() {
return 7;
}
@Override
public void decode(long[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -46,6 +49,7 @@ final class BulkOperationPackedSingleBlock9 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, int[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -68,6 +72,7 @@ final class BulkOperationPackedSingleBlock9 extends BulkOperation {
}
}
@Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -83,6 +88,7 @@ final class BulkOperationPackedSingleBlock9 extends BulkOperation {
}
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
assert blocksOffset + 8 * iterations * blockCount() <= blocks.length;
assert valuesOffset + iterations * valueCount() <= values.length;
@ -105,6 +111,7 @@ final class BulkOperationPackedSingleBlock9 extends BulkOperation {
}
}
@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;
@ -113,6 +120,7 @@ final class BulkOperationPackedSingleBlock9 extends BulkOperation {
}
}
@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;

15
lucene/core/src/java/org/apache/lucene/util/packed/gen_BulkOperation.py
View File

@ -140,9 +140,11 @@ def get_type(bits):
def packed64singleblock(bpv, f):
values = 64 / bpv
f.write(" @Override\n")
f.write(" public int blockCount() {\n")
f.write(" return 1;\n")
f.write(" }\n\n")
f.write(" @Override\n")
f.write(" public int valueCount() {\n")
f.write(" return %d;\n" %values)
f.write(" }\n\n")
@ -155,6 +157,7 @@ def p64sb_decode(bpv, f, bits):
values = 64 / bpv
typ = get_type(bits)
cast_start, cast_end = casts(typ)
f.write(" @Override\n")
f.write(" public void decode(long[] blocks, int blocksOffset, %s[] values, int valuesOffset, int iterations) {\n" %typ)
if bits < bpv:
f.write(" throw new UnsupportedOperationException();\n")
@ -177,6 +180,7 @@ def p64sb_decode(bpv, f, bits):
f.write(" }\n")
f.write(" }\n\n")
f.write(" @Override\n")
f.write(" public void decode(byte[] blocks, int blocksOffset, %s[] values, int valuesOffset, int iterations) {\n" %typ)
if bits < bpv:
f.write(" throw new UnsupportedOperationException();\n")
@ -227,6 +231,7 @@ def p64sb_encode(bpv, f, bits):
values = 64 / bpv
typ = get_type(bits)
mask_start, mask_end = masks(bits)
f.write(" @Override\n")
f.write(" public void encode(%s[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {\n" %typ)
if bits < bpv:
f.write(" throw new UnsupportedOperationException();\n")
@ -255,15 +260,18 @@ def packed64(bpv, f):
values /= 2
assert values * bpv == 64 * blocks, "%d values, %d blocks, %d bits per value" %(values, blocks, bpv)
mask = (1 << bpv) - 1
f.write(" @Override\n")
f.write(" public int blockCount() {\n")
f.write(" return %d;\n" %blocks)
f.write(" }\n\n")
f.write(" @Override\n")
f.write(" public int valueCount() {\n")
f.write(" return %d;\n" %values)
f.write(" }\n\n")
if bpv == 64:
f.write(""" public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
f.write(""" @Override
public void decode(long[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
System.arraycopy(blocks, blocksOffset, values, valuesOffset, valueCount() * iterations);
}
@ -277,10 +285,12 @@ def packed64(bpv, f):
throw new UnsupportedOperationException();
}
@Override
public void decode(byte[] blocks, int blocksOffset, long[] values, int valuesOffset, int iterations) {
LongBuffer.wrap(values, valuesOffset, iterations * valueCount()).put(ByteBuffer.wrap(blocks, blocksOffset, 8 * iterations * blockCount()).asLongBuffer());
}
@Override
public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
System.arraycopy(values, valuesOffset, blocks, blocksOffset, valueCount() * iterations);
}
@ -295,6 +305,7 @@ def p64_decode(bpv, f, bits, values):
typ = get_type(bits)
cast_start, cast_end = casts(typ)
f.write(" @Override\n")
f.write(" public void decode(long[] blocks, int blocksOffset, %s[] values, int valuesOffset, int iterations) {\n" %typ)
if bits < bpv:
f.write(" throw new UnsupportedOperationException();\n")
@ -326,6 +337,7 @@ def p64_decode(bpv, f, bits, values):
f.write(" }\n")
f.write(" }\n\n")
f.write(" @Override\n")
f.write(" public void decode(byte[] blocks, int blocksOffset, %s[] values, int valuesOffset, int iterations) {\n" %typ)
if bits < bpv:
f.write(" throw new UnsupportedOperationException();\n")
@ -374,6 +386,7 @@ def p64_decode(bpv, f, bits, values):
def p64_encode(bpv, f, bits, values):
typ = get_type(bits)
mask_start, mask_end = masks(bits)
f.write(" @Override\n")
f.write(" public void encode(%s[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {\n" %typ)
f.write(" assert blocksOffset + iterations * blockCount() <= blocks.length;\n")
f.write(" assert valuesOffset + iterations * valueCount() <= values.length;\n")