referencecounterlist.h

Go to the documentation of this file.

//
//  referencecounterlist.h
//  MythTV
//
//  Created by Jean-Yves Avenard on 16/08/13.
//  Copyright (c) 2013 Bubblestuff Pty Ltd. All rights reserved.
//
 
#ifndef MYTHTV_REFERENCECOUNTERLIST_H
#define MYTHTV_REFERENCECOUNTERLIST_H
 
#include "mythbaseexp.h"
#include "referencecounter.h"
#include <QList>
 
template <class T>
class RefCountHandler
{
public:
    RefCountHandler() : r(new T()) { }
    RefCountHandler(T *_r) : r(_r) { r->IncrRef(); }
    RefCountHandler(const RefCountHandler &other) : r(other.r) { r->IncrRef(); }
    // The first two lines of this function are the clang-tidy
    // recommended solution to make a function properly handle
    // self-assignment.  No idea why clang-tidy doesn't recognize
    // this, unless it has something to do with templates?
    //
    // NOLINTNEXTLINE(bugprone-unhandled-self-assignment,cert-oop54-cpp)
    RefCountHandler &operator= (const RefCountHandler &other)
    {
        if (this == &other)
            return *this;
        other.r->IncrRef();
        r->DecrRef();
        r = other.r;
        return *this;
    }
    ~RefCountHandler() { r->DecrRef(); }
    operator T *() const { return r; } // Convert to T* automatically.
    T *operator*() { return r; }
    const T* operator*() const { return r; }
    T *operator->() { return r; }
    const T *operator->() const { return r; }
 
private:
    T *r; //NOLINT(readability-identifier-naming)
};
 
template <class T>
 
class RefCountedList : public QList<RefCountHandler<T> >
{
public:
    T *takeAt(int i)
    {
        RefCountHandler<T> rch = QList<RefCountHandler<T> >::takeAt(i);
        rch->IncrRef();
        return rch;
    }
    T *takeFirst(void)
    {
        RefCountHandler<T> rch = QList<RefCountHandler<T> >::takeFirst();
        rch->IncrRef();
        return rch;
    }
    T *takeLast(void)
    {
        RefCountHandler<T> rch = QList<RefCountHandler<T> >::takeLast();
        rch->IncrRef();
        return rch;
    }
    RefCountHandler<T> takeAtAndDecr(int i)
    {
        return QList<RefCountHandler<T> >::takeAt(i);
    }
    RefCountHandler<T> takeFirstAndDecr(void)
    {
        return QList<RefCountHandler<T> >::takeFirst();
    }
    RefCountHandler<T> takeLastAndDecr(void)
    {
        return QList<RefCountHandler<T> >::takeLast();
    }
    RefCountedList<T> mid(int pos, int length = -1) const
    {
        if (length < 0 || pos + length > this->size())
        {
            length = this->size() - pos;
        }
        if (pos == 0 && length == this->size())
        {
            return *this;
        }
        RefCountedList<T> cpy;
        if (length <= 0)
        {
            return cpy;
        }
        for (int i = pos; i < length; i++)
        {
            cpy.append(this->at(pos));
        }
        return cpy;
    }
    RefCountedList<T> operator+(const RefCountedList<T> &other) const
    {
        RefCountedList<T> list = *this;
        list += other;
        return list;
    }
    RefCountedList<T> &operator+=(const RefCountedList<T> &other)
    {
        QList<RefCountHandler<T> >::operator+=(other);
        return *this;
    }
    RefCountedList<T> &operator+=(const RefCountHandler<T> &value)
    {
        QList<RefCountHandler<T> >::operator+=(value);
        return *this;
    }
    RefCountedList<T> &operator<<(const RefCountedList<T> &other)
    {
        QList<RefCountHandler<T> >::operator<<(other);
        return *this;
    }
    RefCountedList<T> &operator<<(const RefCountHandler<T> &value)
    {
        QList<RefCountHandler<T> >::operator<<(value);
        return *this;
    }
    // The first two lines of this function are the clang-tidy
    // recommended solution to make a function properly handle
    // self-assignment.  No idea why clang-tidy doesn't recognize
    // this, unless it has something to do with templates?
    //
    // NOLINTNEXTLINE(bugprone-unhandled-self-assignment,cert-oop54-cpp)
    RefCountedList<T> &operator=(const RefCountedList<T> &other)
    {
        if (this == &other)
            return *this;
        QList<RefCountHandler<T> >::operator=(other);
        return *this;
    }
 
    RefCountedList() = default;
    RefCountedList(const RefCountedList&) = default;
};
 
using ReferenceCounterList = RefCountedList<ReferenceCounter>;
 
#endif /* defined(MYTHTV_REFERENCECOUNTERLIST_H) */