feat: added starts_with ends_with and ""_s literal for Bounded(Const)String

infra/util/BoundedString.cpp

@@ -2,6 +2,15 @@
 
 namespace infra
 {
+
+    namespace literals
+    {
+        infra::BoundedConstString operator""_s(const char* str, std::size_t count)
+        {
+            return infra::BoundedConstString(str, count);
+        }
+    }
+
     BoundedString ByteRangeAsString(infra::MemoryRange<uint8_t> range)
     {
         return BoundedString(reinterpret_cast<char*>(range.begin()), range.size());

infra/util/BoundedString.hpp

@@ -230,8 +230,21 @@ namespace infra
         size_type find_last_not_of(const char* s, size_type pos = npos) const;
         size_type find_last_not_of(char ch, size_type pos = npos) const;
 
+        template<class U>
+        bool starts_with(const BoundedStringBase<U>& other) const;
+        bool starts_with(const char* s, size_type count) const;
+        bool starts_with(const char* s) const;
+        bool starts_with(char ch) const;
+
+        template<class U>
+        bool ends_with(const BoundedStringBase<U>& other) const;
+        bool ends_with(const char* s, size_type count) const;
+        bool ends_with(const char* s) const;
+        bool ends_with(char ch) const;
+
     private:
-        static void AssignToRange(MemoryRange<NonConstT> range, size_type& length, size_type count, char ch);
+        static void
+        AssignToRange(MemoryRange<NonConstT> range, size_type& length, size_type count, char ch);
         template<class U>
         static void AssignToRange(MemoryRange<NonConstT> range, size_type& length, const BoundedStringBase<U>& other);
         template<class U>
@@ -371,6 +384,11 @@ namespace infra
     }
 #endif
 
+    namespace literals
+    {
+        infra::BoundedConstString operator""_s(const char* str, std::size_t count);
+    }
+
     ////    Implementation    ////
 
     template<class T>
@@ -1290,6 +1308,58 @@ namespace infra
         return find_last_not_of(&ch, pos, 1);
     }
 
+    template<class T>
+    template<class U>
+    bool BoundedStringBase<T>::starts_with(const BoundedStringBase<U>& other) const
+    {
+        return starts_with(other.begin(), other.size());
+    }
+
+    template<class T>
+    bool BoundedStringBase<T>::starts_with(const char* s, size_type count) const
+    {
+        return this->substr(0, count) == BoundedConstString{ s, count };
+    }
+
+    template<class T>
+    bool BoundedStringBase<T>::starts_with(const char* s) const
+    {
+        return starts_with(s, std::strlen(s)); //NOSONAR
+    }
+
+    template<class T>
+    bool BoundedStringBase<T>::starts_with(char ch) const
+    {
+        return starts_with(&ch, 1);
+    }
+
+    template<class T>
+    template<class U>
+    bool BoundedStringBase<T>::ends_with(const BoundedStringBase<U>& other) const
+    {
+        return ends_with(other.begin(), other.size());
+    }
+
+    template<class T>
+    bool BoundedStringBase<T>::ends_with(const char* s, size_type count) const
+    {
+        if (count > length)
+            return false;
+        return this->substr(length - count, count) == BoundedConstString{ s, count };
+    }
+
+    template<class T>
+    bool BoundedStringBase<T>::ends_with(const char* s) const
+    {
+        return ends_with(s, std::strlen(s)); //NOSONAR
+    }
+
+    template<class T>
+    bool BoundedStringBase<T>::ends_with(char ch) const
+    {
+        return ends_with(&ch, 1);
+    }
+
     template<class T>
     void BoundedStringBase<T>::AssignToRange(infra::MemoryRange<NonConstT> range, size_type& length, size_type count, char ch)
     {

infra/util/test/TestBoundedString.cpp

@@ -1,6 +1,8 @@
 #include "infra/util/BoundedString.hpp"
 #include "infra/util/ByteRange.hpp"
+#include "gmock/gmock.h"
 #include "gtest/gtest.h"
+#include <type_traits>
 
 TEST(BoundedStringTest, TestConstructedEmpty)
 {
@@ -698,6 +700,28 @@ TEST(BoundedStringTest, TestFindLastNotOf)
     EXPECT_EQ(3, string.find_last_not_of('e'));
 }
 
+TEST(BoundedStringTest, TestStartsWith)
+{
+    char search[] = "qwe";
+    infra::BoundedConstString startsWith = "qwerty";
+    infra::BoundedConstString endsWith = "tyrqwe";
+    infra::BoundedConstString middle = "abcqwedef";
+    EXPECT_THAT(startsWith.starts_with(search), testing::IsTrue());
+    EXPECT_THAT(endsWith.starts_with(search), testing::IsFalse());
+    EXPECT_THAT(middle.starts_with(search), testing::IsFalse());
+}
+
+TEST(BoundedStringTest, TestEndsWith)
+{
+    char search[] = "qwe";
+    infra::BoundedConstString startsWith = "qwerty";
+    infra::BoundedConstString endsWith = "tyrqwe";
+    infra::BoundedConstString middle = "abcqwedef";
+    EXPECT_THAT(startsWith.ends_with(search), testing::IsFalse());
+    EXPECT_THAT(endsWith.ends_with(search), testing::IsTrue());
+    EXPECT_THAT(middle.ends_with(search), testing::IsFalse());
+}
+
 TEST(BoundedStringTest, TestStringAsByteRange)
 {
     infra::BoundedString::WithStorage<5> string("abcde");
@@ -754,3 +778,12 @@ TEST(BoundedStringTest, TestPrintTo2)
     infra::PrintTo(string, &stream);
     EXPECT_EQ(R"("abc")", stream.str());
 }
+
+TEST(BoundedStringTest, TestStringLiteral)
+{
+    using namespace infra::literals;
+    auto string = "abc"_s;
+    EXPECT_THAT(string, testing::Eq("abc"_s));
+
+    static_assert(std::is_same_v<decltype(string), infra::BoundedConstString>);
+}