1 files changed, 32 insertions, 29 deletions

diff --git a/dev/kernel/NeKit/KString.h b/dev/kernel/NeKit/KString.h
index bbe49f8e..6a1b04d2 100644
--- a/dev/kernel/NeKit/KString.h
+++ b/dev/kernel/NeKit/KString.h
@@ -12,52 +12,52 @@
 #include <NeKit/KernelPanic.h>
 #include <NeKit/Utils.h>
 
-#define kMinimumStringSize (8196U)
-
 namespace Kernel {
+inline auto kMinimumStringSize = 8196;
+
 /// @brief Kernel string class, not dynamic.
-template <SizeT MinSz = kMinimumStringSize>
-class BasicKString final {
+template <typename CharKind = Char>
+class KBasicString final {
  public:
-  explicit BasicKString() {
-    fDataSz = MinSz;
+  explicit KBasicString() {
+    fDataSz = kMinimumStringSize;
 
-    fData = new Char[fDataSz];
+    fData = new CharKind[fDataSz];
     MUST_PASS(fData);
 
     rt_set_memory(fData, 0, fDataSz);
   }
 
-  explicit BasicKString(SizeT Sz) : fDataSz(Sz) {
+  explicit KBasicString(SizeT Sz) : fDataSz(Sz) {
     MUST_PASS(Sz > 1);
 
-    fData = new Char[Sz];
+    fData = new CharKind[Sz];
     MUST_PASS(fData);
 
     rt_set_memory(fData, 0, Sz);
   }
 
-  ~BasicKString() {
+  ~KBasicString() {
     if (fData) {
       delete[] fData;
       fData = nullptr;
     }
   }
 
-  NE_COPY_DEFAULT(BasicKString)
+  NE_COPY_DEFAULT(KBasicString)
 
-  Char*       Data();
-  const Char* CData() const;
-  Size        Length() const;
+  CharKind*       Data();
+  const CharKind* CData() const;
+  Size            Length() const;
 
-  bool operator==(const Char* rhs) const;
-  bool operator!=(const Char* rhs) const;
+  bool operator==(const CharKind* rhs) const;
+  bool operator!=(const CharKind* rhs) const;
 
-  bool operator==(const BasicKString<>& rhs) const;
-  bool operator!=(const BasicKString<>& rhs) const;
+  bool operator==(const KBasicString<CharKind>& rhs) const;
+  bool operator!=(const KBasicString<CharKind>& rhs) const;
 
-  BasicKString<>& operator+=(const Char* rhs);
-  BasicKString<>& operator+=(const BasicKString<>& rhs);
+  KBasicString<CharKind>& operator+=(const CharKind* rhs);
+  KBasicString<CharKind>& operator+=(const KBasicString<CharKind>& rhs);
 
   operator const char*() { return fData; }
 
@@ -66,23 +66,26 @@ class BasicKString final {
   bool operator!() { return fData; }
 
  private:
-  Char* fData{nullptr};
-  Size  fDataSz{0};
-  Size  fCur{0};
+  CharKind* fData{nullptr};
+  Size      fDataSz{0};
+  Size      fCur{0};
 
   friend class KStringBuilder;
 };
 
-using KString   = BasicKString<>;
+using KString   = KBasicString<>;
 using KStringOr = ErrorOr<KString>;
 
 class KStringBuilder final {
  public:
-  static ErrorOr<KString> Construct(const Char* data);
-  static const Char*      FromBool(const Char* fmt, bool n);
-  static const Char*      Format(const Char* fmt, const Char* from);
-  static bool             Equals(const Char* lhs, const Char* rhs);
-  static bool             Equals(const Utf8Char* lhs, const Utf8Char* rhs);
+  template <typename CharKind = Char>
+  static ErrorOr<KBasicString<CharKind>> Construct(const CharKind* data);
+  template <typename CharKind = Char>
+  static const CharKind* FromBool(const CharKind* fmt, bool n);
+  template <typename CharKind = Char>
+  static const CharKind* Format(const CharKind* fmt, const CharKind* from);
+  template <typename CharKind = Char>
+  static bool Equals(const CharKind* lhs, const CharKind* rhs);
 };
 }  // namespace Kernel