Класс QContiguousCache

Класс QContiguousCache — шаблонный класс, предоставляющий непрерывный кэш. Подробнее...

• Список всех членов, включая унаследованные

Примечание: Все функции в этом классе являются перевходными.

Публичные функции

Подробное описание

Класс QContiguousCache — шаблонный класс, предоставляющий непрерывный кэш.

Класс QContiguousCache обеспечивает эффективный способ кэширования элементов для отображения в представлении пользовательского интерфейса. В отличие от QCache, он накладывает ограничение, что элементы в кэше являются смежными. Это преимущество состоит в том, что представления пользовательского интерфейса чаще всего запрашивают данные как набор строк, локализованных вокруг текущей позиции прокрутки. Это ограничение позволяет кэшу потреблять меньше памяти и процессорного времени, чем QCache.

QContiguousCache работает с фиксированной емкостью, установленной с помощью setCapacity() или переданной в качестве параметра конструктору. Эта емкость является верхней границей использования памяти самим кэшем, не включая память, выделенную самими элементами. Обратите внимание, что кэш с емкостью ноль (по умолчанию) означает, что элементы не будут храниться: операции insert(), append() и prepend() будут фактически являться бездействующими операциями. Поэтому важно установить емкость в разумное значение перед добавлением элементов в кэш.

Самый простой способ использования непрерывного кэша — использование append() и prepend().

MyRecord record(int row) const
{
    Q_ASSERT(row >= 0 && row < count());

    while(row > cache.lastIndex())
        cache.append(slowFetchRecord(cache.lastIndex()+1));
    while(row < cache.firstIndex())
        cache.prepend(slowFetchRecord(cache.firstIndex()-1));

    return cache.at(row);
}

Если кэш заполнен, то элемент в противоположном конце кэша от того, где добавлен новый элемент, будет удален.

Это использование можно дополнительно оптимизировать, используя функцию insert() в случае, когда запрашиваемая строка находится далеко от текущих элементов кэша. Если между тем, где вставлен новый элемент, и текущими элементами кэша имеется пробел, то существующие кэшированные элементы удаляются, чтобы сохранить непрерывный характер кэша. Следовательно, при использовании insert() необходимо проявить осторожность, чтобы избежать нежелательного очищения кэша.

Диапазон допустимых индексов для класса QContiguousCache — от 0 до INT_MAX. Вызов prepend() таким образом, чтобы первый индекс стал меньше 0, или append() таким образом, чтобы последний индекс стал больше INT_MAX, может привести к тому, что индексы кэша станут недопустимыми. Когда индексы кэша недопустимы, важно вызвать normalizeIndexes() перед вызовом любого из containsIndex(), firstIndex(), lastIndex(), at() или operator[](). Вызов этих функций, когда у кэша есть недопустимые индексы, приведет к неопределенному поведению. Индексы можно проверить с помощью areIndexesValid()

В большинстве случаев индексы не будут превышать 0 до INT_MAX, и normalizeIndexes() использовать не нужно.

См. пример кэша.

Документация по функциям-членам

QContiguousCache::QContiguousCache(int capacity = 0)

Создаёт кэш с заданной capacity.

См. также setCapacity().

QContiguousCache::QContiguousCache(const QContiguousCache<T> &other)

Создаёт копию other.

Эта операция выполняется за постоянное время, потому что QContiguousCache неявным образом делится. Это делает возврат QContiguousCache из функции очень быстрым. Если изменён общий экземпляр, он будет скопирован (копирование при записи), и это займёт линейное время.

См. также operator=().

QContiguousCache::~QContiguousCache()

Удаляет кэш.

void QContiguousCache::append(const T &value)

Вставляет value в конец кэша. Если кэш уже заполнен, элемент в начале кэша будет удалён.

См. также prepend(), insert() и isFull().

bool QContiguousCache::areIndexesValid() const

Возвращает, являются ли индексы элементов, хранящихся в кэше, допустимыми. Индексы могут стать недопустимыми, если элементы добавляются после индексной позиции INT_MAX или вставляются перед индексной позицией 0. Это ожидается только при использовании кэша в виде кольцевого буфера на протяжении очень долгого времени. Индексы можно сделать допустимыми снова, вызвав normalizeIndexes().

См. также normalizeIndexes(), append() и prepend().

const T &QContiguousCache::at(int i) const

Возвращает элемент с индексом i в кэше. i должен быть допустимой индексной позицией в кэше (т. е., firstIndex() <= i <= lastIndex()).

Индексы в кэше относятся к количеству позиций, на которые элемент удалён от первого добавленного в кэш элемента. То есть, если у кэша есть ёмкость 100, а в него добавлено 150 элементов, допустимый диапазон индексов будет от 50 до 149. Это позволяет вставлять и извлекать элементы в кэш на основе теоретически бесконечного списка

См. также firstIndex(), lastIndex(), insert() и operator[]().

int QContiguousCache::available() const

Возвращает количество элементов, которые можно добавить в кэш, прежде чем он заполнится.

См. также size(), capacity() и isFull().

int QContiguousCache::capacity() const

Возвращает количество элементов, которые может хранить кэш, прежде чем он заполнится. Когда кэш содержит количество элементов, равное его ёмкости, добавление новых элементов приведёт к удалению элементов, наиболее удалённых от добавляемого элемента.

См. также setCapacity() и size().

void QContiguousCache::clear()

Удаляет все элементы из кэша. Ёмкость остаётся неизменной.

bool QContiguousCache::containsIndex(int i) const

Возвращает true если диапазон индексов кэша включает данный индекс i.

См. также firstIndex() и lastIndex().

int QContiguousCache::count() const

То же, что и size().

T &QContiguousCache::first()

Возвращает ссылку на первый элемент в кэше. Эта функция предполагает, что кэш не пустой.

См. также last() и isEmpty().

const T &QContiguousCache::first() const

Это перегруженная функция.

int QContiguousCache::firstIndex() const

Возвращает первый допустимый индекс в кэше. Индекс будет недопустимым, если кэш пустой.

См. также capacity(), size() и lastIndex().

void QContiguousCache::insert(int i, const T &value)

Вставляет value в индексную позицию i. Если кэш уже содержит элемент в i, то этот элемент заменяется. Если i равен на единицу больше lastIndex() или на единицу меньше firstIndex(), это эквивалентно append() или prepend().

Если заданный индекс i не входит в текущий диапазон кэша и не прилегает к границам диапазона индексов кэша, кэш сначала очищается перед вставкой элемента. В этот момент размер кэша будет равен 1. Стоит постараться вставлять элементы в порядке, близком к текущему диапазону индексов кэша.

Диапазон допустимых индексов для класса QContiguousCache составляет от 0 до INT_MAX. Вставка за пределами этого диапазона имеет неопределённое поведение.

См. также prepend(), append(), isFull(), firstIndex() и lastIndex().

bool QContiguousCache::isEmpty() const

Возвращает true если в кэше нет элементов.

См. также size() и capacity().

bool QContiguousCache::isFull() const

Возвращает true если количество элементов, хранящихся в кэше, равно ёмкости кэша.

См. также size() и capacity().

T &QContiguousCache::last()

Возвращает ссылку на последний элемент в кэше. Эта функция предполагает, что кэш не пустой.

См. также first() и isEmpty().

const T &QContiguousCache::last() const

Это перегруженная функция.

int QContiguousCache::lastIndex() const

Возвращает последний допустимый индекс в кэше. Индекс будет недопустимым, если кэш пустой.

См. также capacity(), size() и firstIndex().

void QContiguousCache::normalizeIndexes()

Перемещает начальный и конечный индексы кэша так, чтобы они указывали на допустимые индексы. Функция не изменяет содержимое кэша или порядок элементов в кэше.

Она предоставляется для исправления переполнений индексов при использовании кэша в качестве кольцевого буфера.

QContiguousCache<int> cache(10);
cache.insert(INT_MAX, 1); // cache contains one value and has valid indexes, INT_MAX to INT_MAX
cache.append(2); // cache contains two values but does not have valid indexes.
cache.normalizeIndexes(); // cache has two values, 1 and 2.  New first index will be in the range of 0 to capacity().

См. также areIndexesValid(), append() и prepend().

void QContiguousCache::prepend(const T &value)

Вставляет value в начало кэша. Если кэш уже заполнен, элемент в конце кэша будет удалён.

См. также append(), insert() и isFull().

void QContiguousCache::removeFirst()

Удаляет первый элемент из кэша. Эта функция предполагает, что кэш не пустой.

См. также removeLast().

void QContiguousCache::removeLast()

Удаляет последний элемент из кэша. Эта функция предполагает, что кэш не пустой.

См. также removeFirst().

void QContiguousCache::setCapacity(int size)

Устанавливает ёмкость кэша на заданное значение size. Кэш может хранить количество элементов, равное его ёмкости. При вставке, добавлении или вставке в начало элементов в кэш, если кэш уже заполнен, удаляется элемент, наиболее удалённый от добавляемого элемента.

Если заданное size меньше текущего количества элементов в кэше, то останутся только последние size элементов из кэша.

См. также capacity() и isFull().

int QContiguousCache::size() const

Возвращает количество элементов, содержащихся в кэше.

См. также capacity().

void QContiguousCache::swap(QContiguousCache<T> &other)

Меняет местами кэш other с этим кэшем. Эта операция очень быстрая и никогда не терпит неудачу.

Эта функция была представлена в Qt 4.8.

T QContiguousCache::takeFirst()

Удаляет первый элемент в кэше и возвращает его. Эта функция предполагает, что кэш не пустой.

Если вам не нужно значение возврата, то removeFirst() более эффективно.

См. также takeLast() и removeFirst().

T QContiguousCache::takeLast()

Удаляет последний элемент в кэше и возвращает его. Эта функция предполагает, что кэш не пустой.

Если вам не нужно значение возвращаемое функцией, то removeLast() будет более эффективной.

См. также takeFirst() и removeLast().

bool QContiguousCache::operator!=(const QContiguousCache<T> &other) const

Возвращает true если other не равен этому кэшу; в противном случае возвращает false.

Два кэша считаются равными, если они содержат одинаковые значения в одинаковых индексах. Эта функция требует, чтобы тип значения реализовывал operator==().

См. также operator==().

QContiguousCache<T> &QContiguousCache::operator=(const QContiguousCache<T> &other)

Присваивает other этому кэшу и возвращает ссылку на этот кэш.

QContiguousCache<T> &QContiguousCache::operator=(QContiguousCache<T> &&other)

Перемещающее присваивание other экземпляру QContiguousCache.

Эта функция была введена в Qt 5.2.

bool QContiguousCache::operator==(const QContiguousCache<T> &other) const

Возвращает true если other равен этому кэшу; в противном случае возвращает false.

Два кэша считаются равными, если они содержат одинаковые значения в одинаковых индексах. Эта функция требует, чтобы тип значения реализовывал operator==().

См. также operator!=().

T &QContiguousCache::operator[](int i)

Возвращает элемент в позиции с индексом i как ссылку на изменяемое значение. Если в кэше нет элемента в заданной позиции i, то сначала будет вставлен пустой элемент в эту позицию.

В большинстве случаев лучше использовать либо at(), либо insert().

Примечание: Этот неконстантный перегруз оператора[] требует от QContiguousCache создания глубокой копии. Используйте at() для чтения только для доступа к неконстантному QContiguousCache.

См. также insert() и at().

const T &QContiguousCache::operator[](int i) const

Это перегруженная функция.

То же, что и at(i).