drinkingtea/nostalgia
drinkingtea/nostalgia
2
0
Fork 0
Code Issues 7 Pull Requests Actions Releases 9 Activity

[ox/std] Add Integer_c concept to fix string + and += duplication of std::size_t with some compilers/platforms

Browse Source
This commit is contained in:
Gary Talent 2022-03-02 23:42:12 -06:00
parent 187edcd1d3
commit bd2dd3f000
5 changed files with 44 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
deps/ox/src/ox/std/bstring.hpp vendored
View File

@ -29,19 +29,19 @@ class BString {
constexpr BString &operator=(char *str) noexcept;
constexpr BString &operator=(int64_t i) noexcept;
constexpr BString &operator=(Integer_c auto i) noexcept;
constexpr BString &operator+=(const char *str) noexcept;
constexpr BString &operator+=(char *str) noexcept;
constexpr BString &operator+=(int64_t i) noexcept;
constexpr BString &operator+=(Integer_c auto i) noexcept;
constexpr BString operator+(const char *str) const noexcept;
constexpr BString operator+(char *str) const noexcept;
constexpr BString operator+(int64_t i) const noexcept;
constexpr BString operator+(Integer_c auto i) const noexcept;
constexpr bool operator==(const BString &other) const noexcept;
@ -87,7 +87,7 @@ constexpr BString<size>::BString(const char *str) noexcept: m_buff{{0}} {
}
template<std::size_t size>
constexpr BString<size> &BString<size>::operator=(int64_t i) noexcept {
constexpr BString<size> &BString<size>::operator=(Integer_c auto i) noexcept {
char str[65] = {};
ox_itoa(i, str);
return this->operator=(str);
@ -123,7 +123,7 @@ constexpr BString<size> &BString<size>::operator+=(char *str) noexcept {
}
template<std::size_t size>
constexpr BString<size> &BString<size>::operator+=(int64_t i) noexcept {
constexpr BString<size> &BString<size>::operator+=(Integer_c auto i) noexcept {
char str[65] = {};
ox_itoa(i, str);
return this->operator+=(str);
@ -143,7 +143,7 @@ constexpr BString<size> BString<size>::operator+(char *str) const noexcept {
}
template<std::size_t size>
constexpr BString<size> BString<size>::operator+(int64_t i) const noexcept {
constexpr BString<size> BString<size>::operator+(Integer_c auto i) const noexcept {
char str[65] = {};
ox_itoa(i, str);
return this->operator+(str);

2
deps/ox/src/ox/std/fmt.hpp vendored
View File

@ -70,7 +70,7 @@ class FmtArg {
constexpr FmtArg(const T &v) noexcept {
if constexpr(is_bool_v<T>) {
out = v ? "true" : "false";
} else if constexpr(is_integral_v<T>) {
} else if constexpr(is_integer_v<T>) {
out = ox_itoa(v, dataStr);
} else {
out = toCString(v);

49
deps/ox/src/ox/std/string.hpp vendored
View File

@ -120,13 +120,7 @@ class BasicString {
constexpr BasicString &operator+=(char c) noexcept;
constexpr BasicString &operator+=(int i) noexcept;
constexpr BasicString &operator+=(int64_t i) noexcept;
constexpr BasicString &operator+=(uint64_t i) noexcept;
constexpr BasicString &operator+=(std::size_t i) noexcept;
constexpr BasicString &operator+=(Integer_c auto i) noexcept;
constexpr BasicString &operator+=(const BasicString &src) noexcept;
@ -136,11 +130,7 @@ class BasicString {
constexpr BasicString operator+(char c) const noexcept;
constexpr BasicString operator+(int i) const noexcept;
constexpr BasicString operator+(int64_t i) const noexcept;
constexpr BasicString operator+(uint64_t i) const noexcept;
constexpr BasicString operator+(Integer_c auto i) const noexcept;
constexpr BasicString operator+(const BasicString &src) const noexcept;
@ -345,26 +335,7 @@ constexpr BasicString<SmallStringSize> &BasicString<SmallStringSize>::operator+=
}
template<std::size_t SmallStringSize>
constexpr BasicString<SmallStringSize> &BasicString<SmallStringSize>::operator+=(int i) noexcept {
return this->operator+=(static_cast<int64_t>(i));
}
template<std::size_t SmallStringSize>
constexpr BasicString<SmallStringSize> &BasicString<SmallStringSize>::operator+=(int64_t i) noexcept {
char str[65] = {};
ox_itoa(i, str);
return this->operator+=(str);
}
template<std::size_t SmallStringSize>
constexpr BasicString<SmallStringSize> &BasicString<SmallStringSize>::operator+=(uint64_t i) noexcept {
char str[65] = {};
ox_itoa(i, str);
return this->operator+=(str);
}
template<std::size_t SmallStringSize>
constexpr BasicString<SmallStringSize> &BasicString<SmallStringSize>::operator+=(std::size_t i) noexcept {
constexpr BasicString<SmallStringSize> &BasicString<SmallStringSize>::operator+=(Integer_c auto i) noexcept {
char str[65] = {};
ox_itoa(i, str);
return this->operator+=(str);
@ -401,19 +372,7 @@ constexpr BasicString<SmallStringSize> BasicString<SmallStringSize>::operator+(c
}
template<std::size_t SmallStringSize>
constexpr BasicString<SmallStringSize> BasicString<SmallStringSize>::operator+(int i) const noexcept {
return this->operator+(static_cast<int64_t>(i));
}
template<std::size_t SmallStringSize>
constexpr BasicString<SmallStringSize> BasicString<SmallStringSize>::operator+(int64_t i) const noexcept {
char str[65] = {};
ox_itoa(i, str);
return *this + str;
}
template<std::size_t SmallStringSize>
constexpr BasicString<SmallStringSize> BasicString<SmallStringSize>::operator+(uint64_t i) const noexcept {
constexpr BasicString<SmallStringSize> BasicString<SmallStringSize>::operator+(Integer_c auto i) const noexcept {
char str[65] = {};
ox_itoa(i, str);
return *this + str;

59
deps/ox/src/ox/std/trace.hpp vendored
View File

@ -17,6 +17,7 @@
#include "fmt.hpp"
#include "hashmap.hpp"
#include "string.hpp"
#include "typetraits.hpp"
#include "units.hpp"
extern "C" {
@ -110,23 +111,7 @@ class OutStream {
oxTraceHook(m_msg.file, m_msg.line, m_msg.ch, m_msg.msg.c_str());
}
constexpr OutStream &operator<<(short v) noexcept;
constexpr OutStream &operator<<(int v) noexcept;
constexpr OutStream &operator<<(long v) noexcept;
constexpr OutStream &operator<<(long long v) noexcept;
constexpr OutStream &operator<<(unsigned char v) noexcept;
constexpr OutStream &operator<<(unsigned short v) noexcept;
constexpr OutStream &operator<<(unsigned int v) noexcept;
constexpr OutStream &operator<<(unsigned long v) noexcept;
constexpr OutStream &operator<<(unsigned long long v) noexcept;
constexpr OutStream &operator<<(Integer_c auto v) noexcept;
constexpr OutStream &operator<<(char v) noexcept {
if (m_msg.msg.len()) {
@ -185,40 +170,12 @@ class OutStream {
};
constexpr OutStream &OutStream::operator<<(short v) noexcept {
return appendSignedInt(v);
}
constexpr OutStream &OutStream::operator<<(int v) noexcept {
return appendSignedInt(v);
}
constexpr OutStream &OutStream::operator<<(long v) noexcept {
return appendSignedInt(v);
}
constexpr OutStream &OutStream::operator<<(long long v) noexcept {
return appendSignedInt(v);
}
constexpr OutStream &OutStream::operator<<(unsigned char v) noexcept {
return appendUnsignedInt(v);
}
constexpr OutStream &OutStream::operator<<(unsigned short v) noexcept {
return appendUnsignedInt(v);
}
constexpr OutStream &OutStream::operator<<(unsigned int v) noexcept {
return appendUnsignedInt(v);
}
constexpr OutStream &OutStream::operator<<(unsigned long v) noexcept {
return appendUnsignedInt(v);
}
constexpr OutStream &OutStream::operator<<(unsigned long long v) noexcept {
return appendUnsignedInt(v);
constexpr OutStream &OutStream::operator<<(Integer_c auto v) noexcept {
if (m_msg.msg.len()) {
m_msg.msg += m_delimiter;
}
m_msg.msg += v;
return *this;
}

25
deps/ox/src/ox/std/typetraits.hpp vendored
View File

@ -75,6 +75,31 @@ template<> struct is_integral<unsigned long long>: true_type {};
template<typename T>
constexpr bool is_integral_v = is_integral<T>::value;
// is_integer /////////////////////////////////////////////////////////////////
template<typename T> struct is_integer: false_type {};
template<> struct is_integer<int8_t> : true_type {};
template<> struct is_integer<uint8_t> : true_type {};
template<> struct is_integer<int16_t> : true_type {};
template<> struct is_integer<uint16_t>: true_type {};
template<> struct is_integer<int32_t> : true_type {};
template<> struct is_integer<uint32_t>: true_type {};
// some of these need to be done with the actual language syntax because no one
// can agree on what an (u)int64_t is...
template<> struct is_integer<long>: true_type {};
template<> struct is_integer<long long>: true_type {};
template<> struct is_integer<unsigned long>: true_type {};
template<> struct is_integer<unsigned long long>: true_type {};
template<typename T>
constexpr bool is_integer_v = is_integral<T>::value;
template<typename T>
concept Integer_c = is_integer<T>::value;
template<typename T> struct is_char: false_type {};
template<> struct is_char<char> : true_type {};
template<typename T>