Get rid of Optional and switch to C++20

Author: kunitoki

modules/yup_audio_basics/audio_play_head/yup_AudioPlayHead.h

@@ -361,43 +361,43 @@ class YUP_API AudioPlayHead
     {
     public:
         /** Returns the number of samples that have elapsed. */
-        Optional<int64_t> getTimeInSamples() const { return getOptional (flagTimeSamples, timeInSamples); }
+        std::optional<int64_t> getTimeInSamples() const { return getOptional (flagTimeSamples, timeInSamples); }
 
         /** @see getTimeInSamples() */
-        void setTimeInSamples (Optional<int64_t> timeInSamplesIn) { setOptional (flagTimeSamples, timeInSamples, timeInSamplesIn); }
+        void setTimeInSamples (std::optional<int64_t> timeInSamplesIn) { setOptional (flagTimeSamples, timeInSamples, timeInSamplesIn); }
 
         /** Returns the number of seconds that have elapsed. */
-        Optional<double> getTimeInSeconds() const { return getOptional (flagTimeSeconds, timeInSeconds); }
+        std::optional<double> getTimeInSeconds() const { return getOptional (flagTimeSeconds, timeInSeconds); }
 
         /** @see getTimeInSamples() */
-        void setTimeInSeconds (Optional<double> timeInSecondsIn) { setOptional (flagTimeSeconds, timeInSeconds, timeInSecondsIn); }
+        void setTimeInSeconds (std::optional<double> timeInSecondsIn) { setOptional (flagTimeSeconds, timeInSeconds, timeInSecondsIn); }
 
         /** Returns the bpm, if available. */
-        Optional<double> getBpm() const { return getOptional (flagTempo, tempoBpm); }
+        std::optional<double> getBpm() const { return getOptional (flagTempo, tempoBpm); }
 
         /** @see getBpm() */
-        void setBpm (Optional<double> bpmIn) { setOptional (flagTempo, tempoBpm, bpmIn); }
+        void setBpm (std::optional<double> bpmIn) { setOptional (flagTempo, tempoBpm, bpmIn); }
 
         /** Returns the time signature, if available. */
-        Optional<TimeSignature> getTimeSignature() const { return getOptional (flagTimeSignature, timeSignature); }
+        std::optional<TimeSignature> getTimeSignature() const { return getOptional (flagTimeSignature, timeSignature); }
 
         /** @see getTimeSignature() */
-        void setTimeSignature (Optional<TimeSignature> timeSignatureIn) { setOptional (flagTimeSignature, timeSignature, timeSignatureIn); }
+        void setTimeSignature (std::optional<TimeSignature> timeSignatureIn) { setOptional (flagTimeSignature, timeSignature, timeSignatureIn); }
 
         /** Returns host loop points, if available. */
-        Optional<LoopPoints> getLoopPoints() const { return getOptional (flagLoopPoints, loopPoints); }
+        std::optional<LoopPoints> getLoopPoints() const { return getOptional (flagLoopPoints, loopPoints); }
 
         /** @see getLoopPoints() */
-        void setLoopPoints (Optional<LoopPoints> loopPointsIn) { setOptional (flagLoopPoints, loopPoints, loopPointsIn); }
+        void setLoopPoints (std::optional<LoopPoints> loopPointsIn) { setOptional (flagLoopPoints, loopPoints, loopPointsIn); }
 
         /** The number of bars since the beginning of the timeline.
 
             This value isn't available in all hosts or in all plugin formats.
         */
-        Optional<int64_t> getBarCount() const { return getOptional (flagBarCount, barCount); }
+        std::optional<int64_t> getBarCount() const { return getOptional (flagBarCount, barCount); }
 
         /** @see getBarCount() */
-        void setBarCount (Optional<int64_t> barCountIn) { setOptional (flagBarCount, barCount, barCountIn); }
+        void setBarCount (std::optional<int64_t> barCountIn) { setOptional (flagBarCount, barCount, barCountIn); }
 
         /** The position of the start of the last bar, in units of quarter-notes.
 
@@ -406,40 +406,40 @@ class YUP_API AudioPlayHead
 
             Note - this value may be unavailable on some hosts, e.g. Pro-Tools.
         */
-        Optional<double> getPpqPositionOfLastBarStart() const { return getOptional (flagLastBarStartPpq, lastBarStartPpq); }
+        std::optional<double> getPpqPositionOfLastBarStart() const { return getOptional (flagLastBarStartPpq, lastBarStartPpq); }
 
         /** @see getPpqPositionOfLastBarStart() */
-        void setPpqPositionOfLastBarStart (Optional<double> positionIn) { setOptional (flagLastBarStartPpq, lastBarStartPpq, positionIn); }
+        void setPpqPositionOfLastBarStart (std::optional<double> positionIn) { setOptional (flagLastBarStartPpq, lastBarStartPpq, positionIn); }
 
         /** The video frame rate, if available. */
-        Optional<FrameRate> getFrameRate() const { return getOptional (flagFrameRate, frame); }
+        std::optional<FrameRate> getFrameRate() const { return getOptional (flagFrameRate, frame); }
 
         /** @see getFrameRate() */
-        void setFrameRate (Optional<FrameRate> frameRateIn) { setOptional (flagFrameRate, frame, frameRateIn); }
+        void setFrameRate (std::optional<FrameRate> frameRateIn) { setOptional (flagFrameRate, frame, frameRateIn); }
 
         /** The current play position, in units of quarter-notes. */
-        Optional<double> getPpqPosition() const { return getOptional (flagPpqPosition, positionPpq); }
+        std::optional<double> getPpqPosition() const { return getOptional (flagPpqPosition, positionPpq); }
 
         /** @see getPpqPosition() */
-        void setPpqPosition (Optional<double> ppqPositionIn) { setOptional (flagPpqPosition, positionPpq, ppqPositionIn); }
+        void setPpqPosition (std::optional<double> ppqPositionIn) { setOptional (flagPpqPosition, positionPpq, ppqPositionIn); }
 
         /** For timecode, the position of the start of the timeline, in seconds from 00:00:00:00. */
-        Optional<double> getEditOriginTime() const { return getOptional (flagOriginTime, originTime); }
+        std::optional<double> getEditOriginTime() const { return getOptional (flagOriginTime, originTime); }
 
         /** @see getEditOriginTime() */
-        void setEditOriginTime (Optional<double> editOriginTimeIn) { setOptional (flagOriginTime, originTime, editOriginTimeIn); }
+        void setEditOriginTime (std::optional<double> editOriginTimeIn) { setOptional (flagOriginTime, originTime, editOriginTimeIn); }
 
         /** Get the host's callback time in nanoseconds, if available. */
-        Optional<uint64_t> getHostTimeNs() const { return getOptional (flagHostTimeNs, hostTimeNs); }
+        std::optional<uint64_t> getHostTimeNs() const { return getOptional (flagHostTimeNs, hostTimeNs); }
 
         /** @see getHostTimeNs() */
-        void setHostTimeNs (Optional<uint64_t> hostTimeNsIn) { setOptional (flagHostTimeNs, hostTimeNs, hostTimeNsIn); }
+        void setHostTimeNs (std::optional<uint64_t> hostTimeNsIn) { setOptional (flagHostTimeNs, hostTimeNs, hostTimeNsIn); }
 
         /** The current play position, in samples from the start of processing, without looping, if available. */
-        Optional<int64_t> getContinuousTimeInSamples() const { return getOptional (flagContinuousTime, continuousTimeInSamples); }
+        std::optional<int64_t> getContinuousTimeInSamples() const { return getOptional (flagContinuousTime, continuousTimeInSamples); }
 
         /** @see getContinuousTimeInSamples() */
-        void setContinuousTimeInSamples (Optional<int64_t> cont) { setOptional (flagContinuousTime, continuousTimeInSamples, cont); }
+        void setContinuousTimeInSamples (std::optional<int64_t> cont) { setOptional (flagContinuousTime, continuousTimeInSamples, cont); }
 
         /** True if the transport is currently playing. */
         bool getIsPlaying() const { return getFlag (flagIsPlaying); }
@@ -502,18 +502,18 @@ class YUP_API AudioPlayHead
         }
 
         template <typename Value>
-        Optional<Value> getOptional (int64_t flagToCheck, Value value) const
+        std::optional<Value> getOptional (int64_t flagToCheck, Value value) const
         {
-            return getFlag (flagToCheck) ? makeOptional (std::move (value)) : nullopt;
+            return getFlag (flagToCheck) ? std::make_optional (std::move (value)) : std::nullopt;
         }
 
         template <typename Value>
-        void setOptional (int64_t flagToCheck, Value& value, Optional<Value> opt)
+        void setOptional (int64_t flagToCheck, Value& value, std::optional<Value> opt)
         {
-            if (opt.hasValue())
+            if (opt.has_value())
                 value = *opt;
 
-            setFlag (flagToCheck, opt.hasValue());
+            setFlag (flagToCheck, opt.has_value());
         }
 
         enum
@@ -564,7 +564,7 @@ class YUP_API AudioPlayHead
         in which a time would make sense, and some hosts will almost certainly have
         multithreading issues if it's not called on the audio thread.
     */
-    virtual Optional<PositionInfo> getPosition() const = 0;
+    virtual std::optional<PositionInfo> getPosition() const = 0;
 
     /** Returns true if this object can control the transport. */
     virtual bool canControlTransport();

modules/yup_audio_basics/midi/yup_MidiFile.cpp

@@ -79,15 +79,15 @@ struct ReadTrait<uint16>
 };
 
 template <typename Integral>
-Optional<Integral> tryRead (const uint8*& data, size_t& remaining)
+std::optional<Integral> tryRead (const uint8*& data, size_t& remaining)
 {
     using Trait = ReadTrait<Integral>;
     constexpr auto size = sizeof (Integral);
 
     if (remaining < size)
         return {};
 
-    const Optional<Integral> result { Trait::read (data) };
+    const std::optional<Integral> result { Trait::read (data) };
 
     data += size;
     remaining -= size;
@@ -103,15 +103,15 @@ struct HeaderDetails
     short numberOfTracks = 0;
 };
 
-static Optional<HeaderDetails> parseMidiHeader (const uint8* const initialData,
-                                                const size_t maxSize)
+static std::optional<HeaderDetails> parseMidiHeader (const uint8* const initialData,
+                                                     const size_t maxSize)
 {
     auto* data = initialData;
     auto remaining = maxSize;
 
     auto ch = tryRead<uint32> (data, remaining);
 
-    if (! ch.hasValue())
+    if (! ch.has_value())
         return {};
 
     if (*ch != ByteOrder::bigEndianInt ("MThd"))
@@ -124,7 +124,7 @@ static Optional<HeaderDetails> parseMidiHeader (const uint8* const initialData,
             {
                 ch = tryRead<uint32> (data, remaining);
 
-                if (! ch.hasValue())
+                if (! ch.has_value())
                     return {};
 
                 if (*ch == ByteOrder::bigEndianInt ("MThd"))
@@ -141,22 +141,22 @@ static Optional<HeaderDetails> parseMidiHeader (const uint8* const initialData,
 
     const auto bytesRemaining = tryRead<uint32> (data, remaining);
 
-    if (! bytesRemaining.hasValue() || *bytesRemaining > remaining)
+    if (! bytesRemaining.has_value() || *bytesRemaining > remaining)
         return {};
 
     const auto optFileType = tryRead<uint16> (data, remaining);
 
-    if (! optFileType.hasValue() || 2 < *optFileType)
+    if (! optFileType.has_value() || 2 < *optFileType)
         return {};
 
     const auto optNumTracks = tryRead<uint16> (data, remaining);
 
-    if (! optNumTracks.hasValue() || (*optFileType == 0 && *optNumTracks != 1))
+    if (! optNumTracks.has_value() || (*optFileType == 0 && *optNumTracks != 1))
         return {};
 
     const auto optTimeFormat = tryRead<uint16> (data, remaining);
 
-    if (! optTimeFormat.hasValue())
+    if (! optTimeFormat.has_value())
         return {};
 
     HeaderDetails result;
@@ -403,7 +403,7 @@ bool MidiFile::readFrom (InputStream& sourceStream,
 
     const auto optHeader = MidiFileHelpers::parseMidiHeader (d, size);
 
-    if (! optHeader.hasValue())
+    if (! optHeader.has_value())
         return false;
 
     const auto header = *optHeader;
@@ -416,12 +416,12 @@ bool MidiFile::readFrom (InputStream& sourceStream,
     {
         const auto optChunkType = MidiFileHelpers::tryRead<uint32> (d, size);
 
-        if (! optChunkType.hasValue())
+        if (! optChunkType.has_value())
             return false;
 
         const auto optChunkSize = MidiFileHelpers::tryRead<uint32> (d, size);
 
-        if (! optChunkSize.hasValue())
+        if (! optChunkSize.has_value())
             return false;
 
         const auto chunkSize = *optChunkSize;

modules/yup_audio_basics/midi/yup_MidiMessageSequence.cpp

@@ -335,12 +335,12 @@ void MidiMessageSequence::deleteSysExMessages()
 //==============================================================================
 class OptionalPitchWheel
 {
-    Optional<int> value;
+    std::optional<int> value;
 
 public:
     void emit (int channel, Array<MidiMessage>& out) const
     {
-        if (value.hasValue())
+        if (value.has_value())
             out.add (MidiMessage::pitchWheel (channel, *value));
     }
 
@@ -352,13 +352,13 @@ class OptionalPitchWheel
 
 class OptionalControllerValues
 {
-    Optional<char> values[128];
+    std::optional<char> values[128];
 
 public:
     void emit (int channel, Array<MidiMessage>& out) const
     {
         for (auto it = std::begin (values); it != std::end (values); ++it)
-            if (it->hasValue())
+            if (it->has_value())
                 out.add (MidiMessage::controllerEvent (channel, (int) std::distance (std::begin (values), it), **it));
     }
 
@@ -370,15 +370,15 @@ class OptionalControllerValues
 
 class OptionalProgramChange
 {
-    Optional<char> value, bankLSB, bankMSB;
+    std::optional<char> value, bankLSB, bankMSB;
 
 public:
     void emit (int channel, double time, Array<MidiMessage>& out) const
     {
-        if (! value.hasValue())
+        if (! value.has_value())
             return;
 
-        if (bankLSB.hasValue() && bankMSB.hasValue())
+        if (bankLSB.has_value() && bankMSB.has_value())
         {
             out.add (MidiMessage::controllerEvent (channel, 0x00, *bankMSB).withTimeStamp (time));
             out.add (MidiMessage::controllerEvent (channel, 0x20, *bankLSB).withTimeStamp (time));
@@ -414,7 +414,7 @@ class ParameterNumberState
         nrpn
     };
 
-    Optional<char> newestRpnLsb, newestRpnMsb, newestNrpnLsb, newestNrpnMsb, lastSentLsb, lastSentMsb;
+    std::optional<char> newestRpnLsb, newestRpnMsb, newestNrpnLsb, newestNrpnMsb, lastSentLsb, lastSentMsb;
     Kind lastSentKind = Kind::rpn, newestKind = Kind::rpn;
 
 public:
@@ -430,7 +430,7 @@ class ParameterNumberState
         auto lastSent = std::tie (lastSentKind, lastSentMsb, lastSentLsb);
         const auto newest = std::tie (newestKind, newestMsb, newestLsb);
 
-        if (lastSent == newest || ! newestMsb.hasValue() || ! newestLsb.hasValue())
+        if (lastSent == newest || ! newestMsb.has_value() || ! newestLsb.has_value())
             return;
 
         out.add (MidiMessage::controllerEvent (channel, newestKind == Kind::rpn ? 0x65 : 0x63, *newestMsb).withTimeStamp (time));

modules/yup_audio_devices/native/yup_Audio_ios.cpp

@@ -658,7 +658,7 @@ struct iOSAudioIODevice::Pimpl final : public AsyncUpdater
                 impl.handleAudioTransportEvent (kAudioUnitRemoteControlEvent_Rewind);
         }
 
-        Optional<PositionInfo> getPosition() const override
+        std::optional<PositionInfo> getPosition() const override
         {
             if (! canControlTransportImpl())
                 return {};

modules/yup_audio_plugin_client/clap/yup_audio_plugin_client_CLAP.cpp

@@ -227,7 +227,7 @@ class AudioPluginPlayHeadCLAP final : public AudioPlayHead
             return;
     }
 
-    Optional<PositionInfo> getPosition() const override
+    std::optional<PositionInfo> getPosition() const override
     {
         if (process.transport == nullptr)
             return {};