aboutsummaryrefslogtreecommitdiffstats
path: root/libparc/parc/algol/parc_BufferComposer.c
diff options
context:
space:
mode:
authorMichele Papalini <micpapal+fdio@cisco.com>2017-02-24 08:00:33 +0000
committerGerrit Code Review <gerrit@fd.io>2017-02-24 08:00:33 +0000
commit4df7f4cc98b6288177df256e1db70ddc3f7d00db (patch)
tree55e71277b419e4830ae641868ab8e751c8b86972 /libparc/parc/algol/parc_BufferComposer.c
parentf28308bd99381ef5f1e178e2e1f870f245e35873 (diff)
parentec688b4723a041044226358bcd4dd6e2da39da49 (diff)
Merge "Initial commit: cframework. Longbow and Libparc" into cframework/master
Diffstat (limited to 'libparc/parc/algol/parc_BufferComposer.c')
-rwxr-xr-xlibparc/parc/algol/parc_BufferComposer.c289
1 files changed, 289 insertions, 0 deletions
diff --git a/libparc/parc/algol/parc_BufferComposer.c b/libparc/parc/algol/parc_BufferComposer.c
new file mode 100755
index 00000000..20b7ecee
--- /dev/null
+++ b/libparc/parc/algol/parc_BufferComposer.c
@@ -0,0 +1,289 @@
+/*
+ * Copyright (c) 2017 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ */
+
+#include <config.h>
+
+#include <LongBow/runtime.h>
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stdio.h>
+
+#include <parc/algol/parc_Memory.h>
+#include <parc/algol/parc_Object.h>
+#include <parc/algol/parc_BufferComposer.h>
+#include <parc/algol/parc_Buffer.h>
+
+struct parc_buffer_composer {
+ size_t incrementHeuristic;
+ PARCBuffer *buffer;
+};
+
+static void
+_finalize(PARCBufferComposer **bufferPtr)
+{
+ if (bufferPtr != NULL) {
+ PARCBufferComposer *composer = *bufferPtr;
+ parcBufferComposer_OptionalAssertValid(composer);
+ if (composer->buffer != NULL) {
+ parcBuffer_Release(&composer->buffer);
+ }
+ }
+}
+
+parcObject_ExtendPARCObject(PARCBufferComposer, _finalize, NULL, NULL, parcBufferComposer_Equals, NULL, NULL, NULL);
+
+static PARCBufferComposer *
+_create(void)
+{
+ return parcObject_CreateInstance(PARCBufferComposer);
+}
+
+/**
+ * Ensure that the given `PARCBufferComposer` has at least the required number of bytes remaining.
+ *
+ * If the remaining capacity (the difference between the capacity of the buffer and its current position)
+ * of the underlying `PARCBuffer` is less than the required number of bytes,
+ * the underlying PARCBuffer is expanded with sufficient space to accomodate the required number of bytes.
+ *
+ * The position, limit, and mark remain unchanged.
+ * The capacity is increased.
+ */
+static PARCBufferComposer *
+_ensureRemaining(PARCBufferComposer *composer, size_t required)
+{
+ parcBufferComposer_OptionalAssertValid(composer);
+
+ size_t remainingCapacity = parcBuffer_Capacity(composer->buffer) - parcBuffer_Position(composer->buffer);
+
+ if (remainingCapacity < required) {
+ size_t incrementAmount = required;
+ if (incrementAmount < composer->incrementHeuristic) {
+ incrementAmount = composer->incrementHeuristic;
+ }
+ size_t newCapacity = parcBuffer_Capacity(composer->buffer) + incrementAmount;
+
+ PARCBuffer *newBuffer = parcBuffer_Allocate(newCapacity);
+ parcBuffer_Flip(composer->buffer);
+ parcBuffer_PutBuffer(newBuffer, composer->buffer);
+ parcBuffer_Release(&composer->buffer);
+ composer->buffer = newBuffer;
+ }
+
+ return composer;
+}
+
+void
+parcBufferComposer_AssertValid(const PARCBufferComposer *composer)
+{
+ trapIllegalValueIf(composer == NULL, "Parameter must be a non-null pointer to a valid PARCBufferComposer.");
+ trapIllegalValueIf(composer->incrementHeuristic < sizeof(void *), "Heuristic cannot be < sizeof(void *) (%zd), actual %zd", sizeof(void *), composer->incrementHeuristic);
+}
+
+PARCBufferComposer *
+parcBufferComposer_Create(void)
+{
+ return parcBufferComposer_Allocate(parcMemory_RoundUpToCacheLine(LEVEL1_DCACHE_LINESIZE));
+}
+
+PARCBufferComposer *
+parcBufferComposer_Allocate(size_t size)
+{
+ PARCBufferComposer *result = _create();
+ if (result != NULL) {
+ result->buffer = parcBuffer_Allocate(size);
+ result->incrementHeuristic = parcMemory_RoundUpToCacheLine(size);
+ if (result->buffer == NULL) {
+ result->incrementHeuristic = sizeof(void *); // minimum size
+ parcBufferComposer_Release(&result);
+ }
+ }
+ return result;
+}
+
+parcObject_ImplementAcquire(parcBufferComposer, PARCBufferComposer);
+
+parcObject_ImplementRelease(parcBufferComposer, PARCBufferComposer);
+
+bool
+parcBufferComposer_Equals(const PARCBufferComposer *x, const PARCBufferComposer *y)
+{
+ if (x == y) {
+ return true;
+ }
+ if (x == NULL || y == NULL) {
+ return false;
+ }
+
+ if (x->incrementHeuristic == y->incrementHeuristic) {
+ if (parcBuffer_Equals(x->buffer, y->buffer)) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+PARCBufferComposer *
+parcBufferComposer_PutArray(PARCBufferComposer *composer, const unsigned char *bytes, size_t length)
+{
+ if (length > 0) {
+ composer = _ensureRemaining(composer, length);
+ if (composer != NULL) {
+ parcBuffer_PutArray(composer->buffer, length, bytes);
+ }
+ }
+
+ return composer;
+}
+
+PARCBufferComposer *
+parcBufferComposer_PutChar(PARCBufferComposer *composer, char val)
+{
+ return parcBufferComposer_PutUint8(composer, (uint8_t) val);
+}
+
+PARCBufferComposer *
+parcBufferComposer_PutUint8(PARCBufferComposer *composer, uint8_t byte)
+{
+ composer = _ensureRemaining(composer, 1);
+ if (composer != NULL) {
+ parcBuffer_PutUint8(composer->buffer, byte);
+ }
+
+ return composer;
+}
+
+PARCBufferComposer *
+parcBufferComposer_PutUint16(PARCBufferComposer *composer, uint16_t value)
+{
+ composer = _ensureRemaining(composer, 2);
+ if (composer != NULL) {
+ parcBuffer_PutUint16(composer->buffer, value);
+ }
+
+ return composer;
+}
+
+PARCBufferComposer *
+parcBufferComposer_PutUint32(PARCBufferComposer *composer, uint32_t value)
+{
+ composer = _ensureRemaining(composer, 4);
+ if (composer != NULL) {
+ parcBuffer_PutUint32(composer->buffer, value);
+ }
+
+ return composer;
+}
+
+PARCBufferComposer *
+parcBufferComposer_PutUint64(PARCBufferComposer *composer, uint64_t value)
+{
+ composer = _ensureRemaining(composer, 8);
+ if (composer != NULL) {
+ parcBuffer_PutUint64(composer->buffer, value);
+ }
+
+ return composer;
+}
+
+PARCBufferComposer *
+parcBufferComposer_PutBuffer(PARCBufferComposer *composer, const PARCBuffer *source)
+{
+ composer = _ensureRemaining(composer, parcBuffer_Remaining(source));
+ if (composer != NULL) {
+ parcBuffer_PutBuffer(composer->buffer, source);
+ }
+
+ return composer;
+}
+
+PARCBufferComposer *
+parcBufferComposer_PutString(PARCBufferComposer *composer, const char *string)
+{
+ PARCBuffer *wrapper = parcBuffer_AllocateCString(string);
+
+ composer = _ensureRemaining(composer, parcBuffer_Remaining(wrapper));
+ if (composer != NULL) {
+ parcBuffer_PutBuffer(composer->buffer, wrapper);
+ }
+
+ parcBuffer_Release(&wrapper);
+
+ return composer;
+}
+
+PARCBufferComposer *
+parcBufferComposer_PutStrings(PARCBufferComposer *composer, ...)
+{
+ va_list ap;
+ va_start(ap, composer);
+
+ char *arg;
+ while ((arg = va_arg(ap, char *)) != NULL) {
+ parcBufferComposer_PutString(composer, arg);
+ }
+ va_end(ap);
+
+ return composer;
+}
+
+PARCBufferComposer *
+parcBufferComposer_Format(PARCBufferComposer *composer, const char *format, ...)
+{
+ va_list ap;
+ va_start(ap, format);
+ char *cString;
+ ssize_t written = vasprintf(&cString, format, ap);
+ assertTrue(written >= 0, "Got error from vasprintf");
+ va_end(ap);
+
+ parcBufferComposer_PutString(composer, cString);
+ free(cString);
+
+ return composer;
+}
+
+PARCBuffer *
+parcBufferComposer_GetBuffer(const PARCBufferComposer *composer)
+{
+ return composer->buffer;
+}
+
+PARCBuffer *
+parcBufferComposer_CreateBuffer(PARCBufferComposer *composer)
+{
+ return parcBuffer_Duplicate(composer->buffer);
+}
+
+PARCBuffer *
+parcBufferComposer_ProduceBuffer(PARCBufferComposer *composer)
+{
+ return parcBuffer_Acquire(parcBuffer_Flip(composer->buffer));
+}
+
+char *
+parcBufferComposer_ToString(PARCBufferComposer *composer)
+{
+ PARCBuffer *buffer = parcBuffer_Flip(parcBuffer_Duplicate(composer->buffer));
+
+ char *result = parcBuffer_ToString(buffer);
+ parcBuffer_Release(&buffer);
+
+ return result;
+}