roland/xo-umbrella2
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

xo-XXX -> .xo-XXX (prep subrepo)

Browse source
This commit is contained in:
Roland Conybeare 2026-06-06 22:00:54 -04:00
commit cf0bd4d975
2105 changed files with 0 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

134
xo-alloc2/include/xo/alloc2/GCObjectConversion.hpp
View file

@ -1,134 +0,0 @@
/** @file GCObjectConversion.hpp
*
* @author Roland Conybeare, Jan 2026
**/
#pragma once
#include <xo/alloc2/GCObject.hpp>
#include <xo/alloc2/Allocator.hpp>
#include <xo/facet/FacetRegistry.hpp>
#include <xo/facet/obj.hpp>
#include <xo/indentlog/scope.hpp>
namespace xo {
namespace scm {
class GCObjectConversionUtil {
public:
using AGCObject = xo::mm::AGCObject;
using typeseq = xo::reflect::typeseq;
/** helper method fro GCObjectConversion<..>::from_gco()
* on conversion failure
**/
static void _from_gco_fail_aux(obj<AGCObject> gco,
typeseq tseq,
scope * p_log);
};
/** @brief compile-time conversion obj<AGCObject> <-> T
*
* Specialize for each T that participates in conversion.
* Methods here aren't implemented
**/
template <typename T>
class GCObjectConversion {
public:
using AGCObject = xo::mm::AGCObject;
using AAllocator = xo::mm::AAllocator;
/** find gc-aware representation for @p x.
* If necessary allocate from @p mm, but may
* refer to @p x in-place
**/
static obj<AGCObject> to_gco(obj<AAllocator> mm, const T & x);
/** convert to native representation @tparam T from gc-aware
* @p gco. If necessary allocate from @p mm, but
* may instead refer to @p x in-place
**/
static T from_gco(obj<AAllocator> mm, obj<AGCObject> gco);
};
/** Motivating use-case for GCObjectConversion is to transform
* primitive function arguments and results to/from gc-aware
* representation.
*
* However: Schematika also supports runtime polymorphism
* which leads to primitives that expect obj<AFacet> arguments.
*
* Also, Schematika expression parser needs representation for
* expressions, before type unification.
*
* Consider a function like:
* def fact = lambda (n : i64) { if (n <= 0) then 1 else (n * fact(n - 1)); }
* During expression parsing the rhs argument to multiply has unknown type.
* To construct an expression for input to unification will use polymorphic
* binding for multiply primitive, relying on specialization here for
* its implementation.
**/
template <typename AFacet, typename DRepr>
struct GCObjectConversion<obj<AFacet,DRepr>> {
using AGCObject = xo::mm::AGCObject;
using AAllocator = xo::mm::AAllocator;
using FacetRegistry = xo::facet::FacetRegistry;
using DVariantPlaceholder = xo::facet::DVariantPlaceholder;
static obj<AGCObject> to_gco(obj<AAllocator>,
obj<AFacet,DRepr> gco) {
if constexpr (std::is_same_v<AFacet, AGCObject>) {
// trivial conversion!
return gco;
} else if constexpr (std::is_same_v<DRepr, DVariantPlaceholder>) {
// runtime polymorphism
return FacetRegistry::instance().variant<AGCObject,AFacet>(gco);
} else /* DRepr != DVariantPlaceholder */ {
// known content w/ fat object pointer
return obj<AGCObject,DRepr>(gco.data());
}
}
/** Several use cases here:
* 1. runtime polymorphism
* obj<AGCObject,DArray> v(DArray::make(..));
* // from_gco() doesn't know v repr
* auto gc = GCObjectConversion<ASequence,DArray>::from_gco(mm, v);
*
**/
static obj<AFacet,DRepr> from_gco(obj<AAllocator>,
obj<AGCObject> gco) {
scope log(XO_DEBUG(false));
if constexpr (std::is_same_v<AFacet, AGCObject>) {
// Need accurate handling of DVariantPlaceholder.
// runtime type must be some concrete type.
// Only use obj<AFacet,DRepr>::from when DRepr is a concrete type
if constexpr (std::is_same_v<DRepr,DVariantPlaceholder>) {
// At comptime gco has unknown repr. At runtime
// will have some known repr, which assignment here will transfer
return gco;
} else {
// Runtime conversion to concrete type DRepr
auto retval = obj<AFacet,DRepr>::from(gco);
if (!retval) {
GCObjectConversionUtil::_from_gco_fail_aux
(gco, reflect::typeseq::id<DRepr>(), &log);
}
return retval;
}
} else {
// both runtime and comptime polymorphism
// use same path here, since representation of @p gco
// is type-erased here
return FacetRegistry::instance().variant<AFacet,AGCObject>(gco);
}
}
};
} /*namespace scm */
} /*namespace xo*/
/* end GCObjectConversion.hpp */