Improve indentation, constness of 'Activity' and dynamic analyser.

Activity/Observer.hpp

@@ -22,7 +22,7 @@ namespace Activity {
 	and/or to show or unshow status indicators.
 */
 class Observer {
-	public:
+public:
 	virtual ~Observer() = default;
 
 	/// Provides hints as to the sort of information presented on an LED.

Activity/Source.hpp

@@ -13,7 +13,7 @@
 namespace Activity {
 
 class Source {
-	public:
+public:
 	virtual void set_activity_observer(Observer *observer) = 0;
 };
 

Analyser/Dynamic/ConfidenceCounter.hpp

@@ -18,7 +18,7 @@ namespace Analyser::Dynamic {
 	The initial value of the confidence counter is 0.5.
 */
 class ConfidenceCounter: public ConfidenceSource {
-	public:
+public:
 	/*! @returns The computed probability, based on the history of events. */
 	float get_confidence() final;
 
@@ -34,7 +34,7 @@ class ConfidenceCounter: public ConfidenceSource {
 	*/
 	void add_equivocal();
 
-	private:
+private:
 	int hits_ = 1;
 	int misses_ = 1;
 };

Analyser/Dynamic/ConfidenceSummary.cpp

@@ -13,7 +13,10 @@
 
 using namespace Analyser::Dynamic;
 
-ConfidenceSummary::ConfidenceSummary(const std::vector<ConfidenceSource *> &sources, const std::vector<float> &weights) :
+ConfidenceSummary::ConfidenceSummary(
+	const std::vector<ConfidenceSource *> &sources,
+	const std::vector<float> &weights
+) :
 	sources_(sources), weights_(weights) {
 	assert(weights.size() == sources.size());
 	weight_sum_ = std::accumulate(weights.begin(), weights.end(), 0.0f);

Analyser/Dynamic/ConfidenceSummary.hpp

@@ -18,7 +18,7 @@ namespace Analyser::Dynamic {
 	Summaries a collection of confidence sources by calculating their weighted sum.
 */
 class ConfidenceSummary: public ConfidenceSource {
-	public:
+public:
 	/*!
 		Instantiates a summary that will produce the weighted sum of
 		@c sources, each using the corresponding entry of @c weights.
@@ -32,7 +32,7 @@ class ConfidenceSummary: public ConfidenceSource {
 	/*! @returns The weighted sum of all sources. */
 	float get_confidence() final;
 
-	private:
+private:
 	const std::vector<ConfidenceSource *> sources_;
 	const std::vector<float> weights_;
 	float weight_sum_;

Analyser/Dynamic/MultiMachine/Implementation/MultiConfigurable.cpp

@@ -15,7 +15,7 @@ using namespace Analyser::Dynamic;
 namespace {
 
 class MultiStruct: public Reflection::Struct {
-	public:
+public:
 	MultiStruct(const std::vector<Configurable::Device *> &devices) : devices_(devices) {
 		for(auto device: devices) {
 			options_.emplace_back(device->get_options());
@@ -80,7 +80,7 @@ class MultiStruct: public Reflection::Struct {
 		return nullptr;
 	}
 
-		void set(const std::string &name, const void *value, size_t offset) final {
+	void set(const std::string &name, const void *value, const size_t offset) final {
 		const auto safe_type = type_of(name);
 		if(!safe_type) return;
 
@@ -96,7 +96,7 @@ class MultiStruct: public Reflection::Struct {
 		}
 	}
 
-	private:
+private:
 	const std::vector<Configurable::Device *> &devices_;
 	std::vector<std::unique_ptr<Reflection::Struct>> options_;
 };

Analyser/Dynamic/MultiMachine/Implementation/MultiConfigurable.hpp

@@ -23,14 +23,14 @@ namespace Analyser::Dynamic {
 	order of delivered messages.
 */
 class MultiConfigurable: public Configurable::Device {
-	public:
-		MultiConfigurable(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines);
+public:
+	MultiConfigurable(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &);
 
 	// Below is the standard Configurable::Device interface; see there for documentation.
-		void set_options(const std::unique_ptr<Reflection::Struct> &options) final;
+	void set_options(const std::unique_ptr<Reflection::Struct> &) final;
 	std::unique_ptr<Reflection::Struct> get_options() final;
 
-	private:
+private:
 	std::vector<Configurable::Device *> devices_;
 };
 

Analyser/Dynamic/MultiMachine/Implementation/MultiJoystickMachine.cpp

@@ -15,8 +15,8 @@ using namespace Analyser::Dynamic;
 namespace {
 
 class MultiJoystick: public Inputs::Joystick {
-	public:
-		MultiJoystick(std::vector<MachineTypes::JoystickMachine *> &machines, std::size_t index) {
+public:
+	MultiJoystick(std::vector<MachineTypes::JoystickMachine *> &machines, const std::size_t index) {
 		for(const auto &machine: machines) {
 			const auto &joysticks = machine->get_joysticks();
 			if(joysticks.size() >= index) {
@@ -40,13 +40,13 @@ class MultiJoystick: public Inputs::Joystick {
 		return inputs;
 	}
 
-		void set_input(const Input &digital_input, bool is_active) final {
+	void set_input(const Input &digital_input, const bool is_active) final {
 		for(const auto &joystick: joysticks_) {
 			joystick->set_input(digital_input, is_active);
 		}
 	}
 
-		void set_input(const Input &digital_input, float value) final {
+	void set_input(const Input &digital_input, const float value) final {
 		for(const auto &joystick: joysticks_) {
 			joystick->set_input(digital_input, value);
 		}
@@ -58,7 +58,7 @@ class MultiJoystick: public Inputs::Joystick {
 		}
 	}
 
-	private:
+private:
 	std::vector<Input> inputs;
 	std::vector<Inputs::Joystick *> joysticks_;
 };

Analyser/Dynamic/MultiMachine/Implementation/MultiJoystickMachine.hpp

@@ -22,13 +22,13 @@ namespace Analyser::Dynamic {
 	order of delivered messages.
 */
 class MultiJoystickMachine: public MachineTypes::JoystickMachine {
-	public:
-		MultiJoystickMachine(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines);
+public:
+	MultiJoystickMachine(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &);
 
 	// Below is the standard JoystickMachine::Machine interface; see there for documentation.
 	const std::vector<std::unique_ptr<Inputs::Joystick>> &get_joysticks() final;
 
-	private:
+private:
 	std::vector<std::unique_ptr<Inputs::Joystick>> joysticks_;
 };
 

Analyser/Dynamic/MultiMachine/Implementation/MultiKeyboardMachine.cpp

@@ -24,7 +24,7 @@ void MultiKeyboardMachine::clear_all_keys() {
 	}
 }
 
-void MultiKeyboardMachine::set_key_state(uint16_t key, bool is_pressed) {
+void MultiKeyboardMachine::set_key_state(const uint16_t key, const bool is_pressed) {
 	for(const auto &machine: machines_) {
 		machine->set_key_state(key, is_pressed);
 	}
@@ -36,7 +36,7 @@ void MultiKeyboardMachine::type_string(const std::string &string) {
 	}
 }
 
-bool MultiKeyboardMachine::can_type(char c) const {
+bool MultiKeyboardMachine::can_type(const char c) const {
 	bool can_type = true;
 	for(const auto &machine: machines_) {
 		can_type &= machine->can_type(c);
@@ -51,12 +51,20 @@ Inputs::Keyboard &MultiKeyboardMachine::get_keyboard() {
 MultiKeyboardMachine::MultiKeyboard::MultiKeyboard(const std::vector<::MachineTypes::KeyboardMachine *> &machines)
 	: machines_(machines) {
 	for(const auto &machine: machines_) {
-		observed_keys_.insert(machine->get_keyboard().observed_keys().begin(), machine->get_keyboard().observed_keys().end());
+		observed_keys_.insert(
+			machine->get_keyboard().observed_keys().begin(),
+			machine->get_keyboard().observed_keys().end()
+		);
 		is_exclusive_ |= machine->get_keyboard().is_exclusive();
 	}
 }
 
-bool MultiKeyboardMachine::MultiKeyboard::set_key_pressed(Key key, char value, bool is_pressed, bool is_repeat) {
+bool MultiKeyboardMachine::MultiKeyboard::set_key_pressed(
+	const Key key,
+	const char value,
+	const bool is_pressed,
+	const bool is_repeat
+) {
 	bool was_consumed = false;
 	for(const auto &machine: machines_) {
 		was_consumed |= machine->get_keyboard().set_key_pressed(key, value, is_pressed, is_repeat);

Analyser/Dynamic/MultiMachine/Implementation/MultiKeyboardMachine.hpp

@@ -23,12 +23,12 @@ namespace Analyser::Dynamic {
 	order of delivered messages.
 */
 class MultiKeyboardMachine: public MachineTypes::KeyboardMachine {
-	private:
+private:
 	std::vector<MachineTypes::KeyboardMachine *> machines_;
 
 	class MultiKeyboard: public Inputs::Keyboard {
 		public:
-				MultiKeyboard(const std::vector<MachineTypes::KeyboardMachine *> &machines);
+			MultiKeyboard(const std::vector<MachineTypes::KeyboardMachine *> &);
 
 			bool set_key_pressed(Key key, char value, bool is_pressed, bool is_repeat) final;
 			void reset_all_keys() final;
@@ -42,7 +42,7 @@ class MultiKeyboardMachine: public MachineTypes::KeyboardMachine {
 	};
 	std::unique_ptr<MultiKeyboard> keyboard_;
 
-	public:
+public:
 	MultiKeyboardMachine(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines);
 
 	// Below is the standard KeyboardMachine::Machine interface; see there for documentation.

Analyser/Dynamic/MultiMachine/Implementation/MultiMediaTarget.hpp

@@ -23,13 +23,13 @@ namespace Analyser::Dynamic {
 	order of delivered messages.
 */
 struct MultiMediaTarget: public MachineTypes::MediaTarget {
-	public:
-		MultiMediaTarget(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines);
+public:
+	MultiMediaTarget(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &);
 
 	// Below is the standard MediaTarget::Machine interface; see there for documentation.
-		bool insert_media(const Analyser::Static::Media &media) final;
+	bool insert_media(const Analyser::Static::Media &) final;
 
-	private:
+private:
 	std::vector<MachineTypes::MediaTarget *> targets_;
 };
 

Analyser/Dynamic/MultiMachine/Implementation/MultiProducer.cpp

@@ -53,7 +53,7 @@ void MultiInterface<MachineType>::perform_serial(const std::function<void(Machin
 }
 
 // MARK: - MultiScanProducer
-void MultiScanProducer::set_scan_target(Outputs::Display::ScanTarget *scan_target) {
+void MultiScanProducer::set_scan_target(Outputs::Display::ScanTarget *const scan_target) {
 	scan_target_ = scan_target;
 
 	std::lock_guard machines_lock(machines_mutex_);
@@ -80,7 +80,12 @@ void MultiScanProducer::did_change_machine_order() {
 }
 
 // MARK: - MultiAudioProducer
-MultiAudioProducer::MultiAudioProducer(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines, std::recursive_mutex &machines_mutex) : MultiInterface(machines, machines_mutex) {
+MultiAudioProducer::MultiAudioProducer(
+	const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines,
+	std::recursive_mutex &machines_mutex
+) :
+	MultiInterface(machines, machines_mutex)
+{
 	speaker_ = MultiSpeaker::create(machines);
 }
 
@@ -96,7 +101,7 @@ void MultiAudioProducer::did_change_machine_order() {
 
 // MARK: - MultiTimedMachine
 
-void MultiTimedMachine::run_for(Time::Seconds duration) {
+void MultiTimedMachine::run_for(const Time::Seconds duration) {
 	perform_parallel([duration](::MachineTypes::TimedMachine *machine) {
 		if(machine->get_confidence() >= 0.01f) machine->run_for(duration);
 	});

Analyser/Dynamic/MultiMachine/Implementation/MultiProducer.hpp

@@ -21,11 +21,14 @@
 namespace Analyser::Dynamic {
 
 template <typename MachineType> class MultiInterface {
-	public:
-		MultiInterface(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines, std::recursive_mutex &machines_mutex) :
+public:
+	MultiInterface(
+		const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines,
+		std::recursive_mutex &machines_mutex
+	) :
 		machines_(machines), machines_mutex_(machines_mutex), queues_(machines.size()) {}
 
-	protected:
+protected:
 	/*!
 		Performs a parallel for operation across all machines, performing the supplied
 		function on each and returning only once all applications have completed.
@@ -40,16 +43,16 @@ template <typename MachineType> class MultiInterface {
 	*/
 	void perform_serial(const std::function<void(MachineType *)> &);
 
-	protected:
+protected:
 	const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines_;
 	std::recursive_mutex &machines_mutex_;
 
-	private:
+private:
 	std::vector<Concurrency::AsyncTaskQueue<true>> queues_;
 };
 
 class MultiTimedMachine: public MultiInterface<MachineTypes::TimedMachine>, public MachineTypes::TimedMachine {
-	public:
+public:
 	using MultiInterface::MultiInterface;
 
 	/*!
@@ -60,19 +63,19 @@ class MultiTimedMachine: public MultiInterface<MachineTypes::TimedMachine>, publ
 		virtual void did_run_machines(MultiTimedMachine *) = 0;
 	};
 	/// Sets @c delegate as the receiver of delegate messages.
-		void set_delegate(Delegate *delegate) {
+	void set_delegate(Delegate *const delegate) {
 		delegate_ = delegate;
 	}
 
 	void run_for(Time::Seconds duration) final;
 
-	private:
-		void run_for(const Cycles) final {}
+private:
+	void run_for(Cycles) final {}
 	Delegate *delegate_ = nullptr;
 };
 
 class MultiScanProducer: public MultiInterface<MachineTypes::ScanProducer>, public MachineTypes::ScanProducer {
-	public:
+public:
 	using MultiInterface::MultiInterface;
 
 	/*!
@@ -82,16 +85,16 @@ class MultiScanProducer: public MultiInterface<MachineTypes::ScanProducer>, publ
 	*/
 	void did_change_machine_order();
 
-		void set_scan_target(Outputs::Display::ScanTarget *scan_target) final;
+	void set_scan_target(Outputs::Display::ScanTarget *) final;
 	Outputs::Display::ScanStatus get_scan_status() const final;
 
-	private:
+private:
 	Outputs::Display::ScanTarget *scan_target_ = nullptr;
 };
 
 class MultiAudioProducer: public MultiInterface<MachineTypes::AudioProducer>, public MachineTypes::AudioProducer {
-	public:
-		MultiAudioProducer(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines, std::recursive_mutex &machines_mutex);
+public:
+	MultiAudioProducer(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &, std::recursive_mutex &);
 
 	/*!
 		Informs the MultiAudio that the order of machines has changed; it
@@ -101,7 +104,7 @@ class MultiAudioProducer: public MultiInterface<MachineTypes::AudioProducer>, pu
 
 	Outputs::Speaker::Speaker *get_speaker() final;
 
-	private:
+private:
 	MultiSpeaker *speaker_ = nullptr;
 };
 

Analyser/Dynamic/MultiMachine/Implementation/MultiSpeaker.cpp

@@ -28,7 +28,7 @@ MultiSpeaker::MultiSpeaker(const std::vector<Outputs::Speaker::Speaker *> &speak
 	}
 }
 
-float MultiSpeaker::get_ideal_clock_rate_in_range(float minimum, float maximum) {
+float MultiSpeaker::get_ideal_clock_rate_in_range(const float minimum, const float maximum) {
 	float ideal = 0.0f;
 	for(const auto &speaker: speakers_) {
 		ideal += speaker->get_ideal_clock_rate_in_range(minimum, maximum);
@@ -37,7 +37,7 @@ float MultiSpeaker::get_ideal_clock_rate_in_range(float minimum, float maximum)
 	return ideal / float(speakers_.size());
 }
 
-void MultiSpeaker::set_computed_output_rate(float cycles_per_second, int buffer_size, bool stereo) {
+void MultiSpeaker::set_computed_output_rate(const float cycles_per_second, const int buffer_size, const bool stereo) {
 	stereo_output_ = stereo;
 	for(const auto &speaker: speakers_) {
 		speaker->set_computed_output_rate(cycles_per_second, buffer_size, stereo);
@@ -54,13 +54,13 @@ bool MultiSpeaker::get_is_stereo() {
 	return false;
 }
 
-void MultiSpeaker::set_output_volume(float volume) {
+void MultiSpeaker::set_output_volume(const float volume) {
 	for(const auto &speaker: speakers_) {
 		speaker->set_output_volume(volume);
 	}
 }
 
-void MultiSpeaker::speaker_did_complete_samples(Speaker *speaker, const std::vector<int16_t> &buffer) {
+void MultiSpeaker::speaker_did_complete_samples(Speaker *const speaker, const std::vector<int16_t> &buffer) {
 	auto delegate = delegate_.load(std::memory_order_relaxed);
 	if(!delegate) return;
 	{
@@ -70,7 +70,7 @@ void MultiSpeaker::speaker_did_complete_samples(Speaker *speaker, const std::vec
 	did_complete_samples(this, buffer, stereo_output_);
 }
 
-void MultiSpeaker::speaker_did_change_input_clock(Speaker *speaker) {
+void MultiSpeaker::speaker_did_change_input_clock(Speaker *const speaker) {
 	auto delegate = delegate_.load(std::memory_order_relaxed);
 	if(!delegate) return;
 	{
@@ -80,7 +80,7 @@ void MultiSpeaker::speaker_did_change_input_clock(Speaker *speaker) {
 	delegate->speaker_did_change_input_clock(this);
 }
 
-void MultiSpeaker::set_new_front_machine(::Machine::DynamicMachine *machine) {
+void MultiSpeaker::set_new_front_machine(::Machine::DynamicMachine *const machine) {
 	{
 		std::lock_guard lock_guard(front_speaker_mutex_);
 		front_speaker_ = machine->audio_producer()->get_speaker();

Analyser/Dynamic/MultiMachine/Implementation/MultiSpeaker.hpp

@@ -25,15 +25,15 @@ namespace Analyser::Dynamic {
 	abreast of the current frontmost machine.
 */
 class MultiSpeaker: public Outputs::Speaker::Speaker, Outputs::Speaker::Speaker::Delegate {
-	public:
+public:
 	/*!
 		Provides a construction mechanism that may return nullptr, in the case that all included
 		machines return nullptr as their speaker.
 	*/
-		static MultiSpeaker *create(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines);
+	static MultiSpeaker *create(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &);
 
 	/// This class requires the caller to nominate changes in the frontmost machine.
-		void set_new_front_machine(::Machine::DynamicMachine *machine);
+	void set_new_front_machine(::Machine::DynamicMachine *);
 
 	// Below is the standard Outputs::Speaker::Speaker interface; see there for documentation.
 	float get_ideal_clock_rate_in_range(float minimum, float maximum) override;
@@ -41,7 +41,7 @@ class MultiSpeaker: public Outputs::Speaker::Speaker, Outputs::Speaker::Speaker:
 	bool get_is_stereo() override;
 	void set_output_volume(float) override;
 
-	private:
+private:
 	void speaker_did_complete_samples(Speaker *speaker, const std::vector<int16_t> &buffer) final;
 	void speaker_did_change_input_clock(Speaker *speaker) final;
 	MultiSpeaker(const std::vector<Outputs::Speaker::Speaker *> &speakers);

Analyser/Dynamic/MultiMachine/MultiMachine.cpp

@@ -27,7 +27,8 @@ MultiMachine::MultiMachine(std::vector<std::unique_ptr<DynamicMachine>> &&machin
 	audio_producer_(machines_, machines_mutex_),
 	joystick_machine_(machines_),
 	keyboard_machine_(machines_),
-	media_target_(machines_) {
+	media_target_(machines_)
+{
 	timed_machine_.set_delegate(this);
 }
 

Analyser/Dynamic/MultiMachine/MultiMachine.hpp

@@ -38,7 +38,7 @@ namespace Analyser::Dynamic {
 	the others in the set, that machine stops running.
 */
 class MultiMachine: public ::Machine::DynamicMachine, public MultiTimedMachine::Delegate {
-	public:
+public:
 	/*!
 		Allows a potential MultiMachine creator to enquire as to whether there's any benefit in
 		requesting this class as a proxy.
@@ -46,8 +46,8 @@ class MultiMachine: public ::Machine::DynamicMachine, public MultiTimedMachine::
 		@returns @c true if the multimachine would discard all but the first machine in this list;
 			@c false otherwise.
 	*/
-		static bool would_collapse(const std::vector<std::unique_ptr<DynamicMachine>> &machines);
-		MultiMachine(std::vector<std::unique_ptr<DynamicMachine>> &&machines);
+	static bool would_collapse(const std::vector<std::unique_ptr<DynamicMachine>> &);
+	MultiMachine(std::vector<std::unique_ptr<DynamicMachine>> &&);
 
 	Activity::Source *activity_source() final;
 	Configurable::Device *configurable_device() final;
@@ -60,7 +60,7 @@ class MultiMachine: public ::Machine::DynamicMachine, public MultiTimedMachine::
 	MachineTypes::MediaTarget *media_target() final;
 	void *raw_pointer() final;
 
-	private:
+private:
 	void did_run_machines(MultiTimedMachine *) final;
 
 	std::vector<std::unique_ptr<DynamicMachine>> machines_;