1 //******************************************************************
3 // Copyright 2015 Samsung Electronics All Rights Reserved.
5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
7 // Licensed under the Apache License, Version 2.0 (the "License");
8 // you may not use this file except in compliance with the License.
9 // You may obtain a copy of the License at
11 // http://www.apache.org/licenses/LICENSE-2.0
13 // Unless required by applicable law or agreed to in writing, software
14 // distributed under the License is distributed on an "AS IS" BASIS,
15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 // See the License for the specific language governing permissions and
17 // limitations under the License.
19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
21 #include "ResourceCacheManager.h"
22 #include "RCSException.h"
25 #include "ScopeLogger.h"
27 #define TAG PCF("RCSResourceCacheManager")
33 ResourceCacheManager *ResourceCacheManager::s_instance = NULL;
34 std::mutex ResourceCacheManager::s_mutexForCreation;
35 std::mutex ResourceCacheManager::s_mutex;
36 std::unique_ptr<std::list<DataCachePtr>> ResourceCacheManager::s_cacheDataList(nullptr);
38 ResourceCacheManager::~ResourceCacheManager()
40 std::lock_guard<std::mutex> lock(s_mutex);
41 if (s_cacheDataList != nullptr)
43 s_cacheDataList->clear();
47 ResourceCacheManager *ResourceCacheManager::getInstance()
49 if (s_instance == nullptr)
51 s_mutexForCreation.lock();
52 if (s_instance == nullptr)
54 s_instance = new ResourceCacheManager();
55 s_instance->initializeResourceCacheManager();
57 s_mutexForCreation.unlock();
62 CacheID ResourceCacheManager::requestResourceCache(
63 PrimitiveResourcePtr pResource, CacheCB func, CACHE_METHOD cm,
64 REPORT_FREQUENCY rf, long reportTime)
66 SCOPE_LOG_F(DEBUG, TAG);
68 if (pResource == nullptr)
70 throw RCSInvalidParameterException {"[requestResourceCache] Primitive Resource is invaild"};
75 if (cm == CACHE_METHOD::OBSERVE_ONLY)
77 if (func == NULL || func == nullptr)
79 throw RCSInvalidParameterException {"[requestResourceCache] CacheCB is invaild"};
82 std::lock_guard<std::mutex> lock(s_mutex);
83 retID = OCGetRandom();
84 while(observeCacheIDmap.find(retID) != observeCacheIDmap.end())
86 retID = OCGetRandom();
89 auto newHandler = std::make_shared<ObserveCache>(pResource);
90 newHandler->startCache(std::move(func));
92 observeCacheIDmap.insert(std::make_pair(retID, newHandler));
96 if (rf != REPORT_FREQUENCY::NONE)
98 if (func == NULL || func == nullptr)
100 throw RCSInvalidParameterException {"[requestResourceCache] CacheCB is invaild"};
105 reportTime = CACHE_DEFAULT_REPORT_MILLITIME;
109 DataCachePtr newHandler = findDataCache(pResource);
110 if (newHandler == nullptr)
112 std::lock_guard<std::mutex> lock(s_mutex);
113 newHandler.reset(new DataCache());
114 newHandler->initializeDataCache(pResource);
115 s_cacheDataList->push_back(newHandler);
118 std::lock_guard<std::mutex> lock(s_mutex);
119 retID = newHandler->addSubscriber(func, rf, reportTime);
121 cacheIDmap.insert(std::make_pair(retID, newHandler));
126 void ResourceCacheManager::cancelResourceCache(CacheID id)
128 SCOPE_LOG_F(DEBUG, TAG);
129 std::lock_guard<std::mutex> lock(s_mutex);
131 auto observeIns = observeCacheIDmap.find(id);
132 auto dataCacheIns = cacheIDmap.find(id);
133 if ((dataCacheIns == cacheIDmap.end() && observeIns == observeCacheIDmap.end())
136 throw RCSInvalidParameterException {"[cancelResourceCache] CacheID is invaild"};
139 if (observeIns != observeCacheIDmap.end())
143 (observeIns->second)->stopCache();
147 (observeIns->second).reset();
148 observeCacheIDmap.erase(id);
151 (observeIns->second).reset();
152 observeCacheIDmap.erase(id);
156 DataCachePtr foundCacheHandler = findDataCache(id);
157 if (foundCacheHandler != nullptr)
159 CacheID retID = foundCacheHandler->deleteSubscriber(id);
162 cacheIDmap.erase(id);
164 if (foundCacheHandler->isEmptySubscriber())
166 s_cacheDataList->remove(foundCacheHandler);
171 void ResourceCacheManager::updateResourceCache(CacheID updateId) const
173 SCOPE_LOG_F(DEBUG, TAG);
177 throw RCSInvalidParameterException {"[updateResourceCache] CacheID is NULL"};
180 DataCachePtr foundCache = findDataCache(updateId);
181 if (foundCache == nullptr)
183 throw RCSInvalidParameterException {"[updateResourceCache] CacheID is invaild"};
185 foundCache->requestGet();
188 const RCSResourceAttributes ResourceCacheManager::getCachedData(CacheID id) const
190 SCOPE_LOG_F(DEBUG, TAG);
194 throw RCSInvalidParameterException {"[getCachedData] CacheID is NULL"};
197 auto observePtr = observeCacheIDmap.find(id);
198 if (observePtr != observeCacheIDmap.end())
200 return (observePtr->second)->getCachedData();
203 DataCachePtr handler = findDataCache(id);
204 if (handler == nullptr)
206 throw RCSInvalidParameterException {"[getCachedData] CacheID is invaild"};
209 if (handler->isCachedData() == false)
211 throw HasNoCachedDataException {"[getCachedData] Cached Data is not stored"};
214 return handler->getCachedData();
217 CACHE_STATE ResourceCacheManager::getResourceCacheState(CacheID id) const
219 SCOPE_LOG_F(DEBUG, TAG);
223 throw RCSInvalidParameterException {"[getResourceCacheState] CacheID is NULL"};
226 auto observePtr = observeCacheIDmap.find(id);
227 if (observePtr != observeCacheIDmap.end())
229 return (observePtr->second)->getCacheState();
232 DataCachePtr handler = findDataCache(id);
233 if (handler == nullptr)
235 return CACHE_STATE::NONE;
237 return handler->getCacheState();
240 bool ResourceCacheManager::isCachedData(CacheID id) const
242 SCOPE_LOG_F(DEBUG, TAG);
246 throw RCSInvalidParameterException {"[isCachedData] CacheID is NULL"};
249 auto observePtr = observeCacheIDmap.find(id);
250 if (observePtr != observeCacheIDmap.end())
252 return (observePtr->second)->isCachedData();
255 DataCachePtr handler = findDataCache(id);
256 if (handler == nullptr)
258 throw RCSInvalidParameterException {"[isCachedData] CacheID is invaild"};
260 return handler->isCachedData();
263 void ResourceCacheManager::initializeResourceCacheManager()
265 SCOPE_LOG_F(DEBUG, TAG);
267 std::lock_guard<std::mutex> lock(s_mutex);
268 if (s_cacheDataList == nullptr)
271 = std::unique_ptr<std::list<DataCachePtr>>(new std::list<DataCachePtr>);
275 DataCachePtr ResourceCacheManager::findDataCache(PrimitiveResourcePtr pResource) const
277 SCOPE_LOG_F(DEBUG, TAG);
279 DataCachePtr retHandler = nullptr;
280 std::lock_guard<std::mutex> lock(s_mutex);
281 for (auto &i : * s_cacheDataList)
283 if (i->getPrimitiveResource()->getUri() == pResource->getUri() &&
284 i->getPrimitiveResource()->getHost() == pResource->getHost())
293 DataCachePtr ResourceCacheManager::findDataCache(CacheID id) const
295 SCOPE_LOG_F(DEBUG, TAG);
297 DataCachePtr retHandler = nullptr;
298 for (auto it : cacheIDmap)
302 retHandler = it.second;
309 } // namespace Service