@startuml





/' Objects '/

namespace flippR_driver::output {
	class Display <template <int DigitCount>> {
		+Display(int address, int id)
		+~Display()
		-address : int
		+getID() : int
		-id : int
		+content : std::array<char, DigitCount>
		-fit_string(std::string& score_string) : std::string
		+write_content(std::array<char, DigitCount> content) : void
		+write_score(int score) : void
	}
}


namespace flippR_driver::output {
	class DisplayController {
		+DisplayController(std::vector<std::shared_ptr<IDisplay> > displays, std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface)
		+~DisplayController()
		-is_running : bool
		-output_gpio_interface : std::shared_ptr<utility::IOutputGPIOInterface>
		-display_cycle_thread : std::thread
		-displays : std::vector<std::shared_ptr<IDisplay> >
		-cycle_displays() : void
	}
}


class DisplayGPIOInterface {
	+DisplayGPIOInterface()
	+~DisplayGPIOInterface()
}


namespace flippR_driver::input {
	class Event {
		+Event(char address, int priority, std::string name)
		+operator<(const Event& left, const Event& right) : bool
		+operator==(const Event& left, const Event& right) : bool
		+address : char
		+priority : int
		+name : std::string
	}
}


namespace flippR_driver::input {
	class EventHandler {
		+EventHandler(std::shared_ptr<IInputDriver> input_driver)
		+~EventHandler()
		-input_driver : std::shared_ptr<IInputDriver>
		+handle(Event& event) : void
	}
}


namespace flippR_driver::utility {
	class GPIOInterface {
		+GPIOInterface()
		+~GPIOInterface()
		+{static} read_pin(char address) : bool
		+{static} GPIO_LIB_INITIALIZED : static std::once_flag
		+{static} initialize_input_pin(char address) : void
		+{static} initialize_output_pin(char address) : void
		+{static} write_pin(char address, char data) : void
	}
}


namespace flippR_driver::utility {
	abstract class IBlockingQueue <template<typename T>> {
		+~IBlockingQueue()
		+{abstract} pop() : T
		+{abstract} push(T const& value) : void
	}
}


namespace flippR_driver::output {
	abstract class IDisplay {
		+IDisplay()
		+~IDisplay()
		+{abstract} getID() : int
		-fit_string(std::string& score_string) : std::string
		+{abstract} write_content(std::array<char, DigitCount> content) : void
		+{abstract} write_score(int score) : void
	}
}


namespace flippR_driver::output {
	class IDisplayController {
		+IDisplayController()
		+~IDisplayController()
	}
}


abstract class IEventHandler {
	+~IEventHandler()
	+{abstract} handle(flippR_driver::input::Event& event) : void
}


namespace flippR_driver::input {
	abstract class IInputDriver {
		+~IInputDriver()
		+{abstract} get_event(std::string name) : std::shared_ptr<Event>
		+{abstract} register_event_handler(IEventHandler* handler) : void
		+{abstract} unregister_event_handler(IEventHandler* handler) : void
	}
}


namespace flippR_driver::utility {
	abstract class IInputGPIOInterface {
		+~IInputGPIOInterface()
		+{abstract} read_data(char pin) : bool
	}
}


namespace flippR_driver::output {
	class ILamp {
	}
}


namespace flippR_driver::output {
	class IOutputDriver {
		+IOutputDriver()
		+~IOutputDriver()
	}
}


namespace flippR_driver::utility {
	class IOutputGPIOInterface {
		+activate_pin(int i2c_address, int pin) : void
		+deactivate_pin(int i2c_address, int pin) : void
		+set_address(int i2c_address, int address) : void
	}
}


namespace flippR_driver::output {
	abstract class IOutputItem {
		-~IOutputItem()
		-{abstract} activate() : bool
		-{abstract} deactivate() : bool
		-{abstract} isActivated() : bool
	}
}


namespace flippR_driver::output {
	class ISolenoid {
	}
}


namespace flippR_driver::output {
	abstract class ISound {
		+ISound()
		+~ISound()
		+{abstract} play() : void
	}
}


namespace flippR_driver::utility {
	class InputGPIOInterface {
		+InputGPIOInterface(std::istream& input_config_stream)
		+read_data(char pin) : bool
		-col_address_A : char
		-col_address_B : char
		-col_address_C : char
		-data_address : char
		-row_address_A : char
		-row_address_B : char
		-row_address_C : char
		-init_members(std::istream& input_config_stream) : void
		-init_pins() : void
		-write_col(char data) : void
		-write_row(char data) : void
	}
}


namespace flippR_driver::output {
	class Lamp {
		+Lamp(std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface, int address, std::string name, bool activated)
		+~Lamp()
		-activated : bool
		+is_activated() : bool
		+activate() : void
		+deactivate() : void
	}
}


namespace flippR_driver::output {
	class OutputDriver {
		+OutputDriver(std::map<std::string, std::shared_ptr<IOutputtItem> > cabinet_items, std::map<char, std::shared_ptr<IDisplay> > displays, std::map<std::string, std::shared_ptr<ISound> > sounds)
		+~OutputDriver()
		-displays : std::map<char, std::shared_ptr<IDisplay> >
		-cabinet_items : std::map<std::string, std::shared_ptr<IOutputtItem> >
		-sounds : std::map<std::string, std::shared_ptr<ISound> >
		+get_display(char number) : std::shared_ptr<IDisplay>
		+get_cabinet_item(std::string name) : std::shared_ptr<IOutputtItem>
		+get_sound(std::string name) : std::shared_ptr<ISound>
		+get_displays() : std::vector<std::shared_ptr<IDisplay> >
		+get_cabinet_items() : std::vector<std::shared_ptr<IOutputtItem> >
		+get_sounds() : std::vector<std::shared_ptr<ISound> >
	}
}


namespace flippR_driver::output {
	class OutputDriverFactory {
		+{static} getOutputDriver(std::ifstream& output_gpio_config, std::ifstream& output_config) : std::shared_ptr<OutputDriver>
	}
}


namespace flippR_driver::utility {
	class OutputGPIOInterface {
		+activate_cabinet_item(CabinetItem& item) : void
		+write_display(Display& display) : void
		-event_queue : void:IBlockingQueue<CabinetItem>
	}
}


namespace flippR_driver::output {
	class OutputItem {
		+OutputItem(std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface, int address, std::string name)
		+~OutputItem()
		#address : int
		#data_pin_address : int
		#i2c_address : int
		#output_gpio_interface : std::shared_ptr<utility::IOutputGPIOInterface>
		#name : std::string
	}
}


namespace flippR_driver::output {
	class Solenoid {
		+Solenoid(std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface, int address, std::string name, std::chrono::milliseconds deactivation_time)
		+~Solenoid()
		-deactivation_time : std::chrono::milliseconds
		-wait_thread : std::future<void>
		-activate() : void
		-deactivate() : void
		+trigger() : void
	}
}


namespace flippR_driver::output {
	class Sound {
		+Sound(std::shared_ptr<utility::IOutputGPIOInterface> output_gpio_interface, int address, std::string name)
		+~Sound()
		-address : int
		-output_gpio_interface : std::shared_ptr<utility::IOutputGPIOInterface>
		-name : std::string
		+play() : void
	}
}





/' Inheritance relationships '/

namespace flippR_driver::utility {
	GPIOInterface <|-- InputGPIOInterface
}


namespace flippR_driver::utility {
	GPIOInterface <|-- OutputGPIOInterface
}


namespace flippR_driver::output {
	IDisplay <|-- Display
}


namespace flippR_driver::output {
	IDisplayController <|-- DisplayController
}


.IEventHandler <|-- flippR_driver::input.EventHandler


namespace flippR_driver::utility {
	IInputGPIOInterface <|-- InputGPIOInterface
}


namespace flippR_driver::output {
	IOutputDriver <|-- OutputDriver
}


namespace flippR_driver::output {
	IOutputItem <|-- OutputItem
}


namespace flippR_driver::output {
	ISound <|-- Sound
}


namespace flippR_driver::output {
	OutputItem <|-- Lamp
}


namespace flippR_driver::output {
	OutputItem <|-- Solenoid
}





/' Aggregation relationships '/

namespace flippR_driver::output {
	DisplayController o-- IDisplay
}


flippR_driver::output.DisplayController o-- flippR_driver::utility.IOutputGPIOInterface


namespace flippR_driver::input {
	EventHandler o-- IInputDriver
}


namespace flippR_driver::output {
	OutputDriver o-- IDisplay
}


namespace flippR_driver::output {
	OutputDriver o-- ISound
}


namespace flippR_driver::utility {
	OutputGPIOInterface o-- IBlockingQueue
}


flippR_driver::output.OutputItem o-- flippR_driver::utility.IOutputGPIOInterface


flippR_driver::output.Sound o-- flippR_driver::utility.IOutputGPIOInterface




@enduml