This file is indexed.

/usr/include/tse3/TempoTrack.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
/*
 * @(#)TempoTrack.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_TEMPOTRACK_H
#define TSE3_TEMPOTRACK_H

#include "tse3/listen/TempoTrack.h"

#include "tse3/Notifier.h"
#include "tse3/Playable.h"
#include "tse3/Serializable.h"
#include "tse3/EventTrack.h"

namespace TSE3
{
    /**
     * Tempo objects are simply integer values of a tempo change that occur in
     * the Song, held in the @ref TempoTrack.
     *
     * This class defines the type that is used to create tempo events,
     * which are of type @ref Event<@ref Tempo>.
     *
     * When streamed from a @ref Playable interface (using the
     * @ref TempoTrackIterator class) Tempo objects are represented by a
     * @ref MidiEvent containing a @ref MidiCommand_TSE_Meta @ref MidiCommand
     * with data 1 byte as @ref MidiCommand_TSE_Meta_Tempo.
     *
     * Tempo is a value type.
     *
     * @short   A tempo change
     * @author  Pete Goodliffe
     * @version 3.00
     * @see     TempoTrack
     * @see     Event
     */
    class Tempo
    {
        public:

            /**
             * Create a Tempo.
             *
             * @param t Tempo value
             */
            Tempo(int t = 120) : tempo(t) {}

            int tempo;

            int operator==(const Tempo &f) const { return tempo == f.tempo; }
    };

    /**
     * The TempoTrack provides a simple time ordered list of tempo changes
     * in the @ref Song.
     *
     * There is one TempoTrack per @ref Song.
     *
     * @short   A list of Tempo events
     * @author  Pete Goodliffe
     * @version 3.00
     * @see     Event
     * @see     Tempo
     */
    class TempoTrack : public EventTrack<Tempo>,
                       public Serializable
    {
        public:

            /**
             * Creates an empty TempoTrack.
             */
            TempoTrack();
            virtual ~TempoTrack();

            /**
             * Returns the status of the TempoTrack.
             *
             * A value of true means tempo events are generated, a value of
             * false means no tempo events are generated
             *
             * @return TempoTrack status
             * @see    setStatus
             */
            bool status() const { return _status; }

            /**
             * Set the TempoTrack status value.
             *
             * @param s New status
             * @see   status
             */
            void setStatus(bool s) { _status = s; }

            /**
             * @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 &i, SerializableLoadInfo &info);

        private:

            TempoTrack &operator=(const TempoTrack &);
            TempoTrack(const TempoTrack &);

            /**
             * Used by load to read events.
             */
            void loadEvents(std::istream &i, int filePPQN);

            bool _status;
    };
}

#endif