QContiguousCache Class

Documentation sur les fonctions membres

[explicit] QContiguousCache::QContiguousCache(qsizetype capacity = 0)

Crée un cache avec l'capacity on fournie.

Voir aussi setCapacity().

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

Crée une copie de ` other`.

Cette opération s'effectue en temps constant, car QContiguousCache est implicitement partagé. Cela rend très rapide le retour d'un QContiguousCache depuis une fonction. Si une instance partagée est modifiée, elle sera copiée (copie à l'écriture), ce qui prend un temps linéaire.

Voir également operator=().

QContiguousCache::~QContiguousCache()

Vide le cache.

void QContiguousCache::append(const T &value)

Ajoute value à la fin du cache. Si le cache est déjà plein, l'élément situé en début de cache sera supprimé.

Voir également prepend(), insert() et isFull().

bool QContiguousCache::areIndexesValid() const

Indique si les index des éléments stockés dans le cache sont valides. Les index peuvent devenir invalides si des éléments sont ajoutés après la position d’index INT_MAX ou placés avant la position d’index 0. Ce cas de figure ne devrait se produire que dans le cadre d’une utilisation de très longue durée du cache contigu, à la manière d’un tampon circulaire. Les index peuvent être validés à nouveau en appelant la fonction normalizeIndexes().

Voir également normalizeIndexes(), append() et prepend().

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

Renvoie l'élément situé à l'index i dans le cache. i doit être un index valide dans le cache (c'est-à-dire que firstIndex() <= i <= lastIndex()).

Les index du cache correspondent au nombre de positions séparant l'élément de la première entrée ajoutée au cache. Autrement dit, un cache d’une capacité de 100, auquel 150 éléments ont été ajoutés, aura une plage d’index valide comprise entre 50 et 149. Cela permet d’insérer et de récupérer des éléments dans le cache en se basant sur une liste théoriquement infinie

Voir également firstIndex(), lastIndex(), insert() et operator[]().

qsizetype QContiguousCache::available() const

Renvoie le nombre d'éléments pouvant être ajoutés au cache avant que celui-ci ne soit plein.

Voir également size(), capacity() et isFull().

qsizetype QContiguousCache::capacity() const

Renvoie le nombre d'éléments que le cache peut stocker avant d'être plein. Lorsqu'un cache contient un nombre d'éléments égal à sa capacité, l'ajout de nouveaux éléments entraîne la suppression des éléments les plus éloignés de l'élément ajouté.

Voir également setCapacity() et size().

void QContiguousCache::clear()

Supprime tous les éléments du cache. La capacité reste inchangée.

bool QContiguousCache::containsIndex(qsizetype i) const

Renvoie « true » si l'intervalle d'index du cache inclut l'index donné « i ».

Voir également firstIndex() et lastIndex().

qsizetype QContiguousCache::count() const

Identique à ` size()`.

T &QContiguousCache::first()

Renvoie une référence à l'élément situé en première position dans le cache. Cette fonction suppose que le cache n'est pas vide.

Voir également last() et isEmpty().

const T &QContiguousCache::first() const

qsizetype QContiguousCache::firstIndex() const

Renvoie le premier index valide présent dans le cache. L'index ne sera pas valide si le cache est vide.

Voir également capacity(), size() et lastIndex().

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

Insère l'value à la position d'index i. Si le cache contient déjà un élément à l'adresse i, cette valeur est alors remplacée. Si i est soit supérieur d'une unité à lastIndex(), soit inférieur d'une unité à firstIndex(), cela équivaut à un append() ou à un prepend().

Si l’index fourni i ne se trouve pas dans la plage actuelle du cache ni n’est adjacent aux limites de la plage d’index du cache, le cache est d’abord vidé avant l’insertion de l’élément. À ce stade, le cache aura une taille de 1. Il est judicieux de s’efforcer d’insérer les éléments dans un ordre qui commence à proximité de la plage d’index actuelle du cache.

La plage des index valides pour la classe ` QContiguousCache ` va de 0 à `INT_MAX`. Une insertion en dehors de cette plage entraîne un comportement indéfini.

Voir également prepend(), append(), isFull(), firstIndex() et lastIndex().

bool QContiguousCache::isEmpty() const

Renvoie « true » si aucun élément n'est stocké dans le cache.

Voir également size() et capacity().

bool QContiguousCache::isFull() const

Renvoie « true » si le nombre d'éléments stockés dans le cache est égal à la capacité de celui-ci.

Voir également size() et capacity().

T &QContiguousCache::last()

Renvoie une référence à l'élément situé en fin de cache. Cette fonction suppose que le cache n'est pas vide.

Voir également first() et isEmpty().

const T &QContiguousCache::last() const

qsizetype QContiguousCache::lastIndex() const

Renvoie le dernier index valide présent dans le cache. L'index n'est pas valide si le cache est vide.

Voir également capacity(), size() et firstIndex().

void QContiguousCache::normalizeIndexes()

Déplace le premier et le dernier index du cache de manière à ce qu'ils pointent vers des index valides. Cette fonction ne modifie ni le contenu du cache, ni l'ordre des éléments qu'il contient.

Elle est fournie afin de permettre la correction des dépassements d’index lorsque le cache est utilisé comme tampon circulaire.

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

Voir également areIndexesValid(), append() et prepend().

void QContiguousCache::prepend(const T &value)

Insère value au début du cache. Si le cache est déjà plein, l'élément situé à la fin du cache sera supprimé.

Voir également append(), insert() et isFull().

void QContiguousCache::removeFirst()

Supprime le premier élément du cache. Cette fonction suppose que le cache n'est pas vide.

Voir également removeLast().

void QContiguousCache::removeLast()

Supprime le dernier élément du cache. Cette fonction suppose que le cache n'est pas vide.

Voir également removeFirst().

void QContiguousCache::setCapacity(qsizetype size)

Définit la capacité du cache à la valeur indiquée size. Un cache peut contenir un nombre d'éléments égal à sa capacité. Lors de l'insertion, de l'ajout à la fin ou au début du cache, si celui-ci est déjà plein, l'élément le plus éloigné de l'élément ajouté sera supprimé.

Si l’ size spécifiée est inférieure au nombre actuel d’éléments dans le cache, seuls les size derniers éléments du cache seront conservés.

Voir également capacity() et isFull().

qsizetype QContiguousCache::size() const

Renvoie le nombre d'éléments contenus dans le cache.

Voir aussi capacity().

[noexcept] void QContiguousCache::swap(QContiguousCache<T> &other)

Permute ce cache avec celui de other. Cette opération est très rapide et ne rencontre jamais d'échec.

T QContiguousCache::takeFirst()

Supprime le premier élément du cache et le renvoie. Cette fonction suppose que le cache n'est pas vide.

Si vous n'utilisez pas la valeur renvoyée, la fonction ` removeFirst()` est plus efficace.

Voir également ` takeLast()` et ` removeFirst()`.

T QContiguousCache::takeLast()

Supprime l'élément le plus récent du cache et le renvoie. Cette fonction suppose que le cache n'est pas vide.

Si vous n'utilisez pas la valeur renvoyée, la fonction ` removeLast()` est plus efficace.

Voir également takeFirst() et removeLast().

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

Renvoie ` true ` si ` other ` n'est pas égal à ce cache ; sinon, renvoie ` false`.

Deux caches sont considérés comme égaux s’ils contiennent les mêmes valeurs aux mêmes indices. Cette fonction nécessite que le type de valeur implémente l’interface operator==().

Voir également operator==().

[noexcept] QContiguousCache<T> &QContiguousCache::operator=(QContiguousCache<T> &&other)

Cette commande attribue l'other à cette instance QContiguousCache.

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

Attribue la classe « other » à ce cache et renvoie une référence à ce cache.

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

Renvoie ` true ` si ` other ` est égal à ce cache ; sinon, renvoie ` false`.

Deux caches sont considérés comme égaux s’ils contiennent les mêmes valeurs aux mêmes indices. Cette fonction nécessite que le type de valeur implémente l’interface operator==().

Voir également operator!=().

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

Renvoie l'élément situé à l'index i sous forme de référence modifiable. Si le cache ne contient pas d'élément à l'index i, il insère d'abord un élément vide à cet emplacement.

Dans la plupart des cas, il est préférable d'utiliser soit at(), soit insert().

Voir également insert() et at().

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

Comme sur (i).