1143

pending completion

Build # 1143

Build Type

push

travis-ci

Committed by

lizhanhui

Commit Message

<a href="https://github.com/apache/rocketmq/commit/<a class=hub.com/apache/rocketmq/commit/130c85c3cdc8c0a72552b1b65e711213493a8071">130c85c3c<a href="https://github.com/apache/rocketmq/commit/130c85c3cdc8c0a72552b1b65e711213493a8071">&quot;&gt;Revert &amp;quot;Fix Concurrent issue of StoreStatsService&quot;

This reverts commit </a><a class="double-link" href="https://github.com/apache/rocketmq/commit/<a class="double-link" href="https://github.com/apache/rocketmq/commit/fdc6e87cbe7adb8bc8f5991e06392eee73bc5151">fdc6e87cb</a>">fdc6e87cb</a><a href="https://github.com/apache/rocketmq/commit/130c85c3cdc8c0a72552b1b65e711213493a8071">.

Run Details

4 of 4 new or added lines in 1 file covered. (100.0%)

10792 of 27038 relevant lines covered (39.91%)

0.4 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

70.09

/filter/src/main/java/org/apache/rocketmq/filter/util/BitsArray.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.rocketmq.filter.util;

/**
 * Wrapper of bytes array, in order to operate single bit easily.
 */
public class BitsArray implements Cloneable {

    private byte[] bytes;
    private int bitLength;

    public static BitsArray create(int bitLength) {
        return new BitsArray(bitLength);
    }

    public static BitsArray create(byte[] bytes, int bitLength) {
        return new BitsArray(bytes, bitLength);
    }

    public static BitsArray create(byte[] bytes) {
        return new BitsArray(bytes);
    }

    private BitsArray(int bitLength) {
        this.bitLength = bitLength;
        // init bytes
        int temp = bitLength / Byte.SIZE;
        if (bitLength % Byte.SIZE > 0) {
            temp++;
        }
        bytes = new byte[temp];
        for (int i = 0; i < bytes.length; i++) {
            bytes[i] = (byte) 0x00;
        }
    }

    private BitsArray(byte[] bytes, int bitLength) {
        if (bytes == null || bytes.length < 1) {
            throw new IllegalArgumentException("Bytes is empty!");
        }

        if (bitLength < 1) {
            throw new IllegalArgumentException("Bit is less than 1.");
        }

        if (bitLength < bytes.length * Byte.SIZE) {
            throw new IllegalArgumentException("BitLength is less than bytes.length() * " + Byte.SIZE);
        }

        this.bytes = new byte[bytes.length];
        System.arraycopy(bytes, 0, this.bytes, 0, this.bytes.length);
        this.bitLength = bitLength;
    }

    private BitsArray(byte[] bytes) {
        if (bytes == null || bytes.length < 1) {
            throw new IllegalArgumentException("Bytes is empty!");
        }

        this.bitLength = bytes.length * Byte.SIZE;
        this.bytes = new byte[bytes.length];
        System.arraycopy(bytes, 0, this.bytes, 0, this.bytes.length);
    }

    public int bitLength() {
        return this.bitLength;
    }

    public int byteLength() {
        return this.bytes.length;
    }

    public byte[] bytes() {
        return this.bytes;
    }

    public void xor(final BitsArray other) {
        checkInitialized(this);
        checkInitialized(other);

        int minByteLength = Math.min(this.byteLength(), other.byteLength());

        for (int i = 0; i < minByteLength; i++) {
            this.bytes[i] = (byte) (this.bytes[i] ^ other.getByte(i));
        }
    }

    public void xor(int bitPos, boolean set) {
        checkBitPosition(bitPos, this);

        boolean value = getBit(bitPos);
        if (value ^ set) {
            setBit(bitPos, true);
        } else {
            setBit(bitPos, false);
        }
    }

    public void or(final BitsArray other) {
        checkInitialized(this);
        checkInitialized(other);

        int minByteLength = Math.min(this.byteLength(), other.byteLength());

        for (int i = 0; i < minByteLength; i++) {
            this.bytes[i] = (byte) (this.bytes[i] | other.getByte(i));
        }
    }

    public void or(int bitPos, boolean set) {
        checkBitPosition(bitPos, this);

        if (set) {
            setBit(bitPos, true);
        }
    }

    public void and(final BitsArray other) {
        checkInitialized(this);
        checkInitialized(other);

        int minByteLength = Math.min(this.byteLength(), other.byteLength());

        for (int i = 0; i < minByteLength; i++) {
            this.bytes[i] = (byte) (this.bytes[i] & other.getByte(i));
        }
    }

    public void and(int bitPos, boolean set) {
        checkBitPosition(bitPos, this);

        if (!set) {
            setBit(bitPos, false);
        }
    }

    public void not(int bitPos) {
        checkBitPosition(bitPos, this);

        setBit(bitPos, !getBit(bitPos));
    }

    public void setBit(int bitPos, boolean set) {
        checkBitPosition(bitPos, this);
        int sub = subscript(bitPos);
        int pos = position(bitPos);
        if (set) {
            this.bytes[sub] = (byte) (this.bytes[sub] | pos);
        } else {
            this.bytes[sub] = (byte) (this.bytes[sub] & ~pos);
        }
    }

    public void setByte(int bytePos, byte set) {
        checkBytePosition(bytePos, this);

        this.bytes[bytePos] = set;
    }

    public boolean getBit(int bitPos) {
        checkBitPosition(bitPos, this);

        return (this.bytes[subscript(bitPos)] & position(bitPos)) != 0;
    }

    public byte getByte(int bytePos) {
        checkBytePosition(bytePos, this);

        return this.bytes[bytePos];
    }

    protected int subscript(int bitPos) {
        return bitPos / Byte.SIZE;
    }

    protected int position(int bitPos) {
        return 1 << bitPos % Byte.SIZE;
    }

    protected void checkBytePosition(int bytePos, BitsArray bitsArray) {
        checkInitialized(bitsArray);
        if (bytePos > bitsArray.byteLength()) {
            throw new IllegalArgumentException("BytePos is greater than " + bytes.length);
        }
        if (bytePos < 0) {
            throw new IllegalArgumentException("BytePos is less than 0");
        }
    }

    protected void checkBitPosition(int bitPos, BitsArray bitsArray) {
        checkInitialized(bitsArray);
        if (bitPos > bitsArray.bitLength()) {
            throw new IllegalArgumentException("BitPos is greater than " + bitLength);
        }
        if (bitPos < 0) {
            throw new IllegalArgumentException("BitPos is less than 0");
        }
    }

    protected void checkInitialized(BitsArray bitsArray) {
        if (bitsArray.bytes() == null) {
            throw new RuntimeException("Not initialized!");
        }
    }

    public BitsArray clone() {
        byte[] clone = new byte[this.byteLength()];

        System.arraycopy(this.bytes, 0, clone, 0, this.byteLength());

        return create(clone, bitLength());
    }

    @Override
    public String toString() {
        if (this.bytes == null) {
            return "null";
        }
        StringBuilder stringBuilder = new StringBuilder(this.bytes.length * Byte.SIZE);
        for (int i = this.bytes.length - 1; i >= 0; i--) {

            int j = Byte.SIZE - 1;
            if (i == this.bytes.length - 1 && this.bitLength % Byte.SIZE > 0) {
                // not full byte
                j = this.bitLength % Byte.SIZE;
            }

            for (; j >= 0; j--) {

                byte mask = (byte) (1 << j);
                if ((this.bytes[i] & mask) == mask) {
                    stringBuilder.append("1");
                } else {
                    stringBuilder.append("0");
                }
            }
            if (i % 8 == 0) {
                stringBuilder.append("\n");
            }
        }

        return stringBuilder.toString();
    }
}

1	/*
2	* Licensed to the Apache Software Foundation (ASF) under one or more
3	* contributor license agreements. See the NOTICE file distributed with
4	* this work for additional information regarding copyright ownership.
5	* The ASF licenses this file to You under the Apache License, Version 2.0
6	* (the "License"); you may not use this file except in compliance with
7	* the License. You may obtain a copy of the License at
8	*
9	* http://www.apache.org/licenses/LICENSE-2.0
10	*
11	* Unless required by applicable law or agreed to in writing, software
12	* distributed under the License is distributed on an "AS IS" BASIS,
13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	* See the License for the specific language governing permissions and
15	* limitations under the License.
16	*/
17
18	package org.apache.rocketmq.filter.util;
19
20	/**
21	* Wrapper of bytes array, in order to operate single bit easily.
22	*/
23	public class BitsArray implements Cloneable {
24
25	private byte[] bytes;
26	private int bitLength;
27
28	public static BitsArray create(int bitLength) {
29	return new BitsArray(bitLength);	1✔
30	}
31
32	public static BitsArray create(byte[] bytes, int bitLength) {
33	return new BitsArray(bytes, bitLength);	1✔
34	}
35
36	public static BitsArray create(byte[] bytes) {
37	return new BitsArray(bytes);	1✔
38	}
39
40	private BitsArray(int bitLength) {	1✔
41	this.bitLength = bitLength;	1✔
42	// init bytes
43	int temp = bitLength / Byte.SIZE;	1✔
44	if (bitLength % Byte.SIZE > 0) {	1✔
45	temp++;	1✔
46	}
47	bytes = new byte[temp];	1✔
48	for (int i = 0; i < bytes.length; i++) {	1✔
49	bytes[i] = (byte) 0x00;	1✔
50	}
51	}	1✔
52
53	private BitsArray(byte[] bytes, int bitLength) {	1✔
54	if (bytes == null \|\| bytes.length < 1) {	1✔
55	throw new IllegalArgumentException("Bytes is empty!");	×
56	}
57
58	if (bitLength < 1) {	1✔
59	throw new IllegalArgumentException("Bit is less than 1.");	×
60	}
61
62	if (bitLength < bytes.length * Byte.SIZE) {	1✔
63	throw new IllegalArgumentException("BitLength is less than bytes.length() * " + Byte.SIZE);	×
64	}
65
66	this.bytes = new byte[bytes.length];	1✔
67	System.arraycopy(bytes, 0, this.bytes, 0, this.bytes.length);	1✔
68	this.bitLength = bitLength;	1✔
69	}	1✔
70
71	private BitsArray(byte[] bytes) {	1✔
72	if (bytes == null \|\| bytes.length < 1) {	1✔
73	throw new IllegalArgumentException("Bytes is empty!");	×
74	}
75
76	this.bitLength = bytes.length * Byte.SIZE;	1✔
77	this.bytes = new byte[bytes.length];	1✔
78	System.arraycopy(bytes, 0, this.bytes, 0, this.bytes.length);	1✔
79	}	1✔
80
81	public int bitLength() {
82	return this.bitLength;	1✔
83	}
84
85	public int byteLength() {
86	return this.bytes.length;	1✔
87	}
88
89	public byte[] bytes() {
90	return this.bytes;	1✔
91	}
92
93	public void xor(final BitsArray other) {
94	checkInitialized(this);	1✔
95	checkInitialized(other);	1✔
96
97	int minByteLength = Math.min(this.byteLength(), other.byteLength());	1✔
98
99	for (int i = 0; i < minByteLength; i++) {	1✔
100	this.bytes[i] = (byte) (this.bytes[i] ^ other.getByte(i));	1✔
101	}
102	}	1✔
103
104	public void xor(int bitPos, boolean set) {
105	checkBitPosition(bitPos, this);	1✔
106
107	boolean value = getBit(bitPos);	1✔
108	if (value ^ set) {	1✔
109	setBit(bitPos, true);	1✔
110	} else {
111	setBit(bitPos, false);	×
112	}
113	}	1✔
114
115	public void or(final BitsArray other) {
116	checkInitialized(this);	1✔
117	checkInitialized(other);	1✔
118
119	int minByteLength = Math.min(this.byteLength(), other.byteLength());	1✔
120
121	for (int i = 0; i < minByteLength; i++) {	1✔
122	this.bytes[i] = (byte) (this.bytes[i] \| other.getByte(i));	1✔
123	}
124	}	1✔
125
126	public void or(int bitPos, boolean set) {
127	checkBitPosition(bitPos, this);	×
128
129	if (set) {	×
130	setBit(bitPos, true);	×
131	}
132	}	×
133
134	public void and(final BitsArray other) {
135	checkInitialized(this);	×
136	checkInitialized(other);	×
137
138	int minByteLength = Math.min(this.byteLength(), other.byteLength());	×
139
140	for (int i = 0; i < minByteLength; i++) {	×
141	this.bytes[i] = (byte) (this.bytes[i] & other.getByte(i));	×
142	}
143	}	×
144
145	public void and(int bitPos, boolean set) {
146	checkBitPosition(bitPos, this);	1✔
147
148	if (!set) {	1✔
149	setBit(bitPos, false);	1✔
150	}
151	}	1✔
152
153	public void not(int bitPos) {
154	checkBitPosition(bitPos, this);	1✔
155
156	setBit(bitPos, !getBit(bitPos));	1✔
157	}	1✔
158
159	public void setBit(int bitPos, boolean set) {
160	checkBitPosition(bitPos, this);	1✔
161	int sub = subscript(bitPos);	1✔
162	int pos = position(bitPos);	1✔
163	if (set) {	1✔
164	this.bytes[sub] = (byte) (this.bytes[sub] \| pos);	1✔
165	} else {
166	this.bytes[sub] = (byte) (this.bytes[sub] & ~pos);	1✔
167	}
168	}	1✔
169
170	public void setByte(int bytePos, byte set) {
171	checkBytePosition(bytePos, this);	1✔
172
173	this.bytes[bytePos] = set;	1✔
174	}	1✔
175
176	public boolean getBit(int bitPos) {
177	checkBitPosition(bitPos, this);	1✔
178
179	return (this.bytes[subscript(bitPos)] & position(bitPos)) != 0;	1✔
180	}
181
182	public byte getByte(int bytePos) {
183	checkBytePosition(bytePos, this);	1✔
184
185	return this.bytes[bytePos];	1✔
186	}
187
188	protected int subscript(int bitPos) {
189	return bitPos / Byte.SIZE;	1✔
190	}
191
192	protected int position(int bitPos) {
193	return 1 << bitPos % Byte.SIZE;	1✔
194	}
195
196	protected void checkBytePosition(int bytePos, BitsArray bitsArray) {
197	checkInitialized(bitsArray);	1✔
198	if (bytePos > bitsArray.byteLength()) {	1✔
199	throw new IllegalArgumentException("BytePos is greater than " + bytes.length);	×
200	}
201	if (bytePos < 0) {	1✔
202	throw new IllegalArgumentException("BytePos is less than 0");	×
203	}
204	}	1✔
205
206	protected void checkBitPosition(int bitPos, BitsArray bitsArray) {
207	checkInitialized(bitsArray);	1✔
208	if (bitPos > bitsArray.bitLength()) {	1✔
209	throw new IllegalArgumentException("BitPos is greater than " + bitLength);	×
210	}
211	if (bitPos < 0) {	1✔
212	throw new IllegalArgumentException("BitPos is less than 0");	×
213	}
214	}	1✔
215
216	protected void checkInitialized(BitsArray bitsArray) {
217	if (bitsArray.bytes() == null) {	1✔
218	throw new RuntimeException("Not initialized!");	×
219	}
220	}	1✔
221
222	public BitsArray clone() {
223	byte[] clone = new byte[this.byteLength()];	1✔
224
225	System.arraycopy(this.bytes, 0, clone, 0, this.byteLength());	1✔
226
227	return create(clone, bitLength());	1✔
228	}
229
230	@Override
231	public String toString() {
232	if (this.bytes == null) {	×
233	return "null";	×
234	}
235	StringBuilder stringBuilder = new StringBuilder(this.bytes.length * Byte.SIZE);	×
236	for (int i = this.bytes.length - 1; i >= 0; i--) {	×
237
238	int j = Byte.SIZE - 1;	×
239	if (i == this.bytes.length - 1 && this.bitLength % Byte.SIZE > 0) {	×
240	// not full byte
241	j = this.bitLength % Byte.SIZE;	×
242	}
243
244	for (; j >= 0; j--) {	×
245
246	byte mask = (byte) (1 << j);	×
247	if ((this.bytes[i] & mask) == mask) {	×
248	stringBuilder.append("1");	×
249	} else {
250	stringBuilder.append("0");	×
251	}
252	}
253	if (i % 8 == 0) {	×
254	stringBuilder.append("\n");	×
255	}
256	}
257
258	return stringBuilder.toString();	×
259	}
260	}

apache / rocketmq / 1143

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous