Commit 48cf872c authored by Matthieu Dorier's avatar Matthieu Dorier

doing some cleanup

parent 33018afe
......@@ -131,147 +131,7 @@ DataSet DataStore::createDataSet(const std::string& name) {
m_impl->store(1, "", name, std::vector<char>());
return DataSet(this, 1, "", name);
}
#if 0
bool DataStore::load(uint8_t level, const std::string& containerName,
const std::string& objectName, std::vector<char>& data) const {
int ret;
// build full name
std::stringstream ss;
if(!containerName.empty())
ss << containerName << "/";
ss << objectName;
// hash the name to get the provider id
long unsigned provider_idx = 0;
if(level != 0) {
uint64_t h = std::hash<std::string>()(containerName);
ch_placement_find_closest(m_impl->m_chi_sdskv, h, 1, &provider_idx);
} else {
// use the complete name for final objects (level 255)
uint64_t h = std::hash<std::string>()(ss.str());
ch_placement_find_closest(m_impl->m_chi_sdskv, h, 1, &provider_idx);
}
// make corresponding datastore entry
DataStoreEntryPtr entry = make_datastore_entry(level, ss.str());
auto ph = m_impl->m_sdskv_ph[provider_idx];
auto db_id = m_impl->m_sdskv_db[provider_idx];
// find the size of the value, as a way to check if the key exists
hg_size_t vsize;
std::cerr << "[LOG] load (level=" << (int)level
<< ", container=\"" << containerName << "\", object=\""
<< objectName << "\")" << std::endl;
ret = sdskv_length(ph, db_id, entry->raw(), entry->length(), &vsize);
if(ret == SDSKV_ERR_UNKNOWN_KEY) {
return false;
}
if(ret != SDSKV_SUCCESS) {
throw Exception("Error occured when calling sdskv_length");
}
// read the value
data.resize(vsize);
ret = sdskv_get(ph, db_id, entry->raw(), entry->length(), data.data(), &vsize);
if(ret != SDSKV_SUCCESS) {
throw Exception("Error occured when calling sdskv_get");
}
return true;
}
bool DataStore::store(uint8_t level, const std::string& containerName,
const std::string& objectName, const std::vector<char>& data) {
// build full name
std::stringstream ss;
if(!containerName.empty())
ss << containerName << "/";
ss << objectName;
// hash the name to get the provider id
long unsigned provider_idx = 0;
if(level != 0) {
uint64_t h = std::hash<std::string>()(containerName);
ch_placement_find_closest(m_impl->m_chi_sdskv, h, 1, &provider_idx);
} else {
// use the complete name for final objects (level 0)
uint64_t h = std::hash<std::string>()(ss.str());
ch_placement_find_closest(m_impl->m_chi_sdskv, h, 1, &provider_idx);
}
// make corresponding datastore entry
DataStoreEntryPtr entry = make_datastore_entry(level, ss.str());
auto ph = m_impl->m_sdskv_ph[provider_idx];
auto db_id = m_impl->m_sdskv_db[provider_idx];
std::cerr << "[LOG] store (level=" << (int)level
<< ", container=\"" << containerName << "\", object=\""
<< objectName << "\")" << std::endl;
int ret = sdskv_put(ph, db_id, entry->raw(), entry->length(), data.data(), data.size());
if(ret != SDSKV_SUCCESS) {
throw Exception("Could not put key/value pair in SDSKV (sdskv_put error)");
}
return true;
}
size_t DataStore::nextKeys(uint8_t level, const std::string& containerName,
const std::string& lower,
std::vector<std::string>& keys, size_t maxKeys) const {
int ret;
if(level == 0) return 0; // cannot iterate at object level
// build full name from lower bound key
std::stringstream ss;
if(!containerName.empty())
ss << containerName << "/";
ss << lower;
// hash the name to get the provider id
long unsigned provider_idx = 0;
uint64_t h = std::hash<std::string>()(containerName);
ch_placement_find_closest(m_impl->m_chi_sdskv, h, 1, &provider_idx);
// make an entry for the lower bound
DataStoreEntryPtr lb_entry = make_datastore_entry(level, ss.str());
// create data structures to receive keys
std::vector<DataStoreEntryPtr> keys_ent;
std::vector<void*> keys_ptr(maxKeys);
std::vector<hg_size_t> keys_len(maxKeys);
for(unsigned i=0; i < maxKeys; i++) {
keys_ent.push_back(make_datastore_entry(level, 1024));
keys_ptr[i] = keys_ent[i]->raw();
keys_len[i] = sizeof(DataStoreEntry) + 1024;
}
// get provider and database
auto ph = m_impl->m_sdskv_ph[provider_idx];
auto db_id = m_impl->m_sdskv_db[provider_idx];
// issue an sdskv_list_keys
hg_size_t max_keys = maxKeys;
std::cerr << "[LOG] list keys (level=" << (int)level
<< ", container=\"" << containerName << "\", greaterthan=\""
<< lower << "\")" << std::endl;
ret = sdskv_list_keys(ph, db_id, lb_entry->raw(), lb_entry->length(),
keys_ptr.data(), keys_len.data(), &max_keys);
if(ret != HG_SUCCESS) {
throw Exception("Error occured when calling sdskv_list_keys");
}
unsigned i = max_keys - 1;
if(max_keys == 0) return 0;
// remove keys that don't have the same level or the same prefix
std::string prefix = containerName + "/";
keys.resize(0);
for(unsigned i = 0; i < max_keys; i++) {
if(keys_ent[i]->m_level != level) {
max_keys = i;
break;
}
if(!containerName.empty()) {
size_t lenpre = prefix.size();
size_t lenstr = strlen(keys_ent[i]->m_fullname);
if(lenstr < lenpre) {
max_keys = i;
break;
}
if(strncmp(prefix.c_str(), keys_ent[i]->m_fullname, lenpre) != 0) {
max_keys = i;
break;
}
}
keys.push_back(keys_ent[i]->m_fullname);
}
// set the resulting keys
return max_keys;
}
#endif
////////////////////////////////////////////////////////////////////////////////////////////
// DataStore::const_iterator::Impl implementation
////////////////////////////////////////////////////////////////////////////////////////////
......
......@@ -10,6 +10,10 @@
namespace hepnos {
////////////////////////////////////////////////////////////////////////////////////////////
// RunSet implementation
////////////////////////////////////////////////////////////////////////////////////////////
RunSet::RunSet(DataSet* ds)
: m_impl(std::make_unique<RunSet::Impl>(ds)) {}
......@@ -113,6 +117,10 @@ RunSet::const_iterator RunSet::upper_bound(const RunNumber& ub) const {
return it;
}
////////////////////////////////////////////////////////////////////////////////////////////
// RunSet::const_iterator::Impl implementation
////////////////////////////////////////////////////////////////////////////////////////////
class RunSet::const_iterator::Impl {
public:
Run m_current_run;
......@@ -138,6 +146,10 @@ class RunSet::const_iterator::Impl {
}
};
////////////////////////////////////////////////////////////////////////////////////////////
// DataStore::const_iterator implementation
////////////////////////////////////////////////////////////////////////////////////////////
RunSet::const_iterator::const_iterator()
: m_impl(std::make_unique<Impl>()) {}
......@@ -204,6 +216,10 @@ bool RunSet::const_iterator::operator!=(const self_type& rhs) const {
return !(*this == rhs);
}
////////////////////////////////////////////////////////////////////////////////////////////
// DataStore::iterator implementation
////////////////////////////////////////////////////////////////////////////////////////////
RunSet::iterator::iterator(const Run& current)
: const_iterator(current) {}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment