TrackPointer GlobalTrackCache::lookupByRef(
const TrackRef& trackRef) {
if (trackRef.hasId()) {
return lookupById(trackRef.getId());
} else {
const auto canonicalLocation = trackRef.getCanonicalLocation();
const auto trackByCanonicalLocation(
m_tracksByCanonicalLocation.find(canonicalLocation));
if (m_tracksByCanonicalLocation.end() != trackByCanonicalLocation) {
// Cache hit
if (traceLogEnabled()) {
kLogger.trace()
<< "Cache hit for"
<< canonicalLocation
<< trackByCanonicalLocation->second->getPlainPtr();
}
return revive(trackByCanonicalLocation->second);
} else {
// Cache miss
if (traceLogEnabled()) {
kLogger.trace()
<< "Cache miss for"
<< canonicalLocation;
}
return TrackPointer();
}
}
}
/* ****************************************************************************
*
* SubscriptionCache::remove -
*/
int SubscriptionCache::remove
(
const std::string& tenant,
const std::string& servicePath,
const std::string& subId
)
{
Subscription* subP = lookupById(tenant, servicePath, subId);
if (subP == NULL)
{
return -1;
}
return remove(subP);
}
void GlobalTrackCache::resolve(
GlobalTrackCacheResolver* /*in/out*/ pCacheResolver,
QFileInfo /*in*/ fileInfo,
TrackId trackId,
SecurityTokenPointer pSecurityToken) {
DEBUG_ASSERT(pCacheResolver);
// Primary lookup by id (if available)
if (trackId.isValid()) {
if (debugLogEnabled()) {
kLogger.debug()
<< "Resolving track by id"
<< trackId;
}
auto strongPtr = lookupById(trackId);
if (strongPtr) {
if (debugLogEnabled()) {
kLogger.debug()
<< "Cache hit - found track by id"
<< trackId
<< strongPtr.get();
}
TrackRef trackRef = createTrackRef(*strongPtr);
pCacheResolver->initLookupResult(
GlobalTrackCacheLookupResult::HIT,
std::move(strongPtr),
std::move(trackRef));
return;
}
}
// Secondary lookup by canonical location
// The TrackRef is constructed now after the lookup by ID failed to
// avoid calculating the canonical file path if it is not needed.
TrackRef trackRef = TrackRef::fromFileInfo(fileInfo, trackId);
if (trackRef.hasCanonicalLocation()) {
if (debugLogEnabled()) {
kLogger.debug()
<< "Resolving track by canonical location"
<< trackRef.getCanonicalLocation();
}
auto strongPtr = lookupByRef(trackRef);
if (strongPtr) {
// Cache hit
if (debugLogEnabled()) {
kLogger.debug()
<< "Cache hit - found track by canonical location"
<< trackRef.getCanonicalLocation()
<< strongPtr.get();
}
pCacheResolver->initLookupResult(
GlobalTrackCacheLookupResult::HIT,
std::move(strongPtr),
std::move(trackRef));
return;
}
}
if (!m_pSaver) {
// Do not allocate any new tracks once the cache
// has been deactivated
DEBUG_ASSERT(isEmpty());
kLogger.warning()
<< "Cache miss - caching has already been deactivated"
<< trackRef;
return;
}
if (debugLogEnabled()) {
kLogger.debug()
<< "Cache miss - allocating track"
<< trackRef;
}
auto deletingPtr = std::unique_ptr<Track, void (&)(Track*)>(
new Track(
std::move(fileInfo),
std::move(pSecurityToken),
std::move(trackId)),
deleteTrack);
// Track objects live together with the cache on the main thread
// and will be deleted later within the event loop. But this
// function might be called from any thread, even from worker
// threads without an event loop. We need to move the newly
// created object to the target thread.
deletingPtr->moveToThread(QApplication::instance()->thread());
auto cacheEntryPtr = std::make_shared<GlobalTrackCacheEntry>(
std::move(deletingPtr));
auto savingPtr = TrackPointer(
cacheEntryPtr->getPlainPtr(),
EvictAndSaveFunctor(cacheEntryPtr));
cacheEntryPtr->setSavingWeakPtr(savingPtr);
if (debugLogEnabled()) {
kLogger.debug()
<< "Cache miss - inserting new track into cache"
<< trackRef
<< deletingPtr.get();
}
if (trackRef.hasId()) {
// Insert item by id
DEBUG_ASSERT(m_tracksById.find(
trackRef.getId()) == m_tracksById.end());
m_tracksById.insert(std::make_pair(
trackRef.getId(),
cacheEntryPtr));
}
if (trackRef.hasCanonicalLocation()) {
// Insert item by track location
DEBUG_ASSERT(m_tracksByCanonicalLocation.find(
trackRef.getCanonicalLocation()) == m_tracksByCanonicalLocation.end());
m_tracksByCanonicalLocation.insert(std::make_pair(
trackRef.getCanonicalLocation(),
cacheEntryPtr));
}
pCacheResolver->initLookupResult(
GlobalTrackCacheLookupResult::MISS,
std::move(savingPtr),
std::move(trackRef));
}
