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); }