static CCNxContentObject *
//_athenaLRUContentStore_GetMatch(AthenaContentStoreImplementation *store, const CCNxName *name, const PARCBuffer *keyIdRestriction,
// const PARCBuffer *contentObjectHash)
_athenaLRUContentStore_GetMatch(AthenaContentStoreImplementation *store, const CCNxInterest *interest)
{
CCNxContentObject *result = NULL;
AthenaLRUContentStore *impl = (AthenaLRUContentStore *) store;
_AthenaLRUContentStoreEntry *entry = NULL;
CCNxName *name = ccnxInterest_GetName(interest);
PARCBuffer *contentObjectHashRestriction = ccnxInterest_GetContentObjectHashRestriction(interest);
PARCBuffer *keyIdRestriction = ccnxInterest_GetKeyIdRestriction(interest);
if (contentObjectHashRestriction != NULL) {
PARCObject *nameAndHashKey = _createHashableKey(name, NULL, contentObjectHashRestriction);
entry = (_AthenaLRUContentStoreEntry *) parcHashMap_Get(impl->tableByNameAndObjectHash, nameAndHashKey);
parcObject_Release((PARCObject **) &nameAndHashKey);
}
if ((entry == NULL) && (keyIdRestriction != NULL)) {
PARCObject *nameAndKeyIdKey = _createHashableKey(name, keyIdRestriction, NULL);
entry = (_AthenaLRUContentStoreEntry *) parcHashMap_Get(impl->tableByNameAndKeyId, nameAndKeyIdKey);
parcObject_Release((PARCObject **) &nameAndKeyIdKey);
}
if (entry == NULL) {
PARCObject *nameKey = _createHashableKey(name, NULL, NULL);
entry = (_AthenaLRUContentStoreEntry *) parcHashMap_Get(impl->tableByName, nameKey);
parcObject_Release((PARCObject **) &nameKey);
}
// Matching is done. Now check for validity, if necessary.
if (entry != NULL) {
// We found matching content. Now make sure it's not expired before returning it. If it is expired,
// remove it from the store and don't return anything.
if (entry->hasExpiryTime && (entry->expiryTime < parcClock_GetTime(impl->wallClock))) {
_athenaLRUContentStore_PurgeContentStoreEntry(impl, entry);
entry = NULL;
}
// XXX: TODO: Check that the KeyId, if any, was verified.
}
// At this point, the cached content is considered valid for responding with. Return it.
if (entry != NULL) {
result = entry->contentObject;
// Update LRU so that the matched entry is at the top of the list.
_moveContentStoreEntryToLRUHead(impl, entry);
impl->stats.numMatchHits++;
} else {
impl->stats.numMatchMisses++;
}
return result;
}
PARCJSON *
parcHashMap_ToJSON(const PARCHashMap *hashMap)
{
parcHashMap_OptionalAssertValid(hashMap);
PARCJSON *result = parcJSON_Create();
PARCIterator *iterator = parcHashMap_CreateKeyIterator((PARCHashMap *) hashMap);
while (parcIterator_HasNext(iterator)) {
PARCObject *keyObject = parcIterator_Next(iterator);
const PARCObject *valueObject = parcHashMap_Get(hashMap, keyObject);
char *key = parcObject_ToString(keyObject);
PARCJSON *value = parcObject_ToJSON(valueObject);
parcJSON_AddObject(result, key, value);
parcMemory_Deallocate(&key);
parcJSON_Release(&value);
}
parcIterator_Release(&iterator);
return result;
}
static bool
_athenaLRUContentStore_RemoveMatch(AthenaContentStoreImplementation *store, const CCNxName *name,
const PARCBuffer *keyIdRestriction, const PARCBuffer *contentObjectHash)
{
AthenaLRUContentStore *impl = (AthenaLRUContentStore *) store;
bool wasRemoved = false;
if (contentObjectHash != NULL) {
PARCObject *nameAndHashKey = _createHashableKey(name, NULL, contentObjectHash);
_AthenaLRUContentStoreEntry *entry =
(_AthenaLRUContentStoreEntry *) parcHashMap_Get(impl->tableByNameAndObjectHash, nameAndHashKey);
parcObject_Release((PARCObject **) &nameAndHashKey);
if (entry != NULL) {
_athenaLRUContentStore_PurgeContentStoreEntry(store, entry);
wasRemoved = true;
}
}
if (!wasRemoved && keyIdRestriction != NULL) {
PARCObject *nameAndKeyIdKey = _createHashableKey(name, keyIdRestriction, NULL);
_AthenaLRUContentStoreEntry *entry = (_AthenaLRUContentStoreEntry *) parcHashMap_Get(impl->tableByNameAndKeyId,
nameAndKeyIdKey);
parcObject_Release((PARCObject **) &nameAndKeyIdKey);
if (entry != NULL) {
_athenaLRUContentStore_PurgeContentStoreEntry(store, entry);
wasRemoved = true;
}
}
if (!wasRemoved) {
PARCObject *nameKey = _createHashableKey(name, NULL, NULL);
_AthenaLRUContentStoreEntry *entry = (_AthenaLRUContentStoreEntry *) parcHashMap_Get(impl->tableByName,
nameKey);
parcObject_Release((PARCObject **) &nameKey);
if (entry != NULL) {
_athenaLRUContentStore_PurgeContentStoreEntry(store, entry);
wasRemoved = true;
}
}
return wasRemoved;
}
/**
* Add an entry to an index table, returning the entry that would be replaced (if any).
*/
static _AthenaLRUContentStoreEntry *
_addEntryToIndexTableIfNotAlreadyInIt(PARCHashMap *indexTable, PARCObject *key, _AthenaLRUContentStoreEntry *entry)
{
// Check to see if it's already in the table.
_AthenaLRUContentStoreEntry *existingEntry = (_AthenaLRUContentStoreEntry *) parcHashMap_Get(indexTable, key);
if (existingEntry != NULL) {
// There is an existing entry in this table for this key. Note that it will no longer be in the tableByName
// after we add the new one. (The hashMap silently replaces it, after calling _Release on it).
existingEntry->indexCount--;
}
// Place the new entry in the index table.
parcHashMap_Put(indexTable, key, entry);
entry->indexCount += 1;
return existingEntry;
}
PARCBufferComposer *
parcHashMap_BuildString(const PARCHashMap *hashMap, PARCBufferComposer *composer)
{
PARCIterator *iterator = parcHashMap_CreateKeyIterator((PARCHashMap *) hashMap);
while (parcIterator_HasNext(iterator)) {
PARCObject *keyObject = parcIterator_Next(iterator);
const PARCObject *valueObject = parcHashMap_Get(hashMap, keyObject);
char *key = parcObject_ToString(keyObject);
char *value = parcObject_ToString(valueObject);
parcBufferComposer_Format(composer, "%s -> %s\n", key, value);
parcMemory_Deallocate(&key);
parcMemory_Deallocate(&value);
}
parcIterator_Release(&iterator);
return composer;
}
void
parcHashMap_Display(const PARCHashMap *hashMap, int indentation)
{
parcDisplayIndented_PrintLine(indentation, "PARCHashMap@%p {", hashMap);
PARCIterator *iterator = parcHashMap_CreateKeyIterator((PARCHashMap *) hashMap);
while (parcIterator_HasNext(iterator)) {
PARCObject *keyObject = parcIterator_Next(iterator);
const PARCObject *valueObject = parcHashMap_Get(hashMap, keyObject);
char *key = parcObject_ToString(keyObject);
char *value = parcObject_ToString(valueObject);
parcDisplayIndented_PrintLine(indentation + 1, "%s -> %s", key, value);
parcMemory_Deallocate(&key);
parcMemory_Deallocate(&value);
}
parcIterator_Release(&iterator);
parcDisplayIndented_PrintLine(indentation, "}");
}