git subrepo clone https://github.com/Atmosphere-NX/Atmosphere-libs libraries

subrepo:
  subdir:   "libraries"
  merged:   "07af583b"
upstream:
  origin:   "https://github.com/Atmosphere-NX/Atmosphere-libs"
  branch:   "master"
  commit:   "07af583b"
git-subrepo:
  version:  "0.4.0"
  origin:   "https://github.com/ingydotnet/git-subrepo"
  commit:   "5d6aba9"

libraries/libstratosphere/include/stratosphere/kvdb/kvdb_bounded_string.hpp

@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2018-2019 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#include <vapours.hpp>
+
+namespace ams::kvdb {
+
+    /* Represents a string with a backing buffer of N bytes. */
+    template<size_t N>
+    class BoundedString {
+        static_assert(N > 0, "BoundedString requires non-zero backing buffer!");
+        private:
+            char buffer[N];
+        private:
+            /* Utility. */
+            static inline void CheckLength(size_t len) {
+                AMS_ASSERT(len < N);
+            }
+        public:
+            /* Constructors. */
+            constexpr BoundedString() {
+                buffer[0] = 0;
+            }
+
+            explicit constexpr BoundedString(const char *s) {
+                this->Set(s);
+            }
+
+            /* Static constructors. */
+            static constexpr BoundedString<N> Make(const char *s) {
+                return BoundedString<N>(s);
+            }
+
+            static constexpr BoundedString<N> MakeFormat(const char *format, ...) __attribute__((format (printf, 1, 2)))  {
+                BoundedString<N> string;
+
+                std::va_list args;
+                va_start(args, format);
+                CheckLength(std::vsnprintf(string.buffer, N, format, args));
+                va_end(args);
+
+                return string;
+            }
+
+            /* Getters. */
+            size_t GetLength() const {
+                return strnlen(this->buffer, N);
+            }
+
+            const char *Get() const {
+                return this->buffer;
+            }
+
+            operator const char *() const {
+                return this->buffer;
+            }
+
+            /* Setters. */
+            void Set(const char *s) {
+                /* Ensure string can fit in our buffer. */
+                CheckLength(strnlen(s, N));
+                std::strncpy(this->buffer, s, N);
+            }
+
+            void SetFormat(const char *format, ...) __attribute__((format (printf, 2, 3))) {
+                /* Format into the buffer, abort if too large. */
+                std::va_list args;
+                va_start(args, format);
+                CheckLength(std::vsnprintf(this->buffer, N, format, args));
+                va_end(args);
+            }
+
+            /* Append to existing. */
+            void Append(const char *s) {
+                const size_t length = GetLength();
+                CheckLength(length + strnlen(s, N));
+                std::strncat(this->buffer, s, N - length - 1);
+            }
+
+            void Append(char c) {
+                const size_t length = GetLength();
+                CheckLength(length + 1);
+                this->buffer[length] = c;
+                this->buffer[length + 1] = 0;
+            }
+
+            void AppendFormat(const char *format, ...) __attribute__((format (printf, 2, 3))) {
+                const size_t length = GetLength();
+                std::va_list args;
+                va_start(args, format);
+                CheckLength(std::vsnprintf(this->buffer + length, N - length, format, args) + length);
+                va_end(args);
+            }
+
+            /* Substring utilities. */
+            void GetSubstring(char *dst, size_t dst_size, size_t offset, size_t length) const {
+                /* Make sure output buffer can hold the substring. */
+                AMS_ASSERT(offset + length <= GetLength());
+                AMS_ASSERT(dst_size > length);
+                /* Copy substring to dst. */
+                std::strncpy(dst, this->buffer + offset, length);
+                dst[length] = 0;
+            }
+
+            BoundedString<N> GetSubstring(size_t offset, size_t length) const {
+                BoundedString<N> string;
+                GetSubstring(string.buffer, N, offset, length);
+                return string;
+            }
+
+            /* Comparison. */
+            constexpr bool operator==(const BoundedString<N> &rhs) const {
+                return std::strncmp(this->buffer, rhs.buffer, N) == 0;
+            }
+
+            constexpr bool operator!=(const BoundedString<N> &rhs) const {
+                return !(*this == rhs);
+            }
+
+            bool EndsWith(const char *s, size_t offset) const {
+                return std::strncmp(this->buffer + offset, s, N - offset) == 0;
+            }
+
+            bool EndsWith(const char *s) const {
+                const size_t suffix_length = strnlen(s, N);
+                const size_t length = GetLength();
+                return suffix_length <= length && EndsWith(s, length - suffix_length);
+            }
+    };
+
+}