diff options
Diffstat (limited to 'include')
| -rw-r--r-- | include/fud_format.hpp | 131 | ||||
| -rw-r--r-- | include/fud_option.hpp | 45 | ||||
| -rw-r--r-- | include/fud_string_convert.hpp | 456 | ||||
| -rw-r--r-- | include/fud_string_view.hpp | 41 | ||||
| -rw-r--r-- | include/fud_utf8.hpp | 116 |
5 files changed, 674 insertions, 115 deletions
diff --git a/include/fud_format.hpp b/include/fud_format.hpp index ea32bd8..2576eca 100644 --- a/include/fud_format.hpp +++ b/include/fud_format.hpp @@ -22,24 +22,30 @@ #include "fud_result.hpp" #include "fud_status.hpp" #include "fud_string_view.hpp" +#include "fud_option.hpp" #include "fud_utf8.hpp" #include <cstdint> -#include <optional> #include <variant> +#include <limits> namespace fud { struct FormatAlign { - enum class Value : uint8_t + enum class Value : utf8 { - Left, - Right, - Center + Left = '<', + Right = '>', + Center = '^', + Default = std::numeric_limits<utf8>::max() }; - constexpr static std::optional<FormatAlign> from(utf8 letter) + constexpr static FormatAlign makeDefault() noexcept { + return {Value::Default}; + } + + constexpr static Option<FormatAlign> from(utf8 letter) { FormatAlign formatAlign; switch (letter) { @@ -53,12 +59,16 @@ struct FormatAlign formatAlign.value = Value::Center; break; default: - return std::nullopt; + return NullOpt; } return formatAlign; } + Value operator()() const { + return value; + } + Value value; }; @@ -66,37 +76,50 @@ struct FormatFill { FormatAlign align; utf8 fill; - constexpr static Result<std::optional<FormatFill>, FudStatus> parse(StringView formatView) { - // "{:A<X}" - using RetType = Result<std::optional<FormatFill>, FudStatus>; - if (formatView.length() < 3) { - return RetType::okay(std::nullopt); + constexpr static FormatFill make() noexcept { + return FormatFill {FormatAlign::makeDefault(), ' '}; + } + + constexpr static Result<Option<FormatFill>, FudStatus> make(StringView formatView, size_t& length) noexcept { + using RetType = Result<Option<FormatFill>, FudStatus>; + if (formatView.length() < 1) { + return RetType::okay(NullOpt); } const auto* data = formatView.data(); - if (data[0] != 'A') { - return RetType::okay(std::nullopt); + auto align1 = FormatAlign::from(data[0]); + decltype(align1) align2 = NullOpt; + if (formatView.length() > 1) { + align2 = FormatAlign::from(data[1]); } - auto align = FormatAlign::from(data[1]); - if (!align.has_value()) { - return FudStatus::FormatInvalid; + if (align2.hasValue()) { + length = 2; + auto fill = data[0]; + if (not Ascii::valid(fill)) { + return FudStatus::Utf8Invalid; + } + if (fill == '{' || fill == '}') { + return FudStatus::FormatInvalid; + } + return RetType::okay(FormatFill{std::move(align2).value(), data[0]}); } - auto fill = data[2]; - if (!Ascii::valid(fill)) { - return FudStatus::Utf8Invalid; + if (align1.hasValue()) { + length = 1; + return RetType::okay(FormatFill{std::move(align1).value(), ' '}); } - return RetType::okay(FormatFill{*align, fill}); + return RetType::okay(NullOpt); } }; enum class FormatSign : uint8_t { - Plus, - Minus, - Space + Plus = '+', + Minus = '-', + Space = ' ', + Default = std::numeric_limits<utf8>::max() }; enum class FormatStringType : uint8_t @@ -155,6 +178,7 @@ enum class FormatPointerType : uint8_t HexUpper }; +/* using FormatType = std::variant< // break std::monostate, FormatStringType, @@ -163,33 +187,64 @@ using FormatType = std::variant< // break FormatBoolType, FormatFloatingType, FormatPointerType>; +*/ + +enum class FormatType : utf8 { + Unspecified = '\0', + String = 's', + Escaped = '?', + BinaryLower = 'b', + BinaryUpper = 'B', + Character = 'c', + Decimal = 'd', + Octal = 'o', + HexLower = 'x', + HexUpper = 'X', + FloatHexLower = 'a', + FloatHexUpper = 'A', + ScientificLower = 'e', + ScientificUpper = 'E', + FixedLower = 'f', + FixedUpper = 'F', + GeneralLower = 'g', + GeneralUpper = 'G', +}; struct FormatSpec; using FormatSpecResult = Result<FormatSpec, FudStatus>; struct FormatSpec { - size_t width; - size_t precision; - FormatFill fill; - FormatSign formatSign; + static constexpr uint32_t widthUnspecified = std::numeric_limits<uint32_t>::max(); + static constexpr uint32_t precisionUnspecified = std::numeric_limits<uint32_t>::max(); + static constexpr uint16_t positionUnspecified = std::numeric_limits<uint16_t>::max(); + static constexpr utf8 openBracket = '{'; + static constexpr utf8 closeBracket = '}'; + static constexpr utf8 formatTypeUnspecified = std::numeric_limits<utf8>::max(); + static constexpr utf8 localeChar = 'L'; + + uint32_t width{widthUnspecified}; + + uint32_t precision{precisionUnspecified}; + + uint16_t position{positionUnspecified}; + + FormatFill fill{FormatFill::make()}; - FormatType formatType; + FormatSign formatSign{FormatSign::Default}; - bool hasWidth; - bool takesWidth; + FormatType formatType{}; - bool hasPrecision; - bool takesPrecision; + bool takesWidth{false}; - bool hasFill; + bool takesPrecision{false}; - bool hasFormatSign; + bool alternateForm{false}; - bool alternateForm; + bool leadingZero{false}; - bool leadingZero; + bool hasLocale{false}; - static Result<FormatSpec, FudStatus> make(StringView& formatView, size_t specIndex); + static Result<FormatSpec, FudStatus> make(StringView formatView, size_t& specLength); }; } // namespace fud diff --git a/include/fud_option.hpp b/include/fud_option.hpp index ca3954f..931ef82 100644 --- a/include/fud_option.hpp +++ b/include/fud_option.hpp @@ -103,16 +103,16 @@ class Option { } } - constexpr Option(const Option& rhs) noexcept : m_engaged(rhs.m_engaged), m_data(rhs.m_data) + constexpr Option(const Option& rhs) noexcept : m_data(rhs.m_data), m_engaged(rhs.m_engaged) { } - constexpr Option(Option&& rhs) noexcept : m_engaged(rhs.m_engaged), m_data(std::move(rhs.m_data)) + constexpr Option(Option&& rhs) noexcept : m_data(std::move(rhs.m_data)), m_engaged(rhs.m_engaged) { rhs.cleanup(); } - ~Option() noexcept + constexpr ~Option() noexcept { destroy(); } @@ -142,6 +142,11 @@ class Option { return m_engaged; } + [[nodiscard]] bool isNone() const + { + return !m_engaged; + } + operator bool() const { return hasValue(); } @@ -170,7 +175,23 @@ class Option { { fudAssert(m_engaged); static_assert(!IsRef); - return *reinterpret_cast<const ValueType*>(m_data.data()); + return std::move(*reinterpret_cast<const ValueType*>(m_data.data())); + } + + [[nodiscard]] constexpr const ValueType& valueOr(const ValueType& alternative) const& + { + if (m_engaged) { + return value(); + } + return alternative; + } + + [[nodiscard]] constexpr ValueType&& valueOr(ValueType&& alternative) const&& + { + if (m_engaged) { + return value(); + } + return std::move(alternative); } template <typename F> @@ -203,27 +224,11 @@ class Option { m_data.clear(); } - // alignas(maxAlign) Array<uint8_t, maxSize> priv_m_data; - alignas(alignof(T)) option_detail::DataArray<Size> m_data{}; bool m_engaged; }; -namespace test { - -void testOption() -{ - Option<int> intOpt; - static_cast<void>(intOpt); - Option<int&> intRefNull; - static_cast<void>(intRefNull); - int value; - Option<int&> intRefValue{value}; -} - -} // namespace test - } // namespace fud #endif diff --git a/include/fud_string_convert.hpp b/include/fud_string_convert.hpp new file mode 100644 index 0000000..597c6a9 --- /dev/null +++ b/include/fud_string_convert.hpp @@ -0,0 +1,456 @@ +/* + * libfud + * Copyright 2024 Dominick Allen + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef FUD_STRING_CONVERT_HPP +#define FUD_STRING_CONVERT_HPP + +#include "fud_algorithm.hpp" +#include "fud_option.hpp" +#include "fud_result.hpp" +#include "fud_status.hpp" +#include "fud_string.hpp" +#include "fud_string_view.hpp" + +#include <cmath> +#include <cstdint> + +namespace fud { + +enum class Radix : uint8_t +{ + Binary = 2, + Octal = 8, + Decimal = 10, + Hexadecimal = 16, +}; + +constexpr uint8_t RadixMax = 36; + +template <typename T> +struct ConvertValue { + size_t nextIndex; + T value; +}; + +template <typename T> +using StringConvertResult = Result<ConvertValue<T>, FudStatus>; + +template <typename T> +StringConvertResult<T> fromString(StringView inputView, Option<uint8_t> specifiedRadixOption = NullOpt); + +template <typename T> +StringConvertResult<T> fromString(StringView inputView, Radix specifiedRadixOption); + +template <typename T> +StringConvertResult<T> fromString(const String& inputView, Option<uint8_t> specifiedRadixOption = NullOpt); + +namespace impl { +constexpr Array<int8_t, 256> AsciiLookup{ + {-1, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, + -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + -2, -2, -2, -2, -2, -2, -2, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, -2, -2, -2, -2, -2, -2, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, -2, -2, -2, -2, -2, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, + -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, + -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, + -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, + -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3}}; + +// NOLINTBEGIN(readability-magic-numbers) +static_assert(AsciiLookup[static_cast<size_t>('0')] == 0); +static_assert(AsciiLookup[static_cast<size_t>('1')] == 1); +static_assert(AsciiLookup[static_cast<size_t>('2')] == 2); +static_assert(AsciiLookup[static_cast<size_t>('3')] == 3); +static_assert(AsciiLookup[static_cast<size_t>('4')] == 4); +static_assert(AsciiLookup[static_cast<size_t>('5')] == 5); +static_assert(AsciiLookup[static_cast<size_t>('6')] == 6); +static_assert(AsciiLookup[static_cast<size_t>('7')] == 7); +static_assert(AsciiLookup[static_cast<size_t>('8')] == 8); +static_assert(AsciiLookup[static_cast<size_t>('9')] == 9); +static_assert(AsciiLookup[static_cast<size_t>('a')] == 10); +static_assert(AsciiLookup[static_cast<size_t>('b')] == 11); +static_assert(AsciiLookup[static_cast<size_t>('c')] == 12); +static_assert(AsciiLookup[static_cast<size_t>('d')] == 13); +static_assert(AsciiLookup[static_cast<size_t>('e')] == 14); +static_assert(AsciiLookup[static_cast<size_t>('f')] == 15); +static_assert(AsciiLookup[static_cast<size_t>('A')] == 10); +static_assert(AsciiLookup[static_cast<size_t>('B')] == 11); +static_assert(AsciiLookup[static_cast<size_t>('C')] == 12); +static_assert(AsciiLookup[static_cast<size_t>('D')] == 13); +static_assert(AsciiLookup[static_cast<size_t>('E')] == 14); +static_assert(AsciiLookup[static_cast<size_t>('F')] == 15); +static_assert(AsciiLookup[127] == -2); +static_assert(AsciiLookup[128] == -3); +// NOLINTEND(readability-magic-numbers) + +FudStatus checkPlusSigned(StringView& view, size_t& skipIndex); + +Result<Radix, FudStatus> determineRadix(StringView input, size_t& index); + +Result<bool, FudStatus> checkNegative(StringView& view, size_t& skipIndex); + +Result<uint8_t, FudStatus> getRadix(StringView& view, size_t& skipIndex, Option<uint8_t> specifiedRadixOption); + +template <typename T> +StringConvertResult<T> unsignedFromString(StringView nextView, size_t skipIndex, Option<uint8_t> specifiedRadixOption) +{ + static_assert(std::is_unsigned_v<T> && std::is_integral_v<T>); + auto status = checkPlusSigned(nextView, skipIndex); + if (status != FudStatus::Success) { + return FudStatus::ArgumentInvalid; + } + + auto radixResult = impl::getRadix(nextView, skipIndex, specifiedRadixOption); + if (radixResult.isError()) { + return radixResult.takeError(); + } + auto radix = radixResult.takeOkay(); + + T num = 0; + size_t digitIndex = 0; + + while (digitIndex < nextView.length()) { + auto digitResult = impl::AsciiLookup[nextView.data()[digitIndex]]; + if (digitResult >= radix || digitResult < 0) { + break; + } + + auto digit = static_cast<uint8_t>(digitResult); + if (std::numeric_limits<T>::max() / radix < num) { + return FudStatus::RangeError; + } + num *= radix; + if (std::numeric_limits<T>::max() - digit < num) { + return FudStatus::RangeError; + } + num += digit; + digitIndex++; + } + if (digitIndex < 1) { + return FudStatus::ArgumentInvalid; + } + + return ConvertValue{skipIndex + digitIndex, num}; +} + +template <typename T> +FudStatus signedPositiveFromString(StringView view, uint8_t radix, size_t& digitIndex, T& num) +{ + digitIndex = 0; + while (digitIndex < view.length()) { + int8_t digitResult = impl::AsciiLookup[view.data()[digitIndex]]; + if (digitResult >= radix || digitResult < 0) { + break; + } + + auto digit = static_cast<uint8_t>(digitResult); + if (std::numeric_limits<T>::max() / radix < num) { + return FudStatus::RangeError; + } + num = static_cast<T>(num * radix); + if (std::numeric_limits<T>::max() - digit < num) { + return FudStatus::RangeError; + } + num = static_cast<T>(num + digit); + digitIndex++; + } + + return FudStatus::Success; +} + +template <typename T> +FudStatus signedNegativeFromString(StringView view, uint8_t radix, size_t& digitIndex, T& num) +{ + digitIndex = 0; + while (digitIndex < view.length()) { + int8_t digitResult = impl::AsciiLookup[view.data()[digitIndex]]; + if (digitResult >= radix || digitResult < 0) { + break; + } + + auto digit = static_cast<uint8_t>(digitResult); + if ((std::numeric_limits<T>::min() / radix > num)) { + return FudStatus::RangeError; + } + num = static_cast<T>(num * radix); + if (std::numeric_limits<T>::min() + digit > num) { + return FudStatus::RangeError; + } + num = static_cast<T>(num - digit); + digitIndex++; + } + + return FudStatus::Success; +} + +template <typename T> +StringConvertResult<T> signedFromString(StringView nextView, size_t skipIndex, Option<uint8_t> specifiedRadixOption) +{ + static_assert(std::is_signed_v<T> && std::is_integral_v<T>); + auto status = impl::checkPlusSigned(nextView, skipIndex); + if (status != FudStatus::Success) { + return FudStatus::ArgumentInvalid; + } + + auto radixResult = impl::getRadix(nextView, skipIndex, specifiedRadixOption); + if (radixResult.isError()) { + return radixResult.takeError(); + } + auto radix = radixResult.takeOkay(); + + T num = 0; + size_t digitIndex = 0; + + auto isNegativeResult = checkNegative(nextView, skipIndex); + if (isNegativeResult.isError()) { + return isNegativeResult.takeError(); + } + const auto isNegative = isNegativeResult.takeOkay(); + + if (isNegative) { + status = signedNegativeFromString(nextView, radix, digitIndex, num); + } else { + status = signedPositiveFromString(nextView, radix, digitIndex, num); + } + + if (status != FudStatus::Success) { + return status; + } + + if (digitIndex < 1) { + return FudStatus::ArgumentInvalid; + } + + return ConvertValue{skipIndex + digitIndex, num}; +} + +template <typename T> +bool isNanOrInf(T& num, StringView& view, T& sign, size_t& digitIndex) +{ + if (view.length() >= 3) { + Array<uint8_t, 3> letters{{view.data()[0], view.data()[1], view.data()[2]}}; + forEach(letters.span(), charToLower); + if (letters[0] == 'i' && letters[1] == 'n' && letters[2] == 'f') { + num = sign * std::numeric_limits<T>::infinity(); + digitIndex = 3; + return true; + } + if (letters[0] == 'n' && letters[1] == 'a' && letters[2] == 'n') { + num = std::numeric_limits<T>::quiet_NaN(); + digitIndex = 3; + return true; + } + } + return false; +} + +template <typename T> +FudStatus getWhole( + const StringView view, + size_t& digitIndex, + T& num, + T sign, + uint8_t radix, + bool& foundDecimal, + bool& foundExponent) +{ + while (digitIndex < view.length()) { + auto nextChar = view.data()[digitIndex]; + if (nextChar == '.') { + foundDecimal = true; + digitIndex++; + break; + } + + if (radix == static_cast<uint8_t>(Radix::Decimal) && (nextChar == 'e' || nextChar == 'E')) { + foundExponent = true; + digitIndex++; + break; + } + + auto digitResult = impl::AsciiLookup[nextChar]; + if (digitResult >= radix) { + return FudStatus::ArgumentInvalid; + } + if (digitResult < 0) { + break; + } + auto digit = static_cast<T>(digitResult) * sign; + num *= static_cast<T>(radix); + + num += digit; + digitIndex++; + } + return FudStatus::Success; +} + +template <typename T> +FudStatus getExponent(StringView view, size_t& digitIndex, T& num, uint8_t radix) +{ + StringView tempView{view.length() - digitIndex, view.data() + digitIndex}; + size_t exponentLength{}; + auto convertResult = signedFromString<int32_t>(tempView, exponentLength, static_cast<uint8_t>(Radix::Decimal)); + if (convertResult.isError()) { + return convertResult.takeError(); + } + auto convertValue = convertResult.takeOkay(); + digitIndex += convertValue.nextIndex + exponentLength; + num = num * std::pow(static_cast<T>(radix), static_cast<T>(convertValue.value)); + return FudStatus::Success; +} + +template <typename T> +FudStatus getFraction(const StringView view, size_t& digitIndex, T& num, T sign, uint8_t radix, bool& foundExponent) +{ + auto radixDiv = static_cast<T>(1) / static_cast<T>(radix); + while (digitIndex < view.length()) { + auto nextChar = view.data()[digitIndex]; + if (radix == static_cast<uint8_t>(Radix::Decimal) && (nextChar == 'e' || nextChar == 'E')) { + foundExponent = true; + digitIndex++; + break; + } + + auto digitResult = impl::AsciiLookup[nextChar]; + if (digitResult >= radix) { + return FudStatus::ArgumentInvalid; + } + if (digitResult < 0) { + break; + } + auto digit = static_cast<T>(digitResult) * sign; + num += digit * radixDiv; + radixDiv /= static_cast<T>(radix); + digitIndex++; + } + return FudStatus::Success; +} + +template <typename T> +StringConvertResult<T> floatFromString(StringView nextView, size_t skipIndex, Option<uint8_t> specifiedRadixOption) +{ + static_assert(std::is_floating_point_v<T>); + if (nextView.length() < 1) { + return FudStatus::ArgumentInvalid; + } + + auto isNegativeResult = checkNegative(nextView, skipIndex); + if (isNegativeResult.isError()) { + return isNegativeResult.takeError(); + } + const auto isNegative = isNegativeResult.takeOkay(); + + if (!isNegative) { + auto status = checkPlusSigned(nextView, skipIndex); + if (status != FudStatus::Success) { + return FudStatus::ArgumentInvalid; + } + } + T sign = isNegative ? -1.0 : 1.0; + + T num = 0; + size_t digitIndex = 0; + + auto retSuccess = [&]() { return ConvertValue{skipIndex + digitIndex, num}; }; + + if (impl::isNanOrInf(num, nextView, sign, digitIndex)) { + return retSuccess(); + } + + auto radixResult = impl::getRadix(nextView, skipIndex, specifiedRadixOption); + if (radixResult.isError()) { + return radixResult.takeError(); + } + auto radix = radixResult.takeOkay(); + + bool foundDecimal = false; + bool foundExponent = false; + auto status = getWhole(nextView, digitIndex, num, sign, radix, foundDecimal, foundExponent); + + if (status == FudStatus::Success && foundExponent) { + status = getExponent(nextView, digitIndex, num, radix); + } + + if (status != FudStatus::Success) { + return status; + } + + if (!foundDecimal) { + if (digitIndex < 1) { + return FudStatus::ArgumentInvalid; + } + + return retSuccess(); + } + + status = getFraction(nextView, digitIndex, num, sign, radix, foundExponent); + + if (foundExponent) { + status = getExponent(nextView, digitIndex, num, radix); + if (status != FudStatus::Success) { + return status; + } + } + + if (digitIndex < 1) { + return FudStatus::ArgumentInvalid; + } + + if (std::isinf(num) || std::isnan(num)) // isnan is dubious here - likely unreachable + { + return FudStatus::RangeError; + } + + return retSuccess(); +} + +} // namespace impl + +template <typename T> +StringConvertResult<T> fromString(StringView inputView, Radix specifiedRadixOption) +{ + return fromString<T>(inputView, static_cast<uint8_t>(specifiedRadixOption)); +} + +template <typename T> +StringConvertResult<T> fromString(StringView inputView, Option<uint8_t> specifiedRadixOption) +{ + if (inputView.data() == nullptr) { + return FudStatus::NullPointer; + } + + StringView nextView{inputView}; + auto skipResult = nextView.skipWhitespace(); + if (skipResult.isError()) { + return skipResult.takeError(); + } + size_t skipIndex = skipResult.takeOkay(); + + if constexpr (std::is_unsigned_v<T> && std::is_integral_v<T>) { + return impl::unsignedFromString<T>(nextView, skipIndex, specifiedRadixOption); + } else if constexpr (std::is_signed_v<T> && std::is_integral_v<T>) { + return impl::signedFromString<T>(nextView, skipIndex, specifiedRadixOption); + } else if constexpr (std::is_floating_point_v<T>) { + return impl::floatFromString<T>(nextView, skipIndex, specifiedRadixOption); + } else { + return FudStatus::NotImplemented; + } +} + +} // namespace fud + +#endif diff --git a/include/fud_string_view.hpp b/include/fud_string_view.hpp index 8a47ae5..0852645 100644 --- a/include/fud_string_view.hpp +++ b/include/fud_string_view.hpp @@ -20,6 +20,8 @@ #include "fud_status.hpp" #include "fud_utf8.hpp" +#include "fud_config.hpp" +#include "fud_assert.hpp" #include <string_view> @@ -63,6 +65,25 @@ struct StringView { return m_data; } + constexpr const utf8& operator[](size_t index) const + { + if constexpr (fudBoundsChecking) { + fudAssert(m_data != nullptr); + fudAssert(index < m_length); + } + return m_data[index]; + } + + constexpr const utf8* begin() const noexcept + { + return m_data; + } + + constexpr const utf8* end() const noexcept + { + return m_data + m_length; + } + [[nodiscard]] bool nullTerminated() const; [[nodiscard]] bool utf8Valid() const; @@ -79,26 +100,6 @@ struct StringView { void advanceUnsafe(size_t size); - FudStatus toUint8(uint8_t& number, uint8_t specifiedRadix, size_t& strLen) const; - - FudStatus toUint16(uint16_t& number, uint8_t specifiedRadix, size_t& strLen) const; - - FudStatus toUint32(uint32_t& number, uint8_t specifiedRadix, size_t& strLen) const; - - FudStatus toUint64(uint64_t& number, uint8_t specifiedRadix, size_t& strLen) const; - - FudStatus toInt8(int8_t& number, uint8_t specifiedRadix, size_t& strLen) const; - - FudStatus toInt16(int16_t& number, uint8_t specifiedRadix, size_t& strLen) const; - - FudStatus toInt32(int32_t& number, uint8_t specifiedRadix, size_t& strLen) const; - - FudStatus toInt64(int64_t& number, uint8_t specifiedRadix, size_t& strLen) const; - - FudStatus toFloat(float& number, size_t& strLen) const; - - FudStatus toDouble(double& number, size_t& strLen) const; - size_t m_length{0}; const utf8* m_data{nullptr}; diff --git a/include/fud_utf8.hpp b/include/fud_utf8.hpp index 3b1a6b7..50e50aa 100644 --- a/include/fud_utf8.hpp +++ b/include/fud_utf8.hpp @@ -19,8 +19,8 @@ #define FUD_UTF8_HPP #include "fud_array.hpp" -#include "fud_unique_array.hpp" #include "fud_c_string.hpp" +#include "fud_unique_array.hpp" #include <cstdint> #include <optional> @@ -28,8 +28,6 @@ namespace fud { - - using utf8 = unsigned char; class String; @@ -113,8 +111,7 @@ struct Utf82Byte { { } - __attribute__((nonnull)) - constexpr Utf82Byte(const char* letterStr) noexcept : characters{} + __attribute__((nonnull)) constexpr Utf82Byte(const char* letterStr) noexcept : characters{} { auto length = cStringLength(letterStr, 2); if (length < 2) { @@ -159,8 +156,7 @@ struct Utf83Byte { { } - __attribute__((nonnull)) - constexpr Utf83Byte(const char* letterStr) noexcept : characters{} + __attribute__((nonnull)) constexpr Utf83Byte(const char* letterStr) noexcept : characters{} { auto length = cStringLength(letterStr, 3); if (length < 3) { @@ -213,8 +209,7 @@ struct Utf84Byte { { } - __attribute__((nonnull)) - constexpr Utf84Byte(const char* letterStr) noexcept : characters{} + __attribute__((nonnull)) constexpr Utf84Byte(const char* letterStr) noexcept : characters{} { auto length = cStringLength(letterStr, 4); if (length < 4) { @@ -327,7 +322,8 @@ struct FudUtf8 { return unicode; } - static constexpr FudUtf8 make(Utf8Variant utf8Variant) { + static constexpr FudUtf8 make(Utf8Variant utf8Variant) + { FudUtf8 unicode{}; unicode.m_variant = utf8Variant; if (!std::visit([](auto arg) { return arg.valid(); }, utf8Variant)) { @@ -513,82 +509,128 @@ struct FudUtf8 { } }; +namespace classify { + +using CharPredicate = bool (*)(char); +using Utf8Predicate = bool (*)(utf8); +using FudUtf8Predicate = bool (*)(FudUtf8); + /** \brief Checks if a character is ascii. */ -[[nodiscard]] bool charIsAscii(char character); +[[nodiscard]] bool isAscii(char character); -[[nodiscard]] bool utf8IsAscii(FudUtf8 character); +[[nodiscard]] bool isAscii(utf8 character); + +[[nodiscard]] bool isAscii(FudUtf8 character); /** \brief Checks if a character is alphanumeric. */ -[[nodiscard]] bool charIsAlphanumeric(char character); +[[nodiscard]] bool isAlphanumeric(char character); /** \brief Checks if a character is alphanumeric. */ -[[nodiscard]] bool utf8IsAlphanumeric(FudUtf8 character); +[[nodiscard]] bool isAlphanumeric(utf8 character); + +/** \brief Checks if a character is alphanumeric. */ +[[nodiscard]] bool isAlphanumeric(FudUtf8 character); + +/** \brief Checks if a character is alphabetic. */ +[[nodiscard]] bool isAlpha(char character); /** \brief Checks if a character is alphabetic. */ -[[nodiscard]] bool charIsAlpha(char character); +[[nodiscard]] bool isAlpha(utf8 character); /** \brief Checks if a character is alphabetic. */ -[[nodiscard]] bool utf8IsAlpha(FudUtf8 character); +[[nodiscard]] bool isAlpha(FudUtf8 character); + +/** \brief Checks if a character is lowercase. */ +[[nodiscard]] bool isLowercase(char character); /** \brief Checks if a character is lowercase. */ -[[nodiscard]] bool charIsLowercase(char character); +[[nodiscard]] bool isLowercase(utf8 character); /** \brief Checks if a character is lowercase. */ -[[nodiscard]] bool utf8IsLowercase(FudUtf8 character); +[[nodiscard]] bool isLowercase(FudUtf8 character); + +/** \brief Checks if a character is uppercase. */ +[[nodiscard]] bool isUppercase(char character); -/** \brief Checks if a character is an uppercase character. */ -[[nodiscard]] bool charIsUppercase(char character); +/** \brief Checks if a character is uppercase. */ +[[nodiscard]] bool isUppercase(utf8 character); /** \brief Checks if a character is uppercase. */ -[[nodiscard]] bool utf8IsUppercase(FudUtf8 character); +[[nodiscard]] bool isUppercase(FudUtf8 character); /** \brief Checks if a character is a digit. */ -[[nodiscard]] bool charIsDigit(char character); +[[nodiscard]] bool isDigit(char character); /** \brief Checks if a character is a digit. */ -[[nodiscard]] bool utf8IsDigit(FudUtf8 character); +[[nodiscard]] bool isDigit(utf8 character); + +/** \brief Checks if a character is a digit. */ +[[nodiscard]] bool isDigit(FudUtf8 character); /** \brief Checks if a character is a hexadecimal character. */ -[[nodiscard]] bool charIsHexDigit(char character); +[[nodiscard]] bool isHexDigit(char character); + +/** \brief Checks if a character is a hexadecimal character. */ +[[nodiscard]] bool isHexDigit(utf8 character); /** \brief Checks if a character is a hexadecimal digit. */ -[[nodiscard]] bool utf8IsHexDigit(FudUtf8 character); +[[nodiscard]] bool isHexDigit(FudUtf8 character); /** \brief Checks if a character is a control character. */ -[[nodiscard]] bool charIsControl(char character); +[[nodiscard]] bool isControl(char character); /** \brief Checks if a character is a control character. */ -[[nodiscard]] bool utf8IsControl(FudUtf8 character); +[[nodiscard]] bool isControl(utf8 character); + +/** \brief Checks if a character is a control character. */ +[[nodiscard]] bool isControl(FudUtf8 character); + +/** \brief Checks if a character is a graphical character. */ +[[nodiscard]] bool isGraphical(char character); /** \brief Checks if a character is a graphical character. */ -[[nodiscard]] bool charIsGraphical(char character); +[[nodiscard]] bool isGraphical(utf8 character); /** \brief Checks if a character is a graphical character. */ -[[nodiscard]] bool utf8IsGraphical(FudUtf8 character); +[[nodiscard]] bool isGraphical(FudUtf8 character); /** \brief Checks if a character is a space character. */ -[[nodiscard]] bool charIsSpace(char character); +[[nodiscard]] bool isSpace(char character); /** \brief Checks if a character is a space character. */ -[[nodiscard]] bool utf8IsSpace(FudUtf8 character); +[[nodiscard]] bool isSpace(utf8 character); + +/** \brief Checks if a character is a space character. */ +[[nodiscard]] bool isSpace(FudUtf8 character); + +/** \brief Checks if a character is a blank character. */ +[[nodiscard]] bool isBlank(char character); /** \brief Checks if a character is a blank character. */ -[[nodiscard]] bool charIsBlank(char character); +[[nodiscard]] bool isBlank(utf8 character); /** \brief Checks if a character is a blank character. */ -[[nodiscard]] bool utf8IsBlank(FudUtf8 character); +[[nodiscard]] bool isBlank(FudUtf8 character); + +/** \brief Checks if a character is a printable character. */ +[[nodiscard]] bool isPrintable(char character); /** \brief Checks if a character is a printable character. */ -[[nodiscard]] bool charIsPrintable(char character); +[[nodiscard]] bool isPrintable(utf8 character); /** \brief Checks if a character is a printable character. */ -[[nodiscard]] bool utf8IsPrintable(FudUtf8 character); +[[nodiscard]] bool isPrintable(FudUtf8 character); + +/** \brief Checks if a character is a punctuation character. */ +[[nodiscard]] bool isPunctuation(char character); /** \brief Checks if a character is a punctuation character. */ -[[nodiscard]] bool charIsPunctuation(char character); +[[nodiscard]] bool isPunctuation(utf8 character); /** \brief Checks if a character is a punctuation character. */ -[[nodiscard]] bool utf8IsPunctuation(FudUtf8 character); +[[nodiscard]] bool isPunctuation(FudUtf8 character); + +} // namespace classify /** \brief Converts character to lowercase if valid. */ uint8_t charToLower(uint8_t character); |