Use std::optional or experimental as available

At build time, the library will now choose `std::optional<T>` or
`std::experimental::optional<T>` (in order of preference), depending on
which one is available.  A new alias `djinterop::stdx::optional` is
available for clients to use.

Note that sqlite_modern_cpp performs its own detection of
`std::optional<T>` or its experimental equivalent: in order for the
library to build correctly, both will need to detect the same version of
`std::optional<T>`.

16 files changed, 359 insertions, 382 deletions

diff --git a/src/djinterop/crate.cpp b/src/djinterop/crate.cpp
index 5da4ad3..4f3fdaf 100644
--- a/src/djinterop/crate.cpp
+++ b/src/djinterop/crate.cpp
@@ -80,7 +80,7 @@ std::string crate::name() const
     return pimpl_->name();
 }
 
-std::optional<crate> crate::parent() const
+stdx::optional<crate> crate::parent() const
 {
     return pimpl_->parent();
 }
@@ -95,13 +95,12 @@ void crate::set_name(std::string name) const
     pimpl_->set_name(name);
 }
 
-void crate::set_parent(std::optional<crate> parent) const
+void crate::set_parent(stdx::optional<crate> parent) const
 {
     pimpl_->set_parent(parent);
 }
 
-std::optional<crate> crate::sub_crate_by_name(
-    const std::string& name) const
+stdx::optional<crate> crate::sub_crate_by_name(const std::string& name) const
 {
     return pimpl_->sub_crate_by_name(name);
 }
diff --git a/src/djinterop/database.cpp b/src/djinterop/database.cpp
index 1a224f8..fcff0d3 100644
--- a/src/djinterop/database.cpp
+++ b/src/djinterop/database.cpp
@@ -37,7 +37,7 @@ transaction_guard database::begin_transaction() const
     return pimpl_->begin_transaction();
 }
 
-std::optional<crate> database::crate_by_id(int64_t id) const
+stdx::optional<crate> database::crate_by_id(int64_t id) const
 {
     return pimpl_->crate_by_id(id);
 }
@@ -92,13 +92,13 @@ std::vector<crate> database::root_crates() const
     return pimpl_->root_crates();
 }
 
-std::optional<crate> database::root_crate_by_name(
+stdx::optional<crate> database::root_crate_by_name(
     const std::string& name) const
 {
     return pimpl_->root_crate_by_name(name);
 }
 
-std::optional<track> database::track_by_id(int64_t id) const
+stdx::optional<track> database::track_by_id(int64_t id) const
 {
     return pimpl_->track_by_id(id);
 }
diff --git a/src/djinterop/enginelibrary/el_crate_impl.cpp b/src/djinterop/enginelibrary/el_crate_impl.cpp
index f3a2360..0567b02 100644
--- a/src/djinterop/enginelibrary/el_crate_impl.cpp
+++ b/src/djinterop/enginelibrary/el_crate_impl.cpp
@@ -54,7 +54,6 @@ using djinterop::track;
 //     relationship is not written to this table.
 namespace
 {
-
 void update_path(
     sqlite::database& music_db, crate cr, const std::string& parent_path)
 {
@@ -85,8 +84,8 @@ void ensure_valid_name(const std::string& name)
 
 }  // namespace
 
-el_crate_impl::el_crate_impl(std::shared_ptr<el_storage> storage, int64_t id)
-    : crate_impl{id}, storage_{std::move(storage)}
+el_crate_impl::el_crate_impl(std::shared_ptr<el_storage> storage, int64_t id) :
+    crate_impl{id}, storage_{std::move(storage)}
 {
 }
 
@@ -133,9 +132,7 @@ crate el_crate_impl::create_sub_crate(std::string name)
     el_transaction_guard_impl trans{storage_};
 
     std::string path;
-    storage_->db
-            << "SELECT path FROM Crate WHERE id = ?"
-            << id() >>
+    storage_->db << "SELECT path FROM Crate WHERE id = ?" << id() >>
         [&](std::string path_val) {
             if (path.empty())
             {
@@ -157,13 +154,12 @@ crate el_crate_impl::create_sub_crate(std::string name)
                     "crateParentId) VALUES (?, ?)"
                  << sub_id << id();
 
-    storage_->db
-        << "INSERT INTO CrateHierarchy (crateId, crateIdChild) "
-           "SELECT crateId, ? FROM CrateHierarchy "
-           "WHERE crateIdChild = ? "
-           "UNION "
-           "SELECT ? AS crateId, ? AS crateIdChild"
-        << sub_id << id() << id() << sub_id;
+    storage_->db << "INSERT INTO CrateHierarchy (crateId, crateIdChild) "
+                    "SELECT crateId, ? FROM CrateHierarchy "
+                    "WHERE crateIdChild = ? "
+                    "UNION "
+                    "SELECT ? AS crateId, ? AS crateIdChild"
+                 << sub_id << id() << id() << sub_id;
 
     crate cr{std::make_shared<el_crate_impl>(storage_, sub_id)};
 
@@ -211,7 +207,7 @@ bool el_crate_impl::is_valid()
 
 std::string el_crate_impl::name()
 {
-    std::optional<std::string> name;
+    stdx::optional<std::string> name;
     storage_->db << "SELECT title FROM Crate WHERE id = ?" << id() >>
         [&](std::string title) {
             if (!name)
@@ -231,9 +227,9 @@ std::string el_crate_impl::name()
     return *name;
 }
 
-std::optional<crate> el_crate_impl::parent()
+stdx::optional<crate> el_crate_impl::parent()
 {
-    std::optional<crate> parent;
+    stdx::optional<crate> parent;
     storage_->db
             << "SELECT crateParentId FROM CrateParentList WHERE crateOriginId "
                "= ? AND crateParentId <> crateOriginId"
@@ -298,7 +294,7 @@ void el_crate_impl::set_name(std::string name)
     trans.commit();
 }
 
-void el_crate_impl::set_parent(std::optional<crate> parent)
+void el_crate_impl::set_parent(stdx::optional<crate> parent)
 {
     el_transaction_guard_impl trans{storage_};
 
@@ -323,9 +319,9 @@ void el_crate_impl::set_parent(std::optional<crate> parent)
     trans.commit();
 }
 
-std::optional<crate> el_crate_impl::sub_crate_by_name(const std::string& name)
+stdx::optional<crate> el_crate_impl::sub_crate_by_name(const std::string& name)
 {
-    std::optional<crate> cr;
+    stdx::optional<crate> cr;
     storage_->db << "SELECT cr.id FROM Crate cr "
                     "JOIN CrateParentList cpl ON (cpl.crateOriginId = cr.id) "
                     "WHERE cr.title = ? "
diff --git a/src/djinterop/enginelibrary/el_crate_impl.hpp b/src/djinterop/enginelibrary/el_crate_impl.hpp
index 55a24df..7b67835 100644
--- a/src/djinterop/enginelibrary/el_crate_impl.hpp
+++ b/src/djinterop/enginelibrary/el_crate_impl.hpp
@@ -41,11 +41,11 @@ public:
     std::vector<crate> descendants() override;
     bool is_valid() override;
     std::string name() override;
-    std::optional<crate> parent() override;
+    stdx::optional<crate> parent() override;
     void remove_track(track tr) override;
     void set_name(std::string name) override;
-    void set_parent(std::optional<crate> parent) override;
-    std::optional<crate> sub_crate_by_name(const std::string& name) override;
+    void set_parent(stdx::optional<crate> parent) override;
+    stdx::optional<crate> sub_crate_by_name(const std::string& name) override;
     std::vector<track> tracks() override;
 
 private:
diff --git a/src/djinterop/enginelibrary/el_database_impl.cpp b/src/djinterop/enginelibrary/el_database_impl.cpp
index 84193b4..ac723d9 100644
--- a/src/djinterop/enginelibrary/el_database_impl.cpp
+++ b/src/djinterop/enginelibrary/el_database_impl.cpp
@@ -50,17 +50,16 @@ void ensure_valid_crate_name(const std::string& name)
 
 }  // namespace
 
-
-el_database_impl::el_database_impl(std::string directory)
-    : storage_{std::make_shared<el_storage>(std::move(directory))}
+el_database_impl::el_database_impl(std::string directory) :
+    storage_{std::make_shared<el_storage>(std::move(directory))}
 {
     // TODO (haslersn): On construction, should we check that the database
     // version is supported? This would give more guarantees to a user that
     // obtains a database object.
 }
 
-el_database_impl::el_database_impl(std::shared_ptr<el_storage> storage)
-    : storage_{std::move(storage)}
+el_database_impl::el_database_impl(std::shared_ptr<el_storage> storage) :
+    storage_{std::move(storage)}
 {
 }
 
@@ -70,9 +69,9 @@ transaction_guard el_database_impl::begin_transaction()
         std::make_unique<el_transaction_guard_impl>(storage_)};
 }
 
-std::optional<crate> el_database_impl::crate_by_id(int64_t id)
+stdx::optional<crate> el_database_impl::crate_by_id(int64_t id)
 {
-    std::optional<crate> cr;
+    stdx::optional<crate> cr;
     storage_->db << "SELECT COUNT(*) FROM Crate WHERE id = ?" << id >>
         [&](int64_t count) {
             if (count == 1)
@@ -162,7 +161,7 @@ track el_database_impl::create_track(std::string relative_path)
             << "REPLACE INTO MetaData (id, type, text) VALUES (?, ?, ?)";
         for (int64_t type : {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 15, 16})
         {
-            std::optional<std::string> text;
+            stdx::optional<std::string> text;
             switch (type)
             {
                 case 10:
@@ -193,7 +192,7 @@ track el_database_impl::create_track(std::string relative_path)
                                         "type, value) VALUES (?, ?, ?)";
         for (int64_t type = 1; type <= 11 /* 12 */; ++type)
         {
-            std::optional<int64_t> value;
+            stdx::optional<int64_t> value;
             switch (type)
             {
                 case 5: value = 0; break;
@@ -258,9 +257,10 @@ std::vector<crate> el_database_impl::root_crates()
     return results;
 }
 
-std::optional<crate> el_database_impl::root_crate_by_name(const std::string& name)
+stdx::optional<crate> el_database_impl::root_crate_by_name(
+    const std::string& name)
 {
-    std::optional<crate> cr;
+    stdx::optional<crate> cr;
     storage_->db << "SELECT cr.id FROM Crate cr "
                     "JOIN CrateParentList cpl ON (cpl.crateOriginId = cr.id) "
                     "WHERE cr.title = ? "
@@ -273,9 +273,9 @@ std::optional<crate> el_database_impl::root_crate_by_name(const std::string& nam
     return cr;
 }
 
-std::optional<track> el_database_impl::track_by_id(int64_t id)
+stdx::optional<track> el_database_impl::track_by_id(int64_t id)
 {
-    std::optional<track> tr;
+    stdx::optional<track> tr;
     storage_->db << "SELECT COUNT(*) FROM Track WHERE id = ?" << id >>
         [&](int64_t count) {
             if (count == 1)
diff --git a/src/djinterop/enginelibrary/el_database_impl.hpp b/src/djinterop/enginelibrary/el_database_impl.hpp
index 3249bdd..1feda91 100644
--- a/src/djinterop/enginelibrary/el_database_impl.hpp
+++ b/src/djinterop/enginelibrary/el_database_impl.hpp
@@ -33,7 +33,7 @@ public:
     el_database_impl(std::shared_ptr<el_storage> storage);
 
     transaction_guard begin_transaction() override;
-    std::optional<djinterop::crate> crate_by_id(int64_t id) override;
+    stdx::optional<djinterop::crate> crate_by_id(int64_t id) override;
     std::vector<djinterop::crate> crates() override;
     std::vector<djinterop::crate> crates_by_name(
         const std::string& name) override;
@@ -45,9 +45,9 @@ public:
     void remove_crate(djinterop::crate cr) override;
     void remove_track(djinterop::track tr) override;
     std::vector<djinterop::crate> root_crates() override;
-    std::optional<djinterop::crate> root_crate_by_name(
+    stdx::optional<djinterop::crate> root_crate_by_name(
         const std::string& name) override;
-    std::optional<djinterop::track> track_by_id(int64_t id) override;
+    stdx::optional<djinterop::track> track_by_id(int64_t id) override;
     std::vector<djinterop::track> tracks() override;
     std::vector<djinterop::track> tracks_by_relative_path(
         const std::string& relative_path) override;
diff --git a/src/djinterop/enginelibrary/el_track_impl.cpp b/src/djinterop/enginelibrary/el_track_impl.cpp
index 7a15837..9ff2915 100644
--- a/src/djinterop/enginelibrary/el_track_impl.cpp
+++ b/src/djinterop/enginelibrary/el_track_impl.cpp
@@ -37,10 +37,10 @@ using std::chrono::system_clock;
 
 namespace
 {
-std::optional<system_clock::time_point> to_time_point(
-    std::optional<int64_t> timestamp)
+stdx::optional<system_clock::time_point> to_time_point(
+    stdx::optional<int64_t> timestamp)
 {
-    std::optional<system_clock::time_point> result;
+    stdx::optional<system_clock::time_point> result;
     if (timestamp)
     {
         result = system_clock::time_point{seconds(*timestamp)};
@@ -48,10 +48,10 @@ std::optional<system_clock::time_point> to_time_point(
     return result;
 }
 
-std::optional<int64_t> to_timestamp(
-    std::optional<system_clock::time_point> time)
+stdx::optional<int64_t> to_timestamp(
+    stdx::optional<system_clock::time_point> time)
 {
-    std::optional<int64_t> result;
+    stdx::optional<int64_t> result;
     if (time)
     {
         result = duration_cast<seconds>(time->time_since_epoch()).count();
@@ -59,7 +59,8 @@ std::optional<int64_t> to_timestamp(
     return result;
 }
 
-/// Calculate the quantisation number for waveforms, given a quantisation number.
+/// Calculate the quantisation number for waveforms, given a quantisation
+/// number.
 ///
 /// A few numbers written to the waveform performance data are rounded
 /// to multiples of a particular "quantisation number", that is equal to
@@ -76,7 +77,7 @@ int64_t quantisation_number(int64_t sample_rate)
 /// that each one represents must be calculated from the true sample count by
 /// rounding the number of samples to the quantisation number first.
 int64_t calculate_overview_waveform_samples_per_entry(
-        int64_t sample_rate, int64_t sample_count)
+    int64_t sample_rate, int64_t sample_count)
 {
     auto qn = quantisation_number(sample_rate);
     return ((sample_count / qn) * qn) / 1024;
@@ -84,15 +85,15 @@ int64_t calculate_overview_waveform_samples_per_entry(
 
 }  // namespace
 
-el_track_impl::el_track_impl(std::shared_ptr<el_storage> storage, int64_t id)
-    : track_impl{id}, storage_{std::move(storage)}
+el_track_impl::el_track_impl(std::shared_ptr<el_storage> storage, int64_t id) :
+    track_impl{id}, storage_{std::move(storage)}
 {
 }
 
-std::optional<std::string> el_track_impl::get_metadata_str(
+stdx::optional<std::string> el_track_impl::get_metadata_str(
     metadata_str_type type)
 {
-    std::optional<std::string> result;
+    stdx::optional<std::string> result;
     storage_->db << "SELECT text FROM MetaData WHERE id = ? AND "
                     "type = ? AND text IS NOT NULL"
                  << id() << static_cast<int64_t>(type) >>
@@ -113,7 +114,7 @@ std::optional<std::string> el_track_impl::get_metadata_str(
 }
 
 void el_track_impl::set_metadata_str(
-    metadata_str_type type, std::optional<std::string> content)
+    metadata_str_type type, stdx::optional<std::string> content)
 {
     if (content)
     {
@@ -134,9 +135,9 @@ void el_track_impl::set_metadata_str(
                  << id() << static_cast<int64_t>(type) << content;
 }
 
-std::optional<int64_t> el_track_impl::get_metadata_int(metadata_int_type type)
+stdx::optional<int64_t> el_track_impl::get_metadata_int(metadata_int_type type)
 {
-    std::optional<int64_t> result;
+    stdx::optional<int64_t> result;
     storage_->db << "SELECT value FROM MetaDataInteger WHERE id = "
                     "? AND type = ? AND value IS NOT NULL"
                  << id() << static_cast<int64_t>(type) >>
@@ -157,7 +158,7 @@ std::optional<int64_t> el_track_impl::get_metadata_int(metadata_int_type type)
 }
 
 void el_track_impl::set_metadata_int(
-    metadata_int_type type, std::optional<int64_t> content)
+    metadata_int_type type, stdx::optional<int64_t> content)
 {
     storage_->db
         << "REPLACE INTO MetaDataInteger (id, type, value) VALUES (?, ?, ?)"
@@ -262,20 +263,20 @@ void el_track_impl::set_adjusted_main_cue(double sample_offset)
     trans.commit();
 }
 
-std::optional<std::string> el_track_impl::album()
+stdx::optional<std::string> el_track_impl::album()
 {
     return get_metadata_str(metadata_str_type::album);
 }
 
-void el_track_impl::set_album(std::optional<std::string> album)
+void el_track_impl::set_album(stdx::optional<std::string> album)
 {
     set_metadata_str(metadata_str_type::album, album);
 }
 
-std::optional<int64_t> el_track_impl::album_art_id()
+stdx::optional<int64_t> el_track_impl::album_art_id()
 {
     int64_t cell = get_cell<int64_t>("idAlbumArt");
-    std::optional<int64_t> album_art_id;
+    stdx::optional<int64_t> album_art_id;
     if (cell < 1)
     {
         // TODO (haslersn): Throw something.
@@ -287,7 +288,7 @@ std::optional<int64_t> el_track_impl::album_art_id()
     return album_art_id;
 }
 
-void el_track_impl::set_album_art_id(std::optional<int64_t> album_art_id)
+void el_track_impl::set_album_art_id(stdx::optional<int64_t> album_art_id)
 {
     if (album_art_id && *album_art_id <= 1)
     {
@@ -297,23 +298,23 @@ void el_track_impl::set_album_art_id(std::optional<int64_t> album_art_id)
     // 1 is the magic number for "no album art"
 }
 
-std::optional<std::string> el_track_impl::artist()
+stdx::optional<std::string> el_track_impl::artist()
 {
     return get_metadata_str(metadata_str_type::artist);
 }
 
-void el_track_impl::set_artist(std::optional<std::string> artist)
+void el_track_impl::set_artist(stdx::optional<std::string> artist)
 {
     set_metadata_str(metadata_str_type::artist, artist);
 }
 
-std::optional<double> el_track_impl::average_loudness()
+stdx::optional<double> el_track_impl::average_loudness()
 {
     return get_track_data().average_loudness;
 }
 
 void el_track_impl::set_average_loudness(
-    std::optional<double> average_loudness)
+    stdx::optional<double> average_loudness)
 {
     el_transaction_guard_impl trans{storage_};
     auto track_d = get_track_data();
@@ -322,25 +323,25 @@ void el_track_impl::set_average_loudness(
     trans.commit();
 }
 
-std::optional<int64_t> el_track_impl::bitrate()
+stdx::optional<int64_t> el_track_impl::bitrate()
 {
-    return get_cell<std::optional<int64_t>>("bitrate");
+    return get_cell<stdx::optional<int64_t> >("bitrate");
 }
 
-void el_track_impl::set_bitrate(std::optional<int64_t> bitrate)
+void el_track_impl::set_bitrate(stdx::optional<int64_t> bitrate)
 {
     set_cell("bitrate", bitrate);
 }
 
-std::optional<double> el_track_impl::bpm()
+stdx::optional<double> el_track_impl::bpm()
 {
-    return get_cell<std::optional<double>>("bpmAnalyzed");
+    return get_cell<stdx::optional<double> >("bpmAnalyzed");
 }
 
-void el_track_impl::set_bpm(std::optional<double> bpm)
+void el_track_impl::set_bpm(stdx::optional<double> bpm)
 {
     set_cell("bpmAnalyzed", bpm);
-    std::optional<int64_t> ceiled_bpm;
+    stdx::optional<int64_t> ceiled_bpm;
     if (bpm)
     {
         ceiled_bpm = static_cast<int64_t>(std::ceil(*bpm));
@@ -348,22 +349,22 @@ void el_track_impl::set_bpm(std::optional<double> bpm)
     set_cell("bpm", ceiled_bpm);
 }
 
-std::optional<std::string> el_track_impl::comment()
+stdx::optional<std::string> el_track_impl::comment()
 {
     return get_metadata_str(metadata_str_type::comment);
 }
 
-void el_track_impl::set_comment(std::optional<std::string> comment)
+void el_track_impl::set_comment(stdx::optional<std::string> comment)
 {
     set_metadata_str(metadata_str_type::comment, comment);
 }
 
-std::optional<std::string> el_track_impl::composer()
+stdx::optional<std::string> el_track_impl::composer()
 {
     return get_metadata_str(metadata_str_type::composer);
 }
 
-void el_track_impl::set_composer(std::optional<std::string> composer)
+void el_track_impl::set_composer(stdx::optional<std::string> composer)
 {
     set_metadata_str(metadata_str_type::composer, composer);
 }
@@ -414,28 +415,27 @@ void el_track_impl::set_default_main_cue(double sample_offset)
     trans.commit();
 }
 
-std::optional<milliseconds> el_track_impl::duration()
+stdx::optional<milliseconds> el_track_impl::duration()
 {
-    std::optional<milliseconds> result;
+    stdx::optional<milliseconds> result;
     auto smp = sampling();
     if (smp)
     {
         double secs = smp->sample_count / smp->sample_rate;
         return milliseconds{static_cast<int64_t>(1000 * secs)};
     }
-    auto secs = get_cell<std::optional<int64_t>>("length");
+    auto secs = get_cell<stdx::optional<int64_t> >("length");
     if (secs)
     {
         return milliseconds{*secs * 1000};
     }
-    return std::nullopt;
+    return stdx::nullopt;
 }
 
 std::string el_track_impl::file_extension()
 {
     auto rel_path = relative_path();
-    return get_file_extension(rel_path)
-        .value_or(std::string{});
+    return get_file_extension(rel_path).value_or(std::string{});
 }
 
 std::string el_track_impl::filename()
@@ -444,23 +444,23 @@ std::string el_track_impl::filename()
     return get_filename(rel_path);
 }
 
-std::optional<std::string> el_track_impl::genre()
+stdx::optional<std::string> el_track_impl::genre()
 {
     return get_metadata_str(metadata_str_type::genre);
 }
 
-void el_track_impl::set_genre(std::optional<std::string> genre)
+void el_track_impl::set_genre(stdx::optional<std::string> genre)
 {
     set_metadata_str(metadata_str_type::genre, genre);
 }
 
-std::optional<hot_cue> el_track_impl::hot_cue_at(int32_t index)
+stdx::optional<hot_cue> el_track_impl::hot_cue_at(int32_t index)
 {
     auto quick_cues_d = get_quick_cues_data();
     return std::move(quick_cues_d.hot_cues[index]);
 }
 
-void el_track_impl::set_hot_cue_at(int32_t index, std::optional<hot_cue> cue)
+void el_track_impl::set_hot_cue_at(int32_t index, stdx::optional<hot_cue> cue)
 {
     el_transaction_guard_impl trans{storage_};
     auto quick_cues_d = get_quick_cues_data();
@@ -469,13 +469,13 @@ void el_track_impl::set_hot_cue_at(int32_t index, std::optional<hot_cue> cue)
     trans.commit();
 }
 
-std::array<std::optional<hot_cue>, 8> el_track_impl::hot_cues()
+std::array<stdx::optional<hot_cue>, 8> el_track_impl::hot_cues()
 {
     auto quick_cues_d = get_quick_cues_data();
     return std::move(quick_cues_d.hot_cues);
 }
 
-void el_track_impl::set_hot_cues(std::array<std::optional<hot_cue>, 8> cues)
+void el_track_impl::set_hot_cues(std::array<stdx::optional<hot_cue>, 8> cues)
 {
     el_transaction_guard_impl trans{storage_};
     // TODO (haslersn): The following can be optimized because in this case we
@@ -486,20 +486,21 @@ void el_track_impl::set_hot_cues(std::array<std::optional<hot_cue>, 8> cues)
     trans.commit();
 }
 
-std::optional<track_import_info> el_track_impl::import_info()
+stdx::optional<track_import_info> el_track_impl::import_info()
 {
     if (get_cell<int64_t>("isExternalTrack") == 0)
     {
-        return std::nullopt;
+        return stdx::nullopt;
     }
-    return track_import_info{get_cell<std::string>("uuidOfExternalDatabase"),
-                             get_cell<int64_t>("idTrackInExternalDatabase")};
+    return track_import_info{
+        get_cell<std::string>("uuidOfExternalDatabase"),
+        get_cell<int64_t>("idTrackInExternalDatabase")};
     // TODO (haslersn): How should we handle cells that unexpectedly don't
     // contain integral values?
 }
 
 void el_track_impl::set_import_info(
-    const std::optional<track_import_info>& import_info)
+    const stdx::optional<track_import_info>& import_info)
 {
     if (import_info)
     {
@@ -533,9 +534,9 @@ bool el_track_impl::is_valid()
     return valid;
 }
 
-std::optional<musical_key> el_track_impl::key()
+stdx::optional<musical_key> el_track_impl::key()
 {
-    std::optional<musical_key> result;
+    stdx::optional<musical_key> result;
     auto key_num = get_metadata_int(metadata_int_type::musical_key);
     if (key_num)
     {
@@ -544,9 +545,9 @@ std::optional<musical_key> el_track_impl::key()
     return result;
 }
 
-void el_track_impl::set_key(std::optional<musical_key> key)
+void el_track_impl::set_key(stdx::optional<musical_key> key)
 {
-    std::optional<int64_t> key_num;
+    stdx::optional<int64_t> key_num;
     if (key)
     {
         key_num = static_cast<int64_t>(*key);
@@ -560,7 +561,7 @@ void el_track_impl::set_key(std::optional<musical_key> key)
     trans.commit();
 }
 
-std::optional<system_clock::time_point> el_track_impl::last_accessed_at()
+stdx::optional<system_clock::time_point> el_track_impl::last_accessed_at()
 
 {
     // TODO (haslersn): Is there a difference between
@@ -571,7 +572,7 @@ std::optional<system_clock::time_point> el_track_impl::last_accessed_at()
 }
 
 void el_track_impl::set_last_accessed_at(
-    std::optional<system_clock::time_point> accessed_at)
+    stdx::optional<system_clock::time_point> accessed_at)
 {
     if (accessed_at)
     {
@@ -590,34 +591,34 @@ void el_track_impl::set_last_accessed_at(
     }
     else
     {
-        set_metadata_int(metadata_int_type::last_accessed_ts, std::nullopt);
+        set_metadata_int(metadata_int_type::last_accessed_ts, stdx::nullopt);
     }
 }
 
-std::optional<system_clock::time_point> el_track_impl::last_modified_at()
+stdx::optional<system_clock::time_point> el_track_impl::last_modified_at()
 
 {
     return to_time_point(get_metadata_int(metadata_int_type::last_modified_ts));
 }
 
 void el_track_impl::set_last_modified_at(
-    std::optional<system_clock::time_point> modified_at)
+    stdx::optional<system_clock::time_point> modified_at)
 {
     set_metadata_int(
         metadata_int_type::last_modified_ts, to_timestamp(modified_at));
 }
 
-std::optional<system_clock::time_point> el_track_impl::last_played_at()
+stdx::optional<system_clock::time_point> el_track_impl::last_played_at()
 
 {
     return to_time_point(get_metadata_int(metadata_int_type::last_played_ts));
 }
 
 void el_track_impl::set_last_played_at(
-    std::optional<system_clock::time_point> played_at)
+    stdx::optional<system_clock::time_point> played_at)
 {
-    static std::optional<std::string> zero{"0"};
-    static std::optional<std::string> one{"1"};
+    static stdx::optional<std::string> zero{"0"};
+    static stdx::optional<std::string> one{"1"};
     set_metadata_str(metadata_str_type::ever_played, played_at ? one : zero);
     set_metadata_int(
         metadata_int_type::last_played_ts, to_timestamp(played_at));
@@ -632,13 +633,13 @@ void el_track_impl::set_last_played_at(
     }
 }
 
-std::optional<loop> el_track_impl::loop_at(int32_t index)
+stdx::optional<loop> el_track_impl::loop_at(int32_t index)
 {
     auto loops_d = get_loops_data();
     return std::move(loops_d.loops[index]);
 }
 
-void el_track_impl::set_loop_at(int32_t index, std::optional<loop> l)
+void el_track_impl::set_loop_at(int32_t index, stdx::optional<loop> l)
 {
     el_transaction_guard_impl trans{storage_};
     auto loops_d = get_loops_data();
@@ -647,13 +648,13 @@ void el_track_impl::set_loop_at(int32_t index, std::optional<loop> l)
     trans.commit();
 }
 
-std::array<std::optional<loop>, 8> el_track_impl::loops()
+std::array<stdx::optional<loop>, 8> el_track_impl::loops()
 {
     auto loops_d = get_loops_data();
     return std::move(loops_d.loops);
 }
 
-void el_track_impl::set_loops(std::array<std::optional<loop>, 8> cues)
+void el_track_impl::set_loops(std::array<stdx::optional<loop>, 8> cues)
 {
     el_transaction_guard_impl trans{storage_};
     loops_data loops_d;
@@ -668,12 +669,12 @@ std::vector<waveform_entry> el_track_impl::overview_waveform()
     return std::move(overview_waveform_d.waveform);
 }
 
-std::optional<std::string> el_track_impl::publisher()
+stdx::optional<std::string> el_track_impl::publisher()
 {
     return get_metadata_str(metadata_str_type::publisher);
 }
 
-void el_track_impl::set_publisher(std::optional<std::string> publisher)
+void el_track_impl::set_publisher(stdx::optional<std::string> publisher)
 {
     set_metadata_str(metadata_str_type::publisher, publisher);
 }
@@ -687,8 +688,8 @@ int64_t el_track_impl::required_waveform_samples_per_entry()
     }
     if (smp->sample_rate <= 0)
     {
-        throw track_database_inconsistency{"Track has non-positive sample rate",
-                                           id()};
+        throw track_database_inconsistency{
+            "Track has non-positive sample rate", id()};
     }
 
     // In high-resolution waveforms, the samples-per-entry is the same as
@@ -711,16 +712,16 @@ void el_track_impl::set_relative_path(std::string relative_path)
     set_metadata_str(metadata_str_type::file_extension, extension);
 }
 
-std::optional<sampling_info> el_track_impl::sampling()
+stdx::optional<sampling_info> el_track_impl::sampling()
 {
     return get_track_data().sampling;
 }
 
-void el_track_impl::set_sampling(std::optional<sampling_info> sampling)
+void el_track_impl::set_sampling(stdx::optional<sampling_info> sampling)
 {
     el_transaction_guard_impl trans{storage_};
 
-    std::optional<int64_t> secs;
+    stdx::optional<int64_t> secs;
     if (sampling)
     {
         secs = static_cast<int64_t>(
@@ -733,12 +734,11 @@ void el_track_impl::set_sampling(std::optional<sampling_info> sampling)
         oss << ":";
         oss << (*secs % 60);
         auto str = oss.str();
-        set_metadata_str(
-            metadata_str_type::duration_mm_ss, std::string{str});
+        set_metadata_str(metadata_str_type::duration_mm_ss, std::string{str});
     }
     else
     {
-        set_metadata_str(metadata_str_type::duration_mm_ss, std::nullopt);
+        set_metadata_str(metadata_str_type::duration_mm_ss, stdx::nullopt);
     }
     set_cell("length", secs);
     set_cell("lengthCalculated", secs);
@@ -764,7 +764,8 @@ void el_track_impl::set_sampling(std::optional<sampling_info> sampling)
         // entry that is dependent on the sample rate.  If the sample rate is
         // genuinely changed using this method, note that the waveform is likely
         // to need to be updated as well afterwards.
-        high_res_waveform_d.samples_per_entry = quantisation_number(sample_rate);
+        high_res_waveform_d.samples_per_entry =
+            quantisation_number(sample_rate);
         set_high_res_waveform_data(std::move(high_res_waveform_d));
     }
 
@@ -774,29 +775,29 @@ void el_track_impl::set_sampling(std::optional<sampling_info> sampling)
         // the number of entries is always fixed.
         overview_waveform_d.samples_per_entry =
             calculate_overview_waveform_samples_per_entry(
-                    sample_rate, sample_count);
+                sample_rate, sample_count);
         set_overview_waveform_data(std::move(overview_waveform_d));
     }
 
     trans.commit();
 }
 
-std::optional<std::string> el_track_impl::title()
+stdx::optional<std::string> el_track_impl::title()
 {
     return get_metadata_str(metadata_str_type::title);
 }
 
-void el_track_impl::set_title(std::optional<std::string> title)
+void el_track_impl::set_title(stdx::optional<std::string> title)
 {
     set_metadata_str(metadata_str_type::title, title);
 }
 
-std::optional<int32_t> el_track_impl::track_number()
+stdx::optional<int32_t> el_track_impl::track_number()
 {
-    return get_cell<std::optional<int32_t>>("playOrder");
+    return get_cell<stdx::optional<int32_t> >("playOrder");
 }
 
-void el_track_impl::set_track_number(std::optional<int32_t> track_number)
+void el_track_impl::set_track_number(stdx::optional<int32_t> track_number)
 {
     set_cell("playOrder", track_number);
 }
@@ -823,8 +824,8 @@ void el_track_impl::set_waveform(std::vector<waveform_entry> waveform)
         // Calculate an overview waveform automatically.