MemoryStorageService(const DOMElement* e);\r
virtual ~MemoryStorageService();\r
\r
- void createString(const char* key, const char* value, time_t expiration);\r
- bool readString(const char* key, string& value, time_t modifiedSince=0);\r
- bool updateString(const char* key, const char* value=NULL, time_t expiration=0);\r
- bool deleteString(const char* key);\r
+ StorageHandle* createHandle();\r
\r
- void createText(const char* key, const char* value, time_t expiration) {\r
- return createString(key, value, expiration);\r
+ void createString(StorageHandle* handle, const char* key, const char* value, time_t expiration);\r
+ bool readString(StorageHandle* handle, const char* key, string& value, time_t modifiedSince=0);\r
+ bool updateString(StorageHandle* handle, const char* key, const char* value=NULL, time_t expiration=0);\r
+ bool deleteString(StorageHandle* handle, const char* key);\r
+ \r
+ void createText(StorageHandle* handle, const char* key, const char* value, time_t expiration) {\r
+ return createString(handle, key, value, expiration);\r
}\r
- bool readText(const char* key, string& value, time_t modifiedSince=0) {\r
- return readString(key, value, modifiedSince);\r
+ bool readText(StorageHandle* handle, const char* key, string& value, time_t modifiedSince=0) {\r
+ return readString(handle, key, value, modifiedSince);\r
}\r
- bool updateText(const char* key, const char* value=NULL, time_t expiration=0) {\r
- return updateString(key, value, expiration);\r
+ bool updateText(StorageHandle* handle, const char* key, const char* value=NULL, time_t expiration=0) {\r
+ return updateString(handle, key, value, expiration);\r
}\r
- bool deleteText(const char* key) {\r
- return deleteString(key);\r
+ bool deleteText(StorageHandle* handle, const char* key) {\r
+ return deleteString(handle, key);\r
}\r
\r
- void reap() {\r
- shutdown_wait->signal();\r
- }\r
+ void reap(StorageHandle* handle);\r
+\r
+ void removeHandle(StorageHandle* handle);\r
\r
private:\r
void cleanup();\r
time_t modified, expiration;\r
};\r
\r
- map<string,Record> m_dataMap;\r
- multimap<time_t,string> m_expMap;\r
- RWLock* m_lock;\r
+ struct XMLTOOL_DLLLOCAL MemoryHandle : public StorageHandle {\r
+ MemoryHandle(StorageService* storage) : StorageHandle(storage), m_lock(RWLock::create()) {}\r
+ virtual ~MemoryHandle() {\r
+ delete m_lock;\r
+ static_cast<MemoryStorageService*>(m_storage)->removeHandle(this);\r
+ }\r
+ map<string,Record> m_dataMap;\r
+ multimap<time_t,string> m_expMap;\r
+ RWLock* m_lock;\r
+ unsigned long reap();\r
+ };\r
+ \r
+ vector<MemoryHandle*> m_handles;\r
+ Mutex* mutex;\r
CondWait* shutdown_wait;\r
Thread* cleanup_thread;\r
static void* cleanup_fn(void*);\r
static const XMLCh cleanupInterval[] = UNICODE_LITERAL_15(c,l,e,a,n,u,p,I,n,t,e,r,v,a,l);\r
\r
MemoryStorageService::MemoryStorageService(const DOMElement* e)\r
- : m_lock(NULL), shutdown_wait(NULL), cleanup_thread(NULL), shutdown(false), m_cleanupInterval(0),\r
+ : mutex(NULL), shutdown_wait(NULL), cleanup_thread(NULL), shutdown(false), m_cleanupInterval(0),\r
m_log(Category::getInstance(XMLTOOLING_LOGCAT".StorageService"))\r
{\r
- m_lock = RWLock::create();\r
+ mutex = Mutex::create();\r
shutdown_wait = CondWait::create();\r
cleanup_thread = Thread::create(&cleanup_fn, (void*)this);\r
\r
shutdown_wait->signal();\r
cleanup_thread->join(NULL);\r
\r
- delete m_lock;\r
delete shutdown_wait;\r
+ delete mutex;\r
+ for_each(m_handles.begin(), m_handles.end(), xmltooling::cleanup<MemoryHandle>());\r
+}\r
+\r
+StorageService::StorageHandle* MemoryStorageService::createHandle()\r
+{\r
+ Lock wrapper(mutex);\r
+ MemoryHandle* ret = new MemoryHandle(this);\r
+ m_handles.push_back(ret);\r
+ return ret;\r
+}\r
+\r
+void MemoryStorageService::removeHandle(StorageHandle* handle)\r
+{\r
+ Lock wrapper(mutex);\r
+ for (vector<MemoryHandle*>::iterator i=m_handles.begin(); i!=m_handles.end(); ++i) {\r
+ if (*i == handle) {\r
+ m_handles.erase(i);\r
+ return;\r
+ }\r
+ }\r
}\r
\r
void* MemoryStorageService::cleanup_fn(void* cache_p)\r
shutdown_wait->timedwait(mutex, m_cleanupInterval);\r
if (shutdown)\r
break;\r
-\r
- // Lock the "database".\r
- m_lock->wrlock();\r
- \r
- // Garbage collect any expired entries.\r
- unsigned int count=0;\r
- time_t now=time(NULL)-XMLToolingConfig::getConfig().clock_skew_secs;\r
- multimap<time_t,string>::iterator stop=m_expMap.upper_bound(now);\r
- for (multimap<time_t,string>::iterator i=m_expMap.begin(); i!=stop; m_expMap.erase(i++)) {\r
- m_dataMap.erase(i->second);\r
- ++count;\r
- }\r
\r
- m_lock->unlock();\r
+ unsigned long count=0;\r
+ for (vector<MemoryHandle*>::iterator i=m_handles.begin(); i!=m_handles.end(); ++i)\r
+ count += (*i)->reap();\r
\r
if (count)\r
m_log.info("purged %d record(s) from storage", count);\r
Thread::exit(NULL);\r
}\r
\r
-void MemoryStorageService::createString(const char* key, const char* value, time_t expiration)\r
+void MemoryStorageService::reap(StorageHandle* handle)\r
{\r
- // Lock the maps.\r
+ if (!isValid(handle))\r
+ throw IOException("Invalid storage handle.");\r
+ static_cast<MemoryHandle*>(handle)->reap();\r
+}\r
+\r
+unsigned long MemoryStorageService::MemoryHandle::reap()\r
+{\r
+ // Lock the "database".\r
m_lock->wrlock();\r
SharedLock wrapper(m_lock, false);\r
\r
+ // Garbage collect any expired entries.\r
+ unsigned long count=0;\r
+ time_t now=time(NULL)-XMLToolingConfig::getConfig().clock_skew_secs;\r
+ multimap<time_t,string>::iterator stop=m_expMap.upper_bound(now);\r
+ for (multimap<time_t,string>::iterator i=m_expMap.begin(); i!=stop; m_expMap.erase(i++)) {\r
+ m_dataMap.erase(i->second);\r
+ ++count;\r
+ }\r
+\r
+ return count;\r
+}\r
+\r
+void MemoryStorageService::createString(StorageHandle* handle, const char* key, const char* value, time_t expiration)\r
+{\r
+ if (!isValid(handle))\r
+ throw IOException("Invalid storage handle.");\r
+ MemoryHandle* h = static_cast<MemoryHandle*>(handle);\r
+\r
+ // Lock the maps.\r
+ h->m_lock->wrlock();\r
+ SharedLock wrapper(h->m_lock, false);\r
+ \r
// Check for a duplicate.\r
- map<string,Record>::iterator i=m_dataMap.find(key);\r
- if (i!=m_dataMap.end())\r
+ map<string,Record>::iterator i=h->m_dataMap.find(key);\r
+ if (i!=h->m_dataMap.end())\r
throw IOException("attempted to insert a record with duplicate key ($1)", params(1,key));\r
\r
- m_dataMap[key]=Record(value,time(NULL),expiration);\r
- m_expMap.insert(multimap<time_t,string>::value_type(expiration,key));\r
+ h->m_dataMap[key]=Record(value,time(NULL),expiration);\r
+ h->m_expMap.insert(multimap<time_t,string>::value_type(expiration,key));\r
\r
m_log.debug("inserted record (%s)", key);\r
}\r
\r
-bool MemoryStorageService::readString(const char* key, string& value, time_t modifiedSince)\r
+bool MemoryStorageService::readString(StorageHandle* handle, const char* key, string& value, time_t modifiedSince)\r
{\r
- SharedLock wrapper(m_lock);\r
- map<string,Record>::iterator i=m_dataMap.find(key);\r
- if (i==m_dataMap.end())\r
+ if (!isValid(handle))\r
+ throw IOException("Invalid storage handle.");\r
+ MemoryHandle* h = static_cast<MemoryHandle*>(handle);\r
+\r
+ SharedLock wrapper(h->m_lock);\r
+ map<string,Record>::iterator i=h->m_dataMap.find(key);\r
+ if (i==h->m_dataMap.end())\r
return false;\r
else if (modifiedSince >= i->second.modified)\r
return false;\r
return true;\r
}\r
\r
-bool MemoryStorageService::updateString(const char* key, const char* value, time_t expiration)\r
+bool MemoryStorageService::updateString(StorageHandle* handle, const char* key, const char* value, time_t expiration)\r
{\r
+ if (!isValid(handle))\r
+ throw IOException("Invalid storage handle.");\r
+ MemoryHandle* h = static_cast<MemoryHandle*>(handle);\r
+\r
// Lock the maps.\r
- m_lock->wrlock();\r
- SharedLock wrapper(m_lock, false);\r
+ h->m_lock->wrlock();\r
+ SharedLock wrapper(h->m_lock, false);\r
\r
- map<string,Record>::iterator i=m_dataMap.find(key);\r
- if (i==m_dataMap.end())\r
+ map<string,Record>::iterator i=h->m_dataMap.find(key);\r
+ if (i==h->m_dataMap.end())\r
return false;\r
\r
if (value)\r
\r
if (expiration && expiration != i->second.expiration) {\r
// Update secondary map.\r
- pair<multimap<time_t,string>::iterator,multimap<time_t,string>::iterator> range=m_expMap.equal_range(i->second.expiration);\r
+ pair<multimap<time_t,string>::iterator,multimap<time_t,string>::iterator> range =\r
+ h->m_expMap.equal_range(i->second.expiration);\r
for (; range.first != range.second; ++range.first) {\r
if (range.first->second == i->first) {\r
- m_expMap.erase(range.first);\r
+ h->m_expMap.erase(range.first);\r
break;\r
}\r
}\r
i->second.expiration = expiration;\r
- m_expMap.insert(multimap<time_t,string>::value_type(expiration,key));\r
+ h->m_expMap.insert(multimap<time_t,string>::value_type(expiration,key));\r
}\r
\r
i->second.modified = time(NULL);\r
return true;\r
}\r
\r
-bool MemoryStorageService::deleteString(const char* key)\r
+bool MemoryStorageService::deleteString(StorageHandle* handle, const char* key)\r
{\r
+ if (!isValid(handle))\r
+ throw IOException("Invalid storage handle.");\r
+ MemoryHandle* h = static_cast<MemoryHandle*>(handle);\r
+\r
// Lock the maps.\r
- m_lock->wrlock();\r
- SharedLock wrapper(m_lock, false);\r
+ h->m_lock->wrlock();\r
+ SharedLock wrapper(h->m_lock, false);\r
\r
// Find the record.\r
- map<string,Record>::iterator i=m_dataMap.find(key);\r
- if (i!=m_dataMap.end()) {\r
+ map<string,Record>::iterator i=h->m_dataMap.find(key);\r
+ if (i!=h->m_dataMap.end()) {\r
// Now find the reversed index of expiration to key, so we can clear it.\r
- pair<multimap<time_t,string>::iterator,multimap<time_t,string>::iterator> range=m_expMap.equal_range(i->second.expiration);\r
+ pair<multimap<time_t,string>::iterator,multimap<time_t,string>::iterator> range =\r
+ h->m_expMap.equal_range(i->second.expiration);\r
for (; range.first != range.second; ++range.first) {\r
if (range.first->second == i->first) {\r
- m_expMap.erase(range.first);\r
+ h->m_expMap.erase(range.first);\r
break;\r
}\r
}\r
// And finally delete the record itself.\r
- m_dataMap.erase(i);\r
+ h->m_dataMap.erase(i);\r
m_log.debug("deleted record (%s)", key);\r
return true;\r
}\r