PARCBuffer *
parcBuffer_Resize(PARCBuffer *buffer, size_t newCapacity)
{
parcBuffer_OptionalAssertValid(buffer);
PARCByteArray *newArray = parcByteArray_Allocate(newCapacity);
if (newArray == NULL) {
return NULL;
}
size_t numberOfBytesToCopy = parcBuffer_Capacity(buffer);
if (numberOfBytesToCopy > newCapacity) {
numberOfBytesToCopy = newCapacity;
}
parcByteArray_PutBytes(newArray, 0, numberOfBytesToCopy, &parcByteArray_Array(buffer->array)[buffer->arrayOffset]);
parcByteArray_Release(&buffer->array);
buffer->array = newArray;
buffer->arrayOffset = 0;
buffer->limit = _computeNewLimit(buffer->capacity, buffer->limit, newCapacity);
buffer->mark = _computeNewMark(buffer->mark, buffer->limit, newCapacity);
buffer->capacity = newCapacity;
buffer->position = (buffer->position < buffer->limit) ? buffer->position : buffer->limit;
parcBuffer_OptionalAssertValid(buffer);
return buffer;
}
bool
parcBuffer_HasRemaining(const PARCBuffer *buffer)
{
parcBuffer_OptionalAssertValid(buffer);
return parcBuffer_Remaining(buffer) != 0;
}
size_t
parcBuffer_Position(const PARCBuffer *buffer)
{
parcBuffer_OptionalAssertValid(buffer);
return buffer->position;
}
size_t
parcBuffer_Limit(const PARCBuffer *buffer)
{
parcBuffer_OptionalAssertValid(buffer);
return buffer->limit;
}
size_t
parcBuffer_ArrayOffset(const PARCBuffer *buffer)
{
parcBuffer_OptionalAssertValid(buffer);
return buffer->arrayOffset;
}
PARCByteArray *
parcBuffer_Array(const PARCBuffer *buffer)
{
parcBuffer_OptionalAssertValid(buffer);
return buffer->array;
}
size_t
parcBuffer_Capacity(const PARCBuffer *buffer)
{
parcBuffer_OptionalAssertValid(buffer);
return buffer->capacity;
}
size_t
parcBuffer_Remaining(const PARCBuffer *buffer)
{
parcBuffer_OptionalAssertValid(buffer);
return buffer->limit - buffer->position;
}
PARCBuffer *
parcBuffer_PutAtIndex(PARCBuffer *buffer, size_t index, uint8_t value)
{
parcBuffer_OptionalAssertValid(buffer);
assertTrue(_effectiveIndex(buffer, index) < parcBuffer_Limit(buffer), "Buffer overflow");
parcByteArray_PutByte(buffer->array, _effectiveIndex(buffer, index), value);
return buffer;
}
uint8_t
parcBuffer_GetAtIndex(const PARCBuffer *buffer, size_t index)
{
parcBuffer_OptionalAssertValid(buffer);
_trapIfIndexExceedsLimit(buffer, index);
return parcByteArray_GetByte(buffer->array, _effectiveIndex(buffer, index));
}
PARCBuffer *
parcBuffer_Mark(PARCBuffer *buffer)
{
parcBuffer_OptionalAssertValid(buffer);
buffer->mark = buffer->position;
_optionalAssertInvariants(buffer);
return buffer;
}
PARCBuffer *
parcBuffer_PutArray(PARCBuffer *buffer, size_t arrayLength, const uint8_t array[arrayLength])
{
parcBuffer_OptionalAssertValid(buffer);
assertTrue(parcBuffer_Remaining(buffer) >= arrayLength,
"Buffer overflow");
parcByteArray_PutBytes(buffer->array, _effectivePosition(buffer), arrayLength, array);
return parcBuffer_SetPosition(buffer, parcBuffer_Position(buffer) + arrayLength);
}
void *
parcBuffer_Overlay(PARCBuffer *buffer, size_t length)
{
parcBuffer_OptionalAssertValid(buffer);
_trapIfBufferUnderflow(buffer, length);
uint8_t *result = parcByteArray_AddressOfIndex(buffer->array, _effectiveIndex(buffer, parcBuffer_Position(buffer)));
buffer->position += length;
return result;
}
PARCBuffer *
parcBuffer_Rewind(PARCBuffer *buffer)
{
parcBuffer_OptionalAssertValid(buffer);
buffer->position = 0;
_discardMark(buffer);
_optionalAssertInvariants(buffer);
return buffer;
}
PARCBuffer *
parcBuffer_PutUint8(PARCBuffer *buffer, uint8_t value)
{
parcBuffer_OptionalAssertValid(buffer);
assertTrue(parcBuffer_Remaining(buffer) >= 1,
"Buffer overflow");
parcByteArray_PutByte(buffer->array, _effectivePosition(buffer), value);
buffer->position++;
return buffer;
}
PARCBuffer *
parcBuffer_GetBytes(PARCBuffer *buffer, size_t length, uint8_t array[length])
{
parcBuffer_OptionalAssertValid(buffer);
_trapIfBufferUnderflow(buffer, length);
parcByteArray_GetBytes(buffer->array, _effectivePosition(buffer), length, array);
buffer->position += length;
return buffer;
}
PARCJSONValue *
parcJSONValue_CreateFromString(PARCBuffer *value)
{
parcBuffer_OptionalAssertValid(value);
PARCJSONValue *result = _createValue(PARCJSONValueType_String);
if (result != NULL) {
result->value.string = parcBuffer_Acquire(value);
}
return result;
}
uint8_t
parcBuffer_GetUint8(PARCBuffer *buffer)
{
parcBuffer_OptionalAssertValid(buffer);
_trapIfBufferUnderflow(buffer, 1);
uint8_t result = parcByteArray_GetByte(buffer->array, _effectivePosition(buffer));
buffer->position++;
return result;
}
PARCBuffer *
parcBuffer_PutBuffer(PARCBuffer *result, const PARCBuffer *buffer)
{
parcBuffer_OptionalAssertValid(buffer);
assertTrue(parcBuffer_Remaining(result) >= parcBuffer_Remaining(buffer),
"Buffer overflow. %zd bytes remaining, %zd required.", parcBuffer_Remaining(result), parcBuffer_Remaining(buffer));
size_t length = parcBuffer_Remaining(buffer);
parcByteArray_ArrayCopy(result->array, _effectivePosition(result), buffer->array, _effectivePosition(buffer), length);
parcBuffer_SetPosition(result, parcBuffer_Position(result) + length);
return result;
}
PARCBuffer *
parcBuffer_Reset(PARCBuffer *buffer)
{
parcBuffer_OptionalAssertValid(buffer);
assertFalse(_markIsDiscarded(buffer),
"The mark has not been set");
buffer->position = buffer->mark;
_optionalAssertInvariants(buffer);
return buffer;
}
PARCBuffer *
parcBuffer_Flip(PARCBuffer *result)
{
parcBuffer_OptionalAssertValid(result);
size_t position = result->position;
result->position = 0;
result->limit = position;
_optionalAssertInvariants(result);
return result;
}
/**
* Initialise a parcBuffer instance.
*
* The buffer's offset, position, limit and capacity are set to the given values.
* The mark is made invalid.
*
* @return The same pointer as `result`.
*/
static PARCBuffer *
_parcBuffer_Init(PARCBuffer *result, PARCByteArray *array, size_t offset, size_t position, size_t limit, size_t capacity)
{
result->array = array;
result->arrayOffset = offset;
result->position = position;
result->limit = limit;
result->capacity = capacity;
_discardMark(result);
parcBuffer_OptionalAssertValid(result);
return result;
}
PARCBuffer *
parcBuffer_SetPosition(PARCBuffer *buffer, size_t newPosition)
{
parcBuffer_OptionalAssertValid(buffer);
assertFalse(newPosition > buffer->limit,
"new position cannot be greater the buffer's limit");
buffer->position = newPosition;
if (!_markIsDiscarded(buffer) && newPosition < buffer->mark) {
_discardMark(buffer);
}
_optionalAssertInvariants(buffer);
return buffer;
}
PARCBuffer *
parcBuffer_SetLimit(PARCBuffer *buffer, size_t newLimit)
{
parcBuffer_OptionalAssertValid(buffer);
assertTrue(newLimit <= parcBuffer_Capacity(buffer),
"new limit cannot be larger than the capacity");
if (_markIsDiscarded(buffer)) {
buffer->limit = newLimit;
_discardMark(buffer);
} else {
if (newLimit < buffer->position) {
buffer->position = newLimit;
}
if (newLimit < buffer->mark) {
_discardMark(buffer);
}
buffer->limit = newLimit;
}
_optionalAssertInvariants(buffer);
return buffer;
}
PARCBuffer *
parcBuffer_Copy(const PARCBuffer *original)
{
parcBuffer_OptionalAssertValid(original);
PARCBuffer *result = _parcBuffer_getInstance();
if (result != NULL) {
PARCByteArray *array = parcByteArray_Copy(original->array);
if (array != NULL) {
_parcBuffer_Init(result,
array,
parcBuffer_ArrayOffset(original),
parcBuffer_Position(original),
parcBuffer_Limit(original),
parcBuffer_Capacity(original));
} else {
parcBuffer_Release(&result);
}
}
return result;
}
void
parcJSONParser_AssertValid(const PARCJSONParser *parser)
{
assertNotNull(parser, "PARCJSONParser cannot be NULL");
parcBuffer_OptionalAssertValid(parser->buffer);
}
