Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
My implementation of a "QList of References", under the hood it stores pointers, but all of the methods recieve and return references.
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* ReferenceList.hpp *
* *
* Copyright 2014 Tory Gaurnier <tory.gaurnier@linuxmail.org> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU Lesser General Public License as published by *
* the Free Software Foundation; version 3. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU Lesser General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#ifndef REFERENCELIST_HPP
#define REFERENCELIST_HPP
#include <QDataStream>
#include <QDebug>
#include <QList>
/**
* class ReferenceList
*
* Uses QList under the hood to store pointers, on the surface receives and returns nothing but the
* references.
*
* NOTE: Any method that calls its QList<T*> counterpart with parameter T, T must not be const, if
* it is then QList<T*> would have to be QList<const T *const> instead.
*/
template<class T>
class ReferenceList : public QList<T*> {
public:
// Forward declare iterators
class const_iterator;
class iterator;
// Set iterators as friends
friend class const_iterator;
friend class iterator;
ReferenceList() {}
ReferenceList(const QList<T*> &other) : QList<T*>(other) { }
ReferenceList(const ReferenceList<T> &other) : QList<T*>(other) { }
ReferenceList(ReferenceList<T> &&other) : QList<T*>(std::move(other)) { }
~ReferenceList() {}
void append(T &value) {
QList<T*>::append(&value);
}
void append(const ReferenceList<T> other) {
QList<T*>::append(other);
}
const T & at(int i) const {
return *QList<T*>::at(i);
}
T & back() {
return *QList<T*>::back();
}
const T & back() const {
return *QList<T*>::back();
}
iterator begin() {
return iterator(iterator(QList<T*>::begin()));
}
const_iterator begin() const {
return const_iterator(QList<T*>::begin());
}
const_iterator cbegin() const {
return const_iterator(QList<T*>::cbegin());
}
const_iterator cend() const {
return const_iterator(QList<T*>::cend());
}
void clear() {
QList<T*>::clear();
}
const_iterator constBegin() const {
return const_iterator(QList<T*>::constBegin());
}
const_iterator constEnd() const {
return const_iterator(QList<T*>::constEnd());
}
bool contains(T &value) const {
return QList<T*>::contains(&value);
}
int count(T &value) const {
return QList<T*>::count(&value);
}
int count() const {
return QList<T*>::count();
}
bool empty() const {
return QList<T*>::empty();
}
iterator end() {
return iterator(QList<T*>::end());
}
const_iterator end() const {
return const_iterator(QList<T*>::end());
}
bool endsWith(T &value) const {
return QList<T*>::endsWith(&value);
}
iterator erase(iterator pos) {
return iterator(QList<T*>::erase(pos));
}
iterator erase(iterator begin, iterator end) {
return iterator(QList<T*>::erase(begin, end));
}
T & first() {
return *QList<T*>::first();
}
const T & first() const {
return *QList<T*>::first();
}
/**
* Inherited "from" methods are unsupported.
*/
static ReferenceList<T> fromSet(const QSet<T> & set) = delete;
static ReferenceList<T> fromStdList(const std::list<T> & list) = delete;
static ReferenceList<T> fromVector(const QVector<T> & vector) = delete;
T & front() {
return *QList<T*>::front();
}
const T & front() const {
return *QList<T*>::front();
}
int indexOf(T &value, int from = 0) const {
return QList<T*>::indexOf(&value, from);
}
void insert(int i, T &value) {
QList<T*>::insert(i, &value);
}
iterator insert(iterator before, T &value) {
return iterator(QList<T*>::insert(before, &value));
}
bool isEmpty() const {
return QList<T*>::isEmpty();
}
T & last() {
return *QList<T*>::last();
}
const T & last() const {
return *QList<T*>::last();
}
int lastIndexOf(T &value, int from = -1) const {
return QList<T*>::lastIndexOf(&value, from);
}
int length() const {
return QList<T*>::length();
}
ReferenceList<T> mid(int pos, int length = -1) const {
return ReferenceList<T>(QList<T*>::mid(pos, length));
}
void move(int from, int to) {
QList<T*>::move(from, to);
}
void pop_back() {
QList<T*>::pop_back();
}
void pop_front() {
QList<T*>::pop_front();
}
void prepend(T &value) {
QList<T*>::prepend(&value);
}
void push_back(T &value) {
QList<T*>::push_back(&value);
}
void push_front(T &value) {
QList<T*>::push_front(&value);
}
int removeAll(T &value) {
return QList<T*>::removeAll(&value);
}
void removeAt(int i) {
QList<T*>::removeAt(i);
}
void removeFirst() {
QList<T*>::removeFirst();
}
void removeLast() {
QList<T*>::removeLast();
}
bool removeOne(T &value) {
return QList<T*>::removeOne(&value);
}
void replace(int i, T &value) {
QList<T*>::replace(i, &value);
}
void reserve(int alloc) {
QList<T*>::reserve(alloc);
}
int size() const {
return QList<T*>::size();
}
bool startsWith(T &value) const {
return QList<T*>::startsWith(&value);
}
void swap(ReferenceList<T> &other) {
QList<T*>::swap(other);
}
void swap(int i, int j) {
QList<T*>::swap(i, j);
}
T & takeAt(int i) {
return *QList<T*>::takeAt(i);
}
T & takeFirst() {
return *QList<T*>::takeFirst();
}
T & takeLast() {
return *QList<T*>::takeLast();
}
/**
* Inherited "to" methods are not supported.
*/
QSet<T> toSet() const = delete;
std::list<T> toStdList() const = delete;
QVector<T> toVector() const = delete;
T & value(int i) const {
return *QList<T*>::value(i);
}
T & value(int i, T &default_value) const {
return *QList<T*>::value(i, &default_value);
}
bool operator!=(const ReferenceList<T> &other) const {
return QList<T*>::operator!=(other);
}
ReferenceList<T> operator+(const ReferenceList<T> &other) const {
return ReferenceList<T>(QList<T*>::operator+(other));
}
ReferenceList<T> & operator+=(const ReferenceList<T> &other) {
QList<T*>::operator+=(other);
return *this;
}
ReferenceList<T> & operator+=(T &value) {
QList<T*>::operator+=(&value);
return *this;
}
ReferenceList<T> & operator<<(const ReferenceList<T> &other) {
QList<T*>::operator<<(other);
return *this;
}
ReferenceList<T> & operator<<(T &value) {
QList<T*>::operator<<(&value);
return *this;
}
ReferenceList<T> & operator=(ReferenceList<T> &other) {
QList<T*>::operator=(other);
return *this;
}
ReferenceList & operator=(ReferenceList<T> &&other) {
QList<T*>::operator=(std::move(other));
return *this;
}
bool operator==(const ReferenceList<T> &other) const {
return QList<T*>::operator==(other);
}
T & operator[](int i) {
return *QList<T*>::operator[](i);
}
const T & operator[](int i) const {
return *QList<T*>::operator[](i);
}
class iterator : public QList<T*>::iterator {
public:
iterator() { }
iterator(const typename QList<T*>::iterator &other)
: QList<T*>::iterator(other) { }
iterator(const iterator &other) : QList<T*>::iterator(other) { }
T & operator*() const { return *QList<T*>::iterator::operator*(); }
T * operator->() const { return *QList<T*>::iterator::operator->(); }
T & operator[](int j) const { return *QList<T*>::iterator::operator[](j); }
};
class const_iterator : public QList<T*>::const_iterator {
public:
const_iterator() { }
const_iterator(const typename QList<T*>::const_iterator &other)
: QList<T*>::const_iterator(other) { }
const_iterator(const const_iterator &other)
: QList<T*>::const_iterator(other) { }
const_iterator(const iterator &other)
: QList<T*>::const_iterator(other) { }
T & operator*() const { return *QList<T*>::const_iterator::operator*(); }
T * operator->() const { return *QList<T*>::const_iterator::operator->(); }
T & operator[](int j) const { return *QList<T*>::const_iterator::operator[](j); }
};
};
/**
* Implement QDebug << operator so that it will print out values rather than pointer addresses (do
* to it implicitly converting to QList<T*>).
*/
template <class T>
QDebug operator<<(QDebug debug, const ReferenceList<T> &list) {
debug.nospace() << '(';
for(typename QList<T>::size_type i = 0; i < list.count(); ++i) {
if(i) debug << ", ";
debug << list.at(i);
}
debug << ')';
return debug.space();
}
/**
* QDataStream << ReferenceList<T> should have same output as the QDataStream << QList<T>.
*/
template<class T>
QDataStream & operator<<(QDataStream &out, const ReferenceList<T>& list) {
out << quint32(list.size());
for(int i = 0; i < list.size(); ++i) out << list.at(i);
return out;
}
/**
* Make sure QDataStream >> is not callable, there is no scenario where it would be useful with a
* ReferenceList.
*/
template<class T>
QDataStream & operator>>(QDataStream &out, const ReferenceList<T>& list) = delete;
#endif
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment