bool
ccnxManifestHashGroup_Equals(const CCNxManifestHashGroup *objectA, const CCNxManifestHashGroup *objectB)
{
if (objectA == objectB) {
return true;
}
if (objectA == NULL || objectB == NULL) {
return false;
}
if (objectA->dataSize == objectB->dataSize) {
if (objectA->entrySize == objectB->entrySize) {
if (objectA->blockSize == objectB->blockSize) {
if (objectA->treeHeight == objectB->treeHeight) {
if (ccnxName_Equals(objectA->locator, objectB->locator)) {
if (parcBuffer_Equals(objectA->overallDataDigest, objectB->overallDataDigest)) {
if (parcLinkedList_Size(objectA->pointers) == parcLinkedList_Size(objectB->pointers)) {
for (size_t i = 0; i < parcLinkedList_Size(objectA->pointers); i++) {
CCNxManifestHashGroupPointer *ptrA = parcLinkedList_GetAtIndex(objectA->pointers, i);
CCNxManifestHashGroupPointer *ptrB = parcLinkedList_GetAtIndex(objectB->pointers, i);
if (!_CCNxManifestHashGroupPointer_Equals(ptrA, ptrB)) {
return false;
}
}
return true;
}
}
}
}
}
}
}
return false;
}
static size_t
_parcSortedList_GetInsertionIndex(const PARCSortedList *instance, const PARCObject *element)
{
ssize_t low = 0;
ssize_t high = parcLinkedList_Size(instance->list) - 1;
if (high == -1) {
return 0;
}
while (true) {
ssize_t midpoint = (low + (high - low) / 2);
PARCObject *e = parcLinkedList_GetAtIndex(instance->list, midpoint);
int signum = instance->compare(element, e);
if (high == low) {
if (signum < 0) {
return high;
} else if (signum > 0) {
return low + 1;
} else {
return low;
}
}
if (signum < 0) {
high = midpoint;
} else if (signum > 0) {
low = midpoint + 1;
} else {
return midpoint;
}
}
return -1;
}
PARCJSON *
ccnxManifestHashGroup_ToJson(const CCNxManifestHashGroup *group)
{
PARCJSON *root = parcJSON_Create();
PARCJSONArray *ptrList = parcJSONArray_Create();
for (size_t i = 0; i < parcLinkedList_Size(group->pointers); i++) {
CCNxManifestHashGroupPointer *ptr = (CCNxManifestHashGroupPointer *) parcLinkedList_GetAtIndex(group->pointers, i);
PARCJSON *ptrJson = parcJSON_Create();
// Type.
parcJSON_AddInteger(ptrJson, "type", ccnxManifestHashGroupPointer_GetType(ptr));
// Digest.
char *digestString = parcBuffer_ToHexString(ptr->digest);
parcJSON_AddString(ptrJson, "digest", digestString);
parcMemory_Deallocate(&digestString);
// Add the tuple to the list.
PARCJSONValue *val = parcJSONValue_CreateFromJSON(ptrJson);
parcJSONArray_AddValue(ptrList, val);
// Cleanup
parcJSONValue_Release(&val);
parcJSON_Release(&ptrJson);
}
root = parcJSON_AddArray(root, "HashGroup", ptrList);
parcJSONArray_Release(&ptrList);
if (group->overallDataDigest != NULL) {
char *digestString = parcBuffer_ToHexString(group->overallDataDigest);
root = parcJSON_AddString(root, "overallDataDigest", digestString);
parcMemory_Deallocate((void **) &digestString);
}
if (group->locator != NULL) {
char *locatorString = ccnxName_ToString(group->locator);
root = parcJSON_AddString(root, "locator", locatorString);
parcMemory_Deallocate((void **) &locatorString);
}
if (group->entrySize > 0) {
root = parcJSON_AddInteger(root, "entrySize", group->entrySize);
}
if (group->dataSize > 0) {
root = parcJSON_AddInteger(root, "dataSize", group->dataSize);
}
if (group->blockSize > 0) {
root = parcJSON_AddInteger(root, "blockSize", group->blockSize);
}
if (group->treeHeight > 0) {
root = parcJSON_AddInteger(root, "treeHeight", group->treeHeight);
}
return root;
}
static void *
_ccnxManifestHashGroupIterator_GetElement(CCNxManifestHashGroup *group, void *state)
{
_HashgroupIteratorState *thestate = (_HashgroupIteratorState *) state;
CCNxManifestHashGroupPointer *ptr =
(CCNxManifestHashGroupPointer *) parcLinkedList_GetAtIndex(group->pointers, thestate->pointerNumber - 1);
return ptr;
}
PARCBuffer *
ccnxManifestHashGroup_GetPointerDigestAtIndex(const CCNxManifestHashGroup *group, size_t index)
{
CCNxManifestHashGroupPointer *entry = parcLinkedList_GetAtIndex(group->pointers, index);
return entry->digest;
}
CCNxManifestHashGroupPointerType
ccnxManifestHashGroup_GetPointerTypeAtIndex(const CCNxManifestHashGroup *group, size_t index)
{
CCNxManifestHashGroupPointer *entry = parcLinkedList_GetAtIndex(group->pointers, index);
return entry->pointerType;
}
PARCObject *
parcSortedList_GetLast(const PARCSortedList *list)
{
return parcLinkedList_GetAtIndex(list->list, parcLinkedList_Size(list->list) - 1);
}
PARCObject *
parcSortedList_GetFirst(const PARCSortedList *list)
{
return parcLinkedList_GetAtIndex(list->list, 0);
}
PARCObject *
parcSortedList_GetAtIndex(const PARCSortedList *list, const size_t index)
{
return parcLinkedList_GetAtIndex(list->list, index);
}
