Coverage Report

Coverage Report - org.jscsi.target.util.FastByteArrayProvider

Classes in this File

0/19

0/8

 package org.jscsi.target.util;
 
 /**
  * Instances of this class can serve as a source for byte arrays of specified lengths. Up to {@link #capacity} arrays of
  * different lengths can be stored, quickly retrievable with the {@link #getArray(int)} method. Frequently requested
  * arrays will be returned faster, less frequently used arrays might have to be initialized first and are more likely to
  * be removed.
  * 
  * @author Andreas Ergenzinger
  */
 public final class FastByteArrayProvider {
 
     /**
      * Contains the stored byte arrays.
      */
     final byte[][] arrays;
 
     /**
      * The maximum number of array that can be stored.
      */
     final int capacity;
 
     /**
      * The total number of stored arrays.
      */
     int size = 0;
 
     /**
      * A temporary byte array reference used by {@link #getArray(int)};
      */
     byte[] tmp;
 
     /**
      * The constructor.
      * 
      * @param capacity the {@link #capacity} of the created object.
      */
     public FastByteArrayProvider (final int capacity) {
         this.capacity = capacity;
         arrays = new byte[capacity][];
     }
 
     /**
      * Returns a byte array of the specified length.
      * <p>
      * Note that the returned array may have been used before and therefore the array's values are not guaranteed to be
      * <code>0</code>.
      * <p>
      * The method consecutively checks {@link #arrays} for an array of the correct length. If such an array exists, it
      * will be moved to one index position closer to the front of the array (if possible), speeding up future retrievals
      * of the same array.
      * 
      * @param length the length of the returned array
      * @return a byte array of the specified length
      */
     public byte[] getArray (final int length) {
         for (int i = 0; i < size; ++i) {
             if (length == arrays[i].length) {
                 // swap (if not already at the front) and return
                 if (i > 0) {
                     tmp = arrays[i];
                     arrays[i] = arrays[i - 1];
                     arrays[i - 1] = tmp;
                     return tmp;
                 }
                 // no swapping, so element was and still is at the front of the
                 // list
                 return arrays[0];
             }
         }
         // requested array does not exist, add to tail of queue,
         tmp = new byte[length];
         if (size == capacity) --size;// replace last element
         arrays[size] = tmp;
         ++size;
         return tmp;
     }
 
     /**
      * Returns all stored byte arrays.
      * <p>
      * This method's primary purpose is to enable testing of byte array storing and reordering.
      * 
      * @return {@link #arrays}.
      */
     public byte[][] getAll () {
         return arrays;
     }
 }

1		package org.jscsi.target.util;
2
3		/**
4		* Instances of this class can serve as a source for byte arrays of specified lengths. Up to {@link #capacity} arrays of
5		* different lengths can be stored, quickly retrievable with the {@link #getArray(int)} method. Frequently requested
6		* arrays will be returned faster, less frequently used arrays might have to be initialized first and are more likely to
7		* be removed.
8		*
9		* @author Andreas Ergenzinger
10		*/
11		public final class FastByteArrayProvider {
12
13		/**
14		* Contains the stored byte arrays.
15		*/
16		final byte[][] arrays;
17
18		/**
19		* The maximum number of array that can be stored.
20		*/
21		final int capacity;
22
23		/**
24		* The total number of stored arrays.
25		*/
26	0	int size = 0;
27
28		/**
29		* A temporary byte array reference used by {@link #getArray(int)};
30		*/
31		byte[] tmp;
32
33		/**
34		* The constructor.
35		*
36		* @param capacity the {@link #capacity} of the created object.
37		*/
38	0	public FastByteArrayProvider (final int capacity) {
39	0	this.capacity = capacity;
40	0	arrays = new byte[capacity][];
41	0	}
42
43		/**
44		* Returns a byte array of the specified length.
45		* <p>
46		* Note that the returned array may have been used before and therefore the array's values are not guaranteed to be
47		* <code>0</code>.
48		* <p>
49		* The method consecutively checks {@link #arrays} for an array of the correct length. If such an array exists, it
50		* will be moved to one index position closer to the front of the array (if possible), speeding up future retrievals
51		* of the same array.
52		*
53		* @param length the length of the returned array
54		* @return a byte array of the specified length
55		*/
56		public byte[] getArray (final int length) {
57	0	for (int i = 0; i < size; ++i) {
58	0	if (length == arrays[i].length) {
59		// swap (if not already at the front) and return
60	0	if (i > 0) {
61	0	tmp = arrays[i];
62	0	arrays[i] = arrays[i - 1];
63	0	arrays[i - 1] = tmp;
64	0	return tmp;
65		}
66		// no swapping, so element was and still is at the front of the
67		// list
68	0	return arrays[0];
69		}
70		}
71		// requested array does not exist, add to tail of queue,
72	0	tmp = new byte[length];
73	0	if (size == capacity) --size;// replace last element
74	0	arrays[size] = tmp;
75	0	++size;
76	0	return tmp;
77		}
78
79		/**
80		* Returns all stored byte arrays.
81		* <p>
82		* This method's primary purpose is to enable testing of byte array storing and reordering.
83		*
84		* @return {@link #arrays}.
85		*/
86		public byte[][] getAll () {
87	0	return arrays;
88		}
89		}