Класс QContiguousCache

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

Этот класс был введен в Qt 4.6.

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

Примечание: Все функции в этом классе являются взаимоисключающими.

Открытые функции

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

Класс 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() использовать не нужно.

См. пример Contiguous Cache.

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

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

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

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

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

QContiguousCache::QContiguousCache(int capacity = 0)

Создаёт кэш заданной ёмкостью.

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

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

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

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

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

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

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==().

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).