Remove m prefix from data members (#633)

Author: sbooth

Sources/CSFBAudioEngine/Player/AudioPlayer.h

@@ -34,33 +34,33 @@ class AudioPlayer final {
 	using Decoder 		= id<SFBPCMDecoding>;
 
 	/// The shared log for all `AudioPlayer` instances
-	static const os_log_t sLog;
+	static const os_log_t log_;
 
 	/// Unsafe reference to owning `SFBAudioPlayer` instance
-	__unsafe_unretained SFBAudioPlayer 		*mPlayer 			{nil};
+	__unsafe_unretained SFBAudioPlayer 		*player_ 			{nil};
 
 private:
 	/// The underlying `AVAudioEngine` instance
-	AVAudioEngine 							*mEngine 			{nil};
+	AVAudioEngine 							*engine_ 			{nil};
 
 	/// The player driving the audio processing graph
-	SFBAudioPlayerNode						*mPlayerNode 		{nil};
+	SFBAudioPlayerNode						*playerNode_ 		{nil};
 
 	/// Decoders enqueued for non-gapless playback
-	std::deque<Decoder>						mQueuedDecoders;
-	/// The lock used to protect access to `mQueuedDecoders`
-	mutable CXXUnfairLock::UnfairLock 		mQueueLock;
+	std::deque<Decoder>						queuedDecoders_;
+	/// The lock used to protect access to `queuedDecoders_`
+	mutable CXXUnfairLock::UnfairLock 		queueLock_;
 
 	/// The currently rendering decoder
-	id <SFBPCMDecoding> 					mNowPlaying 		{nil};
-	/// The lock used to protect access to `mNowPlaying`
-	mutable CXXUnfairLock::UnfairLock 		mNowPlayingLock;
+	id <SFBPCMDecoding> 					nowPlaying_ 		{nil};
+	/// The lock used to protect access to `nowPlaying_`
+	mutable CXXUnfairLock::UnfairLock 		nowPlayingLock_;
 
 	/// The dispatch queue used for asynchronous events
-	dispatch_queue_t						mEventQueue 		{nil};
+	dispatch_queue_t						eventQueue_ 		{nil};
 
 	/// Flags
-	std::atomic_uint 						mFlags 				{0};
+	std::atomic_uint 						flags_ 				{0};
 	static_assert(std::atomic_uint::is_always_lock_free, "Lock-free std::atomic_uint required");
 
 public:
@@ -81,18 +81,18 @@ class AudioPlayer final {
 #if DEBUG
 		assert(format != nil);
 #endif /* DEBUG */
-		return mPlayerNode->_node->SupportsFormat(format);
+		return playerNode_->_node->SupportsFormat(format);
 	}
 
 	void ClearQueue() noexcept
 	{
-		mPlayerNode->_node->ClearQueue();
+		playerNode_->_node->ClearQueue();
 		ClearInternalDecoderQueue();
 	}
 
 	bool QueueIsEmpty() const noexcept
 	{
-		return mPlayerNode->_node->QueueIsEmpty() && InternalDecoderQueueIsEmpty();
+		return playerNode_->_node->QueueIsEmpty() && InternalDecoderQueueIsEmpty();
 	}
 
 	// MARK: - Playback Control
@@ -111,46 +111,46 @@ class AudioPlayer final {
 
 	bool PlayerNodeIsPlaying() const noexcept
 	{
-		return mPlayerNode->_node->IsPlaying();
+		return playerNode_->_node->IsPlaying();
 	}
 
 	SFBAudioPlayerPlaybackState PlaybackState() const noexcept
 	{
-		if(mFlags.load(std::memory_order_acquire) & static_cast<unsigned int>(Flags::engineIsRunning))
-			return mPlayerNode->_node->IsPlaying() ? SFBAudioPlayerPlaybackStatePlaying : SFBAudioPlayerPlaybackStatePaused;
+		if(flags_.load(std::memory_order_acquire) & static_cast<unsigned int>(Flags::engineIsRunning))
+			return playerNode_->_node->IsPlaying() ? SFBAudioPlayerPlaybackStatePlaying : SFBAudioPlayerPlaybackStatePaused;
 		else
 			return SFBAudioPlayerPlaybackStateStopped;
 	}
 
 	bool IsPlaying() const noexcept
 	{
-		return (mFlags.load(std::memory_order_acquire) & static_cast<unsigned int>(Flags::engineIsRunning)) && mPlayerNode->_node->IsPlaying();
+		return (flags_.load(std::memory_order_acquire) & static_cast<unsigned int>(Flags::engineIsRunning)) && playerNode_->_node->IsPlaying();
 	}
 
 	bool IsPaused() const noexcept
 	{
-		return (mFlags.load(std::memory_order_acquire) & static_cast<unsigned int>(Flags::engineIsRunning)) && !mPlayerNode->_node->IsPlaying();
+		return (flags_.load(std::memory_order_acquire) & static_cast<unsigned int>(Flags::engineIsRunning)) && !playerNode_->_node->IsPlaying();
 	}
 
 	bool IsStopped() const noexcept
 	{
-		return !(mFlags.load(std::memory_order_acquire) & static_cast<unsigned int>(Flags::engineIsRunning));
+		return !(flags_.load(std::memory_order_acquire) & static_cast<unsigned int>(Flags::engineIsRunning));
 	}
 
 	bool IsReady() const noexcept
 	{
-		return mPlayerNode->_node->IsReady();
+		return playerNode_->_node->IsReady();
 	}
 
 	Decoder _Nullable CurrentDecoder() const noexcept
 	{
-		return mPlayerNode->_node->CurrentDecoder();
+		return playerNode_->_node->CurrentDecoder();
 	}
 
 	Decoder _Nullable NowPlaying() const noexcept
 	{
-		std::lock_guard lock(mNowPlayingLock);
-		return mNowPlaying;
+		std::lock_guard lock(nowPlayingLock_);
+		return nowPlaying_;
 	}
 
 private:
@@ -161,49 +161,49 @@ class AudioPlayer final {
 
 	SFBPlaybackPosition PlaybackPosition() const noexcept
 	{
-		return mPlayerNode->_node->PlaybackPosition();
+		return playerNode_->_node->PlaybackPosition();
 	}
 
 	SFBPlaybackTime PlaybackTime() const noexcept
 	{
-		return mPlayerNode->_node->PlaybackTime();
+		return playerNode_->_node->PlaybackTime();
 	}
 
 	bool GetPlaybackPositionAndTime(SFBPlaybackPosition * _Nullable playbackPosition, SFBPlaybackTime * _Nullable playbackTime) const noexcept
 	{
-		return mPlayerNode->_node->GetPlaybackPositionAndTime(playbackPosition, playbackTime);
+		return playerNode_->_node->GetPlaybackPositionAndTime(playbackPosition, playbackTime);
 	}
 
 	// MARK: - Seeking
 
 	bool SeekForward(NSTimeInterval secondsToSkip) noexcept
 	{
-		return mPlayerNode->_node->SeekForward(secondsToSkip);
+		return playerNode_->_node->SeekForward(secondsToSkip);
 	}
 
 	bool SeekBackward(NSTimeInterval secondsToSkip) noexcept
 	{
-		return mPlayerNode->_node->SeekBackward(secondsToSkip);
+		return playerNode_->_node->SeekBackward(secondsToSkip);
 	}
 
 	bool SeekToTime(NSTimeInterval timeInSeconds) noexcept
 	{
-		return mPlayerNode->_node->SeekToTime(timeInSeconds);
+		return playerNode_->_node->SeekToTime(timeInSeconds);
 	}
 
 	bool SeekToPosition(double position) noexcept
 	{
-		return mPlayerNode->_node->SeekToPosition(position);
+		return playerNode_->_node->SeekToPosition(position);
 	}
 
 	bool SeekToFrame(AVAudioFramePosition frame) noexcept
 	{
-		return mPlayerNode->_node->SeekToFrame(frame);
+		return playerNode_->_node->SeekToFrame(frame);
 	}
 
 	bool SupportsSeeking() const noexcept
 	{
-		return mPlayerNode->_node->SupportsSeeking();
+		return playerNode_->_node->SupportsSeeking();
 	}
 
 #if !TARGET_OS_IPHONE
@@ -224,20 +224,20 @@ class AudioPlayer final {
 
 	AVAudioEngine * GetAudioEngine() const noexcept
 	{
-		return mEngine;
+		return engine_;
 	}
 
 	SFBAudioPlayerNode * GetPlayerNode() const noexcept
 	{
-		return mPlayerNode;
+		return playerNode_;
 	}
 
 	// MARK: - Debugging
 
 	void LogProcessingGraphDescription(os_log_t _Nonnull log, os_log_type_t type) const noexcept;
 
 private:
-	/// Possible bits in `mFlags`
+	/// Possible bits in `flags_`
 	enum class Flags : unsigned int {
 		/// Cached value of `_audioEngine.isRunning`
 		engineIsRunning				= 1u << 0,
@@ -250,15 +250,15 @@ class AudioPlayer final {
 	/// Returns true if the internal queue of decoders is empty
 	bool InternalDecoderQueueIsEmpty() const noexcept
 	{
-		std::lock_guard lock(mQueueLock);
-		return mQueuedDecoders.empty();
+		std::lock_guard lock(queueLock_);
+		return queuedDecoders_.empty();
 	}
 
 	/// Removes all decoders from the internal decoder queue
 	void ClearInternalDecoderQueue() noexcept
 	{
-		std::lock_guard lock(mQueueLock);
-		mQueuedDecoders.clear();
+		std::lock_guard lock(queueLock_);
+		queuedDecoders_.clear();
 	}
 
 	/// Inserts `decoder` at the end of the internal decoder queue