113 lines
3.2 KiB
C++
113 lines
3.2 KiB
C++
#include "stdafx.h"
|
|
|
|
#include "IntBuffer.h"
|
|
|
|
//Allocates a new int buffer.
|
|
//The new buffer's position will be zero, its limit will be its capacity, and its mark will be undefined.
|
|
//It will have a backing array, and its array offset will be zero.
|
|
//
|
|
//Parameters:
|
|
//capacity - The new buffer's capacity, in ints
|
|
IntBuffer::IntBuffer(unsigned int capacity) : Buffer( capacity )
|
|
{
|
|
buffer = new int[capacity];
|
|
memset( buffer,0,sizeof(int)*capacity);
|
|
}
|
|
|
|
IntBuffer::IntBuffer( unsigned int capacity, int *backingArray ) : Buffer( capacity )
|
|
{
|
|
hasBackingArray = true;
|
|
buffer = backingArray;
|
|
}
|
|
|
|
IntBuffer::~IntBuffer()
|
|
{
|
|
if( !hasBackingArray )
|
|
delete[] buffer;
|
|
}
|
|
|
|
int *IntBuffer::getBuffer()
|
|
{
|
|
return buffer;
|
|
}
|
|
|
|
//Flips this buffer. The limit is set to the current position and then the position is set to zero.
|
|
//If the mark is defined then it is discarded.
|
|
//
|
|
//Returns:
|
|
//This buffer
|
|
IntBuffer *IntBuffer::flip()
|
|
{
|
|
m_limit = m_position;
|
|
m_position = 0;
|
|
return this;
|
|
}
|
|
|
|
//Absolute get method. Reads the int at the given index.
|
|
//Parameters:
|
|
//index - The index from which the int will be read
|
|
//Returns:
|
|
//The int at the given index
|
|
int IntBuffer::get(unsigned int index)
|
|
{
|
|
assert( index < m_limit );
|
|
|
|
return buffer[index];
|
|
}
|
|
|
|
//Relative bulk put method (optional operation).
|
|
//This method transfers ints into this buffer from the given source array.
|
|
//If there are more ints to be copied from the array than remain in this buffer, that is, if length > remaining(),
|
|
//then no ints are transferred and a BufferOverflowException is thrown.
|
|
//
|
|
//Otherwise, this method copies length ints from the given array into this buffer, starting at the given offset in the array
|
|
//and at the current position of this buffer. The position of this buffer is then incremented by length.
|
|
//
|
|
//In other words, an invocation of this method of the form dst.put(src, off, len) has exactly the same effect as the loop
|
|
//
|
|
// for (int i = off; i < off + len; i++)
|
|
// dst.put(a[i]);
|
|
//except that it first checks that there is sufficient space in this buffer and it is potentially much more efficient.
|
|
//Parameters:
|
|
//src - The array from which ints are to be read
|
|
//offset - The offset within the array of the first int to be read; must be non-negative and no larger than array.length
|
|
//length - The number of ints to be read from the given array; must be non-negative and no larger than array.length - offset
|
|
//Returns:
|
|
//This buffer
|
|
IntBuffer *IntBuffer::put(intArray *inputArray, unsigned int offset, unsigned int length)
|
|
{
|
|
assert( offset + length < inputArray->length );
|
|
|
|
std::copy( inputArray->data +offset, inputArray->data +offset+length, buffer+m_position );
|
|
|
|
m_position += length;
|
|
|
|
return this;
|
|
}
|
|
|
|
IntBuffer *IntBuffer::put(intArray inputArray)
|
|
{
|
|
if( inputArray.length > remaining() )
|
|
assert( false ); //TODO 4J Stu - Some kind of exception?
|
|
|
|
std::copy( inputArray.data, inputArray.data + inputArray.length, buffer+m_position );
|
|
|
|
m_position += inputArray.length;
|
|
|
|
return this;
|
|
}
|
|
|
|
//Writes the given int into this buffer at the current position, and then increments the position.
|
|
//
|
|
//Parameters:
|
|
//i - The int to be written
|
|
//Returns:
|
|
//This buffer
|
|
IntBuffer *IntBuffer::put(int i)
|
|
{
|
|
assert( m_position < m_limit );
|
|
|
|
buffer[m_position++] = i;
|
|
|
|
return this;
|
|
} |