You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucene.apache.org by mi...@apache.org on 2012/08/23 01:13:42 UTC
svn commit: r1376305 [37/37] -
/lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/
Added: 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=1376305&view=auto
==============================================================================
--- lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock5.java (added)
+++ lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock5.java Wed Aug 22 23:13:40 2012
@@ -0,0 +1,144 @@
+// This file has been automatically generated, DO NOT EDIT
+
+package org.apache.lucene.util.packed;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Efficient sequential read/write of packed integers.
+ */
+final class BulkOperationPackedSingleBlock5 extends BulkOperation {
+ public int blockCount() {
+ return 1;
+ }
+
+ public int valueCount() {
+ return 12;
+ }
+
+ 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;
+ for (int i = 0; i < iterations; ++i) {
+ final long block = blocks[blocksOffset++];
+ values[valuesOffset++] = (int) (block & 31L);
+ values[valuesOffset++] = (int) ((block >>> 5) & 31L);
+ values[valuesOffset++] = (int) ((block >>> 10) & 31L);
+ values[valuesOffset++] = (int) ((block >>> 15) & 31L);
+ values[valuesOffset++] = (int) ((block >>> 20) & 31L);
+ values[valuesOffset++] = (int) ((block >>> 25) & 31L);
+ values[valuesOffset++] = (int) ((block >>> 30) & 31L);
+ values[valuesOffset++] = (int) ((block >>> 35) & 31L);
+ values[valuesOffset++] = (int) ((block >>> 40) & 31L);
+ values[valuesOffset++] = (int) ((block >>> 45) & 31L);
+ values[valuesOffset++] = (int) ((block >>> 50) & 31L);
+ values[valuesOffset++] = (int) (block >>> 55);
+ }
+ }
+
+ 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;
+ for (int i = 0; i < iterations; ++i) {
+ final int byte7 = blocks[blocksOffset++] & 0xFF;
+ final int byte6 = blocks[blocksOffset++] & 0xFF;
+ final int byte5 = blocks[blocksOffset++] & 0xFF;
+ final int byte4 = blocks[blocksOffset++] & 0xFF;
+ final int byte3 = blocks[blocksOffset++] & 0xFF;
+ final int byte2 = blocks[blocksOffset++] & 0xFF;
+ final int byte1 = blocks[blocksOffset++] & 0xFF;
+ final int byte0 = blocks[blocksOffset++] & 0xFF;
+ values[valuesOffset++] = byte0 & 31;
+ values[valuesOffset++] = (byte0 >>> 5) | ((byte1 & 3) << 3);
+ values[valuesOffset++] = (byte1 >>> 2) & 31;
+ values[valuesOffset++] = (byte1 >>> 7) | ((byte2 & 15) << 1);
+ values[valuesOffset++] = (byte2 >>> 4) | ((byte3 & 1) << 4);
+ values[valuesOffset++] = (byte3 >>> 1) & 31;
+ values[valuesOffset++] = (byte3 >>> 6) | ((byte4 & 7) << 2);
+ values[valuesOffset++] = byte4 >>> 3;
+ values[valuesOffset++] = byte5 & 31;
+ values[valuesOffset++] = (byte5 >>> 5) | ((byte6 & 3) << 3);
+ values[valuesOffset++] = (byte6 >>> 2) & 31;
+ values[valuesOffset++] = (byte6 >>> 7) | ((byte7 & 15) << 1);
+ }
+ }
+
+ 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;
+ for (int i = 0; i < iterations; ++i) {
+ final long block = blocks[blocksOffset++];
+ values[valuesOffset++] = block & 31L;
+ values[valuesOffset++] = (block >>> 5) & 31L;
+ values[valuesOffset++] = (block >>> 10) & 31L;
+ values[valuesOffset++] = (block >>> 15) & 31L;
+ values[valuesOffset++] = (block >>> 20) & 31L;
+ values[valuesOffset++] = (block >>> 25) & 31L;
+ values[valuesOffset++] = (block >>> 30) & 31L;
+ values[valuesOffset++] = (block >>> 35) & 31L;
+ values[valuesOffset++] = (block >>> 40) & 31L;
+ values[valuesOffset++] = (block >>> 45) & 31L;
+ values[valuesOffset++] = (block >>> 50) & 31L;
+ values[valuesOffset++] = block >>> 55;
+ }
+ }
+
+ 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;
+ for (int i = 0; i < iterations; ++i) {
+ final int byte7 = blocks[blocksOffset++] & 0xFF;
+ final int byte6 = blocks[blocksOffset++] & 0xFF;
+ final int byte5 = blocks[blocksOffset++] & 0xFF;
+ final int byte4 = blocks[blocksOffset++] & 0xFF;
+ final int byte3 = blocks[blocksOffset++] & 0xFF;
+ final int byte2 = blocks[blocksOffset++] & 0xFF;
+ final int byte1 = blocks[blocksOffset++] & 0xFF;
+ final int byte0 = blocks[blocksOffset++] & 0xFF;
+ values[valuesOffset++] = byte0 & 31;
+ values[valuesOffset++] = (byte0 >>> 5) | ((byte1 & 3) << 3);
+ values[valuesOffset++] = (byte1 >>> 2) & 31;
+ values[valuesOffset++] = (byte1 >>> 7) | ((byte2 & 15) << 1);
+ values[valuesOffset++] = (byte2 >>> 4) | ((byte3 & 1) << 4);
+ values[valuesOffset++] = (byte3 >>> 1) & 31;
+ values[valuesOffset++] = (byte3 >>> 6) | ((byte4 & 7) << 2);
+ values[valuesOffset++] = byte4 >>> 3;
+ values[valuesOffset++] = byte5 & 31;
+ values[valuesOffset++] = (byte5 >>> 5) | ((byte6 & 3) << 3);
+ values[valuesOffset++] = (byte6 >>> 2) & 31;
+ values[valuesOffset++] = (byte6 >>> 7) | ((byte7 & 15) << 1);
+ }
+ }
+
+ public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
+ assert blocksOffset + iterations * blockCount() <= blocks.length;
+ assert valuesOffset + iterations * valueCount() <= values.length;
+ for (int i = 0; i < iterations; ++i) {
+ blocks[blocksOffset++] = (values[valuesOffset++] & 0xffffffffL) | ((values[valuesOffset++] & 0xffffffffL) << 5) | ((values[valuesOffset++] & 0xffffffffL) << 10) | ((values[valuesOffset++] & 0xffffffffL) << 15) | ((values[valuesOffset++] & 0xffffffffL) << 20) | ((values[valuesOffset++] & 0xffffffffL) << 25) | ((values[valuesOffset++] & 0xffffffffL) << 30) | ((values[valuesOffset++] & 0xffffffffL) << 35) | ((values[valuesOffset++] & 0xffffffffL) << 40) | ((values[valuesOffset++] & 0xffffffffL) << 45) | ((values[valuesOffset++] & 0xffffffffL) << 50) | ((values[valuesOffset++] & 0xffffffffL) << 55);
+ }
+ }
+
+ public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
+ assert blocksOffset + iterations * blockCount() <= blocks.length;
+ assert valuesOffset + iterations * valueCount() <= values.length;
+ for (int i = 0; i < iterations; ++i) {
+ blocks[blocksOffset++] = values[valuesOffset++] | (values[valuesOffset++] << 5) | (values[valuesOffset++] << 10) | (values[valuesOffset++] << 15) | (values[valuesOffset++] << 20) | (values[valuesOffset++] << 25) | (values[valuesOffset++] << 30) | (values[valuesOffset++] << 35) | (values[valuesOffset++] << 40) | (values[valuesOffset++] << 45) | (values[valuesOffset++] << 50) | (values[valuesOffset++] << 55);
+ }
+ }
+
+}
Added: 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=1376305&view=auto
==============================================================================
--- lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock6.java (added)
+++ lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock6.java Wed Aug 22 23:13:40 2012
@@ -0,0 +1,136 @@
+// This file has been automatically generated, DO NOT EDIT
+
+package org.apache.lucene.util.packed;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Efficient sequential read/write of packed integers.
+ */
+final class BulkOperationPackedSingleBlock6 extends BulkOperation {
+ public int blockCount() {
+ return 1;
+ }
+
+ public int valueCount() {
+ return 10;
+ }
+
+ 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;
+ for (int i = 0; i < iterations; ++i) {
+ final long block = blocks[blocksOffset++];
+ values[valuesOffset++] = (int) (block & 63L);
+ values[valuesOffset++] = (int) ((block >>> 6) & 63L);
+ values[valuesOffset++] = (int) ((block >>> 12) & 63L);
+ values[valuesOffset++] = (int) ((block >>> 18) & 63L);
+ values[valuesOffset++] = (int) ((block >>> 24) & 63L);
+ values[valuesOffset++] = (int) ((block >>> 30) & 63L);
+ values[valuesOffset++] = (int) ((block >>> 36) & 63L);
+ values[valuesOffset++] = (int) ((block >>> 42) & 63L);
+ values[valuesOffset++] = (int) ((block >>> 48) & 63L);
+ values[valuesOffset++] = (int) (block >>> 54);
+ }
+ }
+
+ 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;
+ for (int i = 0; i < iterations; ++i) {
+ final int byte7 = blocks[blocksOffset++] & 0xFF;
+ final int byte6 = blocks[blocksOffset++] & 0xFF;
+ final int byte5 = blocks[blocksOffset++] & 0xFF;
+ final int byte4 = blocks[blocksOffset++] & 0xFF;
+ final int byte3 = blocks[blocksOffset++] & 0xFF;
+ final int byte2 = blocks[blocksOffset++] & 0xFF;
+ final int byte1 = blocks[blocksOffset++] & 0xFF;
+ final int byte0 = blocks[blocksOffset++] & 0xFF;
+ values[valuesOffset++] = byte0 & 63;
+ values[valuesOffset++] = (byte0 >>> 6) | ((byte1 & 15) << 2);
+ values[valuesOffset++] = (byte1 >>> 4) | ((byte2 & 3) << 4);
+ values[valuesOffset++] = byte2 >>> 2;
+ values[valuesOffset++] = byte3 & 63;
+ values[valuesOffset++] = (byte3 >>> 6) | ((byte4 & 15) << 2);
+ values[valuesOffset++] = (byte4 >>> 4) | ((byte5 & 3) << 4);
+ values[valuesOffset++] = byte5 >>> 2;
+ values[valuesOffset++] = byte6 & 63;
+ values[valuesOffset++] = (byte6 >>> 6) | ((byte7 & 15) << 2);
+ }
+ }
+
+ 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;
+ for (int i = 0; i < iterations; ++i) {
+ final long block = blocks[blocksOffset++];
+ values[valuesOffset++] = block & 63L;
+ values[valuesOffset++] = (block >>> 6) & 63L;
+ values[valuesOffset++] = (block >>> 12) & 63L;
+ values[valuesOffset++] = (block >>> 18) & 63L;
+ values[valuesOffset++] = (block >>> 24) & 63L;
+ values[valuesOffset++] = (block >>> 30) & 63L;
+ values[valuesOffset++] = (block >>> 36) & 63L;
+ values[valuesOffset++] = (block >>> 42) & 63L;
+ values[valuesOffset++] = (block >>> 48) & 63L;
+ values[valuesOffset++] = block >>> 54;
+ }
+ }
+
+ 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;
+ for (int i = 0; i < iterations; ++i) {
+ final int byte7 = blocks[blocksOffset++] & 0xFF;
+ final int byte6 = blocks[blocksOffset++] & 0xFF;
+ final int byte5 = blocks[blocksOffset++] & 0xFF;
+ final int byte4 = blocks[blocksOffset++] & 0xFF;
+ final int byte3 = blocks[blocksOffset++] & 0xFF;
+ final int byte2 = blocks[blocksOffset++] & 0xFF;
+ final int byte1 = blocks[blocksOffset++] & 0xFF;
+ final int byte0 = blocks[blocksOffset++] & 0xFF;
+ values[valuesOffset++] = byte0 & 63;
+ values[valuesOffset++] = (byte0 >>> 6) | ((byte1 & 15) << 2);
+ values[valuesOffset++] = (byte1 >>> 4) | ((byte2 & 3) << 4);
+ values[valuesOffset++] = byte2 >>> 2;
+ values[valuesOffset++] = byte3 & 63;
+ values[valuesOffset++] = (byte3 >>> 6) | ((byte4 & 15) << 2);
+ values[valuesOffset++] = (byte4 >>> 4) | ((byte5 & 3) << 4);
+ values[valuesOffset++] = byte5 >>> 2;
+ values[valuesOffset++] = byte6 & 63;
+ values[valuesOffset++] = (byte6 >>> 6) | ((byte7 & 15) << 2);
+ }
+ }
+
+ public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
+ assert blocksOffset + iterations * blockCount() <= blocks.length;
+ assert valuesOffset + iterations * valueCount() <= values.length;
+ for (int i = 0; i < iterations; ++i) {
+ blocks[blocksOffset++] = (values[valuesOffset++] & 0xffffffffL) | ((values[valuesOffset++] & 0xffffffffL) << 6) | ((values[valuesOffset++] & 0xffffffffL) << 12) | ((values[valuesOffset++] & 0xffffffffL) << 18) | ((values[valuesOffset++] & 0xffffffffL) << 24) | ((values[valuesOffset++] & 0xffffffffL) << 30) | ((values[valuesOffset++] & 0xffffffffL) << 36) | ((values[valuesOffset++] & 0xffffffffL) << 42) | ((values[valuesOffset++] & 0xffffffffL) << 48) | ((values[valuesOffset++] & 0xffffffffL) << 54);
+ }
+ }
+
+ public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
+ assert blocksOffset + iterations * blockCount() <= blocks.length;
+ assert valuesOffset + iterations * valueCount() <= values.length;
+ for (int i = 0; i < iterations; ++i) {
+ blocks[blocksOffset++] = values[valuesOffset++] | (values[valuesOffset++] << 6) | (values[valuesOffset++] << 12) | (values[valuesOffset++] << 18) | (values[valuesOffset++] << 24) | (values[valuesOffset++] << 30) | (values[valuesOffset++] << 36) | (values[valuesOffset++] << 42) | (values[valuesOffset++] << 48) | (values[valuesOffset++] << 54);
+ }
+ }
+
+}
Added: 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=1376305&view=auto
==============================================================================
--- lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock7.java (added)
+++ lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock7.java Wed Aug 22 23:13:40 2012
@@ -0,0 +1,132 @@
+// This file has been automatically generated, DO NOT EDIT
+
+package org.apache.lucene.util.packed;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Efficient sequential read/write of packed integers.
+ */
+final class BulkOperationPackedSingleBlock7 extends BulkOperation {
+ public int blockCount() {
+ return 1;
+ }
+
+ public int valueCount() {
+ return 9;
+ }
+
+ 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;
+ for (int i = 0; i < iterations; ++i) {
+ final long block = blocks[blocksOffset++];
+ values[valuesOffset++] = (int) (block & 127L);
+ values[valuesOffset++] = (int) ((block >>> 7) & 127L);
+ values[valuesOffset++] = (int) ((block >>> 14) & 127L);
+ values[valuesOffset++] = (int) ((block >>> 21) & 127L);
+ values[valuesOffset++] = (int) ((block >>> 28) & 127L);
+ values[valuesOffset++] = (int) ((block >>> 35) & 127L);
+ values[valuesOffset++] = (int) ((block >>> 42) & 127L);
+ values[valuesOffset++] = (int) ((block >>> 49) & 127L);
+ values[valuesOffset++] = (int) (block >>> 56);
+ }
+ }
+
+ 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;
+ for (int i = 0; i < iterations; ++i) {
+ final int byte7 = blocks[blocksOffset++] & 0xFF;
+ final int byte6 = blocks[blocksOffset++] & 0xFF;
+ final int byte5 = blocks[blocksOffset++] & 0xFF;
+ final int byte4 = blocks[blocksOffset++] & 0xFF;
+ final int byte3 = blocks[blocksOffset++] & 0xFF;
+ final int byte2 = blocks[blocksOffset++] & 0xFF;
+ final int byte1 = blocks[blocksOffset++] & 0xFF;
+ final int byte0 = blocks[blocksOffset++] & 0xFF;
+ values[valuesOffset++] = byte0 & 127;
+ values[valuesOffset++] = (byte0 >>> 7) | ((byte1 & 63) << 1);
+ values[valuesOffset++] = (byte1 >>> 6) | ((byte2 & 31) << 2);
+ values[valuesOffset++] = (byte2 >>> 5) | ((byte3 & 15) << 3);
+ values[valuesOffset++] = (byte3 >>> 4) | ((byte4 & 7) << 4);
+ values[valuesOffset++] = (byte4 >>> 3) | ((byte5 & 3) << 5);
+ values[valuesOffset++] = (byte5 >>> 2) | ((byte6 & 1) << 6);
+ values[valuesOffset++] = byte6 >>> 1;
+ values[valuesOffset++] = byte7 & 127;
+ }
+ }
+
+ 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;
+ for (int i = 0; i < iterations; ++i) {
+ final long block = blocks[blocksOffset++];
+ values[valuesOffset++] = block & 127L;
+ values[valuesOffset++] = (block >>> 7) & 127L;
+ values[valuesOffset++] = (block >>> 14) & 127L;
+ values[valuesOffset++] = (block >>> 21) & 127L;
+ values[valuesOffset++] = (block >>> 28) & 127L;
+ values[valuesOffset++] = (block >>> 35) & 127L;
+ values[valuesOffset++] = (block >>> 42) & 127L;
+ values[valuesOffset++] = (block >>> 49) & 127L;
+ values[valuesOffset++] = block >>> 56;
+ }
+ }
+
+ 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;
+ for (int i = 0; i < iterations; ++i) {
+ final int byte7 = blocks[blocksOffset++] & 0xFF;
+ final int byte6 = blocks[blocksOffset++] & 0xFF;
+ final int byte5 = blocks[blocksOffset++] & 0xFF;
+ final int byte4 = blocks[blocksOffset++] & 0xFF;
+ final int byte3 = blocks[blocksOffset++] & 0xFF;
+ final int byte2 = blocks[blocksOffset++] & 0xFF;
+ final int byte1 = blocks[blocksOffset++] & 0xFF;
+ final int byte0 = blocks[blocksOffset++] & 0xFF;
+ values[valuesOffset++] = byte0 & 127;
+ values[valuesOffset++] = (byte0 >>> 7) | ((byte1 & 63) << 1);
+ values[valuesOffset++] = (byte1 >>> 6) | ((byte2 & 31) << 2);
+ values[valuesOffset++] = (byte2 >>> 5) | ((byte3 & 15) << 3);
+ values[valuesOffset++] = (byte3 >>> 4) | ((byte4 & 7) << 4);
+ values[valuesOffset++] = (byte4 >>> 3) | ((byte5 & 3) << 5);
+ values[valuesOffset++] = (byte5 >>> 2) | ((byte6 & 1) << 6);
+ values[valuesOffset++] = byte6 >>> 1;
+ values[valuesOffset++] = byte7 & 127;
+ }
+ }
+
+ public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
+ assert blocksOffset + iterations * blockCount() <= blocks.length;
+ assert valuesOffset + iterations * valueCount() <= values.length;
+ for (int i = 0; i < iterations; ++i) {
+ blocks[blocksOffset++] = (values[valuesOffset++] & 0xffffffffL) | ((values[valuesOffset++] & 0xffffffffL) << 7) | ((values[valuesOffset++] & 0xffffffffL) << 14) | ((values[valuesOffset++] & 0xffffffffL) << 21) | ((values[valuesOffset++] & 0xffffffffL) << 28) | ((values[valuesOffset++] & 0xffffffffL) << 35) | ((values[valuesOffset++] & 0xffffffffL) << 42) | ((values[valuesOffset++] & 0xffffffffL) << 49) | ((values[valuesOffset++] & 0xffffffffL) << 56);
+ }
+ }
+
+ public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
+ assert blocksOffset + iterations * blockCount() <= blocks.length;
+ assert valuesOffset + iterations * valueCount() <= values.length;
+ for (int i = 0; i < iterations; ++i) {
+ blocks[blocksOffset++] = values[valuesOffset++] | (values[valuesOffset++] << 7) | (values[valuesOffset++] << 14) | (values[valuesOffset++] << 21) | (values[valuesOffset++] << 28) | (values[valuesOffset++] << 35) | (values[valuesOffset++] << 42) | (values[valuesOffset++] << 49) | (values[valuesOffset++] << 56);
+ }
+ }
+
+}
Added: 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=1376305&view=auto
==============================================================================
--- lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock8.java (added)
+++ lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock8.java Wed Aug 22 23:13:40 2012
@@ -0,0 +1,128 @@
+// This file has been automatically generated, DO NOT EDIT
+
+package org.apache.lucene.util.packed;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Efficient sequential read/write of packed integers.
+ */
+final class BulkOperationPackedSingleBlock8 extends BulkOperation {
+ public int blockCount() {
+ return 1;
+ }
+
+ public int valueCount() {
+ return 8;
+ }
+
+ 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;
+ for (int i = 0; i < iterations; ++i) {
+ final long block = blocks[blocksOffset++];
+ values[valuesOffset++] = (int) (block & 255L);
+ values[valuesOffset++] = (int) ((block >>> 8) & 255L);
+ values[valuesOffset++] = (int) ((block >>> 16) & 255L);
+ values[valuesOffset++] = (int) ((block >>> 24) & 255L);
+ values[valuesOffset++] = (int) ((block >>> 32) & 255L);
+ values[valuesOffset++] = (int) ((block >>> 40) & 255L);
+ values[valuesOffset++] = (int) ((block >>> 48) & 255L);
+ values[valuesOffset++] = (int) (block >>> 56);
+ }
+ }
+
+ 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;
+ for (int i = 0; i < iterations; ++i) {
+ final int byte7 = blocks[blocksOffset++] & 0xFF;
+ final int byte6 = blocks[blocksOffset++] & 0xFF;
+ final int byte5 = blocks[blocksOffset++] & 0xFF;
+ final int byte4 = blocks[blocksOffset++] & 0xFF;
+ final int byte3 = blocks[blocksOffset++] & 0xFF;
+ final int byte2 = blocks[blocksOffset++] & 0xFF;
+ final int byte1 = blocks[blocksOffset++] & 0xFF;
+ final int byte0 = blocks[blocksOffset++] & 0xFF;
+ values[valuesOffset++] = byte0;
+ values[valuesOffset++] = byte1;
+ values[valuesOffset++] = byte2;
+ values[valuesOffset++] = byte3;
+ values[valuesOffset++] = byte4;
+ values[valuesOffset++] = byte5;
+ values[valuesOffset++] = byte6;
+ values[valuesOffset++] = byte7;
+ }
+ }
+
+ 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;
+ for (int i = 0; i < iterations; ++i) {
+ final long block = blocks[blocksOffset++];
+ values[valuesOffset++] = block & 255L;
+ values[valuesOffset++] = (block >>> 8) & 255L;
+ values[valuesOffset++] = (block >>> 16) & 255L;
+ values[valuesOffset++] = (block >>> 24) & 255L;
+ values[valuesOffset++] = (block >>> 32) & 255L;
+ values[valuesOffset++] = (block >>> 40) & 255L;
+ values[valuesOffset++] = (block >>> 48) & 255L;
+ values[valuesOffset++] = block >>> 56;
+ }
+ }
+
+ 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;
+ for (int i = 0; i < iterations; ++i) {
+ final int byte7 = blocks[blocksOffset++] & 0xFF;
+ final int byte6 = blocks[blocksOffset++] & 0xFF;
+ final int byte5 = blocks[blocksOffset++] & 0xFF;
+ final int byte4 = blocks[blocksOffset++] & 0xFF;
+ final int byte3 = blocks[blocksOffset++] & 0xFF;
+ final int byte2 = blocks[blocksOffset++] & 0xFF;
+ final int byte1 = blocks[blocksOffset++] & 0xFF;
+ final int byte0 = blocks[blocksOffset++] & 0xFF;
+ values[valuesOffset++] = byte0;
+ values[valuesOffset++] = byte1;
+ values[valuesOffset++] = byte2;
+ values[valuesOffset++] = byte3;
+ values[valuesOffset++] = byte4;
+ values[valuesOffset++] = byte5;
+ values[valuesOffset++] = byte6;
+ values[valuesOffset++] = byte7;
+ }
+ }
+
+ public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
+ assert blocksOffset + iterations * blockCount() <= blocks.length;
+ assert valuesOffset + iterations * valueCount() <= values.length;
+ for (int i = 0; i < iterations; ++i) {
+ blocks[blocksOffset++] = (values[valuesOffset++] & 0xffffffffL) | ((values[valuesOffset++] & 0xffffffffL) << 8) | ((values[valuesOffset++] & 0xffffffffL) << 16) | ((values[valuesOffset++] & 0xffffffffL) << 24) | ((values[valuesOffset++] & 0xffffffffL) << 32) | ((values[valuesOffset++] & 0xffffffffL) << 40) | ((values[valuesOffset++] & 0xffffffffL) << 48) | ((values[valuesOffset++] & 0xffffffffL) << 56);
+ }
+ }
+
+ public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
+ assert blocksOffset + iterations * blockCount() <= blocks.length;
+ assert valuesOffset + iterations * valueCount() <= values.length;
+ for (int i = 0; i < iterations; ++i) {
+ blocks[blocksOffset++] = values[valuesOffset++] | (values[valuesOffset++] << 8) | (values[valuesOffset++] << 16) | (values[valuesOffset++] << 24) | (values[valuesOffset++] << 32) | (values[valuesOffset++] << 40) | (values[valuesOffset++] << 48) | (values[valuesOffset++] << 56);
+ }
+ }
+
+}
Added: 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=1376305&view=auto
==============================================================================
--- lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock9.java (added)
+++ lucene/dev/trunk/lucene/core/src/java/org/apache/lucene/util/packed/BulkOperationPackedSingleBlock9.java Wed Aug 22 23:13:40 2012
@@ -0,0 +1,124 @@
+// This file has been automatically generated, DO NOT EDIT
+
+package org.apache.lucene.util.packed;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Efficient sequential read/write of packed integers.
+ */
+final class BulkOperationPackedSingleBlock9 extends BulkOperation {
+ public int blockCount() {
+ return 1;
+ }
+
+ public int valueCount() {
+ return 7;
+ }
+
+ 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;
+ for (int i = 0; i < iterations; ++i) {
+ final long block = blocks[blocksOffset++];
+ values[valuesOffset++] = (int) (block & 511L);
+ values[valuesOffset++] = (int) ((block >>> 9) & 511L);
+ values[valuesOffset++] = (int) ((block >>> 18) & 511L);
+ values[valuesOffset++] = (int) ((block >>> 27) & 511L);
+ values[valuesOffset++] = (int) ((block >>> 36) & 511L);
+ values[valuesOffset++] = (int) ((block >>> 45) & 511L);
+ values[valuesOffset++] = (int) (block >>> 54);
+ }
+ }
+
+ 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;
+ for (int i = 0; i < iterations; ++i) {
+ final int byte7 = blocks[blocksOffset++] & 0xFF;
+ final int byte6 = blocks[blocksOffset++] & 0xFF;
+ final int byte5 = blocks[blocksOffset++] & 0xFF;
+ final int byte4 = blocks[blocksOffset++] & 0xFF;
+ final int byte3 = blocks[blocksOffset++] & 0xFF;
+ final int byte2 = blocks[blocksOffset++] & 0xFF;
+ final int byte1 = blocks[blocksOffset++] & 0xFF;
+ final int byte0 = blocks[blocksOffset++] & 0xFF;
+ values[valuesOffset++] = byte0 | ((byte1 & 1) << 8);
+ values[valuesOffset++] = (byte1 >>> 1) | ((byte2 & 3) << 7);
+ values[valuesOffset++] = (byte2 >>> 2) | ((byte3 & 7) << 6);
+ values[valuesOffset++] = (byte3 >>> 3) | ((byte4 & 15) << 5);
+ values[valuesOffset++] = (byte4 >>> 4) | ((byte5 & 31) << 4);
+ values[valuesOffset++] = (byte5 >>> 5) | ((byte6 & 63) << 3);
+ values[valuesOffset++] = (byte6 >>> 6) | ((byte7 & 127) << 2);
+ }
+ }
+
+ 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;
+ for (int i = 0; i < iterations; ++i) {
+ final long block = blocks[blocksOffset++];
+ values[valuesOffset++] = block & 511L;
+ values[valuesOffset++] = (block >>> 9) & 511L;
+ values[valuesOffset++] = (block >>> 18) & 511L;
+ values[valuesOffset++] = (block >>> 27) & 511L;
+ values[valuesOffset++] = (block >>> 36) & 511L;
+ values[valuesOffset++] = (block >>> 45) & 511L;
+ values[valuesOffset++] = block >>> 54;
+ }
+ }
+
+ 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;
+ for (int i = 0; i < iterations; ++i) {
+ final int byte7 = blocks[blocksOffset++] & 0xFF;
+ final int byte6 = blocks[blocksOffset++] & 0xFF;
+ final int byte5 = blocks[blocksOffset++] & 0xFF;
+ final int byte4 = blocks[blocksOffset++] & 0xFF;
+ final int byte3 = blocks[blocksOffset++] & 0xFF;
+ final int byte2 = blocks[blocksOffset++] & 0xFF;
+ final int byte1 = blocks[blocksOffset++] & 0xFF;
+ final int byte0 = blocks[blocksOffset++] & 0xFF;
+ values[valuesOffset++] = byte0 | ((byte1 & 1) << 8);
+ values[valuesOffset++] = (byte1 >>> 1) | ((byte2 & 3) << 7);
+ values[valuesOffset++] = (byte2 >>> 2) | ((byte3 & 7) << 6);
+ values[valuesOffset++] = (byte3 >>> 3) | ((byte4 & 15) << 5);
+ values[valuesOffset++] = (byte4 >>> 4) | ((byte5 & 31) << 4);
+ values[valuesOffset++] = (byte5 >>> 5) | ((byte6 & 63) << 3);
+ values[valuesOffset++] = (byte6 >>> 6) | ((byte7 & 127) << 2);
+ }
+ }
+
+ public void encode(int[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
+ assert blocksOffset + iterations * blockCount() <= blocks.length;
+ assert valuesOffset + iterations * valueCount() <= values.length;
+ for (int i = 0; i < iterations; ++i) {
+ blocks[blocksOffset++] = (values[valuesOffset++] & 0xffffffffL) | ((values[valuesOffset++] & 0xffffffffL) << 9) | ((values[valuesOffset++] & 0xffffffffL) << 18) | ((values[valuesOffset++] & 0xffffffffL) << 27) | ((values[valuesOffset++] & 0xffffffffL) << 36) | ((values[valuesOffset++] & 0xffffffffL) << 45) | ((values[valuesOffset++] & 0xffffffffL) << 54);
+ }
+ }
+
+ public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
+ assert blocksOffset + iterations * blockCount() <= blocks.length;
+ assert valuesOffset + iterations * valueCount() <= values.length;
+ for (int i = 0; i < iterations; ++i) {
+ blocks[blocksOffset++] = values[valuesOffset++] | (values[valuesOffset++] << 9) | (values[valuesOffset++] << 18) | (values[valuesOffset++] << 27) | (values[valuesOffset++] << 36) | (values[valuesOffset++] << 45) | (values[valuesOffset++] << 54);
+ }
+ }
+
+}
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=1376305&r1=1376304&r2=1376305&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 Wed Aug 22 23:13:40 2012
@@ -42,13 +42,6 @@ package org.apache.lucene.util.packed;
* limitations under the License.
*/
-import java.nio.LongBuffer;
-import java.nio.ByteBuffer;
-
-/**
- * Efficient sequential read/write of packed integers.
- */
-enum BulkOperation implements PackedInts.Decoder, PackedInts.Encoder {
"""
FOOTER="""
@@ -150,20 +143,18 @@ def get_type(bits):
def packed64singleblock(bpv, f):
values = 64 / bpv
- f.write("\n PACKED_SINGLE_BLOCK_%d {\n\n" %bpv)
f.write(" public int blockCount() {\n")
f.write(" return 1;\n")
f.write(" }\n\n")
f.write(" public int valueCount() {\n")
f.write(" return %d;\n" %values)
f.write(" }\n\n")
- p64sb_decode(bpv, 32)
- p64sb_decode(bpv, 64)
- p64sb_encode(bpv, 32)
- p64sb_encode(bpv, 64)
- f.write(" }")
+ p64sb_decode(bpv, f, 32)
+ p64sb_decode(bpv, f, 64)
+ p64sb_encode(bpv, f, 32)
+ p64sb_encode(bpv, f, 64)
-def p64sb_decode(bpv, bits):
+def p64sb_decode(bpv, f, bits):
values = 64 / bpv
typ = get_type(bits)
cast_start, cast_end = casts(typ)
@@ -235,7 +226,7 @@ def p64sb_decode(bpv, bits):
f.write(" }\n")
f.write(" }\n\n")
-def p64sb_encode(bpv, bits):
+def p64sb_encode(bpv, f, bits):
values = 64 / bpv
typ = get_type(bits)
mask_start, mask_end = masks(bits)
@@ -267,7 +258,6 @@ 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(" PACKED_%d {\n\n" %bpv)
f.write(" public int blockCount() {\n")
f.write(" return %d;\n" %blocks)
f.write(" }\n\n")
@@ -287,17 +277,14 @@ def packed64(bpv, f):
public void encode(long[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {
System.arraycopy(values, valuesOffset, blocks, blocksOffset, valueCount() * iterations);
}
-
- }
""")
else:
- p64_decode(bpv, 32, values)
- p64_decode(bpv, 64, values)
- p64_encode(bpv, 32, values)
- p64_encode(bpv, 64, values)
- f.write(" }\n")
+ p64_decode(bpv, f, 32, values)
+ p64_decode(bpv, f, 64, values)
+ p64_encode(bpv, f, 32, values)
+ p64_encode(bpv, f, 64, values)
-def p64_decode(bpv, bits, values):
+def p64_decode(bpv, f, bits, values):
typ = get_type(bits)
cast_start, cast_end = casts(typ)
@@ -379,7 +366,7 @@ def p64_decode(bpv, bits, values):
f.write(" }\n")
f.write(" }\n\n")
-def p64_encode(bpv, bits, values):
+def p64_encode(bpv, f, bits, values):
typ = get_type(bits)
mask_start, mask_end = masks(bits)
f.write(" public void encode(%s[] values, int valuesOffset, long[] blocks, int blocksOffset, int iterations) {\n" %typ)
@@ -409,16 +396,46 @@ def p64_encode(bpv, bits, values):
if __name__ == '__main__':
p64_bpv = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 16, 21, 32]
+
f = open(OUTPUT_FILE, 'w')
f.write(HEADER)
+ f.write('import java.nio.ByteBuffer;\n')
+ f.write('\n')
+ f.write('''/**
+ * Efficient sequential read/write of packed integers.
+ */\n''')
+
+ f.write('abstract class BulkOperation implements PackedInts.Decoder, PackedInts.Encoder {\n')
+
for bpv in xrange(1, 65):
- packed64(bpv, f)
- f.write(" ,\n")
+ f2 = open('BulkOperationPacked%d.java' % bpv, 'w')
+ f2.write(HEADER)
+ if bpv == 64:
+ f2.write('import java.nio.LongBuffer;\n')
+ f2.write('import java.nio.ByteBuffer;\n')
+ f2.write('\n')
+ f2.write('''/**
+ * Efficient sequential read/write of packed integers.
+ */\n''')
+ f2.write('final class BulkOperationPacked%d extends BulkOperation {\n' % bpv)
+ packed64(bpv, f2)
+ f2.write('}\n')
+ f2.close()
+ f.write(' private static final BulkOperationPacked%d packed%d = new BulkOperationPacked%d();\n' % (bpv, bpv, bpv))
+
+
for bpv in PACKED_64_SINGLE_BLOCK_BPV:
- if bpv != PACKED_64_SINGLE_BLOCK_BPV[0]:
- f.write(" ,\n")
- packed64singleblock(bpv,f)
- f.write(" ;\n\n")
+ f2 = open('BulkOperationPackedSingleBlock%d.java' % bpv, 'w')
+ f2.write(HEADER)
+ f2.write('''/**
+ * Efficient sequential read/write of packed integers.
+ */\n''')
+ f2.write('final class BulkOperationPackedSingleBlock%d extends BulkOperation {\n' % bpv)
+ packed64singleblock(bpv,f2)
+ f2.write('}\n')
+ f2.close()
+ f.write(' private static final BulkOperationPackedSingleBlock%d packedSingleBlock%d = new BulkOperationPackedSingleBlock%d();\n' % (bpv, bpv, bpv))
+
f.write(" public static BulkOperation of(PackedInts.Format format, int bitsPerValue) {\n")
f.write(" switch (format) {\n")
@@ -426,7 +443,7 @@ if __name__ == '__main__':
f.write(" switch (bitsPerValue) {\n")
for i in xrange(1, 65):
f.write(" case %d:\n" %i)
- f.write(" return PACKED_%d;\n" %i)
+ f.write(" return packed%d;\n" %i)
f.write(" default:\n")
f.write(" throw new AssertionError();\n")
f.write(" }\n")
@@ -434,7 +451,7 @@ if __name__ == '__main__':
f.write(" switch (bitsPerValue) {\n")
for i in PACKED_64_SINGLE_BLOCK_BPV:
f.write(" case %d:\n" %i)
- f.write(" return PACKED_SINGLE_BLOCK_%d;\n" %i)
+ f.write(" return packedSingleBlock%d;\n" %i)
f.write(" default:\n")
f.write(" throw new AssertionError();\n")
f.write(" }\n")