QContiguousCache Class

Documentation des fonctions membres

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

Construit un cache avec l'adresse capacity.

Voir aussi setCapacity().

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

Construit une copie de other.

Cette opération prend un temps constant, car QContiguousCache est implicitement partagé. Cela rend le retour d'un QContiguousCache à partir d'une fonction très rapide. Si une instance partagée est modifiée, elle sera copiée (copy-on-write), ce qui prend un temps linéaire.

Voir aussi operator=().

QContiguousCache::~QContiguousCache()

Détruit le cache.

void QContiguousCache::append(const T &value)

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

Voir aussi prepend(), insert() et isFull().

bool QContiguousCache::areIndexesValid() const

Renvoie 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 INT_MAX de l'index ou ajoutés avant la position 0 de l'index. Cela ne devrait se produire que dans le cas d'une utilisation très longue du cache contigu dans le style des tampons circulaires. Les index peuvent être rendus à nouveau valides en appelant normalizeIndexes().

Voir aussi normalizeIndexes(), append(), et prepend().

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

Renvoie l'élément à la position d'index i dans le cache. i doit être une position d'index valide dans le cache (c'est-à-dire firstIndex() <= i <= lastIndex()).

Les index dans le cache correspondent au nombre de positions de l'élément par rapport au premier élément ajouté au cache. En d'autres termes, un cache d'une capacité de 100, auquel 150 éléments ont été ajoutés, aura une plage d'index valides comprise entre 50 et 149. Cela permet d'insérer et de récupérer des éléments dans le cache sur la base d'une liste théorique infinie

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

qsizetype QContiguousCache::available() const

Renvoie le nombre d'éléments qui peuvent être ajoutés au cache avant qu'il ne soit plein.

Voir aussi 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 la plage d'index du cache comprend l'index donné i.

Voir aussi firstIndex() et lastIndex().

qsizetype QContiguousCache::count() const

Identique à size().

T &QContiguousCache::first()

Renvoie une référence au premier élément du cache. Cette fonction suppose que le cache n'est pas vide.

Voir aussi last() et isEmpty().

const T &QContiguousCache::first() const

qsizetype QContiguousCache::firstIndex() const

Renvoie le premier index valide dans le cache. L'index sera invalide si le cache est vide.

Voir aussi capacity(), size(), et lastIndex().

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

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

Si l'index donné i n'est pas dans la plage actuelle du cache ni adjacent aux limites de la plage d'index du cache, le cache est d'abord vidé avant d'insérer l'élément. À ce stade, le cache a une taille de 1. Il est utile 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 d'index valides pour la classe QContiguousCache est comprise entre 0 et INT_MAX. L'insertion en dehors de cette plage a un comportement indéfini.

Voir aussi prepend(), append(), isFull(), firstIndex() et lastIndex().

bool QContiguousCache::isEmpty() const

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

Voir aussi size() et capacity().

bool QContiguousCache::isFull() const

Renvoie true si le nombre d'éléments stockés dans le cache est égal à la capacité du cache.

Voir aussi size() et capacity().

T &QContiguousCache::last()

Renvoie une référence au dernier élément du cache. Cette fonction suppose que le cache n'est pas vide.

Voir aussi first() et isEmpty().

const T &QContiguousCache::last() const

qsizetype QContiguousCache::lastIndex() const

Renvoie le dernier index valide dans le cache. L'index sera invalide si le cache est vide.

Voir aussi 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 pas le contenu du cache ni l'ordre des éléments dans le cache.

Elle est fournie pour que les débordements d'index puissent être corrigés lors de l'utilisation du cache 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 aussi 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 aussi 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 aussi removeLast().

void QContiguousCache::removeLast()

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

Voir aussi removeFirst().

void QContiguousCache::setCapacity(qsizetype size)

Fixe la capacité du cache à la valeur donnée size. Un cache peut contenir un nombre d'éléments égal à sa capacité. Lors de l'insertion, de l'ajout ou de l'anticipation d'éléments dans le cache, si le cache est déjà plein, l'élément le plus éloigné de l'élément ajouté sera supprimé.

Si l'adresse size est plus petite que le nombre actuel d'éléments dans le cache, seuls les derniers éléments size 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)

Remplace ce cache par other. Cette opération est très rapide et n'échoue jamais.

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 de retour, removeFirst() est plus efficace.

Voir aussi takeLast() et removeFirst().

T QContiguousCache::takeLast()

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

Si vous n'utilisez pas la valeur de retour, 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 index. Cette fonction nécessite le type de valeur pour mettre en œuvre la fonction operator==().

Voir aussi operator==().

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

Move-assigne other à cette instance QContiguousCache.

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

Affecte 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 index. Cette fonction nécessite le type de valeur pour mettre en œuvre la fonction operator==().

Voir également operator!=().

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

Renvoie l'élément à la position d'index i sous la forme d'une référence modifiable. Si le cache ne contient pas d'élément à la position d'index donnée i, il insérera d'abord un élément vide à cette position.

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

Voir aussi insert() et at().

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

Identique à at(i).