refactor: + xo-stringtable2 w/ DString impl

src/stringtable2/CMakeLists.txt

@@ -0,0 +1,28 @@
+# xo-stringtable2/src/stringtable2/CMakeLists.txt
+
+set(SELF_LIB xo_stringtable2)
+set(SELF_SRCS
+    init_stringtable2.cpp
+    stringtable2_register_facets.cpp
+    stringtable2_register_types.cpp
+
+    DString.cpp
+    IGCObject_DString.cpp
+    IPrintable_DString.cpp
+)
+
+xo_add_shared_library4(${SELF_LIB} ${PROJECT_NAME}Targets ${PROJECT_VERSION} 1 ${SELF_SRCS})
+xo_install_include_tree3(include/xo/stringtable2)
+
+# ----------------------------------------------------------------
+# input dependencies
+#
+# NOTE: dependency set here must be kept consistent with
+#       xo-stringtable2/cmake/xo_stringtable2Config.cmake.in
+
+xo_dependency(${SELF_LIB} xo_alloc2)
+xo_dependency(${SELF_LIB} xo_printable2)
+xo_dependency(${SELF_LIB} subsys)
+xo_dependency(${SELF_LIB} indentlog)
+
+# end src/stringtable2/CMakeLists.txt

src/stringtable2/DString.cpp

@@ -0,0 +1,187 @@
+/** @file DString.cpp
+ *
+ *  @author Roland Conybeare, Jan 2026
+ **/
+
+#include "DString.hpp"
+#include <xo/alloc2/Allocator.hpp>
+#include <xo/indentlog/print/pretty.hpp>
+#include <algorithm>
+#include <cstring>
+
+namespace xo {
+    using xo::reflect::typeseq;
+    using xo::print::ppdetail_atomic;
+
+    namespace scm {
+        DString *
+        DString::empty(obj<AAllocator> mm,
+                       size_type cap)
+        {
+            assert(cap > 0);
+
+            DString * result = nullptr;
+
+            if (cap > 0) {
+                void * mem = mm.alloc(typeseq::id<DString>(),
+                                      sizeof(DString) + cap);
+
+                result = new (mem) DString();
+
+                assert(result);
+
+                result->capacity_ = cap;
+                result->size_ = 0;
+                if (cap > 0) {
+                    result->chars_[0] = '\0';
+                }
+            }
+
+            return result;
+        }
+
+        DString *
+        DString::from_cstr(obj<AAllocator> mm,
+                           const char * cstr)
+        {
+            size_type len = std::strlen(cstr);
+            size_type cap = len + 1;
+
+            void * mem = mm.alloc(typeseq::id<DString>(),
+                                  sizeof(DString) + cap);
+
+            DString * result = new (mem) DString();
+            result->capacity_ = cap;
+            result->size_ = len;
+            std::memcpy(result->chars_, cstr, cap);
+
+            return result;
+        }
+
+        DString *
+        DString::_from_view_aux(obj<AAllocator> mm,
+                                std::string_view sv,
+                                bool suballoc_flag)
+        {
+            size_type len = sv.size();
+            size_type cap = len + 1;
+
+            auto tseq = typeseq::id<DString>();
+            void * mem = nullptr;
+            size_type mem_z = sizeof(DString) + cap;
+
+            if (suballoc_flag)
+                mem = mm.sub_alloc(mem_z, false /*!complete_flag*/);
+            else
+                mem = mm.alloc(tseq, mem_z);
+
+            DString * result = new (mem) DString();
+
+            result->capacity_ = cap;
+            result->size_ = len;
+            std::memcpy(result->chars_, sv.data(), len);
+            result->chars_[len] = '\0';
+
+            return result;
+        }
+
+        DString *
+        DString::from_view(obj<AAllocator> mm,
+                           std::string_view sv)
+        {
+            return _from_view_aux(mm, sv, false /*!suballoc_flag*/);
+        }
+
+        DString *
+        DString::from_str(obj<AAllocator> mm,
+                          const std::string & str)
+        {
+            return _from_view_aux(mm,
+                                  std::string_view(str),
+                                  false /*!suballoc_flag*/);
+        }
+
+        DString *
+        DString::from_view_suballoc(obj<AAllocator> mm,
+                                    std::string_view sv)
+        {
+            return _from_view_aux(mm, sv, true /*suballoc_flag*/);
+        }
+
+        DString *
+        DString::clone(obj<AAllocator> mm, const DString * src)
+        {
+            size_type cap = src->capacity_;
+
+            void * mem = mm.alloc(typeseq::id<DString>(),
+                                  sizeof(DString) + cap);
+
+            DString * result = new (mem) DString();
+            result->capacity_ = cap;
+            result->size_ = src->size_;
+            std::memcpy(result->chars_, src->chars_, cap);
+
+            return result;
+        }
+
+        DString &
+        DString::assign(const DString & other)
+        {
+            size_type n = std::min(other.size_, capacity_ - 1);
+            std::memcpy(chars_, other.chars_, n);
+            chars_[n] = '\0';
+            size_ = n;
+
+            return *this;
+        }
+
+        int
+        DString::compare(const DString & lhs, const DString & rhs) noexcept
+        {
+            return ::strcmp(lhs.chars_, rhs.chars_);
+        }
+
+        auto
+        DString::fixup_size() noexcept -> size_type
+        {
+            this->chars_[capacity_ - 1] = '\0';
+            this->size_ = ::strlen(chars_);
+            return this->size_;
+        }
+
+        auto
+        DString::shallow_size() const noexcept -> size_type
+        {
+            return sizeof(DString) + capacity_;
+        }
+
+        DString *
+        DString::shallow_copy(obj<AAllocator> mm) const noexcept
+        {
+            DString * copy = (DString *)mm.alloc_copy((std::byte *)this);
+
+            if (copy) {
+                copy->capacity_ = capacity_;
+                copy->size_ = size_;
+                ::memcpy(copy->chars_, chars_, capacity_);
+            }
+
+            return copy;
+        }
+
+        auto
+        DString::forward_children(obj<ACollector>) noexcept -> size_type
+        {
+            return shallow_size();
+        }
+
+        bool
+        DString::pretty(const ppindentinfo & ppii) const
+        {
+            return ppdetail_atomic<const char *>::print_pretty(ppii, &(chars_[0]));
+        }
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end DString.cpp */

src/stringtable2/IGCObject_DString.cpp

@@ -0,0 +1,39 @@
+/** @file IGCObject_DString.cpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/IGCObject_DString.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_any.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/IGCObject_DString.json5]
+**/
+
+#include "string/IGCObject_DString.hpp"
+
+namespace xo {
+    namespace scm {
+        auto
+        IGCObject_DString::shallow_size(const DString & self) noexcept -> size_type
+        {
+            return self.shallow_size();
+        }
+
+        auto
+        IGCObject_DString::shallow_copy(const DString & self, obj<AAllocator> mm) noexcept -> Opaque
+        {
+            return self.shallow_copy(mm);
+        }
+
+        auto
+        IGCObject_DString::forward_children(DString & self, obj<ACollector> gc) noexcept -> size_type
+        {
+            return self.forward_children(gc);
+        }
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end IGCObject_DString.cpp */

src/stringtable2/IPrintable_DString.cpp

@@ -0,0 +1,28 @@
+/** @file IPrintable_DString.cpp
+ *
+ *  Generated automagically from ingredients:
+ *  1. code generator:
+ *       [xo-facet/codegen/genfacet]
+ *     arguments:
+ *       --input [idl/IPrintable_DString.json5]
+ *  2. jinja2 template for abstract facet .hpp file:
+ *       [iface_facet_any.hpp.j2]
+ *  3. idl for facet methods
+ *       [idl/IPrintable_DString.json5]
+**/
+
+#include "string/IPrintable_DString.hpp"
+
+namespace xo {
+    namespace scm {
+        auto
+        IPrintable_DString::pretty(const DString & self, const ppindentinfo & ppii) -> bool
+        {
+            return self.pretty(ppii);
+        }
+
+
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end IPrintable_DString.cpp */

src/stringtable2/init_stringtable2.cpp

@@ -0,0 +1,43 @@
+/** @file init_stringtable2.cpp
+ *
+ *  @author Roland Conybeare, Jan 2026
+ **/
+
+#include "init_stringtable2.hpp"
+#include "stringtable2_register_facets.hpp"
+#include "stringtable2_register_types.hpp"
+#include <xo/stringtable2/init_stringtable2.hpp>
+//n#include <xo/printable2/init_printable2.hpp>
+#include <xo/alloc2/CollectorTypeRegistry.hpp>
+#include <xo/alloc2/init_alloc2.hpp>
+
+namespace xo {
+    using xo::scm::stringtable2_register_facets;
+    using xo::scm::stringtable2_register_types;
+    using xo::mm::CollectorTypeRegistry;
+
+    void
+    InitSubsys<S_stringtable2_tag>::init()
+        {
+            stringtable2_register_facets();
+
+            CollectorTypeRegistry::instance().register_types(&stringtable2_register_types);
+        }
+
+    InitEvidence
+    InitSubsys<S_stringtable2_tag>::require()
+        {
+            InitEvidence retval;
+
+            /* direct subsystem deps for xo-stringtable2/ */
+            retval ^= InitSubsys<S_alloc2_tag>::require();
+            //retval ^= InitSubsys<S_printable_tag>::require();
+
+            /* xo-expression2/'s own initialization code */
+            retval ^= Subsystem::provide<S_stringtable2_tag>("stringtable2", &init);
+
+            return retval;
+        }
+} /*namespace xo*/
+
+/* end init_stringtable2.cpp */

src/stringtable2/stringtable2_register_facets.cpp

@@ -0,0 +1,36 @@
+/** @file stringtable2_register_facets.cpp
+ *
+ *  @author Roland Conybeare, Mar 2026
+ **/
+
+#include "stringtable2_register_facets.hpp"
+
+#include <xo/stringtable2/String.hpp>
+
+#include <xo/facet/FacetRegistry.hpp>
+#include <xo/indentlog/scope.hpp>
+
+namespace xo {
+    using xo::print::APrintable;
+    using xo::mm::AGCObject;
+    using xo::scm::DString;
+    using xo::facet::FacetRegistry;
+    using xo::facet::typeseq;
+
+    namespace scm {
+        bool
+        stringtable2_register_facets()
+        {
+            scope log(XO_DEBUG(true));
+
+            FacetRegistry::register_impl<AGCObject, DString>();
+            FacetRegistry::register_impl<APrintable, DString>();
+
+            log && log(xtag("DString.tseq", typeseq::id<DString>()));
+
+            return true;
+        }
+    } /*namespace scm*/
+} /*namespace xo*/
+
+/* end stringtable2_register_facets.cpp */

src/stringtable2/stringtable2_register_types.cpp

@@ -0,0 +1,33 @@
+/** @file stringtable2_register_types.cpp
+ *
+ *  @author Roland Conybeare, Mar 2026
+ **/
+
+#include "stringtable2_register_types.hpp"
+#include "String.hpp"
+
+//#include <xo/facet/FacetRegistry.hpp>
+#include <xo/indentlog/scope.hpp>
+
+namespace xo {
+    using xo::mm::ACollector;
+    using xo::mm::AGCObject;
+    using xo::facet::impl_for;
+    using xo::scope;
+
+    namespace scm {
+        bool
+        stringtable2_register_types(obj<ACollector> gc)
+        {
+            scope log(XO_DEBUG(true));
+
+            bool ok = true;
+
+            ok &= gc.install_type(impl_for<AGCObject, DString>());
+
+            return ok;
+        }
+    }
+} /*namespace xo*/
+
+/* end stringtable2_register_types.cpp */