libcryfs/implementations/testfake/FakeBlockStore.cpp

82 lines
2.3 KiB
C++
Raw Normal View History

#include "FakeBlock.h"
#include "FakeBlockStore.h"
#include <messmer/cpp-utils/assert/assert.h>
using std::make_shared;
using std::string;
using std::mutex;
using std::lock_guard;
using cpputils::Data;
using cpputils::unique_ref;
using cpputils::make_unique_ref;
using boost::optional;
using boost::none;
namespace blockstore {
namespace testfake {
FakeBlockStore::FakeBlockStore()
2015-10-17 21:10:26 +02:00
: _blocks(), _used_dataregions_for_blocks(), _mutex() {}
optional<unique_ref<Block>> FakeBlockStore::tryCreate(const Key &key, Data data) {
2015-10-15 04:49:31 +02:00
std::unique_lock<std::mutex> lock(_mutex);
auto insert_result = _blocks.emplace(key.ToString(), std::move(data));
if (!insert_result.second) {
return none;
}
//Return a copy of the stored data
2015-10-15 04:49:31 +02:00
return _load(key);
}
optional<unique_ref<Block>> FakeBlockStore::load(const Key &key) {
2015-10-15 04:49:31 +02:00
std::unique_lock<std::mutex> lock(_mutex);
return _load(key);
}
optional<unique_ref<Block>> FakeBlockStore::_load(const Key &key) {
//Return a copy of the stored data
string key_string = key.ToString();
try {
2015-04-15 14:51:41 +02:00
return makeFakeBlockFromData(key, _blocks.at(key_string), false);
} catch (const std::out_of_range &e) {
return none;
}
}
void FakeBlockStore::remove(unique_ref<Block> block) {
Key key = block->key();
cpputils::destruct(std::move(block));
2015-10-15 04:49:31 +02:00
std::unique_lock<std::mutex> lock(_mutex);
2015-02-22 00:29:21 +01:00
int numRemoved = _blocks.erase(key.ToString());
ASSERT(numRemoved == 1, "Block not found");
2015-02-22 00:29:21 +01:00
}
unique_ref<Block> FakeBlockStore::makeFakeBlockFromData(const Key &key, const Data &data, bool dirty) {
auto newdata = make_shared<Data>(data.copy());
_used_dataregions_for_blocks.push_back(newdata);
return make_unique_ref<FakeBlock>(this, key, newdata, dirty);
}
2015-01-24 22:08:41 +01:00
void FakeBlockStore::updateData(const Key &key, const Data &data) {
2015-10-15 04:49:31 +02:00
std::unique_lock<std::mutex> lock(_mutex);
2015-04-15 14:51:41 +02:00
auto found = _blocks.find(key.ToString());
if (found == _blocks.end()) {
auto insertResult = _blocks.emplace(key.ToString(), data.copy());
ASSERT(true == insertResult.second, "Inserting didn't work");
2015-04-15 14:51:41 +02:00
found = insertResult.first;
}
Data &stored_data = found->second;
ASSERT(data.size() == stored_data.size(), "Wrong data size in block");
std::memcpy(stored_data.data(), data.data(), data.size());
}
2015-02-23 21:07:07 +01:00
uint64_t FakeBlockStore::numBlocks() const {
2015-10-15 04:49:31 +02:00
std::unique_lock<std::mutex> lock(_mutex);
2015-02-23 21:07:07 +01:00
return _blocks.size();
}
}
}