Use string_view for Linda names

3 files changed, 37 insertions, 34 deletions

diff --git a/src/linda.cpp b/src/linda.cpp
index 48da1cf..1916629 100644
--- a/src/linda.cpp
+++ b/src/linda.cpp
@@ -79,10 +79,11 @@ template <bool OPT>
 {
     Linda* const _linda{ ToLinda<OPT>(L_, idx_) };
     if (_linda != nullptr) {
+        std::string_view const _lindaName{ _linda->getName() };
         char _text[128];
         int _len;
-        if (_linda->getName())
-            _len = sprintf(_text, "Linda: %.*s", (int) sizeof(_text) - 8, _linda->getName());
+        if (!_lindaName.empty())
+            _len = sprintf(_text, "Linda: %.*s", (int) sizeof(_text) - 8, _lindaName.data());
         else
             _len = sprintf(_text, "Linda: %p", _linda);
         lua_pushlstring(L_, _text, _len);
@@ -113,37 +114,37 @@ template <bool OPT>
 // have to cast to unsigned long to avoid compilation warnings about loss of data when converting pointer-to-integer
 static constexpr uintptr_t kPointerMagicShift{ 3 };
 
-Linda::Linda(Universe* U_, LindaGroup group_, char const* name_, size_t len_)
+Linda::Linda(Universe* U_, LindaGroup group_, std::string_view const& name_)
 : DeepPrelude{ LindaFactory::Instance }
 , U{ U_ }
 , keeperIndex{ (group_ ? group_ : static_cast<int>(std::bit_cast<uintptr_t>(this) >> kPointerMagicShift)) % U_->keepers->nb_keepers }
 {
-    setName(name_, len_);
+    setName(name_);
 }
 
 // #################################################################################################
 
 Linda::~Linda()
 {
-    if (std::holds_alternative<AllocatedName>(nameVariant)) {
-        AllocatedName& _name = std::get<AllocatedName>(nameVariant);
-        U->internalAllocator.free(_name.name, _name.len);
+    if (std::holds_alternative<std::string_view>(nameVariant)) {
+        std::string_view& _name = std::get<std::string_view>(nameVariant);
+        U->internalAllocator.free(const_cast<char*>(_name.data()), _name.size());
     }
 }
 
 // #################################################################################################
 
-char const* Linda::getName() const
+std::string_view Linda::getName() const
 {
-    if (std::holds_alternative<AllocatedName>(nameVariant)) {
-        AllocatedName const& _name = std::get<AllocatedName>(nameVariant);
-        return _name.name;
+    if (std::holds_alternative<std::string_view>(nameVariant)) {
+        std::string_view const& _name = std::get<std::string_view>(nameVariant);
+        return _name;
     }
     if (std::holds_alternative<EmbeddedName>(nameVariant)) {
         char const* const _name{ std::get<EmbeddedName>(nameVariant).data() };
-        return _name;
+        return std::string_view{ _name, strlen(_name) };
     }
-    return nullptr;
+    return std::string_view{};
 }
 
 // #################################################################################################
@@ -182,22 +183,28 @@ int Linda::ProtectedCall(lua_State* L_, lua_CFunction f_)
 
 // #################################################################################################
 
-void Linda::setName(char const* name_, size_t len_)
+void Linda::setName(std::string_view const& name_)
 {
     // keep default
-    if (!name_ || len_ == 0) {
+    if (name_.empty()) {
         return;
     }
-    ++len_; // don't forget terminating 0
-    if (len_ < kEmbeddedNameLength) {
-        nameVariant.emplace<EmbeddedName>();
-        char* const _name{ std::get<EmbeddedName>(nameVariant).data() };
-        memcpy(_name, name_, len_);
+    size_t const _lenWithTZ{ name_.size() + 1 }; // don't forget terminating 0
+    if (_lenWithTZ < kEmbeddedNameLength) {
+        // grab our internal buffer
+        EmbeddedName& _name = nameVariant.emplace<EmbeddedName>();
+        // copy the string in it
+        memcpy(_name.data(), name_.data(), name_.size());
+        // don't forget terminating 0
+        _name[_lenWithTZ] = 0;
     } else {
-        AllocatedName& _name = std::get<AllocatedName>(nameVariant);
-        _name.name = static_cast<char*>(U->internalAllocator.alloc(len_));
-        _name.len = len_;
-        memcpy(_name.name, name_, len_);
+        // allocate an external buffer
+        char* const _nameBuffer{ static_cast<char*>(U->internalAllocator.alloc(_lenWithTZ)) };
+        // copy the string in it
+        memcpy(_nameBuffer, name_.data(), name_.size());
+        // don't forget terminating 0
+        _nameBuffer[_lenWithTZ] = 0;
+        nameVariant.emplace<std::string_view>(_nameBuffer, name_.size());
     }
 }
 
diff --git a/src/linda.h b/src/linda.h
index 4943197..611008e 100644
--- a/src/linda.h
+++ b/src/linda.h
@@ -7,6 +7,7 @@
 
 #include <array>
 #include <condition_variable>
+#include <string_view>
 #include <variant>
 
 struct Keeper;
@@ -26,13 +27,8 @@ class Linda
     private:
     static constexpr size_t kEmbeddedNameLength = 24;
     using EmbeddedName = std::array<char, kEmbeddedNameLength>;
-    struct AllocatedName
-    {
-        size_t len{ 0 };
-        char* name{ nullptr };
-    };
     // depending on the name length, it is either embedded inside the Linda, or allocated separately
-    std::variant<AllocatedName, EmbeddedName> nameVariant;
+    std::variant<std::string_view, EmbeddedName> nameVariant;
 
     public:
     std::condition_variable readHappened;
@@ -51,7 +47,7 @@ class Linda
     static void operator delete(void* p_) { static_cast<Linda*>(p_)->U->internalAllocator.free(p_, sizeof(Linda)); }
 
     ~Linda();
-    Linda(Universe* U_, LindaGroup group_, char const* name_, size_t len_);
+    Linda(Universe* U_, LindaGroup group_, std::string_view const& name_);
     Linda() = delete;
     // non-copyable, non-movable
     Linda(Linda const&) = delete;
@@ -60,11 +56,11 @@ class Linda
     Linda& operator=(Linda const&&) = delete;
 
     private:
-    void setName(char const* name_, size_t len_);
+    void setName(std::string_view const& name_);
 
     public:
     [[nodiscard]] Keeper* acquireKeeper() const;
-    [[nodiscard]] char const* getName() const;
+    [[nodiscard]] std::string_view getName() const;
     void releaseKeeper(Keeper* keeper_) const;
     [[nodiscard]] static int ProtectedCall(lua_State* L_, lua_CFunction f_);
     [[nodiscard]] Keeper* whichKeeper() const { return U->keepers->nb_keepers ? &U->keepers->keeper_array[keeperIndex] : nullptr; }
diff --git a/src/lindafactory.cpp b/src/lindafactory.cpp
index 015baf4..890cc96 100644
--- a/src/lindafactory.cpp
+++ b/src/lindafactory.cpp
@@ -127,6 +127,6 @@ DeepPrelude* LindaFactory::newDeepObjectInternal(lua_State* L_) const
     // The deep data is allocated separately of Lua stack; we might no longer be around when last reference to it is being released.
     // One can use any memory allocation scheme. Just don't use L's allocF because we don't know which state will get the honor of GCing the linda
     Universe* const _U{ universe_get(L_) };
-    Linda* const _linda{ new (_U) Linda{ _U, _linda_group, _linda_name.data(), _linda_name.size() } };
+    Linda* const _linda{ new (_U) Linda{ _U, _linda_group, _linda_name } };
     return _linda;
 }