From a119e6ca70ffab14f0a70908fa3eeb83b41bb5ab Mon Sep 17 00:00:00 2001 From: HampusM Date: Mon, 14 Mar 2022 10:24:36 +0100 Subject: refactor: rename std to common --- src/common/conversion.cpp | 39 ++++++++++++++++++++++++ src/common/conversion.hpp | 36 ++++++++++++++++++++++ src/common/memory.hpp | 44 +++++++++++++++++++++++++++ src/common/memory.tpp | 76 ++++++++++++++++++++++++++++++++++++++++++++++ src/common/string.cpp | 70 ++++++++++++++++++++++++++++++++++++++++++ src/common/string.hpp | 25 +++++++++++++++ src/common/time.cpp | 42 +++++++++++++++++++++++++ src/common/time.hpp | 60 ++++++++++++++++++++++++++++++++++++ src/gyronardo.cpp | 2 +- src/sensor/calibration.cpp | 6 ++-- src/sensor/sensor.cpp | 2 +- src/sensor/sensor.hpp | 4 +-- src/serial.cpp | 12 ++++---- src/serial.hpp | 4 +-- src/std/conversion.cpp | 33 -------------------- src/std/conversion.hpp | 31 ------------------- src/std/memory.hpp | 39 ------------------------ src/std/memory.tpp | 71 ------------------------------------------- src/std/smart_string.cpp | 65 --------------------------------------- src/std/smart_string.hpp | 20 ------------ src/std/time.cpp | 37 ---------------------- src/std/time.hpp | 55 --------------------------------- 22 files changed, 407 insertions(+), 366 deletions(-) create mode 100644 src/common/conversion.cpp create mode 100644 src/common/conversion.hpp create mode 100644 src/common/memory.hpp create mode 100644 src/common/memory.tpp create mode 100644 src/common/string.cpp create mode 100644 src/common/string.hpp create mode 100644 src/common/time.cpp create mode 100644 src/common/time.hpp delete mode 100644 src/std/conversion.cpp delete mode 100644 src/std/conversion.hpp delete mode 100644 src/std/memory.hpp delete mode 100644 src/std/memory.tpp delete mode 100644 src/std/smart_string.cpp delete mode 100644 src/std/smart_string.hpp delete mode 100644 src/std/time.cpp delete mode 100644 src/std/time.hpp (limited to 'src') diff --git a/src/common/conversion.cpp b/src/common/conversion.cpp new file mode 100644 index 0000000..0bdc81a --- /dev/null +++ b/src/common/conversion.cpp @@ -0,0 +1,39 @@ +#include "conversion.hpp" + +namespace common +{ + +common::UniquePtr doubleToStr(double num, unsigned int width, + unsigned int precision) +{ + auto str = common::make_unique(width + precision); + + dtostrf(num, static_cast(width), static_cast(precision), + str->c_str); + + return str; +} + +common::UniquePtr intToStr(int num) +{ + auto width = static_cast(log10(num)); + + auto str = common::make_unique(width + 1U); + + dtostrf(num, static_cast(width + 1U), 0U, str->c_str); + + return str; +} + +common::UniquePtr uintToStr(unsigned int num) +{ + auto width = static_cast(log10(num)); + + auto str = common::make_unique(width + 1U); + + dtostrf(num, static_cast(width + 1U), 0U, str->c_str); + + return str; +} + +} // namespace common diff --git a/src/common/conversion.hpp b/src/common/conversion.hpp new file mode 100644 index 0000000..81a4a52 --- /dev/null +++ b/src/common/conversion.hpp @@ -0,0 +1,36 @@ +#pragma once + +#include "common/memory.hpp" +#include "common/string.hpp" + +namespace common +{ + +/** + * Converts a double number to a string. + * + * @param num A double number + * @param width The desired double width + * @param precision The desired double precision + * @returns The double as a string. + */ +common::UniquePtr doubleToStr(double num, unsigned int width = 3, + unsigned int precision = 2); + +/** + * Converts a integer to a string. + * + * @param num A number + * @returns The number as a string. + */ +common::UniquePtr intToStr(int num); + +/** + * Converts a unsigned integer to a string. + * + * @param num A number + * @returns The number as a string. + */ +common::UniquePtr uintToStr(unsigned int num); + +} // namespace common diff --git a/src/common/memory.hpp b/src/common/memory.hpp new file mode 100644 index 0000000..de72d80 --- /dev/null +++ b/src/common/memory.hpp @@ -0,0 +1,44 @@ +#pragma once + +#include + +namespace common +{ + +template +memType *malloc_s(unsigned int size); + +template +class UniquePtr +{ +public: + explicit UniquePtr() = default; + explicit UniquePtr(Target *target); + + // Move constructor + UniquePtr(UniquePtr &&unique_ptr) noexcept; + + // Move assignment operator + UniquePtr &operator=(UniquePtr &&unique_ptr) noexcept; + + // Disable the copy constructor + UniquePtr(const UniquePtr &unique_ptr) = delete; + + // Disable the copy assignment operator + UniquePtr &operator=(const UniquePtr &unique_ptr) = delete; + + ~UniquePtr(); + + Target operator*() const; + Target *operator->() const; + +private: + Target *_target = nullptr; +}; + +template +UniquePtr make_unique(Args... args); + +} // namespace common + +#include "memory.tpp" diff --git a/src/common/memory.tpp b/src/common/memory.tpp new file mode 100644 index 0000000..ace2432 --- /dev/null +++ b/src/common/memory.tpp @@ -0,0 +1,76 @@ +#pragma once + +#include "memory.hpp" + +#include "utils.hpp" + +#include +#include + +namespace common +{ + +template +memType *malloc_s(unsigned int size) +{ + auto *mem = malloc(size); + + if (mem == nullptr) + { + Serial.println("Error: Memory allocation failed"); + while (true) {} + } + + return static_cast(mem); +} + +template +UniquePtr::UniquePtr(Target *target) : _target(target) +{ +} + +template +UniquePtr::UniquePtr(UniquePtr &&unique_ptr) noexcept + : _target(unique_ptr._target) +{ + unique_ptr._target = nullptr; +} + +template +UniquePtr &UniquePtr::operator=(UniquePtr &&unique_ptr) noexcept +{ + if (&unique_ptr != this) + { + delete _target; + _target = unique_ptr._target; + unique_ptr._target = nullptr; + } + + return *this; +} + +template +UniquePtr::~UniquePtr() +{ + delete _target; +} + +template +Target UniquePtr::operator*() const +{ + return *(_target); +} + +template +Target *UniquePtr::operator->() const +{ + return _target; +} + +template +UniquePtr make_unique(Args... args) +{ + return UniquePtr(new Target(args...)); +} + +} // namespace common diff --git a/src/common/string.cpp b/src/common/string.cpp new file mode 100644 index 0000000..27b65d4 --- /dev/null +++ b/src/common/string.cpp @@ -0,0 +1,70 @@ +#include "string.hpp" + +#include "common/memory.hpp" + +#include + +namespace common +{ + +String::String(char *c_string) : c_str(c_string) +{ +} + +String::String(unsigned int size) : c_str(malloc_s(size + 1)) +{ +} + +String::String(const String &smart_str) + : c_str(malloc_s(strlen(smart_str.c_str) + 1)) +{ + memcpy(c_str, smart_str.c_str, strlen(smart_str.c_str) + 1); +} + +String::String(String &&smart_str) noexcept : c_str(smart_str.c_str) +{ + smart_str.c_str = nullptr; +} + +String &String::operator=(const String &smart_str) +{ + if (&smart_str != this) + { + free(c_str); + c_str = nullptr; + + auto str_size = strlen(smart_str.c_str) + 1; + + c_str = malloc_s(str_size); + memcpy(c_str, smart_str.c_str, str_size); + } + + return *this; +} + +String &String::operator=(String &&smart_str) noexcept +{ + if (&smart_str != this) + { + free(c_str); + c_str = smart_str.c_str; + smart_str.c_str = nullptr; + } + + return *this; +} + +String::~String() +{ + if (c_str != nullptr) + { + free(c_str); + } +} + +String::operator char *() const +{ + return c_str; +} + +} // namespace common diff --git a/src/common/string.hpp b/src/common/string.hpp new file mode 100644 index 0000000..2641457 --- /dev/null +++ b/src/common/string.hpp @@ -0,0 +1,25 @@ +#pragma once + +namespace common +{ + +class String +{ +public: + explicit String(char *c_str); + explicit String(unsigned int size); + String(const String &smart_str); + String(String &&smart_str) noexcept; + + String &operator=(const String &smart_str); + + String &operator=(String &&smart_str) noexcept; + + ~String(); + + explicit operator char *() const; + + char *c_str = nullptr; +}; + +} // namespace common diff --git a/src/common/time.cpp b/src/common/time.cpp new file mode 100644 index 0000000..ee297d7 --- /dev/null +++ b/src/common/time.cpp @@ -0,0 +1,42 @@ +#include "time.hpp" + +#include + +namespace common +{ + + Time::Time(uint64_t time_micros) : _time_micros(time_micros) + { + } + + void Time::update() + { + _time_micros = micros(); + } + + Time Time::diff(Time prev_time) const + { + return Time(_time_micros - prev_time.microsecs()); + } + + double Time::secs() const + { + return static_cast(_time_micros) * MICROS_TO_SECS; + } + + double Time::millisecs() const + { + return static_cast(_time_micros) * MICROS_TO_MILLIS; + } + + uint64_t Time::microsecs() const + { + return _time_micros; + } + + Time time_now() + { + return Time(micros()); + } + +} // namespace common diff --git a/src/common/time.hpp b/src/common/time.hpp new file mode 100644 index 0000000..8efbd28 --- /dev/null +++ b/src/common/time.hpp @@ -0,0 +1,60 @@ +#pragma once + +#include + +constexpr double MICROS_TO_SECS = 0.000001; +constexpr double MICROS_TO_MILLIS = 0.001; + +namespace common +{ + + /** + * A representation of time. + */ + class Time + { + public: + /** + * A representation of time. + * + * @param time_micros Time in microseconds + */ + explicit Time(uint64_t time_micros); + + /** + * Updates the time to the current time. + */ + void update(); + + /** + * Returns the difference between two points in time. + * + * @param prev_time A previous point in time + */ + Time diff(Time prev_time) const; + + /** + * Returns the time in seconds. + */ + double secs() const; + + /** + * Returns the time in milliseconds. + */ + double millisecs() const; + + /** + * Returns the time in microseconds. + */ + uint64_t microsecs() const; + + private: + uint64_t _time_micros; + }; + + /** + * Returns a time object for the time since the program started. + */ + Time time_now(); + +} // namespace common diff --git a/src/gyronardo.cpp b/src/gyronardo.cpp index 7c01985..4b6b5fd 100644 --- a/src/gyronardo.cpp +++ b/src/gyronardo.cpp @@ -1,7 +1,7 @@ +#include "common/memory.hpp" #include "sensor/calibration.hpp" #include "sensor/sensor.hpp" #include "serial.hpp" -#include "std/memory.hpp" #include #include diff --git a/src/sensor/calibration.cpp b/src/sensor/calibration.cpp index e01bb34..1a2b91e 100644 --- a/src/sensor/calibration.cpp +++ b/src/sensor/calibration.cpp @@ -1,6 +1,6 @@ #include "calibration.hpp" -#include "std/time.hpp" +#include "common/time.hpp" #include "utils.hpp" SensorCalibrator::SensorCalibrator(Sensor &sensor, SerialStream sout) @@ -11,11 +11,11 @@ SensorCalibrator::SensorCalibrator(Sensor &sensor, SerialStream sout) bool SensorCalibrator::calibrate(unsigned int throttle_time) { bool done = false; - auto start_time = time_now(); + auto start_time = common::time_now(); while (!done) { - if (time_now().diff(start_time).millisecs() >= CALIBRATION_TIMEOUT) + if (common::time_now().diff(start_time).millisecs() >= CALIBRATION_TIMEOUT) { return false; } diff --git a/src/sensor/sensor.cpp b/src/sensor/sensor.cpp index 4d7f256..af25a96 100644 --- a/src/sensor/sensor.cpp +++ b/src/sensor/sensor.cpp @@ -40,7 +40,7 @@ bool Sensor::isConnected() noexcept bool Sensor::read() noexcept { - auto now = time_now(); + auto now = common::time_now(); if (_throttle_enabled && now.diff(_last_time).millisecs() < _throttle_time) { diff --git a/src/sensor/sensor.hpp b/src/sensor/sensor.hpp index b79b918..1e7e488 100644 --- a/src/sensor/sensor.hpp +++ b/src/sensor/sensor.hpp @@ -1,7 +1,7 @@ #pragma once +#include "common/time.hpp" #include "serial.hpp" -#include "std/time.hpp" #include #include @@ -164,7 +164,7 @@ private: bool _throttle_enabled; unsigned int _throttle_time; - Time _last_time; + common::Time _last_time; SensorStatus _status; diff --git a/src/serial.cpp b/src/serial.cpp index d3b3989..e60de6c 100644 --- a/src/serial.cpp +++ b/src/serial.cpp @@ -1,6 +1,6 @@ #include "serial.hpp" -#include "std/conversion.hpp" +#include "common/conversion.hpp" SerialStream::SerialStream(Serial_ serial, const unsigned long &baud_rate) : _serial(serial) @@ -14,7 +14,7 @@ SerialStream &SerialStream::operator<<(const char *str) return *this; } -SerialStream &SerialStream::operator<<(const SmartString &str) +SerialStream &SerialStream::operator<<(const common::String &str) { write(str.c_str); return *this; @@ -22,25 +22,25 @@ SerialStream &SerialStream::operator<<(const SmartString &str) SerialStream &SerialStream::operator<<(const double &num) { - write(doubleToStr(num, 3U, 4U)->c_str); + write(common::doubleToStr(num, 3U, 4U)->c_str); return *this; } SerialStream &SerialStream::operator<<(const int &num) { - write(intToStr(num)->c_str); + write(common::intToStr(num)->c_str); return *this; } SerialStream &SerialStream::operator<<(const unsigned int &num) { - write(uintToStr(num)->c_str); + write(common::uintToStr(num)->c_str); return *this; } SerialStream &SerialStream::operator<<(const unsigned long &num) { - write(uintToStr(num)->c_str); + write(common::uintToStr(num)->c_str); return *this; } diff --git a/src/serial.hpp b/src/serial.hpp index f32ca63..36aa6ed 100644 --- a/src/serial.hpp +++ b/src/serial.hpp @@ -1,6 +1,6 @@ #pragma once -#include "std/smart_string.hpp" +#include "common/string.hpp" #include @@ -10,7 +10,7 @@ public: SerialStream(Serial_ serial, const unsigned long &baud_rate); SerialStream &operator<<(const char *str); - SerialStream &operator<<(const SmartString &str); + SerialStream &operator<<(const common::String &str); SerialStream &operator<<(const double &num); SerialStream &operator<<(const int &num); SerialStream &operator<<(const unsigned int &num); diff --git a/src/std/conversion.cpp b/src/std/conversion.cpp deleted file mode 100644 index 3d75e8a..0000000 --- a/src/std/conversion.cpp +++ /dev/null @@ -1,33 +0,0 @@ -#include "conversion.hpp" - -UniquePtr doubleToStr(double num, unsigned int width, unsigned int precision) -{ - auto str = make_unique(width + precision); - - dtostrf(num, static_cast(width), static_cast(precision), - str->c_str); - - return str; -} - -UniquePtr intToStr(int num) -{ - auto width = static_cast(log10(num)); - - auto str = make_unique(width + 1U); - - dtostrf(num, static_cast(width + 1U), 0U, str->c_str); - - return str; -} - -UniquePtr uintToStr(unsigned int num) -{ - auto width = static_cast(log10(num)); - - auto str = make_unique(width + 1U); - - dtostrf(num, static_cast(width + 1U), 0U, str->c_str); - - return str; -} diff --git a/src/std/conversion.hpp b/src/std/conversion.hpp deleted file mode 100644 index 726ce88..0000000 --- a/src/std/conversion.hpp +++ /dev/null @@ -1,31 +0,0 @@ -#pragma once - -#include "std/memory.hpp" -#include "std/smart_string.hpp" - -/** - * Converts a double number to a string. - * - * @param num A double number - * @param width The desired double width - * @param precision The desired double precision - * @returns The double as a string. - */ -UniquePtr doubleToStr(double num, unsigned int width = 3, - unsigned int precision = 2); - -/** - * Converts a integer to a string. - * - * @param num A number - * @returns The number as a string. - */ -UniquePtr intToStr(int num); - -/** - * Converts a unsigned integer to a string. - * - * @param num A number - * @returns The number as a string. - */ -UniquePtr uintToStr(unsigned int num); diff --git a/src/std/memory.hpp b/src/std/memory.hpp deleted file mode 100644 index d1ca762..0000000 --- a/src/std/memory.hpp +++ /dev/null @@ -1,39 +0,0 @@ -#pragma once - -#include - -template -memType *malloc_s(unsigned int size); - -template -class UniquePtr -{ -public: - explicit UniquePtr() = default; - explicit UniquePtr(Target *target); - - // Move constructor - UniquePtr(UniquePtr &&unique_ptr) noexcept; - - // Move assignment operator - UniquePtr &operator=(UniquePtr &&unique_ptr) noexcept; - - // Disable the copy constructor - UniquePtr(const UniquePtr &unique_ptr) = delete; - - // Disable the copy assignment operator - UniquePtr &operator=(const UniquePtr &unique_ptr) = delete; - - ~UniquePtr(); - - Target operator*() const; - Target *operator->() const; - -private: - Target *_target = nullptr; -}; - -template -UniquePtr make_unique(Args... args); - -#include "memory.tpp" diff --git a/src/std/memory.tpp b/src/std/memory.tpp deleted file mode 100644 index b2f39bf..0000000 --- a/src/std/memory.tpp +++ /dev/null @@ -1,71 +0,0 @@ -#pragma once - -#include "memory.hpp" - -#include "utils.hpp" - -#include -#include - -template -memType *malloc_s(unsigned int size) -{ - auto *mem = malloc(size); - - if (mem == nullptr) - { - Serial.println("Error: Memory allocation failed"); - while (true) {} - } - - return static_cast(mem); -} - -template -UniquePtr::UniquePtr(Target *target) : _target(target) -{ -} - -template -UniquePtr::UniquePtr(UniquePtr &&unique_ptr) noexcept - : _target(unique_ptr._target) -{ - unique_ptr._target = nullptr; -} - -template -UniquePtr &UniquePtr::operator=(UniquePtr &&unique_ptr) noexcept -{ - if (&unique_ptr != this) - { - delete _target; - _target = unique_ptr._target; - unique_ptr._target = nullptr; - } - - return *this; -} - -template -UniquePtr::~UniquePtr() -{ - delete _target; -} - -template -Target UniquePtr::operator*() const -{ - return *(_target); -} - -template -Target *UniquePtr::operator->() const -{ - return _target; -} - -template -UniquePtr make_unique(Args... args) -{ - return UniquePtr(new Target(args...)); -} diff --git a/src/std/smart_string.cpp b/src/std/smart_string.cpp deleted file mode 100644 index b24a1a5..0000000 --- a/src/std/smart_string.cpp +++ /dev/null @@ -1,65 +0,0 @@ -#include "smart_string.hpp" - -#include "std/memory.hpp" - -#include - -SmartString::SmartString(char *c_string) : c_str(c_string) -{ -} - -SmartString::SmartString(unsigned int size) : c_str(malloc_s(size + 1)) -{ -} - -SmartString::SmartString(const SmartString &smart_str) - : c_str(malloc_s(strlen(smart_str.c_str) + 1)) -{ - memcpy(c_str, smart_str.c_str, strlen(smart_str.c_str) + 1); -} - -SmartString::SmartString(SmartString &&smart_str) noexcept : c_str(smart_str.c_str) -{ - smart_str.c_str = nullptr; -} - -SmartString &SmartString::operator=(const SmartString &smart_str) -{ - if (&smart_str != this) - { - free(c_str); - c_str = nullptr; - - auto str_size = strlen(smart_str.c_str) + 1; - - c_str = malloc_s(str_size); - memcpy(c_str, smart_str.c_str, str_size); - } - - return *this; -} - -SmartString &SmartString::operator=(SmartString &&smart_str) noexcept -{ - if (&smart_str != this) - { - free(c_str); - c_str = smart_str.c_str; - smart_str.c_str = nullptr; - } - - return *this; -} - -SmartString::~SmartString() -{ - if (c_str != nullptr) - { - free(c_str); - } -} - -SmartString::operator char *() const -{ - return c_str; -} diff --git a/src/std/smart_string.hpp b/src/std/smart_string.hpp deleted file mode 100644 index 6390465..0000000 --- a/src/std/smart_string.hpp +++ /dev/null @@ -1,20 +0,0 @@ -#pragma once - -class SmartString -{ -public: - explicit SmartString(char *c_str); - explicit SmartString(unsigned int size); - SmartString(const SmartString &smart_str); - SmartString(SmartString &&smart_str) noexcept; - - SmartString &operator=(const SmartString &smart_str); - - SmartString &operator=(SmartString &&smart_str) noexcept; - - ~SmartString(); - - explicit operator char *() const; - - char *c_str = nullptr; -}; diff --git a/src/std/time.cpp b/src/std/time.cpp deleted file mode 100644 index cca8955..0000000 --- a/src/std/time.cpp +++ /dev/null @@ -1,37 +0,0 @@ -#include "time.hpp" - -#include - -Time::Time(uint64_t time_micros) : _time_micros(time_micros) -{ -} - -void Time::update() -{ - _time_micros = micros(); -} - -Time Time::diff(Time prev_time) const -{ - return Time(_time_micros - prev_time.microsecs()); -} - -double Time::secs() const -{ - return static_cast(_time_micros) * MICROS_TO_SECS; -} - -double Time::millisecs() const -{ - return static_cast(_time_micros) * MICROS_TO_MILLIS; -} - -uint64_t Time::microsecs() const -{ - return _time_micros; -} - -Time time_now() -{ - return Time(micros()); -} diff --git a/src/std/time.hpp b/src/std/time.hpp deleted file mode 100644 index a544a5a..0000000 --- a/src/std/time.hpp +++ /dev/null @@ -1,55 +0,0 @@ -#pragma once - -#include - -constexpr double MICROS_TO_SECS = 0.000001; -constexpr double MICROS_TO_MILLIS = 0.001; - -/** - * A representation of time. - */ -class Time -{ -public: - /** - * A representation of time. - * - * @param time_micros Time in microseconds - */ - explicit Time(uint64_t time_micros); - - /** - * Updates the time to the current time. - */ - void update(); - - /** - * Returns the difference between two points in time. - * - * @param prev_time A previous point in time - */ - Time diff(Time prev_time) const; - - /** - * Returns the time in seconds. - */ - double secs() const; - - /** - * Returns the time in milliseconds. - */ - double millisecs() const; - - /** - * Returns the time in microseconds. - */ - uint64_t microsecs() const; - -private: - uint64_t _time_micros; -}; - -/** - * Returns a time object for the time since the program started. - */ -Time time_now(); -- cgit v1.2.3-18-g5258