Commit ⋅ snf4j/snf4j

Showing 1 of 2 files from the diff.

.../src/main/java/org/snf4j/core/ByteBufferArray.java changed.

Other files ignored by Codecov

.../test/java/org/snf4j/core/ByteBufferArrayTest.java has changed.

@@ -191,6 +191,25 @@

Loading

		return false;
	}

	/**
	 * Tells whether there are at least the {@code length} of bytes between the
	 * current position and the limit.
	 * 
	 * @return {@code true} if, and only if, there is at least the {@code length} of
	 *         bytes remaining in this buffer array wrapper
	 */
	public boolean hasRemaining(long length) {
		long remaining = 0;

		for (int i = index; i < end; ++i) {
			remaining += array[i].remaining();
			if (remaining >= length) {
				return true;			
			}
		}
		return false;
	}
	
	/**
	 * Returns the number of bytes between the current position and the limit.
	 * 

@@ -391,8 +410,8 @@

Loading

		return ByteBuffer.wrap(data).order(b.order());
	}

	private ByteBuffer buffer(int size, int[] index) {
		int i = index[0];
	private ByteBuffer buffer(int size, long[] index) {
		long i = index[0];

		if (i < 0) {
			throw new IndexOutOfBoundsException();

@@ -411,7 +430,7 @@

Loading

411	430
412	431		for (int j = 0; j < size; ++j) {
413	432		if (i < l) {
414		-	data[j] = buf.get(i++);
	433	+	data[j] = buf.get((int) i++);
415	434		} else if (++b < end) {
416	435		buf = array[b];
417	436		l = buf.limit();

@@ -563,6 +582,19 @@

Loading

	public byte get() {
		return buffer().get();
	}
	
	/**
	 * Relative get method that reads an unsigned value of the byte at this buffer
	 * array wrapper's current position, and then increments the position.
	 * 
	 * @return An unsigned value of the byte at the buffer array wrapper's current
	 *         position
	 * @throws BufferUnderflowException If the buffer array wrapper's current
	 *                                  position is not smaller than its limit
	 */
	public int getUnsigned() {
		return get() & 0xff;
	}

	/**
	 * Absolute get method that reads the byte at the given position.

@@ -572,11 +604,25 @@

Loading

	 * @throws IndexOutOfBoundsException If position is negative or not smaller than
	 *                                   the buffer array wrapper's limit
	 */
	public byte get(int position) {
		int[] indexArray = new int[] { position };
		return buffer(1, indexArray).get(indexArray[0]);
	public byte get(long position) {
		long[] indexArray = new long[] { position };
		return buffer(1, indexArray).get((int) indexArray[0]);
	}

	/**
	 * Absolute get method that reads an unsigned value of the byte at the given
	 * position.
	 * 
	 * @param position The position from which an unsigned value of the byte will be
	 *                 read
	 * @return An unsigned value of the byte at the given position
	 * @throws IndexOutOfBoundsException If position is negative or not smaller than
	 *                                   the buffer array wrapper's limit
	 */
	public int getUnsigned(long position) {
		return get(position) & 0xff;
	}
	
	/**
	 * Relative get method for reading a char value.
	 * <p>

@@ -609,9 +655,9 @@

Loading

	 * @throws IndexOutOfBoundsException If position is negative or not smaller than
	 *                                   the buffer array wrapper's limit, minus one
	 */
	public char getChar(int position) {
		int[] indexArray = new int[] { position };
		return buffer(2, indexArray).getChar(indexArray[0]);
	public char getChar(long position) {
		long[] indexArray = new long[] { position };
		return buffer(2, indexArray).getChar((int) indexArray[0]);
	}

	/**

@@ -632,6 +678,25 @@

Loading

		return buffer(2).getShort();
	}

	/**
	 * Relative get method for reading an unsigned short value.
	 * <p>
	 * It reads the next two bytes at this buffer array wrapper's current position,
	 * composing them into an unsigned short value according to the current byte
	 * order, and then increments the position by two.
	 * <p>
	 * NOTE: The current byte order is determined by the current byte order of the
	 * buffer pointed by the current position of this buffer array wrapper.
	 * 
	 * @return The unsigned short value at the buffer array wrapper's current
	 *         position
	 * @throws BufferUnderflowException If there are fewer than two bytes remaining
	 *                                  in this buffer array wrapper
	 */
	public int getUnsignedShort() {
		return getShort() & 0xffff;
	}
	
	/**
	 * Absolute get method for reading a short value.
	 * <p>

@@ -646,11 +711,29 @@

Loading

	 * @throws IndexOutOfBoundsException If position is negative or not smaller than
	 *                                   the buffer array wrapper's limit, minus one
	 */
	public short getShort(int position) {
		int[] indexArray = new int[] { position };
		return buffer(2, indexArray).getShort(indexArray[0]);
	public short getShort(long position) {
		long[] indexArray = new long[] { position };
		return buffer(2, indexArray).getShort((int) indexArray[0]);
	}

	/**
	 * Absolute get method for reading an unsigned short value.
	 * <p>
	 * It reads two bytes at the given position, composing them into an unsigned
	 * short value according to the current byte order.
	 * <p>
	 * NOTE: The current byte order is determined by the current byte order of the
	 * buffer pointed by the given position.
	 * 
	 * @param position The position from which the bytes will be read
	 * @return The unsigned short value at the given position
	 * @throws IndexOutOfBoundsException If position is negative or not smaller than
	 *                                   the buffer array wrapper's limit, minus one
	 */
	public int getUnsignedShort(long position) {
		return getShort(position) & 0xffff;
	}
	
	/**
	 * Relative get method for reading an int value.
	 * <p>

@@ -669,6 +752,24 @@

Loading

		return buffer(4).getInt();
	}

	/**
	 * Relative get method for reading an unsigned int value.
	 * <p>
	 * It reads the next four bytes at this buffer array wrapper's current position,
	 * composing them into an unsigned int value according to the current byte
	 * order, and then increments the position by four.
	 * <p>
	 * NOTE: The current byte order is determined by the current byte order of the
	 * buffer pointed by the current position of this buffer array wrapper.
	 * 
	 * @return The unsigned int value at the buffer array wrapper's current position
	 * @throws BufferUnderflowException If there are fewer than four bytes remaining
	 *                                  in this buffer array wrapper
	 */
	public long getUnsignedInt() {
		return getInt() & 0xffffffffL;
	}
	
	/**
	 * Absolute get method for reading an int value.
	 * <p>

@@ -684,11 +785,30 @@

Loading

	 *                                   the buffer array wrapper's limit, minus
	 *                                   three
	 */
	public int getInt(int position) {
		int[] indexArray = new int[] { position };
		return buffer(4, indexArray).getInt(indexArray[0]);
	public int getInt(long position) {
		long[] indexArray = new long[] { position };
		return buffer(4, indexArray).getInt((int) indexArray[0]);
	}

	/**
	 * Absolute get method for reading an unsigned int value.
	 * <p>
	 * It reads four bytes at the given position, composing them into an unsigned
	 * int value according to the current byte order.
	 * <p>
	 * NOTE: The current byte order is determined by the current byte order of the
	 * buffer pointed by the given position.
	 * 
	 * @param position The position from which the bytes will be read
	 * @return The unsigned int value at the given position
	 * @throws IndexOutOfBoundsException If position is negative or not smaller than
	 *                                   the buffer array wrapper's limit, minus
	 *                                   three
	 */
	public long getUnsignedInt(long position) {
		return getInt(position) & 0xffffffffL;
	}
	
	/**
	 * Relative get method for reading a long value.
	 * <p>

@@ -722,9 +842,9 @@

Loading

	 *                                   the buffer array wrapper's limit, minus
	 *                                   seven
	 */
	public long getLong(int position) {
		int[] indexArray = new int[] { position };
		return buffer(8, indexArray).getLong(indexArray[0]);
	public long getLong(long position) {
		long[] indexArray = new long[] { position };
		return buffer(8, indexArray).getLong((int) indexArray[0]);
	}

	/**

@@ -760,9 +880,9 @@

Loading

	 *                                   the buffer array wrapper's limit, minus
	 *                                   three
	 */
	public float getFloat(int position) {
		int[] indexArray = new int[] { position };
		return buffer(4, indexArray).getFloat(indexArray[0]);
	public float getFloat(long position) {
		long[] indexArray = new long[] { position };
		return buffer(4, indexArray).getFloat((int) indexArray[0]);
	}

	/**

@@ -798,9 +918,9 @@

Loading

	 *                                   the buffer array wrapper's limit, minus
	 *                                   seven
	 */
	public double getDouble(int position) {
		int[] indexArray = new int[] { position };
		return buffer(8, indexArray).getDouble(indexArray[0]);
	public double getDouble(long position) {
		long[] indexArray = new long[] { position };
		return buffer(8, indexArray).getDouble((int) indexArray[0]);
	}

	static class OneByteBufferArray extends ByteBufferArray {

@@ -829,6 +949,11 @@

Loading

			return buffer.hasRemaining();
		}

		@Override
		public boolean hasRemaining(long length) {
			return buffer.remaining() >= length;
		}
		
		@Override
		public long remaining() {
			return buffer.remaining();

@@ -904,8 +1029,8 @@

Loading

		}

		@Override
		public byte get(int position) {
			return buffer.get(position);
		public byte get(long position) {
			return buffer.get((int) position);
		}

		@Override

@@ -914,8 +1039,8 @@

Loading

		}

		@Override
		public char getChar(int position) {
			return buffer.getChar(position);
		public char getChar(long position) {
			return buffer.getChar((int) position);
		}

		@Override

@@ -924,8 +1049,8 @@

Loading

		}

		@Override
		public short getShort(int position) {
			return buffer.getShort(position);
		public short getShort(long position) {
			return buffer.getShort((int) position);
		}

		@Override

@@ -934,8 +1059,8 @@

Loading

		}

		@Override
		public int getInt(int position) {
			return buffer.getInt(position);
		public int getInt(long position) {
			return buffer.getInt((int) position);
		}

		@Override

@@ -944,8 +1069,8 @@

Loading

		}

		@Override
		public long getLong(int position) {
			return buffer.getLong(position);
		public long getLong(long position) {
			return buffer.getLong((int) position);
		}

		@Override

@@ -954,8 +1079,8 @@

Loading

		}

		@Override
		public float getFloat(int position) {
			return buffer.getFloat(position);
		public float getFloat(long position) {
			return buffer.getFloat((int) position);
		}

		@Override

@@ -964,8 +1089,8 @@

Loading

		}

		@Override
		public double getDouble(int position) {
			return buffer.getDouble(position);
		public double getDouble(long position) {
			return buffer.getDouble((int) position);
		}
		
	}

Files		•	•	•	Coverage
snf4j-core-log4j2/src/main/java/org/snf4j/core/logger/impl	60	58	1	1	96.66%
snf4j-core-slf4j/src/main/java/org/snf4j/core/logger/impl	60	58	1	1	96.66%
snf4j-core/src/main/java/org/snf4j/core	8,940	8,770	102	68	98.09%
snf4j-sctp/src/main/java/org/snf4j/core	1,129	1,113	10	6	98.58%
snf4j-websocket/src/main/java/org/snf4j/websocket	1,768	1,757	4	7	99.37%
Project Totals (242 files)	11,957	11,756	118	83	98.31%

Build #2869242965 -

View CI Build Download

coverage:
  range: "70...100"
  round: down
  precision: 2
  
  status:
    project:
      default:
        enabled: yes
        target: 94%
        threshold: 5%
        
    patch:
      default:
        enabled: yes
        target: 85%
        threshold: 5%
        
    changes: no
    

Read the docs

Interact now

The inner-most circle is the entire project, moving away from the center are folders then, finally, a single file. The size and color of each slice is representing the number of statements and the coverage, respectively.

SVG

The top section represents the entire project. Proceeding with folders and finally individual files. The size and color of each slice is representing the number of statements and the coverage, respectively.

SVG

Each block represents a single file in the project. The size and color of each block is represented by the number of statements and the coverage, respectively.

SVG

Learn more about the coverage sunburst graph

191	191		return false;
192	192		}
193	193
	194	+	/**
	195	+	* Tells whether there are at least the {@code length} of bytes between the
	196	+	* current position and the limit.
	197	+	*
	198	+	* @return {@code true} if, and only if, there is at least the {@code length} of
	199	+	* bytes remaining in this buffer array wrapper
	200	+	*/
	201	+	public boolean hasRemaining(long length) {
	202	+	long remaining = 0;
	203	+
	204	+	for (int i = index; i < end; ++i) {
	205	+	remaining += array[i].remaining();
	206	+	if (remaining >= length) {
	207	+	return true;
	208	+	}
	209	+	}
	210	+	return false;
	211	+	}
	212	+
194	213		/**
195	214		* Returns the number of bytes between the current position and the limit.
196	215		*

563	582		public byte get() {
564	583		return buffer().get();
565	584		}
	585	+
	586	+	/**
	587	+	* Relative get method that reads an unsigned value of the byte at this buffer
	588	+	* array wrapper's current position, and then increments the position.
	589	+	*
	590	+	* @return An unsigned value of the byte at the buffer array wrapper's current
	591	+	* position
	592	+	* @throws BufferUnderflowException If the buffer array wrapper's current
	593	+	* position is not smaller than its limit
	594	+	*/
	595	+	public int getUnsigned() {
	596	+	return get() & 0xff;
	597	+	}
566	598
567	599		/**
568	600		* Absolute get method that reads the byte at the given position.

572	604		* @throws IndexOutOfBoundsException If position is negative or not smaller than
573	605		* the buffer array wrapper's limit
574	606		*/
575		-	public byte get(int position) {
576		-	int[] indexArray = new int[] { position };
577		-	return buffer(1, indexArray).get(indexArray[0]);
	607	+	public byte get(long position) {
	608	+	long[] indexArray = new long[] { position };
	609	+	return buffer(1, indexArray).get((int) indexArray[0]);
578	610		}
579	611
	612	+	/**
	613	+	* Absolute get method that reads an unsigned value of the byte at the given
	614	+	* position.
	615	+	*
	616	+	* @param position The position from which an unsigned value of the byte will be
	617	+	* read
	618	+	* @return An unsigned value of the byte at the given position
	619	+	* @throws IndexOutOfBoundsException If position is negative or not smaller than
	620	+	* the buffer array wrapper's limit
	621	+	*/
	622	+	public int getUnsigned(long position) {
	623	+	return get(position) & 0xff;
	624	+	}
	625	+
580	626		/**
581	627		* Relative get method for reading a char value.
582	628		* <p>

609	655		* @throws IndexOutOfBoundsException If position is negative or not smaller than
610	656		* the buffer array wrapper's limit, minus one
611	657		*/
612		-	public char getChar(int position) {
613		-	int[] indexArray = new int[] { position };
614		-	return buffer(2, indexArray).getChar(indexArray[0]);
	658	+	public char getChar(long position) {
	659	+	long[] indexArray = new long[] { position };
	660	+	return buffer(2, indexArray).getChar((int) indexArray[0]);
615	661		}
616	662
617	663		/**

632	678		return buffer(2).getShort();
633	679		}
634	680
	681	+	/**
	682	+	* Relative get method for reading an unsigned short value.
	683	+	* <p>
	684	+	* It reads the next two bytes at this buffer array wrapper's current position,
	685	+	* composing them into an unsigned short value according to the current byte
	686	+	* order, and then increments the position by two.
	687	+	* <p>
	688	+	* NOTE: The current byte order is determined by the current byte order of the
	689	+	* buffer pointed by the current position of this buffer array wrapper.
	690	+	*
	691	+	* @return The unsigned short value at the buffer array wrapper's current
	692	+	* position
	693	+	* @throws BufferUnderflowException If there are fewer than two bytes remaining
	694	+	* in this buffer array wrapper
	695	+	*/
	696	+	public int getUnsignedShort() {
	697	+	return getShort() & 0xffff;
	698	+	}
	699	+
635	700		/**
636	701		* Absolute get method for reading a short value.
637	702		* <p>

391	410		return ByteBuffer.wrap(data).order(b.order());
392	411		}
393	412
394		-	private ByteBuffer buffer(int size, int[] index) {
395		-	int i = index[0];
	413	+	private ByteBuffer buffer(int size, long[] index) {
	414	+	long i = index[0];
396	415
397	416		if (i < 0) {
398	417		throw new IndexOutOfBoundsException();

646	711		* @throws IndexOutOfBoundsException If position is negative or not smaller than
647	712		* the buffer array wrapper's limit, minus one
648	713		*/
649		-	public short getShort(int position) {
650		-	int[] indexArray = new int[] { position };
651		-	return buffer(2, indexArray).getShort(indexArray[0]);
	714	+	public short getShort(long position) {
	715	+	long[] indexArray = new long[] { position };
	716	+	return buffer(2, indexArray).getShort((int) indexArray[0]);
652	717		}
653	718
	719	+	/**
	720	+	* Absolute get method for reading an unsigned short value.
	721	+	* <p>
	722	+	* It reads two bytes at the given position, composing them into an unsigned
	723	+	* short value according to the current byte order.
	724	+	* <p>
	725	+	* NOTE: The current byte order is determined by the current byte order of the
	726	+	* buffer pointed by the given position.
	727	+	*
	728	+	* @param position The position from which the bytes will be read
	729	+	* @return The unsigned short value at the given position
	730	+	* @throws IndexOutOfBoundsException If position is negative or not smaller than
	731	+	* the buffer array wrapper's limit, minus one
	732	+	*/
	733	+	public int getUnsignedShort(long position) {
	734	+	return getShort(position) & 0xffff;
	735	+	}
	736	+
654	737		/**
655	738		* Relative get method for reading an int value.
656	739		* <p>

669	752		return buffer(4).getInt();
670	753		}
671	754
	755	+	/**
	756	+	* Relative get method for reading an unsigned int value.
	757	+	* <p>
	758	+	* It reads the next four bytes at this buffer array wrapper's current position,
	759	+	* composing them into an unsigned int value according to the current byte
	760	+	* order, and then increments the position by four.
	761	+	* <p>
	762	+	* NOTE: The current byte order is determined by the current byte order of the
	763	+	* buffer pointed by the current position of this buffer array wrapper.
	764	+	*
	765	+	* @return The unsigned int value at the buffer array wrapper's current position
	766	+	* @throws BufferUnderflowException If there are fewer than four bytes remaining
	767	+	* in this buffer array wrapper
	768	+	*/
	769	+	public long getUnsignedInt() {
	770	+	return getInt() & 0xffffffffL;
	771	+	}
	772	+
672	773		/**
673	774		* Absolute get method for reading an int value.
674	775		* <p>

684	785		* the buffer array wrapper's limit, minus
685	786		* three
686	787		*/
687		-	public int getInt(int position) {
688		-	int[] indexArray = new int[] { position };
689		-	return buffer(4, indexArray).getInt(indexArray[0]);
	788	+	public int getInt(long position) {
	789	+	long[] indexArray = new long[] { position };
	790	+	return buffer(4, indexArray).getInt((int) indexArray[0]);
690	791		}
691	792
	793	+	/**
	794	+	* Absolute get method for reading an unsigned int value.
	795	+	* <p>
	796	+	* It reads four bytes at the given position, composing them into an unsigned
	797	+	* int value according to the current byte order.
	798	+	* <p>
	799	+	* NOTE: The current byte order is determined by the current byte order of the
	800	+	* buffer pointed by the given position.
	801	+	*
	802	+	* @param position The position from which the bytes will be read
	803	+	* @return The unsigned int value at the given position
	804	+	* @throws IndexOutOfBoundsException If position is negative or not smaller than
	805	+	* the buffer array wrapper's limit, minus
	806	+	* three
	807	+	*/
	808	+	public long getUnsignedInt(long position) {
	809	+	return getInt(position) & 0xffffffffL;
	810	+	}
	811	+
692	812		/**
693	813		* Relative get method for reading a long value.
694	814		* <p>

722	842		* the buffer array wrapper's limit, minus
723	843		* seven
724	844		*/
725		-	public long getLong(int position) {
726		-	int[] indexArray = new int[] { position };
727		-	return buffer(8, indexArray).getLong(indexArray[0]);
	845	+	public long getLong(long position) {
	846	+	long[] indexArray = new long[] { position };
	847	+	return buffer(8, indexArray).getLong((int) indexArray[0]);
728	848		}
729	849
730	850		/**

760	880		* the buffer array wrapper's limit, minus
761	881		* three
762	882		*/
763		-	public float getFloat(int position) {
764		-	int[] indexArray = new int[] { position };
765		-	return buffer(4, indexArray).getFloat(indexArray[0]);
	883	+	public float getFloat(long position) {
	884	+	long[] indexArray = new long[] { position };
	885	+	return buffer(4, indexArray).getFloat((int) indexArray[0]);
766	886		}
767	887
768	888		/**

798	918		* the buffer array wrapper's limit, minus
799	919		* seven
800	920		*/
801		-	public double getDouble(int position) {
802		-	int[] indexArray = new int[] { position };
803		-	return buffer(8, indexArray).getDouble(indexArray[0]);
	921	+	public double getDouble(long position) {
	922	+	long[] indexArray = new long[] { position };
	923	+	return buffer(8, indexArray).getDouble((int) indexArray[0]);
804	924		}
805	925
806	926		static class OneByteBufferArray extends ByteBufferArray {

829	949		return buffer.hasRemaining();
830	950		}
831	951
	952	+	@Override
	953	+	public boolean hasRemaining(long length) {
	954	+	return buffer.remaining() >= length;
	955	+	}
	956	+
832	957		@Override
833	958		public long remaining() {
834	959		return buffer.remaining();

904	1029		}
905	1030
906	1031		@Override
907		-	public byte get(int position) {
908		-	return buffer.get(position);
	1032	+	public byte get(long position) {
	1033	+	return buffer.get((int) position);
909	1034		}
910	1035
911	1036		@Override

914	1039		}
915	1040
916	1041		@Override
917		-	public char getChar(int position) {
918		-	return buffer.getChar(position);
	1042	+	public char getChar(long position) {
	1043	+	return buffer.getChar((int) position);
919	1044		}
920	1045
921	1046		@Override

934	1059		}
935	1060
936	1061		@Override
937		-	public int getInt(int position) {
938		-	return buffer.getInt(position);
	1062	+	public int getInt(long position) {
	1063	+	return buffer.getInt((int) position);
939	1064		}
940	1065
941	1066		@Override

964	1089		}
965	1090
966	1091		@Override
967		-	public double getDouble(int position) {
968		-	return buffer.getDouble(position);
	1092	+	public double getDouble(long position) {
	1093	+	return buffer.getDouble((int) position);
969	1094		}
970	1095
971	1096		}

Navigation	Overlay
`t` Navigate files	`h` Toggle hits
`y` Change url to tip of branch	`m` Toggle misses
`b / v` Jump to prev/next hit line	`p` Toggle partial
`z / x` Jump to prev/next missed or partial line	`1..9` Toggle flags
`shift + o` Open current page in GitHub	`a` Toggle all on
`/ or ?` Show keyboard shortcuts dialog	`c` Toggle context lines or commits

924	1049		}
925	1050
926	1051		@Override
927		-	public short getShort(int position) {
928		-	return buffer.getShort(position);
	1052	+	public short getShort(long position) {
	1053	+	return buffer.getShort((int) position);
929	1054		}
930	1055
931	1056		@Override

944	1069		}
945	1070
946	1071		@Override
947		-	public long getLong(int position) {
948		-	return buffer.getLong(position);
	1072	+	public long getLong(long position) {
	1073	+	return buffer.getLong((int) position);
949	1074		}
950	1075
951	1076		@Override

954	1079		}
955	1080
956	1081		@Override
957		-	public float getFloat(int position) {
958		-	return buffer.getFloat(position);
	1082	+	public float getFloat(long position) {
	1083	+	return buffer.getFloat((int) position);
959	1084		}
960	1085
961	1086		@Override

1	coverage:
2	range: "70...100"
3	round: down
4	precision: 2
5
6	status:
7	project:
8	default:
9	enabled: yes
10	target: 94%
11	threshold: 5%
12
13	patch:
14	default:
15	enabled: yes
16	target: 85%
17	threshold: 5%
18
19	changes: no
20

Updating our web app