QDjangoQuerySet.h

/*
 * Copyright (C) 2010-2015 Jeremy Lainé
 * Copyright (C) 2011 Mathias Hasselmann
 * Contact: https://github.com/jlaine/qdjango
 *
 * This file is part of the QDjango Library.
 *
 * This library 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; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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.
 */

#ifndef QDJANGO_QUERYSET_H
#define QDJANGO_QUERYSET_H

#include "QDjango.h"
#include "QDjangoWhere.h"
#include "QDjangoQuerySet_p.h"

template <class T>
    class QDjangoQuerySet
{
public:
    typedef int size_type;
    typedef T value_type;
    typedef value_type *pointer;
    typedef const value_type *const_pointer;
    typedef value_type &reference;
    typedef const value_type &const_reference;
    typedef qptrdiff difference_type;
    class const_iterator
    {
        friend class QDjangoQuerySet;

    public:
        typedef std::bidirectional_iterator_tag  iterator_category;

        typedef qptrdiff difference_type;
        typedef T value_type;
        typedef T *pointer;
        typedef T &reference;
        const_iterator()
            : m_querySet(0)
            , m_fetched(-1)
            , m_offset(0)
        {
        }

        const_iterator(const const_iterator &other)
            : m_querySet(other.m_querySet)
            , m_fetched(-1)
            , m_offset(other.m_offset)
        {
        }

    private:
        const_iterator(const QDjangoQuerySet<T> *querySet, int offset = 0)
            : m_querySet(querySet)
            , m_fetched(-1)
            , m_offset(offset)
        {
        }

    public:
        const T &operator*() const { return *t(); }

        const T *operator->() const { return t(); }


        bool operator==(const const_iterator &other) const
        {
            return m_querySet == other.m_querySet && m_offset == other.m_offset;
        }

        bool operator!=(const const_iterator &other) const
        {
            return m_querySet != other.m_querySet || m_offset != other.m_offset;
        }

        bool operator<(const const_iterator& other) const
        {
            return (m_querySet == other.m_querySet && m_offset < other.m_offset)
                    || m_querySet < other.m_querySet;
        }

        bool operator<=(const const_iterator& other) const
        {
            return (m_querySet == other.m_querySet && m_offset <= other.m_offset)
                    || m_querySet < other.m_querySet;
        }

        bool operator>(const const_iterator& other) const
        {
            return (m_querySet == other.m_querySet && m_offset > other.m_offset)
                    || m_querySet > other.m_querySet;
        }

        bool operator>=(const const_iterator& other) const
        {
            return (m_querySet == other.m_querySet && m_offset >= other.m_offset)
                    || m_querySet > other.m_querySet;
        }

        const_iterator &operator++() { ++m_offset; return *this; }

        const_iterator operator++(int) { const_iterator n(*this); ++m_offset; return n; }

        const_iterator &operator+=(int i) { m_offset += i; return *this; }

        const_iterator operator+(int i) const { return const_iterator(m_querySet, m_offset + i); }

        const_iterator &operator-=(int i) { m_offset -= i; return *this; }

        const_iterator operator-(int i) const { return const_iterator(m_querySet, m_offset - i); }

        const_iterator &operator--() { --m_offset; return *this; }

        const_iterator operator--(int) { const_iterator n(*this); --m_offset; return n; }


        difference_type operator-(const const_iterator &other) const { return m_offset - other.m_offset; }

    private:
        const T *t() const
        {
            if (m_fetched != m_offset && m_querySet) {
                if (const_cast<QDjangoQuerySet<T> *>(m_querySet)->at(m_offset, &m_object)) {
                    m_fetched = m_offset;
                }
            }

            return m_fetched == m_offset ? &m_object : 0;
        }

    private:
        const QDjangoQuerySet<T> *m_querySet;
        mutable int m_fetched;
        mutable T m_object;

        int m_offset;
    };

    typedef const_iterator ConstIterator;

    QDjangoQuerySet();
    QDjangoQuerySet(const QDjangoQuerySet<T> &other);
    ~QDjangoQuerySet();

    QDjangoQuerySet all() const;
    QDjangoQuerySet exclude(const QDjangoWhere &where) const;
    QDjangoQuerySet filter(const QDjangoWhere &where) const;
    QDjangoQuerySet limit(int pos, int length = -1) const;
    QDjangoQuerySet none() const;
    QDjangoQuerySet orderBy(const QStringList &keys) const;
    QDjangoQuerySet selectRelated() const;

    int count() const;
    QDjangoWhere where() const;

    bool remove();
    int size();
    int update(const QVariantMap &fields);
    QList<QVariantMap> values(const QStringList &fields = QStringList());
    QList<QVariantList> valuesList(const QStringList &fields = QStringList());

    T *get(const QDjangoWhere &where, T *target = 0) const;
    T *at(int index, T *target = 0);

    const_iterator constBegin() const;
    const_iterator begin() const;

    const_iterator constEnd() const;
    const_iterator end() const;

    QDjangoQuerySet<T> &operator=(const QDjangoQuerySet<T> &other);

private:
    QDjangoQuerySetPrivate *d;
};

template <class T>
QDjangoQuerySet<T>::QDjangoQuerySet()
{
    d = new QDjangoQuerySetPrivate(T::staticMetaObject.className());
}

template <class T>
QDjangoQuerySet<T>::QDjangoQuerySet(const QDjangoQuerySet<T> &other)
{
    other.d->counter.ref();
    d = other.d;
}

template <class T>
QDjangoQuerySet<T>::~QDjangoQuerySet()
{
    if (!d->counter.deref())
        delete d;
}

template <class T>
T *QDjangoQuerySet<T>::at(int index, T *target)
{
    T *entry = target ? target : new T;
    if (!d->sqlLoad(entry, index))
    {
        if (!target)
            delete entry;
        return 0;
    }
    return entry;
}

template <class T>
typename QDjangoQuerySet<T>::const_iterator QDjangoQuerySet<T>::constBegin() const
{
    return const_iterator(this);
}

template <class T>
typename QDjangoQuerySet<T>::const_iterator QDjangoQuerySet<T>::begin() const
{
    return const_iterator(this);
}

template <class T>
typename QDjangoQuerySet<T>::const_iterator QDjangoQuerySet<T>::constEnd() const
{
    return const_iterator(this, QDjangoQuerySet<T>::count());
}

template <class T>
typename QDjangoQuerySet<T>::const_iterator QDjangoQuerySet<T>::end() const
{
    return const_iterator(this, QDjangoQuerySet<T>::count());
}

template <class T>
QDjangoQuerySet<T> QDjangoQuerySet<T>::all() const
{
    QDjangoQuerySet<T> other;
    other.d->lowMark = d->lowMark;
    other.d->highMark = d->highMark;
    other.d->orderBy = d->orderBy;
    other.d->selectRelated = d->selectRelated;
    other.d->whereClause = d->whereClause;
    return other;
}

template <class T>
int QDjangoQuerySet<T>::count() const
{
    if (d->hasResults)
        return d->properties.size();

    // execute COUNT query
    QDjangoQuery query(d->countQuery());
    if (!query.exec() || !query.next())
        return -1;
    return query.value(0).toInt();
}

template <class T>
QDjangoQuerySet<T> QDjangoQuerySet<T>::exclude(const QDjangoWhere &where) const
{
    QDjangoQuerySet<T> other = all();
    other.d->addFilter(!where);
    return other;
}

template <class T>
QDjangoQuerySet<T> QDjangoQuerySet<T>::filter(const QDjangoWhere &where) const
{
    QDjangoQuerySet<T> other = all();
    other.d->addFilter(where);
    return other;
}

template <class T>
T *QDjangoQuerySet<T>::get(const QDjangoWhere &where, T *target) const
{
    QDjangoQuerySet<T> qs = filter(where);
    return qs.size() == 1 ? qs.at(0, target) : 0;
}

template <class T>
QDjangoQuerySet<T> QDjangoQuerySet<T>::limit(int pos, int length) const
{
    Q_ASSERT(pos >= 0);
    Q_ASSERT(length >= -1);

    QDjangoQuerySet<T> other = all();
    other.d->lowMark += pos;
    if (length > 0)
    {
        // calculate new high mark
        other.d->highMark = other.d->lowMark + length;
        // never exceed the current high mark
        if (d->highMark > 0 && other.d->highMark > d->highMark)
            other.d->highMark = d->highMark;
    }
    return other;
}

template <class T>
QDjangoQuerySet<T> QDjangoQuerySet<T>::none() const
{
    QDjangoQuerySet<T> other;
    other.d->whereClause = !QDjangoWhere();
    return other;
}

template <class T>
QDjangoQuerySet<T> QDjangoQuerySet<T>::orderBy(const QStringList &keys) const
{
    // it is not possible to change ordering once a limit has been set
    Q_ASSERT(!d->lowMark && !d->highMark);

    QDjangoQuerySet<T> other = all();
    other.d->orderBy << keys;
    return other;
}

template <class T>
bool QDjangoQuerySet<T>::remove()
{
    return d->sqlDelete();
}

template <class T>
QDjangoQuerySet<T> QDjangoQuerySet<T>::selectRelated() const
{
    QDjangoQuerySet<T> other = all();
    other.d->selectRelated = true;
    return other;
}

template <class T>
int QDjangoQuerySet<T>::size()
{
    if (!d->sqlFetch())
        return -1;
    return d->properties.size();
}

template <class T>
int QDjangoQuerySet<T>::update(const QVariantMap &fields)
{
    return d->sqlUpdate(fields);
}

template <class T>
QList<QVariantMap> QDjangoQuerySet<T>::values(const QStringList &fields)
{
    return d->sqlValues(fields);
}

template <class T>
QList<QVariantList> QDjangoQuerySet<T>::valuesList(const QStringList &fields)
{
    return d->sqlValuesList(fields);
}

template <class T>
QDjangoWhere QDjangoQuerySet<T>::where() const
{
    return d->resolvedWhere(QDjango::database());
}

template <class T>
QDjangoQuerySet<T> &QDjangoQuerySet<T>::operator=(const QDjangoQuerySet<T> &other)
{
    other.d->counter.ref();
    if (!d->counter.deref())
        delete d;
    d = other.d;
    return *this;
}

#endif