/home/pete/Work/TSE3.svn/tse3/src/tse3/EventTrack.h

Go to the documentation of this file.

/*
 * @(#)EventTrack.h 3.00 24 May 1999
 *
 * Copyright (c) 2000 Pete Goodliffe (pete@cthree.org)
 *
 * This file is part of TSE3 - the Trax Sequencer Engine version 3.00.
 *
 * This library is modifiable/redistributable under the terms of the GNU
 * General Public License.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; see the file COPYING. If not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 */

#ifndef TSE3_EVENTTRACK_H
#define TSE3_EVENTTRACK_H

#include "tse3/listen/EventTrack.h"

#include "tse3/Notifier.h"
#include "tse3/Midi.h"
#include "tse3/Playable.h"

#include <vector>
#include <algorithm>
#include <functional>
#include <cstddef>

namespace TSE3
{
    template <class etype>
    class EventTrack : public Playable,
                       public Notifier<EventTrackListener<etype> >
    {
        public:

            EventTrack(bool allowDuplicates = false) : dup(allowDuplicates) {}
            ~EventTrack() {}

            typedef Event<etype> event_type;

            size_t size() const { return data.size(); }

            event_type const &operator[](const size_t n) const
            {
                return data[n];
            }

            int index(const Clock c, bool roundup = true);

            size_t insert(const event_type &event);

            void erase(const event_type &event);

            void erase(size_t index);

        protected:

            std::vector<event_type> data;

        private:

            EventTrack &operator=(const EventTrack &);
            EventTrack(const EventTrack &);

            bool dup;
    };

    template <class etype>
    int EventTrack<etype>::index(const Clock c, bool roundup)
    {
        typename std::vector< TSE3::Event<etype> >::iterator i = data.begin();
        while (i != data.end() && !(c <= (*i).time))
        {
            ++i;
        }
        if (!roundup
            && i != data.begin()
            && (i == data.end() || (*i).time != c))
        {
            --i;
        }
        return i - data.begin();
    }

    template <class etype>
    size_t EventTrack<etype>::insert(const event_type &event)
    {
        typename std::vector<event_type>::iterator i = data.begin();
        while (i != data.end() && *i <= event) ++i;
        if (!dup && i != data.begin() && (i-1)->time == event.time)
        {
            *(i-1) = event;
            size_t index = i - data.begin();
            Notifier<EventTrackListener<etype> >::notify
                (&EventTrackListener<etype>::EventTrack_EventAltered, index);
            return index;
        }
        else
        {
            size_t index = i - data.begin();
            data.insert(i, event);
            Notifier<EventTrackListener<etype> >::notify
                (&EventTrackListener<etype>::EventTrack_EventInserted, index);
            return index;
        }
    }

    template <class etype>
    void EventTrack<etype>::erase(const event_type &event)
    {
        typename std::vector<event_type>::iterator i =
           std::find_if(data.begin(), data.end(),
                   typename event_type::equal_to(event));
        if (i != data.end())
        {
            size_t index = i - data.begin();
            data.erase(i);
            Notifier<EventTrackListener<etype> >::notify
                (&EventTrackListener<etype>::EventTrack_EventErased, index);
        }
    }

    template <class etype>
    void EventTrack<etype>::erase(size_t index)
    {
        if (index < data.size())
        {
            data.erase(data.begin()+index);
            Notifier<EventTrackListener<etype> >::notify
                (&EventTrackListener<etype>::EventTrack_EventErased, index);
        }
    }
}

#endif

---