chore: format Minecraft.World

Minecraft.World/IO/Streams/IntBuffer.cpp

@@ -2,112 +2,108 @@
 
 #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.
+// 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);
+// 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(unsigned int capacity, int* backingArray)
+    : Buffer(capacity) {
+    hasBackingArray = true;
+    buffer = backingArray;
 }
 
-IntBuffer::~IntBuffer()
-{
-	if( !hasBackingArray )
-		delete[] buffer;
+IntBuffer::~IntBuffer() {
+    if (!hasBackingArray) delete[] buffer;
 }
 
-int *IntBuffer::getBuffer()
-{
-	return 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.
+// 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;
+// 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 );
+// 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];
+    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.
+// 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.
+// 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
+// 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 );
+//      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 );
+    std::copy(inputArray->data + offset, inputArray->data + offset + length,
+              buffer + m_position);
 
-	m_position += length;
+    m_position += length;
 
-	return this;
+    return this;
 }
 
-IntBuffer *IntBuffer::put(intArray inputArray)
-{
-	if( inputArray.length > remaining() )
-		assert( false ); //TODO 4J Stu - Some kind of exception?
+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 );
+    std::copy(inputArray.data, inputArray.data + inputArray.length,
+              buffer + m_position);
 
-	m_position += inputArray.length;
+    m_position += inputArray.length;
 
-	return this;
+    return this;
 }
 
-//Writes the given int into this buffer at the current position, and then increments the position.
+// 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 );
+// Parameters:
+// i - The int to be written
+// Returns:
+// This buffer
+IntBuffer* IntBuffer::put(int i) {
+    assert(m_position < m_limit);
 
-	buffer[m_position++] = i;
+    buffer[m_position++] = i;
 
-	return this;
+    return this;
 }