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())
137 throw RCSInvalidParameterException {"[cancelResourceCache] CacheID is invaild"};
140 if (observeIns != observeCacheIDmap.end())
144 (observeIns->second)->stopCache();
148 (observeIns->second).reset();
149 observeCacheIDmap.erase(id);
153 (observeIns->second).reset();
154 observeCacheIDmap.erase(id);
158 DataCachePtr foundCacheHandler = findDataCache(id);
159 if (foundCacheHandler != nullptr)
161 CacheID retID = foundCacheHandler->deleteSubscriber(id);
164 cacheIDmap.erase(id);
166 if (foundCacheHandler->isEmptySubscriber())
168 s_cacheDataList->remove(foundCacheHandler);
173 void ResourceCacheManager::updateResourceCache(CacheID updateId) const
175 SCOPE_LOG_F(DEBUG, TAG);
179 throw RCSInvalidParameterException {"[updateResourceCache] CacheID is NULL"};
182 DataCachePtr foundCache = findDataCache(updateId);
183 if (foundCache == nullptr)
185 throw RCSInvalidParameterException {"[updateResourceCache] CacheID is invaild"};
187 foundCache->requestGet();
190 const RCSResourceAttributes ResourceCacheManager::getCachedData(CacheID id) const
192 SCOPE_LOG_F(DEBUG, TAG);
196 throw RCSInvalidParameterException {"[getCachedData] CacheID is NULL"};
199 auto observePtr = observeCacheIDmap.find(id);
200 if (observePtr != observeCacheIDmap.end())
202 return (observePtr->second)->getCachedData();
205 DataCachePtr handler = findDataCache(id);
206 if (handler == nullptr)
208 throw RCSInvalidParameterException {"[getCachedData] CacheID is invaild"};
211 if (handler->isCachedData() == false)
213 throw HasNoCachedDataException {"[getCachedData] Cached Data is not stored"};
216 return handler->getCachedData();
219 CACHE_STATE ResourceCacheManager::getResourceCacheState(CacheID id) const
221 SCOPE_LOG_F(DEBUG, TAG);
225 throw RCSInvalidParameterException {"[getResourceCacheState] CacheID is NULL"};
228 auto observePtr = observeCacheIDmap.find(id);
229 if (observePtr != observeCacheIDmap.end())
231 return (observePtr->second)->getCacheState();
234 DataCachePtr handler = findDataCache(id);
235 if (handler == nullptr)
237 return CACHE_STATE::NONE;
239 return handler->getCacheState();
242 bool ResourceCacheManager::isCachedData(CacheID id) const
244 SCOPE_LOG_F(DEBUG, TAG);
248 throw RCSInvalidParameterException {"[isCachedData] CacheID is NULL"};
251 auto observePtr = observeCacheIDmap.find(id);
252 if (observePtr != observeCacheIDmap.end())
254 return (observePtr->second)->isCachedData();
257 DataCachePtr handler = findDataCache(id);
258 if (handler == nullptr)
260 throw RCSInvalidParameterException {"[isCachedData] CacheID is invaild"};
262 return handler->isCachedData();
265 void ResourceCacheManager::initializeResourceCacheManager()
267 SCOPE_LOG_F(DEBUG, TAG);
269 std::lock_guard<std::mutex> lock(s_mutex);
270 if (s_cacheDataList == nullptr)
273 = std::unique_ptr<std::list<DataCachePtr>>(new std::list<DataCachePtr>);
277 DataCachePtr ResourceCacheManager::findDataCache(PrimitiveResourcePtr pResource) const
279 SCOPE_LOG_F(DEBUG, TAG);
281 DataCachePtr retHandler = nullptr;
282 std::lock_guard<std::mutex> lock(s_mutex);
283 for (auto &i : * s_cacheDataList)
285 if (i->getPrimitiveResource()->getUri() == pResource->getUri() &&
286 i->getPrimitiveResource()->getHost() == pResource->getHost())
295 DataCachePtr ResourceCacheManager::findDataCache(CacheID id) const
297 SCOPE_LOG_F(DEBUG, TAG);
299 DataCachePtr retHandler = nullptr;
300 for (auto it : cacheIDmap)
304 retHandler = it.second;
311 } // namespace Service