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 <jyong2.kim@samsung.com>
Reviewed-on: https://gerrit.iotivity.org/gerrit/1195
Tested-by: jenkins-iotivity <jenkins-iotivity@opendaylight.org>
Reviewed-by: Uze Choi <uzchoi@samsung.com>
Tested-by: Uze Choi <uzchoi@samsung.com>

diff --git a/service/basis/resourceCache/include/CacheTypes.h b/service/basis/resourceCache/include/CacheTypes.h
index fdc9129..5f312e2 100644 (file)
--- 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<std::string, std::string> CacheData;
-typedef std::function<OCStackResult(std::shared_ptr<ServiceResource>, CacheData)> CacheCB;
+typedef std::function<OCStackResult(std::shared_ptr<PrimitiveResource>, CacheData)> CacheCB;
 typedef std::map<Report_Info, CacheCB> SubscriberInfo;
 typedef std::pair<Report_Info, CacheCB> 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 (file)
--- 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 <list>
 #include <memory>
@@ -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<CacheData> 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<BaseResource> baseHandler;
 
+    std::shared_ptr<ResourceAttributes> attributes;
+
     // cached data info
     std::shared_ptr<CacheData> 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 (file)
--- 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 <list>
 #include <string>
 
-#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 (file)
--- 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<CacheData> CacheHandler::getCachedData()
+std::shared_ptr<CacheData> DataCache::getCachedData()
 {
     if(state != CACHE_STATE::READY)
     {
@@ -133,9 +133,9 @@ std::shared_ptr<CacheData> 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 (file)
--- 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;