#include "RCSException.h"
#include "ocrandom.h"
+#include "ScopeLogger.h"
+
+#define TAG PCF("RCSResourceCacheManager")
+
namespace OIC
{
namespace Service
PrimitiveResourcePtr pResource, CacheCB func, CACHE_METHOD cm,
REPORT_FREQUENCY rf, long reportTime)
{
+ SCOPE_LOG_F(DEBUG, TAG);
+
if (pResource == nullptr)
{
throw RCSInvalidParameterException {"[requestResourceCache] Primitive Resource is invaild"};
auto newHandler = std::make_shared<ObserveCache>(pResource);
newHandler->startCache(std::move(func));
- m_observeCacheList.push_back(newHandler);
observeCacheIDmap.insert(std::make_pair(retID, newHandler));
return retID;
newHandler->initializeDataCache(pResource);
s_cacheDataList->push_back(newHandler);
}
+
+ std::lock_guard<std::mutex> lock(s_mutex);
retID = newHandler->addSubscriber(func, rf, reportTime);
cacheIDmap.insert(std::make_pair(retID, newHandler));
void ResourceCacheManager::cancelResourceCache(CacheID id)
{
+ SCOPE_LOG_F(DEBUG, TAG);
+ std::lock_guard<std::mutex> lock(s_mutex);
+
auto observeIns = observeCacheIDmap.find(id);
auto dataCacheIns = cacheIDmap.find(id);
if ((dataCacheIns == cacheIDmap.end() && observeIns == observeCacheIDmap.end())
if (observeIns != observeCacheIDmap.end())
{
- (observeIns->second)->stopCache();
+ try
+ {
+ (observeIns->second)->stopCache();
+ }
+ catch (...)
+ {
+ (observeIns->second).reset();
+ observeCacheIDmap.erase(id);
+ throw;
+ }
(observeIns->second).reset();
- observeCacheIDmap.erase(observeIns);
+ observeCacheIDmap.erase(id);
return;
}
{
cacheIDmap.erase(id);
}
- std::lock_guard<std::mutex> lock(s_mutex);
if (foundCacheHandler->isEmptySubscriber())
{
s_cacheDataList->remove(foundCacheHandler);
void ResourceCacheManager::updateResourceCache(CacheID updateId) const
{
+ SCOPE_LOG_F(DEBUG, TAG);
+
if (updateId == 0)
{
- throw RCSInvalidParameterException {"[getCachedData] CacheID is NULL"};
+ throw RCSInvalidParameterException {"[updateResourceCache] CacheID is NULL"};
}
DataCachePtr foundCache = findDataCache(updateId);
if (foundCache == nullptr)
{
- throw RCSInvalidParameterException {"[getCachedData] CacheID is invaild"};
+ throw RCSInvalidParameterException {"[updateResourceCache] CacheID is invaild"};
}
foundCache->requestGet();
}
const RCSResourceAttributes ResourceCacheManager::getCachedData(CacheID id) const
{
+ SCOPE_LOG_F(DEBUG, TAG);
+
if (id == 0)
{
throw RCSInvalidParameterException {"[getCachedData] CacheID is NULL"};
CACHE_STATE ResourceCacheManager::getResourceCacheState(CacheID id) const
{
+ SCOPE_LOG_F(DEBUG, TAG);
+
if (id == 0)
{
throw RCSInvalidParameterException {"[getResourceCacheState] CacheID is NULL"};
bool ResourceCacheManager::isCachedData(CacheID id) const
{
+ SCOPE_LOG_F(DEBUG, TAG);
+
if (id == 0)
{
throw RCSInvalidParameterException {"[isCachedData] CacheID is NULL"};
void ResourceCacheManager::initializeResourceCacheManager()
{
+ SCOPE_LOG_F(DEBUG, TAG);
+
std::lock_guard<std::mutex> lock(s_mutex);
if (s_cacheDataList == nullptr)
{
DataCachePtr ResourceCacheManager::findDataCache(PrimitiveResourcePtr pResource) const
{
+ SCOPE_LOG_F(DEBUG, TAG);
+
DataCachePtr retHandler = nullptr;
std::lock_guard<std::mutex> lock(s_mutex);
for (auto &i : * s_cacheDataList)
DataCachePtr ResourceCacheManager::findDataCache(CacheID id) const
{
+ SCOPE_LOG_F(DEBUG, TAG);
+
DataCachePtr retHandler = nullptr;
for (auto it : cacheIDmap)
{