boost — C ++ итераторы произвольного доступа для контейнеров с элементами, загружаемыми по требованию

У вас есть проблемы, потому что ваш итератор не соответствует требованиям прямого итератора. В частности:

• *i должна быть lvalue ссылка на value_type или же const value_type ([Forward.iterators] /1.3)
• *i не может быть ссылкой на объект, сохраненный в самом итераторе, из-за требования, что два итератора равны, если и только если они связаны с одним и тем же объектом ([forward.iterators] / 6)

Да, эти требования являются огромной болью в заднице, и да, это означает, что такие вещи, как std::vector<bool>::iterator не являются итераторами с произвольным доступом, хотя некоторые стандартные реализации библиотек неверно утверждают, что они есть.

РЕДАКТИРОВАТЬ: Следующее предлагаемое решение ужасно сломано, в том, что разыменование временного итератора возвращает ссылку на объект, который может не жить, пока ссылка не используется. Например, после auto& foo = *(i + 1); объект, на который ссылается foo возможно, был освобожден. Реализация reverse_iterator ссылка в OP вызовет ту же проблему.

Я бы предложил разделить ваш дизайн на два класса: FileCache который содержит файловые ресурсы и кэш загруженных сообщений, и FileCache::iterator который содержит номер сообщения и лениво извлекает его из FileCache когда разыменовывается. Реализация может быть чем-то таким простым, как хранение контейнера weak_ptr<Message> в FileCache и shared_ptr<Message> в итераторе: Простая демонстрация

Я должен признать, что, возможно, я не до конца понимаю проблемы, с которыми вы сталкиваетесь, удерживая текущее СООБЩЕНИЕ в качестве члена Iter. Я бы связал каждый итератор с FileReader, из которого он должен читать, и реализовал его как легкую инкапсуляцию индекса чтения для FileReader: 🙁 read | moveTo). Наиболее важным методом перезаписи является boost::iterator_facade<...>::advance(...) который изменяет текущий индекс и пытается извлечь новое СООБЩЕНИЕ из FileReader. Если это не удастся, он помечает итератор как недействительный, а разыменование завершается ошибкой.

template<class MESSAGE,int STEP>
class message_iterator;

template<class MESSAGE>
class FileReader {
public:
typedef message_iterator<MESSAGE, 1> const_iterator;
typedef message_iterator<MESSAGE,-1> const_reverse_iterator;

FileReader();
bool open(const std::string  & rName);
bool moveTo(int n);
bool read(MESSAGE &m);

// get the total count of messages in the file
// helps us to find end() and rbegin()
int getMessageCount();

const_iterator begin() {
return const_iterator(this,0);
}
const_iterator end() {
return const_iterator(this,getMessageCount());
}
const_reverse_iterator rbegin() {
return const_reverse_iterator(this,getMessageCount()-1);
}
const_reverse_iterator rend() {
return const_reverse_iterator(this,-1);
}
};

// declaration of message_iterator moving over MESSAGE
// STEP is used to specify STEP size and direction (e.g -1 == reverse)
template<class MESSAGE,int STEP=1>
class message_iterator
: public boost::iterator_facade<
message_iterator<MESSAGE>
, const MESSAGE
, boost::random_access_traversal_tag
>
{
typedef  boost::iterator_facade<
message_iterator<MESSAGE>
, const MESSAGE
, boost::random_access_traversal_tag
> super;

public:
// constructor associates an iterator with its FileReader and a given position
explicit message_iterator(FileReader<MESSAGE> * p=NULL,int n=0): _filereader(p),_idx(n),_valid(false)    {
advance(0);
}
bool equal(const message_iterator & i) const {
return i._filereader == _filereader && i._idx == _idx;
}
void increment() {
advance(+1);
}
void decrement() {
advance(-1);
}

// overwrite with central functionality. Move to a given relative
// postion and check wether the position can be read. If move/read
// fails we flag the iterator as incalid.

void advance(int n) {
_idx += n*STEP;
if(_filereader!=NULL) {
if( _filereader->moveTo( _idx ) && _filereader->read(_m)) {
_valid = true;
return;
}
}
_valid = false;
}
// Return a ref to the currently cached MESSAGE. Throw
// an acception if positioning at this location in advance(...) failes.
typename super::reference dereference() const {
if(!_valid) {
throw std::runtime_error("access to invalid pos");
}
return _m;
}

private:
FileReader<MESSAGE> * _filereader;
int                   _idx;
bool                  _valid;
MESSAGE               _m;
};

Увеличить PropertyMap

Вы можете избежать написания основной части кода, используя Boost PropertyMap:

Жить на Колиру

#include <boost/property_map/property_map.hpp>
#include <boost/property_map/function_property_map.hpp>

using namespace boost;

struct SpecificMessage {
// add some data
int index; // just for demo
};

template <typename Message>
struct MyLazyReader {
typedef Message type;
std::string fname;

MyLazyReader(std::string fname) : fname(fname) {}

Message operator()(size_t index) const {
Message m;
// FileReader fr;
// fr.open(fname);
// fr.moveTo(index);     // Move to Message
// fr.read(&m);          // Try deserializing as SpecificMessage
m.index = index; // just for demo
return m;
}
};

#include <iostream>

int main() {

auto lazy_access = make_function_property_map<size_t>(MyLazyReader<SpecificMessage>("file.bin"));

for (int i=0; i<10; ++i)
std::cout << lazy_access[rand()%256].index << "\n";
}

Пример вывода

103
198
105
115
81
255
74
236
41
205

Использование файлов с отображенной памятью

Вы можете хранить карту индекса -> BLOB-объектов в общем vector<array<byte, N>>, flat_map<size_t, std::vector<uint8_t> > или похожие.

Итак, теперь вам нужно только десериализовать из myshared_map[index].data() (begin() а также end() если размер BLOB меняется)