bool
ccnxContentObject_Equals(const CCNxContentObject *objectA, const CCNxContentObject *objectB)
{
    CCNxContentObjectInterface *implA = ccnxContentObjectInterface_GetInterface(objectA);
    CCNxContentObjectInterface *implB = ccnxContentObjectInterface_GetInterface(objectB);

    assertNotNull(implA, "ContentObject must have an valid implementation pointer.");
    assertNotNull(implB, "ContentObject must have an valid implementation pointer.");

    if (implA != implB) {
        return false;
    }

    if (implA->equals != NULL) {
        return implA->equals(objectA, objectB);
    } else {
        trapNotImplemented("ccnxContentObject_Equals");
    }
}
void
ccnxContentObject_AssertValid(const CCNxContentObject *contentObject)
{
    assertNotNull(contentObject, "Parameter must be a non-null CCNxContentObject pointer");
    CCNxContentObjectInterface *impl = ccnxContentObjectInterface_GetInterface(contentObject);

    assertNotNull(impl, "ContentObject must have a non-NUll implementation");
    if (impl->assertValid != NULL) {
        impl->assertValid(contentObject);
    }
}
void
ccnxContentObject_Display(const CCNxContentObject *contentObject, int indentation)
{
    ccnxContentObject_OptionalAssertValid(contentObject);
    CCNxContentObjectInterface *impl = ccnxContentObjectInterface_GetInterface(contentObject);

    if (impl->display != NULL) {
        impl->display(contentObject, indentation);
    } else {
        ccnxTlvDictionary_Display(contentObject, indentation);
    }
}
LONGBOW_TEST_CASE(Global, ccnxContentObjectInterface_GetInterface)
{
    CCNxName *name = ccnxName_CreateFromCString("lci:/boose/roo/pie");

    CCNxContentObject *contentObjectV1 =
        ccnxContentObject_CreateWithImplAndPayload(&CCNxContentObjectFacadeV1_Implementation,
                                                   name,
                                                   CCNxPayloadType_DATA,
                                                   NULL);

    assertTrue(ccnxContentObjectInterface_GetInterface(contentObjectV1) == &CCNxContentObjectFacadeV1_Implementation,
               "Expected V1 Implementation");

    // Now unset the pointer and see if it gets derived properly.
    ccnxTlvDictionary_SetMessageInterface(contentObjectV1, NULL);
    assertTrue(ccnxContentObjectInterface_GetInterface(contentObjectV1) == &CCNxContentObjectFacadeV1_Implementation,
               "Expected V1 Implementation");


    ccnxName_Release(&name);
    ccnxContentObject_Release(&contentObjectV1);
}
PARCBuffer *
ccnxContentObject_GetKeyId(const CCNxContentObject *contentObject)
{
    ccnxContentObject_OptionalAssertValid(contentObject);

    PARCBuffer *result = NULL;

    CCNxContentObjectInterface *impl = ccnxContentObjectInterface_GetInterface(contentObject);
    if (impl->getKeyId != NULL) {
        result = impl->getKeyId(contentObject);
    }

    return result;
}
bool
ccnxContentObject_SetSignature(CCNxContentObject *contentObject, const PARCBuffer *keyId,
                               const PARCSignature *signature, const CCNxKeyLocator *keyLocator)
{
    ccnxContentObject_OptionalAssertValid(contentObject);
    CCNxContentObjectInterface *impl = ccnxContentObjectInterface_GetInterface(contentObject);

    bool result = false;

    if (impl->setSignature != NULL) {
        result = impl->setSignature(contentObject, keyId, signature, keyLocator);
    }

    return result;
}
char *
ccnxContentObject_ToString(const CCNxContentObject *contentObject)
{
    ccnxContentObject_OptionalAssertValid(contentObject);
    CCNxContentObjectInterface *impl = ccnxContentObjectInterface_GetInterface(contentObject);

    char *result = NULL;

    if (impl->toString != NULL) {
        result = impl->toString(contentObject);
    } else {
        trapNotImplemented("ccnxContentObject_ToString");
    }
    return result;
}
bool
ccnxContentObject_SetFinalChunkNumber(CCNxContentObject *contentObject, const uint64_t finalChunkNumber)
{
    ccnxContentObject_OptionalAssertValid(contentObject);
    CCNxContentObjectInterface *impl = ccnxContentObjectInterface_GetInterface(contentObject);

    bool result = false;

    if (impl->setFinalChunkNumber != NULL) {
        result = impl->setFinalChunkNumber(contentObject, finalChunkNumber);
    } else {
        trapNotImplemented("ccnxContentObject_SetFinalChunkNumber");
    }
    return result;
}
bool
ccnxContentObject_SetExpiryTime(CCNxContentObject *contentObject, const uint64_t expiryTIme)
{
    bool result = false;

    ccnxContentObject_OptionalAssertValid(contentObject);
    CCNxContentObjectInterface *impl = ccnxContentObjectInterface_GetInterface(contentObject);

    if (impl->setExpiryTime != NULL) {
        result = impl->setExpiryTime(contentObject, expiryTIme);
    } else {
        trapNotImplemented("ccnxContentObject_SetExpiryTime");
    }
    return result;
}
uint64_t
ccnxContentObject_GetFinalChunkNumber(const CCNxContentObject *contentObject)
{
    ccnxContentObject_OptionalAssertValid(contentObject);
    CCNxContentObjectInterface *impl = ccnxContentObjectInterface_GetInterface(contentObject);

    if (impl->hasFinalChunkNumber != NULL && !impl->hasFinalChunkNumber((CCNxTlvDictionary *) contentObject)) {
        trapUnexpectedState("ContentObject has no final chunk number. Call ccnxContentObject_HasFinalChunkNumber() first.");
    }

    if (impl->getFinalChunkNumber != NULL) {
        return impl->getFinalChunkNumber(contentObject);
    } else {
        trapNotImplemented("ccnxContentObject_GetFinalChunkNumber");
    }
}
uint64_t
ccnxContentObject_GetExpiryTime(const CCNxContentObject *contentObject)
{
    ccnxContentObject_OptionalAssertValid(contentObject);
    CCNxContentObjectInterface *impl = ccnxContentObjectInterface_GetInterface(contentObject);

    if (impl->hasExpiryTime != NULL && !impl->hasExpiryTime((CCNxTlvDictionary *) contentObject)) {
        trapUnexpectedState("ContentObject has no ExpiryTime. Call HasExpiryTime() first.");
    }

    if (impl->getExpiryTime != NULL) {
        return impl->getExpiryTime(contentObject);
    } else {
        trapNotImplemented("ccnxContentObject_HasExpiryTime");
    }
}
bool
ccnxContentObject_HasExpiryTime(const CCNxContentObject *contentObject)
{
    ccnxContentObject_OptionalAssertValid(contentObject);
    CCNxContentObjectInterface *impl = ccnxContentObjectInterface_GetInterface(contentObject);

    bool result = false;

    if (impl->hasExpiryTime != NULL) {
        result = impl->hasExpiryTime(contentObject);
    } else {
        return false;
    }

    return result;
}
bool
ccnxContentObject_SetPayload(CCNxContentObject *contentObject, CCNxPayloadType payloadType, const PARCBuffer *payload)
{
    ccnxContentObject_OptionalAssertValid(contentObject);
    CCNxContentObjectInterface *impl = ccnxContentObjectInterface_GetInterface(contentObject);

    bool result = false;;

    if (impl->setPayload != NULL) {
        result = impl->setPayload(contentObject, payloadType, payload);;
    } else {
        trapNotImplemented("ccnxContentObject_SetPayload");
    }

    return result;
}
CCNxPayloadType
ccnxContentObject_GetPayloadType(const CCNxContentObject *contentObject)
{
    ccnxContentObject_OptionalAssertValid(contentObject);
    CCNxContentObjectInterface *impl = ccnxContentObjectInterface_GetInterface(contentObject);

    CCNxPayloadType result = CCNxPayloadType_DATA;

    if (impl->getPayloadType != NULL) {
        result = impl->getPayloadType(contentObject);
    } else {
        trapNotImplemented("ccnxContentObject_GetPayloadType");
    }

    return result;
}
PARCBuffer *
ccnxContentObject_GetPayload(const CCNxContentObject *contentObject)
{
    ccnxContentObject_OptionalAssertValid(contentObject);
    CCNxContentObjectInterface *impl = ccnxContentObjectInterface_GetInterface(contentObject);

    PARCBuffer *result = NULL;

    if (impl->getPayload != NULL) {
        result = impl->getPayload(contentObject);
    } else {
        trapNotImplemented("ccnxContentObject_GetPayload");
    }

    return result;
}
CCNxName *
ccnxContentObject_GetName(const CCNxContentObject *contentObject)
{
    ccnxContentObject_OptionalAssertValid(contentObject);
    CCNxContentObjectInterface *impl = ccnxContentObjectInterface_GetInterface(contentObject);

    CCNxName *result = NULL;

    if (impl->getName != NULL) {
        result = impl->getName(contentObject);
    } else {
        trapNotImplemented("ccnxContentObject_GetName");
    }

    return result;
}