Move Beats et al. to mixxx namespace

10 files changed, 103 insertions, 73 deletions

diff --git a/src/track/beatfactory.cpp b/src/track/beatfactory.cpp
index 92b2fd0591..a5fb85ff9d 100644
--- a/src/track/beatfactory.cpp
+++ b/src/track/beatfactory.cpp
@@ -6,35 +6,36 @@
 #include "track/beatfactory.h"
 #include "track/beatutils.h"
 
-BeatsPointer BeatFactory::loadBeatsFromByteArray(const Track& track,
-                                                 QString beatsVersion,
-                                                 QString beatsSubVersion,
-                                                 const QByteArray& beatsSerialized) {
+mixxx::BeatsPointer BeatFactory::loadBeatsFromByteArray(const Track& track,
+        QString beatsVersion,
+        QString beatsSubVersion,
+        const QByteArray& beatsSerialized) {
     if (beatsVersion == BEAT_GRID_1_VERSION ||
         beatsVersion == BEAT_GRID_2_VERSION) {
-        BeatGrid* pGrid = new BeatGrid(track, 0, beatsSerialized);
+        mixxx::BeatGrid* pGrid = new mixxx::BeatGrid(track, 0, beatsSerialized);
         pGrid->setSubVersion(beatsSubVersion);
         qDebug() << "Successfully deserialized BeatGrid";
-        return BeatsPointer(pGrid, &BeatFactory::deleteBeats);
+        return mixxx::BeatsPointer(pGrid, &BeatFactory::deleteBeats);
     } else if (beatsVersion == BEAT_MAP_VERSION) {
-        BeatMap* pMap = new BeatMap(track, 0, beatsSerialized);
+        mixxx::BeatMap* pMap = new mixxx::BeatMap(track, 0, beatsSerialized);
         pMap->setSubVersion(beatsSubVersion);
         qDebug() << "Successfully deserialized BeatMap";
-        return BeatsPointer(pMap, &BeatFactory::deleteBeats);
+        return mixxx::BeatsPointer(pMap, &BeatFactory::deleteBeats);
     }
     qDebug() << "BeatFactory::loadBeatsFromByteArray could not parse serialized beats.";
-    return BeatsPointer();
+    return mixxx::BeatsPointer();
 }
 
-BeatsPointer BeatFactory::makeBeatGrid(const Track& track, double dBpm,
-                                       double dFirstBeatSample) {
-    BeatGrid* pGrid = new BeatGrid(track, 0);
+mixxx::BeatsPointer BeatFactory::makeBeatGrid(
+        const Track& track, double dBpm, double dFirstBeatSample) {
+    mixxx::BeatGrid* pGrid = new mixxx::BeatGrid(track, 0);
     pGrid->setGrid(dBpm, dFirstBeatSample);
-    return BeatsPointer(pGrid, &BeatFactory::deleteBeats);
+    return mixxx::BeatsPointer(pGrid, &BeatFactory::deleteBeats);
 }
 
 // static
-QString BeatFactory::getPreferredVersion(const bool bEnableFixedTempoCorrection) {
+QString BeatFactory::getPreferredVersion(
+        const bool bEnableFixedTempoCorrection) {
     if (bEnableFixedTempoCorrection) {
         return BEAT_GRID_2_VERSION;
     }
@@ -42,55 +43,64 @@ QString BeatFactory::getPreferredVersion(const bool bEnableFixedTempoCorrection)
 }
 
 QString BeatFactory::getPreferredSubVersion(
-    const bool bEnableFixedTempoCorrection,
-    const bool bEnableOffsetCorrection,
-    const int iMinBpm, const int iMaxBpm,
-    const QHash<QString, QString> extraVersionInfo) {
+        const bool bEnableFixedTempoCorrection,
+        const bool bEnableOffsetCorrection,
+        const int iMinBpm,
+        const int iMaxBpm,
+        const QHash<QString, QString> extraVersionInfo) {
     const char* kSubVersionKeyValueSeparator = "=";
     const char* kSubVersionFragmentSeparator = "|";
     QStringList fragments;
 
     // min/max BPM limits only apply to fixed-tempo assumption
     if (bEnableFixedTempoCorrection) {
-        fragments << QString("min_bpm%1%2").arg(kSubVersionKeyValueSeparator,
-                                                QString::number(iMinBpm));
-        fragments << QString("max_bpm%1%2").arg(kSubVersionKeyValueSeparator,
-                                                QString::number(iMaxBpm));
+        fragments << QString("min_bpm%1%2")
+                             .arg(kSubVersionKeyValueSeparator,
+                                     QString::number(iMinBpm));
+        fragments << QString("max_bpm%1%2")
+                             .arg(kSubVersionKeyValueSeparator,
+                                     QString::number(iMaxBpm));
     }
 
     QHashIterator<QString, QString> it(extraVersionInfo);
     while (it.hasNext()) {
         it.next();
         if (it.key().contains(kSubVersionKeyValueSeparator) ||
-            it.key().contains(kSubVersionFragmentSeparator) ||
-            it.value().contains(kSubVersionKeyValueSeparator) ||
-            it.value().contains(kSubVersionFragmentSeparator)) {
-            qDebug() << "ERROR: Your analyzer key/value contains invalid characters:"
+                it.key().contains(kSubVersionFragmentSeparator) ||
+                it.value().contains(kSubVersionKeyValueSeparator) ||
+                it.value().contains(kSubVersionFragmentSeparator)) {
+            qDebug() << "ERROR: Your analyzer key/value contains invalid "
+                        "characters:"
                      << it.key() << ":" << it.value() << "Skipping.";
             continue;
         }
         fragments << QString("%1%2%3").arg(
-            it.key(), kSubVersionKeyValueSeparator, it.value());
+                it.key(), kSubVersionKeyValueSeparator, it.value());
     }
     if (bEnableFixedTempoCorrection && bEnableOffsetCorrection) {
         fragments << QString("offset_correction%1%2")
-                .arg(kSubVersionKeyValueSeparator, QString::number(1));
+                             .arg(kSubVersionKeyValueSeparator,
+                                     QString::number(1));
     }
 
-    fragments << QString("rounding%1%2").
-            arg(kSubVersionKeyValueSeparator, QString::number(0.05));
+    fragments << QString("rounding%1%2")
+                         .arg(kSubVersionKeyValueSeparator,
+                                 QString::number(0.05));
 
     std::sort(fragments.begin(), fragments.end());
-    return (fragments.size() > 0) ? fragments.join(kSubVersionFragmentSeparator) : "";
+    return (fragments.size() > 0) ? fragments.join(kSubVersionFragmentSeparator)
+                                  : "";
 }
 
-
-BeatsPointer BeatFactory::makePreferredBeats(
-    const Track& track, QVector<double> beats,
-    const QHash<QString, QString> extraVersionInfo,
-    const bool bEnableFixedTempoCorrection, const bool bEnableOffsetCorrection,
-    const int iSampleRate, const int iTotalSamples,
-    const int iMinBpm, const int iMaxBpm) {
+mixxx::BeatsPointer BeatFactory::makePreferredBeats(const Track& track,
+        QVector<double> beats,
+        const QHash<QString, QString> extraVersionInfo,
+        const bool bEnableFixedTempoCorrection,
+        const bool bEnableOffsetCorrection,
+        const int iSampleRate,
+        const int iTotalSamples,
+        const int iMinBpm,
+        const int iMaxBpm) {
     const QString version = getPreferredVersion(bEnableFixedTempoCorrection);
     const QString subVersion = getPreferredSubVersion(bEnableFixedTempoCorrection,
                                                       bEnableOffsetCorrection,
@@ -103,22 +113,22 @@ BeatsPointer BeatFactory::makePreferredBeats(
         double firstBeat = BeatUtils::calculateFixedTempoFirstBeat(
             bEnableOffsetCorrection,
             beats, iSampleRate, iTotalSamples, globalBpm);
-        BeatGrid* pGrid = new BeatGrid(track, iSampleRate);
+        mixxx::BeatGrid* pGrid = new mixxx::BeatGrid(track, iSampleRate);
         // firstBeat is in frames here and setGrid() takes samples.
         pGrid->setGrid(globalBpm, firstBeat * 2);
         pGrid->setSubVersion(subVersion);
-        return BeatsPointer(pGrid, &BeatFactory::deleteBeats);
+        return mixxx::BeatsPointer(pGrid, &BeatFactory::deleteBeats);
     } else if (version == BEAT_MAP_VERSION) {
-        BeatMap* pBeatMap = new BeatMap(track, iSampleRate, beats);
+        mixxx::BeatMap* pBeatMap = new mixxx::BeatMap(track, iSampleRate, beats);
         pBeatMap->setSubVersion(subVersion);
-        return BeatsPointer(pBeatMap, &BeatFactory::deleteBeats);
+        return mixxx::BeatsPointer(pBeatMap, &BeatFactory::deleteBeats);
     } else {
         qDebug() << "ERROR: Could not determine what type of beatgrid to create.";
-        return BeatsPointer();
+        return mixxx::BeatsPointer();
     }
 }
 
-void BeatFactory::deleteBeats(Beats* pBeats) {
+void BeatFactory::deleteBeats(mixxx::Beats* pBeats) {
     // BeatGrid/BeatMap objects have no parent and live in the same thread as
     // their associated TIO. QObject::deleteLater does not have the desired
     // effect when the QObject's thread does not have an event loop (i.e. when
diff --git a/src/track/beatfactory.h b/src/track/beatfactory.h
index 5e2eba252e..cb25021f19 100644
--- a/src/track/beatfactory.h
+++ b/src/track/beatfactory.h
@@ -8,12 +8,13 @@
 
 class BeatFactory {
   public:
-    static BeatsPointer loadBeatsFromByteArray(const Track& track,
-                                               QString beatsVersion,
-                                               QString beatsSubVersion,
-                                               const QByteArray& beatsSerialized);
-    static BeatsPointer makeBeatGrid(const Track& track,
-                                     double dBpm, double dFirstBeatSample);
+    static mixxx::BeatsPointer loadBeatsFromByteArray(const Track& track,
+            QString beatsVersion,
+            QString beatsSubVersion,
+            const QByteArray& beatsSerialized);
+    static mixxx::BeatsPointer makeBeatGrid(const Track& track,
+            double dBpm,
+            double dFirstBeatSample);
 
     static QString getPreferredVersion(const bool bEnableFixedTempoCorrection);
 
@@ -23,16 +24,18 @@ class BeatFactory {
         const int iMinBpm, const int iMaxBpm,
         const QHash<QString, QString> extraVersionInfo);
 
-    static BeatsPointer makePreferredBeats(
-        const Track& track, QVector<double> beats,
-        const QHash<QString, QString> extraVersionInfo,
-        const bool bEnableFixedTempoCorrection,
-        const bool bEnableOffsetCorrection,
-        const int iSampleRate, const int iTotalSamples,
-        const int iMinBpm, const int iMaxBpm);
+    static mixxx::BeatsPointer makePreferredBeats(const Track& track,
+            QVector<double> beats,
+            const QHash<QString, QString> extraVersionInfo,
+            const bool bEnableFixedTempoCorrection,
+            const bool bEnableOffsetCorrection,
+            const int iSampleRate,
+            const int iTotalSamples,
+            const int iMinBpm,
+            const int iMaxBpm);
 
   private:
-    static void deleteBeats(Beats* pBeats);
+    static void deleteBeats(mixxx::Beats* pBeats);
 };
 
 #endif /* BEATFACTORY_H */
diff --git a/src/track/beatgrid.cpp b/src/track/beatgrid.cpp
index c76b015393..815314f736 100644
--- a/src/track/beatgrid.cpp
+++ b/src/track/beatgrid.cpp
@@ -11,6 +11,8 @@ struct BeatGridData {
     double firstBeat;
 };
 
+namespace mixxx {
+
 class BeatGridIterator : public BeatIterator {
   public:
     BeatGridIterator(double dBeatLength, double dFirstBeat, double dEndSample)
@@ -362,3 +364,5 @@ void BeatGrid::setBpm(double dBpm) {
     locker.unlock();
     emit updated();
 }
+
+} // namespace mixxx
diff --git a/src/track/beatgrid.h b/src/track/beatgrid.h
index d671129f7f..f1f09faf28 100644
--- a/src/track/beatgrid.h
+++ b/src/track/beatgrid.h
@@ -10,6 +10,8 @@
 #define BEAT_GRID_1_VERSION "BeatGrid-1.0"
 #define BEAT_GRID_2_VERSION "BeatGrid-2.0"
 
+namespace mixxx {
+
 // BeatGrid is an implementation of the Beats interface that implements an
 // infinite grid of beats, aligned to a song simply by a starting offset of the
 // first beat and the song's average beats-per-minute.
@@ -94,5 +96,6 @@ class BeatGrid final : public Beats {
     double m_dBeatLength;
 };
 
+} // namespace mixxx
 
 #endif /* BEATGRID_H */
diff --git a/src/track/beatmap.cpp b/src/track/beatmap.cpp
index 48aa6ffb86..37dc5e51fe 100644
--- a/src/track/beatmap.cpp
+++ b/src/track/beatmap.cpp
@@ -30,6 +30,8 @@ bool BeatLessThan(const Beat& beat1, const Beat& beat2) {
     return beat1.frame_position() < beat2.frame_position();
 }
 
+namespace mixxx {
+
 class BeatMapIterator : public BeatIterator {
   public:
     BeatMapIterator(BeatList::const_iterator start, BeatList::const_iterator end)
@@ -722,3 +724,5 @@ double BeatMap::calculateBpm(const Beat& startBeat, const Beat& stopBeat) const
 
     return BeatUtils::calculateBpm(beatvect, m_iSampleRate, 0, 9999);
 }
+
+} // namespace mixxx
diff --git a/src/track/beatmap.h b/src/track/beatmap.h
index bb1403eb74..5d1ce7df57 100644
--- a/src/track/beatmap.h
+++ b/src/track/beatmap.h
@@ -18,6 +18,8 @@
 
 typedef QList<mixxx::track::io::Beat> BeatList;
 
+namespace mixxx {
+
 class BeatMap final : public Beats {
   public:
     // Construct a BeatMap. iSampleRate may be provided if a more accurate
@@ -109,4 +111,5 @@ class BeatMap final : public Beats {
     BeatList m_beats;
 };
 
+} // namespace mixxx
 #endif /* BEATMAP_H_ */
diff --git a/src/track/beats.cpp b/src/track/beats.cpp
index 80510c4e5d..307f0a6b9a 100644
--- a/src/track/beats.cpp
+++ b/src/track/beats.cpp
@@ -1,7 +1,7 @@
 
 #include "track/beats.h"
 
-
+namespace mixxx {
 
 int Beats::numBeatsInRange(double dStartSample, double dEndSample) {
     double dLastCountedBeat = 0.0;
@@ -53,3 +53,4 @@ double Beats::findNBeatsFromSample(double fromSample, double beats) const {
     return nthBeat;
 };
 
+} // namespace mixxx
diff --git a/src/track/beats.h b/src/track/beats.h
index 5c93d65e43..1ec09096d7 100644
--- a/src/track/beats.h
+++ b/src/track/beats.h
@@ -14,6 +14,8 @@ namespace {
     double kMaxBpm = 500;
 }
 
+namespace mixxx {
+
 class Beats;
 typedef QSharedPointer<Beats> BeatsPointer;
 
@@ -171,4 +173,5 @@ class Beats : public QObject {
     void updated();
 };
 
+} // namespace mixxx
 #endif /* BEATS_H */
diff --git a/src/track/track.cpp b/src/track/track.cpp
index cb0335782d..d15bd51260 100644
--- a/src/track/track.cpp
+++ b/src/track/track.cpp
@@ -42,10 +42,9 @@ bool compareAndSet(T* pField, const T& value) {
     }
 }
 
-inline
-mixxx::Bpm getActualBpm(
+inline mixxx::Bpm getActualBpm(
         mixxx::Bpm bpm,
-        BeatsPointer pBeats = BeatsPointer()) {
+        mixxx::BeatsPointer pBeats = mixxx::BeatsPointer()) {
     // Only use the imported BPM if the beat grid is not valid!
     // Reason: The BPM value in the metadata might be normalized
     // or rounded, e.g. ID3v2 only supports integer values.
@@ -264,7 +263,7 @@ double Track::setBpm(double bpmValue) {
     if (!mixxx::Bpm::isValidValue(bpmValue)) {
         // If the user sets the BPM to an invalid value, we assume
         // they want to clear the beatgrid.
-        setBeats(BeatsPointer());
+        setBeats(mixxx::BeatsPointer());
         return bpmValue;
     }
 
@@ -273,7 +272,7 @@ double Track::setBpm(double bpmValue) {
     if (!m_pBeats) {
         // No beat grid available -> create and initialize
         double cue = getCuePoint().getPosition();
-        BeatsPointer pBeats(BeatFactory::makeBeatGrid(*this, bpmValue, cue));
+        mixxx::BeatsPointer pBeats(BeatFactory::makeBeatGrid(*this, bpmValue, cue));
         setBeatsAndUnlock(&lock, pBeats);
         return bpmValue;
     }
@@ -297,12 +296,12 @@ QString Track::getBpmText() const {
     return QString("%1").arg(getBpm(), 3,'f',1);
 }
 
-void Track::setBeats(BeatsPointer pBeats) {
+void Track::setBeats(mixxx::BeatsPointer pBeats) {
     QMutexLocker lock(&m_qMutex);
     setBeatsAndUnlock(&lock, pBeats);
 }
 
-void Track::setBeatsAndUnlock(QMutexLocker* pLock, BeatsPointer pBeats) {
+void Track::setBeatsAndUnlock(QMutexLocker* pLock, mixxx::BeatsPointer pBeats) {
     // This whole method is not so great. The fact that Beats is an ABC is
     // limiting with respect to QObject and signals/slots.
 
@@ -312,7 +311,7 @@ void Track::setBeatsAndUnlock(QMutexLocker* pLock, BeatsPointer pBeats) {
     }
 
     if (m_pBeats) {
-        disconnect(m_pBeats.data(), &Beats::updated, this, &Track::slotBeatsUpdated);
+        disconnect(m_pBeats.data(), &mixxx::Beats::updated, this, &Track::slotBeatsUpdated);
     }
 
     m_pBeats = std::move(pBeats);
@@ -320,7 +319,7 @@ void Track::setBeatsAndUnlock(QMutexLocker* pLock, BeatsPointer pBeats) {
     auto bpmValue = mixxx::Bpm::kValueUndefined;
     if (m_pBeats) {
         bpmValue = m_pBeats->getBpm();
-        connect(m_pBeats.data(), &Beats::updated, this, &Track::slotBeatsUpdated);
+        connect(m_pBeats.data(), &mixxx::Beats::updated, this, &Track::slotBeatsUpdated);
     }
     m_record.refMetadata().refTrackInfo().setBpm(mixxx::Bpm(bpmValue));
 
@@ -329,7 +328,7 @@ void Track::setBeatsAndUnlock(QMutexLocker* pLock, BeatsPointer pBeats) {
     emit beatsUpdated();
 }
 
-BeatsPointer Track::getBeats() const {
+mixxx::BeatsPointer Track::getBeats() const {
     QMutexLocker lock(&m_qMutex);
     return m_pBeats;
 }
diff --git a/src/track/track.h b/src/track/track.h
index 1b0e312318..5d4b64f609 100644
--- a/src/track/track.h
+++ b/src/track/track.h
@@ -275,10 +275,10 @@ class Track : public QObject {
     bool isDirty();
 
     // Get the track's Beats list
-    BeatsPointer getBeats() const;
+    mixxx::BeatsPointer getBeats() const;
 
     // Set the track's Beats
-    void setBeats(BeatsPointer beats);
+    void setBeats(mixxx::BeatsPointer beats);
 
     void resetKeys();
     void setKeys(const Keys& keys);
@@ -375,7 +375,7 @@ class Track : public QObject {
     void markDirtyAndUnlock(QMutexLocker* pLock, bool bDirty = true);
     void setDirtyAndUnlock(QMutexLocker* pLock, bool bDirty);
 
-    void setBeatsAndUnlock(QMutexLocker* pLock, BeatsPointer pBeats);
+    void setBeatsAndUnlock(QMutexLocker* pLock, mixxx::BeatsPointer pBeats);
 
     void afterKeysUpdated(QMutexLocker* pLock);
 
@@ -428,7 +428,7 @@ class Track : public QObject {
     QList<CuePointer> m_cuePoints;
 
     // Storage for the track's beats
-    BeatsPointer m_pBeats;
+    mixxx::BeatsPointer m_pBeats;
 
     //Visual waveform data
     ConstWaveformPointer m_waveform;