001/*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements.  See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License.  You may obtain a copy of the License at
008 *
009 *      http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017package org.apache.commons.lang3;
018
019/**
020 * Supports operations on bit-mapped fields. Instances of this class can be
021 * used to store a flag or data within an {@code int}, {@code short} or
022 * {@code byte}.
023 *
024 * <p>Each {@link BitField} is constructed with a mask value, which indicates
025 * the bits that will be used to store and retrieve the data for that field.
026 * For instance, the mask {@code 0xFF} indicates the least-significant byte
027 * should be used to store the data.</p>
028 *
029 * <p>As an example, consider a car painting machine that accepts
030 * paint instructions as integers. Bit fields can be used to encode this:</p>
031 *
032 *<pre>
033 *    // blue, green and red are 1 byte values (0-255) stored in the three least
034 *    // significant bytes
035 *    BitField blue = new BitField(0xFF);
036 *    BitField green = new BitField(0xFF00);
037 *    BitField red = new BitField(0xFF0000);
038 *
039 *    // anyColor is a flag triggered if any color is used
040 *    BitField anyColor = new BitField(0xFFFFFF);
041 *
042 *    // isMetallic is a single bit flag
043 *    BitField isMetallic = new BitField(0x1000000);
044 *</pre>
045 *
046 * <p>Using these {@link BitField} instances, a paint instruction can be
047 * encoded into an integer:</p>
048 *
049 *<pre>
050 *    int paintInstruction = 0;
051 *    paintInstruction = red.setValue(paintInstruction, 35);
052 *    paintInstruction = green.setValue(paintInstruction, 100);
053 *    paintInstruction = blue.setValue(paintInstruction, 255);
054 *</pre>
055 *
056 * <p>Flags and data can be retrieved from the integer:</p>
057 *
058 *<pre>
059 *    // Prints true if red, green or blue is non-zero
060 *    System.out.println(anyColor.isSet(paintInstruction));   // prints true
061 *
062 *    // Prints value of red, green and blue
063 *    System.out.println(red.getValue(paintInstruction));     // prints 35
064 *    System.out.println(green.getValue(paintInstruction));   // prints 100
065 *    System.out.println(blue.getValue(paintInstruction));    // prints 255
066 *
067 *    // Prints true if isMetallic was set
068 *    System.out.println(isMetallic.isSet(paintInstruction)); // prints false
069 *</pre>
070 *
071 * @since 2.0
072 */
073public class BitField {
074
075    private final int mask;
076    private final int shiftCount;
077
078    /**
079     * Creates a BitField instance.
080     *
081     * @param mask the mask specifying which bits apply to this
082     *  BitField. Bits that are set in this mask are the bits
083     *  that this BitField operates on
084     */
085    public BitField(final int mask) {
086        this.mask = mask;
087        this.shiftCount = mask == 0 ? 0 : Integer.numberOfTrailingZeros(mask);
088    }
089
090    /**
091     * Clears the bits.
092     *
093     * @param holder the int data containing the bits we're
094     *  interested in
095     * @return the value of holder with the specified bits cleared
096     *  (set to {@code 0})
097     */
098    public int clear(final int holder) {
099        return holder & ~mask;
100    }
101
102    /**
103     * Clears the bits.
104     *
105     * @param holder the byte data containing the bits we're
106     *  interested in
107     *
108     * @return the value of holder with the specified bits cleared
109     *  (set to {@code 0})
110     */
111    public byte clearByte(final byte holder) {
112        return (byte) clear(holder);
113    }
114
115    /**
116     * Clears the bits.
117     *
118     * @param holder the short data containing the bits we're
119     *  interested in
120     * @return the value of holder with the specified bits cleared
121     *  (set to {@code 0})
122     */
123    public short clearShort(final short holder) {
124        return (short) clear(holder);
125    }
126
127    /**
128     * Obtains the value for the specified BitField, unshifted.
129     *
130     * @param holder the int data containing the bits we're
131     *  interested in
132     * @return the selected bits
133     */
134    public int getRawValue(final int holder) {
135        return holder & mask;
136    }
137
138    /**
139     * Obtains the value for the specified BitField, unshifted.
140     *
141     * @param holder the short data containing the bits we're
142     *  interested in
143     * @return the selected bits
144     */
145    public short getShortRawValue(final short holder) {
146        return (short) getRawValue(holder);
147    }
148
149    /**
150     * Obtains the value for the specified BitField, appropriately
151     * shifted right, as a short.
152     *
153     * <p>Many users of a BitField will want to treat the specified
154     * bits as an int value, and will not want to be aware that the
155     * value is stored as a BitField (and so shifted left so many
156     * bits).</p>
157     *
158     * @see #setShortValue(short,short)
159     * @param holder the short data containing the bits we're
160     *  interested in
161     * @return the selected bits, shifted right appropriately
162     */
163    public short getShortValue(final short holder) {
164        return (short) getValue(holder);
165    }
166
167    /**
168     * Obtains the value for the specified BitField, appropriately
169     * shifted right.
170     *
171     * <p>Many users of a BitField will want to treat the specified
172     * bits as an int value, and will not want to be aware that the
173     * value is stored as a BitField (and so shifted left so many
174     * bits).</p>
175     *
176     * @see #setValue(int,int)
177     * @param holder the int data containing the bits we're interested
178     *  in
179     * @return the selected bits, shifted right appropriately
180     */
181    public int getValue(final int holder) {
182        return getRawValue(holder) >> shiftCount;
183    }
184
185    /**
186     * Returns whether all of the bits are set or not.
187     *
188     * <p>This is a stricter test than {@link #isSet(int)},
189     * in that all of the bits in a multi-bit set must be set
190     * for this method to return {@code true}.</p>
191     *
192     * @param holder the int data containing the bits we're
193     *  interested in
194     * @return {@code true} if all of the bits are set,
195     *  else {@code false}
196     */
197    public boolean isAllSet(final int holder) {
198        return (holder & mask) == mask;
199    }
200
201    /**
202     * Returns whether the field is set or not.
203     *
204     * <p>This is most commonly used for a single-bit field, which is
205     * often used to represent a boolean value; the results of using
206     * it for a multi-bit field is to determine whether *any* of its
207     * bits are set.</p>
208     *
209     * @param holder the int data containing the bits we're interested
210     *  in
211     * @return {@code true} if any of the bits are set,
212     *  else {@code false}
213     */
214    public boolean isSet(final int holder) {
215        return (holder & mask) != 0;
216    }
217
218    /**
219     * Sets the bits.
220     *
221     * @param holder the int data containing the bits we're
222     *  interested in
223     * @return the value of holder with the specified bits set
224     *  to {@code 1}
225     */
226    public int set(final int holder) {
227        return holder | mask;
228    }
229
230    /**
231     * Sets a boolean BitField.
232     *
233     * @param holder the int data containing the bits we're
234     *  interested in
235     * @param flag indicating whether to set or clear the bits
236     * @return the value of holder with the specified bits set or
237     *         cleared
238     */
239    public int setBoolean(final int holder, final boolean flag) {
240        return flag ? set(holder) : clear(holder);
241    }
242
243    /**
244     * Sets the bits.
245     *
246     * @param holder the byte data containing the bits we're
247     *  interested in
248     *
249     * @return the value of holder with the specified bits set
250     *  to {@code 1}
251     */
252    public byte setByte(final byte holder) {
253        return (byte) set(holder);
254    }
255
256    /**
257     * Sets a boolean BitField.
258     *
259     * @param holder the byte data containing the bits we're
260     *  interested in
261     * @param flag indicating whether to set or clear the bits
262     * @return the value of holder with the specified bits set or
263     *  cleared
264     */
265    public byte setByteBoolean(final byte holder, final boolean flag) {
266        return flag ? setByte(holder) : clearByte(holder);
267    }
268
269    /**
270     * Sets the bits.
271     *
272     * @param holder the short data containing the bits we're
273     *  interested in
274     * @return the value of holder with the specified bits set
275     *  to {@code 1}
276     */
277    public short setShort(final short holder) {
278        return (short) set(holder);
279    }
280
281    /**
282     * Sets a boolean BitField.
283     *
284     * @param holder the short data containing the bits we're
285     *  interested in
286     * @param flag indicating whether to set or clear the bits
287     * @return the value of holder with the specified bits set or
288     *  cleared
289     */
290    public short setShortBoolean(final short holder, final boolean flag) {
291        return flag ? setShort(holder) : clearShort(holder);
292    }
293
294    /**
295     * Replaces the bits with new values.
296     *
297     * @see #getShortValue(short)
298     * @param holder the short data containing the bits we're
299     *  interested in
300     * @param value the new value for the specified bits
301     * @return the value of holder with the bits from the value
302     *  parameter replacing the old bits
303     */
304    public short setShortValue(final short holder, final short value) {
305        return (short) setValue(holder, value);
306    }
307
308    /**
309     * Replaces the bits with new values.
310     *
311     * @see #getValue(int)
312     * @param holder the int data containing the bits we're
313     *  interested in
314     * @param value the new value for the specified bits
315     * @return the value of holder with the bits from the value
316     *  parameter replacing the old bits
317     */
318    public int setValue(final int holder, final int value) {
319        return holder & ~mask | value << shiftCount & mask;
320    }
321
322}