This is an automated email from the ASF dual-hosted git repository.
garydgregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-compress.git
The following commit(s) were added to refs/heads/master by this push:
new a1889445a Normalize spelling.
a1889445a is described below
commit a1889445ad822d27f46f0f050ecc20e373d1496f
Author: Gary Gregory <[email protected]>
AuthorDate: Tue Jul 7 07:02:15 2026 -0400
Normalize spelling.
---
.../commons/compress/harmony/pack200/BandSet.java | 50 +++++++-------
.../compress/harmony/pack200/CodecEncoding.java | 22 +++----
.../compress/harmony/pack200/PopulationCodec.java | 76 +++++++++++-----------
.../commons/compress/harmony/pack200/RunCodec.java | 8 +--
.../compress/harmony/unpack200/BandSet.java | 8 +--
5 files changed, 82 insertions(+), 82 deletions(-)
diff --git
a/src/main/java/org/apache/commons/compress/harmony/pack200/BandSet.java
b/src/main/java/org/apache/commons/compress/harmony/pack200/BandSet.java
index 92cf9fa71..ad4fcd0ea 100644
--- a/src/main/java/org/apache/commons/compress/harmony/pack200/BandSet.java
+++ b/src/main/java/org/apache/commons/compress/harmony/pack200/BandSet.java
@@ -551,24 +551,24 @@ private void encodeWithPopulationCodec(final int[] band,
final BHSDCodec default
favoredToIndex.put(favored.get(i), Integer.valueOf(i));
}
- final IntList unfavoured = new IntList();
+ final IntList unfavored = new IntList();
final int[] tokens = new int[band.length];
for (int i = 0; i < band.length; i++) {
- final Integer favouredIndex =
favoredToIndex.get(Integer.valueOf(band[i]));
- if (favouredIndex == null) {
+ final Integer favoredIndex =
favoredToIndex.get(Integer.valueOf(band[i]));
+ if (favoredIndex == null) {
tokens[i] = 0;
- unfavoured.add(band[i]);
+ unfavored.add(band[i]);
} else {
- tokens[i] = favouredIndex.intValue() + 1;
+ tokens[i] = favoredIndex.intValue() + 1;
}
}
favored.add(favored.get(favored.size() - 1)); // repeat last value
- final int[] favouredBand = integerListToArray(favored);
- final int[] unfavouredBand = unfavoured.toArray();
+ final int[] favoredBand = integerListToArray(favored);
+ final int[] unfavoredBand = unfavored.toArray();
// Analyse the three bands to get the best codec
- final BandAnalysisResults favouredResults = analyzeBand("POPULATION",
favouredBand, defaultCodec);
- final BandAnalysisResults unfavouredResults =
analyzeBand("POPULATION", unfavouredBand, defaultCodec);
+ final BandAnalysisResults favoredResults = analyzeBand("POPULATION",
favoredBand, defaultCodec);
+ final BandAnalysisResults unfavoredResults = analyzeBand("POPULATION",
unfavoredBand, defaultCodec);
int tdefL = 0;
int l = 0;
@@ -638,21 +638,21 @@ private void encodeWithPopulationCodec(final int[] band,
final BHSDCodec default
}
}
- final byte[] favouredEncoded = favouredResults.encodedBand;
- final byte[] unfavouredEncoded = unfavouredResults.encodedBand;
- final Codec favouredCodec = favouredResults.betterCodec;
- final Codec unfavouredCodec = unfavouredResults.betterCodec;
+ final byte[] favoredEncoded = favoredResults.encodedBand;
+ final byte[] unfavoredEncoded = unfavoredResults.encodedBand;
+ final Codec favoredCodec = favoredResults.betterCodec;
+ final Codec unfavoredCodec = unfavoredResults.betterCodec;
- int specifier = 141 + (favouredCodec == null ? 1 : 0) + 4 * tdefL +
(unfavouredCodec == null ? 2 : 0);
+ int specifier = 141 + (favoredCodec == null ? 1 : 0) + 4 * tdefL +
(unfavoredCodec == null ? 2 : 0);
final IntList extraBandMetadata = new IntList(3);
- if (favouredCodec != null) {
- IntStream.of(CodecEncoding.getSpecifier(favouredCodec,
null)).forEach(extraBandMetadata::add);
+ if (favoredCodec != null) {
+ IntStream.of(CodecEncoding.getSpecifier(favoredCodec,
null)).forEach(extraBandMetadata::add);
}
if (tdefL == 0) {
IntStream.of(CodecEncoding.getSpecifier(tokenCodec,
null)).forEach(extraBandMetadata::add);
}
- if (unfavouredCodec != null) {
- IntStream.of(CodecEncoding.getSpecifier(unfavouredCodec,
null)).forEach(extraBandMetadata::add);
+ if (unfavoredCodec != null) {
+ IntStream.of(CodecEncoding.getSpecifier(unfavoredCodec,
null)).forEach(extraBandMetadata::add);
}
final int[] extraMetadata = extraBandMetadata.toArray();
final byte[] extraMetadataEncoded =
Codec.UNSIGNED5.encode(extraMetadata);
@@ -662,22 +662,22 @@ private void encodeWithPopulationCodec(final int[] band,
final BHSDCodec default
specifier += defaultCodec.getL();
}
final byte[] firstValueEncoded = defaultCodec.encode(new int[] {
specifier });
- final int totalBandLength = firstValueEncoded.length +
favouredEncoded.length + tokensEncoded.length + unfavouredEncoded.length;
+ final int totalBandLength = firstValueEncoded.length +
favoredEncoded.length + tokensEncoded.length + unfavoredEncoded.length;
if (totalBandLength + extraMetadataEncoded.length <
results.encodedBand.length) {
results.saved += results.encodedBand.length - (totalBandLength +
extraMetadataEncoded.length);
final byte[] encodedBand = new byte[totalBandLength];
System.arraycopy(firstValueEncoded, 0, encodedBand, 0,
firstValueEncoded.length);
- System.arraycopy(favouredEncoded, 0, encodedBand,
firstValueEncoded.length, favouredEncoded.length);
- System.arraycopy(tokensEncoded, 0, encodedBand,
firstValueEncoded.length + favouredEncoded.length, tokensEncoded.length);
- System.arraycopy(unfavouredEncoded, 0, encodedBand,
firstValueEncoded.length + favouredEncoded.length + tokensEncoded.length,
- unfavouredEncoded.length);
+ System.arraycopy(favoredEncoded, 0, encodedBand,
firstValueEncoded.length, favoredEncoded.length);
+ System.arraycopy(tokensEncoded, 0, encodedBand,
firstValueEncoded.length + favoredEncoded.length, tokensEncoded.length);
+ System.arraycopy(unfavoredEncoded, 0, encodedBand,
firstValueEncoded.length + favoredEncoded.length + tokensEncoded.length,
+ unfavoredEncoded.length);
results.encodedBand = encodedBand;
results.extraMetadata = extraMetadata;
if (l != 0) {
- results.betterCodec = new PopulationCodec(favouredCodec, l,
unfavouredCodec);
+ results.betterCodec = new PopulationCodec(favoredCodec, l,
unfavoredCodec);
} else {
- results.betterCodec = new PopulationCodec(favouredCodec,
tokenCodec, unfavouredCodec);
+ results.betterCodec = new PopulationCodec(favoredCodec,
tokenCodec, unfavoredCodec);
}
}
}
diff --git
a/src/main/java/org/apache/commons/compress/harmony/pack200/CodecEncoding.java
b/src/main/java/org/apache/commons/compress/harmony/pack200/CodecEncoding.java
index 849907ebd..5d2fd8750 100644
---
a/src/main/java/org/apache/commons/compress/harmony/pack200/CodecEncoding.java
+++
b/src/main/java/org/apache/commons/compress/harmony/pack200/CodecEncoding.java
@@ -254,13 +254,13 @@ public static int[] getSpecifier(final Codec codec, final
Codec defaultForBand)
if (codec instanceof PopulationCodec) {
final PopulationCodec populationCodec = (PopulationCodec) codec;
final Codec tokenCodec = populationCodec.getTokenCodec();
- final Codec favouredCodec = populationCodec.getFavouredCodec();
- final Codec unfavouredCodec = populationCodec.getUnfavouredCodec();
- final int fDef = favouredCodec.equals(defaultForBand) ? 1 : 0;
- final int uDef = unfavouredCodec.equals(defaultForBand) ? 1 : 0;
+ final Codec favoredCodec = populationCodec.getFavouredCodec();
+ final Codec unfavoredCodec = populationCodec.getUnfavouredCodec();
+ final int fDef = favoredCodec.equals(defaultForBand) ? 1 : 0;
+ final int uDef = unfavoredCodec.equals(defaultForBand) ? 1 : 0;
int tDefL = 0;
- final int[] favoured = populationCodec.getFavoured();
- if (favoured != null) {
+ final int[] favored = populationCodec.getFavoured();
+ if (favored != null) {
if (tokenCodec == Codec.BYTE1) {
tDefL = 1;
} else if (tokenCodec instanceof BHSDCodec) {
@@ -277,13 +277,13 @@ public static int[] getSpecifier(final Codec codec, final
Codec defaultForBand)
}
}
final int first = 141 + fDef + 2 * uDef + 4 * tDefL;
- final int[] favouredSpecifier = fDef == 1 ? EMPTY_INT_ARRAY :
getSpecifier(favouredCodec, defaultForBand);
+ final int[] favoredSpecifier = fDef == 1 ? EMPTY_INT_ARRAY :
getSpecifier(favoredCodec, defaultForBand);
final int[] tokenSpecifier = tDefL != 0 ? EMPTY_INT_ARRAY :
getSpecifier(tokenCodec, defaultForBand);
- final int[] unfavouredSpecifier = uDef == 1 ? EMPTY_INT_ARRAY :
getSpecifier(unfavouredCodec, defaultForBand);
- final int[] specifier = new int[1 + favouredSpecifier.length +
unfavouredSpecifier.length + tokenSpecifier.length];
+ final int[] unfavoredSpecifier = uDef == 1 ? EMPTY_INT_ARRAY :
getSpecifier(unfavoredCodec, defaultForBand);
+ final int[] specifier = new int[1 + favoredSpecifier.length +
unfavoredSpecifier.length + tokenSpecifier.length];
specifier[0] = first;
int index = 1;
- for (final int element : favouredSpecifier) {
+ for (final int element : favoredSpecifier) {
specifier[index] = element;
index++;
}
@@ -291,7 +291,7 @@ public static int[] getSpecifier(final Codec codec, final
Codec defaultForBand)
specifier[index] = element;
index++;
}
- for (final int element : unfavouredSpecifier) {
+ for (final int element : unfavoredSpecifier) {
specifier[index] = element;
index++;
}
diff --git
a/src/main/java/org/apache/commons/compress/harmony/pack200/PopulationCodec.java
b/src/main/java/org/apache/commons/compress/harmony/pack200/PopulationCodec.java
index e2f051c8d..1e451e799 100644
---
a/src/main/java/org/apache/commons/compress/harmony/pack200/PopulationCodec.java
+++
b/src/main/java/org/apache/commons/compress/harmony/pack200/PopulationCodec.java
@@ -30,39 +30,39 @@
*/
public class PopulationCodec extends Codec {
- private final Codec favouredCodec;
+ private final Codec favoredCodec;
private Codec tokenCodec;
- private final Codec unfavouredCodec;
+ private final Codec unfavoredCodec;
private int l;
- private int[] favoured;
+ private int[] favored;
/**
* Constructs a new PopulationCodec.
*
- * @param favouredCodec the favoured codec.
+ * @param favoredCodec the favored codec.
* @param tokenCodec the token codec.
- * @param unvafouredCodec the unfavoured codec.
+ * @param unvaforedCodec the unfavored codec.
*/
- public PopulationCodec(final Codec favouredCodec, final Codec tokenCodec,
final Codec unvafouredCodec) {
- this.favouredCodec = favouredCodec;
+ public PopulationCodec(final Codec favoredCodec, final Codec tokenCodec,
final Codec unvaforedCodec) {
+ this.favoredCodec = favoredCodec;
this.tokenCodec = tokenCodec;
- this.unfavouredCodec = unvafouredCodec;
+ this.unfavoredCodec = unvaforedCodec;
}
/**
* Constructs a new PopulationCodec.
*
- * @param favouredCodec the favoured codec.
+ * @param favoredCodec the favored codec.
* @param l the L value.
- * @param unfavouredCodec the unfavoured codec.
+ * @param unfavoredCodec the unfavored codec.
*/
- public PopulationCodec(final Codec favouredCodec, final int l, final Codec
unfavouredCodec) {
+ public PopulationCodec(final Codec favoredCodec, final int l, final Codec
unfavoredCodec) {
if (l >= 256 || l <= 0) {
throw new IllegalArgumentException("L must be between 1..255");
}
- this.favouredCodec = favouredCodec;
+ this.favoredCodec = favoredCodec;
this.l = l;
- this.unfavouredCodec = unfavouredCodec;
+ this.unfavoredCodec = unfavoredCodec;
}
@Override
@@ -78,7 +78,7 @@ public int decode(final InputStream in, final long last)
throws IOException, Pac
@Override
public int[] decodeInts(final int n, final InputStream in) throws
IOException, Pack200Exception {
lastBandLength = 0;
- favoured = new int[Pack200Exception.checkIntArray(check(n, in))]; //
there must be <= n values, but probably a lot
+ favored = new int[Pack200Exception.checkIntArray(check(n, in))]; //
there must be <= n values, but probably a lot
// less
final int[] result;
// read table of favorites first
@@ -89,11 +89,11 @@ public int[] decodeInts(final int n, final InputStream in)
throws IOException, P
int absoluteValue;
int k = -1;
while (true) {
- value = favouredCodec.decode(in, last);
+ value = favoredCodec.decode(in, last);
if (k > -1 && (value == smallest || value == last)) {
break;
}
- favoured[++k] = value;
+ favored[++k] = value;
absoluteSmallest = Math.abs(smallest);
absoluteValue = Math.abs(value);
if (absoluteSmallest > absoluteValue) {
@@ -132,9 +132,9 @@ public int[] decodeInts(final int n, final InputStream in)
throws IOException, P
final int index = result[i];
if (index == 0) {
lastBandLength++;
- result[i] = last = unfavouredCodec.decode(in, last);
+ result[i] = last = unfavoredCodec.decode(in, last);
} else {
- result[i] = favoured[index - 1];
+ result[i] = favored[index - 1];
}
}
return result;
@@ -153,41 +153,41 @@ public byte[] encode(final int value, final int last)
throws Pack200Exception {
/**
* Encodes the values.
*
- * @param favoured the favoured values.
+ * @param favored the favored values.
* @param tokens the tokens.
- * @param unfavoured the unfavoured values.
+ * @param unfavored the unfavored values.
* @return the encoded bytes.
* @throws Pack200Exception if an error occurs.
*/
- public byte[] encode(final int[] favoured, final int[] tokens, final int[]
unfavoured) throws Pack200Exception {
- final int[] favoured2 = Arrays.copyOf(favoured, favoured.length + 1);
- favoured2[favoured2.length - 1] = favoured[favoured.length - 1]; //
repeat last value;
- final byte[] favouredEncoded = favouredCodec.encode(favoured2);
+ public byte[] encode(final int[] favored, final int[] tokens, final int[]
unfavored) throws Pack200Exception {
+ final int[] favored2 = Arrays.copyOf(favored, favored.length + 1);
+ favored2[favored2.length - 1] = favored[favored.length - 1]; // repeat
last value;
+ final byte[] favoredEncoded = favoredCodec.encode(favored2);
final byte[] tokensEncoded = tokenCodec.encode(tokens);
- final byte[] unfavouredEncoded = unfavouredCodec.encode(unfavoured);
- final byte[] band = new byte[favouredEncoded.length +
tokensEncoded.length + unfavouredEncoded.length];
- System.arraycopy(favouredEncoded, 0, band, 0, favouredEncoded.length);
- System.arraycopy(tokensEncoded, 0, band, favouredEncoded.length,
tokensEncoded.length);
- System.arraycopy(unfavouredEncoded, 0, band, favouredEncoded.length +
tokensEncoded.length, unfavouredEncoded.length);
+ final byte[] unfavoredEncoded = unfavoredCodec.encode(unfavored);
+ final byte[] band = new byte[favoredEncoded.length +
tokensEncoded.length + unfavoredEncoded.length];
+ System.arraycopy(favoredEncoded, 0, band, 0, favoredEncoded.length);
+ System.arraycopy(tokensEncoded, 0, band, favoredEncoded.length,
tokensEncoded.length);
+ System.arraycopy(unfavoredEncoded, 0, band, favoredEncoded.length +
tokensEncoded.length, unfavoredEncoded.length);
return band;
}
/**
- * Gets the favoured values.
+ * Gets the favored values.
*
- * @return the favoured values.
+ * @return the favored values.
*/
public int[] getFavoured() {
- return favoured;
+ return favored;
}
/**
- * Gets the favoured codec.
+ * Gets the favored codec.
*
- * @return the favoured codec.
+ * @return the favored codec.
*/
public Codec getFavouredCodec() {
- return favouredCodec;
+ return favoredCodec;
}
/**
@@ -200,11 +200,11 @@ public Codec getTokenCodec() {
}
/**
- * Gets the unfavoured codec.
+ * Gets the unfavored codec.
*
- * @return the unfavoured codec.
+ * @return the unfavored codec.
*/
public Codec getUnfavouredCodec() {
- return unfavouredCodec;
+ return unfavoredCodec;
}
}
diff --git
a/src/main/java/org/apache/commons/compress/harmony/pack200/RunCodec.java
b/src/main/java/org/apache/commons/compress/harmony/pack200/RunCodec.java
index a1188fe3c..808317eb9 100644
--- a/src/main/java/org/apache/commons/compress/harmony/pack200/RunCodec.java
+++ b/src/main/java/org/apache/commons/compress/harmony/pack200/RunCodec.java
@@ -150,11 +150,11 @@ private void normalize(final int[] band, final Codec
codecUsed) throws Pack200Ex
}
} else if (codecUsed instanceof PopulationCodec) {
final PopulationCodec popCodec = (PopulationCodec) codecUsed;
- final int[] favoured = popCodec.getFavoured().clone();
- Arrays.sort(favoured);
+ final int[] favored = popCodec.getFavoured().clone();
+ Arrays.sort(favored);
for (int i = 0; i < band.length; i++) {
- final boolean favouredValue = Arrays.binarySearch(favoured,
band[i]) > -1;
- final Codec theCodec = favouredValue ?
popCodec.getFavouredCodec() : popCodec.getUnfavouredCodec();
+ final boolean favoredValue = Arrays.binarySearch(favored,
band[i]) > -1;
+ final Codec theCodec = favoredValue ?
popCodec.getFavouredCodec() : popCodec.getUnfavouredCodec();
if (theCodec instanceof BHSDCodec) {
final BHSDCodec bhsd = (BHSDCodec) theCodec;
if (bhsd.isDelta()) {
diff --git
a/src/main/java/org/apache/commons/compress/harmony/unpack200/BandSet.java
b/src/main/java/org/apache/commons/compress/harmony/unpack200/BandSet.java
index 1f8fe7381..7c6c387f1 100644
--- a/src/main/java/org/apache/commons/compress/harmony/unpack200/BandSet.java
+++ b/src/main/java/org/apache/commons/compress/harmony/unpack200/BandSet.java
@@ -115,11 +115,11 @@ public int[] decodeBandInt(final String name, final
InputStream in, final BHSDCo
// }
if (codecUsed instanceof PopulationCodec) {
final PopulationCodec popCodec = (PopulationCodec) codecUsed;
- final int[] favoured = popCodec.getFavoured().clone();
- Arrays.sort(favoured);
+ final int[] favored = popCodec.getFavoured().clone();
+ Arrays.sort(favored);
for (int i = 0; i < band.length; i++) {
- final boolean favouredValue = Arrays.binarySearch(favoured,
band[i]) > -1;
- final Codec theCodec = favouredValue ?
popCodec.getFavouredCodec() : popCodec.getUnfavouredCodec();
+ final boolean favoredValue = Arrays.binarySearch(favored,
band[i]) > -1;
+ final Codec theCodec = favoredValue ?
popCodec.getFavouredCodec() : popCodec.getUnfavouredCodec();
if (theCodec instanceof BHSDCodec && ((BHSDCodec)
theCodec).isDelta()) {
final BHSDCodec bhsd = (BHSDCodec) theCodec;
final long cardinality = bhsd.cardinality();
