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>
#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
{
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;
//
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-#ifndef CACHEHANDLER_H_
-#define CACHEHANDLER_H_
+#ifndef DATACACHE_H_
+#define DATACACHE_H_
#include <list>
#include <memory>
#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
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;
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;
};
-#endif /* CACHEHANDLER_H_ */
+#endif /* DATACACHE_H_ */
//
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-#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_ */
#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())
}
}
-CacheHandler::~CacheHandler()
+DataCache::~DataCache()
{
// TODO Auto-generated destructor stub
data.reset();
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;
return newItem.reportID;
}
-CacheID CacheHandler::deleteSubscriber(CacheID id)
+CacheID DataCache::deleteSubscriber(CacheID id)
{
CacheID ret = 0;
return ret;
}
-SubscriberInfoPair CacheHandler::findSubscriber(CacheID id)
+SubscriberInfoPair DataCache::findSubscriber(CacheID id)
{
SubscriberInfoPair ret = nullptr;
return ret;
}
-std::shared_ptr<CacheData> CacheHandler::getCachedData()
+std::shared_ptr<CacheData> DataCache::getCachedData()
{
if(state != CACHE_STATE::READY)
{
return data;
}
-ServiceResource * CacheHandler::getServiceResource()
+PrimitiveResource * DataCache::getPrimitiveResource()
{
- ServiceResource ret = NULL;
+ PrimitiveResource ret = NULL;
if(sResource)
{
ret = sResource;
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)
// TODO handle error
return;
}
-// if(_rep.empty() || _rep.emptyData())
if(_rep.getAttributes().isEmpty())
{
return;
// 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;
}
//
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-#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)
}
-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;
}
}
- 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);
return ret;
}
-OCStackResult ResourceCache::cancelResourceCache(ServiceResource & pResource, CacheID id)
+OCStackResult ResourceCacheManager::cancelResourceCache(PrimitiveResource & pResource, CacheID id)
{
OCStackResult ret = OC_STACK_ERROR;
// TODO cancel cache
CacheID retID = 0;
- CacheHandler * deleteCacheHandler = findCacheHandler(pResource);
+ DataCache * deleteCacheHandler = findCacheHandler(pResource);
if(deleteCacheHandler == nullptr)
{
return ret;
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;
return retHandler;
}
-OCStackResult ResourceCache::updateResourceCache(ServiceResource & pResource)
+OCStackResult ResourceCacheManager::updateResourceCache(PrimitiveResource & pResource)
{
OCStackResult ret = OC_STACK_ERROR;