| <!DOCTYPE HTML> |
| <html lang="en"> |
| <head> |
| <!-- Generated by javadoc (17) --> |
| <title>Source code</title> |
| <meta name="viewport" content="width=device-width, initial-scale=1"> |
| <meta name="description" content="source: package: org.apache.hadoop.hbase.util, class: Bytes, class: ByteArrayComparator"> |
| <meta name="generator" content="javadoc/SourceToHTMLConverter"> |
| <link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style"> |
| </head> |
| <body class="source-page"> |
| <main role="main"> |
| <div class="source-container"> |
| <pre><span class="source-line-no">001</span><span id="line-1">/*</span> |
| <span class="source-line-no">002</span><span id="line-2"> * Licensed to the Apache Software Foundation (ASF) under one</span> |
| <span class="source-line-no">003</span><span id="line-3"> * or more contributor license agreements. See the NOTICE file</span> |
| <span class="source-line-no">004</span><span id="line-4"> * distributed with this work for additional information</span> |
| <span class="source-line-no">005</span><span id="line-5"> * regarding copyright ownership. The ASF licenses this file</span> |
| <span class="source-line-no">006</span><span id="line-6"> * to you under the Apache License, Version 2.0 (the</span> |
| <span class="source-line-no">007</span><span id="line-7"> * "License"); you may not use this file except in compliance</span> |
| <span class="source-line-no">008</span><span id="line-8"> * with the License. You may obtain a copy of the License at</span> |
| <span class="source-line-no">009</span><span id="line-9"> *</span> |
| <span class="source-line-no">010</span><span id="line-10"> * http://www.apache.org/licenses/LICENSE-2.0</span> |
| <span class="source-line-no">011</span><span id="line-11"> *</span> |
| <span class="source-line-no">012</span><span id="line-12"> * Unless required by applicable law or agreed to in writing, software</span> |
| <span class="source-line-no">013</span><span id="line-13"> * distributed under the License is distributed on an "AS IS" BASIS,</span> |
| <span class="source-line-no">014</span><span id="line-14"> * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.</span> |
| <span class="source-line-no">015</span><span id="line-15"> * See the License for the specific language governing permissions and</span> |
| <span class="source-line-no">016</span><span id="line-16"> * limitations under the License.</span> |
| <span class="source-line-no">017</span><span id="line-17"> */</span> |
| <span class="source-line-no">018</span><span id="line-18">package org.apache.hadoop.hbase.util;</span> |
| <span class="source-line-no">019</span><span id="line-19"></span> |
| <span class="source-line-no">020</span><span id="line-20">import static org.apache.hbase.thirdparty.com.google.common.base.Preconditions.checkArgument;</span> |
| <span class="source-line-no">021</span><span id="line-21">import static org.apache.hbase.thirdparty.com.google.common.base.Preconditions.checkNotNull;</span> |
| <span class="source-line-no">022</span><span id="line-22">import static org.apache.hbase.thirdparty.com.google.common.base.Preconditions.checkPositionIndex;</span> |
| <span class="source-line-no">023</span><span id="line-23"></span> |
| <span class="source-line-no">024</span><span id="line-24">import java.io.DataInput;</span> |
| <span class="source-line-no">025</span><span id="line-25">import java.io.DataOutput;</span> |
| <span class="source-line-no">026</span><span id="line-26">import java.io.IOException;</span> |
| <span class="source-line-no">027</span><span id="line-27">import java.io.UnsupportedEncodingException;</span> |
| <span class="source-line-no">028</span><span id="line-28">import java.math.BigDecimal;</span> |
| <span class="source-line-no">029</span><span id="line-29">import java.math.BigInteger;</span> |
| <span class="source-line-no">030</span><span id="line-30">import java.nio.ByteBuffer;</span> |
| <span class="source-line-no">031</span><span id="line-31">import java.nio.charset.StandardCharsets;</span> |
| <span class="source-line-no">032</span><span id="line-32">import java.security.SecureRandom;</span> |
| <span class="source-line-no">033</span><span id="line-33">import java.util.ArrayList;</span> |
| <span class="source-line-no">034</span><span id="line-34">import java.util.Arrays;</span> |
| <span class="source-line-no">035</span><span id="line-35">import java.util.Collection;</span> |
| <span class="source-line-no">036</span><span id="line-36">import java.util.Collections;</span> |
| <span class="source-line-no">037</span><span id="line-37">import java.util.Comparator;</span> |
| <span class="source-line-no">038</span><span id="line-38">import java.util.Iterator;</span> |
| <span class="source-line-no">039</span><span id="line-39">import java.util.List;</span> |
| <span class="source-line-no">040</span><span id="line-40">import java.util.Random;</span> |
| <span class="source-line-no">041</span><span id="line-41">import org.apache.hadoop.hbase.Cell;</span> |
| <span class="source-line-no">042</span><span id="line-42">import org.apache.hadoop.hbase.CellComparator;</span> |
| <span class="source-line-no">043</span><span id="line-43">import org.apache.hadoop.hbase.unsafe.HBasePlatformDependent;</span> |
| <span class="source-line-no">044</span><span id="line-44">import org.apache.hadoop.io.RawComparator;</span> |
| <span class="source-line-no">045</span><span id="line-45">import org.apache.hadoop.io.WritableComparator;</span> |
| <span class="source-line-no">046</span><span id="line-46">import org.apache.hadoop.io.WritableUtils;</span> |
| <span class="source-line-no">047</span><span id="line-47">import org.apache.yetus.audience.InterfaceAudience;</span> |
| <span class="source-line-no">048</span><span id="line-48">import org.slf4j.Logger;</span> |
| <span class="source-line-no">049</span><span id="line-49">import org.slf4j.LoggerFactory;</span> |
| <span class="source-line-no">050</span><span id="line-50"></span> |
| <span class="source-line-no">051</span><span id="line-51">import org.apache.hbase.thirdparty.org.apache.commons.collections4.CollectionUtils;</span> |
| <span class="source-line-no">052</span><span id="line-52"></span> |
| <span class="source-line-no">053</span><span id="line-53">/**</span> |
| <span class="source-line-no">054</span><span id="line-54"> * Utility class that handles byte arrays, conversions to/from other types, comparisons, hash code</span> |
| <span class="source-line-no">055</span><span id="line-55"> * generation, manufacturing keys for HashMaps or HashSets, and can be used as key in maps or trees.</span> |
| <span class="source-line-no">056</span><span id="line-56"> */</span> |
| <span class="source-line-no">057</span><span id="line-57">@InterfaceAudience.Public</span> |
| <span class="source-line-no">058</span><span id="line-58">@edu.umd.cs.findbugs.annotations.SuppressWarnings(</span> |
| <span class="source-line-no">059</span><span id="line-59"> value = "EQ_CHECK_FOR_OPERAND_NOT_COMPATIBLE_WITH_THIS",</span> |
| <span class="source-line-no">060</span><span id="line-60"> justification = "It has been like this forever")</span> |
| <span class="source-line-no">061</span><span id="line-61">@SuppressWarnings("MixedMutabilityReturnType")</span> |
| <span class="source-line-no">062</span><span id="line-62">public class Bytes implements Comparable<Bytes> {</span> |
| <span class="source-line-no">063</span><span id="line-63"></span> |
| <span class="source-line-no">064</span><span id="line-64"> // Using the charset canonical name for String/byte[] conversions is much</span> |
| <span class="source-line-no">065</span><span id="line-65"> // more efficient due to use of cached encoders/decoders.</span> |
| <span class="source-line-no">066</span><span id="line-66"> private static final String UTF8_CSN = StandardCharsets.UTF_8.name();</span> |
| <span class="source-line-no">067</span><span id="line-67"></span> |
| <span class="source-line-no">068</span><span id="line-68"> // HConstants.EMPTY_BYTE_ARRAY should be updated if this changed</span> |
| <span class="source-line-no">069</span><span id="line-69"> private static final byte[] EMPTY_BYTE_ARRAY = new byte[0];</span> |
| <span class="source-line-no">070</span><span id="line-70"></span> |
| <span class="source-line-no">071</span><span id="line-71"> private static final Logger LOG = LoggerFactory.getLogger(Bytes.class);</span> |
| <span class="source-line-no">072</span><span id="line-72"></span> |
| <span class="source-line-no">073</span><span id="line-73"> /**</span> |
| <span class="source-line-no">074</span><span id="line-74"> * Size of boolean in bytes</span> |
| <span class="source-line-no">075</span><span id="line-75"> */</span> |
| <span class="source-line-no">076</span><span id="line-76"> public static final int SIZEOF_BOOLEAN = Byte.SIZE / Byte.SIZE;</span> |
| <span class="source-line-no">077</span><span id="line-77"></span> |
| <span class="source-line-no">078</span><span id="line-78"> /**</span> |
| <span class="source-line-no">079</span><span id="line-79"> * Size of byte in bytes</span> |
| <span class="source-line-no">080</span><span id="line-80"> */</span> |
| <span class="source-line-no">081</span><span id="line-81"> public static final int SIZEOF_BYTE = SIZEOF_BOOLEAN;</span> |
| <span class="source-line-no">082</span><span id="line-82"></span> |
| <span class="source-line-no">083</span><span id="line-83"> /**</span> |
| <span class="source-line-no">084</span><span id="line-84"> * Size of char in bytes</span> |
| <span class="source-line-no">085</span><span id="line-85"> */</span> |
| <span class="source-line-no">086</span><span id="line-86"> public static final int SIZEOF_CHAR = Character.SIZE / Byte.SIZE;</span> |
| <span class="source-line-no">087</span><span id="line-87"></span> |
| <span class="source-line-no">088</span><span id="line-88"> /**</span> |
| <span class="source-line-no">089</span><span id="line-89"> * Size of double in bytes</span> |
| <span class="source-line-no">090</span><span id="line-90"> */</span> |
| <span class="source-line-no">091</span><span id="line-91"> public static final int SIZEOF_DOUBLE = Double.SIZE / Byte.SIZE;</span> |
| <span class="source-line-no">092</span><span id="line-92"></span> |
| <span class="source-line-no">093</span><span id="line-93"> /**</span> |
| <span class="source-line-no">094</span><span id="line-94"> * Size of float in bytes</span> |
| <span class="source-line-no">095</span><span id="line-95"> */</span> |
| <span class="source-line-no">096</span><span id="line-96"> public static final int SIZEOF_FLOAT = Float.SIZE / Byte.SIZE;</span> |
| <span class="source-line-no">097</span><span id="line-97"></span> |
| <span class="source-line-no">098</span><span id="line-98"> /**</span> |
| <span class="source-line-no">099</span><span id="line-99"> * Size of int in bytes</span> |
| <span class="source-line-no">100</span><span id="line-100"> */</span> |
| <span class="source-line-no">101</span><span id="line-101"> public static final int SIZEOF_INT = Integer.SIZE / Byte.SIZE;</span> |
| <span class="source-line-no">102</span><span id="line-102"></span> |
| <span class="source-line-no">103</span><span id="line-103"> /**</span> |
| <span class="source-line-no">104</span><span id="line-104"> * Size of long in bytes</span> |
| <span class="source-line-no">105</span><span id="line-105"> */</span> |
| <span class="source-line-no">106</span><span id="line-106"> public static final int SIZEOF_LONG = Long.SIZE / Byte.SIZE;</span> |
| <span class="source-line-no">107</span><span id="line-107"></span> |
| <span class="source-line-no">108</span><span id="line-108"> /**</span> |
| <span class="source-line-no">109</span><span id="line-109"> * Size of short in bytes</span> |
| <span class="source-line-no">110</span><span id="line-110"> */</span> |
| <span class="source-line-no">111</span><span id="line-111"> public static final int SIZEOF_SHORT = Short.SIZE / Byte.SIZE;</span> |
| <span class="source-line-no">112</span><span id="line-112"></span> |
| <span class="source-line-no">113</span><span id="line-113"> /**</span> |
| <span class="source-line-no">114</span><span id="line-114"> * Mask to apply to a long to reveal the lower int only. Use like this: int i =</span> |
| <span class="source-line-no">115</span><span id="line-115"> * (int)(0xFFFFFFFF00000000L ^ some_long_value);</span> |
| <span class="source-line-no">116</span><span id="line-116"> */</span> |
| <span class="source-line-no">117</span><span id="line-117"> public static final long MASK_FOR_LOWER_INT_IN_LONG = 0xFFFFFFFF00000000L;</span> |
| <span class="source-line-no">118</span><span id="line-118"></span> |
| <span class="source-line-no">119</span><span id="line-119"> /**</span> |
| <span class="source-line-no">120</span><span id="line-120"> * Estimate of size cost to pay beyond payload in jvm for instance of byte []. Estimate based on</span> |
| <span class="source-line-no">121</span><span id="line-121"> * study of jhat and jprofiler numbers.</span> |
| <span class="source-line-no">122</span><span id="line-122"> */</span> |
| <span class="source-line-no">123</span><span id="line-123"> // JHat says BU is 56 bytes.</span> |
| <span class="source-line-no">124</span><span id="line-124"> // SizeOf which uses java.lang.instrument says 24 bytes. (3 longs?)</span> |
| <span class="source-line-no">125</span><span id="line-125"> public static final int ESTIMATED_HEAP_TAX = 16;</span> |
| <span class="source-line-no">126</span><span id="line-126"></span> |
| <span class="source-line-no">127</span><span id="line-127"> static final boolean UNSAFE_UNALIGNED = HBasePlatformDependent.unaligned();</span> |
| <span class="source-line-no">128</span><span id="line-128"></span> |
| <span class="source-line-no">129</span><span id="line-129"> /**</span> |
| <span class="source-line-no">130</span><span id="line-130"> * Returns length of the byte array, returning 0 if the array is null. Useful for calculating</span> |
| <span class="source-line-no">131</span><span id="line-131"> * sizes.</span> |
| <span class="source-line-no">132</span><span id="line-132"> * @param b byte array, which can be null</span> |
| <span class="source-line-no">133</span><span id="line-133"> * @return 0 if b is null, otherwise returns length</span> |
| <span class="source-line-no">134</span><span id="line-134"> */</span> |
| <span class="source-line-no">135</span><span id="line-135"> final public static int len(byte[] b) {</span> |
| <span class="source-line-no">136</span><span id="line-136"> return b == null ? 0 : b.length;</span> |
| <span class="source-line-no">137</span><span id="line-137"> }</span> |
| <span class="source-line-no">138</span><span id="line-138"></span> |
| <span class="source-line-no">139</span><span id="line-139"> private byte[] bytes;</span> |
| <span class="source-line-no">140</span><span id="line-140"> private int offset;</span> |
| <span class="source-line-no">141</span><span id="line-141"> private int length;</span> |
| <span class="source-line-no">142</span><span id="line-142"></span> |
| <span class="source-line-no">143</span><span id="line-143"> /**</span> |
| <span class="source-line-no">144</span><span id="line-144"> * Create a zero-size sequence.</span> |
| <span class="source-line-no">145</span><span id="line-145"> */</span> |
| <span class="source-line-no">146</span><span id="line-146"> public Bytes() {</span> |
| <span class="source-line-no">147</span><span id="line-147"> super();</span> |
| <span class="source-line-no">148</span><span id="line-148"> }</span> |
| <span class="source-line-no">149</span><span id="line-149"></span> |
| <span class="source-line-no">150</span><span id="line-150"> /**</span> |
| <span class="source-line-no">151</span><span id="line-151"> * Create a Bytes using the byte array as the initial value.</span> |
| <span class="source-line-no">152</span><span id="line-152"> * @param bytes This array becomes the backing storage for the object.</span> |
| <span class="source-line-no">153</span><span id="line-153"> */</span> |
| <span class="source-line-no">154</span><span id="line-154"> public Bytes(byte[] bytes) {</span> |
| <span class="source-line-no">155</span><span id="line-155"> this(bytes, 0, bytes.length);</span> |
| <span class="source-line-no">156</span><span id="line-156"> }</span> |
| <span class="source-line-no">157</span><span id="line-157"></span> |
| <span class="source-line-no">158</span><span id="line-158"> /**</span> |
| <span class="source-line-no">159</span><span id="line-159"> * Set the new Bytes to the contents of the passed <code>ibw</code>.</span> |
| <span class="source-line-no">160</span><span id="line-160"> * @param ibw the value to set this Bytes to.</span> |
| <span class="source-line-no">161</span><span id="line-161"> */</span> |
| <span class="source-line-no">162</span><span id="line-162"> public Bytes(final Bytes ibw) {</span> |
| <span class="source-line-no">163</span><span id="line-163"> this(ibw.get(), ibw.getOffset(), ibw.getLength());</span> |
| <span class="source-line-no">164</span><span id="line-164"> }</span> |
| <span class="source-line-no">165</span><span id="line-165"></span> |
| <span class="source-line-no">166</span><span id="line-166"> /**</span> |
| <span class="source-line-no">167</span><span id="line-167"> * Set the value to a given byte range</span> |
| <span class="source-line-no">168</span><span id="line-168"> * @param bytes the new byte range to set to</span> |
| <span class="source-line-no">169</span><span id="line-169"> * @param offset the offset in newData to start at</span> |
| <span class="source-line-no">170</span><span id="line-170"> * @param length the number of bytes in the range</span> |
| <span class="source-line-no">171</span><span id="line-171"> */</span> |
| <span class="source-line-no">172</span><span id="line-172"> public Bytes(final byte[] bytes, final int offset, final int length) {</span> |
| <span class="source-line-no">173</span><span id="line-173"> this.bytes = bytes;</span> |
| <span class="source-line-no">174</span><span id="line-174"> this.offset = offset;</span> |
| <span class="source-line-no">175</span><span id="line-175"> this.length = length;</span> |
| <span class="source-line-no">176</span><span id="line-176"> }</span> |
| <span class="source-line-no">177</span><span id="line-177"></span> |
| <span class="source-line-no">178</span><span id="line-178"> /**</span> |
| <span class="source-line-no">179</span><span id="line-179"> * Get the data from the Bytes.</span> |
| <span class="source-line-no">180</span><span id="line-180"> * @return The data is only valid between offset and offset+length.</span> |
| <span class="source-line-no">181</span><span id="line-181"> */</span> |
| <span class="source-line-no">182</span><span id="line-182"> public byte[] get() {</span> |
| <span class="source-line-no">183</span><span id="line-183"> if (this.bytes == null) {</span> |
| <span class="source-line-no">184</span><span id="line-184"> throw new IllegalStateException(</span> |
| <span class="source-line-no">185</span><span id="line-185"> "Uninitialiized. Null constructor " + "called w/o accompaying readFields invocation");</span> |
| <span class="source-line-no">186</span><span id="line-186"> }</span> |
| <span class="source-line-no">187</span><span id="line-187"> return this.bytes;</span> |
| <span class="source-line-no">188</span><span id="line-188"> }</span> |
| <span class="source-line-no">189</span><span id="line-189"></span> |
| <span class="source-line-no">190</span><span id="line-190"> /** Use passed bytes as backing array for this instance. */</span> |
| <span class="source-line-no">191</span><span id="line-191"> public void set(final byte[] b) {</span> |
| <span class="source-line-no">192</span><span id="line-192"> set(b, 0, b.length);</span> |
| <span class="source-line-no">193</span><span id="line-193"> }</span> |
| <span class="source-line-no">194</span><span id="line-194"></span> |
| <span class="source-line-no">195</span><span id="line-195"> /** Use passed bytes as backing array for this instance. */</span> |
| <span class="source-line-no">196</span><span id="line-196"> public void set(final byte[] b, final int offset, final int length) {</span> |
| <span class="source-line-no">197</span><span id="line-197"> this.bytes = b;</span> |
| <span class="source-line-no">198</span><span id="line-198"> this.offset = offset;</span> |
| <span class="source-line-no">199</span><span id="line-199"> this.length = length;</span> |
| <span class="source-line-no">200</span><span id="line-200"> }</span> |
| <span class="source-line-no">201</span><span id="line-201"></span> |
| <span class="source-line-no">202</span><span id="line-202"> /** Returns the number of valid bytes in the buffer */</span> |
| <span class="source-line-no">203</span><span id="line-203"> public int getLength() {</span> |
| <span class="source-line-no">204</span><span id="line-204"> if (this.bytes == null) {</span> |
| <span class="source-line-no">205</span><span id="line-205"> throw new IllegalStateException(</span> |
| <span class="source-line-no">206</span><span id="line-206"> "Uninitialiized. Null constructor " + "called w/o accompaying readFields invocation");</span> |
| <span class="source-line-no">207</span><span id="line-207"> }</span> |
| <span class="source-line-no">208</span><span id="line-208"> return this.length;</span> |
| <span class="source-line-no">209</span><span id="line-209"> }</span> |
| <span class="source-line-no">210</span><span id="line-210"></span> |
| <span class="source-line-no">211</span><span id="line-211"> /** Return the offset into the buffer. */</span> |
| <span class="source-line-no">212</span><span id="line-212"> public int getOffset() {</span> |
| <span class="source-line-no">213</span><span id="line-213"> return this.offset;</span> |
| <span class="source-line-no">214</span><span id="line-214"> }</span> |
| <span class="source-line-no">215</span><span id="line-215"></span> |
| <span class="source-line-no">216</span><span id="line-216"> @Override</span> |
| <span class="source-line-no">217</span><span id="line-217"> public int hashCode() {</span> |
| <span class="source-line-no">218</span><span id="line-218"> return Bytes.hashCode(bytes, offset, length);</span> |
| <span class="source-line-no">219</span><span id="line-219"> }</span> |
| <span class="source-line-no">220</span><span id="line-220"></span> |
| <span class="source-line-no">221</span><span id="line-221"> /**</span> |
| <span class="source-line-no">222</span><span id="line-222"> * Define the sort order of the Bytes.</span> |
| <span class="source-line-no">223</span><span id="line-223"> * @param that The other bytes writable</span> |
| <span class="source-line-no">224</span><span id="line-224"> * @return Positive if left is bigger than right, 0 if they are equal, and negative if left is</span> |
| <span class="source-line-no">225</span><span id="line-225"> * smaller than right.</span> |
| <span class="source-line-no">226</span><span id="line-226"> */</span> |
| <span class="source-line-no">227</span><span id="line-227"> @Override</span> |
| <span class="source-line-no">228</span><span id="line-228"> public int compareTo(Bytes that) {</span> |
| <span class="source-line-no">229</span><span id="line-229"> return BYTES_RAWCOMPARATOR.compare(this.bytes, this.offset, this.length, that.bytes,</span> |
| <span class="source-line-no">230</span><span id="line-230"> that.offset, that.length);</span> |
| <span class="source-line-no">231</span><span id="line-231"> }</span> |
| <span class="source-line-no">232</span><span id="line-232"></span> |
| <span class="source-line-no">233</span><span id="line-233"> /**</span> |
| <span class="source-line-no">234</span><span id="line-234"> * Compares the bytes in this object to the specified byte array</span> |
| <span class="source-line-no">235</span><span id="line-235"> * @return Positive if left is bigger than right, 0 if they are equal, and negative if left is</span> |
| <span class="source-line-no">236</span><span id="line-236"> * smaller than right.</span> |
| <span class="source-line-no">237</span><span id="line-237"> */</span> |
| <span class="source-line-no">238</span><span id="line-238"> public int compareTo(final byte[] that) {</span> |
| <span class="source-line-no">239</span><span id="line-239"> return BYTES_RAWCOMPARATOR.compare(this.bytes, this.offset, this.length, that, 0, that.length);</span> |
| <span class="source-line-no">240</span><span id="line-240"> }</span> |
| <span class="source-line-no">241</span><span id="line-241"></span> |
| <span class="source-line-no">242</span><span id="line-242"> @Override</span> |
| <span class="source-line-no">243</span><span id="line-243"> public boolean equals(Object right_obj) {</span> |
| <span class="source-line-no">244</span><span id="line-244"> if (right_obj instanceof byte[]) {</span> |
| <span class="source-line-no">245</span><span id="line-245"> return compareTo((byte[]) right_obj) == 0;</span> |
| <span class="source-line-no">246</span><span id="line-246"> }</span> |
| <span class="source-line-no">247</span><span id="line-247"> if (right_obj instanceof Bytes) {</span> |
| <span class="source-line-no">248</span><span id="line-248"> return compareTo((Bytes) right_obj) == 0;</span> |
| <span class="source-line-no">249</span><span id="line-249"> }</span> |
| <span class="source-line-no">250</span><span id="line-250"> return false;</span> |
| <span class="source-line-no">251</span><span id="line-251"> }</span> |
| <span class="source-line-no">252</span><span id="line-252"></span> |
| <span class="source-line-no">253</span><span id="line-253"> @Override</span> |
| <span class="source-line-no">254</span><span id="line-254"> public String toString() {</span> |
| <span class="source-line-no">255</span><span id="line-255"> return Bytes.toString(bytes, offset, length);</span> |
| <span class="source-line-no">256</span><span id="line-256"> }</span> |
| <span class="source-line-no">257</span><span id="line-257"></span> |
| <span class="source-line-no">258</span><span id="line-258"> /**</span> |
| <span class="source-line-no">259</span><span id="line-259"> * Convert a list of byte[] to an array</span> |
| <span class="source-line-no">260</span><span id="line-260"> * @param array List of byte [].</span> |
| <span class="source-line-no">261</span><span id="line-261"> * @return Array of byte [].</span> |
| <span class="source-line-no">262</span><span id="line-262"> */</span> |
| <span class="source-line-no">263</span><span id="line-263"> public static byte[][] toArray(final List<byte[]> array) {</span> |
| <span class="source-line-no">264</span><span id="line-264"> // List#toArray doesn't work on lists of byte [].</span> |
| <span class="source-line-no">265</span><span id="line-265"> byte[][] results = new byte[array.size()][];</span> |
| <span class="source-line-no">266</span><span id="line-266"> for (int i = 0; i < array.size(); i++) {</span> |
| <span class="source-line-no">267</span><span id="line-267"> results[i] = array.get(i);</span> |
| <span class="source-line-no">268</span><span id="line-268"> }</span> |
| <span class="source-line-no">269</span><span id="line-269"> return results;</span> |
| <span class="source-line-no">270</span><span id="line-270"> }</span> |
| <span class="source-line-no">271</span><span id="line-271"></span> |
| <span class="source-line-no">272</span><span id="line-272"> /** Returns a copy of the bytes referred to by this writable */</span> |
| <span class="source-line-no">273</span><span id="line-273"> public byte[] copyBytes() {</span> |
| <span class="source-line-no">274</span><span id="line-274"> return Arrays.copyOfRange(bytes, offset, offset + length);</span> |
| <span class="source-line-no">275</span><span id="line-275"> }</span> |
| <span class="source-line-no">276</span><span id="line-276"></span> |
| <span class="source-line-no">277</span><span id="line-277"> /** Byte array comparator class. */</span> |
| <span class="source-line-no">278</span><span id="line-278"> @InterfaceAudience.Public</span> |
| <span class="source-line-no">279</span><span id="line-279"> public static class ByteArrayComparator implements RawComparator<byte[]> {</span> |
| <span class="source-line-no">280</span><span id="line-280"></span> |
| <span class="source-line-no">281</span><span id="line-281"> public ByteArrayComparator() {</span> |
| <span class="source-line-no">282</span><span id="line-282"> super();</span> |
| <span class="source-line-no">283</span><span id="line-283"> }</span> |
| <span class="source-line-no">284</span><span id="line-284"></span> |
| <span class="source-line-no">285</span><span id="line-285"> @Override</span> |
| <span class="source-line-no">286</span><span id="line-286"> public int compare(byte[] left, byte[] right) {</span> |
| <span class="source-line-no">287</span><span id="line-287"> return compareTo(left, right);</span> |
| <span class="source-line-no">288</span><span id="line-288"> }</span> |
| <span class="source-line-no">289</span><span id="line-289"></span> |
| <span class="source-line-no">290</span><span id="line-290"> @Override</span> |
| <span class="source-line-no">291</span><span id="line-291"> public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) {</span> |
| <span class="source-line-no">292</span><span id="line-292"> return LexicographicalComparerHolder.BEST_COMPARER.compareTo(b1, s1, l1, b2, s2, l2);</span> |
| <span class="source-line-no">293</span><span id="line-293"> }</span> |
| <span class="source-line-no">294</span><span id="line-294"> }</span> |
| <span class="source-line-no">295</span><span id="line-295"></span> |
| <span class="source-line-no">296</span><span id="line-296"> /**</span> |
| <span class="source-line-no">297</span><span id="line-297"> * A {@link ByteArrayComparator} that treats the empty array as the largest value. This is useful</span> |
| <span class="source-line-no">298</span><span id="line-298"> * for comparing row end keys for regions.</span> |
| <span class="source-line-no">299</span><span id="line-299"> */</span> |
| <span class="source-line-no">300</span><span id="line-300"> // TODO: unfortunately, HBase uses byte[0] as both start and end keys for region</span> |
| <span class="source-line-no">301</span><span id="line-301"> // boundaries. Thus semantically, we should treat empty byte array as the smallest value</span> |
| <span class="source-line-no">302</span><span id="line-302"> // while comparing row keys, start keys etc; but as the largest value for comparing</span> |
| <span class="source-line-no">303</span><span id="line-303"> // region boundaries for endKeys.</span> |
| <span class="source-line-no">304</span><span id="line-304"> @InterfaceAudience.Public</span> |
| <span class="source-line-no">305</span><span id="line-305"> public static class RowEndKeyComparator extends ByteArrayComparator {</span> |
| <span class="source-line-no">306</span><span id="line-306"> @Override</span> |
| <span class="source-line-no">307</span><span id="line-307"> public int compare(byte[] left, byte[] right) {</span> |
| <span class="source-line-no">308</span><span id="line-308"> return compare(left, 0, left.length, right, 0, right.length);</span> |
| <span class="source-line-no">309</span><span id="line-309"> }</span> |
| <span class="source-line-no">310</span><span id="line-310"></span> |
| <span class="source-line-no">311</span><span id="line-311"> @Override</span> |
| <span class="source-line-no">312</span><span id="line-312"> public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) {</span> |
| <span class="source-line-no">313</span><span id="line-313"> if (b1 == b2 && s1 == s2 && l1 == l2) {</span> |
| <span class="source-line-no">314</span><span id="line-314"> return 0;</span> |
| <span class="source-line-no">315</span><span id="line-315"> }</span> |
| <span class="source-line-no">316</span><span id="line-316"> if (l1 == 0) {</span> |
| <span class="source-line-no">317</span><span id="line-317"> return l2; // 0 or positive</span> |
| <span class="source-line-no">318</span><span id="line-318"> }</span> |
| <span class="source-line-no">319</span><span id="line-319"> if (l2 == 0) {</span> |
| <span class="source-line-no">320</span><span id="line-320"> return -1;</span> |
| <span class="source-line-no">321</span><span id="line-321"> }</span> |
| <span class="source-line-no">322</span><span id="line-322"> return super.compare(b1, s1, l1, b2, s2, l2);</span> |
| <span class="source-line-no">323</span><span id="line-323"> }</span> |
| <span class="source-line-no">324</span><span id="line-324"> }</span> |
| <span class="source-line-no">325</span><span id="line-325"></span> |
| <span class="source-line-no">326</span><span id="line-326"> /** Pass this to TreeMaps where byte [] are keys. */</span> |
| <span class="source-line-no">327</span><span id="line-327"> public final static Comparator<byte[]> BYTES_COMPARATOR = new ByteArrayComparator();</span> |
| <span class="source-line-no">328</span><span id="line-328"></span> |
| <span class="source-line-no">329</span><span id="line-329"> /** Use comparing byte arrays, byte-by-byte */</span> |
| <span class="source-line-no">330</span><span id="line-330"> public final static RawComparator<byte[]> BYTES_RAWCOMPARATOR = new ByteArrayComparator();</span> |
| <span class="source-line-no">331</span><span id="line-331"></span> |
| <span class="source-line-no">332</span><span id="line-332"> /**</span> |
| <span class="source-line-no">333</span><span id="line-333"> * Read byte-array written with a WritableableUtils.vint prefix.</span> |
| <span class="source-line-no">334</span><span id="line-334"> * @param in Input to read from.</span> |
| <span class="source-line-no">335</span><span id="line-335"> * @return byte array read off <code>in</code></span> |
| <span class="source-line-no">336</span><span id="line-336"> * @throws IOException e</span> |
| <span class="source-line-no">337</span><span id="line-337"> */</span> |
| <span class="source-line-no">338</span><span id="line-338"> public static byte[] readByteArray(final DataInput in) throws IOException {</span> |
| <span class="source-line-no">339</span><span id="line-339"> int len = WritableUtils.readVInt(in);</span> |
| <span class="source-line-no">340</span><span id="line-340"> if (len < 0) {</span> |
| <span class="source-line-no">341</span><span id="line-341"> throw new NegativeArraySizeException(Integer.toString(len));</span> |
| <span class="source-line-no">342</span><span id="line-342"> }</span> |
| <span class="source-line-no">343</span><span id="line-343"> byte[] result = new byte[len];</span> |
| <span class="source-line-no">344</span><span id="line-344"> in.readFully(result, 0, len);</span> |
| <span class="source-line-no">345</span><span id="line-345"> return result;</span> |
| <span class="source-line-no">346</span><span id="line-346"> }</span> |
| <span class="source-line-no">347</span><span id="line-347"></span> |
| <span class="source-line-no">348</span><span id="line-348"> /**</span> |
| <span class="source-line-no">349</span><span id="line-349"> * Read byte-array written with a WritableableUtils.vint prefix. IOException is converted to a</span> |
| <span class="source-line-no">350</span><span id="line-350"> * RuntimeException.</span> |
| <span class="source-line-no">351</span><span id="line-351"> * @param in Input to read from.</span> |
| <span class="source-line-no">352</span><span id="line-352"> * @return byte array read off <code>in</code></span> |
| <span class="source-line-no">353</span><span id="line-353"> */</span> |
| <span class="source-line-no">354</span><span id="line-354"> public static byte[] readByteArrayThrowsRuntime(final DataInput in) {</span> |
| <span class="source-line-no">355</span><span id="line-355"> try {</span> |
| <span class="source-line-no">356</span><span id="line-356"> return readByteArray(in);</span> |
| <span class="source-line-no">357</span><span id="line-357"> } catch (Exception e) {</span> |
| <span class="source-line-no">358</span><span id="line-358"> throw new RuntimeException(e);</span> |
| <span class="source-line-no">359</span><span id="line-359"> }</span> |
| <span class="source-line-no">360</span><span id="line-360"> }</span> |
| <span class="source-line-no">361</span><span id="line-361"></span> |
| <span class="source-line-no">362</span><span id="line-362"> /**</span> |
| <span class="source-line-no">363</span><span id="line-363"> * Write byte-array with a WritableableUtils.vint prefix.</span> |
| <span class="source-line-no">364</span><span id="line-364"> * @param out output stream to be written to</span> |
| <span class="source-line-no">365</span><span id="line-365"> * @param b array to write</span> |
| <span class="source-line-no">366</span><span id="line-366"> * @throws IOException e</span> |
| <span class="source-line-no">367</span><span id="line-367"> */</span> |
| <span class="source-line-no">368</span><span id="line-368"> public static void writeByteArray(final DataOutput out, final byte[] b) throws IOException {</span> |
| <span class="source-line-no">369</span><span id="line-369"> if (b == null) {</span> |
| <span class="source-line-no">370</span><span id="line-370"> WritableUtils.writeVInt(out, 0);</span> |
| <span class="source-line-no">371</span><span id="line-371"> } else {</span> |
| <span class="source-line-no">372</span><span id="line-372"> writeByteArray(out, b, 0, b.length);</span> |
| <span class="source-line-no">373</span><span id="line-373"> }</span> |
| <span class="source-line-no">374</span><span id="line-374"> }</span> |
| <span class="source-line-no">375</span><span id="line-375"></span> |
| <span class="source-line-no">376</span><span id="line-376"> /**</span> |
| <span class="source-line-no">377</span><span id="line-377"> * Write byte-array to out with a vint length prefix.</span> |
| <span class="source-line-no">378</span><span id="line-378"> * @param out output stream</span> |
| <span class="source-line-no">379</span><span id="line-379"> * @param b array</span> |
| <span class="source-line-no">380</span><span id="line-380"> * @param offset offset into array</span> |
| <span class="source-line-no">381</span><span id="line-381"> * @param length length past offset</span> |
| <span class="source-line-no">382</span><span id="line-382"> * @throws IOException e</span> |
| <span class="source-line-no">383</span><span id="line-383"> */</span> |
| <span class="source-line-no">384</span><span id="line-384"> public static void writeByteArray(final DataOutput out, final byte[] b, final int offset,</span> |
| <span class="source-line-no">385</span><span id="line-385"> final int length) throws IOException {</span> |
| <span class="source-line-no">386</span><span id="line-386"> WritableUtils.writeVInt(out, length);</span> |
| <span class="source-line-no">387</span><span id="line-387"> out.write(b, offset, length);</span> |
| <span class="source-line-no">388</span><span id="line-388"> }</span> |
| <span class="source-line-no">389</span><span id="line-389"></span> |
| <span class="source-line-no">390</span><span id="line-390"> /**</span> |
| <span class="source-line-no">391</span><span id="line-391"> * Write byte-array from src to tgt with a vint length prefix.</span> |
| <span class="source-line-no">392</span><span id="line-392"> * @param tgt target array</span> |
| <span class="source-line-no">393</span><span id="line-393"> * @param tgtOffset offset into target array</span> |
| <span class="source-line-no">394</span><span id="line-394"> * @param src source array</span> |
| <span class="source-line-no">395</span><span id="line-395"> * @param srcOffset source offset</span> |
| <span class="source-line-no">396</span><span id="line-396"> * @param srcLength source length</span> |
| <span class="source-line-no">397</span><span id="line-397"> * @return New offset in src array.</span> |
| <span class="source-line-no">398</span><span id="line-398"> */</span> |
| <span class="source-line-no">399</span><span id="line-399"> public static int writeByteArray(final byte[] tgt, final int tgtOffset, final byte[] src,</span> |
| <span class="source-line-no">400</span><span id="line-400"> final int srcOffset, final int srcLength) {</span> |
| <span class="source-line-no">401</span><span id="line-401"> byte[] vint = vintToBytes(srcLength);</span> |
| <span class="source-line-no">402</span><span id="line-402"> System.arraycopy(vint, 0, tgt, tgtOffset, vint.length);</span> |
| <span class="source-line-no">403</span><span id="line-403"> int offset = tgtOffset + vint.length;</span> |
| <span class="source-line-no">404</span><span id="line-404"> System.arraycopy(src, srcOffset, tgt, offset, srcLength);</span> |
| <span class="source-line-no">405</span><span id="line-405"> return offset + srcLength;</span> |
| <span class="source-line-no">406</span><span id="line-406"> }</span> |
| <span class="source-line-no">407</span><span id="line-407"></span> |
| <span class="source-line-no">408</span><span id="line-408"> /**</span> |
| <span class="source-line-no">409</span><span id="line-409"> * Put bytes at the specified byte array position.</span> |
| <span class="source-line-no">410</span><span id="line-410"> * @param tgtBytes the byte array</span> |
| <span class="source-line-no">411</span><span id="line-411"> * @param tgtOffset position in the array</span> |
| <span class="source-line-no">412</span><span id="line-412"> * @param srcBytes array to write out</span> |
| <span class="source-line-no">413</span><span id="line-413"> * @param srcOffset source offset</span> |
| <span class="source-line-no">414</span><span id="line-414"> * @param srcLength source length</span> |
| <span class="source-line-no">415</span><span id="line-415"> * @return incremented offset</span> |
| <span class="source-line-no">416</span><span id="line-416"> */</span> |
| <span class="source-line-no">417</span><span id="line-417"> public static int putBytes(byte[] tgtBytes, int tgtOffset, byte[] srcBytes, int srcOffset,</span> |
| <span class="source-line-no">418</span><span id="line-418"> int srcLength) {</span> |
| <span class="source-line-no">419</span><span id="line-419"> System.arraycopy(srcBytes, srcOffset, tgtBytes, tgtOffset, srcLength);</span> |
| <span class="source-line-no">420</span><span id="line-420"> return tgtOffset + srcLength;</span> |
| <span class="source-line-no">421</span><span id="line-421"> }</span> |
| <span class="source-line-no">422</span><span id="line-422"></span> |
| <span class="source-line-no">423</span><span id="line-423"> /**</span> |
| <span class="source-line-no">424</span><span id="line-424"> * Write a single byte out to the specified byte array position.</span> |
| <span class="source-line-no">425</span><span id="line-425"> * @param bytes the byte array</span> |
| <span class="source-line-no">426</span><span id="line-426"> * @param offset position in the array</span> |
| <span class="source-line-no">427</span><span id="line-427"> * @param b byte to write out</span> |
| <span class="source-line-no">428</span><span id="line-428"> * @return incremented offset</span> |
| <span class="source-line-no">429</span><span id="line-429"> */</span> |
| <span class="source-line-no">430</span><span id="line-430"> public static int putByte(byte[] bytes, int offset, byte b) {</span> |
| <span class="source-line-no">431</span><span id="line-431"> bytes[offset] = b;</span> |
| <span class="source-line-no">432</span><span id="line-432"> return offset + 1;</span> |
| <span class="source-line-no">433</span><span id="line-433"> }</span> |
| <span class="source-line-no">434</span><span id="line-434"></span> |
| <span class="source-line-no">435</span><span id="line-435"> /**</span> |
| <span class="source-line-no">436</span><span id="line-436"> * Add the whole content of the ByteBuffer to the bytes arrays. The ByteBuffer is modified.</span> |
| <span class="source-line-no">437</span><span id="line-437"> * @param bytes the byte array</span> |
| <span class="source-line-no">438</span><span id="line-438"> * @param offset position in the array</span> |
| <span class="source-line-no">439</span><span id="line-439"> * @param buf ByteBuffer to write out</span> |
| <span class="source-line-no">440</span><span id="line-440"> * @return incremented offset</span> |
| <span class="source-line-no">441</span><span id="line-441"> */</span> |
| <span class="source-line-no">442</span><span id="line-442"> public static int putByteBuffer(byte[] bytes, int offset, ByteBuffer buf) {</span> |
| <span class="source-line-no">443</span><span id="line-443"> int len = buf.remaining();</span> |
| <span class="source-line-no">444</span><span id="line-444"> buf.get(bytes, offset, len);</span> |
| <span class="source-line-no">445</span><span id="line-445"> return offset + len;</span> |
| <span class="source-line-no">446</span><span id="line-446"> }</span> |
| <span class="source-line-no">447</span><span id="line-447"></span> |
| <span class="source-line-no">448</span><span id="line-448"> /**</span> |
| <span class="source-line-no">449</span><span id="line-449"> * Returns a new byte array, copied from the given {@code buf}, from the index 0 (inclusive) to</span> |
| <span class="source-line-no">450</span><span id="line-450"> * the limit (exclusive), regardless of the current position. The position and the other index</span> |
| <span class="source-line-no">451</span><span id="line-451"> * parameters are not changed.</span> |
| <span class="source-line-no">452</span><span id="line-452"> * @param buf a byte buffer</span> |
| <span class="source-line-no">453</span><span id="line-453"> * @return the byte array</span> |
| <span class="source-line-no">454</span><span id="line-454"> * @see #getBytes(ByteBuffer)</span> |
| <span class="source-line-no">455</span><span id="line-455"> */</span> |
| <span class="source-line-no">456</span><span id="line-456"> public static byte[] toBytes(ByteBuffer buf) {</span> |
| <span class="source-line-no">457</span><span id="line-457"> ByteBuffer dup = buf.duplicate();</span> |
| <span class="source-line-no">458</span><span id="line-458"> dup.position(0);</span> |
| <span class="source-line-no">459</span><span id="line-459"> return readBytes(dup);</span> |
| <span class="source-line-no">460</span><span id="line-460"> }</span> |
| <span class="source-line-no">461</span><span id="line-461"></span> |
| <span class="source-line-no">462</span><span id="line-462"> private static byte[] readBytes(ByteBuffer buf) {</span> |
| <span class="source-line-no">463</span><span id="line-463"> byte[] result = new byte[buf.remaining()];</span> |
| <span class="source-line-no">464</span><span id="line-464"> buf.get(result);</span> |
| <span class="source-line-no">465</span><span id="line-465"> return result;</span> |
| <span class="source-line-no">466</span><span id="line-466"> }</span> |
| <span class="source-line-no">467</span><span id="line-467"></span> |
| <span class="source-line-no">468</span><span id="line-468"> /**</span> |
| <span class="source-line-no">469</span><span id="line-469"> * Convert a byte[] into a string. Charset is assumed to be UTF-8.</span> |
| <span class="source-line-no">470</span><span id="line-470"> * @param b Presumed UTF-8 encoded byte array.</span> |
| <span class="source-line-no">471</span><span id="line-471"> * @return String made from <code>b</code></span> |
| <span class="source-line-no">472</span><span id="line-472"> */</span> |
| <span class="source-line-no">473</span><span id="line-473"> public static String toString(final byte[] b) {</span> |
| <span class="source-line-no">474</span><span id="line-474"> if (b == null) {</span> |
| <span class="source-line-no">475</span><span id="line-475"> return null;</span> |
| <span class="source-line-no">476</span><span id="line-476"> }</span> |
| <span class="source-line-no">477</span><span id="line-477"> return toString(b, 0, b.length);</span> |
| <span class="source-line-no">478</span><span id="line-478"> }</span> |
| <span class="source-line-no">479</span><span id="line-479"></span> |
| <span class="source-line-no">480</span><span id="line-480"> /**</span> |
| <span class="source-line-no">481</span><span id="line-481"> * Joins two byte arrays together using a separator.</span> |
| <span class="source-line-no">482</span><span id="line-482"> * @param b1 The first byte array.</span> |
| <span class="source-line-no">483</span><span id="line-483"> * @param sep The separator to use.</span> |
| <span class="source-line-no">484</span><span id="line-484"> * @param b2 The second byte array.</span> |
| <span class="source-line-no">485</span><span id="line-485"> */</span> |
| <span class="source-line-no">486</span><span id="line-486"> public static String toString(final byte[] b1, String sep, final byte[] b2) {</span> |
| <span class="source-line-no">487</span><span id="line-487"> return toString(b1, 0, b1.length) + sep + toString(b2, 0, b2.length);</span> |
| <span class="source-line-no">488</span><span id="line-488"> }</span> |
| <span class="source-line-no">489</span><span id="line-489"></span> |
| <span class="source-line-no">490</span><span id="line-490"> /**</span> |
| <span class="source-line-no">491</span><span id="line-491"> * This method will convert utf8 encoded bytes into a string. If the given byte array is null,</span> |
| <span class="source-line-no">492</span><span id="line-492"> * this method will return null.</span> |
| <span class="source-line-no">493</span><span id="line-493"> * @param b Presumed UTF-8 encoded byte array.</span> |
| <span class="source-line-no">494</span><span id="line-494"> * @param off offset into array</span> |
| <span class="source-line-no">495</span><span id="line-495"> * @return String made from <code>b</code> or null</span> |
| <span class="source-line-no">496</span><span id="line-496"> */</span> |
| <span class="source-line-no">497</span><span id="line-497"> public static String toString(final byte[] b, int off) {</span> |
| <span class="source-line-no">498</span><span id="line-498"> if (b == null) {</span> |
| <span class="source-line-no">499</span><span id="line-499"> return null;</span> |
| <span class="source-line-no">500</span><span id="line-500"> }</span> |
| <span class="source-line-no">501</span><span id="line-501"> int len = b.length - off;</span> |
| <span class="source-line-no">502</span><span id="line-502"> if (len <= 0) {</span> |
| <span class="source-line-no">503</span><span id="line-503"> return "";</span> |
| <span class="source-line-no">504</span><span id="line-504"> }</span> |
| <span class="source-line-no">505</span><span id="line-505"> try {</span> |
| <span class="source-line-no">506</span><span id="line-506"> return new String(b, off, len, UTF8_CSN);</span> |
| <span class="source-line-no">507</span><span id="line-507"> } catch (UnsupportedEncodingException e) {</span> |
| <span class="source-line-no">508</span><span id="line-508"> // should never happen!</span> |
| <span class="source-line-no">509</span><span id="line-509"> throw new IllegalArgumentException("UTF8 encoding is not supported", e);</span> |
| <span class="source-line-no">510</span><span id="line-510"> }</span> |
| <span class="source-line-no">511</span><span id="line-511"> }</span> |
| <span class="source-line-no">512</span><span id="line-512"></span> |
| <span class="source-line-no">513</span><span id="line-513"> /**</span> |
| <span class="source-line-no">514</span><span id="line-514"> * This method will convert utf8 encoded bytes into a string. If the given byte array is null,</span> |
| <span class="source-line-no">515</span><span id="line-515"> * this method will return null.</span> |
| <span class="source-line-no">516</span><span id="line-516"> * @param b Presumed UTF-8 encoded byte array.</span> |
| <span class="source-line-no">517</span><span id="line-517"> * @param off offset into array</span> |
| <span class="source-line-no">518</span><span id="line-518"> * @param len length of utf-8 sequence</span> |
| <span class="source-line-no">519</span><span id="line-519"> * @return String made from <code>b</code> or null</span> |
| <span class="source-line-no">520</span><span id="line-520"> */</span> |
| <span class="source-line-no">521</span><span id="line-521"> public static String toString(final byte[] b, int off, int len) {</span> |
| <span class="source-line-no">522</span><span id="line-522"> if (b == null) {</span> |
| <span class="source-line-no">523</span><span id="line-523"> return null;</span> |
| <span class="source-line-no">524</span><span id="line-524"> }</span> |
| <span class="source-line-no">525</span><span id="line-525"> if (len == 0) {</span> |
| <span class="source-line-no">526</span><span id="line-526"> return "";</span> |
| <span class="source-line-no">527</span><span id="line-527"> }</span> |
| <span class="source-line-no">528</span><span id="line-528"> try {</span> |
| <span class="source-line-no">529</span><span id="line-529"> return new String(b, off, len, UTF8_CSN);</span> |
| <span class="source-line-no">530</span><span id="line-530"> } catch (UnsupportedEncodingException e) {</span> |
| <span class="source-line-no">531</span><span id="line-531"> // should never happen!</span> |
| <span class="source-line-no">532</span><span id="line-532"> throw new IllegalArgumentException("UTF8 encoding is not supported", e);</span> |
| <span class="source-line-no">533</span><span id="line-533"> }</span> |
| <span class="source-line-no">534</span><span id="line-534"> }</span> |
| <span class="source-line-no">535</span><span id="line-535"></span> |
| <span class="source-line-no">536</span><span id="line-536"> /**</span> |
| <span class="source-line-no">537</span><span id="line-537"> * Write a printable representation of a byte array.</span> |
| <span class="source-line-no">538</span><span id="line-538"> * @param b byte array</span> |
| <span class="source-line-no">539</span><span id="line-539"> * @see #toStringBinary(byte[], int, int)</span> |
| <span class="source-line-no">540</span><span id="line-540"> */</span> |
| <span class="source-line-no">541</span><span id="line-541"> public static String toStringBinary(final byte[] b) {</span> |
| <span class="source-line-no">542</span><span id="line-542"> if (b == null) return "null";</span> |
| <span class="source-line-no">543</span><span id="line-543"> return toStringBinary(b, 0, b.length);</span> |
| <span class="source-line-no">544</span><span id="line-544"> }</span> |
| <span class="source-line-no">545</span><span id="line-545"></span> |
| <span class="source-line-no">546</span><span id="line-546"> /**</span> |
| <span class="source-line-no">547</span><span id="line-547"> * Converts the given byte buffer to a printable representation, from the index 0 (inclusive) to</span> |
| <span class="source-line-no">548</span><span id="line-548"> * the limit (exclusive), regardless of the current position. The position and the other index</span> |
| <span class="source-line-no">549</span><span id="line-549"> * parameters are not changed.</span> |
| <span class="source-line-no">550</span><span id="line-550"> * @param buf a byte buffer</span> |
| <span class="source-line-no">551</span><span id="line-551"> * @return a string representation of the buffer's binary contents</span> |
| <span class="source-line-no">552</span><span id="line-552"> * @see #toBytes(ByteBuffer)</span> |
| <span class="source-line-no">553</span><span id="line-553"> * @see #getBytes(ByteBuffer)</span> |
| <span class="source-line-no">554</span><span id="line-554"> */</span> |
| <span class="source-line-no">555</span><span id="line-555"> public static String toStringBinary(ByteBuffer buf) {</span> |
| <span class="source-line-no">556</span><span id="line-556"> if (buf == null) return "null";</span> |
| <span class="source-line-no">557</span><span id="line-557"> if (buf.hasArray()) {</span> |
| <span class="source-line-no">558</span><span id="line-558"> return toStringBinary(buf.array(), buf.arrayOffset(), buf.limit());</span> |
| <span class="source-line-no">559</span><span id="line-559"> }</span> |
| <span class="source-line-no">560</span><span id="line-560"> return toStringBinary(toBytes(buf));</span> |
| <span class="source-line-no">561</span><span id="line-561"> }</span> |
| <span class="source-line-no">562</span><span id="line-562"></span> |
| <span class="source-line-no">563</span><span id="line-563"> private static final char[] HEX_CHARS_UPPER =</span> |
| <span class="source-line-no">564</span><span id="line-564"> { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };</span> |
| <span class="source-line-no">565</span><span id="line-565"></span> |
| <span class="source-line-no">566</span><span id="line-566"> /**</span> |
| <span class="source-line-no">567</span><span id="line-567"> * Write a printable representation of a byte array. Non-printable characters are hex escaped in</span> |
| <span class="source-line-no">568</span><span id="line-568"> * the format \\x%02X, eg: \x00 \x05 etc</span> |
| <span class="source-line-no">569</span><span id="line-569"> * @param b array to write out</span> |
| <span class="source-line-no">570</span><span id="line-570"> * @param off offset to start at</span> |
| <span class="source-line-no">571</span><span id="line-571"> * @param len length to write</span> |
| <span class="source-line-no">572</span><span id="line-572"> * @return string output</span> |
| <span class="source-line-no">573</span><span id="line-573"> */</span> |
| <span class="source-line-no">574</span><span id="line-574"> public static String toStringBinary(final byte[] b, int off, int len) {</span> |
| <span class="source-line-no">575</span><span id="line-575"> StringBuilder result = new StringBuilder();</span> |
| <span class="source-line-no">576</span><span id="line-576"> // Just in case we are passed a 'len' that is > buffer length...</span> |
| <span class="source-line-no">577</span><span id="line-577"> if (off >= b.length) return result.toString();</span> |
| <span class="source-line-no">578</span><span id="line-578"> if (off + len > b.length) len = b.length - off;</span> |
| <span class="source-line-no">579</span><span id="line-579"> for (int i = off; i < off + len; ++i) {</span> |
| <span class="source-line-no">580</span><span id="line-580"> int ch = b[i] & 0xFF;</span> |
| <span class="source-line-no">581</span><span id="line-581"> if (ch >= ' ' && ch <= '~' && ch != '\\') {</span> |
| <span class="source-line-no">582</span><span id="line-582"> result.append((char) ch);</span> |
| <span class="source-line-no">583</span><span id="line-583"> } else {</span> |
| <span class="source-line-no">584</span><span id="line-584"> result.append("\\x");</span> |
| <span class="source-line-no">585</span><span id="line-585"> result.append(HEX_CHARS_UPPER[ch / 0x10]);</span> |
| <span class="source-line-no">586</span><span id="line-586"> result.append(HEX_CHARS_UPPER[ch % 0x10]);</span> |
| <span class="source-line-no">587</span><span id="line-587"> }</span> |
| <span class="source-line-no">588</span><span id="line-588"> }</span> |
| <span class="source-line-no">589</span><span id="line-589"> return result.toString();</span> |
| <span class="source-line-no">590</span><span id="line-590"> }</span> |
| <span class="source-line-no">591</span><span id="line-591"></span> |
| <span class="source-line-no">592</span><span id="line-592"> private static boolean isHexDigit(char c) {</span> |
| <span class="source-line-no">593</span><span id="line-593"> return (c >= 'A' && c <= 'F') || (c >= '0' && c <= '9');</span> |
| <span class="source-line-no">594</span><span id="line-594"> }</span> |
| <span class="source-line-no">595</span><span id="line-595"></span> |
| <span class="source-line-no">596</span><span id="line-596"> /**</span> |
| <span class="source-line-no">597</span><span id="line-597"> * Takes a ASCII digit in the range A-F0-9 and returns the corresponding integer/ordinal value.</span> |
| <span class="source-line-no">598</span><span id="line-598"> * @param ch The hex digit.</span> |
| <span class="source-line-no">599</span><span id="line-599"> * @return The converted hex value as a byte.</span> |
| <span class="source-line-no">600</span><span id="line-600"> */</span> |
| <span class="source-line-no">601</span><span id="line-601"> public static byte toBinaryFromHex(byte ch) {</span> |
| <span class="source-line-no">602</span><span id="line-602"> if (ch >= 'A' && ch <= 'F') return (byte) ((byte) 10 + (byte) (ch - 'A'));</span> |
| <span class="source-line-no">603</span><span id="line-603"> // else</span> |
| <span class="source-line-no">604</span><span id="line-604"> return (byte) (ch - '0');</span> |
| <span class="source-line-no">605</span><span id="line-605"> }</span> |
| <span class="source-line-no">606</span><span id="line-606"></span> |
| <span class="source-line-no">607</span><span id="line-607"> public static byte[] toBytesBinary(String in) {</span> |
| <span class="source-line-no">608</span><span id="line-608"> // this may be bigger than we need, but let's be safe.</span> |
| <span class="source-line-no">609</span><span id="line-609"> byte[] b = new byte[in.length()];</span> |
| <span class="source-line-no">610</span><span id="line-610"> int size = 0;</span> |
| <span class="source-line-no">611</span><span id="line-611"> for (int i = 0; i < in.length(); ++i) {</span> |
| <span class="source-line-no">612</span><span id="line-612"> char ch = in.charAt(i);</span> |
| <span class="source-line-no">613</span><span id="line-613"> if (ch == '\\' && in.length() > i + 1 && in.charAt(i + 1) == 'x') {</span> |
| <span class="source-line-no">614</span><span id="line-614"> // ok, take next 2 hex digits.</span> |
| <span class="source-line-no">615</span><span id="line-615"> char hd1 = in.charAt(i + 2);</span> |
| <span class="source-line-no">616</span><span id="line-616"> char hd2 = in.charAt(i + 3);</span> |
| <span class="source-line-no">617</span><span id="line-617"></span> |
| <span class="source-line-no">618</span><span id="line-618"> // they need to be A-F0-9:</span> |
| <span class="source-line-no">619</span><span id="line-619"> if (!isHexDigit(hd1) || !isHexDigit(hd2)) {</span> |
| <span class="source-line-no">620</span><span id="line-620"> // bogus escape code, ignore:</span> |
| <span class="source-line-no">621</span><span id="line-621"> continue;</span> |
| <span class="source-line-no">622</span><span id="line-622"> }</span> |
| <span class="source-line-no">623</span><span id="line-623"> // turn hex ASCII digit -> number</span> |
| <span class="source-line-no">624</span><span id="line-624"> byte d = (byte) ((toBinaryFromHex((byte) hd1) << 4) + toBinaryFromHex((byte) hd2));</span> |
| <span class="source-line-no">625</span><span id="line-625"></span> |
| <span class="source-line-no">626</span><span id="line-626"> b[size++] = d;</span> |
| <span class="source-line-no">627</span><span id="line-627"> i += 3; // skip 3</span> |
| <span class="source-line-no">628</span><span id="line-628"> } else {</span> |
| <span class="source-line-no">629</span><span id="line-629"> b[size++] = (byte) ch;</span> |
| <span class="source-line-no">630</span><span id="line-630"> }</span> |
| <span class="source-line-no">631</span><span id="line-631"> }</span> |
| <span class="source-line-no">632</span><span id="line-632"> // resize:</span> |
| <span class="source-line-no">633</span><span id="line-633"> byte[] b2 = new byte[size];</span> |
| <span class="source-line-no">634</span><span id="line-634"> System.arraycopy(b, 0, b2, 0, size);</span> |
| <span class="source-line-no">635</span><span id="line-635"> return b2;</span> |
| <span class="source-line-no">636</span><span id="line-636"> }</span> |
| <span class="source-line-no">637</span><span id="line-637"></span> |
| <span class="source-line-no">638</span><span id="line-638"> /**</span> |
| <span class="source-line-no">639</span><span id="line-639"> * Converts a string to a UTF-8 byte array.</span> |
| <span class="source-line-no">640</span><span id="line-640"> * @param s string</span> |
| <span class="source-line-no">641</span><span id="line-641"> * @return the byte array</span> |
| <span class="source-line-no">642</span><span id="line-642"> */</span> |
| <span class="source-line-no">643</span><span id="line-643"> public static byte[] toBytes(String s) {</span> |
| <span class="source-line-no">644</span><span id="line-644"> try {</span> |
| <span class="source-line-no">645</span><span id="line-645"> return s.getBytes(UTF8_CSN);</span> |
| <span class="source-line-no">646</span><span id="line-646"> } catch (UnsupportedEncodingException e) {</span> |
| <span class="source-line-no">647</span><span id="line-647"> // should never happen!</span> |
| <span class="source-line-no">648</span><span id="line-648"> throw new IllegalArgumentException("UTF8 decoding is not supported", e);</span> |
| <span class="source-line-no">649</span><span id="line-649"> }</span> |
| <span class="source-line-no">650</span><span id="line-650"> }</span> |
| <span class="source-line-no">651</span><span id="line-651"></span> |
| <span class="source-line-no">652</span><span id="line-652"> /**</span> |
| <span class="source-line-no">653</span><span id="line-653"> * Convert a boolean to a byte array. True becomes -1 and false becomes 0.</span> |
| <span class="source-line-no">654</span><span id="line-654"> * @param b value</span> |
| <span class="source-line-no">655</span><span id="line-655"> * @return <code>b</code> encoded in a byte array.</span> |
| <span class="source-line-no">656</span><span id="line-656"> */</span> |
| <span class="source-line-no">657</span><span id="line-657"> public static byte[] toBytes(final boolean b) {</span> |
| <span class="source-line-no">658</span><span id="line-658"> return new byte[] { b ? (byte) -1 : (byte) 0 };</span> |
| <span class="source-line-no">659</span><span id="line-659"> }</span> |
| <span class="source-line-no">660</span><span id="line-660"></span> |
| <span class="source-line-no">661</span><span id="line-661"> /**</span> |
| <span class="source-line-no">662</span><span id="line-662"> * Reverses {@link #toBytes(boolean)}</span> |
| <span class="source-line-no">663</span><span id="line-663"> * @param b array</span> |
| <span class="source-line-no">664</span><span id="line-664"> * @return True or false.</span> |
| <span class="source-line-no">665</span><span id="line-665"> */</span> |
| <span class="source-line-no">666</span><span id="line-666"> public static boolean toBoolean(final byte[] b) {</span> |
| <span class="source-line-no">667</span><span id="line-667"> if (b.length != 1) {</span> |
| <span class="source-line-no">668</span><span id="line-668"> throw new IllegalArgumentException("Array has wrong size: " + b.length);</span> |
| <span class="source-line-no">669</span><span id="line-669"> }</span> |
| <span class="source-line-no">670</span><span id="line-670"> return b[0] != (byte) 0;</span> |
| <span class="source-line-no">671</span><span id="line-671"> }</span> |
| <span class="source-line-no">672</span><span id="line-672"></span> |
| <span class="source-line-no">673</span><span id="line-673"> /**</span> |
| <span class="source-line-no">674</span><span id="line-674"> * Convert a long value to a byte array using big-endian.</span> |
| <span class="source-line-no">675</span><span id="line-675"> * @param val value to convert</span> |
| <span class="source-line-no">676</span><span id="line-676"> * @return the byte array</span> |
| <span class="source-line-no">677</span><span id="line-677"> */</span> |
| <span class="source-line-no">678</span><span id="line-678"> public static byte[] toBytes(long val) {</span> |
| <span class="source-line-no">679</span><span id="line-679"> byte[] b = new byte[8];</span> |
| <span class="source-line-no">680</span><span id="line-680"> for (int i = 7; i > 0; i--) {</span> |
| <span class="source-line-no">681</span><span id="line-681"> b[i] = (byte) val;</span> |
| <span class="source-line-no">682</span><span id="line-682"> val >>>= 8;</span> |
| <span class="source-line-no">683</span><span id="line-683"> }</span> |
| <span class="source-line-no">684</span><span id="line-684"> b[0] = (byte) val;</span> |
| <span class="source-line-no">685</span><span id="line-685"> return b;</span> |
| <span class="source-line-no">686</span><span id="line-686"> }</span> |
| <span class="source-line-no">687</span><span id="line-687"></span> |
| <span class="source-line-no">688</span><span id="line-688"> /**</span> |
| <span class="source-line-no">689</span><span id="line-689"> * Converts a byte array to a long value. Reverses {@link #toBytes(long)}</span> |
| <span class="source-line-no">690</span><span id="line-690"> * @param bytes array</span> |
| <span class="source-line-no">691</span><span id="line-691"> * @return the long value</span> |
| <span class="source-line-no">692</span><span id="line-692"> */</span> |
| <span class="source-line-no">693</span><span id="line-693"> public static long toLong(byte[] bytes) {</span> |
| <span class="source-line-no">694</span><span id="line-694"> return toLong(bytes, 0, SIZEOF_LONG);</span> |
| <span class="source-line-no">695</span><span id="line-695"> }</span> |
| <span class="source-line-no">696</span><span id="line-696"></span> |
| <span class="source-line-no">697</span><span id="line-697"> /**</span> |
| <span class="source-line-no">698</span><span id="line-698"> * Converts a byte array to a long value. Assumes there will be {@link #SIZEOF_LONG} bytes</span> |
| <span class="source-line-no">699</span><span id="line-699"> * available.</span> |
| <span class="source-line-no">700</span><span id="line-700"> * @param bytes bytes</span> |
| <span class="source-line-no">701</span><span id="line-701"> * @param offset offset</span> |
| <span class="source-line-no">702</span><span id="line-702"> * @return the long value</span> |
| <span class="source-line-no">703</span><span id="line-703"> */</span> |
| <span class="source-line-no">704</span><span id="line-704"> public static long toLong(byte[] bytes, int offset) {</span> |
| <span class="source-line-no">705</span><span id="line-705"> return toLong(bytes, offset, SIZEOF_LONG);</span> |
| <span class="source-line-no">706</span><span id="line-706"> }</span> |
| <span class="source-line-no">707</span><span id="line-707"></span> |
| <span class="source-line-no">708</span><span id="line-708"> /**</span> |
| <span class="source-line-no">709</span><span id="line-709"> * Converts a byte array to a long value.</span> |
| <span class="source-line-no">710</span><span id="line-710"> * @param bytes array of bytes</span> |
| <span class="source-line-no">711</span><span id="line-711"> * @param offset offset into array</span> |
| <span class="source-line-no">712</span><span id="line-712"> * @param length length of data (must be {@link #SIZEOF_LONG})</span> |
| <span class="source-line-no">713</span><span id="line-713"> * @return the long value</span> |
| <span class="source-line-no">714</span><span id="line-714"> * @throws IllegalArgumentException if length is not {@link #SIZEOF_LONG} or if there's not enough</span> |
| <span class="source-line-no">715</span><span id="line-715"> * room in the array at the offset indicated.</span> |
| <span class="source-line-no">716</span><span id="line-716"> */</span> |
| <span class="source-line-no">717</span><span id="line-717"> public static long toLong(byte[] bytes, int offset, final int length) {</span> |
| <span class="source-line-no">718</span><span id="line-718"> if (length != SIZEOF_LONG || offset + length > bytes.length) {</span> |
| <span class="source-line-no">719</span><span id="line-719"> throw explainWrongLengthOrOffset(bytes, offset, length, SIZEOF_LONG);</span> |
| <span class="source-line-no">720</span><span id="line-720"> }</span> |
| <span class="source-line-no">721</span><span id="line-721"> return ConverterHolder.BEST_CONVERTER.toLong(bytes, offset, length);</span> |
| <span class="source-line-no">722</span><span id="line-722"> }</span> |
| <span class="source-line-no">723</span><span id="line-723"></span> |
| <span class="source-line-no">724</span><span id="line-724"> private static IllegalArgumentException explainWrongLengthOrOffset(final byte[] bytes,</span> |
| <span class="source-line-no">725</span><span id="line-725"> final int offset, final int length, final int expectedLength) {</span> |
| <span class="source-line-no">726</span><span id="line-726"> String reason;</span> |
| <span class="source-line-no">727</span><span id="line-727"> if (length != expectedLength) {</span> |
| <span class="source-line-no">728</span><span id="line-728"> reason = "Wrong length: " + length + ", expected " + expectedLength;</span> |
| <span class="source-line-no">729</span><span id="line-729"> } else {</span> |
| <span class="source-line-no">730</span><span id="line-730"> reason = "offset (" + offset + ") + length (" + length + ") exceed the"</span> |
| <span class="source-line-no">731</span><span id="line-731"> + " capacity of the array: " + bytes.length;</span> |
| <span class="source-line-no">732</span><span id="line-732"> }</span> |
| <span class="source-line-no">733</span><span id="line-733"> return new IllegalArgumentException(reason);</span> |
| <span class="source-line-no">734</span><span id="line-734"> }</span> |
| <span class="source-line-no">735</span><span id="line-735"></span> |
| <span class="source-line-no">736</span><span id="line-736"> /**</span> |
| <span class="source-line-no">737</span><span id="line-737"> * Put a long value out to the specified byte array position.</span> |
| <span class="source-line-no">738</span><span id="line-738"> * @param bytes the byte array</span> |
| <span class="source-line-no">739</span><span id="line-739"> * @param offset position in the array</span> |
| <span class="source-line-no">740</span><span id="line-740"> * @param val long to write out</span> |
| <span class="source-line-no">741</span><span id="line-741"> * @return incremented offset</span> |
| <span class="source-line-no">742</span><span id="line-742"> * @throws IllegalArgumentException if the byte array given doesn't have enough room at the offset</span> |
| <span class="source-line-no">743</span><span id="line-743"> * specified.</span> |
| <span class="source-line-no">744</span><span id="line-744"> */</span> |
| <span class="source-line-no">745</span><span id="line-745"> public static int putLong(byte[] bytes, int offset, long val) {</span> |
| <span class="source-line-no">746</span><span id="line-746"> if (bytes.length - offset < SIZEOF_LONG) {</span> |
| <span class="source-line-no">747</span><span id="line-747"> throw new IllegalArgumentException("Not enough room to put a long at" + " offset " + offset</span> |
| <span class="source-line-no">748</span><span id="line-748"> + " in a " + bytes.length + " byte array");</span> |
| <span class="source-line-no">749</span><span id="line-749"> }</span> |
| <span class="source-line-no">750</span><span id="line-750"> return ConverterHolder.BEST_CONVERTER.putLong(bytes, offset, val);</span> |
| <span class="source-line-no">751</span><span id="line-751"> }</span> |
| <span class="source-line-no">752</span><span id="line-752"></span> |
| <span class="source-line-no">753</span><span id="line-753"> /**</span> |
| <span class="source-line-no">754</span><span id="line-754"> * Put a float value out to the specified byte array position. Presumes float encoded as IEEE 754</span> |
| <span class="source-line-no">755</span><span id="line-755"> * floating-point "single format"</span> |
| <span class="source-line-no">756</span><span id="line-756"> * @param bytes byte array</span> |
| <span class="source-line-no">757</span><span id="line-757"> * @return Float made from passed byte array.</span> |
| <span class="source-line-no">758</span><span id="line-758"> */</span> |
| <span class="source-line-no">759</span><span id="line-759"> public static float toFloat(byte[] bytes) {</span> |
| <span class="source-line-no">760</span><span id="line-760"> return toFloat(bytes, 0);</span> |
| <span class="source-line-no">761</span><span id="line-761"> }</span> |
| <span class="source-line-no">762</span><span id="line-762"></span> |
| <span class="source-line-no">763</span><span id="line-763"> /**</span> |
| <span class="source-line-no">764</span><span id="line-764"> * Put a float value out to the specified byte array position. Presumes float encoded as IEEE 754</span> |
| <span class="source-line-no">765</span><span id="line-765"> * floating-point "single format"</span> |
| <span class="source-line-no">766</span><span id="line-766"> * @param bytes array to convert</span> |
| <span class="source-line-no">767</span><span id="line-767"> * @param offset offset into array</span> |
| <span class="source-line-no">768</span><span id="line-768"> * @return Float made from passed byte array.</span> |
| <span class="source-line-no">769</span><span id="line-769"> */</span> |
| <span class="source-line-no">770</span><span id="line-770"> public static float toFloat(byte[] bytes, int offset) {</span> |
| <span class="source-line-no">771</span><span id="line-771"> return Float.intBitsToFloat(toInt(bytes, offset, SIZEOF_INT));</span> |
| <span class="source-line-no">772</span><span id="line-772"> }</span> |
| <span class="source-line-no">773</span><span id="line-773"></span> |
| <span class="source-line-no">774</span><span id="line-774"> /**</span> |
| <span class="source-line-no">775</span><span id="line-775"> * Put a float value out to the specified byte array position.</span> |
| <span class="source-line-no">776</span><span id="line-776"> * @param bytes byte array</span> |
| <span class="source-line-no">777</span><span id="line-777"> * @param offset offset to write to</span> |
| <span class="source-line-no">778</span><span id="line-778"> * @param f float value</span> |
| <span class="source-line-no">779</span><span id="line-779"> * @return New offset in <code>bytes</code></span> |
| <span class="source-line-no">780</span><span id="line-780"> */</span> |
| <span class="source-line-no">781</span><span id="line-781"> public static int putFloat(byte[] bytes, int offset, float f) {</span> |
| <span class="source-line-no">782</span><span id="line-782"> return putInt(bytes, offset, Float.floatToRawIntBits(f));</span> |
| <span class="source-line-no">783</span><span id="line-783"> }</span> |
| <span class="source-line-no">784</span><span id="line-784"></span> |
| <span class="source-line-no">785</span><span id="line-785"> /** Return the float represented as byte[] */</span> |
| <span class="source-line-no">786</span><span id="line-786"> public static byte[] toBytes(final float f) {</span> |
| <span class="source-line-no">787</span><span id="line-787"> // Encode it as int</span> |
| <span class="source-line-no">788</span><span id="line-788"> return Bytes.toBytes(Float.floatToRawIntBits(f));</span> |
| <span class="source-line-no">789</span><span id="line-789"> }</span> |
| <span class="source-line-no">790</span><span id="line-790"></span> |
| <span class="source-line-no">791</span><span id="line-791"> /** Return double made from passed bytes. */</span> |
| <span class="source-line-no">792</span><span id="line-792"> public static double toDouble(final byte[] bytes) {</span> |
| <span class="source-line-no">793</span><span id="line-793"> return toDouble(bytes, 0);</span> |
| <span class="source-line-no">794</span><span id="line-794"> }</span> |
| <span class="source-line-no">795</span><span id="line-795"></span> |
| <span class="source-line-no">796</span><span id="line-796"> /** Return double made from passed bytes. */</span> |
| <span class="source-line-no">797</span><span id="line-797"> public static double toDouble(final byte[] bytes, final int offset) {</span> |
| <span class="source-line-no">798</span><span id="line-798"> return Double.longBitsToDouble(toLong(bytes, offset, SIZEOF_LONG));</span> |
| <span class="source-line-no">799</span><span id="line-799"> }</span> |
| <span class="source-line-no">800</span><span id="line-800"></span> |
| <span class="source-line-no">801</span><span id="line-801"> /**</span> |
| <span class="source-line-no">802</span><span id="line-802"> * Put a double value out to the specified byte array position as the IEEE 754 double format.</span> |
| <span class="source-line-no">803</span><span id="line-803"> * @param bytes byte array</span> |
| <span class="source-line-no">804</span><span id="line-804"> * @param offset offset to write to</span> |
| <span class="source-line-no">805</span><span id="line-805"> * @param d value</span> |
| <span class="source-line-no">806</span><span id="line-806"> * @return New offset into array <code>bytes</code></span> |
| <span class="source-line-no">807</span><span id="line-807"> */</span> |
| <span class="source-line-no">808</span><span id="line-808"> public static int putDouble(byte[] bytes, int offset, double d) {</span> |
| <span class="source-line-no">809</span><span id="line-809"> return putLong(bytes, offset, Double.doubleToLongBits(d));</span> |
| <span class="source-line-no">810</span><span id="line-810"> }</span> |
| <span class="source-line-no">811</span><span id="line-811"></span> |
| <span class="source-line-no">812</span><span id="line-812"> /**</span> |
| <span class="source-line-no">813</span><span id="line-813"> * Serialize a double as the IEEE 754 double format output. The resultant array will be 8 bytes</span> |
| <span class="source-line-no">814</span><span id="line-814"> * long.</span> |
| <span class="source-line-no">815</span><span id="line-815"> * @param d value</span> |
| <span class="source-line-no">816</span><span id="line-816"> * @return the double represented as byte []</span> |
| <span class="source-line-no">817</span><span id="line-817"> */</span> |
| <span class="source-line-no">818</span><span id="line-818"> public static byte[] toBytes(final double d) {</span> |
| <span class="source-line-no">819</span><span id="line-819"> // Encode it as a long</span> |
| <span class="source-line-no">820</span><span id="line-820"> return Bytes.toBytes(Double.doubleToRawLongBits(d));</span> |
| <span class="source-line-no">821</span><span id="line-821"> }</span> |
| <span class="source-line-no">822</span><span id="line-822"></span> |
| <span class="source-line-no">823</span><span id="line-823"> /**</span> |
| <span class="source-line-no">824</span><span id="line-824"> * Convert an int value to a byte array. Big-endian. Same as what DataOutputStream.writeInt does.</span> |
| <span class="source-line-no">825</span><span id="line-825"> * @param val value</span> |
| <span class="source-line-no">826</span><span id="line-826"> * @return the byte array</span> |
| <span class="source-line-no">827</span><span id="line-827"> */</span> |
| <span class="source-line-no">828</span><span id="line-828"> public static byte[] toBytes(int val) {</span> |
| <span class="source-line-no">829</span><span id="line-829"> byte[] b = new byte[4];</span> |
| <span class="source-line-no">830</span><span id="line-830"> for (int i = 3; i > 0; i--) {</span> |
| <span class="source-line-no">831</span><span id="line-831"> b[i] = (byte) val;</span> |
| <span class="source-line-no">832</span><span id="line-832"> val >>>= 8;</span> |
| <span class="source-line-no">833</span><span id="line-833"> }</span> |
| <span class="source-line-no">834</span><span id="line-834"> b[0] = (byte) val;</span> |
| <span class="source-line-no">835</span><span id="line-835"> return b;</span> |
| <span class="source-line-no">836</span><span id="line-836"> }</span> |
| <span class="source-line-no">837</span><span id="line-837"></span> |
| <span class="source-line-no">838</span><span id="line-838"> /**</span> |
| <span class="source-line-no">839</span><span id="line-839"> * Converts a byte array to an int value</span> |
| <span class="source-line-no">840</span><span id="line-840"> * @param bytes byte array</span> |
| <span class="source-line-no">841</span><span id="line-841"> * @return the int value</span> |
| <span class="source-line-no">842</span><span id="line-842"> */</span> |
| <span class="source-line-no">843</span><span id="line-843"> public static int toInt(byte[] bytes) {</span> |
| <span class="source-line-no">844</span><span id="line-844"> return toInt(bytes, 0, SIZEOF_INT);</span> |
| <span class="source-line-no">845</span><span id="line-845"> }</span> |
| <span class="source-line-no">846</span><span id="line-846"></span> |
| <span class="source-line-no">847</span><span id="line-847"> /**</span> |
| <span class="source-line-no">848</span><span id="line-848"> * Converts a byte array to an int value</span> |
| <span class="source-line-no">849</span><span id="line-849"> * @param bytes byte array</span> |
| <span class="source-line-no">850</span><span id="line-850"> * @param offset offset into array</span> |
| <span class="source-line-no">851</span><span id="line-851"> * @return the int value</span> |
| <span class="source-line-no">852</span><span id="line-852"> */</span> |
| <span class="source-line-no">853</span><span id="line-853"> public static int toInt(byte[] bytes, int offset) {</span> |
| <span class="source-line-no">854</span><span id="line-854"> return toInt(bytes, offset, SIZEOF_INT);</span> |
| <span class="source-line-no">855</span><span id="line-855"> }</span> |
| <span class="source-line-no">856</span><span id="line-856"></span> |
| <span class="source-line-no">857</span><span id="line-857"> /**</span> |
| <span class="source-line-no">858</span><span id="line-858"> * Converts a byte array to an int value</span> |
| <span class="source-line-no">859</span><span id="line-859"> * @param bytes byte array</span> |
| <span class="source-line-no">860</span><span id="line-860"> * @param offset offset into array</span> |
| <span class="source-line-no">861</span><span id="line-861"> * @param length length of int (has to be {@link #SIZEOF_INT})</span> |
| <span class="source-line-no">862</span><span id="line-862"> * @return the int value</span> |
| <span class="source-line-no">863</span><span id="line-863"> * @throws IllegalArgumentException if length is not {@link #SIZEOF_INT} or if there's not enough</span> |
| <span class="source-line-no">864</span><span id="line-864"> * room in the array at the offset indicated.</span> |
| <span class="source-line-no">865</span><span id="line-865"> */</span> |
| <span class="source-line-no">866</span><span id="line-866"> public static int toInt(byte[] bytes, int offset, final int length) {</span> |
| <span class="source-line-no">867</span><span id="line-867"> if (length != SIZEOF_INT || offset + length > bytes.length) {</span> |
| <span class="source-line-no">868</span><span id="line-868"> throw explainWrongLengthOrOffset(bytes, offset, length, SIZEOF_INT);</span> |
| <span class="source-line-no">869</span><span id="line-869"> }</span> |
| <span class="source-line-no">870</span><span id="line-870"> return ConverterHolder.BEST_CONVERTER.toInt(bytes, offset, length);</span> |
| <span class="source-line-no">871</span><span id="line-871"> }</span> |
| <span class="source-line-no">872</span><span id="line-872"></span> |
| <span class="source-line-no">873</span><span id="line-873"> /**</span> |
| <span class="source-line-no">874</span><span id="line-874"> * Converts a byte array to an int value</span> |
| <span class="source-line-no">875</span><span id="line-875"> * @param bytes byte array</span> |
| <span class="source-line-no">876</span><span id="line-876"> * @param offset offset into array</span> |
| <span class="source-line-no">877</span><span id="line-877"> * @param length how many bytes should be considered for creating int</span> |
| <span class="source-line-no">878</span><span id="line-878"> * @return the int value</span> |
| <span class="source-line-no">879</span><span id="line-879"> * @throws IllegalArgumentException if there's not enough room in the array at the offset</span> |
| <span class="source-line-no">880</span><span id="line-880"> * indicated.</span> |
| <span class="source-line-no">881</span><span id="line-881"> */</span> |
| <span class="source-line-no">882</span><span id="line-882"> public static int readAsInt(byte[] bytes, int offset, final int length) {</span> |
| <span class="source-line-no">883</span><span id="line-883"> if (offset + length > bytes.length) {</span> |
| <span class="source-line-no">884</span><span id="line-884"> throw new IllegalArgumentException("offset (" + offset + ") + length (" + length</span> |
| <span class="source-line-no">885</span><span id="line-885"> + ") exceed the" + " capacity of the array: " + bytes.length);</span> |
| <span class="source-line-no">886</span><span id="line-886"> }</span> |
| <span class="source-line-no">887</span><span id="line-887"> int n = 0;</span> |
| <span class="source-line-no">888</span><span id="line-888"> for (int i = offset; i < (offset + length); i++) {</span> |
| <span class="source-line-no">889</span><span id="line-889"> n <<= 8;</span> |
| <span class="source-line-no">890</span><span id="line-890"> n ^= bytes[i] & 0xFF;</span> |
| <span class="source-line-no">891</span><span id="line-891"> }</span> |
| <span class="source-line-no">892</span><span id="line-892"> return n;</span> |
| <span class="source-line-no">893</span><span id="line-893"> }</span> |
| <span class="source-line-no">894</span><span id="line-894"></span> |
| <span class="source-line-no">895</span><span id="line-895"> /**</span> |
| <span class="source-line-no">896</span><span id="line-896"> * Put an int value out to the specified byte array position.</span> |
| <span class="source-line-no">897</span><span id="line-897"> * @param bytes the byte array</span> |
| <span class="source-line-no">898</span><span id="line-898"> * @param offset position in the array</span> |
| <span class="source-line-no">899</span><span id="line-899"> * @param val int to write out</span> |
| <span class="source-line-no">900</span><span id="line-900"> * @return incremented offset</span> |
| <span class="source-line-no">901</span><span id="line-901"> * @throws IllegalArgumentException if the byte array given doesn't have enough room at the offset</span> |
| <span class="source-line-no">902</span><span id="line-902"> * specified.</span> |
| <span class="source-line-no">903</span><span id="line-903"> */</span> |
| <span class="source-line-no">904</span><span id="line-904"> public static int putInt(byte[] bytes, int offset, int val) {</span> |
| <span class="source-line-no">905</span><span id="line-905"> if (bytes.length - offset < SIZEOF_INT) {</span> |
| <span class="source-line-no">906</span><span id="line-906"> throw new IllegalArgumentException("Not enough room to put an int at" + " offset " + offset</span> |
| <span class="source-line-no">907</span><span id="line-907"> + " in a " + bytes.length + " byte array");</span> |
| <span class="source-line-no">908</span><span id="line-908"> }</span> |
| <span class="source-line-no">909</span><span id="line-909"> return ConverterHolder.BEST_CONVERTER.putInt(bytes, offset, val);</span> |
| <span class="source-line-no">910</span><span id="line-910"> }</span> |
| <span class="source-line-no">911</span><span id="line-911"></span> |
| <span class="source-line-no">912</span><span id="line-912"> /**</span> |
| <span class="source-line-no">913</span><span id="line-913"> * Convert a short value to a byte array of {@link #SIZEOF_SHORT} bytes long.</span> |
| <span class="source-line-no">914</span><span id="line-914"> * @param val value</span> |
| <span class="source-line-no">915</span><span id="line-915"> * @return the byte array</span> |
| <span class="source-line-no">916</span><span id="line-916"> */</span> |
| <span class="source-line-no">917</span><span id="line-917"> public static byte[] toBytes(short val) {</span> |
| <span class="source-line-no">918</span><span id="line-918"> byte[] b = new byte[SIZEOF_SHORT];</span> |
| <span class="source-line-no">919</span><span id="line-919"> b[1] = (byte) val;</span> |
| <span class="source-line-no">920</span><span id="line-920"> val >>= 8;</span> |
| <span class="source-line-no">921</span><span id="line-921"> b[0] = (byte) val;</span> |
| <span class="source-line-no">922</span><span id="line-922"> return b;</span> |
| <span class="source-line-no">923</span><span id="line-923"> }</span> |
| <span class="source-line-no">924</span><span id="line-924"></span> |
| <span class="source-line-no">925</span><span id="line-925"> /**</span> |
| <span class="source-line-no">926</span><span id="line-926"> * Converts a byte array to a short value</span> |
| <span class="source-line-no">927</span><span id="line-927"> * @param bytes byte array</span> |
| <span class="source-line-no">928</span><span id="line-928"> * @return the short value</span> |
| <span class="source-line-no">929</span><span id="line-929"> */</span> |
| <span class="source-line-no">930</span><span id="line-930"> public static short toShort(byte[] bytes) {</span> |
| <span class="source-line-no">931</span><span id="line-931"> return toShort(bytes, 0, SIZEOF_SHORT);</span> |
| <span class="source-line-no">932</span><span id="line-932"> }</span> |
| <span class="source-line-no">933</span><span id="line-933"></span> |
| <span class="source-line-no">934</span><span id="line-934"> /**</span> |
| <span class="source-line-no">935</span><span id="line-935"> * Converts a byte array to a short value</span> |
| <span class="source-line-no">936</span><span id="line-936"> * @param bytes byte array</span> |
| <span class="source-line-no">937</span><span id="line-937"> * @param offset offset into array</span> |
| <span class="source-line-no">938</span><span id="line-938"> * @return the short value</span> |
| <span class="source-line-no">939</span><span id="line-939"> */</span> |
| <span class="source-line-no">940</span><span id="line-940"> public static short toShort(byte[] bytes, int offset) {</span> |
| <span class="source-line-no">941</span><span id="line-941"> return toShort(bytes, offset, SIZEOF_SHORT);</span> |
| <span class="source-line-no">942</span><span id="line-942"> }</span> |
| <span class="source-line-no">943</span><span id="line-943"></span> |
| <span class="source-line-no">944</span><span id="line-944"> /**</span> |
| <span class="source-line-no">945</span><span id="line-945"> * Converts a byte array to a short value</span> |
| <span class="source-line-no">946</span><span id="line-946"> * @param bytes byte array</span> |
| <span class="source-line-no">947</span><span id="line-947"> * @param offset offset into array</span> |
| <span class="source-line-no">948</span><span id="line-948"> * @param length length, has to be {@link #SIZEOF_SHORT}</span> |
| <span class="source-line-no">949</span><span id="line-949"> * @return the short value</span> |
| <span class="source-line-no">950</span><span id="line-950"> * @throws IllegalArgumentException if length is not {@link #SIZEOF_SHORT} or if there's not</span> |
| <span class="source-line-no">951</span><span id="line-951"> * enough room in the array at the offset indicated.</span> |
| <span class="source-line-no">952</span><span id="line-952"> */</span> |
| <span class="source-line-no">953</span><span id="line-953"> public static short toShort(byte[] bytes, int offset, final int length) {</span> |
| <span class="source-line-no">954</span><span id="line-954"> if (length != SIZEOF_SHORT || offset + length > bytes.length) {</span> |
| <span class="source-line-no">955</span><span id="line-955"> throw explainWrongLengthOrOffset(bytes, offset, length, SIZEOF_SHORT);</span> |
| <span class="source-line-no">956</span><span id="line-956"> }</span> |
| <span class="source-line-no">957</span><span id="line-957"> return ConverterHolder.BEST_CONVERTER.toShort(bytes, offset, length);</span> |
| <span class="source-line-no">958</span><span id="line-958"> }</span> |
| <span class="source-line-no">959</span><span id="line-959"></span> |
| <span class="source-line-no">960</span><span id="line-960"> /**</span> |
| <span class="source-line-no">961</span><span id="line-961"> * Returns a new byte array, copied from the given {@code buf}, from the position (inclusive) to</span> |
| <span class="source-line-no">962</span><span id="line-962"> * the limit (exclusive). The position and the other index parameters are not changed.</span> |
| <span class="source-line-no">963</span><span id="line-963"> * @param buf a byte buffer</span> |
| <span class="source-line-no">964</span><span id="line-964"> * @return the byte array</span> |
| <span class="source-line-no">965</span><span id="line-965"> * @see #toBytes(ByteBuffer)</span> |
| <span class="source-line-no">966</span><span id="line-966"> */</span> |
| <span class="source-line-no">967</span><span id="line-967"> public static byte[] getBytes(ByteBuffer buf) {</span> |
| <span class="source-line-no">968</span><span id="line-968"> return readBytes(buf.duplicate());</span> |
| <span class="source-line-no">969</span><span id="line-969"> }</span> |
| <span class="source-line-no">970</span><span id="line-970"></span> |
| <span class="source-line-no">971</span><span id="line-971"> /**</span> |
| <span class="source-line-no">972</span><span id="line-972"> * Put a short value out to the specified byte array position.</span> |
| <span class="source-line-no">973</span><span id="line-973"> * @param bytes the byte array</span> |
| <span class="source-line-no">974</span><span id="line-974"> * @param offset position in the array</span> |
| <span class="source-line-no">975</span><span id="line-975"> * @param val short to write out</span> |
| <span class="source-line-no">976</span><span id="line-976"> * @return incremented offset</span> |
| <span class="source-line-no">977</span><span id="line-977"> * @throws IllegalArgumentException if the byte array given doesn't have enough room at the offset</span> |
| <span class="source-line-no">978</span><span id="line-978"> * specified.</span> |
| <span class="source-line-no">979</span><span id="line-979"> */</span> |
| <span class="source-line-no">980</span><span id="line-980"> public static int putShort(byte[] bytes, int offset, short val) {</span> |
| <span class="source-line-no">981</span><span id="line-981"> if (bytes.length - offset < SIZEOF_SHORT) {</span> |
| <span class="source-line-no">982</span><span id="line-982"> throw new IllegalArgumentException("Not enough room to put a short at" + " offset " + offset</span> |
| <span class="source-line-no">983</span><span id="line-983"> + " in a " + bytes.length + " byte array");</span> |
| <span class="source-line-no">984</span><span id="line-984"> }</span> |
| <span class="source-line-no">985</span><span id="line-985"> return ConverterHolder.BEST_CONVERTER.putShort(bytes, offset, val);</span> |
| <span class="source-line-no">986</span><span id="line-986"> }</span> |
| <span class="source-line-no">987</span><span id="line-987"></span> |
| <span class="source-line-no">988</span><span id="line-988"> /**</span> |
| <span class="source-line-no">989</span><span id="line-989"> * Put an int value as short out to the specified byte array position. Only the lower 2 bytes of</span> |
| <span class="source-line-no">990</span><span id="line-990"> * the short will be put into the array. The caller of the API need to make sure they will not</span> |
| <span class="source-line-no">991</span><span id="line-991"> * loose the value by doing so. This is useful to store an unsigned short which is represented as</span> |
| <span class="source-line-no">992</span><span id="line-992"> * int in other parts.</span> |
| <span class="source-line-no">993</span><span id="line-993"> * @param bytes the byte array</span> |
| <span class="source-line-no">994</span><span id="line-994"> * @param offset position in the array</span> |
| <span class="source-line-no">995</span><span id="line-995"> * @param val value to write out</span> |
| <span class="source-line-no">996</span><span id="line-996"> * @return incremented offset</span> |
| <span class="source-line-no">997</span><span id="line-997"> * @throws IllegalArgumentException if the byte array given doesn't have enough room at the offset</span> |
| <span class="source-line-no">998</span><span id="line-998"> * specified.</span> |
| <span class="source-line-no">999</span><span id="line-999"> */</span> |
| <span class="source-line-no">1000</span><span id="line-1000"> public static int putAsShort(byte[] bytes, int offset, int val) {</span> |
| <span class="source-line-no">1001</span><span id="line-1001"> if (bytes.length - offset < SIZEOF_SHORT) {</span> |
| <span class="source-line-no">1002</span><span id="line-1002"> throw new IllegalArgumentException("Not enough room to put a short at" + " offset " + offset</span> |
| <span class="source-line-no">1003</span><span id="line-1003"> + " in a " + bytes.length + " byte array");</span> |
| <span class="source-line-no">1004</span><span id="line-1004"> }</span> |
| <span class="source-line-no">1005</span><span id="line-1005"> bytes[offset + 1] = (byte) val;</span> |
| <span class="source-line-no">1006</span><span id="line-1006"> val >>= 8;</span> |
| <span class="source-line-no">1007</span><span id="line-1007"> bytes[offset] = (byte) val;</span> |
| <span class="source-line-no">1008</span><span id="line-1008"> return offset + SIZEOF_SHORT;</span> |
| <span class="source-line-no">1009</span><span id="line-1009"> }</span> |
| <span class="source-line-no">1010</span><span id="line-1010"></span> |
| <span class="source-line-no">1011</span><span id="line-1011"> /** Convert a BigDecimal value to a byte array */</span> |
| <span class="source-line-no">1012</span><span id="line-1012"> public static byte[] toBytes(BigDecimal val) {</span> |
| <span class="source-line-no">1013</span><span id="line-1013"> byte[] valueBytes = val.unscaledValue().toByteArray();</span> |
| <span class="source-line-no">1014</span><span id="line-1014"> byte[] result = new byte[valueBytes.length + SIZEOF_INT];</span> |
| <span class="source-line-no">1015</span><span id="line-1015"> int offset = putInt(result, 0, val.scale());</span> |
| <span class="source-line-no">1016</span><span id="line-1016"> putBytes(result, offset, valueBytes, 0, valueBytes.length);</span> |
| <span class="source-line-no">1017</span><span id="line-1017"> return result;</span> |
| <span class="source-line-no">1018</span><span id="line-1018"> }</span> |
| <span class="source-line-no">1019</span><span id="line-1019"></span> |
| <span class="source-line-no">1020</span><span id="line-1020"> /** Converts a byte array to a BigDecimal */</span> |
| <span class="source-line-no">1021</span><span id="line-1021"> public static BigDecimal toBigDecimal(byte[] bytes) {</span> |
| <span class="source-line-no">1022</span><span id="line-1022"> return toBigDecimal(bytes, 0, bytes.length);</span> |
| <span class="source-line-no">1023</span><span id="line-1023"> }</span> |
| <span class="source-line-no">1024</span><span id="line-1024"></span> |
| <span class="source-line-no">1025</span><span id="line-1025"> /** Converts a byte array to a BigDecimal value */</span> |
| <span class="source-line-no">1026</span><span id="line-1026"> public static BigDecimal toBigDecimal(byte[] bytes, int offset, final int length) {</span> |
| <span class="source-line-no">1027</span><span id="line-1027"> if (bytes == null || length < SIZEOF_INT + 1 || (offset + length > bytes.length)) {</span> |
| <span class="source-line-no">1028</span><span id="line-1028"> return null;</span> |
| <span class="source-line-no">1029</span><span id="line-1029"> }</span> |
| <span class="source-line-no">1030</span><span id="line-1030"></span> |
| <span class="source-line-no">1031</span><span id="line-1031"> int scale = toInt(bytes, offset);</span> |
| <span class="source-line-no">1032</span><span id="line-1032"> byte[] tcBytes = new byte[length - SIZEOF_INT];</span> |
| <span class="source-line-no">1033</span><span id="line-1033"> System.arraycopy(bytes, offset + SIZEOF_INT, tcBytes, 0, length - SIZEOF_INT);</span> |
| <span class="source-line-no">1034</span><span id="line-1034"> return new BigDecimal(new BigInteger(tcBytes), scale);</span> |
| <span class="source-line-no">1035</span><span id="line-1035"> }</span> |
| <span class="source-line-no">1036</span><span id="line-1036"></span> |
| <span class="source-line-no">1037</span><span id="line-1037"> /**</span> |
| <span class="source-line-no">1038</span><span id="line-1038"> * Put a BigDecimal value out to the specified byte array position.</span> |
| <span class="source-line-no">1039</span><span id="line-1039"> * @param bytes the byte array</span> |
| <span class="source-line-no">1040</span><span id="line-1040"> * @param offset position in the array</span> |
| <span class="source-line-no">1041</span><span id="line-1041"> * @param val BigDecimal to write out</span> |
| <span class="source-line-no">1042</span><span id="line-1042"> * @return incremented offset</span> |
| <span class="source-line-no">1043</span><span id="line-1043"> */</span> |
| <span class="source-line-no">1044</span><span id="line-1044"> public static int putBigDecimal(byte[] bytes, int offset, BigDecimal val) {</span> |
| <span class="source-line-no">1045</span><span id="line-1045"> if (bytes == null) {</span> |
| <span class="source-line-no">1046</span><span id="line-1046"> return offset;</span> |
| <span class="source-line-no">1047</span><span id="line-1047"> }</span> |
| <span class="source-line-no">1048</span><span id="line-1048"></span> |
| <span class="source-line-no">1049</span><span id="line-1049"> byte[] valueBytes = val.unscaledValue().toByteArray();</span> |
| <span class="source-line-no">1050</span><span id="line-1050"> byte[] result = new byte[valueBytes.length + SIZEOF_INT];</span> |
| <span class="source-line-no">1051</span><span id="line-1051"> offset = putInt(result, offset, val.scale());</span> |
| <span class="source-line-no">1052</span><span id="line-1052"> return putBytes(result, offset, valueBytes, 0, valueBytes.length);</span> |
| <span class="source-line-no">1053</span><span id="line-1053"> }</span> |
| <span class="source-line-no">1054</span><span id="line-1054"></span> |
| <span class="source-line-no">1055</span><span id="line-1055"> /**</span> |
| <span class="source-line-no">1056</span><span id="line-1056"> * Encode a long value as a variable length integer.</span> |
| <span class="source-line-no">1057</span><span id="line-1057"> * @param vint Integer to make a vint of.</span> |
| <span class="source-line-no">1058</span><span id="line-1058"> * @return Vint as bytes array.</span> |
| <span class="source-line-no">1059</span><span id="line-1059"> */</span> |
| <span class="source-line-no">1060</span><span id="line-1060"> public static byte[] vintToBytes(final long vint) {</span> |
| <span class="source-line-no">1061</span><span id="line-1061"> long i = vint;</span> |
| <span class="source-line-no">1062</span><span id="line-1062"> int size = WritableUtils.getVIntSize(i);</span> |
| <span class="source-line-no">1063</span><span id="line-1063"> byte[] result = new byte[size];</span> |
| <span class="source-line-no">1064</span><span id="line-1064"> int offset = 0;</span> |
| <span class="source-line-no">1065</span><span id="line-1065"> if (i >= -112 && i <= 127) {</span> |
| <span class="source-line-no">1066</span><span id="line-1066"> result[offset] = (byte) i;</span> |
| <span class="source-line-no">1067</span><span id="line-1067"> return result;</span> |
| <span class="source-line-no">1068</span><span id="line-1068"> }</span> |
| <span class="source-line-no">1069</span><span id="line-1069"></span> |
| <span class="source-line-no">1070</span><span id="line-1070"> int len = -112;</span> |
| <span class="source-line-no">1071</span><span id="line-1071"> if (i < 0) {</span> |
| <span class="source-line-no">1072</span><span id="line-1072"> i ^= -1L; // take one's complement'</span> |
| <span class="source-line-no">1073</span><span id="line-1073"> len = -120;</span> |
| <span class="source-line-no">1074</span><span id="line-1074"> }</span> |
| <span class="source-line-no">1075</span><span id="line-1075"></span> |
| <span class="source-line-no">1076</span><span id="line-1076"> long tmp = i;</span> |
| <span class="source-line-no">1077</span><span id="line-1077"> while (tmp != 0) {</span> |
| <span class="source-line-no">1078</span><span id="line-1078"> tmp = tmp >> 8;</span> |
| <span class="source-line-no">1079</span><span id="line-1079"> len--;</span> |
| <span class="source-line-no">1080</span><span id="line-1080"> }</span> |
| <span class="source-line-no">1081</span><span id="line-1081"></span> |
| <span class="source-line-no">1082</span><span id="line-1082"> result[offset++] = (byte) len;</span> |
| <span class="source-line-no">1083</span><span id="line-1083"></span> |
| <span class="source-line-no">1084</span><span id="line-1084"> len = (len < -120) ? -(len + 120) : -(len + 112);</span> |
| <span class="source-line-no">1085</span><span id="line-1085"></span> |
| <span class="source-line-no">1086</span><span id="line-1086"> for (int idx = len; idx != 0; idx--) {</span> |
| <span class="source-line-no">1087</span><span id="line-1087"> int shiftbits = (idx - 1) * 8;</span> |
| <span class="source-line-no">1088</span><span id="line-1088"> long mask = 0xFFL << shiftbits;</span> |
| <span class="source-line-no">1089</span><span id="line-1089"> result[offset++] = (byte) ((i & mask) >> shiftbits);</span> |
| <span class="source-line-no">1090</span><span id="line-1090"> }</span> |
| <span class="source-line-no">1091</span><span id="line-1091"> return result;</span> |
| <span class="source-line-no">1092</span><span id="line-1092"> }</span> |
| <span class="source-line-no">1093</span><span id="line-1093"></span> |
| <span class="source-line-no">1094</span><span id="line-1094"> /**</span> |
| <span class="source-line-no">1095</span><span id="line-1095"> * Reads a zero-compressed encoded long from input buffer and returns it.</span> |
| <span class="source-line-no">1096</span><span id="line-1096"> * @param buffer buffer to convert</span> |
| <span class="source-line-no">1097</span><span id="line-1097"> * @return vint bytes as an integer.</span> |
| <span class="source-line-no">1098</span><span id="line-1098"> */</span> |
| <span class="source-line-no">1099</span><span id="line-1099"> public static long bytesToVint(final byte[] buffer) {</span> |
| <span class="source-line-no">1100</span><span id="line-1100"> int offset = 0;</span> |
| <span class="source-line-no">1101</span><span id="line-1101"> byte firstByte = buffer[offset++];</span> |
| <span class="source-line-no">1102</span><span id="line-1102"> int len = WritableUtils.decodeVIntSize(firstByte);</span> |
| <span class="source-line-no">1103</span><span id="line-1103"> if (len == 1) {</span> |
| <span class="source-line-no">1104</span><span id="line-1104"> return firstByte;</span> |
| <span class="source-line-no">1105</span><span id="line-1105"> }</span> |
| <span class="source-line-no">1106</span><span id="line-1106"> long i = 0;</span> |
| <span class="source-line-no">1107</span><span id="line-1107"> for (int idx = 0; idx < len - 1; idx++) {</span> |
| <span class="source-line-no">1108</span><span id="line-1108"> byte b = buffer[offset++];</span> |
| <span class="source-line-no">1109</span><span id="line-1109"> i = i << 8;</span> |
| <span class="source-line-no">1110</span><span id="line-1110"> i = i | (b & 0xFF);</span> |
| <span class="source-line-no">1111</span><span id="line-1111"> }</span> |
| <span class="source-line-no">1112</span><span id="line-1112"> return (WritableUtils.isNegativeVInt(firstByte) ? ~i : i);</span> |
| <span class="source-line-no">1113</span><span id="line-1113"> }</span> |
| <span class="source-line-no">1114</span><span id="line-1114"></span> |
| <span class="source-line-no">1115</span><span id="line-1115"> /**</span> |
| <span class="source-line-no">1116</span><span id="line-1116"> * Reads a zero-compressed encoded long from input buffer and returns it.</span> |
| <span class="source-line-no">1117</span><span id="line-1117"> * @param buffer Binary array</span> |
| <span class="source-line-no">1118</span><span id="line-1118"> * @param offset Offset into array at which vint begins.</span> |
| <span class="source-line-no">1119</span><span id="line-1119"> * @return deserialized long from buffer.</span> |
| <span class="source-line-no">1120</span><span id="line-1120"> */</span> |
| <span class="source-line-no">1121</span><span id="line-1121"> public static long readAsVLong(final byte[] buffer, final int offset) {</span> |
| <span class="source-line-no">1122</span><span id="line-1122"> byte firstByte = buffer[offset];</span> |
| <span class="source-line-no">1123</span><span id="line-1123"> int len = WritableUtils.decodeVIntSize(firstByte);</span> |
| <span class="source-line-no">1124</span><span id="line-1124"> if (len == 1) {</span> |
| <span class="source-line-no">1125</span><span id="line-1125"> return firstByte;</span> |
| <span class="source-line-no">1126</span><span id="line-1126"> }</span> |
| <span class="source-line-no">1127</span><span id="line-1127"> long i = 0;</span> |
| <span class="source-line-no">1128</span><span id="line-1128"> for (int idx = 0; idx < len - 1; idx++) {</span> |
| <span class="source-line-no">1129</span><span id="line-1129"> byte b = buffer[offset + 1 + idx];</span> |
| <span class="source-line-no">1130</span><span id="line-1130"> i = i << 8;</span> |
| <span class="source-line-no">1131</span><span id="line-1131"> i = i | (b & 0xFF);</span> |
| <span class="source-line-no">1132</span><span id="line-1132"> }</span> |
| <span class="source-line-no">1133</span><span id="line-1133"> return (WritableUtils.isNegativeVInt(firstByte) ? ~i : i);</span> |
| <span class="source-line-no">1134</span><span id="line-1134"> }</span> |
| <span class="source-line-no">1135</span><span id="line-1135"></span> |
| <span class="source-line-no">1136</span><span id="line-1136"> /**</span> |
| <span class="source-line-no">1137</span><span id="line-1137"> * Lexicographically compare two arrays.</span> |
| <span class="source-line-no">1138</span><span id="line-1138"> * @param left left operand</span> |
| <span class="source-line-no">1139</span><span id="line-1139"> * @param right right operand</span> |
| <span class="source-line-no">1140</span><span id="line-1140"> * @return 0 if equal, &lt; 0 if left is less than right, etc.</span> |
| <span class="source-line-no">1141</span><span id="line-1141"> */</span> |
| <span class="source-line-no">1142</span><span id="line-1142"> public static int compareTo(final byte[] left, final byte[] right) {</span> |
| <span class="source-line-no">1143</span><span id="line-1143"> return LexicographicalComparerHolder.BEST_COMPARER.compareTo(left, 0,</span> |
| <span class="source-line-no">1144</span><span id="line-1144"> left == null ? 0 : left.length, right, 0, right == null ? 0 : right.length);</span> |
| <span class="source-line-no">1145</span><span id="line-1145"> }</span> |
| <span class="source-line-no">1146</span><span id="line-1146"></span> |
| <span class="source-line-no">1147</span><span id="line-1147"> /**</span> |
| <span class="source-line-no">1148</span><span id="line-1148"> * Lexicographically compare two arrays.</span> |
| <span class="source-line-no">1149</span><span id="line-1149"> * @param buffer1 left operand</span> |
| <span class="source-line-no">1150</span><span id="line-1150"> * @param buffer2 right operand</span> |
| <span class="source-line-no">1151</span><span id="line-1151"> * @param offset1 Where to start comparing in the left buffer</span> |
| <span class="source-line-no">1152</span><span id="line-1152"> * @param offset2 Where to start comparing in the right buffer</span> |
| <span class="source-line-no">1153</span><span id="line-1153"> * @param length1 How much to compare from the left buffer</span> |
| <span class="source-line-no">1154</span><span id="line-1154"> * @param length2 How much to compare from the right buffer</span> |
| <span class="source-line-no">1155</span><span id="line-1155"> * @return 0 if equal, &lt; 0 if left is less than right, etc.</span> |
| <span class="source-line-no">1156</span><span id="line-1156"> */</span> |
| <span class="source-line-no">1157</span><span id="line-1157"> public static int compareTo(byte[] buffer1, int offset1, int length1, byte[] buffer2, int offset2,</span> |
| <span class="source-line-no">1158</span><span id="line-1158"> int length2) {</span> |
| <span class="source-line-no">1159</span><span id="line-1159"> return LexicographicalComparerHolder.BEST_COMPARER.compareTo(buffer1, offset1, length1, buffer2,</span> |
| <span class="source-line-no">1160</span><span id="line-1160"> offset2, length2);</span> |
| <span class="source-line-no">1161</span><span id="line-1161"> }</span> |
| <span class="source-line-no">1162</span><span id="line-1162"></span> |
| <span class="source-line-no">1163</span><span id="line-1163"> interface Comparer<T> {</span> |
| <span class="source-line-no">1164</span><span id="line-1164"> int compareTo(T buffer1, int offset1, int length1, T buffer2, int offset2, int length2);</span> |
| <span class="source-line-no">1165</span><span id="line-1165"> }</span> |
| <span class="source-line-no">1166</span><span id="line-1166"></span> |
| <span class="source-line-no">1167</span><span id="line-1167"> static abstract class Converter {</span> |
| <span class="source-line-no">1168</span><span id="line-1168"> abstract long toLong(byte[] bytes, int offset, int length);</span> |
| <span class="source-line-no">1169</span><span id="line-1169"></span> |
| <span class="source-line-no">1170</span><span id="line-1170"> abstract int putLong(byte[] bytes, int offset, long val);</span> |
| <span class="source-line-no">1171</span><span id="line-1171"></span> |
| <span class="source-line-no">1172</span><span id="line-1172"> abstract int toInt(byte[] bytes, int offset, final int length);</span> |
| <span class="source-line-no">1173</span><span id="line-1173"></span> |
| <span class="source-line-no">1174</span><span id="line-1174"> abstract int putInt(byte[] bytes, int offset, int val);</span> |
| <span class="source-line-no">1175</span><span id="line-1175"></span> |
| <span class="source-line-no">1176</span><span id="line-1176"> abstract short toShort(byte[] bytes, int offset, final int length);</span> |
| <span class="source-line-no">1177</span><span id="line-1177"></span> |
| <span class="source-line-no">1178</span><span id="line-1178"> abstract int putShort(byte[] bytes, int offset, short val);</span> |
| <span class="source-line-no">1179</span><span id="line-1179"></span> |
| <span class="source-line-no">1180</span><span id="line-1180"> }</span> |
| <span class="source-line-no">1181</span><span id="line-1181"></span> |
| <span class="source-line-no">1182</span><span id="line-1182"> static abstract class CommonPrefixer {</span> |
| <span class="source-line-no">1183</span><span id="line-1183"> abstract int findCommonPrefix(byte[] left, int leftOffset, int leftLength, byte[] right,</span> |
| <span class="source-line-no">1184</span><span id="line-1184"> int rightOffset, int rightLength);</span> |
| <span class="source-line-no">1185</span><span id="line-1185"> }</span> |
| <span class="source-line-no">1186</span><span id="line-1186"></span> |
| <span class="source-line-no">1187</span><span id="line-1187"> static Comparer<byte[]> lexicographicalComparerJavaImpl() {</span> |
| <span class="source-line-no">1188</span><span id="line-1188"> return LexicographicalComparerHolder.PureJavaComparer.INSTANCE;</span> |
| <span class="source-line-no">1189</span><span id="line-1189"> }</span> |
| <span class="source-line-no">1190</span><span id="line-1190"></span> |
| <span class="source-line-no">1191</span><span id="line-1191"> static class ConverterHolder {</span> |
| <span class="source-line-no">1192</span><span id="line-1192"> static final String UNSAFE_CONVERTER_NAME =</span> |
| <span class="source-line-no">1193</span><span id="line-1193"> ConverterHolder.class.getName() + "$UnsafeConverter";</span> |
| <span class="source-line-no">1194</span><span id="line-1194"></span> |
| <span class="source-line-no">1195</span><span id="line-1195"> static final Converter BEST_CONVERTER = getBestConverter();</span> |
| <span class="source-line-no">1196</span><span id="line-1196"></span> |
| <span class="source-line-no">1197</span><span id="line-1197"> /**</span> |
| <span class="source-line-no">1198</span><span id="line-1198"> * Returns the Unsafe-using Converter, or falls back to the pure-Java implementation if unable</span> |
| <span class="source-line-no">1199</span><span id="line-1199"> * to do so.</span> |
| <span class="source-line-no">1200</span><span id="line-1200"> */</span> |
| <span class="source-line-no">1201</span><span id="line-1201"> static Converter getBestConverter() {</span> |
| <span class="source-line-no">1202</span><span id="line-1202"> try {</span> |
| <span class="source-line-no">1203</span><span id="line-1203"> Class<?> theClass = Class.forName(UNSAFE_CONVERTER_NAME);</span> |
| <span class="source-line-no">1204</span><span id="line-1204"></span> |
| <span class="source-line-no">1205</span><span id="line-1205"> // yes, UnsafeComparer does implement Comparer<byte[]></span> |
| <span class="source-line-no">1206</span><span id="line-1206"> @SuppressWarnings("unchecked")</span> |
| <span class="source-line-no">1207</span><span id="line-1207"> Converter converter = (Converter) theClass.getConstructor().newInstance();</span> |
| <span class="source-line-no">1208</span><span id="line-1208"> return converter;</span> |
| <span class="source-line-no">1209</span><span id="line-1209"> } catch (Throwable t) { // ensure we really catch *everything*</span> |
| <span class="source-line-no">1210</span><span id="line-1210"> return PureJavaConverter.INSTANCE;</span> |
| <span class="source-line-no">1211</span><span id="line-1211"> }</span> |
| <span class="source-line-no">1212</span><span id="line-1212"> }</span> |
| <span class="source-line-no">1213</span><span id="line-1213"></span> |
| <span class="source-line-no">1214</span><span id="line-1214"> protected static final class PureJavaConverter extends Converter {</span> |
| <span class="source-line-no">1215</span><span id="line-1215"> static final PureJavaConverter INSTANCE = new PureJavaConverter();</span> |
| <span class="source-line-no">1216</span><span id="line-1216"></span> |
| <span class="source-line-no">1217</span><span id="line-1217"> private PureJavaConverter() {</span> |
| <span class="source-line-no">1218</span><span id="line-1218"> }</span> |
| <span class="source-line-no">1219</span><span id="line-1219"></span> |
| <span class="source-line-no">1220</span><span id="line-1220"> @Override</span> |
| <span class="source-line-no">1221</span><span id="line-1221"> long toLong(byte[] bytes, int offset, int length) {</span> |
| <span class="source-line-no">1222</span><span id="line-1222"> long l = 0;</span> |
| <span class="source-line-no">1223</span><span id="line-1223"> for (int i = offset; i < offset + length; i++) {</span> |
| <span class="source-line-no">1224</span><span id="line-1224"> l <<= 8;</span> |
| <span class="source-line-no">1225</span><span id="line-1225"> l ^= bytes[i] & 0xFF;</span> |
| <span class="source-line-no">1226</span><span id="line-1226"> }</span> |
| <span class="source-line-no">1227</span><span id="line-1227"> return l;</span> |
| <span class="source-line-no">1228</span><span id="line-1228"> }</span> |
| <span class="source-line-no">1229</span><span id="line-1229"></span> |
| <span class="source-line-no">1230</span><span id="line-1230"> @Override</span> |
| <span class="source-line-no">1231</span><span id="line-1231"> int putLong(byte[] bytes, int offset, long val) {</span> |
| <span class="source-line-no">1232</span><span id="line-1232"> for (int i = offset + 7; i > offset; i--) {</span> |
| <span class="source-line-no">1233</span><span id="line-1233"> bytes[i] = (byte) val;</span> |
| <span class="source-line-no">1234</span><span id="line-1234"> val >>>= 8;</span> |
| <span class="source-line-no">1235</span><span id="line-1235"> }</span> |
| <span class="source-line-no">1236</span><span id="line-1236"> bytes[offset] = (byte) val;</span> |
| <span class="source-line-no">1237</span><span id="line-1237"> return offset + SIZEOF_LONG;</span> |
| <span class="source-line-no">1238</span><span id="line-1238"> }</span> |
| <span class="source-line-no">1239</span><span id="line-1239"></span> |
| <span class="source-line-no">1240</span><span id="line-1240"> @Override</span> |
| <span class="source-line-no">1241</span><span id="line-1241"> int toInt(byte[] bytes, int offset, int length) {</span> |
| <span class="source-line-no">1242</span><span id="line-1242"> int n = 0;</span> |
| <span class="source-line-no">1243</span><span id="line-1243"> for (int i = offset; i < (offset + length); i++) {</span> |
| <span class="source-line-no">1244</span><span id="line-1244"> n <<= 8;</span> |
| <span class="source-line-no">1245</span><span id="line-1245"> n ^= bytes[i] & 0xFF;</span> |
| <span class="source-line-no">1246</span><span id="line-1246"> }</span> |
| <span class="source-line-no">1247</span><span id="line-1247"> return n;</span> |
| <span class="source-line-no">1248</span><span id="line-1248"> }</span> |
| <span class="source-line-no">1249</span><span id="line-1249"></span> |
| <span class="source-line-no">1250</span><span id="line-1250"> @Override</span> |
| <span class="source-line-no">1251</span><span id="line-1251"> int putInt(byte[] bytes, int offset, int val) {</span> |
| <span class="source-line-no">1252</span><span id="line-1252"> for (int i = offset + 3; i > offset; i--) {</span> |
| <span class="source-line-no">1253</span><span id="line-1253"> bytes[i] = (byte) val;</span> |
| <span class="source-line-no">1254</span><span id="line-1254"> val >>>= 8;</span> |
| <span class="source-line-no">1255</span><span id="line-1255"> }</span> |
| <span class="source-line-no">1256</span><span id="line-1256"> bytes[offset] = (byte) val;</span> |
| <span class="source-line-no">1257</span><span id="line-1257"> return offset + SIZEOF_INT;</span> |
| <span class="source-line-no">1258</span><span id="line-1258"> }</span> |
| <span class="source-line-no">1259</span><span id="line-1259"></span> |
| <span class="source-line-no">1260</span><span id="line-1260"> @Override</span> |
| <span class="source-line-no">1261</span><span id="line-1261"> short toShort(byte[] bytes, int offset, int length) {</span> |
| <span class="source-line-no">1262</span><span id="line-1262"> short n = 0;</span> |
| <span class="source-line-no">1263</span><span id="line-1263"> n = (short) ((n ^ bytes[offset]) & 0xFF);</span> |
| <span class="source-line-no">1264</span><span id="line-1264"> n = (short) (n << 8);</span> |
| <span class="source-line-no">1265</span><span id="line-1265"> n ^= (short) (bytes[offset + 1] & 0xFF);</span> |
| <span class="source-line-no">1266</span><span id="line-1266"> return n;</span> |
| <span class="source-line-no">1267</span><span id="line-1267"> }</span> |
| <span class="source-line-no">1268</span><span id="line-1268"></span> |
| <span class="source-line-no">1269</span><span id="line-1269"> @Override</span> |
| <span class="source-line-no">1270</span><span id="line-1270"> int putShort(byte[] bytes, int offset, short val) {</span> |
| <span class="source-line-no">1271</span><span id="line-1271"> bytes[offset + 1] = (byte) val;</span> |
| <span class="source-line-no">1272</span><span id="line-1272"> val >>= 8;</span> |
| <span class="source-line-no">1273</span><span id="line-1273"> bytes[offset] = (byte) val;</span> |
| <span class="source-line-no">1274</span><span id="line-1274"> return offset + SIZEOF_SHORT;</span> |
| <span class="source-line-no">1275</span><span id="line-1275"> }</span> |
| <span class="source-line-no">1276</span><span id="line-1276"> }</span> |
| <span class="source-line-no">1277</span><span id="line-1277"></span> |
| <span class="source-line-no">1278</span><span id="line-1278"> protected static final class UnsafeConverter extends Converter {</span> |
| <span class="source-line-no">1279</span><span id="line-1279"></span> |
| <span class="source-line-no">1280</span><span id="line-1280"> public UnsafeConverter() {</span> |
| <span class="source-line-no">1281</span><span id="line-1281"> }</span> |
| <span class="source-line-no">1282</span><span id="line-1282"></span> |
| <span class="source-line-no">1283</span><span id="line-1283"> static {</span> |
| <span class="source-line-no">1284</span><span id="line-1284"> if (!UNSAFE_UNALIGNED) {</span> |
| <span class="source-line-no">1285</span><span id="line-1285"> // It doesn't matter what we throw;</span> |
| <span class="source-line-no">1286</span><span id="line-1286"> // it's swallowed in getBestComparer().</span> |
| <span class="source-line-no">1287</span><span id="line-1287"> throw new Error();</span> |
| <span class="source-line-no">1288</span><span id="line-1288"> }</span> |
| <span class="source-line-no">1289</span><span id="line-1289"></span> |
| <span class="source-line-no">1290</span><span id="line-1290"> // sanity check - this should never fail</span> |
| <span class="source-line-no">1291</span><span id="line-1291"> if (HBasePlatformDependent.arrayIndexScale(byte[].class) != 1) {</span> |
| <span class="source-line-no">1292</span><span id="line-1292"> throw new AssertionError();</span> |
| <span class="source-line-no">1293</span><span id="line-1293"> }</span> |
| <span class="source-line-no">1294</span><span id="line-1294"> }</span> |
| <span class="source-line-no">1295</span><span id="line-1295"></span> |
| <span class="source-line-no">1296</span><span id="line-1296"> @Override</span> |
| <span class="source-line-no">1297</span><span id="line-1297"> long toLong(byte[] bytes, int offset, int length) {</span> |
| <span class="source-line-no">1298</span><span id="line-1298"> return UnsafeAccess.toLong(bytes, offset);</span> |
| <span class="source-line-no">1299</span><span id="line-1299"> }</span> |
| <span class="source-line-no">1300</span><span id="line-1300"></span> |
| <span class="source-line-no">1301</span><span id="line-1301"> @Override</span> |
| <span class="source-line-no">1302</span><span id="line-1302"> int putLong(byte[] bytes, int offset, long val) {</span> |
| <span class="source-line-no">1303</span><span id="line-1303"> return UnsafeAccess.putLong(bytes, offset, val);</span> |
| <span class="source-line-no">1304</span><span id="line-1304"> }</span> |
| <span class="source-line-no">1305</span><span id="line-1305"></span> |
| <span class="source-line-no">1306</span><span id="line-1306"> @Override</span> |
| <span class="source-line-no">1307</span><span id="line-1307"> int toInt(byte[] bytes, int offset, int length) {</span> |
| <span class="source-line-no">1308</span><span id="line-1308"> return UnsafeAccess.toInt(bytes, offset);</span> |
| <span class="source-line-no">1309</span><span id="line-1309"> }</span> |
| <span class="source-line-no">1310</span><span id="line-1310"></span> |
| <span class="source-line-no">1311</span><span id="line-1311"> @Override</span> |
| <span class="source-line-no">1312</span><span id="line-1312"> int putInt(byte[] bytes, int offset, int val) {</span> |
| <span class="source-line-no">1313</span><span id="line-1313"> return UnsafeAccess.putInt(bytes, offset, val);</span> |
| <span class="source-line-no">1314</span><span id="line-1314"> }</span> |
| <span class="source-line-no">1315</span><span id="line-1315"></span> |
| <span class="source-line-no">1316</span><span id="line-1316"> @Override</span> |
| <span class="source-line-no">1317</span><span id="line-1317"> short toShort(byte[] bytes, int offset, int length) {</span> |
| <span class="source-line-no">1318</span><span id="line-1318"> return UnsafeAccess.toShort(bytes, offset);</span> |
| <span class="source-line-no">1319</span><span id="line-1319"> }</span> |
| <span class="source-line-no">1320</span><span id="line-1320"></span> |
| <span class="source-line-no">1321</span><span id="line-1321"> @Override</span> |
| <span class="source-line-no">1322</span><span id="line-1322"> int putShort(byte[] bytes, int offset, short val) {</span> |
| <span class="source-line-no">1323</span><span id="line-1323"> return UnsafeAccess.putShort(bytes, offset, val);</span> |
| <span class="source-line-no">1324</span><span id="line-1324"> }</span> |
| <span class="source-line-no">1325</span><span id="line-1325"> }</span> |
| <span class="source-line-no">1326</span><span id="line-1326"> }</span> |
| <span class="source-line-no">1327</span><span id="line-1327"></span> |
| <span class="source-line-no">1328</span><span id="line-1328"> /**</span> |
| <span class="source-line-no">1329</span><span id="line-1329"> * Provides a lexicographical comparer implementation; either a Java implementation or a faster</span> |
| <span class="source-line-no">1330</span><span id="line-1330"> * implementation based on {@code Unsafe}.</span> |
| <span class="source-line-no">1331</span><span id="line-1331"> * <p></span> |
| <span class="source-line-no">1332</span><span id="line-1332"> * Uses reflection to gracefully fall back to the Java implementation if {@code Unsafe} isn't</span> |
| <span class="source-line-no">1333</span><span id="line-1333"> * available.</span> |
| <span class="source-line-no">1334</span><span id="line-1334"> */</span> |
| <span class="source-line-no">1335</span><span id="line-1335"> static class LexicographicalComparerHolder {</span> |
| <span class="source-line-no">1336</span><span id="line-1336"> static final String UNSAFE_COMPARER_NAME =</span> |
| <span class="source-line-no">1337</span><span id="line-1337"> LexicographicalComparerHolder.class.getName() + "$UnsafeComparer";</span> |
| <span class="source-line-no">1338</span><span id="line-1338"></span> |
| <span class="source-line-no">1339</span><span id="line-1339"> static final Comparer<byte[]> BEST_COMPARER = getBestComparer();</span> |
| <span class="source-line-no">1340</span><span id="line-1340"></span> |
| <span class="source-line-no">1341</span><span id="line-1341"> /**</span> |
| <span class="source-line-no">1342</span><span id="line-1342"> * Returns the Unsafe-using Comparer, or falls back to the pure-Java implementation if unable to</span> |
| <span class="source-line-no">1343</span><span id="line-1343"> * do so.</span> |
| <span class="source-line-no">1344</span><span id="line-1344"> */</span> |
| <span class="source-line-no">1345</span><span id="line-1345"> static Comparer<byte[]> getBestComparer() {</span> |
| <span class="source-line-no">1346</span><span id="line-1346"> try {</span> |
| <span class="source-line-no">1347</span><span id="line-1347"> Class<?> theClass = Class.forName(UNSAFE_COMPARER_NAME);</span> |
| <span class="source-line-no">1348</span><span id="line-1348"></span> |
| <span class="source-line-no">1349</span><span id="line-1349"> // yes, UnsafeComparer does implement Comparer<byte[]></span> |
| <span class="source-line-no">1350</span><span id="line-1350"> @SuppressWarnings("unchecked")</span> |
| <span class="source-line-no">1351</span><span id="line-1351"> Comparer<byte[]> comparer = (Comparer<byte[]>) theClass.getEnumConstants()[0];</span> |
| <span class="source-line-no">1352</span><span id="line-1352"> return comparer;</span> |
| <span class="source-line-no">1353</span><span id="line-1353"> } catch (Throwable t) { // ensure we really catch *everything*</span> |
| <span class="source-line-no">1354</span><span id="line-1354"> return lexicographicalComparerJavaImpl();</span> |
| <span class="source-line-no">1355</span><span id="line-1355"> }</span> |
| <span class="source-line-no">1356</span><span id="line-1356"> }</span> |
| <span class="source-line-no">1357</span><span id="line-1357"></span> |
| <span class="source-line-no">1358</span><span id="line-1358"> enum PureJavaComparer implements Comparer<byte[]> {</span> |
| <span class="source-line-no">1359</span><span id="line-1359"> INSTANCE;</span> |
| <span class="source-line-no">1360</span><span id="line-1360"></span> |
| <span class="source-line-no">1361</span><span id="line-1361"> @Override</span> |
| <span class="source-line-no">1362</span><span id="line-1362"> public int compareTo(byte[] buffer1, int offset1, int length1, byte[] buffer2, int offset2,</span> |
| <span class="source-line-no">1363</span><span id="line-1363"> int length2) {</span> |
| <span class="source-line-no">1364</span><span id="line-1364"> // Short circuit equal case</span> |
| <span class="source-line-no">1365</span><span id="line-1365"> if (buffer1 == buffer2 && offset1 == offset2 && length1 == length2) {</span> |
| <span class="source-line-no">1366</span><span id="line-1366"> return 0;</span> |
| <span class="source-line-no">1367</span><span id="line-1367"> }</span> |
| <span class="source-line-no">1368</span><span id="line-1368"> // Bring WritableComparator code local</span> |
| <span class="source-line-no">1369</span><span id="line-1369"> int end1 = offset1 + length1;</span> |
| <span class="source-line-no">1370</span><span id="line-1370"> int end2 = offset2 + length2;</span> |
| <span class="source-line-no">1371</span><span id="line-1371"> for (int i = offset1, j = offset2; i < end1 && j < end2; i++, j++) {</span> |
| <span class="source-line-no">1372</span><span id="line-1372"> int a = (buffer1[i] & 0xff);</span> |
| <span class="source-line-no">1373</span><span id="line-1373"> int b = (buffer2[j] & 0xff);</span> |
| <span class="source-line-no">1374</span><span id="line-1374"> if (a != b) {</span> |
| <span class="source-line-no">1375</span><span id="line-1375"> return a - b;</span> |
| <span class="source-line-no">1376</span><span id="line-1376"> }</span> |
| <span class="source-line-no">1377</span><span id="line-1377"> }</span> |
| <span class="source-line-no">1378</span><span id="line-1378"> return length1 - length2;</span> |
| <span class="source-line-no">1379</span><span id="line-1379"> }</span> |
| <span class="source-line-no">1380</span><span id="line-1380"> }</span> |
| <span class="source-line-no">1381</span><span id="line-1381"></span> |
| <span class="source-line-no">1382</span><span id="line-1382"> enum UnsafeComparer implements Comparer<byte[]> {</span> |
| <span class="source-line-no">1383</span><span id="line-1383"> INSTANCE;</span> |
| <span class="source-line-no">1384</span><span id="line-1384"></span> |
| <span class="source-line-no">1385</span><span id="line-1385"> static {</span> |
| <span class="source-line-no">1386</span><span id="line-1386"> if (!UNSAFE_UNALIGNED) {</span> |
| <span class="source-line-no">1387</span><span id="line-1387"> // It doesn't matter what we throw;</span> |
| <span class="source-line-no">1388</span><span id="line-1388"> // it's swallowed in getBestComparer().</span> |
| <span class="source-line-no">1389</span><span id="line-1389"> throw new Error();</span> |
| <span class="source-line-no">1390</span><span id="line-1390"> }</span> |
| <span class="source-line-no">1391</span><span id="line-1391"></span> |
| <span class="source-line-no">1392</span><span id="line-1392"> // sanity check - this should never fail</span> |
| <span class="source-line-no">1393</span><span id="line-1393"> if (HBasePlatformDependent.arrayIndexScale(byte[].class) != 1) {</span> |
| <span class="source-line-no">1394</span><span id="line-1394"> throw new AssertionError();</span> |
| <span class="source-line-no">1395</span><span id="line-1395"> }</span> |
| <span class="source-line-no">1396</span><span id="line-1396"> }</span> |
| <span class="source-line-no">1397</span><span id="line-1397"></span> |
| <span class="source-line-no">1398</span><span id="line-1398"> /**</span> |
| <span class="source-line-no">1399</span><span id="line-1399"> * Lexicographically compare two arrays.</span> |
| <span class="source-line-no">1400</span><span id="line-1400"> * @param buffer1 left operand</span> |
| <span class="source-line-no">1401</span><span id="line-1401"> * @param buffer2 right operand</span> |
| <span class="source-line-no">1402</span><span id="line-1402"> * @param offset1 Where to start comparing in the left buffer</span> |
| <span class="source-line-no">1403</span><span id="line-1403"> * @param offset2 Where to start comparing in the right buffer</span> |
| <span class="source-line-no">1404</span><span id="line-1404"> * @param length1 How much to compare from the left buffer</span> |
| <span class="source-line-no">1405</span><span id="line-1405"> * @param length2 How much to compare from the right buffer</span> |
| <span class="source-line-no">1406</span><span id="line-1406"> * @return 0 if equal, < 0 if left is less than right, etc.</span> |
| <span class="source-line-no">1407</span><span id="line-1407"> */</span> |
| <span class="source-line-no">1408</span><span id="line-1408"> @Override</span> |
| <span class="source-line-no">1409</span><span id="line-1409"> public int compareTo(byte[] buffer1, int offset1, int length1, byte[] buffer2, int offset2,</span> |
| <span class="source-line-no">1410</span><span id="line-1410"> int length2) {</span> |
| <span class="source-line-no">1411</span><span id="line-1411"></span> |
| <span class="source-line-no">1412</span><span id="line-1412"> // Short circuit equal case</span> |
| <span class="source-line-no">1413</span><span id="line-1413"> if (buffer1 == buffer2 && offset1 == offset2 && length1 == length2) {</span> |
| <span class="source-line-no">1414</span><span id="line-1414"> return 0;</span> |
| <span class="source-line-no">1415</span><span id="line-1415"> }</span> |
| <span class="source-line-no">1416</span><span id="line-1416"> final int stride = 8;</span> |
| <span class="source-line-no">1417</span><span id="line-1417"> final int minLength = Math.min(length1, length2);</span> |
| <span class="source-line-no">1418</span><span id="line-1418"> int strideLimit = minLength & ~(stride - 1);</span> |
| <span class="source-line-no">1419</span><span id="line-1419"> final long offset1Adj = offset1 + UnsafeAccess.BYTE_ARRAY_BASE_OFFSET;</span> |
| <span class="source-line-no">1420</span><span id="line-1420"> final long offset2Adj = offset2 + UnsafeAccess.BYTE_ARRAY_BASE_OFFSET;</span> |
| <span class="source-line-no">1421</span><span id="line-1421"> int i;</span> |
| <span class="source-line-no">1422</span><span id="line-1422"></span> |
| <span class="source-line-no">1423</span><span id="line-1423"> /*</span> |
| <span class="source-line-no">1424</span><span id="line-1424"> * Compare 8 bytes at a time. Benchmarking on x86 shows a stride of 8 bytes is no slower</span> |
| <span class="source-line-no">1425</span><span id="line-1425"> * than 4 bytes even on 32-bit. On the other hand, it is substantially faster on 64-bit.</span> |
| <span class="source-line-no">1426</span><span id="line-1426"> */</span> |
| <span class="source-line-no">1427</span><span id="line-1427"> for (i = 0; i < strideLimit; i += stride) {</span> |
| <span class="source-line-no">1428</span><span id="line-1428"> long lw = HBasePlatformDependent.getLong(buffer1, offset1Adj + i);</span> |
| <span class="source-line-no">1429</span><span id="line-1429"> long rw = HBasePlatformDependent.getLong(buffer2, offset2Adj + i);</span> |
| <span class="source-line-no">1430</span><span id="line-1430"> if (lw != rw) {</span> |
| <span class="source-line-no">1431</span><span id="line-1431"> if (!UnsafeAccess.LITTLE_ENDIAN) {</span> |
| <span class="source-line-no">1432</span><span id="line-1432"> return ((lw + Long.MIN_VALUE) < (rw + Long.MIN_VALUE)) ? -1 : 1;</span> |
| <span class="source-line-no">1433</span><span id="line-1433"> }</span> |
| <span class="source-line-no">1434</span><span id="line-1434"></span> |
| <span class="source-line-no">1435</span><span id="line-1435"> /*</span> |
| <span class="source-line-no">1436</span><span id="line-1436"> * We want to compare only the first index where left[index] != right[index]. This</span> |
| <span class="source-line-no">1437</span><span id="line-1437"> * corresponds to the least significant nonzero byte in lw ^ rw, since lw and rw are</span> |
| <span class="source-line-no">1438</span><span id="line-1438"> * little-endian. Long.numberOfTrailingZeros(diff) tells us the least significant</span> |
| <span class="source-line-no">1439</span><span id="line-1439"> * nonzero bit, and zeroing out the first three bits of L.nTZ gives us the shift to get</span> |
| <span class="source-line-no">1440</span><span id="line-1440"> * that least significant nonzero byte. This comparison logic is based on UnsignedBytes</span> |
| <span class="source-line-no">1441</span><span id="line-1441"> * comparator from guava v21</span> |
| <span class="source-line-no">1442</span><span id="line-1442"> */</span> |
| <span class="source-line-no">1443</span><span id="line-1443"> int n = Long.numberOfTrailingZeros(lw ^ rw) & ~0x7;</span> |
| <span class="source-line-no">1444</span><span id="line-1444"> return ((int) ((lw >>> n) & 0xFF)) - ((int) ((rw >>> n) & 0xFF));</span> |
| <span class="source-line-no">1445</span><span id="line-1445"> }</span> |
| <span class="source-line-no">1446</span><span id="line-1446"> }</span> |
| <span class="source-line-no">1447</span><span id="line-1447"></span> |
| <span class="source-line-no">1448</span><span id="line-1448"> // The epilogue to cover the last (minLength % stride) elements.</span> |
| <span class="source-line-no">1449</span><span id="line-1449"> for (; i < minLength; i++) {</span> |
| <span class="source-line-no">1450</span><span id="line-1450"> int a = (buffer1[offset1 + i] & 0xFF);</span> |
| <span class="source-line-no">1451</span><span id="line-1451"> int b = (buffer2[offset2 + i] & 0xFF);</span> |
| <span class="source-line-no">1452</span><span id="line-1452"> if (a != b) {</span> |
| <span class="source-line-no">1453</span><span id="line-1453"> return a - b;</span> |
| <span class="source-line-no">1454</span><span id="line-1454"> }</span> |
| <span class="source-line-no">1455</span><span id="line-1455"> }</span> |
| <span class="source-line-no">1456</span><span id="line-1456"> return length1 - length2;</span> |
| <span class="source-line-no">1457</span><span id="line-1457"> }</span> |
| <span class="source-line-no">1458</span><span id="line-1458"> }</span> |
| <span class="source-line-no">1459</span><span id="line-1459"> }</span> |
| <span class="source-line-no">1460</span><span id="line-1460"></span> |
| <span class="source-line-no">1461</span><span id="line-1461"> static class CommonPrefixerHolder {</span> |
| <span class="source-line-no">1462</span><span id="line-1462"> static final String UNSAFE_COMMON_PREFIXER_NAME =</span> |
| <span class="source-line-no">1463</span><span id="line-1463"> CommonPrefixerHolder.class.getName() + "$UnsafeCommonPrefixer";</span> |
| <span class="source-line-no">1464</span><span id="line-1464"></span> |
| <span class="source-line-no">1465</span><span id="line-1465"> static final CommonPrefixer BEST_COMMON_PREFIXER = getBestCommonPrefixer();</span> |
| <span class="source-line-no">1466</span><span id="line-1466"></span> |
| <span class="source-line-no">1467</span><span id="line-1467"> static CommonPrefixer getBestCommonPrefixer() {</span> |
| <span class="source-line-no">1468</span><span id="line-1468"> try {</span> |
| <span class="source-line-no">1469</span><span id="line-1469"> Class<? extends CommonPrefixer> theClass =</span> |
| <span class="source-line-no">1470</span><span id="line-1470"> Class.forName(UNSAFE_COMMON_PREFIXER_NAME).asSubclass(CommonPrefixer.class);</span> |
| <span class="source-line-no">1471</span><span id="line-1471"></span> |
| <span class="source-line-no">1472</span><span id="line-1472"> return theClass.getConstructor().newInstance();</span> |
| <span class="source-line-no">1473</span><span id="line-1473"> } catch (Throwable t) { // ensure we really catch *everything*</span> |
| <span class="source-line-no">1474</span><span id="line-1474"> return CommonPrefixerHolder.PureJavaCommonPrefixer.INSTANCE;</span> |
| <span class="source-line-no">1475</span><span id="line-1475"> }</span> |
| <span class="source-line-no">1476</span><span id="line-1476"> }</span> |
| <span class="source-line-no">1477</span><span id="line-1477"></span> |
| <span class="source-line-no">1478</span><span id="line-1478"> static final class PureJavaCommonPrefixer extends CommonPrefixer {</span> |
| <span class="source-line-no">1479</span><span id="line-1479"> static final PureJavaCommonPrefixer INSTANCE = new PureJavaCommonPrefixer();</span> |
| <span class="source-line-no">1480</span><span id="line-1480"></span> |
| <span class="source-line-no">1481</span><span id="line-1481"> private PureJavaCommonPrefixer() {</span> |
| <span class="source-line-no">1482</span><span id="line-1482"> }</span> |
| <span class="source-line-no">1483</span><span id="line-1483"></span> |
| <span class="source-line-no">1484</span><span id="line-1484"> @Override</span> |
| <span class="source-line-no">1485</span><span id="line-1485"> public int findCommonPrefix(byte[] left, int leftOffset, int leftLength, byte[] right,</span> |
| <span class="source-line-no">1486</span><span id="line-1486"> int rightOffset, int rightLength) {</span> |
| <span class="source-line-no">1487</span><span id="line-1487"> int length = Math.min(leftLength, rightLength);</span> |
| <span class="source-line-no">1488</span><span id="line-1488"> int result = 0;</span> |
| <span class="source-line-no">1489</span><span id="line-1489"></span> |
| <span class="source-line-no">1490</span><span id="line-1490"> while (result < length && left[leftOffset + result] == right[rightOffset + result]) {</span> |
| <span class="source-line-no">1491</span><span id="line-1491"> result++;</span> |
| <span class="source-line-no">1492</span><span id="line-1492"> }</span> |
| <span class="source-line-no">1493</span><span id="line-1493"> return result;</span> |
| <span class="source-line-no">1494</span><span id="line-1494"> }</span> |
| <span class="source-line-no">1495</span><span id="line-1495"> }</span> |
| <span class="source-line-no">1496</span><span id="line-1496"></span> |
| <span class="source-line-no">1497</span><span id="line-1497"> static final class UnsafeCommonPrefixer extends CommonPrefixer {</span> |
| <span class="source-line-no">1498</span><span id="line-1498"></span> |
| <span class="source-line-no">1499</span><span id="line-1499"> static {</span> |
| <span class="source-line-no">1500</span><span id="line-1500"> if (!UNSAFE_UNALIGNED) {</span> |
| <span class="source-line-no">1501</span><span id="line-1501"> throw new Error();</span> |
| <span class="source-line-no">1502</span><span id="line-1502"> }</span> |
| <span class="source-line-no">1503</span><span id="line-1503"></span> |
| <span class="source-line-no">1504</span><span id="line-1504"> // sanity check - this should never fail</span> |
| <span class="source-line-no">1505</span><span id="line-1505"> if (HBasePlatformDependent.arrayIndexScale(byte[].class) != 1) {</span> |
| <span class="source-line-no">1506</span><span id="line-1506"> throw new AssertionError();</span> |
| <span class="source-line-no">1507</span><span id="line-1507"> }</span> |
| <span class="source-line-no">1508</span><span id="line-1508"> }</span> |
| <span class="source-line-no">1509</span><span id="line-1509"></span> |
| <span class="source-line-no">1510</span><span id="line-1510"> public UnsafeCommonPrefixer() {</span> |
| <span class="source-line-no">1511</span><span id="line-1511"> }</span> |
| <span class="source-line-no">1512</span><span id="line-1512"></span> |
| <span class="source-line-no">1513</span><span id="line-1513"> @Override</span> |
| <span class="source-line-no">1514</span><span id="line-1514"> public int findCommonPrefix(byte[] left, int leftOffset, int leftLength, byte[] right,</span> |
| <span class="source-line-no">1515</span><span id="line-1515"> int rightOffset, int rightLength) {</span> |
| <span class="source-line-no">1516</span><span id="line-1516"> final int stride = 8;</span> |
| <span class="source-line-no">1517</span><span id="line-1517"> final int minLength = Math.min(leftLength, rightLength);</span> |
| <span class="source-line-no">1518</span><span id="line-1518"> int strideLimit = minLength & ~(stride - 1);</span> |
| <span class="source-line-no">1519</span><span id="line-1519"> final long leftOffsetAdj = leftOffset + UnsafeAccess.BYTE_ARRAY_BASE_OFFSET;</span> |
| <span class="source-line-no">1520</span><span id="line-1520"> final long rightOffsetAdj = rightOffset + UnsafeAccess.BYTE_ARRAY_BASE_OFFSET;</span> |
| <span class="source-line-no">1521</span><span id="line-1521"> int result = 0;</span> |
| <span class="source-line-no">1522</span><span id="line-1522"> int i;</span> |
| <span class="source-line-no">1523</span><span id="line-1523"></span> |
| <span class="source-line-no">1524</span><span id="line-1524"> for (i = 0; i < strideLimit; i += stride) {</span> |
| <span class="source-line-no">1525</span><span id="line-1525"> long lw = HBasePlatformDependent.getLong(left, leftOffsetAdj + i);</span> |
| <span class="source-line-no">1526</span><span id="line-1526"> long rw = HBasePlatformDependent.getLong(right, rightOffsetAdj + i);</span> |
| <span class="source-line-no">1527</span><span id="line-1527"> if (lw != rw) {</span> |
| <span class="source-line-no">1528</span><span id="line-1528"> if (!UnsafeAccess.LITTLE_ENDIAN) {</span> |
| <span class="source-line-no">1529</span><span id="line-1529"> return result + (Long.numberOfLeadingZeros(lw ^ rw) / Bytes.SIZEOF_LONG);</span> |
| <span class="source-line-no">1530</span><span id="line-1530"> } else {</span> |
| <span class="source-line-no">1531</span><span id="line-1531"> return result + (Long.numberOfTrailingZeros(lw ^ rw) / Bytes.SIZEOF_LONG);</span> |
| <span class="source-line-no">1532</span><span id="line-1532"> }</span> |
| <span class="source-line-no">1533</span><span id="line-1533"> } else {</span> |
| <span class="source-line-no">1534</span><span id="line-1534"> result += Bytes.SIZEOF_LONG;</span> |
| <span class="source-line-no">1535</span><span id="line-1535"> }</span> |
| <span class="source-line-no">1536</span><span id="line-1536"> }</span> |
| <span class="source-line-no">1537</span><span id="line-1537"></span> |
| <span class="source-line-no">1538</span><span id="line-1538"> // The epilogue to cover the last (minLength % stride) elements.</span> |
| <span class="source-line-no">1539</span><span id="line-1539"> for (; i < minLength; i++) {</span> |
| <span class="source-line-no">1540</span><span id="line-1540"> int il = (left[leftOffset + i]);</span> |
| <span class="source-line-no">1541</span><span id="line-1541"> int ir = (right[rightOffset + i]);</span> |
| <span class="source-line-no">1542</span><span id="line-1542"> if (il != ir) {</span> |
| <span class="source-line-no">1543</span><span id="line-1543"> return result;</span> |
| <span class="source-line-no">1544</span><span id="line-1544"> } else {</span> |
| <span class="source-line-no">1545</span><span id="line-1545"> result++;</span> |
| <span class="source-line-no">1546</span><span id="line-1546"> }</span> |
| <span class="source-line-no">1547</span><span id="line-1547"> }</span> |
| <span class="source-line-no">1548</span><span id="line-1548"></span> |
| <span class="source-line-no">1549</span><span id="line-1549"> return result;</span> |
| <span class="source-line-no">1550</span><span id="line-1550"> }</span> |
| <span class="source-line-no">1551</span><span id="line-1551"> }</span> |
| <span class="source-line-no">1552</span><span id="line-1552"> }</span> |
| <span class="source-line-no">1553</span><span id="line-1553"></span> |
| <span class="source-line-no">1554</span><span id="line-1554"> /**</span> |
| <span class="source-line-no">1555</span><span id="line-1555"> * Lexicographically determine the equality of two arrays.</span> |
| <span class="source-line-no">1556</span><span id="line-1556"> * @param left left operand</span> |
| <span class="source-line-no">1557</span><span id="line-1557"> * @param right right operand</span> |
| <span class="source-line-no">1558</span><span id="line-1558"> * @return True if equal</span> |
| <span class="source-line-no">1559</span><span id="line-1559"> */</span> |
| <span class="source-line-no">1560</span><span id="line-1560"> public static boolean equals(final byte[] left, final byte[] right) {</span> |
| <span class="source-line-no">1561</span><span id="line-1561"> // Could use Arrays.equals?</span> |
| <span class="source-line-no">1562</span><span id="line-1562"> // noinspection SimplifiableConditionalExpression</span> |
| <span class="source-line-no">1563</span><span id="line-1563"> if (left == right) return true;</span> |
| <span class="source-line-no">1564</span><span id="line-1564"> if (left == null || right == null) return false;</span> |
| <span class="source-line-no">1565</span><span id="line-1565"> if (left.length != right.length) return false;</span> |
| <span class="source-line-no">1566</span><span id="line-1566"> if (left.length == 0) return true;</span> |
| <span class="source-line-no">1567</span><span id="line-1567"></span> |
| <span class="source-line-no">1568</span><span id="line-1568"> // Since we're often comparing adjacent sorted data,</span> |
| <span class="source-line-no">1569</span><span id="line-1569"> // it's usual to have equal arrays except for the very last byte</span> |
| <span class="source-line-no">1570</span><span id="line-1570"> // so check that first</span> |
| <span class="source-line-no">1571</span><span id="line-1571"> if (left[left.length - 1] != right[right.length - 1]) return false;</span> |
| <span class="source-line-no">1572</span><span id="line-1572"></span> |
| <span class="source-line-no">1573</span><span id="line-1573"> return compareTo(left, right) == 0;</span> |
| <span class="source-line-no">1574</span><span id="line-1574"> }</span> |
| <span class="source-line-no">1575</span><span id="line-1575"></span> |
| <span class="source-line-no">1576</span><span id="line-1576"> /**</span> |
| <span class="source-line-no">1577</span><span id="line-1577"> * Lexicographically determine the equality of two arrays.</span> |
| <span class="source-line-no">1578</span><span id="line-1578"> * @param left left operand</span> |
| <span class="source-line-no">1579</span><span id="line-1579"> * @param leftOffset offset into left operand</span> |
| <span class="source-line-no">1580</span><span id="line-1580"> * @param leftLen length of left operand</span> |
| <span class="source-line-no">1581</span><span id="line-1581"> * @param right right operand</span> |
| <span class="source-line-no">1582</span><span id="line-1582"> * @param rightOffset offset into right operand</span> |
| <span class="source-line-no">1583</span><span id="line-1583"> * @param rightLen length of right operand</span> |
| <span class="source-line-no">1584</span><span id="line-1584"> * @return True if equal</span> |
| <span class="source-line-no">1585</span><span id="line-1585"> */</span> |
| <span class="source-line-no">1586</span><span id="line-1586"> public static boolean equals(final byte[] left, int leftOffset, int leftLen, final byte[] right,</span> |
| <span class="source-line-no">1587</span><span id="line-1587"> int rightOffset, int rightLen) {</span> |
| <span class="source-line-no">1588</span><span id="line-1588"> // short circuit case</span> |
| <span class="source-line-no">1589</span><span id="line-1589"> if (left == right && leftOffset == rightOffset && leftLen == rightLen) {</span> |
| <span class="source-line-no">1590</span><span id="line-1590"> return true;</span> |
| <span class="source-line-no">1591</span><span id="line-1591"> }</span> |
| <span class="source-line-no">1592</span><span id="line-1592"> // different lengths fast check</span> |
| <span class="source-line-no">1593</span><span id="line-1593"> if (leftLen != rightLen) {</span> |
| <span class="source-line-no">1594</span><span id="line-1594"> return false;</span> |
| <span class="source-line-no">1595</span><span id="line-1595"> }</span> |
| <span class="source-line-no">1596</span><span id="line-1596"> if (leftLen == 0) {</span> |
| <span class="source-line-no">1597</span><span id="line-1597"> return true;</span> |
| <span class="source-line-no">1598</span><span id="line-1598"> }</span> |
| <span class="source-line-no">1599</span><span id="line-1599"></span> |
| <span class="source-line-no">1600</span><span id="line-1600"> // Since we're often comparing adjacent sorted data,</span> |
| <span class="source-line-no">1601</span><span id="line-1601"> // it's usual to have equal arrays except for the very last byte</span> |
| <span class="source-line-no">1602</span><span id="line-1602"> // so check that first</span> |
| <span class="source-line-no">1603</span><span id="line-1603"> if (left[leftOffset + leftLen - 1] != right[rightOffset + rightLen - 1]) return false;</span> |
| <span class="source-line-no">1604</span><span id="line-1604"></span> |
| <span class="source-line-no">1605</span><span id="line-1605"> return LexicographicalComparerHolder.BEST_COMPARER.compareTo(left, leftOffset, leftLen, right,</span> |
| <span class="source-line-no">1606</span><span id="line-1606"> rightOffset, rightLen) == 0;</span> |
| <span class="source-line-no">1607</span><span id="line-1607"> }</span> |
| <span class="source-line-no">1608</span><span id="line-1608"></span> |
| <span class="source-line-no">1609</span><span id="line-1609"> /**</span> |
| <span class="source-line-no">1610</span><span id="line-1610"> * Lexicographically determine the equality of two byte[], one as ByteBuffer.</span> |
| <span class="source-line-no">1611</span><span id="line-1611"> * @param a left operand</span> |
| <span class="source-line-no">1612</span><span id="line-1612"> * @param buf right operand</span> |
| <span class="source-line-no">1613</span><span id="line-1613"> * @return True if equal</span> |
| <span class="source-line-no">1614</span><span id="line-1614"> */</span> |
| <span class="source-line-no">1615</span><span id="line-1615"> public static boolean equals(byte[] a, ByteBuffer buf) {</span> |
| <span class="source-line-no">1616</span><span id="line-1616"> if (a == null) return buf == null;</span> |
| <span class="source-line-no">1617</span><span id="line-1617"> if (buf == null) return false;</span> |
| <span class="source-line-no">1618</span><span id="line-1618"> if (a.length != buf.remaining()) return false;</span> |
| <span class="source-line-no">1619</span><span id="line-1619"></span> |
| <span class="source-line-no">1620</span><span id="line-1620"> // Thou shalt not modify the original byte buffer in what should be read only operations.</span> |
| <span class="source-line-no">1621</span><span id="line-1621"> ByteBuffer b = buf.duplicate();</span> |
| <span class="source-line-no">1622</span><span id="line-1622"> for (byte anA : a) {</span> |
| <span class="source-line-no">1623</span><span id="line-1623"> if (anA != b.get()) {</span> |
| <span class="source-line-no">1624</span><span id="line-1624"> return false;</span> |
| <span class="source-line-no">1625</span><span id="line-1625"> }</span> |
| <span class="source-line-no">1626</span><span id="line-1626"> }</span> |
| <span class="source-line-no">1627</span><span id="line-1627"> return true;</span> |
| <span class="source-line-no">1628</span><span id="line-1628"> }</span> |
| <span class="source-line-no">1629</span><span id="line-1629"></span> |
| <span class="source-line-no">1630</span><span id="line-1630"> /**</span> |
| <span class="source-line-no">1631</span><span id="line-1631"> * Return true if the byte array on the right is a prefix of the byte array on the left.</span> |
| <span class="source-line-no">1632</span><span id="line-1632"> */</span> |
| <span class="source-line-no">1633</span><span id="line-1633"> public static boolean startsWith(byte[] bytes, byte[] prefix) {</span> |
| <span class="source-line-no">1634</span><span id="line-1634"> return bytes != null && prefix != null && bytes.length >= prefix.length</span> |
| <span class="source-line-no">1635</span><span id="line-1635"> && LexicographicalComparerHolder.BEST_COMPARER.compareTo(bytes, 0, prefix.length, prefix, 0,</span> |
| <span class="source-line-no">1636</span><span id="line-1636"> prefix.length) == 0;</span> |
| <span class="source-line-no">1637</span><span id="line-1637"> }</span> |
| <span class="source-line-no">1638</span><span id="line-1638"></span> |
| <span class="source-line-no">1639</span><span id="line-1639"> /**</span> |
| <span class="source-line-no">1640</span><span id="line-1640"> * Calculate a hash code from a given byte array.</span> |
| <span class="source-line-no">1641</span><span id="line-1641"> * @param b bytes to hash</span> |
| <span class="source-line-no">1642</span><span id="line-1642"> * @return Runs {@link WritableComparator#hashBytes(byte[], int)} on the passed in array. This</span> |
| <span class="source-line-no">1643</span><span id="line-1643"> * method is what {@link org.apache.hadoop.io.Text} use calculating hash code.</span> |
| <span class="source-line-no">1644</span><span id="line-1644"> */</span> |
| <span class="source-line-no">1645</span><span id="line-1645"> public static int hashCode(final byte[] b) {</span> |
| <span class="source-line-no">1646</span><span id="line-1646"> return hashCode(b, b.length);</span> |
| <span class="source-line-no">1647</span><span id="line-1647"> }</span> |
| <span class="source-line-no">1648</span><span id="line-1648"></span> |
| <span class="source-line-no">1649</span><span id="line-1649"> /**</span> |
| <span class="source-line-no">1650</span><span id="line-1650"> * Calculate a hash code from a given byte array.</span> |
| <span class="source-line-no">1651</span><span id="line-1651"> * @param b value</span> |
| <span class="source-line-no">1652</span><span id="line-1652"> * @param length length of the value</span> |
| <span class="source-line-no">1653</span><span id="line-1653"> * @return Runs {@link WritableComparator#hashBytes(byte[], int)} on the passed in array. This</span> |
| <span class="source-line-no">1654</span><span id="line-1654"> * method is what {@link org.apache.hadoop.io.Text} use calculating hash code.</span> |
| <span class="source-line-no">1655</span><span id="line-1655"> */</span> |
| <span class="source-line-no">1656</span><span id="line-1656"> public static int hashCode(final byte[] b, final int length) {</span> |
| <span class="source-line-no">1657</span><span id="line-1657"> return WritableComparator.hashBytes(b, length);</span> |
| <span class="source-line-no">1658</span><span id="line-1658"> }</span> |
| <span class="source-line-no">1659</span><span id="line-1659"></span> |
| <span class="source-line-no">1660</span><span id="line-1660"> /**</span> |
| <span class="source-line-no">1661</span><span id="line-1661"> * Calculate a hash code from a given byte array suitable for use as a key in maps.</span> |
| <span class="source-line-no">1662</span><span id="line-1662"> * @param b bytes to hash</span> |
| <span class="source-line-no">1663</span><span id="line-1663"> * @return A hash of <code>b</code> as an Integer that can be used as key in Maps.</span> |
| <span class="source-line-no">1664</span><span id="line-1664"> */</span> |
| <span class="source-line-no">1665</span><span id="line-1665"> public static Integer mapKey(final byte[] b) {</span> |
| <span class="source-line-no">1666</span><span id="line-1666"> return hashCode(b);</span> |
| <span class="source-line-no">1667</span><span id="line-1667"> }</span> |
| <span class="source-line-no">1668</span><span id="line-1668"></span> |
| <span class="source-line-no">1669</span><span id="line-1669"> /**</span> |
| <span class="source-line-no">1670</span><span id="line-1670"> * Calculate a hash code from a given byte array suitable for use as a key in maps.</span> |
| <span class="source-line-no">1671</span><span id="line-1671"> * @param b bytes to hash</span> |
| <span class="source-line-no">1672</span><span id="line-1672"> * @param length length to hash</span> |
| <span class="source-line-no">1673</span><span id="line-1673"> * @return A hash of <code>b</code> as an Integer that can be used as key in Maps.</span> |
| <span class="source-line-no">1674</span><span id="line-1674"> */</span> |
| <span class="source-line-no">1675</span><span id="line-1675"> public static Integer mapKey(final byte[] b, final int length) {</span> |
| <span class="source-line-no">1676</span><span id="line-1676"> return hashCode(b, length);</span> |
| <span class="source-line-no">1677</span><span id="line-1677"> }</span> |
| <span class="source-line-no">1678</span><span id="line-1678"></span> |
| <span class="source-line-no">1679</span><span id="line-1679"> /**</span> |
| <span class="source-line-no">1680</span><span id="line-1680"> * Concatenate byte arrays.</span> |
| <span class="source-line-no">1681</span><span id="line-1681"> * @param a lower half</span> |
| <span class="source-line-no">1682</span><span id="line-1682"> * @param b upper half</span> |
| <span class="source-line-no">1683</span><span id="line-1683"> * @return New array that has a in lower half and b in upper half.</span> |
| <span class="source-line-no">1684</span><span id="line-1684"> */</span> |
| <span class="source-line-no">1685</span><span id="line-1685"> public static byte[] add(final byte[] a, final byte[] b) {</span> |
| <span class="source-line-no">1686</span><span id="line-1686"> return add(a, b, EMPTY_BYTE_ARRAY);</span> |
| <span class="source-line-no">1687</span><span id="line-1687"> }</span> |
| <span class="source-line-no">1688</span><span id="line-1688"></span> |
| <span class="source-line-no">1689</span><span id="line-1689"> /**</span> |
| <span class="source-line-no">1690</span><span id="line-1690"> * Concatenate byte arrays.</span> |
| <span class="source-line-no">1691</span><span id="line-1691"> * @param a first third</span> |
| <span class="source-line-no">1692</span><span id="line-1692"> * @param b second third</span> |
| <span class="source-line-no">1693</span><span id="line-1693"> * @param c third third</span> |
| <span class="source-line-no">1694</span><span id="line-1694"> * @return New array made from a, b and c</span> |
| <span class="source-line-no">1695</span><span id="line-1695"> */</span> |
| <span class="source-line-no">1696</span><span id="line-1696"> public static byte[] add(final byte[] a, final byte[] b, final byte[] c) {</span> |
| <span class="source-line-no">1697</span><span id="line-1697"> byte[] result = new byte[a.length + b.length + c.length];</span> |
| <span class="source-line-no">1698</span><span id="line-1698"> System.arraycopy(a, 0, result, 0, a.length);</span> |
| <span class="source-line-no">1699</span><span id="line-1699"> System.arraycopy(b, 0, result, a.length, b.length);</span> |
| <span class="source-line-no">1700</span><span id="line-1700"> System.arraycopy(c, 0, result, a.length + b.length, c.length);</span> |
| <span class="source-line-no">1701</span><span id="line-1701"> return result;</span> |
| <span class="source-line-no">1702</span><span id="line-1702"> }</span> |
| <span class="source-line-no">1703</span><span id="line-1703"></span> |
| <span class="source-line-no">1704</span><span id="line-1704"> /**</span> |
| <span class="source-line-no">1705</span><span id="line-1705"> * Concatenate byte arrays.</span> |
| <span class="source-line-no">1706</span><span id="line-1706"> * @param arrays all the arrays to concatenate together.</span> |
| <span class="source-line-no">1707</span><span id="line-1707"> * @return New array made from the concatenation of the given arrays.</span> |
| <span class="source-line-no">1708</span><span id="line-1708"> */</span> |
| <span class="source-line-no">1709</span><span id="line-1709"> public static byte[] add(final byte[][] arrays) {</span> |
| <span class="source-line-no">1710</span><span id="line-1710"> int length = 0;</span> |
| <span class="source-line-no">1711</span><span id="line-1711"> for (int i = 0; i < arrays.length; i++) {</span> |
| <span class="source-line-no">1712</span><span id="line-1712"> length += arrays[i].length;</span> |
| <span class="source-line-no">1713</span><span id="line-1713"> }</span> |
| <span class="source-line-no">1714</span><span id="line-1714"> byte[] result = new byte[length];</span> |
| <span class="source-line-no">1715</span><span id="line-1715"> int index = 0;</span> |
| <span class="source-line-no">1716</span><span id="line-1716"> for (int i = 0; i < arrays.length; i++) {</span> |
| <span class="source-line-no">1717</span><span id="line-1717"> System.arraycopy(arrays[i], 0, result, index, arrays[i].length);</span> |
| <span class="source-line-no">1718</span><span id="line-1718"> index += arrays[i].length;</span> |
| <span class="source-line-no">1719</span><span id="line-1719"> }</span> |
| <span class="source-line-no">1720</span><span id="line-1720"> return result;</span> |
| <span class="source-line-no">1721</span><span id="line-1721"> }</span> |
| <span class="source-line-no">1722</span><span id="line-1722"></span> |
| <span class="source-line-no">1723</span><span id="line-1723"> /**</span> |
| <span class="source-line-no">1724</span><span id="line-1724"> * Make a new byte array from a subset of bytes at the head of another.</span> |
| <span class="source-line-no">1725</span><span id="line-1725"> * @param a array</span> |
| <span class="source-line-no">1726</span><span id="line-1726"> * @param length amount of bytes to grab</span> |
| <span class="source-line-no">1727</span><span id="line-1727"> * @return First <code>length</code> bytes from <code>a</code></span> |
| <span class="source-line-no">1728</span><span id="line-1728"> */</span> |
| <span class="source-line-no">1729</span><span id="line-1729"> public static byte[] head(final byte[] a, final int length) {</span> |
| <span class="source-line-no">1730</span><span id="line-1730"> if (a.length < length) {</span> |
| <span class="source-line-no">1731</span><span id="line-1731"> return null;</span> |
| <span class="source-line-no">1732</span><span id="line-1732"> }</span> |
| <span class="source-line-no">1733</span><span id="line-1733"> byte[] result = new byte[length];</span> |
| <span class="source-line-no">1734</span><span id="line-1734"> System.arraycopy(a, 0, result, 0, length);</span> |
| <span class="source-line-no">1735</span><span id="line-1735"> return result;</span> |
| <span class="source-line-no">1736</span><span id="line-1736"> }</span> |
| <span class="source-line-no">1737</span><span id="line-1737"></span> |
| <span class="source-line-no">1738</span><span id="line-1738"> /**</span> |
| <span class="source-line-no">1739</span><span id="line-1739"> * Make a new byte array from a subset of bytes at the tail of another.</span> |
| <span class="source-line-no">1740</span><span id="line-1740"> * @param a array</span> |
| <span class="source-line-no">1741</span><span id="line-1741"> * @param length amount of bytes to snarf</span> |
| <span class="source-line-no">1742</span><span id="line-1742"> * @return Last <code>length</code> bytes from <code>a</code></span> |
| <span class="source-line-no">1743</span><span id="line-1743"> */</span> |
| <span class="source-line-no">1744</span><span id="line-1744"> public static byte[] tail(final byte[] a, final int length) {</span> |
| <span class="source-line-no">1745</span><span id="line-1745"> if (a.length < length) {</span> |
| <span class="source-line-no">1746</span><span id="line-1746"> return null;</span> |
| <span class="source-line-no">1747</span><span id="line-1747"> }</span> |
| <span class="source-line-no">1748</span><span id="line-1748"> byte[] result = new byte[length];</span> |
| <span class="source-line-no">1749</span><span id="line-1749"> System.arraycopy(a, a.length - length, result, 0, length);</span> |
| <span class="source-line-no">1750</span><span id="line-1750"> return result;</span> |
| <span class="source-line-no">1751</span><span id="line-1751"> }</span> |
| <span class="source-line-no">1752</span><span id="line-1752"></span> |
| <span class="source-line-no">1753</span><span id="line-1753"> /**</span> |
| <span class="source-line-no">1754</span><span id="line-1754"> * Make a new byte array from a subset of bytes at the head of another, zero padded as desired.</span> |
| <span class="source-line-no">1755</span><span id="line-1755"> * @param a array</span> |
| <span class="source-line-no">1756</span><span id="line-1756"> * @param length new array size</span> |
| <span class="source-line-no">1757</span><span id="line-1757"> * @return Value in <code>a</code> plus <code>length</code> prepended 0 bytes</span> |
| <span class="source-line-no">1758</span><span id="line-1758"> */</span> |
| <span class="source-line-no">1759</span><span id="line-1759"> public static byte[] padHead(final byte[] a, final int length) {</span> |
| <span class="source-line-no">1760</span><span id="line-1760"> byte[] padding = new byte[length];</span> |
| <span class="source-line-no">1761</span><span id="line-1761"> for (int i = 0; i < length; i++) {</span> |
| <span class="source-line-no">1762</span><span id="line-1762"> padding[i] = 0;</span> |
| <span class="source-line-no">1763</span><span id="line-1763"> }</span> |
| <span class="source-line-no">1764</span><span id="line-1764"> return add(padding, a);</span> |
| <span class="source-line-no">1765</span><span id="line-1765"> }</span> |
| <span class="source-line-no">1766</span><span id="line-1766"></span> |
| <span class="source-line-no">1767</span><span id="line-1767"> /**</span> |
| <span class="source-line-no">1768</span><span id="line-1768"> * Make a new byte array from a subset of bytes at the tail of another, zero padded as desired.</span> |
| <span class="source-line-no">1769</span><span id="line-1769"> * @param a array</span> |
| <span class="source-line-no">1770</span><span id="line-1770"> * @param length new array size</span> |
| <span class="source-line-no">1771</span><span id="line-1771"> * @return Value in <code>a</code> plus <code>length</code> appended 0 bytes</span> |
| <span class="source-line-no">1772</span><span id="line-1772"> */</span> |
| <span class="source-line-no">1773</span><span id="line-1773"> public static byte[] padTail(final byte[] a, final int length) {</span> |
| <span class="source-line-no">1774</span><span id="line-1774"> byte[] padding = new byte[length];</span> |
| <span class="source-line-no">1775</span><span id="line-1775"> for (int i = 0; i < length; i++) {</span> |
| <span class="source-line-no">1776</span><span id="line-1776"> padding[i] = 0;</span> |
| <span class="source-line-no">1777</span><span id="line-1777"> }</span> |
| <span class="source-line-no">1778</span><span id="line-1778"> return add(a, padding);</span> |
| <span class="source-line-no">1779</span><span id="line-1779"> }</span> |
| <span class="source-line-no">1780</span><span id="line-1780"></span> |
| <span class="source-line-no">1781</span><span id="line-1781"> /**</span> |
| <span class="source-line-no">1782</span><span id="line-1782"> * Split passed range. Expensive operation relatively. Uses BigInteger math. Useful splitting</span> |
| <span class="source-line-no">1783</span><span id="line-1783"> * ranges for MapReduce jobs.</span> |
| <span class="source-line-no">1784</span><span id="line-1784"> * @param a Beginning of range</span> |
| <span class="source-line-no">1785</span><span id="line-1785"> * @param b End of range</span> |
| <span class="source-line-no">1786</span><span id="line-1786"> * @param num Number of times to split range. Pass 1 if you want to split the range in two; i.e.</span> |
| <span class="source-line-no">1787</span><span id="line-1787"> * one split.</span> |
| <span class="source-line-no">1788</span><span id="line-1788"> * @return Array of dividing values</span> |
| <span class="source-line-no">1789</span><span id="line-1789"> */</span> |
| <span class="source-line-no">1790</span><span id="line-1790"> public static byte[][] split(final byte[] a, final byte[] b, final int num) {</span> |
| <span class="source-line-no">1791</span><span id="line-1791"> return split(a, b, false, num);</span> |
| <span class="source-line-no">1792</span><span id="line-1792"> }</span> |
| <span class="source-line-no">1793</span><span id="line-1793"></span> |
| <span class="source-line-no">1794</span><span id="line-1794"> /**</span> |
| <span class="source-line-no">1795</span><span id="line-1795"> * Split passed range. Expensive operation relatively. Uses BigInteger math. Useful splitting</span> |
| <span class="source-line-no">1796</span><span id="line-1796"> * ranges for MapReduce jobs.</span> |
| <span class="source-line-no">1797</span><span id="line-1797"> * @param a Beginning of range</span> |
| <span class="source-line-no">1798</span><span id="line-1798"> * @param b End of range</span> |
| <span class="source-line-no">1799</span><span id="line-1799"> * @param inclusive Whether the end of range is prefix-inclusive or is considered an exclusive</span> |
| <span class="source-line-no">1800</span><span id="line-1800"> * boundary. Automatic splits are generally exclusive and manual splits with an</span> |
| <span class="source-line-no">1801</span><span id="line-1801"> * explicit range utilize an inclusive end of range.</span> |
| <span class="source-line-no">1802</span><span id="line-1802"> * @param num Number of times to split range. Pass 1 if you want to split the range in two;</span> |
| <span class="source-line-no">1803</span><span id="line-1803"> * i.e. one split.</span> |
| <span class="source-line-no">1804</span><span id="line-1804"> * @return Array of dividing values</span> |
| <span class="source-line-no">1805</span><span id="line-1805"> */</span> |
| <span class="source-line-no">1806</span><span id="line-1806"> public static byte[][] split(final byte[] a, final byte[] b, boolean inclusive, final int num) {</span> |
| <span class="source-line-no">1807</span><span id="line-1807"> byte[][] ret = new byte[num + 2][];</span> |
| <span class="source-line-no">1808</span><span id="line-1808"> int i = 0;</span> |
| <span class="source-line-no">1809</span><span id="line-1809"> Iterable<byte[]> iter = iterateOnSplits(a, b, inclusive, num);</span> |
| <span class="source-line-no">1810</span><span id="line-1810"> if (iter == null) return null;</span> |
| <span class="source-line-no">1811</span><span id="line-1811"> for (byte[] elem : iter) {</span> |
| <span class="source-line-no">1812</span><span id="line-1812"> ret[i++] = elem;</span> |
| <span class="source-line-no">1813</span><span id="line-1813"> }</span> |
| <span class="source-line-no">1814</span><span id="line-1814"> return ret;</span> |
| <span class="source-line-no">1815</span><span id="line-1815"> }</span> |
| <span class="source-line-no">1816</span><span id="line-1816"></span> |
| <span class="source-line-no">1817</span><span id="line-1817"> /**</span> |
| <span class="source-line-no">1818</span><span id="line-1818"> * Iterate over keys within the passed range, splitting at an [a,b) boundary.</span> |
| <span class="source-line-no">1819</span><span id="line-1819"> */</span> |
| <span class="source-line-no">1820</span><span id="line-1820"> public static Iterable<byte[]> iterateOnSplits(final byte[] a, final byte[] b, final int num) {</span> |
| <span class="source-line-no">1821</span><span id="line-1821"> return iterateOnSplits(a, b, false, num);</span> |
| <span class="source-line-no">1822</span><span id="line-1822"> }</span> |
| <span class="source-line-no">1823</span><span id="line-1823"></span> |
| <span class="source-line-no">1824</span><span id="line-1824"> /**</span> |
| <span class="source-line-no">1825</span><span id="line-1825"> * Iterate over keys within the passed range.</span> |
| <span class="source-line-no">1826</span><span id="line-1826"> */</span> |
| <span class="source-line-no">1827</span><span id="line-1827"> public static Iterable<byte[]> iterateOnSplits(final byte[] a, final byte[] b, boolean inclusive,</span> |
| <span class="source-line-no">1828</span><span id="line-1828"> final int num) {</span> |
| <span class="source-line-no">1829</span><span id="line-1829"> byte[] aPadded;</span> |
| <span class="source-line-no">1830</span><span id="line-1830"> byte[] bPadded;</span> |
| <span class="source-line-no">1831</span><span id="line-1831"> if (a.length < b.length) {</span> |
| <span class="source-line-no">1832</span><span id="line-1832"> aPadded = padTail(a, b.length - a.length);</span> |
| <span class="source-line-no">1833</span><span id="line-1833"> bPadded = b;</span> |
| <span class="source-line-no">1834</span><span id="line-1834"> } else if (b.length < a.length) {</span> |
| <span class="source-line-no">1835</span><span id="line-1835"> aPadded = a;</span> |
| <span class="source-line-no">1836</span><span id="line-1836"> bPadded = padTail(b, a.length - b.length);</span> |
| <span class="source-line-no">1837</span><span id="line-1837"> } else {</span> |
| <span class="source-line-no">1838</span><span id="line-1838"> aPadded = a;</span> |
| <span class="source-line-no">1839</span><span id="line-1839"> bPadded = b;</span> |
| <span class="source-line-no">1840</span><span id="line-1840"> }</span> |
| <span class="source-line-no">1841</span><span id="line-1841"> if (compareTo(aPadded, bPadded) >= 0) {</span> |
| <span class="source-line-no">1842</span><span id="line-1842"> throw new IllegalArgumentException("b <= a");</span> |
| <span class="source-line-no">1843</span><span id="line-1843"> }</span> |
| <span class="source-line-no">1844</span><span id="line-1844"> if (num <= 0) {</span> |
| <span class="source-line-no">1845</span><span id="line-1845"> throw new IllegalArgumentException("num cannot be <= 0");</span> |
| <span class="source-line-no">1846</span><span id="line-1846"> }</span> |
| <span class="source-line-no">1847</span><span id="line-1847"> byte[] prependHeader = { 1, 0 };</span> |
| <span class="source-line-no">1848</span><span id="line-1848"> final BigInteger startBI = new BigInteger(add(prependHeader, aPadded));</span> |
| <span class="source-line-no">1849</span><span id="line-1849"> final BigInteger stopBI = new BigInteger(add(prependHeader, bPadded));</span> |
| <span class="source-line-no">1850</span><span id="line-1850"> BigInteger diffBI = stopBI.subtract(startBI);</span> |
| <span class="source-line-no">1851</span><span id="line-1851"> if (inclusive) {</span> |
| <span class="source-line-no">1852</span><span id="line-1852"> diffBI = diffBI.add(BigInteger.ONE);</span> |
| <span class="source-line-no">1853</span><span id="line-1853"> }</span> |
| <span class="source-line-no">1854</span><span id="line-1854"> final BigInteger splitsBI = BigInteger.valueOf(num + 1);</span> |
| <span class="source-line-no">1855</span><span id="line-1855"> // when diffBI < splitBI, use an additional byte to increase diffBI</span> |
| <span class="source-line-no">1856</span><span id="line-1856"> if (diffBI.compareTo(splitsBI) < 0) {</span> |
| <span class="source-line-no">1857</span><span id="line-1857"> byte[] aPaddedAdditional = new byte[aPadded.length + 1];</span> |
| <span class="source-line-no">1858</span><span id="line-1858"> byte[] bPaddedAdditional = new byte[bPadded.length + 1];</span> |
| <span class="source-line-no">1859</span><span id="line-1859"> for (int i = 0; i < aPadded.length; i++) {</span> |
| <span class="source-line-no">1860</span><span id="line-1860"> aPaddedAdditional[i] = aPadded[i];</span> |
| <span class="source-line-no">1861</span><span id="line-1861"> }</span> |
| <span class="source-line-no">1862</span><span id="line-1862"> for (int j = 0; j < bPadded.length; j++) {</span> |
| <span class="source-line-no">1863</span><span id="line-1863"> bPaddedAdditional[j] = bPadded[j];</span> |
| <span class="source-line-no">1864</span><span id="line-1864"> }</span> |
| <span class="source-line-no">1865</span><span id="line-1865"> aPaddedAdditional[aPadded.length] = 0;</span> |
| <span class="source-line-no">1866</span><span id="line-1866"> bPaddedAdditional[bPadded.length] = 0;</span> |
| <span class="source-line-no">1867</span><span id="line-1867"> return iterateOnSplits(aPaddedAdditional, bPaddedAdditional, inclusive, num);</span> |
| <span class="source-line-no">1868</span><span id="line-1868"> }</span> |
| <span class="source-line-no">1869</span><span id="line-1869"> final BigInteger intervalBI;</span> |
| <span class="source-line-no">1870</span><span id="line-1870"> try {</span> |
| <span class="source-line-no">1871</span><span id="line-1871"> intervalBI = diffBI.divide(splitsBI);</span> |
| <span class="source-line-no">1872</span><span id="line-1872"> } catch (Exception e) {</span> |
| <span class="source-line-no">1873</span><span id="line-1873"> LOG.error("Exception caught during division", e);</span> |
| <span class="source-line-no">1874</span><span id="line-1874"> return null;</span> |
| <span class="source-line-no">1875</span><span id="line-1875"> }</span> |
| <span class="source-line-no">1876</span><span id="line-1876"></span> |
| <span class="source-line-no">1877</span><span id="line-1877"> final Iterator<byte[]> iterator = new Iterator<byte[]>() {</span> |
| <span class="source-line-no">1878</span><span id="line-1878"> private int i = -1;</span> |
| <span class="source-line-no">1879</span><span id="line-1879"></span> |
| <span class="source-line-no">1880</span><span id="line-1880"> @Override</span> |
| <span class="source-line-no">1881</span><span id="line-1881"> public boolean hasNext() {</span> |
| <span class="source-line-no">1882</span><span id="line-1882"> return i < num + 1;</span> |
| <span class="source-line-no">1883</span><span id="line-1883"> }</span> |
| <span class="source-line-no">1884</span><span id="line-1884"></span> |
| <span class="source-line-no">1885</span><span id="line-1885"> @Override</span> |
| <span class="source-line-no">1886</span><span id="line-1886"> public byte[] next() {</span> |
| <span class="source-line-no">1887</span><span id="line-1887"> i++;</span> |
| <span class="source-line-no">1888</span><span id="line-1888"> if (i == 0) return a;</span> |
| <span class="source-line-no">1889</span><span id="line-1889"> if (i == num + 1) return b;</span> |
| <span class="source-line-no">1890</span><span id="line-1890"></span> |
| <span class="source-line-no">1891</span><span id="line-1891"> BigInteger curBI = startBI.add(intervalBI.multiply(BigInteger.valueOf(i)));</span> |
| <span class="source-line-no">1892</span><span id="line-1892"> byte[] padded = curBI.toByteArray();</span> |
| <span class="source-line-no">1893</span><span id="line-1893"> if (padded[1] == 0) padded = tail(padded, padded.length - 2);</span> |
| <span class="source-line-no">1894</span><span id="line-1894"> else padded = tail(padded, padded.length - 1);</span> |
| <span class="source-line-no">1895</span><span id="line-1895"> return padded;</span> |
| <span class="source-line-no">1896</span><span id="line-1896"> }</span> |
| <span class="source-line-no">1897</span><span id="line-1897"></span> |
| <span class="source-line-no">1898</span><span id="line-1898"> @Override</span> |
| <span class="source-line-no">1899</span><span id="line-1899"> public void remove() {</span> |
| <span class="source-line-no">1900</span><span id="line-1900"> throw new UnsupportedOperationException();</span> |
| <span class="source-line-no">1901</span><span id="line-1901"> }</span> |
| <span class="source-line-no">1902</span><span id="line-1902"></span> |
| <span class="source-line-no">1903</span><span id="line-1903"> };</span> |
| <span class="source-line-no">1904</span><span id="line-1904"></span> |
| <span class="source-line-no">1905</span><span id="line-1905"> return new Iterable<byte[]>() {</span> |
| <span class="source-line-no">1906</span><span id="line-1906"> @Override</span> |
| <span class="source-line-no">1907</span><span id="line-1907"> public Iterator<byte[]> iterator() {</span> |
| <span class="source-line-no">1908</span><span id="line-1908"> return iterator;</span> |
| <span class="source-line-no">1909</span><span id="line-1909"> }</span> |
| <span class="source-line-no">1910</span><span id="line-1910"> };</span> |
| <span class="source-line-no">1911</span><span id="line-1911"> }</span> |
| <span class="source-line-no">1912</span><span id="line-1912"></span> |
| <span class="source-line-no">1913</span><span id="line-1913"> /**</span> |
| <span class="source-line-no">1914</span><span id="line-1914"> * Calculate the hash code for a given range of bytes.</span> |
| <span class="source-line-no">1915</span><span id="line-1915"> * @param bytes array to hash</span> |
| <span class="source-line-no">1916</span><span id="line-1916"> * @param offset offset to start from</span> |
| <span class="source-line-no">1917</span><span id="line-1917"> * @param length length to hash</span> |
| <span class="source-line-no">1918</span><span id="line-1918"> */</span> |
| <span class="source-line-no">1919</span><span id="line-1919"> public static int hashCode(byte[] bytes, int offset, int length) {</span> |
| <span class="source-line-no">1920</span><span id="line-1920"> int hash = 1;</span> |
| <span class="source-line-no">1921</span><span id="line-1921"> for (int i = offset; i < offset + length; i++)</span> |
| <span class="source-line-no">1922</span><span id="line-1922"> hash = (31 * hash) + bytes[i];</span> |
| <span class="source-line-no">1923</span><span id="line-1923"> return hash;</span> |
| <span class="source-line-no">1924</span><span id="line-1924"> }</span> |
| <span class="source-line-no">1925</span><span id="line-1925"></span> |
| <span class="source-line-no">1926</span><span id="line-1926"> /**</span> |
| <span class="source-line-no">1927</span><span id="line-1927"> * Create an array of byte[] given an array of String.</span> |
| <span class="source-line-no">1928</span><span id="line-1928"> * @param t operands</span> |
| <span class="source-line-no">1929</span><span id="line-1929"> * @return Array of byte arrays made from passed array of Text</span> |
| <span class="source-line-no">1930</span><span id="line-1930"> */</span> |
| <span class="source-line-no">1931</span><span id="line-1931"> public static byte[][] toByteArrays(final String[] t) {</span> |
| <span class="source-line-no">1932</span><span id="line-1932"> byte[][] result = new byte[t.length][];</span> |
| <span class="source-line-no">1933</span><span id="line-1933"> for (int i = 0; i < t.length; i++) {</span> |
| <span class="source-line-no">1934</span><span id="line-1934"> result[i] = Bytes.toBytes(t[i]);</span> |
| <span class="source-line-no">1935</span><span id="line-1935"> }</span> |
| <span class="source-line-no">1936</span><span id="line-1936"> return result;</span> |
| <span class="source-line-no">1937</span><span id="line-1937"> }</span> |
| <span class="source-line-no">1938</span><span id="line-1938"></span> |
| <span class="source-line-no">1939</span><span id="line-1939"> /**</span> |
| <span class="source-line-no">1940</span><span id="line-1940"> * Create an array of byte[] given an array of String.</span> |
| <span class="source-line-no">1941</span><span id="line-1941"> * @param t operands</span> |
| <span class="source-line-no">1942</span><span id="line-1942"> * @return Array of binary byte arrays made from passed array of binary strings</span> |
| <span class="source-line-no">1943</span><span id="line-1943"> */</span> |
| <span class="source-line-no">1944</span><span id="line-1944"> public static byte[][] toBinaryByteArrays(final String[] t) {</span> |
| <span class="source-line-no">1945</span><span id="line-1945"> byte[][] result = new byte[t.length][];</span> |
| <span class="source-line-no">1946</span><span id="line-1946"> for (int i = 0; i < t.length; i++) {</span> |
| <span class="source-line-no">1947</span><span id="line-1947"> result[i] = Bytes.toBytesBinary(t[i]);</span> |
| <span class="source-line-no">1948</span><span id="line-1948"> }</span> |
| <span class="source-line-no">1949</span><span id="line-1949"> return result;</span> |
| <span class="source-line-no">1950</span><span id="line-1950"> }</span> |
| <span class="source-line-no">1951</span><span id="line-1951"></span> |
| <span class="source-line-no">1952</span><span id="line-1952"> /**</span> |
| <span class="source-line-no">1953</span><span id="line-1953"> * Create a byte[][] where first and only entry is <code>column</code></span> |
| <span class="source-line-no">1954</span><span id="line-1954"> * @param column operand</span> |
| <span class="source-line-no">1955</span><span id="line-1955"> * @return A byte array of a byte array where first and only entry is <code>column</code></span> |
| <span class="source-line-no">1956</span><span id="line-1956"> */</span> |
| <span class="source-line-no">1957</span><span id="line-1957"> public static byte[][] toByteArrays(final String column) {</span> |
| <span class="source-line-no">1958</span><span id="line-1958"> return toByteArrays(toBytes(column));</span> |
| <span class="source-line-no">1959</span><span id="line-1959"> }</span> |
| <span class="source-line-no">1960</span><span id="line-1960"></span> |
| <span class="source-line-no">1961</span><span id="line-1961"> /**</span> |
| <span class="source-line-no">1962</span><span id="line-1962"> * Create a byte[][] where first and only entry is <code>column</code></span> |
| <span class="source-line-no">1963</span><span id="line-1963"> * @param column operand</span> |
| <span class="source-line-no">1964</span><span id="line-1964"> * @return A byte array of a byte array where first and only entry is <code>column</code></span> |
| <span class="source-line-no">1965</span><span id="line-1965"> */</span> |
| <span class="source-line-no">1966</span><span id="line-1966"> public static byte[][] toByteArrays(final byte[] column) {</span> |
| <span class="source-line-no">1967</span><span id="line-1967"> byte[][] result = new byte[1][];</span> |
| <span class="source-line-no">1968</span><span id="line-1968"> result[0] = column;</span> |
| <span class="source-line-no">1969</span><span id="line-1969"> return result;</span> |
| <span class="source-line-no">1970</span><span id="line-1970"> }</span> |
| <span class="source-line-no">1971</span><span id="line-1971"></span> |
| <span class="source-line-no">1972</span><span id="line-1972"> /**</span> |
| <span class="source-line-no">1973</span><span id="line-1973"> * Binary search for keys in indexes using Bytes.BYTES_RAWCOMPARATOR.</span> |
| <span class="source-line-no">1974</span><span id="line-1974"> * @param arr array of byte arrays to search for</span> |
| <span class="source-line-no">1975</span><span id="line-1975"> * @param key the key you want to find</span> |
| <span class="source-line-no">1976</span><span id="line-1976"> * @param offset the offset in the key you want to find</span> |
| <span class="source-line-no">1977</span><span id="line-1977"> * @param length the length of the key</span> |
| <span class="source-line-no">1978</span><span id="line-1978"> * @return zero-based index of the key, if the key is present in the array. Otherwise, a value -(i</span> |
| <span class="source-line-no">1979</span><span id="line-1979"> * + 1) such that the key is between arr[i - 1] and arr[i] non-inclusively, where i is in</span> |
| <span class="source-line-no">1980</span><span id="line-1980"> * [0, i], if we define arr[-1] = -Inf and arr[N] = Inf for an N-element array. The above</span> |
| <span class="source-line-no">1981</span><span id="line-1981"> * means that this function can return 2N + 1 different values ranging from -(N + 1) to N</span> |
| <span class="source-line-no">1982</span><span id="line-1982"> * - 1.</span> |
| <span class="source-line-no">1983</span><span id="line-1983"> */</span> |
| <span class="source-line-no">1984</span><span id="line-1984"> public static int binarySearch(byte[][] arr, byte[] key, int offset, int length) {</span> |
| <span class="source-line-no">1985</span><span id="line-1985"> int low = 0;</span> |
| <span class="source-line-no">1986</span><span id="line-1986"> int high = arr.length - 1;</span> |
| <span class="source-line-no">1987</span><span id="line-1987"></span> |
| <span class="source-line-no">1988</span><span id="line-1988"> while (low <= high) {</span> |
| <span class="source-line-no">1989</span><span id="line-1989"> int mid = low + ((high - low) >> 1);</span> |
| <span class="source-line-no">1990</span><span id="line-1990"> // we have to compare in this order, because the comparator order</span> |
| <span class="source-line-no">1991</span><span id="line-1991"> // has special logic when the 'left side' is a special key.</span> |
| <span class="source-line-no">1992</span><span id="line-1992"> int cmp =</span> |
| <span class="source-line-no">1993</span><span id="line-1993"> Bytes.BYTES_RAWCOMPARATOR.compare(key, offset, length, arr[mid], 0, arr[mid].length);</span> |
| <span class="source-line-no">1994</span><span id="line-1994"> // key lives above the midpoint</span> |
| <span class="source-line-no">1995</span><span id="line-1995"> if (cmp > 0) low = mid + 1;</span> |
| <span class="source-line-no">1996</span><span id="line-1996"> // key lives below the midpoint</span> |
| <span class="source-line-no">1997</span><span id="line-1997"> else if (cmp < 0) high = mid - 1;</span> |
| <span class="source-line-no">1998</span><span id="line-1998"> // BAM. how often does this really happen?</span> |
| <span class="source-line-no">1999</span><span id="line-1999"> else return mid;</span> |
| <span class="source-line-no">2000</span><span id="line-2000"> }</span> |
| <span class="source-line-no">2001</span><span id="line-2001"> return -(low + 1);</span> |
| <span class="source-line-no">2002</span><span id="line-2002"> }</span> |
| <span class="source-line-no">2003</span><span id="line-2003"></span> |
| <span class="source-line-no">2004</span><span id="line-2004"> /**</span> |
| <span class="source-line-no">2005</span><span id="line-2005"> * Binary search for keys in indexes.</span> |
| <span class="source-line-no">2006</span><span id="line-2006"> * @param arr array of byte arrays to search for</span> |
| <span class="source-line-no">2007</span><span id="line-2007"> * @param key the key you want to find</span> |
| <span class="source-line-no">2008</span><span id="line-2008"> * @param comparator a comparator to compare.</span> |
| <span class="source-line-no">2009</span><span id="line-2009"> * @return zero-based index of the key, if the key is present in the array. Otherwise, a value -(i</span> |
| <span class="source-line-no">2010</span><span id="line-2010"> * + 1) such that the key is between arr[i - 1] and arr[i] non-inclusively, where i is in</span> |
| <span class="source-line-no">2011</span><span id="line-2011"> * [0, i], if we define arr[-1] = -Inf and arr[N] = Inf for an N-element array. The above</span> |
| <span class="source-line-no">2012</span><span id="line-2012"> * means that this function can return 2N + 1 different values ranging from -(N + 1) to N</span> |
| <span class="source-line-no">2013</span><span id="line-2013"> * - 1.</span> |
| <span class="source-line-no">2014</span><span id="line-2014"> * @return the index of the block</span> |
| <span class="source-line-no">2015</span><span id="line-2015"> */</span> |
| <span class="source-line-no">2016</span><span id="line-2016"> public static int binarySearch(Cell[] arr, Cell key, CellComparator comparator) {</span> |
| <span class="source-line-no">2017</span><span id="line-2017"> int low = 0;</span> |
| <span class="source-line-no">2018</span><span id="line-2018"> int high = arr.length - 1;</span> |
| <span class="source-line-no">2019</span><span id="line-2019"> while (low <= high) {</span> |
| <span class="source-line-no">2020</span><span id="line-2020"> int mid = low + ((high - low) >> 1);</span> |
| <span class="source-line-no">2021</span><span id="line-2021"> // we have to compare in this order, because the comparator order</span> |
| <span class="source-line-no">2022</span><span id="line-2022"> // has special logic when the 'left side' is a special key.</span> |
| <span class="source-line-no">2023</span><span id="line-2023"> int cmp = comparator.compare(key, arr[mid]);</span> |
| <span class="source-line-no">2024</span><span id="line-2024"> // key lives above the midpoint</span> |
| <span class="source-line-no">2025</span><span id="line-2025"> if (cmp > 0) low = mid + 1;</span> |
| <span class="source-line-no">2026</span><span id="line-2026"> // key lives below the midpoint</span> |
| <span class="source-line-no">2027</span><span id="line-2027"> else if (cmp < 0) high = mid - 1;</span> |
| <span class="source-line-no">2028</span><span id="line-2028"> // BAM. how often does this really happen?</span> |
| <span class="source-line-no">2029</span><span id="line-2029"> else return mid;</span> |
| <span class="source-line-no">2030</span><span id="line-2030"> }</span> |
| <span class="source-line-no">2031</span><span id="line-2031"> return -(low + 1);</span> |
| <span class="source-line-no">2032</span><span id="line-2032"> }</span> |
| <span class="source-line-no">2033</span><span id="line-2033"></span> |
| <span class="source-line-no">2034</span><span id="line-2034"> /**</span> |
| <span class="source-line-no">2035</span><span id="line-2035"> * Bytewise binary increment/deincrement of long contained in byte array on given amount.</span> |
| <span class="source-line-no">2036</span><span id="line-2036"> * @param value - array of bytes containing long (length &lt;= SIZEOF_LONG)</span> |
| <span class="source-line-no">2037</span><span id="line-2037"> * @param amount value will be incremented on (deincremented if negative)</span> |
| <span class="source-line-no">2038</span><span id="line-2038"> * @return array of bytes containing incremented long (length == SIZEOF_LONG)</span> |
| <span class="source-line-no">2039</span><span id="line-2039"> */</span> |
| <span class="source-line-no">2040</span><span id="line-2040"> public static byte[] incrementBytes(byte[] value, long amount) {</span> |
| <span class="source-line-no">2041</span><span id="line-2041"> byte[] val = value;</span> |
| <span class="source-line-no">2042</span><span id="line-2042"> if (val.length < SIZEOF_LONG) {</span> |
| <span class="source-line-no">2043</span><span id="line-2043"> // Hopefully this doesn't happen too often.</span> |
| <span class="source-line-no">2044</span><span id="line-2044"> byte[] newvalue;</span> |
| <span class="source-line-no">2045</span><span id="line-2045"> if (val[0] < 0) {</span> |
| <span class="source-line-no">2046</span><span id="line-2046"> newvalue = new byte[] { -1, -1, -1, -1, -1, -1, -1, -1 };</span> |
| <span class="source-line-no">2047</span><span id="line-2047"> } else {</span> |
| <span class="source-line-no">2048</span><span id="line-2048"> newvalue = new byte[SIZEOF_LONG];</span> |
| <span class="source-line-no">2049</span><span id="line-2049"> }</span> |
| <span class="source-line-no">2050</span><span id="line-2050"> System.arraycopy(val, 0, newvalue, newvalue.length - val.length, val.length);</span> |
| <span class="source-line-no">2051</span><span id="line-2051"> val = newvalue;</span> |
| <span class="source-line-no">2052</span><span id="line-2052"> } else if (val.length > SIZEOF_LONG) {</span> |
| <span class="source-line-no">2053</span><span id="line-2053"> throw new IllegalArgumentException("Increment Bytes - value too big: " + val.length);</span> |
| <span class="source-line-no">2054</span><span id="line-2054"> }</span> |
| <span class="source-line-no">2055</span><span id="line-2055"> if (amount == 0) return val;</span> |
| <span class="source-line-no">2056</span><span id="line-2056"> if (val[0] < 0) {</span> |
| <span class="source-line-no">2057</span><span id="line-2057"> return binaryIncrementNeg(val, amount);</span> |
| <span class="source-line-no">2058</span><span id="line-2058"> }</span> |
| <span class="source-line-no">2059</span><span id="line-2059"> return binaryIncrementPos(val, amount);</span> |
| <span class="source-line-no">2060</span><span id="line-2060"> }</span> |
| <span class="source-line-no">2061</span><span id="line-2061"></span> |
| <span class="source-line-no">2062</span><span id="line-2062"> /* increment/deincrement for positive value */</span> |
| <span class="source-line-no">2063</span><span id="line-2063"> private static byte[] binaryIncrementPos(byte[] value, long amount) {</span> |
| <span class="source-line-no">2064</span><span id="line-2064"> long amo = amount;</span> |
| <span class="source-line-no">2065</span><span id="line-2065"> int sign = 1;</span> |
| <span class="source-line-no">2066</span><span id="line-2066"> if (amount < 0) {</span> |
| <span class="source-line-no">2067</span><span id="line-2067"> amo = -amount;</span> |
| <span class="source-line-no">2068</span><span id="line-2068"> sign = -1;</span> |
| <span class="source-line-no">2069</span><span id="line-2069"> }</span> |
| <span class="source-line-no">2070</span><span id="line-2070"> for (int i = 0; i < value.length; i++) {</span> |
| <span class="source-line-no">2071</span><span id="line-2071"> int cur = ((int) amo % 256) * sign;</span> |
| <span class="source-line-no">2072</span><span id="line-2072"> amo = (amo >> 8);</span> |
| <span class="source-line-no">2073</span><span id="line-2073"> int val = value[value.length - i - 1] & 0x0ff;</span> |
| <span class="source-line-no">2074</span><span id="line-2074"> int total = val + cur;</span> |
| <span class="source-line-no">2075</span><span id="line-2075"> if (total > 255) {</span> |
| <span class="source-line-no">2076</span><span id="line-2076"> amo += sign;</span> |
| <span class="source-line-no">2077</span><span id="line-2077"> total %= 256;</span> |
| <span class="source-line-no">2078</span><span id="line-2078"> } else if (total < 0) {</span> |
| <span class="source-line-no">2079</span><span id="line-2079"> amo -= sign;</span> |
| <span class="source-line-no">2080</span><span id="line-2080"> }</span> |
| <span class="source-line-no">2081</span><span id="line-2081"> value[value.length - i - 1] = (byte) total;</span> |
| <span class="source-line-no">2082</span><span id="line-2082"> if (amo == 0) return value;</span> |
| <span class="source-line-no">2083</span><span id="line-2083"> }</span> |
| <span class="source-line-no">2084</span><span id="line-2084"> return value;</span> |
| <span class="source-line-no">2085</span><span id="line-2085"> }</span> |
| <span class="source-line-no">2086</span><span id="line-2086"></span> |
| <span class="source-line-no">2087</span><span id="line-2087"> /* increment/deincrement for negative value */</span> |
| <span class="source-line-no">2088</span><span id="line-2088"> private static byte[] binaryIncrementNeg(byte[] value, long amount) {</span> |
| <span class="source-line-no">2089</span><span id="line-2089"> long amo = amount;</span> |
| <span class="source-line-no">2090</span><span id="line-2090"> int sign = 1;</span> |
| <span class="source-line-no">2091</span><span id="line-2091"> if (amount < 0) {</span> |
| <span class="source-line-no">2092</span><span id="line-2092"> amo = -amount;</span> |
| <span class="source-line-no">2093</span><span id="line-2093"> sign = -1;</span> |
| <span class="source-line-no">2094</span><span id="line-2094"> }</span> |
| <span class="source-line-no">2095</span><span id="line-2095"> for (int i = 0; i < value.length; i++) {</span> |
| <span class="source-line-no">2096</span><span id="line-2096"> int cur = ((int) amo % 256) * sign;</span> |
| <span class="source-line-no">2097</span><span id="line-2097"> amo = (amo >> 8);</span> |
| <span class="source-line-no">2098</span><span id="line-2098"> int val = (~value[value.length - i - 1] & 0x0ff) + 1;</span> |
| <span class="source-line-no">2099</span><span id="line-2099"> int total = cur - val;</span> |
| <span class="source-line-no">2100</span><span id="line-2100"> if (total >= 0) {</span> |
| <span class="source-line-no">2101</span><span id="line-2101"> amo += sign;</span> |
| <span class="source-line-no">2102</span><span id="line-2102"> } else if (total < -256) {</span> |
| <span class="source-line-no">2103</span><span id="line-2103"> amo -= sign;</span> |
| <span class="source-line-no">2104</span><span id="line-2104"> total %= 256;</span> |
| <span class="source-line-no">2105</span><span id="line-2105"> }</span> |
| <span class="source-line-no">2106</span><span id="line-2106"> value[value.length - i - 1] = (byte) total;</span> |
| <span class="source-line-no">2107</span><span id="line-2107"> if (amo == 0) return value;</span> |
| <span class="source-line-no">2108</span><span id="line-2108"> }</span> |
| <span class="source-line-no">2109</span><span id="line-2109"> return value;</span> |
| <span class="source-line-no">2110</span><span id="line-2110"> }</span> |
| <span class="source-line-no">2111</span><span id="line-2111"></span> |
| <span class="source-line-no">2112</span><span id="line-2112"> /**</span> |
| <span class="source-line-no">2113</span><span id="line-2113"> * Writes a string as a fixed-size field, padded with zeros.</span> |
| <span class="source-line-no">2114</span><span id="line-2114"> */</span> |
| <span class="source-line-no">2115</span><span id="line-2115"> public static void writeStringFixedSize(final DataOutput out, String s, int size)</span> |
| <span class="source-line-no">2116</span><span id="line-2116"> throws IOException {</span> |
| <span class="source-line-no">2117</span><span id="line-2117"> byte[] b = toBytes(s);</span> |
| <span class="source-line-no">2118</span><span id="line-2118"> if (b.length > size) {</span> |
| <span class="source-line-no">2119</span><span id="line-2119"> throw new IOException("Trying to write " + b.length + " bytes (" + toStringBinary(b)</span> |
| <span class="source-line-no">2120</span><span id="line-2120"> + ") into a field of length " + size);</span> |
| <span class="source-line-no">2121</span><span id="line-2121"> }</span> |
| <span class="source-line-no">2122</span><span id="line-2122"></span> |
| <span class="source-line-no">2123</span><span id="line-2123"> out.writeBytes(s);</span> |
| <span class="source-line-no">2124</span><span id="line-2124"> for (int i = 0; i < size - s.length(); ++i)</span> |
| <span class="source-line-no">2125</span><span id="line-2125"> out.writeByte(0);</span> |
| <span class="source-line-no">2126</span><span id="line-2126"> }</span> |
| <span class="source-line-no">2127</span><span id="line-2127"></span> |
| <span class="source-line-no">2128</span><span id="line-2128"> /**</span> |
| <span class="source-line-no">2129</span><span id="line-2129"> * Reads a fixed-size field and interprets it as a string padded with zeros.</span> |
| <span class="source-line-no">2130</span><span id="line-2130"> */</span> |
| <span class="source-line-no">2131</span><span id="line-2131"> public static String readStringFixedSize(final DataInput in, int size) throws IOException {</span> |
| <span class="source-line-no">2132</span><span id="line-2132"> byte[] b = new byte[size];</span> |
| <span class="source-line-no">2133</span><span id="line-2133"> in.readFully(b);</span> |
| <span class="source-line-no">2134</span><span id="line-2134"> int n = b.length;</span> |
| <span class="source-line-no">2135</span><span id="line-2135"> while (n > 0 && b[n - 1] == 0)</span> |
| <span class="source-line-no">2136</span><span id="line-2136"> --n;</span> |
| <span class="source-line-no">2137</span><span id="line-2137"></span> |
| <span class="source-line-no">2138</span><span id="line-2138"> return toString(b, 0, n);</span> |
| <span class="source-line-no">2139</span><span id="line-2139"> }</span> |
| <span class="source-line-no">2140</span><span id="line-2140"></span> |
| <span class="source-line-no">2141</span><span id="line-2141"> /**</span> |
| <span class="source-line-no">2142</span><span id="line-2142"> * Copy the byte array given in parameter and return an instance of a new byte array with the same</span> |
| <span class="source-line-no">2143</span><span id="line-2143"> * length and the same content.</span> |
| <span class="source-line-no">2144</span><span id="line-2144"> * @param bytes the byte array to duplicate</span> |
| <span class="source-line-no">2145</span><span id="line-2145"> * @return a copy of the given byte array</span> |
| <span class="source-line-no">2146</span><span id="line-2146"> */</span> |
| <span class="source-line-no">2147</span><span id="line-2147"> public static byte[] copy(byte[] bytes) {</span> |
| <span class="source-line-no">2148</span><span id="line-2148"> if (bytes == null) return null;</span> |
| <span class="source-line-no">2149</span><span id="line-2149"> byte[] result = new byte[bytes.length];</span> |
| <span class="source-line-no">2150</span><span id="line-2150"> System.arraycopy(bytes, 0, result, 0, bytes.length);</span> |
| <span class="source-line-no">2151</span><span id="line-2151"> return result;</span> |
| <span class="source-line-no">2152</span><span id="line-2152"> }</span> |
| <span class="source-line-no">2153</span><span id="line-2153"></span> |
| <span class="source-line-no">2154</span><span id="line-2154"> /**</span> |
| <span class="source-line-no">2155</span><span id="line-2155"> * Copy the byte array given in parameter and return an instance of a new byte array with the same</span> |
| <span class="source-line-no">2156</span><span id="line-2156"> * length and the same content.</span> |
| <span class="source-line-no">2157</span><span id="line-2157"> * @param bytes the byte array to copy from</span> |
| <span class="source-line-no">2158</span><span id="line-2158"> * @return a copy of the given designated byte array</span> |
| <span class="source-line-no">2159</span><span id="line-2159"> */</span> |
| <span class="source-line-no">2160</span><span id="line-2160"> public static byte[] copy(byte[] bytes, final int offset, final int length) {</span> |
| <span class="source-line-no">2161</span><span id="line-2161"> if (bytes == null) return null;</span> |
| <span class="source-line-no">2162</span><span id="line-2162"> byte[] result = new byte[length];</span> |
| <span class="source-line-no">2163</span><span id="line-2163"> System.arraycopy(bytes, offset, result, 0, length);</span> |
| <span class="source-line-no">2164</span><span id="line-2164"> return result;</span> |
| <span class="source-line-no">2165</span><span id="line-2165"> }</span> |
| <span class="source-line-no">2166</span><span id="line-2166"></span> |
| <span class="source-line-no">2167</span><span id="line-2167"> /**</span> |
| <span class="source-line-no">2168</span><span id="line-2168"> * Search sorted array "a" for byte "key". I can't remember if I wrote this or copied it from</span> |
| <span class="source-line-no">2169</span><span id="line-2169"> * somewhere. (mcorgan)</span> |
| <span class="source-line-no">2170</span><span id="line-2170"> * @param a Array to search. Entries must be sorted and unique.</span> |
| <span class="source-line-no">2171</span><span id="line-2171"> * @param fromIndex First index inclusive of "a" to include in the search.</span> |
| <span class="source-line-no">2172</span><span id="line-2172"> * @param toIndex Last index exclusive of "a" to include in the search.</span> |
| <span class="source-line-no">2173</span><span id="line-2173"> * @param key The byte to search for.</span> |
| <span class="source-line-no">2174</span><span id="line-2174"> * @return The index of key if found. If not found, return -(index + 1), where negative indicates</span> |
| <span class="source-line-no">2175</span><span id="line-2175"> * "not found" and the "index + 1" handles the "-0" case.</span> |
| <span class="source-line-no">2176</span><span id="line-2176"> */</span> |
| <span class="source-line-no">2177</span><span id="line-2177"> public static int unsignedBinarySearch(byte[] a, int fromIndex, int toIndex, byte key) {</span> |
| <span class="source-line-no">2178</span><span id="line-2178"> int unsignedKey = key & 0xff;</span> |
| <span class="source-line-no">2179</span><span id="line-2179"> int low = fromIndex;</span> |
| <span class="source-line-no">2180</span><span id="line-2180"> int high = toIndex - 1;</span> |
| <span class="source-line-no">2181</span><span id="line-2181"></span> |
| <span class="source-line-no">2182</span><span id="line-2182"> while (low <= high) {</span> |
| <span class="source-line-no">2183</span><span id="line-2183"> int mid = low + ((high - low) >> 1);</span> |
| <span class="source-line-no">2184</span><span id="line-2184"> int midVal = a[mid] & 0xff;</span> |
| <span class="source-line-no">2185</span><span id="line-2185"></span> |
| <span class="source-line-no">2186</span><span id="line-2186"> if (midVal < unsignedKey) {</span> |
| <span class="source-line-no">2187</span><span id="line-2187"> low = mid + 1;</span> |
| <span class="source-line-no">2188</span><span id="line-2188"> } else if (midVal > unsignedKey) {</span> |
| <span class="source-line-no">2189</span><span id="line-2189"> high = mid - 1;</span> |
| <span class="source-line-no">2190</span><span id="line-2190"> } else {</span> |
| <span class="source-line-no">2191</span><span id="line-2191"> return mid; // key found</span> |
| <span class="source-line-no">2192</span><span id="line-2192"> }</span> |
| <span class="source-line-no">2193</span><span id="line-2193"> }</span> |
| <span class="source-line-no">2194</span><span id="line-2194"> return -(low + 1); // key not found.</span> |
| <span class="source-line-no">2195</span><span id="line-2195"> }</span> |
| <span class="source-line-no">2196</span><span id="line-2196"></span> |
| <span class="source-line-no">2197</span><span id="line-2197"> /**</span> |
| <span class="source-line-no">2198</span><span id="line-2198"> * Treat the byte[] as an unsigned series of bytes, most significant bits first. Start by adding 1</span> |
| <span class="source-line-no">2199</span><span id="line-2199"> * to the rightmost bit/byte and carry over all overflows to the more significant bits/bytes.</span> |
| <span class="source-line-no">2200</span><span id="line-2200"> * @param input The byte[] to increment.</span> |
| <span class="source-line-no">2201</span><span id="line-2201"> * @return The incremented copy of "in". May be same length or 1 byte longer.</span> |
| <span class="source-line-no">2202</span><span id="line-2202"> */</span> |
| <span class="source-line-no">2203</span><span id="line-2203"> public static byte[] unsignedCopyAndIncrement(final byte[] input) {</span> |
| <span class="source-line-no">2204</span><span id="line-2204"> byte[] copy = copy(input);</span> |
| <span class="source-line-no">2205</span><span id="line-2205"> if (copy == null) {</span> |
| <span class="source-line-no">2206</span><span id="line-2206"> throw new IllegalArgumentException("cannot increment null array");</span> |
| <span class="source-line-no">2207</span><span id="line-2207"> }</span> |
| <span class="source-line-no">2208</span><span id="line-2208"> for (int i = copy.length - 1; i >= 0; --i) {</span> |
| <span class="source-line-no">2209</span><span id="line-2209"> if (copy[i] == -1) {// -1 is all 1-bits, which is the unsigned maximum</span> |
| <span class="source-line-no">2210</span><span id="line-2210"> copy[i] = 0;</span> |
| <span class="source-line-no">2211</span><span id="line-2211"> } else {</span> |
| <span class="source-line-no">2212</span><span id="line-2212"> ++copy[i];</span> |
| <span class="source-line-no">2213</span><span id="line-2213"> return copy;</span> |
| <span class="source-line-no">2214</span><span id="line-2214"> }</span> |
| <span class="source-line-no">2215</span><span id="line-2215"> }</span> |
| <span class="source-line-no">2216</span><span id="line-2216"> // we maxed out the array</span> |
| <span class="source-line-no">2217</span><span id="line-2217"> byte[] out = new byte[copy.length + 1];</span> |
| <span class="source-line-no">2218</span><span id="line-2218"> out[0] = 1;</span> |
| <span class="source-line-no">2219</span><span id="line-2219"> System.arraycopy(copy, 0, out, 1, copy.length);</span> |
| <span class="source-line-no">2220</span><span id="line-2220"> return out;</span> |
| <span class="source-line-no">2221</span><span id="line-2221"> }</span> |
| <span class="source-line-no">2222</span><span id="line-2222"></span> |
| <span class="source-line-no">2223</span><span id="line-2223"> public static boolean equals(List<byte[]> a, List<byte[]> b) {</span> |
| <span class="source-line-no">2224</span><span id="line-2224"> if (a == null) {</span> |
| <span class="source-line-no">2225</span><span id="line-2225"> if (b == null) {</span> |
| <span class="source-line-no">2226</span><span id="line-2226"> return true;</span> |
| <span class="source-line-no">2227</span><span id="line-2227"> }</span> |
| <span class="source-line-no">2228</span><span id="line-2228"> return false;</span> |
| <span class="source-line-no">2229</span><span id="line-2229"> }</span> |
| <span class="source-line-no">2230</span><span id="line-2230"> if (b == null) {</span> |
| <span class="source-line-no">2231</span><span id="line-2231"> return false;</span> |
| <span class="source-line-no">2232</span><span id="line-2232"> }</span> |
| <span class="source-line-no">2233</span><span id="line-2233"> if (a.size() != b.size()) {</span> |
| <span class="source-line-no">2234</span><span id="line-2234"> return false;</span> |
| <span class="source-line-no">2235</span><span id="line-2235"> }</span> |
| <span class="source-line-no">2236</span><span id="line-2236"> for (int i = 0; i < a.size(); ++i) {</span> |
| <span class="source-line-no">2237</span><span id="line-2237"> if (!Bytes.equals(a.get(i), b.get(i))) {</span> |
| <span class="source-line-no">2238</span><span id="line-2238"> return false;</span> |
| <span class="source-line-no">2239</span><span id="line-2239"> }</span> |
| <span class="source-line-no">2240</span><span id="line-2240"> }</span> |
| <span class="source-line-no">2241</span><span id="line-2241"> return true;</span> |
| <span class="source-line-no">2242</span><span id="line-2242"> }</span> |
| <span class="source-line-no">2243</span><span id="line-2243"></span> |
| <span class="source-line-no">2244</span><span id="line-2244"> public static boolean isSorted(Collection<byte[]> arrays) {</span> |
| <span class="source-line-no">2245</span><span id="line-2245"> if (!CollectionUtils.isEmpty(arrays)) {</span> |
| <span class="source-line-no">2246</span><span id="line-2246"> byte[] previous = new byte[0];</span> |
| <span class="source-line-no">2247</span><span id="line-2247"> for (byte[] array : arrays) {</span> |
| <span class="source-line-no">2248</span><span id="line-2248"> if (Bytes.compareTo(previous, array) > 0) {</span> |
| <span class="source-line-no">2249</span><span id="line-2249"> return false;</span> |
| <span class="source-line-no">2250</span><span id="line-2250"> }</span> |
| <span class="source-line-no">2251</span><span id="line-2251"> previous = array;</span> |
| <span class="source-line-no">2252</span><span id="line-2252"> }</span> |
| <span class="source-line-no">2253</span><span id="line-2253"> }</span> |
| <span class="source-line-no">2254</span><span id="line-2254"> return true;</span> |
| <span class="source-line-no">2255</span><span id="line-2255"> }</span> |
| <span class="source-line-no">2256</span><span id="line-2256"></span> |
| <span class="source-line-no">2257</span><span id="line-2257"> public static List<byte[]> getUtf8ByteArrays(List<String> strings) {</span> |
| <span class="source-line-no">2258</span><span id="line-2258"> if (CollectionUtils.isEmpty(strings)) {</span> |
| <span class="source-line-no">2259</span><span id="line-2259"> return Collections.emptyList();</span> |
| <span class="source-line-no">2260</span><span id="line-2260"> }</span> |
| <span class="source-line-no">2261</span><span id="line-2261"> List<byte[]> byteArrays = new ArrayList<>(strings.size());</span> |
| <span class="source-line-no">2262</span><span id="line-2262"> strings.forEach(s -> byteArrays.add(Bytes.toBytes(s)));</span> |
| <span class="source-line-no">2263</span><span id="line-2263"> return byteArrays;</span> |
| <span class="source-line-no">2264</span><span id="line-2264"> }</span> |
| <span class="source-line-no">2265</span><span id="line-2265"></span> |
| <span class="source-line-no">2266</span><span id="line-2266"> /**</span> |
| <span class="source-line-no">2267</span><span id="line-2267"> * Returns the index of the first appearance of the value {@code target} in {@code array}.</span> |
| <span class="source-line-no">2268</span><span id="line-2268"> * @param array an array of {@code byte} values, possibly empty</span> |
| <span class="source-line-no">2269</span><span id="line-2269"> * @param target a primitive {@code byte} value</span> |
| <span class="source-line-no">2270</span><span id="line-2270"> * @return the least index {@code i} for which {@code array[i] == target}, or {@code -1} if no</span> |
| <span class="source-line-no">2271</span><span id="line-2271"> * such index exists.</span> |
| <span class="source-line-no">2272</span><span id="line-2272"> */</span> |
| <span class="source-line-no">2273</span><span id="line-2273"> public static int indexOf(byte[] array, byte target) {</span> |
| <span class="source-line-no">2274</span><span id="line-2274"> for (int i = 0; i < array.length; i++) {</span> |
| <span class="source-line-no">2275</span><span id="line-2275"> if (array[i] == target) {</span> |
| <span class="source-line-no">2276</span><span id="line-2276"> return i;</span> |
| <span class="source-line-no">2277</span><span id="line-2277"> }</span> |
| <span class="source-line-no">2278</span><span id="line-2278"> }</span> |
| <span class="source-line-no">2279</span><span id="line-2279"> return -1;</span> |
| <span class="source-line-no">2280</span><span id="line-2280"> }</span> |
| <span class="source-line-no">2281</span><span id="line-2281"></span> |
| <span class="source-line-no">2282</span><span id="line-2282"> /**</span> |
| <span class="source-line-no">2283</span><span id="line-2283"> * Returns the start position of the first occurrence of the specified {@code</span> |
| <span class="source-line-no">2284</span><span id="line-2284"> * target} within {@code array}, or {@code -1} if there is no such occurrence.</span> |
| <span class="source-line-no">2285</span><span id="line-2285"> * <p></span> |
| <span class="source-line-no">2286</span><span id="line-2286"> * More formally, returns the lowest index {@code i} such that {@code</span> |
| <span class="source-line-no">2287</span><span id="line-2287"> * java.util.Arrays.copyOfRange(array, i, i + target.length)} contains exactly the same elements</span> |
| <span class="source-line-no">2288</span><span id="line-2288"> * as {@code target}.</span> |
| <span class="source-line-no">2289</span><span id="line-2289"> * @param array the array to search for the sequence {@code target}</span> |
| <span class="source-line-no">2290</span><span id="line-2290"> * @param target the array to search for as a sub-sequence of {@code array}</span> |
| <span class="source-line-no">2291</span><span id="line-2291"> */</span> |
| <span class="source-line-no">2292</span><span id="line-2292"> public static int indexOf(byte[] array, byte[] target) {</span> |
| <span class="source-line-no">2293</span><span id="line-2293"> checkNotNull(array, "array");</span> |
| <span class="source-line-no">2294</span><span id="line-2294"> checkNotNull(target, "target");</span> |
| <span class="source-line-no">2295</span><span id="line-2295"> if (target.length == 0) {</span> |
| <span class="source-line-no">2296</span><span id="line-2296"> return 0;</span> |
| <span class="source-line-no">2297</span><span id="line-2297"> }</span> |
| <span class="source-line-no">2298</span><span id="line-2298"></span> |
| <span class="source-line-no">2299</span><span id="line-2299"> outer: for (int i = 0; i < array.length - target.length + 1; i++) {</span> |
| <span class="source-line-no">2300</span><span id="line-2300"> for (int j = 0; j < target.length; j++) {</span> |
| <span class="source-line-no">2301</span><span id="line-2301"> if (array[i + j] != target[j]) {</span> |
| <span class="source-line-no">2302</span><span id="line-2302"> continue outer;</span> |
| <span class="source-line-no">2303</span><span id="line-2303"> }</span> |
| <span class="source-line-no">2304</span><span id="line-2304"> }</span> |
| <span class="source-line-no">2305</span><span id="line-2305"> return i;</span> |
| <span class="source-line-no">2306</span><span id="line-2306"> }</span> |
| <span class="source-line-no">2307</span><span id="line-2307"> return -1;</span> |
| <span class="source-line-no">2308</span><span id="line-2308"> }</span> |
| <span class="source-line-no">2309</span><span id="line-2309"></span> |
| <span class="source-line-no">2310</span><span id="line-2310"> /**</span> |
| <span class="source-line-no">2311</span><span id="line-2311"> * Return true if target is present as an element anywhere in the given array.</span> |
| <span class="source-line-no">2312</span><span id="line-2312"> * @param array an array of {@code byte} values, possibly empty</span> |
| <span class="source-line-no">2313</span><span id="line-2313"> * @param target a primitive {@code byte} value</span> |
| <span class="source-line-no">2314</span><span id="line-2314"> * @return {@code true} if {@code target} is present as an element anywhere in {@code array}.</span> |
| <span class="source-line-no">2315</span><span id="line-2315"> */</span> |
| <span class="source-line-no">2316</span><span id="line-2316"> public static boolean contains(byte[] array, byte target) {</span> |
| <span class="source-line-no">2317</span><span id="line-2317"> return indexOf(array, target) > -1;</span> |
| <span class="source-line-no">2318</span><span id="line-2318"> }</span> |
| <span class="source-line-no">2319</span><span id="line-2319"></span> |
| <span class="source-line-no">2320</span><span id="line-2320"> /**</span> |
| <span class="source-line-no">2321</span><span id="line-2321"> * Return true if target is present as an element anywhere in the given array.</span> |
| <span class="source-line-no">2322</span><span id="line-2322"> * @param array an array of {@code byte} values, possibly empty</span> |
| <span class="source-line-no">2323</span><span id="line-2323"> * @param target an array of {@code byte}</span> |
| <span class="source-line-no">2324</span><span id="line-2324"> * @return {@code true} if {@code target} is present anywhere in {@code array}</span> |
| <span class="source-line-no">2325</span><span id="line-2325"> */</span> |
| <span class="source-line-no">2326</span><span id="line-2326"> public static boolean contains(byte[] array, byte[] target) {</span> |
| <span class="source-line-no">2327</span><span id="line-2327"> return indexOf(array, target) > -1;</span> |
| <span class="source-line-no">2328</span><span id="line-2328"> }</span> |
| <span class="source-line-no">2329</span><span id="line-2329"></span> |
| <span class="source-line-no">2330</span><span id="line-2330"> /**</span> |
| <span class="source-line-no">2331</span><span id="line-2331"> * Fill given array with zeros.</span> |
| <span class="source-line-no">2332</span><span id="line-2332"> * @param b array which needs to be filled with zeros</span> |
| <span class="source-line-no">2333</span><span id="line-2333"> */</span> |
| <span class="source-line-no">2334</span><span id="line-2334"> public static void zero(byte[] b) {</span> |
| <span class="source-line-no">2335</span><span id="line-2335"> zero(b, 0, b.length);</span> |
| <span class="source-line-no">2336</span><span id="line-2336"> }</span> |
| <span class="source-line-no">2337</span><span id="line-2337"></span> |
| <span class="source-line-no">2338</span><span id="line-2338"> /**</span> |
| <span class="source-line-no">2339</span><span id="line-2339"> * Fill given array with zeros at the specified position.</span> |
| <span class="source-line-no">2340</span><span id="line-2340"> */</span> |
| <span class="source-line-no">2341</span><span id="line-2341"> public static void zero(byte[] b, int offset, int length) {</span> |
| <span class="source-line-no">2342</span><span id="line-2342"> checkPositionIndex(offset, b.length, "offset");</span> |
| <span class="source-line-no">2343</span><span id="line-2343"> checkArgument(length > 0, "length must be greater than 0");</span> |
| <span class="source-line-no">2344</span><span id="line-2344"> checkPositionIndex(offset + length, b.length, "offset + length");</span> |
| <span class="source-line-no">2345</span><span id="line-2345"> Arrays.fill(b, offset, offset + length, (byte) 0);</span> |
| <span class="source-line-no">2346</span><span id="line-2346"> }</span> |
| <span class="source-line-no">2347</span><span id="line-2347"></span> |
| <span class="source-line-no">2348</span><span id="line-2348"> // Pseudorandom random number generator, do not use SecureRandom here</span> |
| <span class="source-line-no">2349</span><span id="line-2349"> private static final Random RNG = new Random();</span> |
| <span class="source-line-no">2350</span><span id="line-2350"></span> |
| <span class="source-line-no">2351</span><span id="line-2351"> /**</span> |
| <span class="source-line-no">2352</span><span id="line-2352"> * Fill given array with random bytes.</span> |
| <span class="source-line-no">2353</span><span id="line-2353"> * @param b array which needs to be filled with random bytes</span> |
| <span class="source-line-no">2354</span><span id="line-2354"> * <p></span> |
| <span class="source-line-no">2355</span><span id="line-2355"> * If you want random bytes generated by a strong source of randomness use</span> |
| <span class="source-line-no">2356</span><span id="line-2356"> * {@link Bytes#secureRandom(byte[])}.</span> |
| <span class="source-line-no">2357</span><span id="line-2357"> * @param b array which needs to be filled with random bytes</span> |
| <span class="source-line-no">2358</span><span id="line-2358"> */</span> |
| <span class="source-line-no">2359</span><span id="line-2359"> public static void random(byte[] b) {</span> |
| <span class="source-line-no">2360</span><span id="line-2360"> RNG.nextBytes(b);</span> |
| <span class="source-line-no">2361</span><span id="line-2361"> }</span> |
| <span class="source-line-no">2362</span><span id="line-2362"></span> |
| <span class="source-line-no">2363</span><span id="line-2363"> /**</span> |
| <span class="source-line-no">2364</span><span id="line-2364"> * Fill given array with random bytes at the specified position.</span> |
| <span class="source-line-no">2365</span><span id="line-2365"> * <p></span> |
| <span class="source-line-no">2366</span><span id="line-2366"> * If you want random bytes generated by a strong source of randomness use</span> |
| <span class="source-line-no">2367</span><span id="line-2367"> * {@link Bytes#secureRandom(byte[], int, int)}.</span> |
| <span class="source-line-no">2368</span><span id="line-2368"> * @param b array which needs to be filled with random bytes</span> |
| <span class="source-line-no">2369</span><span id="line-2369"> * @param offset staring offset in array</span> |
| <span class="source-line-no">2370</span><span id="line-2370"> * @param length number of bytes to fill</span> |
| <span class="source-line-no">2371</span><span id="line-2371"> */</span> |
| <span class="source-line-no">2372</span><span id="line-2372"> public static void random(byte[] b, int offset, int length) {</span> |
| <span class="source-line-no">2373</span><span id="line-2373"> checkPositionIndex(offset, b.length, "offset");</span> |
| <span class="source-line-no">2374</span><span id="line-2374"> checkArgument(length > 0, "length must be greater than 0");</span> |
| <span class="source-line-no">2375</span><span id="line-2375"> checkPositionIndex(offset + length, b.length, "offset + length");</span> |
| <span class="source-line-no">2376</span><span id="line-2376"> byte[] buf = new byte[length];</span> |
| <span class="source-line-no">2377</span><span id="line-2377"> RNG.nextBytes(buf);</span> |
| <span class="source-line-no">2378</span><span id="line-2378"> System.arraycopy(buf, 0, b, offset, length);</span> |
| <span class="source-line-no">2379</span><span id="line-2379"> }</span> |
| <span class="source-line-no">2380</span><span id="line-2380"></span> |
| <span class="source-line-no">2381</span><span id="line-2381"> // Bytes.secureRandom may be used to create key material.</span> |
| <span class="source-line-no">2382</span><span id="line-2382"> private static final SecureRandom SECURE_RNG = new SecureRandom();</span> |
| <span class="source-line-no">2383</span><span id="line-2383"></span> |
| <span class="source-line-no">2384</span><span id="line-2384"> /**</span> |
| <span class="source-line-no">2385</span><span id="line-2385"> * Fill given array with random bytes using a strong random number generator.</span> |
| <span class="source-line-no">2386</span><span id="line-2386"> * @param b array which needs to be filled with random bytes</span> |
| <span class="source-line-no">2387</span><span id="line-2387"> */</span> |
| <span class="source-line-no">2388</span><span id="line-2388"> public static void secureRandom(byte[] b) {</span> |
| <span class="source-line-no">2389</span><span id="line-2389"> SECURE_RNG.nextBytes(b);</span> |
| <span class="source-line-no">2390</span><span id="line-2390"> }</span> |
| <span class="source-line-no">2391</span><span id="line-2391"></span> |
| <span class="source-line-no">2392</span><span id="line-2392"> /**</span> |
| <span class="source-line-no">2393</span><span id="line-2393"> * Fill given array with random bytes at the specified position using a strong random number</span> |
| <span class="source-line-no">2394</span><span id="line-2394"> * generator.</span> |
| <span class="source-line-no">2395</span><span id="line-2395"> * @param b array which needs to be filled with random bytes</span> |
| <span class="source-line-no">2396</span><span id="line-2396"> * @param offset staring offset in array</span> |
| <span class="source-line-no">2397</span><span id="line-2397"> * @param length number of bytes to fill</span> |
| <span class="source-line-no">2398</span><span id="line-2398"> */</span> |
| <span class="source-line-no">2399</span><span id="line-2399"> public static void secureRandom(byte[] b, int offset, int length) {</span> |
| <span class="source-line-no">2400</span><span id="line-2400"> checkPositionIndex(offset, b.length, "offset");</span> |
| <span class="source-line-no">2401</span><span id="line-2401"> checkArgument(length > 0, "length must be greater than 0");</span> |
| <span class="source-line-no">2402</span><span id="line-2402"> checkPositionIndex(offset + length, b.length, "offset + length");</span> |
| <span class="source-line-no">2403</span><span id="line-2403"> byte[] buf = new byte[length];</span> |
| <span class="source-line-no">2404</span><span id="line-2404"> SECURE_RNG.nextBytes(buf);</span> |
| <span class="source-line-no">2405</span><span id="line-2405"> System.arraycopy(buf, 0, b, offset, length);</span> |
| <span class="source-line-no">2406</span><span id="line-2406"> }</span> |
| <span class="source-line-no">2407</span><span id="line-2407"></span> |
| <span class="source-line-no">2408</span><span id="line-2408"> /**</span> |
| <span class="source-line-no">2409</span><span id="line-2409"> * Create a max byte array with the specified max byte count</span> |
| <span class="source-line-no">2410</span><span id="line-2410"> * @param maxByteCount the length of returned byte array</span> |
| <span class="source-line-no">2411</span><span id="line-2411"> * @return the created max byte array</span> |
| <span class="source-line-no">2412</span><span id="line-2412"> */</span> |
| <span class="source-line-no">2413</span><span id="line-2413"> public static byte[] createMaxByteArray(int maxByteCount) {</span> |
| <span class="source-line-no">2414</span><span id="line-2414"> byte[] maxByteArray = new byte[maxByteCount];</span> |
| <span class="source-line-no">2415</span><span id="line-2415"> for (int i = 0; i < maxByteArray.length; i++) {</span> |
| <span class="source-line-no">2416</span><span id="line-2416"> maxByteArray[i] = (byte) 0xff;</span> |
| <span class="source-line-no">2417</span><span id="line-2417"> }</span> |
| <span class="source-line-no">2418</span><span id="line-2418"> return maxByteArray;</span> |
| <span class="source-line-no">2419</span><span id="line-2419"> }</span> |
| <span class="source-line-no">2420</span><span id="line-2420"></span> |
| <span class="source-line-no">2421</span><span id="line-2421"> /**</span> |
| <span class="source-line-no">2422</span><span id="line-2422"> * Create a byte array which is multiple given bytes</span> |
| <span class="source-line-no">2423</span><span id="line-2423"> * @return byte array</span> |
| <span class="source-line-no">2424</span><span id="line-2424"> */</span> |
| <span class="source-line-no">2425</span><span id="line-2425"> public static byte[] multiple(byte[] srcBytes, int multiNum) {</span> |
| <span class="source-line-no">2426</span><span id="line-2426"> if (multiNum <= 0) {</span> |
| <span class="source-line-no">2427</span><span id="line-2427"> return new byte[0];</span> |
| <span class="source-line-no">2428</span><span id="line-2428"> }</span> |
| <span class="source-line-no">2429</span><span id="line-2429"> byte[] result = new byte[srcBytes.length * multiNum];</span> |
| <span class="source-line-no">2430</span><span id="line-2430"> for (int i = 0; i < multiNum; i++) {</span> |
| <span class="source-line-no">2431</span><span id="line-2431"> System.arraycopy(srcBytes, 0, result, i * srcBytes.length, srcBytes.length);</span> |
| <span class="source-line-no">2432</span><span id="line-2432"> }</span> |
| <span class="source-line-no">2433</span><span id="line-2433"> return result;</span> |
| <span class="source-line-no">2434</span><span id="line-2434"> }</span> |
| <span class="source-line-no">2435</span><span id="line-2435"></span> |
| <span class="source-line-no">2436</span><span id="line-2436"> private static final char[] HEX_CHARS =</span> |
| <span class="source-line-no">2437</span><span id="line-2437"> { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };</span> |
| <span class="source-line-no">2438</span><span id="line-2438"></span> |
| <span class="source-line-no">2439</span><span id="line-2439"> /**</span> |
| <span class="source-line-no">2440</span><span id="line-2440"> * Convert a byte range into a hex string</span> |
| <span class="source-line-no">2441</span><span id="line-2441"> */</span> |
| <span class="source-line-no">2442</span><span id="line-2442"> public static String toHex(byte[] b, int offset, int length) {</span> |
| <span class="source-line-no">2443</span><span id="line-2443"> checkArgument(length <= Integer.MAX_VALUE / 2);</span> |
| <span class="source-line-no">2444</span><span id="line-2444"> int numChars = length * 2;</span> |
| <span class="source-line-no">2445</span><span id="line-2445"> char[] ch = new char[numChars];</span> |
| <span class="source-line-no">2446</span><span id="line-2446"> for (int i = 0; i < numChars; i += 2) {</span> |
| <span class="source-line-no">2447</span><span id="line-2447"> byte d = b[offset + i / 2];</span> |
| <span class="source-line-no">2448</span><span id="line-2448"> ch[i] = HEX_CHARS[(d >> 4) & 0x0F];</span> |
| <span class="source-line-no">2449</span><span id="line-2449"> ch[i + 1] = HEX_CHARS[d & 0x0F];</span> |
| <span class="source-line-no">2450</span><span id="line-2450"> }</span> |
| <span class="source-line-no">2451</span><span id="line-2451"> return new String(ch);</span> |
| <span class="source-line-no">2452</span><span id="line-2452"> }</span> |
| <span class="source-line-no">2453</span><span id="line-2453"></span> |
| <span class="source-line-no">2454</span><span id="line-2454"> /**</span> |
| <span class="source-line-no">2455</span><span id="line-2455"> * Convert a byte array into a hex string</span> |
| <span class="source-line-no">2456</span><span id="line-2456"> */</span> |
| <span class="source-line-no">2457</span><span id="line-2457"> public static String toHex(byte[] b) {</span> |
| <span class="source-line-no">2458</span><span id="line-2458"> return toHex(b, 0, b.length);</span> |
| <span class="source-line-no">2459</span><span id="line-2459"> }</span> |
| <span class="source-line-no">2460</span><span id="line-2460"></span> |
| <span class="source-line-no">2461</span><span id="line-2461"> private static int hexCharToNibble(char ch) {</span> |
| <span class="source-line-no">2462</span><span id="line-2462"> if (ch <= '9' && ch >= '0') {</span> |
| <span class="source-line-no">2463</span><span id="line-2463"> return ch - '0';</span> |
| <span class="source-line-no">2464</span><span id="line-2464"> } else if (ch >= 'a' && ch <= 'f') {</span> |
| <span class="source-line-no">2465</span><span id="line-2465"> return ch - 'a' + 10;</span> |
| <span class="source-line-no">2466</span><span id="line-2466"> } else if (ch >= 'A' && ch <= 'F') {</span> |
| <span class="source-line-no">2467</span><span id="line-2467"> return ch - 'A' + 10;</span> |
| <span class="source-line-no">2468</span><span id="line-2468"> }</span> |
| <span class="source-line-no">2469</span><span id="line-2469"> throw new IllegalArgumentException("Invalid hex char: " + ch);</span> |
| <span class="source-line-no">2470</span><span id="line-2470"> }</span> |
| <span class="source-line-no">2471</span><span id="line-2471"></span> |
| <span class="source-line-no">2472</span><span id="line-2472"> private static byte hexCharsToByte(char c1, char c2) {</span> |
| <span class="source-line-no">2473</span><span id="line-2473"> return (byte) ((hexCharToNibble(c1) << 4) | hexCharToNibble(c2));</span> |
| <span class="source-line-no">2474</span><span id="line-2474"> }</span> |
| <span class="source-line-no">2475</span><span id="line-2475"></span> |
| <span class="source-line-no">2476</span><span id="line-2476"> /**</span> |
| <span class="source-line-no">2477</span><span id="line-2477"> * Create a byte array from a string of hash digits. The length of the string must be a multiple</span> |
| <span class="source-line-no">2478</span><span id="line-2478"> * of 2</span> |
| <span class="source-line-no">2479</span><span id="line-2479"> */</span> |
| <span class="source-line-no">2480</span><span id="line-2480"> public static byte[] fromHex(String hex) {</span> |
| <span class="source-line-no">2481</span><span id="line-2481"> checkArgument(hex.length() % 2 == 0, "length must be a multiple of 2");</span> |
| <span class="source-line-no">2482</span><span id="line-2482"> int len = hex.length();</span> |
| <span class="source-line-no">2483</span><span id="line-2483"> byte[] b = new byte[len / 2];</span> |
| <span class="source-line-no">2484</span><span id="line-2484"> for (int i = 0; i < len; i += 2) {</span> |
| <span class="source-line-no">2485</span><span id="line-2485"> b[i / 2] = hexCharsToByte(hex.charAt(i), hex.charAt(i + 1));</span> |
| <span class="source-line-no">2486</span><span id="line-2486"> }</span> |
| <span class="source-line-no">2487</span><span id="line-2487"> return b;</span> |
| <span class="source-line-no">2488</span><span id="line-2488"> }</span> |
| <span class="source-line-no">2489</span><span id="line-2489"></span> |
| <span class="source-line-no">2490</span><span id="line-2490"> /**</span> |
| <span class="source-line-no">2491</span><span id="line-2491"> * Find index of passed delimiter.</span> |
| <span class="source-line-no">2492</span><span id="line-2492"> * @return Index of delimiter having started from start of <code>b</code> moving rightward.</span> |
| <span class="source-line-no">2493</span><span id="line-2493"> */</span> |
| <span class="source-line-no">2494</span><span id="line-2494"> public static int searchDelimiterIndex(final byte[] b, int offset, final int length,</span> |
| <span class="source-line-no">2495</span><span id="line-2495"> final int delimiter) {</span> |
| <span class="source-line-no">2496</span><span id="line-2496"> if (b == null) {</span> |
| <span class="source-line-no">2497</span><span id="line-2497"> throw new IllegalArgumentException("Passed buffer is null");</span> |
| <span class="source-line-no">2498</span><span id="line-2498"> }</span> |
| <span class="source-line-no">2499</span><span id="line-2499"> int result = -1;</span> |
| <span class="source-line-no">2500</span><span id="line-2500"> for (int i = offset; i < length + offset; i++) {</span> |
| <span class="source-line-no">2501</span><span id="line-2501"> if (b[i] == delimiter) {</span> |
| <span class="source-line-no">2502</span><span id="line-2502"> result = i;</span> |
| <span class="source-line-no">2503</span><span id="line-2503"> break;</span> |
| <span class="source-line-no">2504</span><span id="line-2504"> }</span> |
| <span class="source-line-no">2505</span><span id="line-2505"> }</span> |
| <span class="source-line-no">2506</span><span id="line-2506"> return result;</span> |
| <span class="source-line-no">2507</span><span id="line-2507"> }</span> |
| <span class="source-line-no">2508</span><span id="line-2508"></span> |
| <span class="source-line-no">2509</span><span id="line-2509"> /**</span> |
| <span class="source-line-no">2510</span><span id="line-2510"> * Find index of passed delimiter walking from end of buffer backwards.</span> |
| <span class="source-line-no">2511</span><span id="line-2511"> * @return Index of delimiter</span> |
| <span class="source-line-no">2512</span><span id="line-2512"> */</span> |
| <span class="source-line-no">2513</span><span id="line-2513"> public static int searchDelimiterIndexInReverse(final byte[] b, final int offset,</span> |
| <span class="source-line-no">2514</span><span id="line-2514"> final int length, final int delimiter) {</span> |
| <span class="source-line-no">2515</span><span id="line-2515"> if (b == null) {</span> |
| <span class="source-line-no">2516</span><span id="line-2516"> throw new IllegalArgumentException("Passed buffer is null");</span> |
| <span class="source-line-no">2517</span><span id="line-2517"> }</span> |
| <span class="source-line-no">2518</span><span id="line-2518"> int result = -1;</span> |
| <span class="source-line-no">2519</span><span id="line-2519"> for (int i = (offset + length) - 1; i >= offset; i--) {</span> |
| <span class="source-line-no">2520</span><span id="line-2520"> if (b[i] == delimiter) {</span> |
| <span class="source-line-no">2521</span><span id="line-2521"> result = i;</span> |
| <span class="source-line-no">2522</span><span id="line-2522"> break;</span> |
| <span class="source-line-no">2523</span><span id="line-2523"> }</span> |
| <span class="source-line-no">2524</span><span id="line-2524"> }</span> |
| <span class="source-line-no">2525</span><span id="line-2525"> return result;</span> |
| <span class="source-line-no">2526</span><span id="line-2526"> }</span> |
| <span class="source-line-no">2527</span><span id="line-2527"></span> |
| <span class="source-line-no">2528</span><span id="line-2528"> public static int findCommonPrefix(byte[] left, byte[] right, int leftLength, int rightLength,</span> |
| <span class="source-line-no">2529</span><span id="line-2529"> int leftOffset, int rightOffset) {</span> |
| <span class="source-line-no">2530</span><span id="line-2530"> return CommonPrefixerHolder.BEST_COMMON_PREFIXER.findCommonPrefix(left, leftOffset, leftLength,</span> |
| <span class="source-line-no">2531</span><span id="line-2531"> right, rightOffset, rightLength);</span> |
| <span class="source-line-no">2532</span><span id="line-2532"> }</span> |
| <span class="source-line-no">2533</span><span id="line-2533">}</span> |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| </pre> |
| </div> |
| </main> |
| </body> |
| </html> |
