This file is indexed.

/usr/include/tse3/Track.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
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
/*
 * @(#)Track.h 3.00 17 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_TRACK_H
#define TSE3_TRACK_H

#include "tse3/listen/Track.h"

#include "tse3/Notifier.h"
#include "tse3/Playable.h"
#include "tse3/Serializable.h"
#include "tse3/listen/Part.h"
#include "tse3/listen/DisplayParams.h"

#include <string>
#include <cstddef>

namespace TSE3
{
    class Song;
    class MidiFilter;
    class MidiParams;

    /**
     * A Track is a subunit of a @ref Song. Many Tracks can exist in a @ref Song
     * and are played concurrently. You can imagine them to correspond to the
     * different members of a band or orchestra.
     *
     * Tracks contain a number of parameters that effect the way the musical
     * data they contain is produced.
     *
     * Tracks contain @ref Parts. They 'own' them, and so a @ref Part's lifetime
     * is bound to it's parent Track. @ref Parts are created by external
     * agents - the user of the TSE3 library. Each @ref Part has a well defined
     * start and end time, and the @ref Part objects in the Track may not
     * overlap.
     *
     * @sect Command classes
     *
     * Use the following command classes to manipute this object in a undo/redo
     * environment.
     *
     *     @li @ref TSE3::Cmd::Track_SetInfo
     *     @li @ref TSE3::Cmd::Track_Snip
     *     @li @ref TSE3::Cmd::Track_Glue
     *     @li @ref TSE3::Cmd::Track_RemovePart
     *     @li @ref TSE3::Cmd::Track_Sort
     *     @li @ref TSE3::Cmd::Song_InsertTrack
     *     @li @ref TSE3::Cmd::Song_RemoveTrack
     *     @li @ref TSE3::Cmd::Song_SoloTrack
     *     @li @ref TSE3::Cmd::Part_Move
     *
     * @short   Represents the concurrent musical sections of a Song
     * @author  Pete Goodliffe
     * @version 3.00
     * @see     Song
     * @see     Part
     */
    class Track : public Listener<PartListener>,
                  public Listener<DisplayParamsListener>,
                  public Playable,
                  public Serializable,
                  public Notifier<TrackListener>
    {

        public:

            Track();
            virtual ~Track();

            /**
             * Read the Track title.
             *
             * @return Track's title string
             * @see    setTitle
             */
            const std::string &title() const;

            /**
             * Set the Track title.
             *
             * @param s New title string
             * @see   title
             */
            void setTitle(const std::string &s);

            /**
             * @ref MidiFilter that affects how @ref MidiEvents are
             * produced by this Track.
             *
             * @return Track's @ref MidiFilter
             */
            MidiFilter *filter();

            /**
             * The Track parameters.
             *
             * @return Track's @ref MidiParams
             */
            MidiParams *params();

            /**
             * The display parameters.
             *
             * @return The Track's @ref DisplayParams object
             */
            DisplayParams *displayParams();

            /**
             * Returns a pointer to the parent @ref Song that this
             * Track has been inserted into. If this Track has not been
             * inserted in a @ref Song, this method returns zero.
             *
             * @return @ref Song this Track is inserted in
             */
            Song *parent() const;

            /**
             * The number of @ref Parts in this Track.
             *
             * @return The number of @ref Parts
             */
            size_t size() const;

            /**
             * Return the @ref Part at the given index
             *
             * The value returned for an index that is out of range is
             * undefined. The @ref size method describes the valid
             * values.
             *
             * @param  n Index
             * @return @ref Part at this index
             */
            Part *operator[](size_t n) const;

            /**
             * Inserts a @ref Part between the given times. The Track 'owns'
             * this @ref Part and will delete it when it is deleted.
             *
             * If the @ref Part cannot be inserted (due to @ref Part overlap)
             * a @ref TrackError will be thrown.
             *
             * @param  start  @ref Part's start time
             * @param  end    @ref Part's end time
             * @throws TrackError
             * @return New @ref Part. If several @ref Part objects are inserted
             *         (because @p action is @ref Part::Under) the pointer
             *         to the first @ref Part will be returned.
             */
            Part *insert(Clock start, Clock end);

            /**
             * Inserts the given @ref Part into the Track at the @ref Part's
             * times.
             *
             * This causes the @ref Part to be 'owned' by the Track, it will
             * be deleted when the Track is deleted.
             *
             * You may not pass a @ref Part that has already been inserted
             * into a different (or indeed the same) Track (the @ref TrackError
             * exception will be thrown).
             *
             * If the @ref Part cannot be inserted (due to @ref Part overlap)
             * a @ref TrackError will be thrown.
             *
             * If the @ref Part has invalid times (i.e. start after end)
             * then a @ref TrackError will be thrown.
             *
             * @param  New @ref Part to insert
             * @throws TrackError
             */
            void insert(Part *part);

            /**
             * Remove the given @ref Part.
             *
             * The @ref Part will not be deleted, it is no longer considered
             * to be 'owned' by the Track.
             *
             * If the @ref Part is not in the Track then nothing will
             * happen.
             *
             * @param part @ref Part to remove - you must now delete it
             */
            void remove(Part *part);

            /**
             * Remove the @ref Part with the given index.
             *
             * The @ref Part will not be deleted, it is no longer considered
             * to be 'owned' by the Track.
             *
             * If the index is invalid then nothing will happen.
             *
             * @param part @ref Part to remove - you must now delete it
             */
            void remove(size_t index);

            /**
             * Returns the number of @ref Part objects (or bits of @ref Part
             * objects) that exist in the Track between the given times.
             *
             * @param   start Start of time zone
             * @param   end   End of time zone
             * @returns Number of @ref Part objects between times
             */
            size_t numPartsBetween(Clock start, Clock end);

            /**
             * This less than operation compares the Tracks' title strings.
             */
            int operator<(const Track &t) const;

            /**
             * Returns the index of the first @ref Part that occurs after
             * the given @ref Clock.
             *
             * @param  c Clock value to search for
             * @return Index of first Part at or after this time.
             *         If past the end of the Track object then returns
             *         'size'.
             */
            size_t index(Clock c) const;

            /**
             * Returns the index of the specified @ref Part (or size if not
             * in this Track).
             *
             * @param  part Pointer to @refPartTrack
             * @return The index of the specified @ref Part, or @ref size()
             */
            size_t index(Part *part) const;

            /**
             * @reimplemented
             */
            virtual void Notifier_Deleted(Part *);

            /**
             * @reimplemented
             */
            virtual PlayableIterator *iterator(Clock index);

            /**
             * @reimplemented
             */
            virtual Clock lastClock() const;

            /**
             * @reimplemented
             */
            virtual void save(std::ostream &o, int i) const;

            /**
             * @reimplemented
             */
            virtual void load(std::istream &in, SerializableLoadInfo &info);

            /**
             * @reimplemented
             */
            virtual void DisplayParams_Altered(DisplayParams *);

            /**
             * The @ref Song class is a friend so that it can access the
             * @ref setParentSong() method.
             */
            friend class Song;

        private:

            Track &operator=(const Track &);
            Track(const Track &);

            /**
             * This method is called by the @ref Song class alone. It is used
             * to set the parent @ref Song pointer, song. This will be set
             * to the parent's pointer, or to zero if the Track is removed
             * from the @ref Song.
             *
             * This is the only private member the @ref Song class accesses.
             *
             * @ref parent @ref Song object that this Track has been inserted
             *             into.
             */
            void setParentSong(Song *parent);

            /**
             * A private method to insert a @ref Part into the @ref parts
             * vector. This will also set the @ref Part's parent Track and
             * attach the Track to this @ref Part.
             *
             * The @ref Part passed must be valid to be placed in the vector
             * (i.e. it must not cause an overlap, be in any other Track).
             *
             * This private method is called by other insert methods.
             *
             * The notification for Part insertion is not performed.
             *
             * @param part @ref Part to insert
             */
            void prvInsertPart(Part *part);

            class TrackImpl *pimpl;
    };
}

#endif