/** * Copies the contents of the stack into a native array. Note that this will NOT * pop them out of the stack. The front of the list will be the top of the stack. * * @return an <code>byte[]</code> value */ public byte[] toArray() { byte[] retval = _list.toArray(); reverse( retval, 0, size() ); return retval; }
/** * Reverse the order of the elements in the range of the list. * * @param dest the array of data * @param from the inclusive index at which to start reversing * @param to the exclusive index at which to stop reversing */ private void reverse( byte[] dest, int from, int to ) { if ( from == to ) { return; // nothing to do } if ( from > to ) { throw new IllegalArgumentException( "from cannot be greater than to" ); } for ( int i = from, j = to - 1; i < j; i++, j-- ) { swap( dest, i, j ); } }
/** * Returns a String representation of the list, top to bottom. * * @return a <code>String</code> value */ public String toString() { final StringBuilder buf = new StringBuilder( "{" ); for ( int i = _list.size() - 1; i > 0; i-- ) { buf.append( _list.get( i ) ); buf.append( ", " ); } if ( size() > 0 ) { buf.append( _list.get( 0 ) ); } buf.append( "}" ); return buf.toString(); }
/** * Returns a String representation of the list, top to bottom. * * @return a <code>String</code> value */ public String toString() { final StringBuilder buf = new StringBuilder( "{" ); for ( int i = _list.size() - 1; i > 0; i-- ) { buf.append( _list.get( i ) ); buf.append( ", " ); } if ( size() > 0 ) { buf.append( _list.get( 0 ) ); } buf.append( "}" ); return buf.toString(); }
/** * Copies a slice of the list into a native array. Note that this will NOT * pop them out of the stack. The front of the list will be the top * of the stack. * <p> * If the native array is smaller than the stack depth, * the native array will be filled with the elements from the top * of the array until it is full and exclude the remainder. * * @param dest the array to copy into. */ public void toArray( byte[] dest ) { int size = size(); int start = size - dest.length; if ( start < 0 ) { start = 0; } int length = Math.min( size, dest.length ); _list.toArray( dest, start, length ); reverse( dest, 0, length ); if ( dest.length > size ) { dest[size] = _list.getNoEntryValue(); } }
/** * Reverse the order of the elements in the range of the list. * * @param dest the array of data * @param from the inclusive index at which to start reversing * @param to the exclusive index at which to stop reversing */ private void reverse( byte[] dest, int from, int to ) { if ( from == to ) { return; // nothing to do } if ( from > to ) { throw new IllegalArgumentException( "from cannot be greater than to" ); } for ( int i = from, j = to - 1; i < j; i++, j-- ) { swap( dest, i, j ); } }
/** * Returns a String representation of the list, top to bottom. * * @return a <code>String</code> value */ public String toString() { final StringBuilder buf = new StringBuilder( "{" ); for ( int i = _list.size() - 1; i > 0; i-- ) { buf.append( _list.get( i ) ); buf.append( ", " ); } if ( size() > 0 ) { buf.append( _list.get( 0 ) ); } buf.append( "}" ); return buf.toString(); }
/** * Copies the contents of the stack into a native array. Note that this will NOT * pop them out of the stack. The front of the list will be the top of the stack. * * @return an <code>byte[]</code> value */ public byte[] toArray() { byte[] retval = _list.toArray(); reverse( retval, 0, size() ); return retval; }
/** * Reverse the order of the elements in the range of the list. * * @param dest the array of data * @param from the inclusive index at which to start reversing * @param to the exclusive index at which to stop reversing */ private void reverse( byte[] dest, int from, int to ) { if ( from == to ) { return; // nothing to do } if ( from > to ) { throw new IllegalArgumentException( "from cannot be greater than to" ); } for ( int i = from, j = to - 1; i < j; i++, j-- ) { swap( dest, i, j ); } }
/** * Returns a String representation of the list, top to bottom. * * @return a <code>String</code> value */ public String toString() { final StringBuilder buf = new StringBuilder( "{" ); for ( int i = _list.size() - 1; i > 0; i-- ) { buf.append( _list.get( i ) ); buf.append( ", " ); } if ( size() > 0 ) { buf.append( _list.get( 0 ) ); } buf.append( "}" ); return buf.toString(); }
/** * Copies the contents of the stack into a native array. Note that this will NOT * pop them out of the stack. The front of the list will be the top of the stack. * * @return an <code>byte[]</code> value */ @Override public byte[] toArray() { byte[] retval = _list.toArray(); reverse( retval, 0, size() ); return retval; }
/** * Reverse the order of the elements in the range of the list. * * @param dest the array of data * @param from the inclusive index at which to start reversing * @param to the exclusive index at which to stop reversing */ private void reverse( byte[] dest, int from, int to ) { if ( from == to ) { return; // nothing to do } if ( from > to ) { throw new IllegalArgumentException( "from cannot be greater than to" ); } for ( int i = from, j = to - 1; i < j; i++, j-- ) { swap( dest, i, j ); } }
/** * Returns a String representation of the list, top to bottom. * * @return a <code>String</code> value */ @Override public String toString() { final StringBuilder buf = new StringBuilder( "{" ); for ( int i = _list.size() - 1; i > 0; i-- ) { buf.append( _list.get( i ) ); buf.append( ", " ); } if ( size() > 0 ) { buf.append( _list.get( 0 ) ); } buf.append( "}" ); return buf.toString(); }
/** * Copies the contents of the stack into a native array. Note that this will NOT * pop them out of the stack. The front of the list will be the top of the stack. * * @return an <code>byte[]</code> value */ public byte[] toArray() { byte[] retval = _list.toArray(); reverse( retval, 0, size() ); return retval; }
/** * Reverse the order of the elements in the range of the list. * * @param dest the array of data * @param from the inclusive index at which to start reversing * @param to the exclusive index at which to stop reversing */ private void reverse( byte[] dest, int from, int to ) { if ( from == to ) { return; // nothing to do } if ( from > to ) { throw new IllegalArgumentException( "from cannot be greater than to" ); } for ( int i = from, j = to - 1; i < j; i++, j-- ) { swap( dest, i, j ); } }
/** * Copies the contents of the stack into a native array. Note that this will NOT * pop them out of the stack. The front of the list will be the top of the stack. * * @return an <code>byte[]</code> value */ public byte[] toArray() { byte[] retval = _list.toArray(); reverse( retval, 0, size() ); return retval; }
/** * Copies a slice of the list into a native array. Note that this will NOT * pop them out of the stack. The front of the list will be the top * of the stack. * <p> * If the native array is smaller than the stack depth, * the native array will be filled with the elements from the top * of the array until it is full and exclude the remainder. * * @param dest the array to copy into. */ public void toArray( byte[] dest ) { int size = size(); int start = size - dest.length; if ( start < 0 ) { start = 0; } int length = Math.min( size, dest.length ); _list.toArray( dest, start, length ); reverse( dest, 0, length ); if ( dest.length > size ) { dest[size] = _list.getNoEntryValue(); } }
/** * Copies a slice of the list into a native array. Note that this will NOT * pop them out of the stack. The front of the list will be the top * of the stack. * <p> * If the native array is smaller than the stack depth, * the native array will be filled with the elements from the top * of the array until it is full and exclude the remainder. * * @param dest the array to copy into. */ public void toArray( byte[] dest ) { int size = size(); int start = size - dest.length; if ( start < 0 ) { start = 0; } int length = Math.min( size, dest.length ); _list.toArray( dest, start, length ); reverse( dest, 0, length ); if ( dest.length > size ) { dest[size] = _list.getNoEntryValue(); } }
/** * Copies a slice of the list into a native array. Note that this will NOT * pop them out of the stack. The front of the list will be the top * of the stack. * <p> * If the native array is smaller than the stack depth, * the native array will be filled with the elements from the top * of the array until it is full and exclude the remainder. * * @param dest the array to copy into. */ @Override public void toArray( byte[] dest ) { int size = size(); int start = size - dest.length; if ( start < 0 ) { start = 0; } int length = Math.min( size, dest.length ); _list.toArray( dest, start, length ); reverse( dest, 0, length ); if ( dest.length > size ) { dest[size] = _list.getNoEntryValue(); } }
/** * Copies a slice of the list into a native array. Note that this will NOT * pop them out of the stack. The front of the list will be the top * of the stack. * <p> * If the native array is smaller than the stack depth, * the native array will be filled with the elements from the top * of the array until it is full and exclude the remainder. * * @param dest the array to copy into. */ public void toArray( byte[] dest ) { int size = size(); int start = size - dest.length; if ( start < 0 ) { start = 0; } int length = Math.min( size, dest.length ); _list.toArray( dest, start, length ); reverse( dest, 0, length ); if ( dest.length > size ) { dest[size] = _list.getNoEntryValue(); } }