Use std::optional where available

Either <optional> or <experimental/optional> is now required for
compilation and in the public API.  In order to seamlessly use either
one, the relevant symbols are aliased within the namespace `djinterop::stdx`.

It is expected that this is removed in favour of just using
std::optional in future once older compiler support can be removed.

4 files changed, 88 insertions, 89 deletions

diff --git a/src/djinterop/crate.cpp b/src/djinterop/crate.cpp
index 6bb21b0..93da6a2 100644
--- a/src/djinterop/crate.cpp
+++ b/src/djinterop/crate.cpp
@@ -80,7 +80,7 @@ std::string crate::name() const
     return pimpl_->name();
 }
 
-std::experimental::optional<crate> crate::parent() const
+stdx::optional<crate> crate::parent() const
 {
     return from_boost_optional(pimpl_->parent());
 }
@@ -95,13 +95,13 @@ void crate::set_name(std::string name) const
     pimpl_->set_name(name);
 }
 
-void crate::set_parent(std::experimental::optional<crate> parent) const
+void crate::set_parent(stdx::optional<crate> parent) const
 {
     pimpl_->set_parent(to_boost_optional(parent));
 }
 
-std::experimental::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 from_boost_optional(pimpl_->sub_crate_by_name(name));
 }
diff --git a/src/djinterop/database.cpp b/src/djinterop/database.cpp
index 2dd8e73..e6703b4 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::experimental::optional<crate> database::crate_by_id(int64_t id) const
+stdx::optional<crate> database::crate_by_id(int64_t id) const
 {
     return from_boost_optional(pimpl_->crate_by_id(id));
 }
@@ -92,13 +92,13 @@ std::vector<crate> database::root_crates() const
     return pimpl_->root_crates();
 }
 
-std::experimental::optional<crate> database::root_crate_by_name(
-        const std::string& name) const
+stdx::optional<crate> database::root_crate_by_name(
+    const std::string& name) const
 {
     return from_boost_optional(pimpl_->root_crate_by_name(name));
 }
 
-std::experimental::optional<track> database::track_by_id(int64_t id) const
+stdx::optional<track> database::track_by_id(int64_t id) const
 {
     return from_boost_optional(pimpl_->track_by_id(id));
 }
@@ -124,8 +124,8 @@ semantic_version database::version() const
     return pimpl_->version();
 }
 
-database::database(std::shared_ptr<database_impl> pimpl)
-    : pimpl_{std::move(pimpl)}
+database::database(std::shared_ptr<database_impl> pimpl) :
+    pimpl_{std::move(pimpl)}
 {
 }
 
diff --git a/src/djinterop/impl/util.hpp b/src/djinterop/impl/util.hpp
index 3b7a1bb..1896846 100644
--- a/src/djinterop/impl/util.hpp
+++ b/src/djinterop/impl/util.hpp
@@ -18,7 +18,7 @@
 #pragma once
 
 #include <boost/optional.hpp>
-#include <djinterop/optional/optional.hpp>
+#include <djinterop/optional.hpp>
 
 namespace djinterop
 {
@@ -26,14 +26,13 @@ std::string get_filename(const std::string& file_path);
 boost::optional<std::string> get_file_extension(const std::string& file_path);
 
 template <typename T>
-std::experimental::optional<T> from_boost_optional(boost::optional<T> opt)
+stdx::optional<T> from_boost_optional(boost::optional<T> opt)
 {
-    return opt ? std::experimental::optional<T>{*opt}
-               : std::experimental::nullopt;
+    return opt ? stdx::optional<T>{*opt} : stdx::nullopt;
 }
 
 template <typename T>
-boost::optional<T> to_boost_optional(std::experimental::optional<T> opt)
+boost::optional<T> to_boost_optional(stdx::optional<T> opt)
 {
     return opt ? boost::optional<T>{*opt} : boost::none;
 }
diff --git a/src/djinterop/track.cpp b/src/djinterop/track.cpp
index 76b8f52..777dcd8 100644
--- a/src/djinterop/track.cpp
+++ b/src/djinterop/track.cpp
@@ -94,124 +94,124 @@ void track::set_adjusted_main_cue(double sample_offset) const
     pimpl_->set_adjusted_main_cue(sample_offset);
 }
 
-std::experimental::optional<std::string> track::album() const
+stdx::optional<std::string> track::album() const
 {
     return from_boost_optional(pimpl_->album());
 }
 
-void track::set_album(std::experimental::optional<std::string> album) const
+void track::set_album(stdx::optional<std::string> album) const
 {
     pimpl_->set_album(to_boost_optional(album));
 }
 
 void track::set_album(std::string album) const
 {
-    set_album(std::experimental::make_optional(album));
+    set_album(stdx::make_optional(album));
 }
 
-std::experimental::optional<int64_t> track::album_art_id() const
+stdx::optional<int64_t> track::album_art_id() const
 {
     return from_boost_optional(pimpl_->album_art_id());
 }
 
-void track::set_album_art_id(std::experimental::optional<int64_t> album_art_id) const
+void track::set_album_art_id(stdx::optional<int64_t> album_art_id) const
 {
     pimpl_->set_album_art_id(to_boost_optional(album_art_id));
 }
 
 void track::set_album_art_id(int64_t album_art_id) const
 {
-    set_album_art_id(std::experimental::make_optional(album_art_id));
+    set_album_art_id(stdx::make_optional(album_art_id));
 }
 
-std::experimental::optional<std::string> track::artist() const
+stdx::optional<std::string> track::artist() const
 {
     return from_boost_optional(pimpl_->artist());
 }
 
-void track::set_artist(std::experimental::optional<std::string> artist) const
+void track::set_artist(stdx::optional<std::string> artist) const
 {
     pimpl_->set_artist(to_boost_optional(artist));
 }
 
 void track::set_artist(std::string artist) const
 {
-    set_artist(std::experimental::make_optional(artist));
+    set_artist(stdx::make_optional(artist));
 }
 
-std::experimental::optional<double> track::average_loudness() const
+stdx::optional<double> track::average_loudness() const
 {
     return from_boost_optional(pimpl_->average_loudness());
 }
 
-void track::set_average_loudness(std::experimental::optional<double> average_loudness) const
+void track::set_average_loudness(stdx::optional<double> average_loudness) const
 {
     pimpl_->set_average_loudness(to_boost_optional(average_loudness));
 }
 
 void track::set_average_loudness(double average_loudness) const
 {
-    set_average_loudness(std::experimental::make_optional(average_loudness));
+    set_average_loudness(stdx::make_optional(average_loudness));
 }
 
-std::experimental::optional<int64_t> track::bitrate() const
+stdx::optional<int64_t> track::bitrate() const
 {
     return from_boost_optional(pimpl_->bitrate());
 }
 
-void track::set_bitrate(std::experimental::optional<int64_t> bitrate) const
+void track::set_bitrate(stdx::optional<int64_t> bitrate) const
 {
     pimpl_->set_bitrate(to_boost_optional(bitrate));
 }
 
 void track::set_bitrate(int64_t bitrate) const
 {
-    set_bitrate(std::experimental::make_optional(bitrate));
+    set_bitrate(stdx::make_optional(bitrate));
 }
 
-std::experimental::optional<double> track::bpm() const
+stdx::optional<double> track::bpm() const
 {
     return from_boost_optional(pimpl_->bpm());
 }
 
-void track::set_bpm(std::experimental::optional<double> bpm) const
+void track::set_bpm(stdx::optional<double> bpm) const
 {
     pimpl_->set_bpm(to_boost_optional(bpm));
 }
 
 void track::set_bpm(double bpm) const
 {
-    set_bpm(std::experimental::make_optional(bpm));
+    set_bpm(stdx::make_optional(bpm));
 }
 
-std::experimental::optional<std::string> track::comment() const
+stdx::optional<std::string> track::comment() const
 {
     return from_boost_optional(pimpl_->comment());
 }
 
-void track::set_comment(std::experimental::optional<std::string> comment) const
+void track::set_comment(stdx::optional<std::string> comment) const
 {
     pimpl_->set_comment(to_boost_optional(comment));
 }
 
 void track::set_comment(std::string comment) const
 {
-    set_comment(std::experimental::make_optional(comment));
+    set_comment(stdx::make_optional(comment));
 }
 
-std::experimental::optional<std::string> track::composer() const
+stdx::optional<std::string> track::composer() const
 {
     return from_boost_optional(pimpl_->composer());
 }
 
-void track::set_composer(std::experimental::optional<std::string> composer) const
+void track::set_composer(stdx::optional<std::string> composer) const
 {
     pimpl_->set_composer(to_boost_optional(composer));
 }
 
 void track::set_composer(std::string composer) const
 {
-    set_composer(std::experimental::make_optional(composer));
+    set_composer(stdx::make_optional(composer));
 }
 
 std::vector<crate> track::containing_crates() const
@@ -244,7 +244,7 @@ void track::set_default_main_cue(double sample_offset) const
     pimpl_->set_default_main_cue(sample_offset);
 }
 
-std::experimental::optional<milliseconds> track::duration() const
+stdx::optional<milliseconds> track::duration() const
 {
     return from_boost_optional(pimpl_->duration());
 }
@@ -259,56 +259,56 @@ std::string track::filename() const
     return pimpl_->filename();
 }
 
-std::experimental::optional<std::string> track::genre() const
+stdx::optional<std::string> track::genre() const
 {
     return from_boost_optional(pimpl_->genre());
 }
 
-void track::set_genre(std::experimental::optional<std::string> genre) const
+void track::set_genre(stdx::optional<std::string> genre) const
 {
     pimpl_->set_genre(to_boost_optional(genre));
 }
 
 void track::set_genre(std::string genre) const
 {
-    set_genre(std::experimental::make_optional(genre));
+    set_genre(stdx::make_optional(genre));
 }
 
-std::experimental::optional<hot_cue> track::hot_cue_at(int32_t index) const
+stdx::optional<hot_cue> track::hot_cue_at(int32_t index) const
 {
     return from_boost_optional(pimpl_->hot_cue_at(index));
 }
 
-void track::set_hot_cue_at(int32_t index, std::experimental::optional<hot_cue> cue) const
+void track::set_hot_cue_at(int32_t index, stdx::optional<hot_cue> cue) const
 {
     pimpl_->set_hot_cue_at(index, to_boost_optional(cue));
 }
 
 void track::set_hot_cue_at(int32_t index, hot_cue cue) const
 {
-    set_hot_cue_at(index, std::experimental::make_optional(std::move(cue)));
+    set_hot_cue_at(index, stdx::make_optional(std::move(cue)));
 }
 
-std::array<std::experimental::optional<hot_cue>, 8> track::hot_cues() const
+std::array<stdx::optional<hot_cue>, 8> track::hot_cues() const
 {
-    std::array<std::experimental::optional<hot_cue>, 8> results;
+    std::array<stdx::optional<hot_cue>, 8> results;
     auto bcues = pimpl_->hot_cues();
     std::transform(
             bcues.begin(), bcues.end(), results.begin(),
             [](boost::optional<hot_cue> bcue) ->
-                    std::experimental::optional<hot_cue>
+                    stdx::optional<hot_cue>
             {
                 return from_boost_optional(bcue);
             });
     return results;
 }
 
-void track::set_hot_cues(std::array<std::experimental::optional<hot_cue>, 8> cues) const
+void track::set_hot_cues(std::array<stdx::optional<hot_cue>, 8> cues) const
 {
     std::array<boost::optional<hot_cue>, 8> bcues;
     std::transform(
             cues.begin(), cues.end(), bcues.begin(),
-            [](std::experimental::optional<hot_cue> cue) ->
+            [](stdx::optional<hot_cue> cue) ->
                     boost::optional<hot_cue>
                 {
                     return to_boost_optional(cue);
@@ -321,20 +321,20 @@ int64_t track::id() const
     return pimpl_->id();
 }
 
-std::experimental::optional<track_import_info> track::import_info() const
+stdx::optional<track_import_info> track::import_info() const
 {
     return from_boost_optional(pimpl_->import_info());
 }
 
 void track::set_import_info(
-    const std::experimental::optional<track_import_info>& import_info) const
+    const stdx::optional<track_import_info>& import_info) const
 {
     pimpl_->set_import_info(to_boost_optional(import_info));
 }
 
 void track::set_import_info(const track_import_info& import_info) const
 {
-    set_import_info(std::experimental::make_optional(import_info));
+    set_import_info(stdx::make_optional(import_info));
 }
 
 bool track::is_valid() const
@@ -342,103 +342,103 @@ bool track::is_valid() const
     return pimpl_->is_valid();
 }
 
-std::experimental::optional<musical_key> track::key() const
+stdx::optional<musical_key> track::key() const
 {
     return from_boost_optional(pimpl_->key());
 }
 
-void track::set_key(std::experimental::optional<musical_key> key) const
+void track::set_key(stdx::optional<musical_key> key) const
 {
     pimpl_->set_key(to_boost_optional(key));
 }
 
 void track::set_key(musical_key key) const
 {
-    set_key(std::experimental::make_optional(key));
+    set_key(stdx::make_optional(key));
 }
 
-std::experimental::optional<system_clock::time_point> track::last_accessed_at() const
+stdx::optional<system_clock::time_point> track::last_accessed_at() const
 {
     return from_boost_optional(pimpl_->last_accessed_at());
 }
 
 void track::set_last_accessed_at(
-    std::experimental::optional<system_clock::time_point> accessed_at) const
+    stdx::optional<system_clock::time_point> accessed_at) const
 {
     pimpl_->set_last_accessed_at(to_boost_optional(accessed_at));
 }
 
 void track::set_last_accessed_at(system_clock::time_point accessed_at) const
 {
-    set_last_accessed_at(std::experimental::make_optional(accessed_at));
+    set_last_accessed_at(stdx::make_optional(accessed_at));
 }
 
-std::experimental::optional<system_clock::time_point> track::last_modified_at() const
+stdx::optional<system_clock::time_point> track::last_modified_at() const
 {
     return from_boost_optional(pimpl_->last_modified_at());
 }
 
 void track::set_last_modified_at(
-    std::experimental::optional<system_clock::time_point> modified_at) const
+    stdx::optional<system_clock::time_point> modified_at) const
 {
     pimpl_->set_last_modified_at(to_boost_optional(modified_at));
 }
 
 void track::set_last_modified_at(system_clock::time_point modified_at) const
 {
-    set_last_modified_at(std::experimental::make_optional(modified_at));
+    set_last_modified_at(stdx::make_optional(modified_at));
 }
 
-std::experimental::optional<system_clock::time_point> track::last_played_at() const
+stdx::optional<system_clock::time_point> track::last_played_at() const
 {
     return from_boost_optional(pimpl_->last_played_at());
 }
 
 void track::set_last_played_at(
-    std::experimental::optional<system_clock::time_point> played_at) const
+    stdx::optional<system_clock::time_point> played_at) const
 {
     pimpl_->set_last_played_at(to_boost_optional(played_at));
 }
 
 void track::set_last_played_at(system_clock::time_point played_at) const
 {
-    set_last_played_at(std::experimental::make_optional(played_at));
+    set_last_played_at(stdx::make_optional(played_at));
 }
 
-std::experimental::optional<loop> track::loop_at(int32_t index) const
+stdx::optional<loop> track::loop_at(int32_t index) const
 {
     return from_boost_optional(pimpl_->loop_at(index));
 }
 
-void track::set_loop_at(int32_t index, std::experimental::optional<loop> l) const
+void track::set_loop_at(int32_t index, stdx::optional<loop> l) const
 {
     pimpl_->set_loop_at(index, to_boost_optional(l));
 }
 
 void track::set_loop_at(int32_t index, loop l) const
 {
-    set_loop_at(index, std::experimental::make_optional(l));
+    set_loop_at(index, stdx::make_optional(l));
 }
 
-std::array<std::experimental::optional<loop>, 8> track::loops() const
+std::array<stdx::optional<loop>, 8> track::loops() const
 {
-    std::array<std::experimental::optional<loop>, 8> results;
+    std::array<stdx::optional<loop>, 8> results;
     auto bloops = pimpl_->loops();
     std::transform(
             bloops.begin(), bloops.end(), results.begin(),
-            [](boost::optional<loop> l) -> std::experimental::optional<loop>
+            [](boost::optional<loop> l) -> stdx::optional<loop>
             {
                 return from_boost_optional(l);
             });
     return results;
 }
 
-void track::set_loops(std::array<std::experimental::optional<loop>, 8> loops) const
+void track::set_loops(std::array<stdx::optional<loop>, 8> loops) const
 {
     std::array<boost::optional<loop>, 8> bloops;
     std::transform(
             loops.begin(), loops.end(), bloops.begin(),
-            [](std::experimental::optional<loop> l) -> boost::optional<loop>
+            [](stdx::optional<loop> l) -> boost::optional<loop>
             {
                 return to_boost_optional(l);
             });
@@ -450,19 +450,19 @@ std::vector<waveform_entry> track::overview_waveform() const
     return pimpl_->overview_waveform();
 }
 
-std::experimental::optional<std::string> track::publisher() const
+stdx::optional<std::string> track::publisher() const
 {
     return from_boost_optional(pimpl_->publisher());
 }
 
-void track::set_publisher(std::experimental::optional<std::string> publisher) const
+void track::set_publisher(stdx::optional<std::string> publisher) const
 {
     pimpl_->set_publisher(to_boost_optional(publisher));
 }
 
 void track::set_publisher(std::string publisher) const
 {
-    set_publisher(std::experimental::make_optional(publisher));
+    set_publisher(stdx::make_optional(publisher));
 }
 
 int64_t track::recommended_waveform_size() const
@@ -480,49 +480,49 @@ void track::set_relative_path(std::string relative_path) const
     pimpl_->set_relative_path(relative_path);
 }
 
-std::experimental::optional<sampling_info> track::sampling() const
+stdx::optional<sampling_info> track::sampling() const
 {
     return from_boost_optional(pimpl_->sampling());
 }
 
-void track::set_sampling(std::experimental::optional<sampling_info> sampling) const
+void track::set_sampling(stdx::optional<sampling_info> sampling) const
 {
     pimpl_->set_sampling(to_boost_optional(sampling));
 }
 
 void track::set_sampling(sampling_info sampling) const
 {
-    set_sampling(std::experimental::make_optional(sampling));
+    set_sampling(stdx::make_optional(sampling));
 }
 
-std::experimental::optional<std::string> track::title() const
+stdx::optional<std::string> track::title() const
 {
     return from_boost_optional(pimpl_->title());
 }
 
-void track::set_title(std::experimental::optional<std::string> title) const
+void track::set_title(stdx::optional<std::string> title) const
 {
     pimpl_->set_title(to_boost_optional(title));
 }
 
 void track::set_title(std::string title) const
 {
-    set_title(std::experimental::make_optional(title));
+    set_title(stdx::make_optional(title));
 }
 
-std::experimental::optional<int32_t> track::track_number() const
+stdx::optional<int32_t> track::track_number() const
 {
     return from_boost_optional(pimpl_->track_number());
 }
 
-void track::set_track_number(std::experimental::optional<int32_t> track_number) const
+void track::set_track_number(stdx::optional<int32_t> track_number) const
 {
     pimpl_->set_track_number(to_boost_optional(track_number));
 }
 
 void track::set_track_number(int32_t track_number) const
 {
-    set_track_number(std::experimental::make_optional(track_number));
+    set_track_number(stdx::make_optional(track_number));
 }
 
 std::vector<waveform_entry> track::waveform() const
@@ -535,19 +535,19 @@ void track::set_waveform(std::vector<waveform_entry> waveform) const
     pimpl_->set_waveform(waveform);
 }
 
-std::experimental::optional<int32_t> track::year() const
+stdx::optional<int32_t> track::year() const
 {
     return from_boost_optional(pimpl_->year());
 }
 
-void track::set_year(std::experimental::optional<int32_t> year) const
+void track::set_year(stdx::optional<int32_t> year) const
 {
     pimpl_->set_year(to_boost_optional(year));
 }
 
 void track::set_year(int32_t year) const
 {
-    set_year(std::experimental::make_optional(year));
+    set_year(stdx::make_optional(year));
 }
 
 track::track(std::shared_ptr<track_impl> pimpl) : pimpl_{std::move(pimpl)} {}