lucene-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From uschind...@apache.org
Subject svn commit: r1376625 [3/3] - /lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/
Date Thu, 23 Aug 2012 18:11:19 GMT
Modified: lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked8.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked8.java?rev=1376625&r1=1376624&r2=1376625&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked8.java (original)
+++ lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked8.java Thu Aug 23 18:11:16 2012
@@ -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
       }
     }
 
+    @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
       }
     }
 
+    @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
       }
     }
 
+    @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
       }
     }
 
+    @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
       }
     }
 
+    @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;

Modified: lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked9.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked9.java?rev=1376625&r1=1376624&r2=1376625&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked9.java (original)
+++ lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPacked9.java Thu Aug 23 18:11:16 2012
@@ -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
       }
     }
 
+    @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
       }
     }
 
+    @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
       }
     }
 
+    @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
       }
     }
 
+    @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
       }
     }
 
+    @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;

Modified: lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock1.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock1.java?rev=1376625&r1=1376624&r2=1376625&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock1.java (original)
+++ lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock1.java Thu Aug 23 18:11:16 2012
@@ -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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @Override
     public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
       assert blocksOffset + iterations * blockCount() <= blocks.length;
       assert valuesOffset + iterations * valueCount() <= values.length;
@@ -341,6 +348,7 @@ final class BulkOperationPackedSingleBlo
       }
     }
 
+    @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;

Modified: lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock10.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock10.java?rev=1376625&r1=1376624&r2=1376625&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock10.java (original)
+++ lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock10.java Thu Aug 23 18:11:16 2012
@@ -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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @Override
     public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
       assert blocksOffset + iterations * blockCount() <= blocks.length;
       assert valuesOffset + iterations * valueCount() <= values.length;
@@ -109,6 +116,7 @@ final class BulkOperationPackedSingleBlo
       }
     }
 
+    @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;

Modified: lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock12.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock12.java?rev=1376625&r1=1376624&r2=1376625&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock12.java (original)
+++ lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock12.java Thu Aug 23 18:11:16 2012
@@ -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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @Override
     public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
       assert blocksOffset + iterations * blockCount() <= blocks.length;
       assert valuesOffset + iterations * valueCount() <= values.length;
@@ -105,6 +112,7 @@ final class BulkOperationPackedSingleBlo
       }
     }
 
+    @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;

Modified: lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock16.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock16.java?rev=1376625&r1=1376624&r2=1376625&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock16.java (original)
+++ lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock16.java Thu Aug 23 18:11:16 2012
@@ -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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @Override
     public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
       assert blocksOffset + iterations * blockCount() <= blocks.length;
       assert valuesOffset + iterations * valueCount() <= values.length;
@@ -101,6 +108,7 @@ final class BulkOperationPackedSingleBlo
       }
     }
 
+    @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;

Modified: lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock2.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock2.java?rev=1376625&r1=1376624&r2=1376625&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock2.java (original)
+++ lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock2.java Thu Aug 23 18:11:16 2012
@@ -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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @Override
     public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
       assert blocksOffset + iterations * blockCount() <= blocks.length;
       assert valuesOffset + iterations * valueCount() <= values.length;
@@ -213,6 +220,7 @@ final class BulkOperationPackedSingleBlo
       }
     }
 
+    @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;

Modified: lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock21.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock21.java?rev=1376625&r1=1376624&r2=1376625&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock21.java (original)
+++ lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock21.java Thu Aug 23 18:11:16 2012
@@ -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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @Override
     public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
       assert blocksOffset + iterations * blockCount() <= blocks.length;
       assert valuesOffset + iterations * valueCount() <= values.length;
@@ -97,6 +104,7 @@ final class BulkOperationPackedSingleBlo
       }
     }
 
+    @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;

Modified: lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock3.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock3.java?rev=1376625&r1=1376624&r2=1376625&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock3.java (original)
+++ lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock3.java Thu Aug 23 18:11:16 2012
@@ -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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @Override
     public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
       assert blocksOffset + iterations * blockCount() <= blocks.length;
       assert valuesOffset + iterations * valueCount() <= values.length;
@@ -169,6 +176,7 @@ final class BulkOperationPackedSingleBlo
       }
     }
 
+    @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;

Modified: lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock32.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock32.java?rev=1376625&r1=1376624&r2=1376625&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock32.java (original)
+++ lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock32.java Thu Aug 23 18:11:16 2012
@@ -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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @Override
     public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
       assert blocksOffset + iterations * blockCount() <= blocks.length;
       assert valuesOffset + iterations * valueCount() <= values.length;
@@ -93,6 +100,7 @@ final class BulkOperationPackedSingleBlo
       }
     }
 
+    @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;

Modified: lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock4.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock4.java?rev=1376625&r1=1376624&r2=1376625&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock4.java (original)
+++ lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock4.java Thu Aug 23 18:11:16 2012
@@ -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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @Override
     public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
       assert blocksOffset + iterations * blockCount() <= blocks.length;
       assert valuesOffset + iterations * valueCount() <= values.length;
@@ -149,6 +156,7 @@ final class BulkOperationPackedSingleBlo
       }
     }
 
+    @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;

Modified: lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock5.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock5.java?rev=1376625&r1=1376624&r2=1376625&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock5.java (original)
+++ lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock5.java Thu Aug 23 18:11:16 2012
@@ -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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @Override
     public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
       assert blocksOffset + iterations * blockCount() <= blocks.length;
       assert valuesOffset + iterations * valueCount() <= values.length;
@@ -133,6 +140,7 @@ final class BulkOperationPackedSingleBlo
       }
     }
 
+    @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;

Modified: lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock6.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock6.java?rev=1376625&r1=1376624&r2=1376625&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock6.java (original)
+++ lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock6.java Thu Aug 23 18:11:16 2012
@@ -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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @Override
     public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
       assert blocksOffset + iterations * blockCount() <= blocks.length;
       assert valuesOffset + iterations * valueCount() <= values.length;
@@ -125,6 +132,7 @@ final class BulkOperationPackedSingleBlo
       }
     }
 
+    @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;

Modified: lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock7.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock7.java?rev=1376625&r1=1376624&r2=1376625&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock7.java (original)
+++ lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock7.java Thu Aug 23 18:11:16 2012
@@ -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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @Override
     public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
       assert blocksOffset + iterations * blockCount() <= blocks.length;
       assert valuesOffset + iterations * valueCount() <= values.length;
@@ -121,6 +128,7 @@ final class BulkOperationPackedSingleBlo
       }
     }
 
+    @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;

Modified: lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock8.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock8.java?rev=1376625&r1=1376624&r2=1376625&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock8.java (original)
+++ lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock8.java Thu Aug 23 18:11:16 2012
@@ -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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @Override
     public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
       assert blocksOffset + iterations * blockCount() <= blocks.length;
       assert valuesOffset + iterations * valueCount() <= values.length;
@@ -117,6 +124,7 @@ final class BulkOperationPackedSingleBlo
       }
     }
 
+    @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;

Modified: lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock9.java
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock9.java?rev=1376625&r1=1376624&r2=1376625&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock9.java (original)
+++ lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock9.java Thu Aug 23 18:11:16 2012
@@ -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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @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 BulkOperationPackedSingleBlo
       }
     }
 
+    @Override
     public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
       assert blocksOffset + iterations * blockCount() <= blocks.length;
       assert valuesOffset + iterations * valueCount() <= values.length;
@@ -113,6 +120,7 @@ final class BulkOperationPackedSingleBlo
       }
     }
 
+    @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;

Modified: lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/gen_BulkOperation.py
URL: http://svn.apache.org/viewvc/lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/gen_BulkOperation.py?rev=1376625&r1=1376624&r2=1376625&view=diff
==============================================================================
--- lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/gen_BulkOperation.py (original)
+++ lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/gen_BulkOperation.py Thu Aug 23 18:11:16 2012
@@ -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")



Mime
View raw message