MultiTrackSink.h

Go to the documentation of this file.

/*************************************************************************
       MultiTrackSink.h  -  template for multi-track sinks
                            -------------------
    begin                : Sat Oct 20 2007
    copyright            : (C) 2007 by Thomas Eschenbacher
    email                : Thomas.Eschenbacher@gmx.de
***************************************************************************/

/***************************************************************************
*                                                                         *
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU General Public License as published by  *
*   the Free Software Foundation; either version 2 of the License, or     *
*   (at your option) any later version.                                   *
*                                                                         *
***************************************************************************/

#ifndef MULTI_TRACK_SINK_H
#define MULTI_TRACK_SINK_H

#include "config.h"

#include <new>

#include <QList>
#include <QObject>

#include "libkwave/SampleSink.h"

namespace Kwave
{

    template <class SINK, const bool INITIALIZE>
    class MultiTrackSink: public Kwave::SampleSink,
                          private QList<SINK *>
    {
    public:
        MultiTrackSink(unsigned int tracks, QObject *parent = Q_NULLPTR)
            :Kwave::SampleSink(parent),
            QList<SINK *>()
        {
            Q_UNUSED(tracks);
            Q_ASSERT(INITIALIZE || (tracks == 0));
            Q_ASSERT(QList<SINK *>::size() == static_cast<int>(tracks));
        }

        virtual ~MultiTrackSink() Q_DECL_OVERRIDE
        {
            clear();
        }

        virtual bool done() const Q_DECL_OVERRIDE
        {
            foreach (Kwave::SampleSink *s,
                     static_cast< QList<SINK *> >(*this))
                if (s && !s->done()) return false;
            return true;
        }

        virtual unsigned int tracks() const Q_DECL_OVERRIDE
        {
            return QList<SINK *>::size();
        }

        inline virtual SINK *at(unsigned int track) const {
            return QList<SINK *>::at(track);
        }

        inline virtual SINK * operator [] (unsigned int track) Q_DECL_OVERRIDE {
            return at(track);
        }

        virtual bool insert(unsigned int track, SINK *sink) {
            QList<SINK *>::insert(track, sink);
            return (at(track) == sink);
        }

        virtual void clear() {
            while (!QList<SINK *>::isEmpty())
                delete QList<SINK *>::takeLast();
        }
    };

    template <class SINK>
    class MultiTrackSink<SINK, true>
        :public Kwave::MultiTrackSink<SINK, false>
    {
    public:
        MultiTrackSink(unsigned int tracks, QObject *parent = Q_NULLPTR)
            :Kwave::MultiTrackSink<SINK, false>(0, parent)
        {
            for (unsigned int i = 0; i < tracks; i++)
                this->insert(i, new(std::nothrow) SINK());
        }

        virtual ~MultiTrackSink() { }
    };

}

#endif /* _MULTI_TRACK_SINK_H */

//***************************************************************************
//***************************************************************************