Merge pull request #2 from cwood/3986-chris-file_repo

Update the Chunker implementation and add a new function to the API to

parc/algol/parc_BufferChunker.c

@@ -41,10 +41,10 @@
 
 #include <parc/algol/parc_BufferChunker.h>
 
-PARCChunkerInterface *PARCBufferChunkerAsBunker = &(PARCChunkerInterface) {
-    .ForwardIterator = (void *(*)(const void *))parcBufferChunker_ForwardIterator,
-    .ReverseIterator = (void *(*)(const void *))parcBufferChunker_ReverseIterator,
-    .Release = (void (*)(void **))parcBufferChunker_Release
+PARCChunkerInterface *PARCBufferChunkerAsChunker = &(PARCChunkerInterface) {
+    .ForwardIterator = (void *(*)(const void *)) parcBufferChunker_ForwardIterator,
+    .ReverseIterator = (void *(*)(const void *)) parcBufferChunker_ReverseIterator,
+    .GetChunkSize = (size_t (*)(const void *)) parcBufferChunker_GetChunkSize
 };
 
 struct _parc_chunker_state {
@@ -266,3 +266,9 @@ parcBufferChunker_ReverseIterator(const PARCBufferChunker *chunker)
 
     return iterator;
 }
+
+size_t
+parcBufferChunker_GetChunkSize(const PARCBufferChunker *chunker)
+{
+    return chunker->chunkSize;
+}

parc/algol/parc_BufferChunker.h

@@ -36,8 +36,6 @@
 #ifndef libparc_parc_BufferChunker_h
 #define libparc_parc_BufferChunker_h
 
-#include <config.h>
-
 #include <parc/algol/parc_Chunker.h>
 
 struct parc_buffer_chunker;
@@ -211,4 +209,22 @@ PARCIterator *parcBufferChunker_ForwardIterator(const PARCBufferChunker *chunker
  */
 PARCIterator *parcBufferChunker_ReverseIterator(const PARCBufferChunker *chunker);
 
+/**
+ * Get the chunk size of a `PARCBufferChunker.`
+ *
+ * @param [in] chunker A `PARCBufferChunker` instance.
+ *
+ * @return the chunk size
+ *
+ * Example
+ * @code
+ * {
+ *     PARCBuffer *dataToChunk = ...
+ *     PARCBufferChunker *chunker = ...
+ *
+ *     size_t chunkSize = parcBufferChunker_GetChunkSize(chunker);
+ * }
+ * @endcode
+ */
+size_t parcBufferChunker_GetChunkSize(const PARCBufferChunker *chunker);
 #endif // libparc_parc_BufferChunker_h

parc/algol/parc_Chunker.c

@@ -41,14 +41,14 @@
 #include <parc/algol/parc_Chunker.h>
 
 struct parc_chunker {
-    void *instance;
+    PARCObject *instance;
     const PARCChunkerInterface *interface;
 };
 
 static void
 _destroy(PARCChunker **chunkerP)
 {
-    (*chunkerP)->interface->Release(&(*chunkerP)->instance);
+    parcObject_Release(&(*chunkerP)->instance);
 }
 
 
@@ -57,12 +57,12 @@ parcObject_ImplementAcquire(parcChunker, PARCChunker);
 parcObject_ImplementRelease(parcChunker, PARCChunker);
 
 PARCChunker *
-parcChunker_Create(void *instance, PARCChunkerInterface *interface)
+parcChunker_Create(PARCObject *instance, PARCChunkerInterface *interface)
 {
     PARCChunker *chunker = parcObject_CreateInstance(PARCChunker);
 
     if (chunker != NULL) {
-        chunker->instance = instance;
+        chunker->instance = parcObject_Acquire(instance);
         chunker->interface = interface;
     }
 
@@ -80,3 +80,9 @@ parcChunker_ReverseIterator(const PARCChunker *chunker)
 {
     return (chunker->interface)->ReverseIterator(chunker->instance);
 }
+
+size_t
+parcChunker_GetChunkSize(const PARCChunker *chunker)
+{
+    return (chunker->interface)->GetChunkSize(chunker->instance);
+}

parc/algol/parc_Chunker.h

@@ -37,8 +37,6 @@
 #ifndef libparc_parc_Chunker_h
 #define libparc_parc_Chunker_h
 
-#include <config.h>
-
 #include <parc/algol/parc_Object.h>
 #include <parc/algol/parc_Iterator.h>
 
@@ -61,9 +59,9 @@ typedef struct PARCChunkerInterface {
     void *(*ReverseIterator)(const void *original);
 
     /**
-     * @see parcChunker_Release
+     * @see parcChunker_GetChunkSize
      */
-    void (*Release)(void **originalP);
+    size_t (*GetChunkSize)(const void *original);
 } PARCChunkerInterface;
 
 /**
@@ -83,7 +81,7 @@ typedef struct PARCChunkerInterface {
  *     PARCChunker *chunker = parcChunker_Create(bufferCunker, &PARCBufferChunkerAsChunker);
  * }
  */
-PARCChunker *parcChunker_Create(void *instance, PARCChunkerInterface *interface);
+PARCChunker *parcChunker_Create(PARCObject *instance, PARCChunkerInterface *interface);
 
 /**
  * Create a new chunker to segment data contained in a file.
@@ -243,4 +241,23 @@ PARCIterator *parcChunker_ForwardIterator(const PARCChunker *chunker);
  * @endcode
  */
 PARCIterator *parcChunker_ReverseIterator(const PARCChunker *chunker);
+
+/**
+ * Get the chunk size of a `PARCChunker.`
+ *
+ * @param [in] chunker A `PARCChunker` instance.
+ *
+ * @return the chunk size
+ *
+ * Example
+ * @code
+ * {
+ *     PARCBuffer *dataToChunk = ...
+ *     PARCChunker *chunker = ...
+ *
+ *     size_t chunkSize = parcChunker_GetChunkSize(chunker);
+ * }
+ * @endcode
+ */
+size_t parcChunker_GetChunkSize(const PARCChunker *chunker);
 #endif // libparc_parc_Chunker_h

parc/algol/parc_FileChunker.c

@@ -43,10 +43,10 @@
 
 #include <parc/algol/parc_FileChunker.h>
 
-PARCChunkerInterface *PARCFileChunkerAsBunker = &(PARCChunkerInterface) {
-    .ForwardIterator = (void *(*)(const void *))parcFileChunker_ForwardIterator,
-    .ReverseIterator = (void *(*)(const void *))parcFileChunker_ReverseIterator,
-    .Release = (void (*)(void **))parcFileChunker_Release
+PARCChunkerInterface *PARCFileChunkerAsChunker = &(PARCChunkerInterface) {
+    .ForwardIterator = (void *(*)(const void *)) parcFileChunker_ForwardIterator,
+    .ReverseIterator = (void *(*)(const void *)) parcFileChunker_ReverseIterator,
+    .GetChunkSize = (size_t (*)(const void *)) parcFileChunker_GetChunkSize
 };
 
 struct _parc_chunker_state {
@@ -287,3 +287,9 @@ parcFileChunker_ReverseIterator(const PARCFileChunker *chunker)
 
     return iterator;
 }
+
+size_t
+parcFileChunker_GetChunkSize(const PARCFileChunker *chunker)
+{
+    return chunker->chunkSize;
+}

parc/algol/parc_FileChunker.h

@@ -36,8 +36,6 @@
 #ifndef libparc_parc_FileChunker_h
 #define libparc_parc_FileChunker_h
 
-#include <config.h>
-
 #include <parc/algol/parc_Chunker.h>
 
 #include <parc/algol/parc_File.h>
@@ -212,4 +210,23 @@ PARCIterator *parcFileChunker_ForwardIterator(const PARCFileChunker *chunker);
  * @endcode
  */
 PARCIterator *parcFileChunker_ReverseIterator(const PARCFileChunker *chunker);
+
+/**
+ * Get the chunk size of a `PARCFileChunker.`
+ *
+ * @param [in] chunker A `PARCFileChunker` instance.
+ *
+ * @return the chunk size
+ *
+ * Example
+ * @code
+ * {
+ *     PARCBuffer *dataToChunk = ...
+ *     PARCFileChunker *chunker = ...
+ *
+ *     size_t chunkSize = parcFileChunker_GetChunkSize(chunker);
+ * }
+ * @endcode
+ */
+size_t parcFileChunker_GetChunkSize(const PARCFileChunker *chunker);
 #endif // libparc_parc_FileChunker_h

parc/algol/parc_RandomAccessFile.c

@@ -196,4 +196,3 @@ parcRandomAccessFile_Seek(PARCRandomAccessFile *fileHandle, long offset, PARCRan
     }
     return result;
 }
-

parc/algol/test/test_parc_BufferChunker.c

@@ -65,6 +65,7 @@ LONGBOW_TEST_FIXTURE(Global)
     LONGBOW_RUN_TEST_CASE(Global, parc_Chunker_ReverseIterator_Buffer);
     LONGBOW_RUN_TEST_CASE(Global, parc_Chunker_ReverseIterator_BufferPartial);
     LONGBOW_RUN_TEST_CASE(Global, parc_Chunker_ReverseIterator_BufferSmall);
+    LONGBOW_RUN_TEST_CASE(Global, parc_Chunker_GetChunkSize);
 }
 
 LONGBOW_TEST_FIXTURE_SETUP(Global)
@@ -325,6 +326,19 @@ LONGBOW_TEST_CASE(Global, parc_Chunker_ReverseIterator_BufferSmall)
     parcBuffer_Release(&buffer);
 }
 
+LONGBOW_TEST_CASE(Global, parc_Chunker_GetChunkSize)
+{
+    size_t expectedChunkSize = 32;
+    PARCBuffer *buffer = parcBuffer_Allocate(16);
+    PARCBufferChunker *chunker = parcBufferChunker_Create(buffer, expectedChunkSize); // each chunk is 32 bytes
+    size_t actualChunkSize = parcBufferChunker_GetChunkSize(chunker);
+
+    assertTrue(actualChunkSize == expectedChunkSize, "Expected chunk size of %zu, got %zu", expectedChunkSize, actualChunkSize);
+
+    parcBuffer_Release(&buffer);
+    parcBufferChunker_Release(&chunker);
+}
+
 int
 main(int argc, char *argv[])
 {

parc/algol/test/test_parc_Chunker.c

@@ -50,6 +50,7 @@ typedef struct {
     int start;
     int end;
     bool released;
+    size_t chunkSize;
 } _DummyChunker;
 
 static void *
@@ -84,12 +85,6 @@ _next(_DummyChunker *chunker, void *voidstate)
     return state;
 }
 
-//static void
-//_parcChunker_RemoveAt(CCNxBufferChunker *chunker, void **state)
-//{
-//    // pass
-//}
-
 static void *
 _get(_DummyChunker *chunker, void *voidstate)
 {
@@ -104,12 +99,6 @@ _finish(_DummyChunker *chunker, void *state)
     parcMemory_Deallocate(&thestate);
 }
 
-//static void
-//_parcChunker_AssertValid(const void *state)
-//{
-//    // pass
-//}
-
 static PARCIterator *
 _mock_ForwardIterator(const void *chunker)
 {
@@ -140,6 +129,13 @@ _mock_ReverseIterator(const void *chunker)
     return iterator;
 }
 
+static size_t
+_mock_GetChunkSize(const void *chunker)
+{
+    _DummyChunker *dummy = (_DummyChunker *) chunker;
+    return dummy->chunkSize;
+}
+
 static void
 _dummyDestroy(_DummyChunker **chunkerP)
 {
@@ -149,7 +145,7 @@ _dummyDestroy(_DummyChunker **chunkerP)
 PARCChunkerInterface *_MockChunker = &(PARCChunkerInterface) {
     .ForwardIterator = (void *(*)(const void *))_mock_ForwardIterator,
     .ReverseIterator = (void *(*)(const void *))_mock_ReverseIterator,
-    .Release = (void (*)(void **))_dummyDestroy
+    .GetChunkSize = (size_t (*)(const void *))_mock_GetChunkSize
 };
 
 parcObject_ExtendPARCObject(_DummyChunker, _dummyDestroy, NULL, NULL, NULL, NULL, NULL, NULL);
@@ -163,6 +159,7 @@ _dummy_Create(int val)
     chunker->start = 0;
     chunker->end = val;
     chunker->released = false;
+    chunker->chunkSize = val;
     return chunker;
 }
 
@@ -189,6 +186,7 @@ LONGBOW_TEST_FIXTURE(Global)
     LONGBOW_RUN_TEST_CASE(Global, parc_Chunker_Create);
     LONGBOW_RUN_TEST_CASE(Global, parc_Chunker_ForwardIterator);
     LONGBOW_RUN_TEST_CASE(Global, parc_Chunker_ReverseIterator);
+    LONGBOW_RUN_TEST_CASE(Global, parc_Chunker_GetChunkSize);
 }
 
 LONGBOW_TEST_FIXTURE_SETUP(Global)
@@ -210,14 +208,14 @@ LONGBOW_TEST_CASE(Global, parc_Chunker_Create)
 {
     _DummyChunker *dummy = _dummy_Create(10);
     PARCChunker *chunker = parcChunker_Create(dummy, _MockChunker);
+    _dummy_Release(&dummy);
 
     assertNotNull(chunker, "Expected non-NULL PARCChunker to be created from the dummy MockChunker");
     PARCChunker *copy = parcChunker_Acquire(chunker);
     assertNotNull(copy, "Expected non-NULL copy of the PARCChunker");
 
     parcChunker_Release(&chunker);
     parcChunker_Release(&copy);
-    _dummy_Release(&dummy);
 }
 
 LONGBOW_TEST_CASE(Global, parc_Chunker_ForwardIterator)
@@ -226,6 +224,7 @@ LONGBOW_TEST_CASE(Global, parc_Chunker_ForwardIterator)
 
     _DummyChunker *dummy = _dummy_Create(n);
     PARCChunker *chunker = parcChunker_Create(dummy, _MockChunker);
+    _dummy_Release(&dummy);
     PARCIterator *itr = parcChunker_ForwardIterator(chunker);
 
     int targetSum = (n * (n + 1)) / 2;
@@ -238,7 +237,6 @@ LONGBOW_TEST_CASE(Global, parc_Chunker_ForwardIterator)
 
     parcIterator_Release(&itr);
     parcChunker_Release(&chunker);
-    _dummy_Release(&dummy);
 }
 
 LONGBOW_TEST_CASE(Global, parc_Chunker_ReverseIterator)
@@ -247,6 +245,7 @@ LONGBOW_TEST_CASE(Global, parc_Chunker_ReverseIterator)
 
     _DummyChunker *dummy = _dummy_Create(n);
     PARCChunker *chunker = parcChunker_Create(dummy, _MockChunker);
+    _dummy_Release(&dummy);
     PARCIterator *itr = parcChunker_ReverseIterator(chunker);
 
     int targetSum = (n * (n + 1)) / 2;
@@ -259,7 +258,20 @@ LONGBOW_TEST_CASE(Global, parc_Chunker_ReverseIterator)
 
     parcIterator_Release(&itr);
     parcChunker_Release(&chunker);
+}
+
+LONGBOW_TEST_CASE(Global, parc_Chunker_GetChunkSize)
+{
+    int n = 10;
+
+    _DummyChunker *dummy = _dummy_Create(n);
+    PARCChunker *chunker = parcChunker_Create(dummy, _MockChunker);
     _dummy_Release(&dummy);
+
+    size_t chunkSize = parcChunker_GetChunkSize(chunker);
+    assertTrue(chunkSize == n, "Expected the chunk size to be %d, got %zu\n", n, chunkSize);
+
+    parcChunker_Release(&chunker);
 }
 
 int