✨Better Code Organization

include/pros/distance.hpp

@@ -24,6 +24,8 @@
 #include "pros/distance.h"
 
 namespace pros {
+inline namespace v5 {
+
 class Distance {
 	public:
 	/**
@@ -109,6 +111,8 @@ class Distance {
 	private:
 	const std::uint8_t _port;
 };
+
+}
 }  // namespace pros
 
 #endif

include/pros/gps.hpp

@@ -26,6 +26,7 @@
 #include "pros/gps.h"
 
 namespace pros {
+inline namespace v5 {
 class Gps {
 	const std::uint8_t _port;
 
@@ -277,6 +278,7 @@ class Gps {
 	virtual pros::c::gps_accel_s_t get_accel() const;
 
 };  // Gps Class
+}
 
 using GPS = Gps;
 

include/pros/imu.hpp

@@ -22,6 +22,7 @@
 #include "pros/imu.h"
 
 namespace pros {
+inline namespace v5 {
 class Imu {
 	const std::uint8_t _port;
 
@@ -446,9 +447,10 @@ class Imu {
 	 */
 	virtual bool is_calibrating() const;
 };
-
+  
 using IMU = Imu;
-
+
+}  //namespace v5
 }  // namespace pros
 
 #endif

include/pros/misc.h

@@ -457,7 +457,7 @@ int32_t usd_is_installed(void);
 
 #ifdef __cplusplus
 }
-}
+} // namespace pros
 }
 #endif
 

include/pros/misc.hpp

@@ -27,6 +27,7 @@
 #include <string>
 
 namespace pros {
+inline namespace v5 {
 class Controller {
 	public:
 	/**
@@ -258,6 +259,7 @@ class Controller {
 	private:
 	controller_id_e_t _id;
 };
+} //  namespace v5
 
 namespace battery {
 /**

include/pros/motors.hpp

@@ -24,6 +24,7 @@
 #include "pros/motors.h"
 
 namespace pros {
+inline namespace v5 {
 class Motor {
 	public:
 	/**
@@ -838,5 +839,6 @@ namespace literals {
 const pros::Motor operator"" _mtr(const unsigned long long int m);
 const pros::Motor operator"" _rmtr(const unsigned long long int m);
 }  // namespace literals
+}  // namespace v5
 }  // namespace pros
 #endif  // _PROS_MOTORS_HPP_

include/pros/optical.hpp

@@ -26,6 +26,7 @@
 #include "pros/optical.h"
 
 namespace pros {
+inline namespace v5 {
 class Optical {
 	public:
 	/**
@@ -229,6 +230,7 @@ class Optical {
 	private:
 	const std::uint8_t _port;
 };
+}
 }  // namespace pros
 
 #endif

include/pros/rotation.hpp

@@ -23,6 +23,7 @@
 #include "pros/rotation.h"
 
 namespace pros {
+inline namespace v5 {
 class Rotation {
 	const std::uint8_t _port;
 
@@ -185,6 +186,7 @@ class Rotation {
 	 */
 	virtual std::int32_t get_reversed();
 };
+}
 }  // namespace pros
 
 #endif

include/pros/rtos.hpp

@@ -31,6 +31,7 @@
 #include <type_traits>
 
 namespace pros {
+inline namespace rtos {
 class Task {
 	public:
 	/**
@@ -522,7 +523,7 @@ class Mutex {
 		return take(std::max(static_cast<uint32_t>(0), (abs_time - Clock::now()).count()));
 	}
 };
-
+}
 /**
  * Gets the number of milliseconds since PROS initialized.
  *

include/pros/vision.hpp

@@ -25,6 +25,7 @@
 #include <cstdint>
 
 namespace pros {
+inline namespace v5 {
 class Vision {
 	public:
 	/**
@@ -441,5 +442,6 @@ class Vision {
 	private:
 	std::uint8_t _port;
 };
+}  // namespace v5
 }  // namespace pros
 #endif  // _PROS_VISION_HPP_

src/devices/controller.c

@@ -18,7 +18,7 @@
 #include "v5_api.h"
 #include "vdml/vdml.h"
 
-#define CONTROLLER_MAX_COLS 19
+#define CONTROLLER_MAX_COLS 15
 
 // From enum in misc.h
 #define NUM_BUTTONS 12

src/devices/controller.cpp

@@ -15,6 +15,7 @@
 #include "kapi.h"
 
 namespace pros {
+inline namespace v5 {
 using namespace pros::c;
 
 Controller::Controller(pros::controller_id_e_t id) : _id(id) {}
@@ -80,4 +81,5 @@ std::uint8_t is_disabled(void) {
 	return competition_is_disabled();
 }
 }  // namespace competition
+}  // namespace v5
 }  // namespace pros

src/devices/vdml_adi.cpp

@@ -15,148 +15,148 @@
 #include "vdml/port.h"
 
 namespace pros {
+namespace adi{
 using namespace pros::c;
 
-ADIPort::ADIPort(std::uint8_t adi_port, adi_port_config_e_t type)
+Port::Port(std::uint8_t adi_port, adi_port_config_e_t type)
     : _smart_port(INTERNAL_ADI_PORT), _adi_port(adi_port) {
 	ext_adi_port_set_config(_smart_port, _adi_port, type);
 }
 
-ADIPort::ADIPort(ext_adi_port_pair_t port_pair, adi_port_config_e_t type)
+Port::Port(ext_adi_port_pair_t port_pair, adi_port_config_e_t type)
     : _smart_port(port_pair.first), _adi_port(port_pair.second) {
 	ext_adi_port_set_config(_smart_port, _adi_port, type);
 }
 
-std::int32_t ADIPort::set_config(adi_port_config_e_t type) const {
+std::int32_t Port::set_config(adi_port_config_e_t type) const {
 	return ext_adi_port_set_config(_smart_port, _adi_port, type);
 }
 
-std::int32_t ADIPort::get_config() const {
+std::int32_t Port::get_config() const {
 	return ext_adi_port_get_config(_smart_port, _adi_port);
 }
 
-std::int32_t ADIPort::set_value(std::int32_t value) const {
+std::int32_t Port::set_value(std::int32_t value) const {
 	return ext_adi_port_set_value(_smart_port, _adi_port, value);
 }
 
-std::int32_t ADIPort::get_value() const {
+std::int32_t Port::get_value() const {
 	return ext_adi_port_get_value(_smart_port, _adi_port);
 }
 
+AnalogIn::AnalogIn(std::uint8_t adi_port) : Port(adi_port, E_ADI_ANALOG_IN) {}
+AnalogIn::AnalogIn(ext_adi_port_pair_t port_pair) : Port(port_pair, E_ADI_ANALOG_IN) {}
 
-ADIAnalogIn::ADIAnalogIn(std::uint8_t adi_port) : ADIPort(adi_port, E_ADI_ANALOG_IN) {}
-ADIAnalogIn::ADIAnalogIn(ext_adi_port_pair_t port_pair) : ADIPort(port_pair, E_ADI_ANALOG_IN) {}
-
-std::int32_t ADIAnalogIn::calibrate() const {
+std::int32_t AnalogIn::calibrate() const {
 	return ext_adi_analog_calibrate(_smart_port, _adi_port);
 }
 
-std::int32_t ADIAnalogIn::get_value_calibrated() const {
+std::int32_t AnalogIn::get_value_calibrated() const {
 	return ext_adi_analog_read_calibrated(_smart_port, _adi_port);
 }
 
-std::int32_t ADIAnalogIn::get_value_calibrated_HR() const {
+std::int32_t AnalogIn::get_value_calibrated_HR() const {
 	return ext_adi_analog_read_calibrated_HR(_smart_port, _adi_port);
 }
 
-ADIAnalogOut::ADIAnalogOut(std::uint8_t adi_port) : ADIPort(adi_port, E_ADI_ANALOG_OUT) {}
-ADIAnalogOut::ADIAnalogOut(ext_adi_port_pair_t port_pair) : ADIPort(port_pair, E_ADI_ANALOG_OUT) {}
+AnalogOut::AnalogOut(std::uint8_t adi_port) : Port(adi_port, E_ADI_ANALOG_OUT) {}
+AnalogOut::AnalogOut(ext_adi_port_pair_t port_pair) : Port(port_pair, E_ADI_ANALOG_OUT) {}
 
-ADIDigitalIn::ADIDigitalIn(std::uint8_t adi_port) : ADIPort(adi_port, E_ADI_DIGITAL_IN) {}
-ADIDigitalIn::ADIDigitalIn(ext_adi_port_pair_t port_pair) : ADIPort(port_pair, E_ADI_DIGITAL_IN) {}
+DigitalIn::DigitalIn(std::uint8_t adi_port) : Port(adi_port, E_ADI_DIGITAL_IN) {}
+DigitalIn::DigitalIn(ext_adi_port_pair_t port_pair) : Port(port_pair, E_ADI_DIGITAL_IN) {}
 
-std::int32_t ADIDigitalIn::get_new_press() const {
+std::int32_t DigitalIn::get_new_press() const {
 	return ext_adi_digital_get_new_press(_smart_port, _adi_port);
 }
 
-ADIDigitalOut::ADIDigitalOut(std::uint8_t adi_port, bool init_state) : ADIPort(adi_port, E_ADI_DIGITAL_OUT) {
+DigitalOut::DigitalOut(std::uint8_t adi_port, bool init_state) : Port(adi_port, E_ADI_DIGITAL_OUT) {
 	set_value(init_state);
 }
 
-ADIDigitalOut::ADIDigitalOut(ext_adi_port_pair_t port_pair, bool init_state) : ADIPort(port_pair, E_ADI_DIGITAL_OUT) {
+DigitalOut::DigitalOut(ext_adi_port_pair_t port_pair, bool init_state) : ADIPort(port_pair, E_ADI_DIGITAL_IN) {
 	set_value(init_state);
 }
 
-ADIMotor::ADIMotor(std::uint8_t adi_port) : ADIPort(adi_port, E_ADI_LEGACY_PWM) {
+Motor::Motor(std::uint8_t adi_port) : Port(adi_port, E_ADI_LEGACY_PWM) {
 	stop();
 }
 
-ADIMotor::ADIMotor(ext_adi_port_pair_t port_pair) : ADIPort(port_pair, E_ADI_LEGACY_PWM) {
+Motor::Motor(ext_adi_port_pair_t port_pair) : Port(port_pair, E_ADI_LEGACY_PWM) {
 	stop();
 }
 
-std::int32_t ADIMotor::stop() const {
+std::int32_t Motor::stop() const {
 	return ext_adi_motor_stop(_smart_port, _adi_port);
 }
 
-ADIEncoder::ADIEncoder(std::uint8_t adi_port_top, std::uint8_t adi_port_bottom, bool reversed) : ADIPort(adi_port_top) {
+Encoder::Encoder(std::uint8_t adi_port_top, std::uint8_t adi_port_bottom, bool reversed) : Port(adi_port_top) {
 	std::int32_t _port = ext_adi_encoder_init(INTERNAL_ADI_PORT, adi_port_top, adi_port_bottom, reversed);
 	get_ports(_port, _smart_port, _adi_port);
 }
 
-ADIEncoder::ADIEncoder(ext_adi_port_tuple_t port_tuple, bool reversed) : ADIPort(std::get<1>(port_tuple)) {
+Encoder::Encoder(ext_adi_port_tuple_t port_tuple, bool reversed) : Port(std::get<1>(port_tuple)) {
 	std::int32_t _port =
 	    ext_adi_encoder_init(std::get<0>(port_tuple), std::get<1>(port_tuple), std::get<2>(port_tuple), reversed);
 	get_ports(_port, _smart_port, _adi_port);
 
 }
 
-std::int32_t ADIEncoder::reset() const {
+std::int32_t Encoder::reset() const {
 	return adi_encoder_reset(merge_adi_ports(_smart_port, _adi_port));
 }
 
-std::int32_t ADIEncoder::get_value() const {
+std::int32_t Encoder::get_value() const {
 	return adi_encoder_get(merge_adi_ports(_smart_port, _adi_port));
 }
 
-ADIUltrasonic::ADIUltrasonic(std::uint8_t adi_port_ping, std::uint8_t adi_port_echo) : ADIPort(adi_port_ping) {
+Ultrasonic::Ultrasonic(std::uint8_t adi_port_ping, std::uint8_t adi_port_echo) : Port(adi_port_ping) {
 	std::int32_t _port = ext_adi_ultrasonic_init(INTERNAL_ADI_PORT, adi_port_ping, adi_port_echo);
 	get_ports(_port, _smart_port, _adi_port);
 }
 
-ADIUltrasonic::ADIUltrasonic(ext_adi_port_tuple_t port_tuple) : ADIPort(std::get<1>(port_tuple)) {
+Ultrasonic::Ultrasonic(ext_adi_port_tuple_t port_tuple) : Port(std::get<1>(port_tuple)) {
 	std::int32_t _port =
 	    ext_adi_ultrasonic_init(std::get<0>(port_tuple), std::get<1>(port_tuple), std::get<2>(port_tuple));
 	get_ports(_port, _smart_port, _adi_port);
 }
 
-std::int32_t ADIUltrasonic::get_value() const {
+std::int32_t Ultrasonic::get_value() const {
 	return adi_ultrasonic_get(merge_adi_ports(_smart_port, _adi_port));
 }
 
-ADIGyro::ADIGyro(std::uint8_t adi_port, double multiplier) : ADIPort(adi_port) {
+Gyro::Gyro(std::uint8_t adi_port, double multiplier) : Port(adi_port) {
 	std::int32_t _port = ext_adi_gyro_init(INTERNAL_ADI_PORT, adi_port, multiplier);
 	get_ports(_port, _smart_port, _adi_port);
 }
 
-ADIGyro::ADIGyro(ext_adi_port_pair_t port_pair, double multiplier) : ADIPort(std::get<1>(port_pair)) {
+Gyro::Gyro(ext_adi_port_pair_t port_pair, double multiplier) : ADIPort(std::get<1>(port_pair)) {
 	std::int32_t _port = ext_adi_gyro_init(port_pair.first, port_pair.second, multiplier);
 	get_ports(_port, _smart_port, _adi_port);
 }
 
-double ADIGyro::get_value() const {
+double Gyro::get_value() const {
 	return adi_gyro_get(merge_adi_ports(_smart_port, _adi_port));
 }
 
-std::int32_t ADIGyro::reset() const {
+std::int32_t Gyro::reset() const {
 	return adi_gyro_reset(merge_adi_ports(_smart_port, _adi_port));
 }
 
-ADIPotentiometer::ADIPotentiometer(std::uint8_t adi_port, adi_potentiometer_type_e_t potentiometer_type) : ADIAnalogIn(adi_port) { 
+Potentiometer::Potentiometer(std::uint8_t adi_port, adi_potentiometer_type_e_t potentiometer_type) : AnalogIn(adi_port) { 
 	std::int32_t _port = ext_adi_potentiometer_init(INTERNAL_ADI_PORT, adi_port, potentiometer_type);
 	get_ports(_port, _smart_port, _adi_port);
 	_smart_port++; // for inherited functions this is necessary
 }
 
-ADIPotentiometer::ADIPotentiometer(ext_adi_port_pair_t port_pair, adi_potentiometer_type_e_t potentiometer_type) : ADIAnalogIn(std::get<1>(port_pair)) { 
+Potentiometer::Potentiometer(ext_adi_port_pair_t port_pair, adi_potentiometer_type_e_t potentiometer_type) : AnalogIn(std::get<1>(port_pair)) { 
  	std::int32_t _port = ext_adi_potentiometer_init(port_pair.first, port_pair.second, potentiometer_type);
 	get_ports(_port, _smart_port, _adi_port);
 	_smart_port++; // for inherited functions this is necessary
 }
 
-double ADIPotentiometer::get_angle() const {
+double Potentiometer::get_angle() const {
 	uint8_t temp_smart = _smart_port - 1;
 	return ext_adi_potentiometer_get_angle(merge_adi_ports(temp_smart, _adi_port));
 }
-
+}  // namespace adi
 }  // namespace pros

src/devices/vdml_distance.cpp

@@ -13,7 +13,8 @@
 #include "pros/distance.hpp"
 
 namespace pros {
-
+inline namespace v5{ 
+
 Distance::Distance(const std::uint8_t port) : _port(port) {}
 
 std::int32_t Distance::get() {
@@ -35,4 +36,6 @@ double Distance::get_object_velocity() {
 std::uint8_t Distance::get_port() {
 	return _port;
 }
+
+}
 }  // namespace pros

src/devices/vdml_gps.cpp

@@ -13,6 +13,7 @@
 #include "pros/gps.hpp"
 
 namespace pros {
+inline namespace v5 {
 
 std::int32_t Gps::initialize_full(double xInitial, double yInitial, double headingInitial, double xOffset,
                                   double yOffset) const {
@@ -71,4 +72,5 @@ pros::c::gps_accel_s_t Gps::get_accel() const {
 	return pros::c::gps_get_accel(_port);
 }
 
+}
 }  // namespace pros