Commit 86650843 authored by Matthieu Dorier's avatar Matthieu Dorier

removing the use of boost if type is POD

parent 41e684e6
......@@ -162,10 +162,8 @@ class DataSet : public KeyValueContainer {
* @return a valid ProductID if the key did not already exist and the write succeeded,
* an invalid one otherwise.
*/
ProductID storeRawData(const std::string& key, const std::string& value) override;
ProductID storeRawData(std::string&& key, std::string&& value) override;
ProductID storeRawData(WriteBatch& batch, const std::string& key, const std::string& value) override;
ProductID storeRawData(WriteBatch& batch, std::string&& key, std::string&& value) override;
ProductID storeRawData(const std::string& key, const char* value, size_t vsize) override;
ProductID storeRawData(WriteBatch& batch, const std::string& key, const char* value, size_t vsize) override;
/**
* @brief Loads binary data associated with a particular key from the DataSet.
......@@ -179,6 +177,7 @@ class DataSet : public KeyValueContainer {
* false otherwise.
*/
bool loadRawData(const std::string& key, std::string& value) const override;
bool loadRawData(const std::string& key, char* value, size_t* vsize) const override;
/**
* @brief Comparison operator.
......
......@@ -330,6 +330,13 @@ class DataStore {
* @return true if the data was loaded successfuly, false otherwise.
*/
bool loadRawProduct(const ProductID& productID, std::string& buffer);
bool loadRawProduct(const ProductID& productID, char* value, size_t* value_size);
template<typename T>
bool loadProductImpl(const ProductID& productID, T& t, const std::integral_constant<bool, false>&);
template<typename T>
bool loadProductImpl(const ProductID& productID, T& t, const std::integral_constant<bool, true>&);
};
class DataStore::const_iterator {
......@@ -574,6 +581,11 @@ Ptr<T,C> DataStore::makePtr(const ProductID& productID, std::size_t index) {
template<typename T>
bool DataStore::loadProduct(const ProductID& productID, T& t) {
return loadProductImpl(productID, t, std::is_pod<T>());
}
template<typename T>
bool DataStore::loadProductImpl(const ProductID& productID, T& t, const std::integral_constant<bool, false>&) {
std::string buffer;
if(!loadRawProduct(productID, buffer)) {
return false;
......@@ -589,6 +601,16 @@ bool DataStore::loadProduct(const ProductID& productID, T& t) {
return true;
}
template<typename T>
bool DataStore::loadProductImpl(const ProductID& productID, T& t, const std::integral_constant<bool, true>&) {
size_t value_size = sizeof(t);
if(loadRawProduct(productID, reinterpret_cast<char*>(&t), &value_size)) {
return value_size == sizeof(t);
} else {
return false;
}
}
}
#endif
......@@ -109,10 +109,8 @@ class Event : public KeyValueContainer {
*
* @return a valid ProductID if the key did not already exist, an invalid one otherwise.
*/
ProductID storeRawData(const std::string& key, const std::string& value) override;
ProductID storeRawData(std::string&& key, std::string&& value) override;
ProductID storeRawData(WriteBatch& batch, const std::string& key, const std::string& value) override;
ProductID storeRawData(WriteBatch& batch, std::string&& key, std::string&& value) override;
ProductID storeRawData(const std::string& key, const char* value, size_t vsize) override;
ProductID storeRawData(WriteBatch& batch, const std::string& key, const char* value, size_t vsize) override;
/**
* @brief Loads raw key/value data from this Event.
......@@ -123,6 +121,7 @@ class Event : public KeyValueContainer {
* @return true if the key exists, false otherwise.
*/
bool loadRawData(const std::string& key, std::string& value) const override;
bool loadRawData(const std::string& key, char* value, size_t* vsize) const override;
/**
* @brief Compares this Event with another Event. The Events must point to
......
......@@ -67,17 +67,25 @@ class KeyValueContainer {
* This function is virtual and must be overloaded in the child class.
*
* @param key Key
* @param buffer Value
* @param value Value pointer
* @param vsize Value size (in bytes)
*
* @return A valid ProductID if the key did not already exist, an invalid one otherwise.
*/
virtual ProductID storeRawData(const std::string& key, const std::string& value) = 0;
virtual ProductID storeRawData(const std::string& key, const char* value, size_t vsize) = 0;
virtual ProductID storeRawData(std::string&& key, std::string&& value) = 0;
virtual ProductID storeRawData(WriteBatch& batch, const std::string& key, const std::string& value) = 0;
virtual ProductID storeRawData(WriteBatch& batch, std::string&& key, std::string&& value) = 0;
/**
* @brief Stores raw key/value data in a WriteBatch.
* This function is virtual and must be overloaded in the child class.
*
* @param batch Batch in which to write.
* @param key Key
* @param value Value pointer
* @param vsize Value size (in bytes)
*
* @return
*/
virtual ProductID storeRawData(WriteBatch& batch, const std::string& key, const char* value, size_t vsize) = 0;
/**
* @brief Loads raw key/value data from this KeyValueContainer.
......@@ -90,6 +98,8 @@ class KeyValueContainer {
*/
virtual bool loadRawData(const std::string& key, std::string& buffer) const = 0;
virtual bool loadRawData(const std::string& key, char* value, size_t* vsize) const = 0;
/**
* @brief Stores a key/value pair into the KeyValueContainer.
* The type of the key should have operator<< available
......@@ -107,16 +117,12 @@ class KeyValueContainer {
*/
template<typename K, typename V>
ProductID store(const K& key, const V& value) {
std::string key_str, val_str;
serializeKeyValue(key, value, key_str, val_str);
return storeRawData(std::move(key_str), std::move(val_str));
return storeImpl(key, value, std::is_pod<V>());
}
template<typename K, typename V>
ProductID store(WriteBatch& batch, const K& key, const V& value) {
std::string key_str, val_str;
serializeKeyValue(key, value, key_str, val_str);
return storeRawData(batch, std::move(key_str), std::move(val_str));
return storeImpl(batch, key, value, std::is_pod<V>());
}
/**
......@@ -136,6 +142,59 @@ class KeyValueContainer {
*/
template<typename K, typename V>
bool load(const K& key, V& value) const {
return loadImpl(key, value, std::is_pod<V>());
}
private:
template<typename K, typename V>
ProductID storeImpl(const K& key, const V& value,
const std::integral_constant<bool, false>&) {
std::string key_str, val_str;
serializeKeyValue(key, value, key_str, val_str);
return storeRawData(key_str, val_str.data(), val_str.size());
}
template<typename K, typename V>
ProductID storeImpl(WriteBatch& batch, const K& key, const V& value,
const std::integral_constant<bool, false>&) {
std::string key_str, val_str;
serializeKeyValue(key, value, key_str, val_str);
return storeRawData(batch, key_str, val_str.data(), val_str.size());
}
template<typename K, typename V>
ProductID storeImpl(const K& key, const V& value,
const std::integral_constant<bool, true>&) {
std::string key_str;
serializeKeyValue(key, value, key_str);
return storeRawData(key_str, reinterpret_cast<const char*>(&value), sizeof(value));
}
template<typename K, typename V>
ProductID storeImpl(WriteBatch& batch, const K& key, const V& value,
const std::integral_constant<bool, true>&) {
std::string key_str;
serializeKeyValue(key, value, key_str);
return storeRawData(batch, key_str, reinterpret_cast<const char*>(&value), sizeof(value));
}
template<typename K, typename V>
bool loadImpl(const K& key, V& value,
const std::integral_constant<bool, true>&) const {
std::string buffer;
std::stringstream ss_key;
ss_key << key << "#" << demangle<V>();
size_t vsize = sizeof(value);
if(!loadRawData(ss_key.str(), reinterpret_cast<char*>(&value), &vsize)) {
return false;
}
return vsize == sizeof(value);
}
template<typename K, typename V>
bool loadImpl(const K& key, V& value,
const std::integral_constant<bool, false>&) const {
std::string buffer;
std::stringstream ss_key;
ss_key << key << "#" << demangle<V>();
......@@ -152,15 +211,11 @@ class KeyValueContainer {
return true;
}
private:
template<typename K, typename V>
static void serializeKeyValue(const K& key, const V& value,
std::string& key_str, std::string& value_str) {
serializeKeyValue(key, value, key_str);
std::stringstream ss_value;
std::stringstream ss_key;
ss_key << key << "#" << demangle<V>();
key_str = std::move(ss_key.str());
boost::archive::binary_oarchive oa(ss_value, boost::archive::archive_flags::no_header);
try {
oa << value;
......@@ -169,6 +224,13 @@ class KeyValueContainer {
}
value_str = ss_value.str();
}
template<typename K, typename V>
static void serializeKeyValue(const K& key, const V& value, std::string& key_str) {
std::stringstream ss_key;
ss_key << key << "#" << demangle<V>();
key_str = std::move(ss_key.str());
}
};
}
......
......@@ -116,10 +116,9 @@ class Run : public KeyValueContainer {
*
* @return a valid ProductID if the key did not already exist, an invalid one otherwise.
*/
ProductID storeRawData(const std::string& key, const std::string& value) override;
ProductID storeRawData(std::string&& key, std::string&& value) override;
ProductID storeRawData(WriteBatch& batch, const std::string& key, const std::string& value) override;
ProductID storeRawData(WriteBatch& batch, std::string&& key, std::string&& value) override;
ProductID storeRawData(const std::string& key, const char* value, size_t vsize) override;
ProductID storeRawData(WriteBatch& batch, const std::string& key, const char* value, size_t vsize) override;
/**
* @brief Loads raw key/value data from this Run.
*
......@@ -129,6 +128,7 @@ class Run : public KeyValueContainer {
* @return true if the key exists, false otherwise.
*/
bool loadRawData(const std::string& key, std::string& buffer) const override;
bool loadRawData(const std::string& key, char* value, size_t* vsize) const override;
/**
* @brief Compares this Run with another Run. The Runs must point to
......
......@@ -112,10 +112,8 @@ class SubRun : public KeyValueContainer {
*
* @return a valid ProductID if the key did not already exist, an invalid one otherwise.
*/
ProductID storeRawData(const std::string& key, const std::string& value) override;
ProductID storeRawData(std::string&& key, std::string&& value) override;
ProductID storeRawData(WriteBatch& batch, const std::string& key, const std::string& value) override;
ProductID storeRawData(WriteBatch& batch, std::string&& key, std::string&& value) override;
ProductID storeRawData(const std::string& key, const char* value, size_t vsize) override;
ProductID storeRawData(WriteBatch& batch, const std::string& key, const char* value, size_t vsize) override;
/**
* @brief Loads raw key/value data from this SubRun.
......@@ -126,6 +124,7 @@ class SubRun : public KeyValueContainer {
* @return true if the key exists, false otherwise.
*/
bool loadRawData(const std::string& key, std::string& buffer) const override;
bool loadRawData(const std::string& key, char* value, size_t* vsize) const override;
/**
* @brief Compares this SubRun with another SubRun. The SubRuns must point to
......
......@@ -94,40 +94,36 @@ bool DataSet::valid() const {
return m_impl && m_impl->m_datastore;
}
ProductID DataSet::storeRawData(const std::string& key, const std::string& buffer) {
ProductID DataSet::storeRawData(const std::string& key, const char* value, size_t vsize) {
if(!valid()) {
throw Exception("Calling DataSet member function on an invalid DataSet");
}
// forward the call to the datastore's store function
return m_impl->m_datastore->m_impl->store(0, fullname(), key, buffer);
return m_impl->m_datastore->m_impl->store(0, fullname(), key, value, vsize);
}
ProductID DataSet::storeRawData(std::string&& key, std::string&& buffer) {
return storeRawData(key, buffer); // will call the function above
}
ProductID DataSet::storeRawData(WriteBatch& batch, const std::string& key, const std::string& buffer) {
ProductID DataSet::storeRawData(WriteBatch& batch, const std::string& key, const char* value, size_t vsize) {
if(!valid()) {
throw Exception("Calling DataSet member function on an invalid DataSet");
}
// forward the call to the datastore's store function
return batch.m_impl->store(0, fullname(), key, buffer);
return batch.m_impl->store(0, fullname(), key, value, vsize);
}
ProductID DataSet::storeRawData(WriteBatch& batch, std::string&& key, std::string&& buffer) {
bool DataSet::loadRawData(const std::string& key, std::string& buffer) const {
if(!valid()) {
throw Exception("Calling DataSet member function on an invalid DataSet");
}
// forward the call to the datastore's store function
return batch.m_impl->store(0, fullname(), std::move(key), std::move(buffer));
// forward the call to the datastore's load function
return m_impl->m_datastore->m_impl->load(0, fullname(), key, buffer);
}
bool DataSet::loadRawData(const std::string& key, std::string& buffer) const {
bool DataSet::loadRawData(const std::string& key, char* value, size_t* vsize) const {
if(!valid()) {
throw Exception("Calling DataSet member function on an invalid DataSet");
}
// forward the call to the datastore's load function
return m_impl->m_datastore->m_impl->load(0, fullname(), key, buffer);
return m_impl->m_datastore->m_impl->load(0, fullname(), key, value, vsize);
}
bool DataSet::operator==(const DataSet& other) const {
......@@ -174,7 +170,7 @@ DataSet DataSet::createDataSet(const std::string& name) {
throw Exception("Invalid character '/' or '%' in dataset name");
}
std::string parent = fullname();
m_impl->m_datastore->m_impl->store(m_impl->m_level+1, parent, name, std::string());
m_impl->m_datastore->m_impl->store(m_impl->m_level+1, parent, name);
return DataSet(m_impl->m_datastore, m_impl->m_level+1, std::make_shared<std::string>(parent), name);
}
......@@ -184,7 +180,7 @@ Run DataSet::createRun(const RunNumber& runNumber) {
}
std::string parent = fullname();
std::string runStr = Run::Impl::makeKeyStringFromRunNumber(runNumber);
m_impl->m_datastore->m_impl->store(m_impl->m_level+1, parent, runStr, std::string());
m_impl->m_datastore->m_impl->store(m_impl->m_level+1, parent, runStr);
return Run(m_impl->m_datastore, m_impl->m_level+1,
std::make_shared<std::string>(parent), runNumber);
}
......@@ -195,7 +191,7 @@ Run DataSet::createRun(WriteBatch& batch, const RunNumber& runNumber) {
}
std::string parent = fullname();
std::string runStr = Run::Impl::makeKeyStringFromRunNumber(runNumber);
batch.m_impl->store(m_impl->m_level+1, parent, runStr, std::string());
batch.m_impl->store(m_impl->m_level+1, parent, runStr);
return Run(m_impl->m_datastore, m_impl->m_level+1,
std::make_shared<std::string>(parent), runNumber);
}
......
......@@ -177,7 +177,7 @@ DataSet DataStore::createDataSet(const std::string& name) {
|| name.find('%') != std::string::npos) {
throw Exception("Invalid character ('/' or '%') in dataset name");
}
m_impl->store(1, "", name, std::string());
m_impl->store(1, "", name);
return DataSet(this, 1, std::make_shared<std::string>(""), name);
}
......@@ -189,7 +189,7 @@ DataSet DataStore::createDataSet(WriteBatch& batch, const std::string& name) {
|| name.find('%') != std::string::npos) {
throw Exception("Invalid character ('/' or '%') in dataset name");
}
batch.m_impl->store(1, "", name, std::string());
batch.m_impl->store(1, "", name);
return DataSet(this, 1, std::make_shared<std::string>(""), name);
}
......@@ -209,6 +209,13 @@ bool DataStore::loadRawProduct(const ProductID& productID, std::string& buffer)
return m_impl->load(productID.m_level, productID.m_containerName, productID.m_objectName, buffer);
}
bool DataStore::loadRawProduct(const ProductID& productID, char* data, size_t* size) {
if(!m_impl) {
throw Exception("Calling DataStore member function on an invalid DataStore object");
}
return m_impl->load(productID.m_level, productID.m_containerName, productID.m_objectName, data, size);
}
////////////////////////////////////////////////////////////////////////////////////////////
// DataStore::const_iterator::Impl implementation
////////////////////////////////////////////////////////////////////////////////////////////
......
......@@ -61,40 +61,36 @@ bool Event::valid() const {
}
ProductID Event::storeRawData(const std::string& key, const std::string& buffer) {
ProductID Event::storeRawData(const std::string& key, const char* value, size_t vsize) {
if(!valid()) {
throw Exception("Calling Event member function on an invalid Event object");
}
// forward the call to the datastore's store function
return m_impl->m_datastore->m_impl->store(0, m_impl->fullpath(), key, buffer);
return m_impl->m_datastore->m_impl->store(0, m_impl->fullpath(), key, value, vsize);
}
ProductID Event::storeRawData(std::string&& key, std::string&& buffer) {
return storeRawData(key, buffer); // call the above function
}
ProductID Event::storeRawData(WriteBatch& batch, const std::string& key, const std::string& buffer) {
ProductID Event::storeRawData(WriteBatch& batch, const std::string& key, const char* value, size_t vsize) {
if(!valid()) {
throw Exception("Calling Event member function on an invalid Event object");
}
// forward the call to the datastore's store function
return batch.m_impl->store(0, m_impl->fullpath(), key, buffer);
return batch.m_impl->store(0, m_impl->fullpath(), key, value, vsize);
}
ProductID Event::storeRawData(WriteBatch& batch, std::string&& key, std::string&& buffer) {
bool Event::loadRawData(const std::string& key, std::string& buffer) const {
if(!valid()) {
throw Exception("Calling Event member function on an invalid Event object");
}
// forward the call to the datastore's store function
return batch.m_impl->store(0, m_impl->fullpath(), std::move(key), std::move(buffer));
// forward the call to the datastore's load function
return m_impl->m_datastore->m_impl->load(0, m_impl->fullpath(), key, buffer);
}
bool Event::loadRawData(const std::string& key, std::string& buffer) const {
bool Event::loadRawData(const std::string& key, char* value, size_t* vsize) const {
if(!valid()) {
throw Exception("Calling Event member function on an invalid Event object");
throw Exception("Calling DataSet member function on an invalid DataSet");
}
// forward the call to the datastore's load function
return m_impl->m_datastore->m_impl->load(0, m_impl->fullpath(), key, buffer);
return m_impl->m_datastore->m_impl->load(0, m_impl->fullpath(), key, value, vsize);
}
bool Event::operator==(const Event& other) const {
......
......@@ -63,40 +63,36 @@ bool Run::valid() const {
}
ProductID Run::storeRawData(const std::string& key, const std::string& buffer) {
ProductID Run::storeRawData(const std::string& key, const char* value, size_t vsize) {
if(!valid()) {
throw Exception("Calling Run member function on an invalid Run object");
}
// forward the call to the datastore's store function
return m_impl->m_datastore->m_impl->store(0, m_impl->fullpath(), key, buffer);
return m_impl->m_datastore->m_impl->store(0, m_impl->fullpath(), key, value, vsize);
}
ProductID Run::storeRawData(std::string&& key, std::string&& buffer) {
return storeRawData(key, buffer); // calls the above function
}
ProductID Run::storeRawData(WriteBatch& batch, const std::string& key, const std::string& buffer) {
ProductID Run::storeRawData(WriteBatch& batch, const std::string& key, const char* value, size_t vsize) {
if(!valid()) {
throw Exception("Calling Run member function on an invalid Run object");
}
// forward the call to the datastore's store function
return batch.m_impl->store(0, m_impl->fullpath(), key, buffer);
return batch.m_impl->store(0, m_impl->fullpath(), key, value, vsize);
}
ProductID Run::storeRawData(WriteBatch& batch, std::string&& key, std::string&& buffer) {
bool Run::loadRawData(const std::string& key, std::string& buffer) const {
if(!valid()) {
throw Exception("Calling Run member function on an invalid Run object");
}
// forward the call to the datastore's store function
return batch.m_impl->store(0, m_impl->fullpath(), std::move(key), std::move(buffer));
// forward the call to the datastore's load function
return m_impl->m_datastore->m_impl->load(0, m_impl->fullpath(), key, buffer);
}
bool Run::loadRawData(const std::string& key, std::string& buffer) const {
bool Run::loadRawData(const std::string& key, char* value, size_t* vsize) const {
if(!valid()) {
throw Exception("Calling Run member function on an invalid Run object");
throw Exception("Calling DataSet member function on an invalid DataSet");
}
// forward the call to the datastore's load function
return m_impl->m_datastore->m_impl->load(0, m_impl->fullpath(), key, buffer);
return m_impl->m_datastore->m_impl->load(0, m_impl->fullpath(), key, value, vsize);
}
bool Run::operator==(const Run& other) const {
......@@ -135,7 +131,7 @@ SubRun Run::createSubRun(const SubRunNumber& subRunNumber) {
}
std::string parent = m_impl->fullpath();
std::string subRunStr = SubRun::Impl::makeKeyStringFromSubRunNumber(subRunNumber);
m_impl->m_datastore->m_impl->store(m_impl->m_level+1, parent, subRunStr, std::string());
m_impl->m_datastore->m_impl->store(m_impl->m_level+1, parent, subRunStr);
return SubRun(m_impl->m_datastore, m_impl->m_level+1,
std::make_shared<std::string>(parent), subRunNumber);
}
......@@ -146,7 +142,7 @@ SubRun Run::createSubRun(WriteBatch& batch, const SubRunNumber& subRunNumber) {
}
std::string parent = m_impl->fullpath();
std::string subRunStr = SubRun::Impl::makeKeyStringFromSubRunNumber(subRunNumber);
batch.m_impl->store(m_impl->m_level+1, parent, subRunStr, std::string());
batch.m_impl->store(m_impl->m_level+1, parent, subRunStr);
return SubRun(m_impl->m_datastore, m_impl->m_level+1,
std::make_shared<std::string>(parent), subRunNumber);
}
......
......@@ -65,40 +65,36 @@ bool SubRun::valid() const {
return m_impl && m_impl->m_datastore;
}
ProductID SubRun::storeRawData(const std::string& key, const std::string& buffer) {
ProductID SubRun::storeRawData(const std::string& key, const char* value, size_t vsize) {
if(!valid()) {
throw Exception("Calling SubRun member function on invalid SubRun object");
}
// forward the call to the datastore's store function
return m_impl->m_datastore->m_impl->store(0, m_impl->fullpath(), key, buffer);
return m_impl->m_datastore->m_impl->store(0, m_impl->fullpath(), key, value, vsize);
}
ProductID SubRun::storeRawData(std::string&& key, std::string&& buffer) {
return storeRawData(key, buffer); // call above function
}
ProductID SubRun::storeRawData(WriteBatch& batch, const std::string& key, const std::string& buffer) {
ProductID SubRun::storeRawData(WriteBatch& batch, const std::string& key, const char* value, size_t vsize) {
if(!valid()) {
throw Exception("Calling SubRun member function on invalid SubRun object");
}
// forward the call to the datastore's store function
return batch.m_impl->store(0, m_impl->fullpath(), key, buffer);
return batch.m_impl->store(0, m_impl->fullpath(), key, value, vsize);
}
ProductID SubRun::storeRawData(WriteBatch& batch, std::string&& key, std::string&& buffer) {
bool SubRun::loadRawData(const std::string& key, std::string& buffer) const {
if(!valid()) {
throw Exception("Calling SubRun member function on invalid SubRun object");
}
// forward the call to the datastore's store function
return batch.m_impl->store(0, m_impl->fullpath(), std::move(key), std::move(buffer));
// forward the call to the datastore's load function
return m_impl->m_datastore->m_impl->load(0, m_impl->fullpath(), key, buffer);
}
bool SubRun::loadRawData(const std::string& key, std::string& buffer) const {
bool SubRun::loadRawData(const std::string& key, char* value, size_t* vsize) const {
if(!valid()) {
throw Exception("Calling SubRun member function on invalid SubRun object");
throw Exception("Calling DataSet member function on an invalid DataSet");
}
// forward the call to the datastore's load function
return m_impl->m_datastore->m_impl->load(0, m_impl->fullpath(), key, buffer);
return m_impl->m_datastore->m_impl->load(0, m_impl->fullpath(), key, value, vsize);
}
bool SubRun::operator==(const SubRun& other) const {
......@@ -127,7 +123,7 @@ Event SubRun::createEvent(const EventNumber& eventNumber) {
}
std::string parent = m_impl->fullpath();
std::string eventStr = Event::Impl::makeKeyStringFromEventNumber(eventNumber);
m_impl->m_datastore->m_impl->store(m_impl->m_level+1, parent, eventStr, std::string());
m_impl->m_datastore->m_impl->store(m_impl->m_level+1, parent, eventStr);
return Event(m_impl->m_datastore, m_impl->m_level+1,
std::make_shared<std::string>(parent), eventNumber);
}
......@@ -138,7 +134,7 @@ Event SubRun::createEvent(WriteBatch& batch, const EventNumber& eventNumber) {
}
std::string parent = m_impl->fullpath();
std::string eventStr = Event::Impl::makeKeyStringFromEventNumber(eventNumber);
batch.m_impl->store(m_impl->m_level+1, parent, eventStr, std::string());
batch.m_impl->store(m_impl->m_level+1, parent, eventStr);
return Event(m_impl->m_datastore, m_impl->m_level+1,
std::make_shared<std::string>(parent), eventNumber);
}
......
......@@ -208,6 +208,29 @@ class DataStore::Impl {
return true;
}
bool load(uint8_t level, const std::string& containerName,
const std::string& objectName, char* value, size_t* vsize) const {
int ret;
// build key
auto key = buildKey(level, containerName, objectName);
// find out which DB to access
long unsigned sdskv_db_idx = computeDbIndex(level, containerName, key);
// make corresponding datastore entry
auto& db = m_databases[sdskv_db_idx];
// read the value
try {
db.get(key.data(), key.size(), value, vsize);
} catch(sdskv::exception& ex) {
if(ex.error() == SDSKV_ERR_UNKNOWN_KEY)
return false;
else if(ex.error() == SDSKV_ERR_SIZE)
return false;
else
throw Exception("Error occured when calling sdskv::database::get (SDSKV error="+std::to_string(ex.error())+")");
}
return true;
}
bool exists(uint8_t level, const std::string& containerName,
const std::string& objectName) const {
int ret;
......@@ -226,7 +249,7 @@ class DataStore::Impl {
}
ProductID store(uint8_t level, const std::string& containerName,
const std::string& objectName, const std::string& data) {
const std::string& objectName, const char* data=nullptr, size_t data_size=0) {
// build full name
auto key = buildKey(level, containerName, objectName);
// find out which DB to access
......@@ -234,7 +257,7 @@ class DataStore::Impl {
// Create the product id
const auto& db = m_databases[sdskv_db_idx];
try {
db.put(key, data);
db.put(key.data(), key.size(), data, data_size);
} catch(sdskv::exception& ex) {
if(ex.error() == SDSKV_ERR_KEYEXISTS) {
return ProductID();
......@@ -246,8 +269,8 @@ class DataStore::Impl {
}
void storeMultiple(unsigned long db_index,
const std::vector<std::string> keys,
const std::vector<std::string> values) {
const std::vector<std::string>& keys,
const std::vector<std::string>& values) {
// Create the product id
const auto& db = m_databases[db_index];
try {
......
......@@ -50,21 +50,15 @@ class WriteBatch::Impl {
Impl(DataStore* ds)
: m_datastore(ds) {}
ProductID store(uint8_t level, const std::string& containerName, const std::string& objectName, const std::string& content) {
ProductID store(uint8_t level, const std::string& containerName, const std::string& objectName, const char* content=nullptr, size_t size=0) {
std::string key = DataStore::Impl::buildKey(level, containerName, objectName);
auto db_idx = m_datastore->m_impl->computeDbIndex(level, containerName, key);
auto& e = m_entries[db_idx];
e.first.push_back(std::move(key));
e.second.push_back(content);
return ProductID(level, containerName, objectName);
}
ProductID store(uint8_t level, const std::string& containerName, const std::string& objectName, std::string&& content) {
std::string key = DataStore::Impl::buildKey(level, containerName, objectName);
auto db_idx = m_datastore->m_impl->computeDbIndex(level, containerName, key);
auto& e = m_entries[db_idx];
e.first.push_back(std::move(key));
e.second.push_back(std::move(content));
if(content == nullptr)
e.second.push_back(std::string());
else
e.second.push_back(std::string(content, size));
return ProductID(level, containerName, objectName);
}
......
#include <map>
#include <type_traits>
#include <boost/serialization/map.hpp>