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

refactor: move xo::facet::typeseq to xo-reflectutil/

Browse source 
prep for adding xo-arena/
This commit is contained in:
Roland Conybeare 2026-01-05 21:49:33 -05:00
commit ed6c1b05bf
7 changed files with 103 additions and 84 deletions
Download patch file Download diff file Expand all files Collapse all files

2
CMakeLists.txt
View file

@ -77,13 +77,13 @@ set(DOX_EXCLUDE_PATTERNS [=[
add_subdirectory(xo-cmake)
add_subdirectory(xo-facet) # sep iface,data
add_subdirectory(xo-indentlog)
add_subdirectory(xo-reflectutil) # header-only reflect support
add_subdirectory(xo-allocutil)
add_subdirectory(xo-refcnt)
add_subdirectory(xo-subsys)
add_subdirectory(xo-randomgen)
add_subdirectory(xo-flatstring)
add_subdirectory(xo-pyutil)
add_subdirectory(xo-reflectutil)
add_subdirectory(xo-reflect)
add_subdirectory(xo-pyreflect)
add_subdirectory(xo-ratio)

4
xo-facet/CMakeLists.txt
View file

@ -25,6 +25,10 @@ add_subdirectory(utest)
set(SELF_LIB xo_facet)
xo_add_headeronly_library(${SELF_LIB})
# note: dependencies here must coordinate with cmake/xo_facetConfig.cmake.in
xo_headeronly_dependency(${SELF_LIB} xo_reflectutil)
xo_install_library4(${SELF_LIB} ${PROJECT_NAME}Targets)
xo_export_cmake_config(${PROJECT_NAME} ${PROJECT_VERSION} ${PROJECT_NAME}Targets)

4
xo-facet/cmake/xo_facetConfig.cmake.in
View file

@ -1,7 +1,7 @@
@PACKAGE_INIT@
include(CMakeFindDependencyMacro)
#find_dependency(indentlog)
#find_dependency(xo_flatstring)
# note: dependencies here must coordinate with xo-facet/CMakeLists.txt
find_dependency(xo_reflectutil)
include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake")
check_required_components("@PROJECT_NAME@")

80
xo-facet/include/xo/facet/typeseq.hpp
View file

@ -1,87 +1,19 @@
/** @file typeseq.hpp
*
* @brief Re-export typeseq from xo-arena for backwards compatibility
*
* @author Roland Conybeare, Dec 2025
**/
#pragma once
#include <iostream>
#include <cstdint>
#include <xo/reflectutil/typeseq.hpp>
namespace xo {
namespace facet {
/**
* Tag here so we can preserve header-only implementation
* and still have static variable
*/
template<typename Tag = class typeseq_tag>
struct typeseq_impl {
explicit typeseq_impl(int32_t s) : seqno_{s} {}
/** Can't have this be constexpr.
* We need ids in shared libraries to be generated
* at load time to avoid false positives
*
* Return unique id number for each type.
* Numbers are sequentially allocated, so can use
* as vector indices
*
* Conversely note that built-in typeinfo may
* return false negatives across library boundaries
* when using clang.
**/
template <typename T>
static typeseq_impl<Tag> id() {
static bool armed = true;
static int32_t id = 0;
if (armed) {
armed = false;
id = ++s_next_id;
}
return typeseq_impl(id);
}
/** 'anonymous' sentinel type.
* Niche uses for this, e.g. untyped allocator
**/
static typeseq_impl<Tag> anon() {
return typeseq_impl(-1);
}
int32_t seqno() const { return seqno_; }
private:
static int32_t s_next_id;
int32_t seqno_;
};
template <typename Tag>
int32_t typeseq_impl<Tag>::s_next_id = 0;
template <typename Tag>
inline bool
operator==(const typeseq_impl<Tag> & lhs, const typeseq_impl<Tag> & rhs) {
return lhs.seqno() == rhs.seqno();
}
template <typename Tag>
inline bool
operator!=(const typeseq_impl<Tag> & lhs, const typeseq_impl<Tag> & rhs) {
return lhs.seqno() != rhs.seqno();
}
template <typename Tag>
inline std::ostream &
operator<<(std::ostream & s, const typeseq_impl<Tag> & x) {
s << x.seqno();
return s;
}
using typeseq = typeseq_impl<>;
// Re-export from xo::arena namespace
using xo::reflect::typeseq_impl;
using xo::reflect::typeseq;
}
} /*namespace xo*/

2
xo-reflectutil/CMakeLists.txt
View file

@ -39,7 +39,7 @@ xo_export_cmake_config(${PROJECT_NAME} ${PROJECT_VERSION} ${PROJECT_NAME}Targets
# ----------------------------------------------------------------
# dependencies
xo_headeronly_dependency(${SELF_LIB} xo_flatstring)
#xo_headeronly_dependency(${SELF_LIB} xo_flatstring)
#xo_headeronly_dependency(${SELF_LIB} randomgen)
# etc..

7
xo-reflectutil/cmake/xo_reflectutilConfig.cmake.in
View file

@ -6,12 +6,7 @@ include(CMakeFindDependencyMacro)
# must coordinate with xo_dependency() calls
# in xo-reactor/src/reactor/CMakeLists.txt
#
find_dependency(xo_flatstring)
#find_dependency(subsys)
#find_dependency(Eigen3)
#find_dependency(webutil)
#find_dependency(printjson)
#find_dependency(callback)
#find_dependency(xo_flatstring)
include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake")
check_required_components("@PROJECT_NAME@")

88
xo-reflectutil/include/xo/reflectutil/typeseq.hpp Normal file
View file

@ -0,0 +1,88 @@
/** @file typeseq.hpp
*
* @author Roland Conybeare, Dec 2025
**/
#pragma once
#include <iostream>
#include <cstdint>
namespace xo {
namespace reflect {
/**
* Tag here so we can preserve header-only implementation
* and still have static variable
*/
template<typename Tag = class typeseq_tag>
struct typeseq_impl {
explicit typeseq_impl(int32_t s) : seqno_{s} {}
/** Can't have this be constexpr.
* We need ids in shared libraries to be generated
* at load time to avoid false positives
*
* Return unique id number for each type.
* Numbers are sequentially allocated, so can use
* as vector indices
*
* Conversely note that built-in typeinfo may
* return false negatives across library boundaries
* when using clang.
**/
template <typename T>
static typeseq_impl<Tag> id() {
static bool armed = true;
static int32_t id = 0;
if (armed) {
armed = false;
id = ++s_next_id;
}
return typeseq_impl(id);
}
/** 'anonymous' sentinel type.
* Niche uses for this, e.g. untyped allocator
**/
static typeseq_impl<Tag> anon() {
return typeseq_impl(-1);
}
int32_t seqno() const { return seqno_; }
private:
static int32_t s_next_id;
int32_t seqno_;
};
template <typename Tag>
int32_t typeseq_impl<Tag>::s_next_id = 0;
template <typename Tag>
inline bool
operator==(const typeseq_impl<Tag> & lhs, const typeseq_impl<Tag> & rhs) {
return lhs.seqno() == rhs.seqno();
}
template <typename Tag>
inline bool
operator!=(const typeseq_impl<Tag> & lhs, const typeseq_impl<Tag> & rhs) {
return lhs.seqno() != rhs.seqno();
}
template <typename Tag>
inline std::ostream &
operator<<(std::ostream & s, const typeseq_impl<Tag> & x) {
s << x.seqno();
return s;
}
using typeseq = typeseq_impl<>;
} /*namespace reflect*/
} /*namespace xo*/
/* end typeseq.hpp */