From 8a3a6e9f14619f98bc9bfccd5a7fc5adb76483b3 Mon Sep 17 00:00:00 2001 From: "jyong2.kim" Date: Tue, 7 Jul 2015 19:49:30 +0900 Subject: [PATCH] Arrange Cache module code and logic. add namespace OIC::Service. change parameter and return type of interfaces. add exception handle in interfaces. arrange duplicated code and logic. add updateResourceCache(). Change-Id: I71302bc7cc0351626dd67790e2b4bf787c5b881e Signed-off-by: jyong2.kim Reviewed-on: https://gerrit.iotivity.org/gerrit/1558 Tested-by: jenkins-iotivity Reviewed-by: Uze Choi --- .../modules/resourceCache/SConscript | 3 +- .../modules/resourceCache/include/CacheTypes.h | 87 +++--- .../modules/resourceCache/include/DataCache.h | 112 +++---- .../resourceCache/include/ResourceCacheManager.h | 73 +++-- .../modules/resourceCache/src/DataCache.cpp | 324 ++++++++++---------- .../resourceCache/src/ResourceCacheManager.cpp | 334 ++++++++++++--------- 6 files changed, 514 insertions(+), 419 deletions(-) diff --git a/service/resource-manipulation/modules/resourceCache/SConscript b/service/resource-manipulation/modules/resourceCache/SConscript index d5e51bc..4b1eac3 100644 --- a/service/resource-manipulation/modules/resourceCache/SConscript +++ b/service/resource-manipulation/modules/resourceCache/SConscript @@ -44,6 +44,7 @@ target_os = env.get('TARGET_OS') resourcecache_env.AppendUnique(CPPPATH = ['include']) resourcecache_env.AppendUnique(CPPPATH = ['../common/primitiveResource/include']) resourcecache_env.AppendUnique(CPPPATH = ['../common/expiryTimer/include']) +resourcecache_env.AppendUnique(CPPPATH = ['../common/expiryTimer/src']) resourcecache_env.PrependUnique(LIBS = ['service_common', 'ExpiryTimer', 'oc', 'octbstack', 'oc_logger', 'connectivity_abstraction', 'libcoap']) if target_os not in ['windows', 'winrt']: @@ -66,5 +67,5 @@ resourcecachesdk = resourcecache_env.StaticLibrary('ResourceCache', resourcecach resourcecache_env.InstallTarget(resourcecachesdk, 'libResouceCache') # Go to build sample apps -SConscript('SampleApp/SConscript') +#SConscript('SampleApp/SConscript') diff --git a/service/resource-manipulation/modules/resourceCache/include/CacheTypes.h b/service/resource-manipulation/modules/resourceCache/include/CacheTypes.h index 77ed25b..8cf9c41 100755 --- a/service/resource-manipulation/modules/resourceCache/include/CacheTypes.h +++ b/service/resource-manipulation/modules/resourceCache/include/CacheTypes.h @@ -18,64 +18,69 @@ // //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= -#ifndef CACHETYPES_H -#define CACHETYPES_H +#ifndef RCM_CACHETYPES_H +#define RCM_CACHETYPES_H #include #include #include #include -#include "ocstack.h" -#include "OCResource.h" +#include "logger.h" #include "PrimitiveResource.h" #include "ResourceAttributes.h" -#define CACHE_TAG PCF("CACHE") -#define DEFAULT_REPORT_TIME 30 -#define DEFAULT_EXPIRED_TIME 15l +namespace OIC +{ + namespace Service + { -using namespace OIC::Service; + class DataCache; -class DataCache; + #define CACHE_TAG PCF("CACHE") + #define DEFAULT_REPORT_TIME 10l + #define DEFAULT_EXPIRED_TIME 15l -enum class REPORT_FREQUENCY -{ - NONE = 0, - UPTODATE, - PERIODICTY -}; + enum class REPORT_FREQUENCY + { + NONE = 0, + UPTODATE, + PERIODICTY + }; -struct Report_Info -{ - REPORT_FREQUENCY rf; - int reportID; - long repeatTime; - unsigned int timerID; -}; + struct Report_Info + { + REPORT_FREQUENCY rf; + int reportID; + long repeatTime; + unsigned int timerID; + }; -enum class CACHE_STATE -{ - READY = 0, - READY_YET, - LOST_SIGNAL, - DESTROYED, - UPDATING, - NONE -}; + enum class CACHE_STATE + { + READY = 0, + READY_YET, + LOST_SIGNAL, + DESTROYED, + UPDATING, + NONE + }; -typedef int CacheID; + typedef int CacheID; -typedef std::function, const ResourceAttributes &)> CacheCB; -typedef std::map> SubscriberInfo; -typedef std::pair> SubscriberInfoPair; + typedef std::function, + const ResourceAttributes &)> CacheCB; + typedef std::map> SubscriberInfo; + typedef std::pair> SubscriberInfoPair; -typedef OC::OCResource BaseResource; -typedef PrimitiveResource::GetCallback GetCB; -typedef PrimitiveResource::ObserveCallback ObserveCB; + typedef OC::OCResource BaseResource; + typedef PrimitiveResource::GetCallback GetCB; + typedef PrimitiveResource::ObserveCallback ObserveCB; -typedef std::shared_ptr DataCachePtr; -typedef std::shared_ptr PrimitiveResourcePtr; + typedef std::shared_ptr DataCachePtr; + typedef std::shared_ptr PrimitiveResourcePtr; + } // namespace Service +} // namespace OIC -#endif +#endif /* RCM_CACHETYPES_H */ diff --git a/service/resource-manipulation/modules/resourceCache/include/DataCache.h b/service/resource-manipulation/modules/resourceCache/include/DataCache.h index 6ec8814..7fd246c 100755 --- a/service/resource-manipulation/modules/resourceCache/include/DataCache.h +++ b/service/resource-manipulation/modules/resourceCache/include/DataCache.h @@ -18,65 +18,71 @@ // //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= -#ifndef DATACACHE_H_ -#define DATACACHE_H_ +#ifndef RCM_DATACACHE_H_ +#define RCM_DATACACHE_H_ #include #include #include -#include "OCResource.h" -#include "logger.h" - #include "CacheTypes.h" #include "ExpiryTimer.h" -class DataCache +namespace OIC { -public: - DataCache( - PrimitiveResourcePtr pResource, - CacheCB func, - REPORT_FREQUENCY rf, - long repeatTime); - ~DataCache(); - - CacheID addSubscriber(CacheCB func, REPORT_FREQUENCY rf, long repeatTime); - CacheID deleteSubscriber(CacheID id); - - CACHE_STATE getCacheState() const; - const ResourceAttributes getCachedData() const; - const PrimitiveResourcePtr getPrimitiveResource() const; - - SubscriberInfoPair findSubscriber(CacheID id); - -private: - // resource instance - PrimitiveResourcePtr sResource; - std::shared_ptr baseHandler; - - // cached data info - ResourceAttributes attributes; - CACHE_STATE state; - - // subscriber info - std::unique_ptr subscriberList; - - // timer info - ExpiryTimer *timerInstance; - TimerID expiredTimerId; - - // for requestCB from base - void onObserve(const HeaderOptions& _hos, - const ResponseStatement& _rep, int _result, int _seq); - void onGet(const HeaderOptions& _hos, const ResponseStatement& _rep, int _result); - void *onTimer(const unsigned int timerID); - ObserveCB pObserveCB; - GetCB pGetCB; - TimerCB pTimerCB; - - OCStackResult updateCacheData(); - -}; - -#endif /* DATACACHE_H_ */ + namespace Service + { + class DataCache + { + public: + DataCache(); + ~DataCache(); + + void initializeDataCache(PrimitiveResourcePtr pResource); + + CacheID addSubscriber(CacheCB func, REPORT_FREQUENCY rf, long repeatTime); + CacheID deleteSubscriber(CacheID id); + + CACHE_STATE getCacheState() const; + const ResourceAttributes getCachedData() const; + const PrimitiveResourcePtr getPrimitiveResource() const; + + void requestGet(); + + private: + // resource instance + PrimitiveResourcePtr sResource; + std::shared_ptr baseHandler; + + // cached data info + ResourceAttributes attributes; + CACHE_STATE state; + + // subscriber info + std::unique_ptr subscriberList; + + ExpiryTimer networkTimer; + ExpiryTimer pollingTimer; + TimerID networkTimeOutHandle; + TimerID pollingHandle; + + ObserveCB pObserveCB; + GetCB pGetCB; + TimerCB pTimerCB; + TimerCB pPollingCB; + + // for requestCB from base + void onObserve(const HeaderOptions& _hos, + const ResponseStatement& _rep, int _result, int _seq); + void onGet(const HeaderOptions& _hos, const ResponseStatement& _rep, int _result); + void *onTimeOut(const unsigned int timerID); + void *onPollingOut(const unsigned int timerID); + + CacheID generateCacheID(); + SubscriberInfoPair findSubscriber(CacheID id); + void notifyObservers(ResourceAttributes Att); + }; + } // namespace Service +} // namespace OIC + +#endif /* RCM_DATACACHE_H_ */ diff --git a/service/resource-manipulation/modules/resourceCache/include/ResourceCacheManager.h b/service/resource-manipulation/modules/resourceCache/include/ResourceCacheManager.h index 040c3fc..2ad47ee 100755 --- a/service/resource-manipulation/modules/resourceCache/include/ResourceCacheManager.h +++ b/service/resource-manipulation/modules/resourceCache/include/ResourceCacheManager.h @@ -18,46 +18,65 @@ // //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= -#ifndef RESOURCECACHEMANAGER_H_ -#define RESOURCECACHEMANAGER_H_ +#ifndef RCM_RESOURCECACHEMANAGER_H_ +#define RCM_RESOURCECACHEMANAGER_H_ #include #include #include +#include -#include "OCPlatform.h" #include "CacheTypes.h" #include "DataCache.h" -#define CACHE_TAG PCF("CACHE") - -class ResourceCacheManager +namespace OIC { -public: - static ResourceCacheManager * getInstance(); + namespace Service + { + class ResourceCacheManager + { + public: + class InvalidParameter: public PrimitiveException + { + public: + InvalidParameter(std::string&& what) : PrimitiveException{ std::move(what) } {} + }; + + static ResourceCacheManager * getInstance(); + + CacheID requestResourceCache( + PrimitiveResourcePtr pResource, CacheCB func = NULL, + REPORT_FREQUENCY rf = REPORT_FREQUENCY::NONE, long time = 0l); + void cancelResourceCache(CacheID id); + + void updateResourceCache(PrimitiveResourcePtr pResource) const; + void updateResourceCache(CacheID id) const; - CacheID requestResourceCache( - PrimitiveResourcePtr pResource, - CacheCB func = NULL, REPORT_FREQUENCY rf = REPORT_FREQUENCY::NONE, long time = 0l); - CacheID cancelResourceCache(CacheID id); - OCStackResult updateResourceCache(PrimitiveResourcePtr pResource); + const ResourceAttributes getCachedData(PrimitiveResourcePtr pResource) const; + const ResourceAttributes getCachedData(CacheID id) const; - const ResourceAttributes getCachedData(PrimitiveResourcePtr pResource) const; - const ResourceAttributes getCachedData(CacheID id) const; + CACHE_STATE getResourceCacheState(PrimitiveResourcePtr pResource) const; + CACHE_STATE getResourceCacheState(CacheID id) const; - CACHE_STATE getResourceCacheState(PrimitiveResourcePtr pResource) const; - CACHE_STATE getResourceCacheState(CacheID id) const; + private: + static ResourceCacheManager * s_instance; + static std::mutex s_mutexForCreation; + static std::unique_ptr> s_cacheDataList; + std::map cacheIDmap; - ~ResourceCacheManager(); -private: - ResourceCacheManager(); + ResourceCacheManager() = default; + ~ResourceCacheManager(); + ResourceCacheManager(const ResourceCacheManager&) = delete; + ResourceCacheManager(ResourceCacheManager&&) = delete; - static ResourceCacheManager * s_instance; - static std::mutex s_mutexForCreation; - static std::unique_ptr> s_cacheDataList; + ResourceCacheManager& operator=(const ResourceCacheManager&) const = delete; + ResourceCacheManager& operator=(ResourceCacheManager&&) const = delete; - DataCachePtr findDataCache(PrimitiveResourcePtr pResource) const; - DataCachePtr findDataCache(CacheID id) const; -}; + static void initializeResourceCacheManager(); + DataCachePtr findDataCache(PrimitiveResourcePtr pResource) const; + DataCachePtr findDataCache(CacheID id) const; + }; + } // namespace Service +} // namespace OIC -#endif /* RESOURCECACHEMANAGER_H_ */ +#endif /* RCM_RESOURCECACHEMANAGER_H_ */ diff --git a/service/resource-manipulation/modules/resourceCache/src/DataCache.cpp b/service/resource-manipulation/modules/resourceCache/src/DataCache.cpp index 0a4e56c..4a47c26 100755 --- a/service/resource-manipulation/modules/resourceCache/src/DataCache.cpp +++ b/service/resource-manipulation/modules/resourceCache/src/DataCache.cpp @@ -25,7 +25,7 @@ #include #include -#include "OCApi.h" +//#include "OCApi.h" #include "DataCache.h" @@ -33,209 +33,219 @@ #include "ResourceAttributes.h" #include "ExpiryTimer.h" -DataCache::DataCache( - PrimitiveResourcePtr pResource, - CacheCB func, - REPORT_FREQUENCY rf, - long repeatTime - ):sResource(pResource) +namespace OIC { - subscriberList = std::unique_ptr(new SubscriberInfo()); - - timerInstance = new ExpiryTimer; - state = CACHE_STATE::READY_YET; - - pObserveCB = (ObserveCB)(std::bind(&DataCache::onObserve, this, - std::placeholders::_1, std::placeholders::_2, - std::placeholders::_3, std::placeholders::_4)); - pGetCB = (GetCB)(std::bind(&DataCache::onGet, this, - std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)); - pTimerCB = (TimerCB)(std::bind(&DataCache::onTimer, this, std::placeholders::_1)); - - pResource->requestGet(pGetCB); - if(pResource->isObservable()) + namespace Service { - pResource->requestObserve(pObserveCB); - expiredTimerId = timerInstance->requestTimer(DEFAULT_EXPIRED_TIME, pTimerCB); - } -} + DataCache::DataCache() + { + subscriberList = std::unique_ptr(new SubscriberInfo()); -DataCache::~DataCache() -{ - // TODO Auto-generated destructor stub + sResource = nullptr; - // TODO delete all node!! - subscriberList->clear(); - subscriberList.release(); -} + state = CACHE_STATE::READY_YET; -CacheID DataCache::addSubscriber(CacheCB func, REPORT_FREQUENCY rf, long repeatTime) -{ - Report_Info newItem; - newItem.rf = rf; - newItem.repeatTime = repeatTime; - newItem.timerID = 0; + pObserveCB = (ObserveCB)(std::bind(&DataCache::onObserve, this, + std::placeholders::_1, std::placeholders::_2, + std::placeholders::_3, std::placeholders::_4)); + pGetCB = (GetCB)(std::bind(&DataCache::onGet, this, + std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)); + pTimerCB = (TimerCB)(std::bind(&DataCache::onTimeOut, this, std::placeholders::_1)); + pPollingCB = (TimerCB)(std::bind(&DataCache::onPollingOut, this, std::placeholders::_1)); - srand(time(NULL)); - newItem.reportID = rand(); + } - while(1) - { - if(findSubscriber(newItem.reportID).first != 0 || newItem.reportID == 0) + DataCache::~DataCache() { - newItem.reportID = rand(); + state = CACHE_STATE::DESTROYED; + if(subscriberList != nullptr) + { + subscriberList->clear(); + subscriberList.release(); + } } - else + + void DataCache::initializeDataCache(PrimitiveResourcePtr pResource) { - break; + sResource = pResource; + + sResource->requestGet(pGetCB); + if(sResource->isObservable()) + { + sResource->requestObserve(pObserveCB); + } + networkTimeOutHandle = networkTimer.requestTimer(DEFAULT_EXPIRED_TIME, pTimerCB); } - } - TimerID timerId = timerInstance->requestTimer(repeatTime, pTimerCB); - newItem.timerID = timerId; + CacheID DataCache::addSubscriber(CacheCB func, REPORT_FREQUENCY rf, long repeatTime) + { + Report_Info newItem; + newItem.rf = rf; + newItem.repeatTime = repeatTime; + newItem.timerID = 0; - subscriberList->insert(std::make_pair(newItem.reportID, std::make_pair(newItem, func))); + newItem.reportID = generateCacheID(); + if(subscriberList != nullptr) + { + subscriberList->insert(std::make_pair(newItem.reportID, std::make_pair(newItem, func))); + } - return newItem.reportID; -} + return newItem.reportID; + } -CacheID DataCache::deleteSubscriber(CacheID id) -{ - CacheID ret = 0; + CacheID DataCache::deleteSubscriber(CacheID id) + { + CacheID ret = 0; - SubscriberInfoPair pair = findSubscriber(id); - if(pair.first != 0) - { - ret = pair.first; - subscriberList->erase(pair.first); - } + SubscriberInfoPair pair = findSubscriber(id); + if(pair.first != 0) + { + ret = pair.first; + subscriberList->erase(pair.first); + } - return ret; -} + return ret; + } -SubscriberInfoPair DataCache::findSubscriber(CacheID id) -{ - SubscriberInfoPair ret; + SubscriberInfoPair DataCache::findSubscriber(CacheID id) + { + SubscriberInfoPair ret; - for(auto & i : *subscriberList) - { - if(i.first == id) + for(auto & i : *subscriberList) + { + if(i.first == id) + { + ret = std::make_pair(i.first, std::make_pair((Report_Info)i.second.first, + (CacheCB)i.second.second)); + break; + } + } + + return ret; + } + + const PrimitiveResourcePtr DataCache::getPrimitiveResource() const { - ret = std::make_pair(i.first, std::make_pair((Report_Info)i.second.first, (CacheCB)i.second.second)); + return (sResource!=nullptr)?sResource:nullptr; } - } - return ret; -} + const ResourceAttributes DataCache::getCachedData() const + { + if(state != CACHE_STATE::READY || attributes.empty()) + { + return ResourceAttributes(); + } + const ResourceAttributes retAtt = attributes; + return retAtt; + } -const PrimitiveResourcePtr DataCache::getPrimitiveResource() const -{ - return sResource; -} + void DataCache::onObserve( + const HeaderOptions& _hos, const ResponseStatement& _rep, int _result, int _seq) + { -const ResourceAttributes DataCache::getCachedData() const -{ - if(state != CACHE_STATE::READY) - { - return ResourceAttributes(); - } - const ResourceAttributes retAtt = attributes; + if(_result != OC_STACK_OK || _rep.getAttributes().empty()) + { + return; + } - return retAtt; -} + if(state != CACHE_STATE::READY) + { + state = CACHE_STATE::READY; + } -void DataCache::onObserve( - const HeaderOptions& _hos, const ResponseStatement& _rep, int _result, int _seq) -{ + networkTimer.cancelTimer(networkTimeOutHandle); + networkTimeOutHandle = networkTimer.requestTimer(DEFAULT_EXPIRED_TIME, pTimerCB); - if(_result != OC_STACK_OK) - { - // TODO handle error - return; - } + notifyObservers(_rep.getAttributes()); + } - if(_rep.getAttributes().empty()) - { - return; - } + void DataCache::onGet(const HeaderOptions& _hos, + const ResponseStatement& _rep, int _result) + { + if(_result != OC_STACK_OK || _rep.getAttributes().empty()) + { + return; + } - state = CACHE_STATE::READY; + if(state != CACHE_STATE::READY) + { + state = CACHE_STATE::READY; + } - attributes = _rep.getAttributes(); + if(!sResource->isObservable()) + { + networkTimer.cancelTimer(networkTimeOutHandle); + networkTimeOutHandle = networkTimer.requestTimer(DEFAULT_EXPIRED_TIME, pTimerCB); - if(sResource->isObservable()) - { - timerInstance->cancelTimer(expiredTimerId); - expiredTimerId = timerInstance->requestTimer(DEFAULT_EXPIRED_TIME, pTimerCB); - } + pollingHandle = pollingTimer.requestTimer(DEFAULT_REPORT_TIME, pPollingCB); + } - // notify!! - ResourceAttributes retAtt = attributes; - for(auto & i : * subscriberList) - { - if(i.second.first.rf == REPORT_FREQUENCY::UPTODATE) - { - i.second.second(this->sResource, retAtt); + notifyObservers(_rep.getAttributes()); } - } -} -void DataCache::onGet(const HeaderOptions& _hos, - const ResponseStatement& _rep, int _result) -{ - if(state == CACHE_STATE::READY_YET) - { - state = CACHE_STATE::READY; - attributes = _rep.getAttributes(); - if(sResource->isObservable()) + void DataCache::notifyObservers(ResourceAttributes Att) { - timerInstance->cancelTimer(expiredTimerId); - expiredTimerId = timerInstance->requestTimer(DEFAULT_EXPIRED_TIME, pTimerCB); + if(attributes == Att) + { + return; + } + + attributes = Att; + + ResourceAttributes retAtt = Att; + for(auto & i : * subscriberList) + { + if(i.second.first.rf == REPORT_FREQUENCY::UPTODATE) + { + i.second.second(this->sResource, retAtt); + } + } } - } - else - { - attributes = _rep.getAttributes(); - if(sResource->isObservable()) + + CACHE_STATE DataCache::getCacheState() const { - timerInstance->cancelTimer(expiredTimerId); - expiredTimerId = timerInstance->requestTimer(DEFAULT_EXPIRED_TIME, pTimerCB); + return state; } - ResourceAttributes retAtt = attributes; - for(auto & i : * subscriberList) + void *DataCache::onTimeOut(unsigned int timerID) + { + state = CACHE_STATE::LOST_SIGNAL; + return NULL; + } + void *DataCache::onPollingOut(const unsigned int timerID) { - if(i.second.first.rf != REPORT_FREQUENCY::NONE) + if(sResource != nullptr) { - i.second.second(this->sResource, retAtt); + sResource->requestGet(pGetCB); } + return NULL; } - } -} -CACHE_STATE DataCache::getCacheState() const -{ - return state; -} + CacheID DataCache::generateCacheID() + { + CacheID retID = 0; + srand(time(NULL)); -void *DataCache::onTimer(const unsigned int timerID) -{ - sResource->requestGet(pGetCB); - if(sResource->isObservable()) - { - expiredTimerId = timerInstance->requestTimer(DEFAULT_EXPIRED_TIME, pTimerCB); - } - else - { - for(auto & i : * subscriberList) + while(1) + { + if(findSubscriber(retID).first == 0 && retID != 0) + { + break; + } + retID = rand(); + } + + return retID; + } + + void DataCache::requestGet() { - if(i.second.first.timerID == timerID) + state = CACHE_STATE::UPDATING; + if(sResource != nullptr) { - TimerID timerId = timerInstance->requestTimer(i.second.first.repeatTime, pTimerCB); - i.second.first.timerID = timerId; - break; + sResource->requestGet(pGetCB); } } - } -} \ No newline at end of file + } // namespace Service +} // namespace OIC diff --git a/service/resource-manipulation/modules/resourceCache/src/ResourceCacheManager.cpp b/service/resource-manipulation/modules/resourceCache/src/ResourceCacheManager.cpp index aa36896..416a2c4 100755 --- a/service/resource-manipulation/modules/resourceCache/src/ResourceCacheManager.cpp +++ b/service/resource-manipulation/modules/resourceCache/src/ResourceCacheManager.cpp @@ -20,167 +20,221 @@ #include "ResourceCacheManager.h" -ResourceCacheManager * ResourceCacheManager::s_instance = NULL; -std::mutex ResourceCacheManager::s_mutexForCreation; -std::unique_ptr> ResourceCacheManager::s_cacheDataList(nullptr); - -ResourceCacheManager::ResourceCacheManager() +namespace OIC { - // TODO Auto-generated constructor stub - if(!s_cacheDataList) + namespace Service { - s_cacheDataList = std::unique_ptr>(new std::list); - } -} + ResourceCacheManager * ResourceCacheManager::s_instance = NULL; + std::mutex ResourceCacheManager::s_mutexForCreation; + std::unique_ptr> ResourceCacheManager::s_cacheDataList(nullptr); -ResourceCacheManager::~ResourceCacheManager() -{ - // TODO Auto-generated destructor stub - if(s_cacheDataList) - { - s_cacheDataList->clear(); - } -} + ResourceCacheManager::~ResourceCacheManager() + { + if(s_cacheDataList != nullptr) + { + s_cacheDataList->clear(); + } + } -ResourceCacheManager * ResourceCacheManager::getInstance() -{ - if(s_instance == nullptr) - { - s_mutexForCreation.lock(); - if(s_instance == nullptr) + ResourceCacheManager * ResourceCacheManager::getInstance() { - s_instance = new ResourceCacheManager(); + if(s_instance == nullptr) + { + s_mutexForCreation.lock(); + if(s_instance == nullptr) + { + s_instance = new ResourceCacheManager(); + s_instance->initializeResourceCacheManager(); + } + s_mutexForCreation.unlock(); + } + return s_instance; } - s_mutexForCreation.unlock(); - } - return s_instance; -} - -CacheID ResourceCacheManager::requestResourceCache( - PrimitiveResourcePtr pResource, CacheCB func, - REPORT_FREQUENCY rf, long reportTime) -{ - CacheID retID = 0; - if(rf != REPORT_FREQUENCY::NONE) - { - if(func == NULL) + CacheID ResourceCacheManager::requestResourceCache( + PrimitiveResourcePtr pResource, CacheCB func, + REPORT_FREQUENCY rf, long reportTime) { + if(pResource == nullptr) + { + throw InvalidParameter{"[requestResourceCache] Primitive Resource is invaild"}; + } + + CacheID retID = 0; + + if(rf != REPORT_FREQUENCY::NONE) + { + if(func == NULL || func == nullptr) + { + throw InvalidParameter{"[requestResourceCache] CacheCB is invaild"}; + } + if(!reportTime) + { + // default setting + reportTime = DEFAULT_REPORT_TIME; + } + } + + DataCachePtr newHandler = findDataCache(pResource); + if(newHandler == nullptr) + { + newHandler.reset(new DataCache()); + newHandler->initializeDataCache(pResource); + s_cacheDataList->push_back(newHandler); + } + retID = newHandler->addSubscriber(func, rf, reportTime); + + cacheIDmap.insert(std::make_pair(retID, newHandler)); + return retID; } - if(!reportTime) + + void ResourceCacheManager::cancelResourceCache(CacheID id) { - // default setting - reportTime = DEFAULT_REPORT_TIME; + if(id == 0 || cacheIDmap.find(id) == cacheIDmap.end()) + { + throw InvalidParameter{"[cancelResourceCache] CacheID is invaild"}; + } + + DataCachePtr foundCacheHandler = findDataCache(id); + if(foundCacheHandler != nullptr) + { + CacheID retID = foundCacheHandler->deleteSubscriber(id); + if(retID == id) + { + cacheIDmap.erase(id); + } + } } - } - - DataCachePtr newHandler = findDataCache(pResource); - if(newHandler == nullptr) - { - newHandler = std::make_shared(pResource, func, rf, reportTime); - s_cacheDataList->push_back(newHandler); - } - retID = newHandler->addSubscriber(func, rf, reportTime); - - return retID; -} - -CacheID ResourceCacheManager::cancelResourceCache(CacheID id) -{ - CacheID retID = 0; - if(id == 0) - { - return retID; - } - - DataCachePtr foundCacheHandler = findDataCache(id); - if(foundCacheHandler == nullptr) - { - return retID; - } - else - { - retID = foundCacheHandler->deleteSubscriber(id); - } - - return retID; -} -DataCachePtr ResourceCacheManager::findDataCache(PrimitiveResourcePtr pResource) const -{ - DataCachePtr retHandler = nullptr; - for (auto & i : * s_cacheDataList) - { - if(i->getPrimitiveResource()->getUri() == pResource->getUri() && - i->getPrimitiveResource()->getHost() == pResource->getHost()) + void ResourceCacheManager::updateResourceCache(PrimitiveResourcePtr pResource) const + { + if(pResource == nullptr) + { + throw InvalidParameter{"[updateResourceCache] Primitive Resource is invaild"}; + } + + DataCachePtr foundCache = findDataCache(pResource); + if(foundCache == nullptr) + { + throw InvalidParameter{"[updateResourceCache] Primitive Resource is invaild"}; + } + foundCache->requestGet(); + } + void ResourceCacheManager::updateResourceCache(CacheID updateId) const { - retHandler = i; - break; + if(updateId == 0) + { + throw InvalidParameter{"[getCachedData] CacheID is invaild"}; + } + + DataCachePtr foundCache = findDataCache(updateId); + if(foundCache == nullptr) + { + throw InvalidParameter{"[getCachedData] CacheID is invaild"}; + } + foundCache->requestGet(); } - } - return retHandler; -} -DataCachePtr ResourceCacheManager::findDataCache(CacheID id) const -{ - DataCachePtr retHandler = nullptr; - for (auto & i : * s_cacheDataList) - { - SubscriberInfoPair pair = i->findSubscriber(id); - if(pair.first != 0) + const ResourceAttributes ResourceCacheManager::getCachedData( + PrimitiveResourcePtr pResource) const { - retHandler = i; - break; + if(pResource == nullptr) + { + throw InvalidParameter{"[getCachedData] Primitive Resource is invaild"}; + } + + DataCachePtr handler = findDataCache(pResource); + if(handler == nullptr) + { + throw InvalidParameter{"[getCachedData] Primitive Resource is invaild"}; + } + return handler->getCachedData(); } - } - return retHandler; -} -OCStackResult ResourceCacheManager::updateResourceCache(PrimitiveResourcePtr pResource) -{ - OCStackResult ret = OC_STACK_ERROR; + const ResourceAttributes ResourceCacheManager::getCachedData(CacheID id) const + { + if(id == 0) + { + throw InvalidParameter{"[getCachedData] CacheID is invaild"}; + } + + DataCachePtr handler = findDataCache(id); + if(handler == nullptr) + { + throw InvalidParameter{"[getCachedData] CacheID is invaild"}; + } + return handler->getCachedData(); + } - // TODO update now (request get) + CACHE_STATE ResourceCacheManager::getResourceCacheState( + PrimitiveResourcePtr pResource) const + { + if(pResource == nullptr) + { + throw InvalidParameter{"[getResourceCacheState] Primitive Resource is invaild"}; + } + + DataCachePtr handler = findDataCache(pResource); + if(handler == nullptr) + { + return CACHE_STATE::NONE; + } + return handler->getCacheState(); + } - return ret; -} + CACHE_STATE ResourceCacheManager::getResourceCacheState(CacheID id) const + { + if(id == 0) + { + throw InvalidParameter{"[getResourceCacheState] CacheID is invaild"}; + } + + DataCachePtr handler = findDataCache(id); + if(handler == nullptr) + { + return CACHE_STATE::NONE; + } + return handler->getCacheState(); + } -const ResourceAttributes ResourceCacheManager::getCachedData(PrimitiveResourcePtr pResource) const -{ - DataCachePtr handler = findDataCache(pResource); - if(handler == nullptr) - { - return ResourceAttributes(); - } - return handler->getCachedData(); -} + void ResourceCacheManager::initializeResourceCacheManager() + { + if(s_cacheDataList == nullptr) + { + s_cacheDataList + = std::unique_ptr>(new std::list); + } + } -const ResourceAttributes ResourceCacheManager::getCachedData(CacheID id) const -{ - DataCachePtr handler = findDataCache(id); - if(handler == nullptr) - { - return ResourceAttributes(); - } - return handler->getCachedData(); -} + DataCachePtr ResourceCacheManager::findDataCache(PrimitiveResourcePtr pResource) const + { + DataCachePtr retHandler = nullptr; + for (auto & i : * s_cacheDataList) + { + if(i->getPrimitiveResource()->getUri() == pResource->getUri() && + i->getPrimitiveResource()->getHost() == pResource->getHost()) + { + retHandler = i; + break; + } + } + return retHandler; + } -CACHE_STATE ResourceCacheManager::getResourceCacheState(PrimitiveResourcePtr pResource) const -{ - DataCachePtr handler = findDataCache(pResource); - if(handler == nullptr) - { - return CACHE_STATE::NONE; - } - return handler->getCacheState(); -} -CACHE_STATE ResourceCacheManager::getResourceCacheState(CacheID id) const -{ - DataCachePtr handler = findDataCache(id); - if(handler == nullptr) - { - return CACHE_STATE::NONE; - } - return handler->getCacheState(); -} + DataCachePtr ResourceCacheManager::findDataCache(CacheID id) const + { + DataCachePtr retHandler = nullptr; + for(auto it : cacheIDmap) + { + if(it.first == id) + { + retHandler = it.second; + break; + } + } + + return retHandler; + } + } // namespace Service +} // namespace OIC -- 2.7.4