/usr/include/tse3/Playable.h is in libtse3-dev 0.3.1-4.3ubuntu1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 | /*
* @(#)Playable.h 3.00 20 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_PLAYABLE_H
#define TSE3_PLAYABLE_H
#include "tse3/listen/Playable.h"
#include "tse3/Notifier.h"
#include "tse3/Midi.h"
namespace TSE3
{
class PlayableIterator;
/**
* The interface that an object that can produce @ref MidiEvents must
* implement. @ref Playable objects allow a 'player' to get an iterator
* that will produce all the @ref MidiEvents in the object. Each
* implementation of @ref Playable will therefore also supply an
* implementation of @ref PlayableIterator which is accesed via the
* @ref iterator() method.
*
* Since all @ref Song components implement the Playable interface, this is
* an application of the 'Composite' pattern from the GoF book.
*
* @short A 'playable' object interface
* @author Pete Goodliffe
* @version 3.00
* @see PlayableIterator
*/
class Playable : public Notifier<PlayableListener>
{
public:
Playable() {}
virtual ~Playable() {};
/**
* Creates a new @ref PlayableIterator object and passes it to you
* ready to iterate over the @ref MidiEvents in this object.
*
* It is the user's responsibility to delete it.
*
* @param index The time at which to position the iterator
* @return New @ref PlayableIterator that emits @ref MidiEvent
* data contained in this object - you must delete the
* @ref PlayableIterator when you have finished with it.
*/
virtual PlayableIterator *iterator(Clock index) = 0;
/**
* Returns the last @ref Clock value that will be returned by
* this Playable object. Since all @ref MidiEvents are delivered
* in strict order, this will also be the greatest @ref Clock
* value returned by this Playable object.
*
* @return The last @ref Clock value in the object
*/
virtual Clock lastClock() const = 0;
protected:
Playable &operator=(const Playable &);
Playable(const Playable &);
};
/**
* This is an iterator that moves over every @ref MidiEvent in a
* @ref Playable object. Each @ref MidiEvent are delivered in time order.
* This is a use of the 'Iterator' design pattern in the GoF book.
*
* Each kind of @ref Playable object will provide an implementation of the
* PlayableIterator interface that knows how to iterate over that kind of
* object.
*
* @short Iterator over the MidiEvents in a Playable
* @author Pete Goodliffe
* @version 3.00
* @see Playable
* @see MidiEvent
*/
class PlayableIterator
{
public:
/**
* Create a PlayableIterator. Client code will never call this
* member function.
*
* @sect Important note
*
* Derived classes must attach themselves to the parent Playable
* object as listeners, and then implement @ref Listener::deleted
* properly.
*
* @internal
*/
PlayableIterator();
virtual ~PlayableIterator();
/**
* Returns the next @ref MidiEvent in the iterator
*
* @return Next @ref MidiEvent
* @see operator->
*/
const MidiEvent &operator*() const { return _next; }
/**
* Returns the next @ref MidiEvent in the iterator
*
* @return Next @ref MidiEvent
* @see operator*
*/
const MidiEvent *operator->() const { return &_next; }
/**
* Returns whether there are any more events to come; i.e.
* whether @ref operator++ is valid on this object.
*
* @return Whether there are any more events
*/
bool more() const { return _more; }
/**
* Moves the iterator to the given time position.
*
* @param c Time to move iterator to.
*/
virtual void moveTo(Clock /*c*/) { _more = false; }
/**
* Increments the iterator, so that it will return the next
* @ref MidiEvent in the Playable.
*/
PlayableIterator &operator++();
//PlayableIterator operator++(int);
// We can't implement this operator: it is impossible to
// make a copy of a PlayableIterator: there is no
// copy constructor.
protected:
virtual void getNextEvent() = 0;
MidiEvent _next; // Implementations must put the next MidiEvent
// in here.
bool _more; // Implementations must define whether or not
// this is true.
private:
PlayableIterator &operator=(const PlayableIterator &);
PlayableIterator(const PlayableIterator &);
};
}
#endif
|