From 986375e3b383f3478852d740999681ad64da379b Mon Sep 17 00:00:00 2001 From: "jyong2.kim" Date: Fri, 5 Jun 2015 11:30:23 +0900 Subject: [PATCH] Replace ServiceResource with PrimitiveResource for ResourceCache fix class name from ResourceCache to ResourceCacheManager. fix class name from CacheHandler to DataCache. change callback from base to PrimitiveResource. change data model from OCRepresentation to PrimitiveResource::ResponseStatement. Change-Id: I0bb74c3cabb1ad8f30d482c473745130b2b2df38 Signed-off-by: jyong2.kim Reviewed-on: https://gerrit.iotivity.org/gerrit/1195 Tested-by: jenkins-iotivity Reviewed-by: Uze Choi Tested-by: Uze Choi --- service/basis/resourceCache/include/CacheTypes.h | 8 ++--- .../include/{CacheHandler.h => DataCache.h} | 32 ++++++++---------- .../{ResourceCache.h => ResourceCacheManager.h} | 32 +++++++++--------- .../src/{CacheHandler.cpp => DataCache.cpp} | 35 ++++++++++---------- ...{ResourceCache.cpp => ResourceCacheManager.cpp} | 38 +++++++++++----------- 5 files changed, 69 insertions(+), 76 deletions(-) rename service/basis/resourceCache/include/{CacheHandler.h => DataCache.h} (72%) rename service/basis/resourceCache/include/{ResourceCache.h => ResourceCacheManager.h} (66%) rename service/basis/resourceCache/src/{CacheHandler.cpp => DataCache.cpp} (79%) rename service/basis/resourceCache/src/{ResourceCache.cpp => ResourceCacheManager.cpp} (66%) diff --git a/service/basis/resourceCache/include/CacheTypes.h b/service/basis/resourceCache/include/CacheTypes.h index fdc9129..5f312e2 100644 --- a/service/basis/resourceCache/include/CacheTypes.h +++ b/service/basis/resourceCache/include/CacheTypes.h @@ -29,11 +29,9 @@ #include "ocstack.h" #include "OCResource.h" -#include "../include/PrimitiveResource.h" +#include "PrimitiveResource.h" -//class ServiceResource; - -typedef PrimitiveResource ServiceResource; +#define CACHE_TAG PCF("CACHE") enum class REPORT_FREQUENCY { @@ -62,7 +60,7 @@ enum class CACHE_STATE typedef int CacheID; typedef std::map CacheData; -typedef std::function, CacheData)> CacheCB; +typedef std::function, CacheData)> CacheCB; typedef std::map SubscriberInfo; typedef std::pair SubscriberInfoPair; diff --git a/service/basis/resourceCache/include/CacheHandler.h b/service/basis/resourceCache/include/DataCache.h similarity index 72% rename from service/basis/resourceCache/include/CacheHandler.h rename to service/basis/resourceCache/include/DataCache.h index d09555a..7c7d054 100644 --- a/service/basis/resourceCache/include/CacheHandler.h +++ b/service/basis/resourceCache/include/DataCache.h @@ -18,8 +18,8 @@ // //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= -#ifndef CACHEHANDLER_H_ -#define CACHEHANDLER_H_ +#ifndef DATACACHE_H_ +#define DATACACHE_H_ #include #include @@ -31,27 +31,21 @@ #include "CacheTypes.h" -#define CACHE_TAG PCF("CACHE") - -class CacheHandler +class DataCache { public: - CacheHandler( - ServiceResource & pResource, + DataCache( + PrimitiveResource & pResource, CacheCB func, REPORT_FREQUENCY rf, long repeatTime); - ~CacheHandler(); + ~DataCache(); CacheID addSubscriber(CacheCB func, REPORT_FREQUENCY rf, long repeatTime); CacheID deleteSubscriber(CacheID id); std::shared_ptr getCachedData(); - ServiceResource * getServiceResource(); - - // for request to base - OCStackResult requestToNetwork(std::string uri, std::string address, OCMethod method); - OCStackResult requestToNetwork(ServiceResource *pResource, OCMethod method); + PrimitiveResource * getPrimitiveResource(); private: // origin resource info @@ -59,9 +53,11 @@ private: std::string address; // resource instance - ServiceResource *sResource; + PrimitiveResource *sResource; std::shared_ptr baseHandler; + std::shared_ptr attributes; + // cached data info std::shared_ptr data; long updateTime; @@ -72,9 +68,9 @@ private: SubscriberInfoPair findSubscriber(CacheID id); // for requestCB from base - void onObserve(const HeaderOptions& ho, const ResponseStatement& _rep, int _result, int _seq); - void onGet(const OC::HeaderOptions& _ho, - const OC::OCRepresentation& _rep, const int _result); + void onObserve(const HeaderOptions& _hos, + const ResponseStatement& _rep, int _result, int _seq); + void onGet(const HeaderOptions& _hos, const ResponseStatement& _rep, int _result); ObserveCB pObserveCB; GetCB pGetCB; @@ -89,4 +85,4 @@ private: }; -#endif /* CACHEHANDLER_H_ */ +#endif /* DATACACHE_H_ */ diff --git a/service/basis/resourceCache/include/ResourceCache.h b/service/basis/resourceCache/include/ResourceCacheManager.h similarity index 66% rename from service/basis/resourceCache/include/ResourceCache.h rename to service/basis/resourceCache/include/ResourceCacheManager.h index e232be1..bc36d7f 100644 --- a/service/basis/resourceCache/include/ResourceCache.h +++ b/service/basis/resourceCache/include/ResourceCacheManager.h @@ -18,45 +18,45 @@ // //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= -#ifndef RESOURCECACHE_H_ -#define RESOURCECACHE_H_ +#ifndef RESOURCECACHEMANAGER_H_ +#define RESOURCECACHEMANAGER_H_ #include #include -#include "../../../../resource/csdk/stack/include/octypes.h" -#include "CacheHandler.h" +#include "OCPlatform.h" #include "CacheTypes.h" +#include "DataCache.h" #define CACHE_TAG PCF("CACHE") -class ResourceCache +class ResourceCacheManager { public: - ResourceCache * getInstance(); + ResourceCacheManager * getInstance(); CacheID requestResourceCache( - ServiceResource & pResource, + PrimitiveResource & pResource, CacheCB func = NULL, REPORT_FREQUENCY rf = REPORT_FREQUENCY::NONE, long time = 0l); // OCStackResult cancelResourceCache(std::string address, std::string uri); - OCStackResult cancelResourceCache(ServiceResource & pResource, CacheID id); + OCStackResult cancelResourceCache(PrimitiveResource & pResource, CacheID id); // OCStackResult updateResourceCache(std::string address, std::string uri); - OCStackResult updateResourceCache(ServiceResource & pResource); + OCStackResult updateResourceCache(PrimitiveResource & pResource); // OCStackResult getResourceCache(std::string address, std::string uri); - OCStackResult getResourceCache(ServiceResource & pResource); + OCStackResult getResourceCache(PrimitiveResource & pResource); private: - ResourceCache(); - ~ResourceCache(); + ResourceCacheManager(); + ~ResourceCacheManager(); - static ResourceCache * s_instance; + static ResourceCacheManager * s_instance; static std::mutex s_mutexForCreation; - static std::list< CacheHandler * > * s_cacheDataList; + static std::list< DataCache * > * s_cacheDataList; - CacheHandler * findCacheHandler(ServiceResource & pResource); + DataCache * findCacheHandler(PrimitiveResource & pResource); }; -#endif /* RESOURCECACHE_H_ */ +#endif /* RESOURCECACHEMANAGER_H_ */ diff --git a/service/basis/resourceCache/src/CacheHandler.cpp b/service/basis/resourceCache/src/DataCache.cpp similarity index 79% rename from service/basis/resourceCache/src/CacheHandler.cpp rename to service/basis/resourceCache/src/DataCache.cpp index 5d7d3a7..caed5b4 100644 --- a/service/basis/resourceCache/src/CacheHandler.cpp +++ b/service/basis/resourceCache/src/DataCache.cpp @@ -29,23 +29,23 @@ #include "OCApi.h" -CacheHandler::CacheHandler( - ServiceResource & pResource, +DataCache::DataCache( + PrimitiveResource & pResource, CacheCB func, REPORT_FREQUENCY rf, long repeatTime ):sResource(pResource) { subscriberList = new SubscriberInfo(); - data = new(CacheData()); + data = new CacheData(); state = CACHE_STATE::READY_YET; updateTime = 0l; - pObserveCB = (ObserveCB)(std::bind(&CacheHandler::onObserve, this, + pObserveCB = (ObserveCB)(std::bind(&DataCache::onObserve, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4)); - pGetCB = (GetCB)(std::bind(&CacheHandler::onGet, this, + pGetCB = (GetCB)(std::bind(&DataCache::onGet, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)); if(pResource.isObservable()) @@ -58,7 +58,7 @@ CacheHandler::CacheHandler( } } -CacheHandler::~CacheHandler() +DataCache::~DataCache() { // TODO Auto-generated destructor stub data.reset(); @@ -68,7 +68,7 @@ CacheHandler::~CacheHandler() delete subscriberList; } -CacheID CacheHandler::addSubscriber(CacheCB func, REPORT_FREQUENCY rf, long repeatTime) +CacheID DataCache::addSubscriber(CacheCB func, REPORT_FREQUENCY rf, long repeatTime) { Report_Info newItem; newItem.rf = rf; @@ -95,7 +95,7 @@ CacheID CacheHandler::addSubscriber(CacheCB func, REPORT_FREQUENCY rf, long repe return newItem.reportID; } -CacheID CacheHandler::deleteSubscriber(CacheID id) +CacheID DataCache::deleteSubscriber(CacheID id) { CacheID ret = 0; @@ -109,7 +109,7 @@ CacheID CacheHandler::deleteSubscriber(CacheID id) return ret; } -SubscriberInfoPair CacheHandler::findSubscriber(CacheID id) +SubscriberInfoPair DataCache::findSubscriber(CacheID id) { SubscriberInfoPair ret = nullptr; @@ -124,7 +124,7 @@ SubscriberInfoPair CacheHandler::findSubscriber(CacheID id) return ret; } -std::shared_ptr CacheHandler::getCachedData() +std::shared_ptr DataCache::getCachedData() { if(state != CACHE_STATE::READY) { @@ -133,9 +133,9 @@ std::shared_ptr CacheHandler::getCachedData() return data; } -ServiceResource * CacheHandler::getServiceResource() +PrimitiveResource * DataCache::getPrimitiveResource() { - ServiceResource ret = NULL; + PrimitiveResource ret = NULL; if(sResource) { ret = sResource; @@ -144,8 +144,8 @@ ServiceResource * CacheHandler::getServiceResource() return ret; } -void CacheHandler::onObserve( - const HeaderOptions& ho, const ResponseStatement& _rep, int _result, int _seq) +void DataCache::onObserve( + const HeaderOptions& _hos, const ResponseStatement& _rep, int _result, int _seq) { if(_result != OC_STACK_OK) @@ -153,7 +153,6 @@ void CacheHandler::onObserve( // TODO handle error return; } -// if(_rep.empty() || _rep.emptyData()) if(_rep.getAttributes().isEmpty()) { return; @@ -163,12 +162,12 @@ void CacheHandler::onObserve( // set data data->clear(); - OC::OCRepresentation::iterator it = att.begin(); + ResourceAttributes::iterator it = att.begin(); for(; att.end(); ++it) { - std::string key = it->attrname(); + std::string key = it->key(); // TODO change template or variant - std::string val = it->getValueToString(); + std::string val = it->value(); data[key] = val; } diff --git a/service/basis/resourceCache/src/ResourceCache.cpp b/service/basis/resourceCache/src/ResourceCacheManager.cpp similarity index 66% rename from service/basis/resourceCache/src/ResourceCache.cpp rename to service/basis/resourceCache/src/ResourceCacheManager.cpp index 01885e9..e5bcf2a 100644 --- a/service/basis/resourceCache/src/ResourceCache.cpp +++ b/service/basis/resourceCache/src/ResourceCacheManager.cpp @@ -18,22 +18,22 @@ // //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= -#include "ResourceCache.h" +#include "ResourceCacheManager.h" -ResourceCache * ResourceCache::s_instance = NULL; -std::mutex ResourceCache::s_mutexForCreation; -std::list< CacheHandler * > * ResourceCache::s_cacheDataList = NULL; +ResourceCacheManager * ResourceCacheManager::s_instance = NULL; +std::mutex ResourceCacheManager::s_mutexForCreation; +std::list< DataCache * > * ResourceCacheManager::s_cacheDataList = NULL; -ResourceCache::ResourceCache() +ResourceCacheManager::ResourceCacheManager() { // TODO Auto-generated constructor stub if(!s_cacheDataList) { - s_cacheDataList = new std::list< CacheHandler * >(); + s_cacheDataList = new std::list< DataCache * >(); } } -ResourceCache::~ResourceCache() +ResourceCacheManager::~ResourceCacheManager() { // TODO Auto-generated destructor stub if(s_cacheDataList) @@ -44,22 +44,22 @@ ResourceCache::~ResourceCache() } -ResourceCache * ResourceCache::getInstance() +ResourceCacheManager * ResourceCacheManager::getInstance() { if(!s_instance) { s_mutexForCreation.lock(); if(!s_instance) { - s_instance = new ResourceCache(); + s_instance = new ResourceCacheManager(); } s_mutexForCreation.unlock(); } return s_instance; } -CacheID ResourceCache::requestResourceCache( - ServiceResource & pResource, CacheCB func, REPORT_FREQUENCY rf, long reportTime) +CacheID ResourceCacheManager::requestResourceCache( + PrimitiveResource & pResource, CacheCB func, REPORT_FREQUENCY rf, long reportTime) { CacheID ret = 0; @@ -81,10 +81,10 @@ CacheID ResourceCache::requestResourceCache( } } - CacheHandler * newHandler = findCacheHandler(pResource); + DataCache * newHandler = findCacheHandler(pResource); if(newHandler == nullptr) { - CacheHandler * newHandler = new CacheHandler(pResource, func, rf, reportTime); + DataCache * newHandler = new DataCache(pResource, func, rf, reportTime); s_cacheDataList->push_back(newHandler); } ret = newHandler->addSubscriber(func, rf, reportTime); @@ -92,7 +92,7 @@ CacheID ResourceCache::requestResourceCache( return ret; } -OCStackResult ResourceCache::cancelResourceCache(ServiceResource & pResource, CacheID id) +OCStackResult ResourceCacheManager::cancelResourceCache(PrimitiveResource & pResource, CacheID id) { OCStackResult ret = OC_STACK_ERROR; @@ -103,7 +103,7 @@ OCStackResult ResourceCache::cancelResourceCache(ServiceResource & pResource, Ca // TODO cancel cache CacheID retID = 0; - CacheHandler * deleteCacheHandler = findCacheHandler(pResource); + DataCache * deleteCacheHandler = findCacheHandler(pResource); if(deleteCacheHandler == nullptr) { return ret; @@ -121,12 +121,12 @@ OCStackResult ResourceCache::cancelResourceCache(ServiceResource & pResource, Ca return ret; } -CacheHandler * ResourceCache::findCacheHandler(ServiceResource & pResource) +DataCache * ResourceCacheManager::findCacheHandler(PrimitiveResource & pResource) { - CacheHandler * retHandler = nullptr; + DataCache * retHandler = nullptr; for (auto i : s_cacheDataList) { - if(i->getServiceResource() == pResource) + if(i->getPrimitiveResource() == pResource) { retHandler = i; break; @@ -135,7 +135,7 @@ CacheHandler * ResourceCache::findCacheHandler(ServiceResource & pResource) return retHandler; } -OCStackResult ResourceCache::updateResourceCache(ServiceResource & pResource) +OCStackResult ResourceCacheManager::updateResourceCache(PrimitiveResource & pResource) { OCStackResult ret = OC_STACK_ERROR; -- 2.7.4