模块契约Value

容器与所有权

Capacity 和 Reserve 适用于 Array、Set 和 Object。树形 IntMap 没有可承诺的 连续容量,调用二者报告 XERR_UNSUPPORTED;Trim 和 Clear 支持四种容器。 需要取得 IntMap 实际释放的空闲页数时使用 xrtValueIntMapTrim,并可显式保留 指定数量的空闲节点。

xrtValueObjectLifo 创建与普通 Object 完全相同的字符串键对象,但在 Clear 或 最后一个共享 backing 释放时,按键的当前插入顺序逆序释放仍由对象拥有的值。它用于 类字段、资源作用域等必须按构造逆序析构的场景。读取、ObjectAt、迭代和序列化顺序 仍是正向首次插入顺序;替换或删除会立即释放旧值,Take 会立即移交值。替换不改变 键位置,删除后重新插入则作为新的尾部键。Clone、写时复制、深克隆和以该对象为 目标的失败原子批量操作始终保留该析构策略。

每个写入操作有三种所有权手感:

  • Append/Set/Add:成功时增加传入值引用。
  • ...Take:只在成功时移交并清空来源指针。
  • ...New:无论成功失败都消费临时值,适合 xrtValueObjectSetNew(obj, key, xrtValueInt(200))。

容器 Take 的来源槽必须是独立 xvalue* 变量,不能覆盖目标或来源 Value 外壳。 失败保持来源槽不变;New 明确放弃这一回滚能力并始终消费临时值。

同一个值覆盖同一个 Array 槽、IntMap 键或 Object 键是成功的无操作:借用写入不会增加净引用,Take 写入会消费调用方移交的那一个额外引用。失败的 Take 保持来源指针不变。

COW 与线程

xrtValueClone 为容器创建独立外壳并共享 backing,复杂度为 O(1)。首次有效写入先浅拷贝 backing,失败时可见内容不变。越界或标量 Edit、同值覆盖、缺失删除、重复 Set 加入、空容器清空和不增加容量的 Reserve 都不会无意义地分离 backing。ArrayEdit、IntMapEdit 和 ObjectEdit 只分离需要修改的嵌套路径。

外壳和 backing 引用计数是原子的,但 Value 容器不内置锁。同一外壳的并发 API 调用、写入和生命周期结束必须由调用方同步;需要多线程独立修改时,先为每个执行者创建 O(1) Clone。句柄策略若可能从不同外壳并发执行,回调本身必须线程安全。

值图禁止形成强引用环,避免引用计数泄漏;共享 DAG 合法。环检测前 32 个唯一 backing 使用栈内去重,大图才按需分配 Set,因此共享子图按唯一 backing 数量线性访问,不会因重复边指数展开。深度超过 XRT_VALUE_DEPTH_MAX、已有递归环或新增反向边报告 XERR_VALUE。具有身份的宿主对象图由独立运行时对象模块处理。

子值 Drop、Value Set 的 Handle Hash/Equal 回调不得重入正在操作的父 Value。父外壳与底层容器在回调期间同时进入忙状态,Clone、读取、写入和再次释放都以 XERR_STATE 拒绝。

错误

错误典型原因
XERR_ARGUMENT空必需参数、非法视图、Take 来源槽自别名、Getter/Hash/索引输出覆盖拥有内存、迭代输出别名、句柄策略不完整
XERR_TYPEGetter 类型不匹配、容器传给标量 Hash/Equal、两个不同句柄缺少结构比较策略
XERR_STATE引用计数耗尽、Hash/Equal/Clone/Drop 回调重入活动 Value、失效迭代器、Clone 回调失败却未报告错误
XERR_MEMORYValue 外壳、字符串、字节、backing、事务准备或大图记忆表分配失败
XERR_RANGE字符串终止字节、容量、负索引解析或容器索引计算溢出
XERR_VALUE值图强引用环、非法已有环或递归深度超过上限
XERR_EXISTS使用 XVALUE_MERGE_ERROR 时映射键冲突
XERR_UNSUPPORTEDIntMap Reserve,或深克隆拥有句柄但策略没有 Clone

完整可执行示例:

  • examples/value/basic/main.c:全部基础标量、Getter、类型查询、Hash 与标量相等。
  • examples/value/ownership/main.c:String/Bytes Take、Retain、Clone 与统一释放。
  • examples/value/handle/main.c:Native Handle 策略、接管、借用、Hash 与相等。
  • examples/value/containers/main.c:Array、Object、负索引、嵌套 COW 与快照迭代。
  • examples/value/containers/indexed/main.c:IntMap、Set、数值等价和 Take 所有权。
  • examples/value/containers/lifo/main.c:LIFO Object 的正向访问与逆序资源析构。
  • examples/value/collections/main.c:Object 覆盖合并、Set 合并与完整关系判断。
  • examples/value/collections/batch/main.c:Array 扩展/连接和 IntMap 冲突策略。
  • examples/value/graph/main.c:DAG 身份保留深克隆、结构相等和修改隔离。

裁剪与依赖

只需要标量、字符串或 native 句柄时不启用 VALUE_CONTAINER。只需要基础增删改查时不启用 VALUE_COLLECTION;数组批量操作、映射合并和 Set 代数可以独立裁掉。

核心契约

对象终结职责由最后一次 backing 原子释放唯一取得,而非各外壳释放前的引用数快照。 带终结器的身份对象被公开迭代器引用时,迭代器同时拥有 backing 和真实来源外壳; End 先清空游标状态、释放 backing 槽,再释放外壳槽,保证最后一次终结获得真实 receiver。普通无终结器 COW 容器仍只拥有 backing,不改变源外壳的弱引用寿命。 拥有图按这两个实际槽分别计边,内部检查用的临时视图不得冒充拥有外壳。

xrtValueObjectFinalizerBindOwned(object, finalize, context, trace, release) 在唯一外壳和 backing 上原子接管上下文,不分配;失败不更改对象、不消费上下文、不调用任何回调。 非空上下文要求显式 Trace。Finalize 先借用对象和字段,全部 backing 字段释放后才 调用 Release 一次。Finalize 内可枚举字段;其新建游标若继续持有 backing,字段及 上下文释放也随之延后,但不会重新运行 Finalize。运行中的终结拒绝图检查。 Release 若释放最后一份代码租约,Release 本身须常驻;XRT 不会自动保活任意回调代码。 旧 FinalizerBind 的回调仍自行管理其上下文,不转成新接口的拥有式接管合同。

  • xvalue 是不透明结构,调用方不得依赖内部布局。
  • NULL 表示失败或缺失,语言 null 使用 xrtValueNull() 单例表示。
  • null 和 bool 是不可变单例;其他值使用原子外壳引用计数。
  • 字符串与字节默认复制;StringTake 和 BytesTake 接管 XRT 分配的内存。
  • Take 的来源指针槽必须独立存在,不能位于准备接管的字符串、字节或句柄内存中。
  • 裸指针不拥有目标;句柄必须提供释放器,策略描述必须比值活得更久。
  • 句柄 Hash 与 Equal 必须同时提供或同时省略;两者必须满足相等值哈希一致。
  • 句柄克隆器失败时必须设置错误,并且不得在输出中遗留资源;未提供克隆器的句柄深拷贝报告 XERR_UNSUPPORTED。
  • Getter 和 Hash 失败时不改输出;输出区间不得覆盖 Value 外壳或其拥有的字符串、字节、句柄首地址。
  • 句柄 Hash、Equal、Clone 和最终释放回调不得读取、保留或再次释放正在参与回调的 Value;这些重入以 XERR_STATE 拒绝。
  • 标量不可变。Retain 共享同一身份,Clone 对标量等价于 Retain。
  • 非静态值可在发布前用 xrtValueTypeIdBind 一次性绑定调用者定义的非零语义类型身份;重复绑定同一值成功,冲突绑定报告 XERR_STATE。该身份随浅克隆和深克隆传播,但不改变 XRT 的类别、相等、哈希或序列化语义。
  • 精确 Getter 不做文本解析或隐式类型转换,类型错误报告 XERR_TYPE。
  • xrtValueHash 只接受可哈希标量,并与数值相等规则保持一致;Pointer 和 Handle 的哈希仅在当前进程内有效,不可持久化或跨进程比较。
  • xrtValueScalarEqual 比较标量内容;字符代码、有符号整数、无符号整数与可无损转换的浮点数按精确数值等价,所有 NaN 互相等价。
  • Value Set 同样接受 XVALUE_CHAR 与完整 XVALUE_UINT;字符 'A'、整数 65、

无符号整数 65 和浮点数 65.0 共用规范哈希,去重时保留首次插入的值类型。 字符 NUL/补充平面码点合法;浅克隆后的增删不会更改原集合。

xrtValueTruthy 使用稳定的动态值真值口径:null、false、数值零、空字符串、空字节和空容器为 false;其他值为 true。Time、Pointer 和 Handle 表示已经存在的值对象,因此即使其内部数值或地址为零也为 true。

字符与拥有图补充合同

以下是现有原生 Value API 的合同,不表示语言标准库公开拥有图或回调接口。

类型

xvaluetype 是稳定的动态值类别,不等同于可扩展的 xrttype 运行时类型描述:

常量含义
XVALUE_INVALID非法类型,只用于报告空指针或无效输入。
XVALUE_NULL语言级 null 单例。
XVALUE_BOOL布尔单例。
XVALUE_INT有符号 64 位整数。
XVALUE_FLOAT双精度浮点数。
XVALUE_STRING允许内嵌零、带额外末尾零的字节字符串。
XVALUE_BYTES不附加文本语义的二进制块。
XVALUE_TIME公元 UTC 毫秒时间。
XVALUE_POINTER不拥有目标的裸指针。
XVALUE_HANDLE由 xvaluehandleops 管理的原生句柄。
XVALUE_ARRAY0 基稠密数组。
XVALUE_INT_MAPint64 键稀疏映射。
XVALUE_SET保持首次插入顺序的标量集合。
XVALUE_OBJECT保持首次插入顺序的字符串键对象。
XVALUE_UINT无符号 64 位整数。
XVALUE_CHAR不可变 Unicode scalar,排除代理项。

标量

字符串视图允许内嵌零,并额外保证 Data[Size] 是零。二进制视图只承诺长度内字节有效。

StringTake 会把缓冲调整到 size + 1 并写入末尾零,失败时来源指针和内容不变。 BytesTake 不增加隐藏终止字节。两者只接受由 XRT 分配器取得的内存;成功后来源 指针被清空,Value 在最后释放时销毁该内存。

xrtValueTypeId 对未绑定值和空指针返回零。xrtValueTypeIdBind 只接受非静态值与 非零身份;调用方必须在把值外壳发布给其他线程之前完成首次绑定。类型身份属于宿主 语义元数据,不会被 XRT 当作结构内容;COW 外壳克隆和 Value Graph 深克隆会保留它。 xrtValueTypeIdRebind 仅供已经完成语义验证的唯一拥有外壳替换身份;冲突的共享外壳 以 XERR_STATE 拒绝,调用方需要先创建独立 COW 外壳,不能重新解释其他持有者的值。

Native Handle

Drop 必须提供,空句柄也会按同一策略进入 Drop。Clone 只供 Value Graph 深克隆 使用;普通 xrtValueClone 只增加不可变句柄 Value 的外壳引用。Hash 和 Equal 可以同时省略,此时句柄不能加入 Value Set,也不能与另一个句柄执行标量或结构 内容比较。直接调用 Hash/Equal 时,正在参与策略回调的 Handle Value 都进入忙状态。

策略结构是不可变静态描述;user_data 与策略生命周期都必须覆盖关联的全部 Value。 只读句柄 Value 可跨线程发布,因此 Hash、Equal 和 Clone 回调若可能并发执行,回调 自身必须线程安全。完整用法见 examples/value/handle/main.c。

快照迭代

xvaluekeytype 说明每次迭代返回的键:

常量xvaluekey 内容
XVALUE_KEY_NONESet 元素没有独立键。
XVALUE_KEY_INDEXArray 使用 Index。
XVALUE_KEY_INTIntMap 使用 Integer。
XVALUE_KEY_STRINGObject 使用借用的 String。

迭代器持有 backing 快照。xrtValueIterBegin 按稳定正序推进;xrtValueIterRBegin 按完全相反的稳定顺序推进。迭代开始后修改原值会触发 COW,旧迭代顺序和借用键仍然有效。Object 字符串键借用快照 backing,迭代结束后失效。键输出不得覆盖迭代器,Begin 输出不得覆盖 Value 外壳;别名错误不会推进快照。Begin 和 RBegin 只能用于未活动或已经 End 的迭代器。该公开层供 JSON、可选数据格式、模板和动态宿主使用,不需要访问任何私有容器结构。

xrtValueIterNext 是不隔离当前错误的最短快速路径,返回空值时调用方需按自身上下文判断结束。需要严格区分结果时使用 xrtValueIterAdvance:XVALUE_ITER_ITEM 表示写出一个借用元素,XVALUE_ITER_END 表示正常结束,XVALUE_ITER_ERROR 表示失败且当前错误已更新。成功项和正常结束均保留调用前已有错误;空指针或未活动迭代器属于错误。

Create/RCreate 提供相同语义的拥有式入口,适合 FFI、语言运行时和不保存公开结构布局的消费者。成功后必须用 xrtValueIterDestroy 结束并释放;Destroy(NULL) 是空操作。栈上固定存储仍优先使用 Begin/End,不会产生一次迭代器分配。

批量操作与集合代数

Array Extend、IntMap/Object Merge 和 Set Merge 都是失败原子操作:全部准备完成后才一次提交,OOM、冲突或环检测失败不会暴露部分结果;来源与目标可以是同一个值。映射合并必须显式选择策略:

  • XVALUE_MERGE_KEEP:保留目标已有值,只加入缺失键。
  • XVALUE_MERGE_REPLACE:来源覆盖已有值,但 Object 中已有键的位置不变。
  • XVALUE_MERGE_ERROR:任一键冲突即报告 XERR_EXISTS,目标保持不变。

Object 的来源新键按来源顺序追加。Set 运算直接复用通用 Set 已压实的失败原子实现:并集保持左集合顺序并追加右侧独有元素;交集和差集保持左集合顺序;对称差集先放左侧独有元素,再放右侧独有元素。IsSubset 和 IsSuperset 支持普通或严格关系判断;IsDisjoint 判断是否没有共同元素;SetEqual 在不启用值图模块时也能直接比较两个标量集合。

空来源批量操作、映射共享同一 backing 且没有实际替换、Set 子集合并和自身 Keep/Replace 合并都是不分配、不分离 backing 的成功操作。空目标接收非空 Array、IntMap、Object 或 Set 时直接共享来源 backing,再由 COW 保证后续修改隔离。Union/Intersection 等同一集合或空集合恒等式也走 O(1) Clone 或直接创建空结果,不复制元素。

Value Set 的 Handle Hash/Equal 策略执行期间,左右 Value 外壳和底层 Set 同时进入忙状态;回调不能读取、Clone、释放或修改任一参与外壳。映射批量提交释放被替换旧值时,目标外壳同样保持忙状态。关系不成立是正常的 false;非法参数、类型、忙状态和分配失败分别报告结构化错误。

值图

深拷贝与源图完全隔离,并保留同一个 Value 外壳在结果图中的共享身份。不同 COW 外壳即使暂时共享 backing,仍表示两个独立的可修改位置,因此分别深克隆。null、 bool 和其他不可变标量只增加引用,复杂度为 O(1) 且不分配;拥有句柄只有提供 Clone 策略时才能深拷贝,避免把同一 native 资源伪装成两个独立所有者。Clone 失败却遗留非空输出时,库会防御性调用 Drop 回收,但回调仍违反契约。

结构相等比较内容而不是共享拓扑:一侧重复引用同一子值、另一侧放置两个内容相等 的独立子值,结果仍然相等。Object 不比较插入顺序,Array 比较顺序,Set 复用通用 Set 的等价元素关系;有符号整数、无符号整数与可无损转换的浮点数仍按精确数值相等。两个不同 Handle 必须 具有相同的策略与 user_data,并提供 Equal,否则报告 XERR_TYPE。

深克隆和结构相等各使用 32 项栈内身份表,小图不会为遍历状态分配;更大的图才按需 创建 Map。深克隆按源 Value 身份去重并保留 DAG,结构相等按已经验证相等的值对去重, 因此共享 DAG 不会按重复路径指数展开。结构相等不修改输入,但大图记忆表可能报告 XERR_MEMORY。从根开始最多访问 XRT_VALUE_DEPTH_MAX 层值;下一层报告 XERR_VALUE。

Handle Clone/Equal 和嵌套 Set 的 Hash/Equal 执行期间,当前 Handle、当前容器以及从 根到当前位置的活动祖先都进入忙状态。回调不得对这些 Value 执行读取、Clone、写入 或释放;同一外壳的跨线程调用仍由调用方同步。

可复制的 backing 生命周期能力

xrtValueObjectLifetimeBindOwned 把不可变上下文交给独立的共享生命周期节点, 不创建终结职责。绑定要求唯一外壳/backing;分配或校验失败不修改对象、不运行 回调、不消费上下文。成功后 backing 拥有该节点,节点拥有上下文及 Trace 描述 的真实强边;非空上下文必须提供 Trace,Release 始终必需。

浅 Clone 共享 backing;COW 分裂、DeepClone 的新 Object backing 各增加一次 生命周期节点引用。节点计数对应实际 backing 边,不把每个别名外壳误算成一个 上下文 owner。Release 仅在最后一个关联 backing 的字段及 finalizer context 全部释放后执行。代码租约适合放在这个节点,普通可复制对象不需要伪造空析构。 回调地址必须保持有效;Release 若可能释放最后代码引用,本身须为常驻函数。

xrtValueObjectConstructionPrepare 标记没有用户析构的普通构造事务;不会使 对象变为禁止 COW 分裂的引用身份。其 pending 状态随普通 backing 分裂/复制 传播,xrtValueObjectConstructionCommit 无分配地提交一次,也可提交通过 FinalizerPrepareOwned 准备的实际析构。原 FinalizerCommit 仍只接受真正的 owned finalizer;有用户终结职责的共享 backing 仍不能分裂或复制该职责。 DeepClone 继承生命周期能力但不复制终结职责,语言的 clone 策略须由上层定义。

空 Object 合并也从目标准备 backing,保留目标生命周期和构造状态,不借来源 backing 的快速路径替换它们。源数据字段仍按正常合并策略复制/共享。 这不是环收集器或原生并发图安全点;字段/构造状态修改及 ownership inspection 继续遵守既有同步要求,独立 backing 对同一生命周期节点的引用释放是原子的。

普通 Value 的物理接管适配器

xrtValueOwnershipAdapterV1 在调用方已持有 ownership freeze 时识别本 XRT 实例的普通 Value 外壳和四类容器 backing。它不调用未知 Count、Trace 或用户 策略,也不读取外部 descriptor 的尾部。自定义 handle、identity、finalizer、 lifetime、构造中对象,以及借用 blob 内存仍返回 NULL;包括上下文为 NULL 但代码来自外部的析构器。弱引用 Handle 是已知内建策略,不提供强拥有边。

适配器遵循 core 中 V1 的完整图保有与两阶段接管合同。普通强引用仍按原语义 保有;Claim 暂时使 WeakRefLock 返回 null,但 WeakRefExpired 仍反映实际强 生命周期。撤销 Restore 后可以重新提升。Clear 提交隔离并按物理 backing 断开元素强边,不经 COW EnsureUnique、不分配,所有目标须仍由事务实际保有。 有外部别名可达的 backing 不得 Clear。Drop 在 freeze 外归还事务引用。

该接口不自动寻找环,也不会把未建模的类析构/原生 callable 默认为空清理。 专项 ownership_adapter_tests 保留了普通终态析构,验证实际 COW 共享、重复边、 弱准入恢复、无分配清理及在回调之前拒绝自定义策略。

显式认证的类与原生 Handle 生命周期

xrtValueObjectOwnershipBindV1 仅接受尚未发布的 prepared 对象,绑定不可变的 xvalueobjectownershipv1 策略身份;收集器必须用同一授权策略调用 xrtValueObjectOwnershipAdapterV1。非空 Trace 并不意味着允许接管。 xrtValueObjectIdentityBindV1 把同一代码生命周期覆盖的 hash/equal 纳入认证; 普通 identity 绑定不会隐式获得这种权限。COW 副本继承实际 lifetime 拥有边。

非终态 Finalize 借用事务实际保有的 receiver,先物理撤销析构职责,再在 freeze 之外调用 FinalizeChecked;返回 false 即失败,即使没有错误对象。终态 RC 路径仍使用 void Finalize,两者必须表达同一语言职责,绝不会各调用一次。 撤销事务不恢复已执行职责;字段与 context/lifetime 在重验证和全部语义析构后 才机械释放。真正的事务 backing Hold 有独立记账,不伪造强计数,也不把它误当 COW 别名;第二个真实外壳/游标仍遵守原有共享与借用 receiver 限制。

xrtValueHandleOwnershipAdapterV1 只识别明确授权的 resident Ops/Trace 对, Clear 隔离实际 payload,Finish 在 freeze 之外运行一次机械 Drop。它不认证 payload 指向的 callable 或任意用户对象;每个传递子节点仍须独立准入。

普通末次释放同样区分物理修改和语义析构:已认证的类先在短 mutation 内归零并 隔离节点,然后在该 scope 外调用真实 receiver 的 Finalize;字段、context、 copyable lifetime 的拥有引用仍保持到各自实际释放边界。原生游标结束先脱离 自己的 backing/receiver 槽,再运行子释放。未知 legacy finalizer/lifetime 不 获得这一认证;外部调用方自己持有的 mutation 不会被库自动暂停。

xrtValueHandleOwnershipBindPhased 是独立的显式末次 Drop 合同,要求不可变的 Ops/Trace 和真实代码生命周期自行协调载荷变化与活动。它与 trace-only 的 xrtValueHandleOwnershipBind 都不自动授权图收集;后者保留保守的 Drop scope。 DeepClone 继承同一 Drop 合同。xruntime 已知 callable/Future Value 包装层使用 phased 绑定,任意 Object/Weak/native 包装策略不会因有 Trace 而自动升级。

普通 String/Bytes 有两种物理拥有形式:xrtValueString/Bytes 把副本内联保存在 同一个 Value 分配中,Take 入口则拥有单独分配。OWNED_DATA 只表示后者,不能 据此拒绝前者。普通适配器识别本实例的内联地址或明确的独立拥有标志,仍不接纳 未知外部借用字节。ownership_adapter_tests 保留原分母,新增 200 个容器图、 1200 个内联/空/Take 的物理字符串和字节值,以及 Clone 后的 2400 个实际拥有槽, 覆盖清理与恢复、精确重复边计数、无分配事务及内存平衡。不可变标量的 Clone 保有原节点,不创建第二个物理节点。

字符与拥有图补充合同

xrtValueChar函数

创建引用数为 1 的不可变 Unicode scalar;用后调用 xrtValueRelease。 零和补充平面合法,代理项及大于 0x10FFFF 的输入返回 NULL/XERR_VALUE; 分配失败返回 NULL/XERR_MEMORY。类别是 XVALUE_CHAR,不是整数隐式转换。

xvalue* xrtValueChar(uint32 iValue)

xrtValueGetChar函数

精确读取 CHAR 的 scalar。整数 65 虽与字符 'A' 数值相等,却不能被此 Getter 读取;类型不符报告 XERR_TYPE。失败不改输出,输出必须是独立有效槽,不能 覆盖 Value 外壳或其拥有内存;同样遵守上述通用 Getter 别名规则。

bool xrtValueGetChar(const xvalue* pValue, uint32* pResult)

xvalueownershiptrace类型

生产者描述隐藏状态中实际拥有的强引用槽,用 visitor 报告边并传播失败。 检查在整个图静止且由调用者保活的情况下进行,不以普通 Trace 回调自动授予 收集资格;不透明 Handle 未提供完整适配时封闭拒绝。

typedef bool(*xvalueownershiptrace)(const xvalue* pValue, xrtownershipvisitor pVisit, ptr pContext)

xvalueobjectfinalizerrelease类型

拥有式终结器在 Finalize 和全部 backing 字段销毁之后恰好调用一次 Release, 释放接管的上下文。若它释放最后一份代码租约,Release 自身必须常驻;XRT 不隐式保活回调代码。失败的 BindOwned 不消费上下文,也不调用此回调。

typedef void(*xvalueobjectfinalizerrelease)(ptr pUserData)

xrtValueOwnership函数

返回检查用的借入身份,不增加引用。调用者必须保活并冻结完整传递拥有图。 外壳拥有一个 backing 引用,backing 拥有元素槽,不将每个 COW 外壳重复算为 元素所有者;普通标量是叶节点。此接口本身不是垃圾收集器。

xrtownershipref xrtValueOwnership(const xvalue* pValue)

xrtValueObjectFinalizerOwnershipBind函数

为已绑定终结器的上下文登记实际强引用槽;在发布之前、外壳与 backing 都唯一 时绑定一次。回调取得真实 FinalizerUserData,不是临时伪造的 Value 外壳。 空上下文不需要适配器;登记的是边元数据,不是回调代码的生命周期租约。

bool xrtValueObjectFinalizerOwnershipBind(xvalue* pObject, xrtownershiptrace pTrace)

xrtValueCursorRCreate函数

创建拥有式反向快照游标,失败返回 NULL 并设置错误。游标保活 backing, 对带终结器的身份对象还保活真实来源外壳;普通 COW 来源外壳不被保活。 推进必须串行且调用期间持有引用;元素/键借入有效期到下次推进或最后释放。

xvaluecursor* xrtValueCursorRCreate(const xvalue* pValue)

xrtValueCursorRelease函数

释放一份游标引用,允许 NULL。最后释放结束快照并销毁游标;调用者不能 在推进进行中释放最后引用,也不能在最后释放后使用借入元素或键。 现有栈迭代器和独占堆迭代器的 ABI、生命周期不因此改变。

void xrtValueCursorRelease(xvaluecursor* pCursor)

xvaluetype类型

动态值类型保持紧凑稳定,语言运行时类型在独立模块扩展。

值语义
XVALUE_INVALID无效
XVALUE_NULL空值
XVALUE_BOOL布尔
XVALUE_INT有符号整数
XVALUE_FLOAT浮点
XVALUE_STRING字符串
XVALUE_BYTESBYTES
XVALUE_TIME时间
XVALUE_POINTERPOINTER
XVALUE_HANDLEHANDLE
XVALUE_ARRAY数组形态
XVALUE_INT_MAP有符号整数映射形态
XVALUE_SET集合形态
XVALUE_OBJECT对象形态
XVALUE_UINT无符号整数
XVALUE_CHARUnicode scalar
typedef enum xvaluetype { XVALUE_INVALID = -1, XVALUE_NULL = 0, XVALUE_BOOL, XVALUE_INT, XVALUE_FLOAT, XVALUE_STRING, XVALUE_BYTES, XVALUE_TIME, XVALUE_POINTER, XVALUE_HANDLE, XVALUE_ARRAY, XVALUE_INT_MAP, XVALUE_SET, XVALUE_OBJECT, XVALUE_UINT, XVALUE_CHAR } xvaluetype;

xvaluehandleops类型

句柄策略是静态不可变描述,其生命周期必须覆盖全部关联值。

字段类型语义
ClonexvaluehandlecloneClone
DropxvaluehandledropDrop
HashxvaluehandlehashHash
EqualxvaluehandleequalEqual
typedef struct xvaluehandleops { xvaluehandleclone Clone; xvaluehandledrop Drop; xvaluehandlehash Hash; xvaluehandleequal Equal; } xvaluehandleops;

xvaluekeytype类型

通用迭代键区分数组索引、稀疏整数键、对象字符串键和无键集合。

值语义
XVALUE_KEY_NONE无
XVALUE_KEY_INDEX索引
XVALUE_KEY_INT有符号整数
XVALUE_KEY_STRING字符串键
typedef enum xvaluekeytype { XVALUE_KEY_NONE = 0, XVALUE_KEY_INDEX, XVALUE_KEY_INT, XVALUE_KEY_STRING } xvaluekeytype;

xvalueiterresult类型

三态推进结果显式区分元素、正常结束和迭代错误。

值语义
XVALUE_ITER_ERROR失败
XVALUE_ITER_ENDEND
XVALUE_ITER_ITEM已产出
typedef enum xvalueiterresult { XVALUE_ITER_ERROR = -1, XVALUE_ITER_END = 0, XVALUE_ITER_ITEM = 1 } xvalueiterresult;

xvaluemergepolicy类型

映射批量合并时对已有键采用明确且互斥的处理策略。

值语义
XVALUE_MERGE_KEEPKEEP
XVALUE_MERGE_REPLACEREPLACE
XVALUE_MERGE_ERROR失败
typedef enum xvaluemergepolicy { XVALUE_MERGE_KEEP = 0, XVALUE_MERGE_REPLACE, XVALUE_MERGE_ERROR } xvaluemergepolicy;

xvalue类型

动态值结构保持不透明,所有权通过 Retain、Release 和 Take 系列表达。 不透明句柄或别名;生命周期与所有权见各使用方 API 节。

typedef struct xvalue xvalue;

xvalueidentityhash类型

语义值哈希器只借用已经绑定 TypeId 的容器值。回调可以通过只读 Value API 观察该值及其字段,也可以递归哈希字段,但不得修改、保留或释放输入值。 回调类型;参数与返回语义见签名及各使用方 API 节。

typedef uint64(*xvalueidentityhash)(const xvalue* pValue, ptr pUserData)

xvalueidentityequal类型

语义值相等器只借用同一 TypeId 和同一策略域中的两个容器值。回调可以 递归比较字段,但不得修改、保留或释放任一输入值。 回调类型;参数与返回语义见签名及各使用方 API 节。

typedef bool(*xvalueidentityequal)( const xvalue* pLeft, const xvalue* pRight, ptr pUserData)

xvaluehandleclone类型

句柄克隆器创建独立句柄;失败时必须设置错误且不得在输出中遗留资源。 回调类型;参数与返回语义见签名及各使用方 API 节。

typedef bool(*xvaluehandleclone)(ptr pHandle, ptr* pClone, ptr pUserData)

xvaluehandledrop类型

句柄释放器销毁 Value 独占的一个句柄。 回调类型;参数与返回语义见签名及各使用方 API 节。

typedef void(*xvaluehandledrop)(ptr pHandle, ptr pUserData)

xvaluehandlehash类型

句柄哈希器必须与相等器成对提供、保持一致且不得重入父 Value。 回调类型;参数与返回语义见签名及各使用方 API 节。

typedef uint64(*xvaluehandlehash)(ptr pHandle, ptr pUserData)

xvaluehandleequal类型

句柄相等器只借用两个句柄,必须与哈希器成对提供且不得重入父 Value。 回调类型;参数与返回语义见签名及各使用方 API 节。

typedef bool(*xvaluehandleequal)(ptr pLeft, ptr pRight, ptr pUserData)

xvalueobjectfinalizer类型

Object finalizers borrow the last live object shell before its owned fields are released. The callback may inspect or mutate fields, but it must not retain, clone or release the borrowed object itself. A finalizer is attached to the shared object backing and therefore runs exactly once, when the final backing owner is released. 回调类型;参数与返回语义见签名及各使用方 API 节。

typedef void(*xvalueobjectfinalizer)(xvalue* pObject, ptr pUserData)
标量

xrtValueNull函数

返回进程期不可变的 null 单例。

xvalue* xrtValueNull()

参数

参数方向约束说明
无参数———
返回值
返回含义失败时状态
非空进程期单例,不必释放—
错误
  • 无 — 单例不失败

范例已编译验证

basic · null 单例

		(xrtValueType(xrtValueNull()) != XVALUE_NULL)

xrtValueBool函数

返回进程期不可变的布尔单例。

xvalue* xrtValueBool(bool bValue)

参数

参数方向约束说明
bValue输入—布尔值
返回值
返回含义失败时状态
非空进程期单例,不必释放—
错误
  • 无 — 单例不失败

范例已编译验证

basic · 布尔单例

	xvalue* pTrue = xrtValueBool(true);

xrtValueInt函数

创建不可变的 64 位整数值。

xvalue* xrtValueInt(int64 iValue)

参数

参数方向约束说明
iValue输入—整数值
返回值
返回含义失败时状态
非空新值(引用 1),用后 xrtValueRelease—
NULL创建失败XERR_MEMORY 等
错误
  • 无 — 标量创建不失败

范例已编译验证

array_tour · 整数

		xvalue* pA = xrtValueInt(1);

xrtValueUInt函数

创建不可变的 64 位无符号整数值。

xvalue* xrtValueUInt(uint64 iValue)

参数

参数方向约束说明
iValue输入—无符号值
返回值
返回含义失败时状态
非空新值(引用 1),用后 xrtValueRelease—
NULL创建失败XERR_MEMORY 等
错误
  • 无 — 标量创建不失败

范例已编译验证

object_tour · 无符号整数

		xvalue* pU = xrtValueUInt(UINT64_C(4294967296));

xrtValueFloat函数

创建不可变的双精度浮点值。

xvalue* xrtValueFloat(double fValue)

参数

参数方向约束说明
fValue输入—浮点值
返回值
返回含义失败时状态
非空新值(引用 1),用后 xrtValueRelease—
NULL创建失败XERR_MEMORY 等
错误
  • 无 — 标量创建不失败

范例已编译验证

basic · 浮点

		xrtValueFloat(2.0),

xrtValueString函数

复制字节并创建带末尾零但允许内嵌零的字符串值。

xvalue* xrtValueString(xstrview Text)

参数

参数方向约束说明
Text输入借用文本视图
返回值
返回含义失败时状态
非空新值(引用 1),用后 xrtValueRelease—
NULL创建失败XERR_MEMORY 等
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_MEMORY — 分配失败

范例已编译验证

array_tour · 字符串

	(void)xrtValueArrayAppendNew(pArray, xrtValueString(SV("a")));

xrtValueStringTake函数

接管 XRT 字符串并清空独立来源槽;来源槽不得位于被接管内存中。

xvalue* xrtValueStringTake(str* pText, size_t iSize)

参数

参数方向约束说明
pText输入/输出非空、独立来源槽拥有的字符串
iSize输入—字节数
返回值
返回含义失败时状态
非空新值(引用 1),用后 xrtValueRelease—
NULL创建失败XERR_MEMORY 等
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_STATE — 所有权或快照状态非法
  • XERR_MEMORY — 分配失败

范例已编译验证

ownership · 接管字符串

	pText = xrtValueStringTake(&sText, 5);

xrtValueBytes函数

复制任意字节并创建二进制值。

xvalue* xrtValueBytes(xbytesview Data)

参数

参数方向约束说明
Data输入借用二进制视图
返回值
返回含义失败时状态
非空新值(引用 1),用后 xrtValueRelease—
NULL创建失败XERR_MEMORY 等
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_MEMORY — 分配失败

范例已编译验证

basic · 二进制

		xrtValueBytes((xbytesview){ arrBytes, sizeof(arrBytes) }),

xrtValueBytesTake函数

接管 XRT 二进制块并清空独立来源槽;来源槽不得位于被接管内存中。

xvalue* xrtValueBytesTake(bytes* pData, size_t iSize)

参数

参数方向约束说明
pData输入/输出非空、独立来源槽拥有的字节块
iSize输入—字节数
返回值
返回含义失败时状态
非空新值(引用 1),用后 xrtValueRelease—
NULL创建失败XERR_MEMORY 等
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_STATE — 所有权或快照状态非法
  • XERR_MEMORY — 分配失败

范例已编译验证

ownership · 接管二进制

	pBytes = xrtValueBytesTake(&pData, 3);

xrtValueTime函数

创建使用 公元 UTC 毫秒表示的时间值。

xvalue* xrtValueTime(xtime Time)

参数

参数方向约束说明
Time输入—公元 UTC 毫秒
返回值
返回含义失败时状态
非空新值(引用 1),用后 xrtValueRelease—
NULL创建失败XERR_MEMORY 等
错误
  • 无 — 标量创建不失败

范例已编译验证

basic · 时间

		xrtValueTime((xtime)1234567),

xrtValuePointer函数

创建不拥有目标生命周期的裸指针值。

xvalue* xrtValuePointer(ptr pPointer)

参数

参数方向约束说明
pPointer输入—指针
返回值
返回含义失败时状态
非空新值(引用 1),用后 xrtValueRelease—
NULL创建失败XERR_MEMORY 等
错误
  • 无 — 标量创建不失败

范例已编译验证

basic · 裸指针

		xrtValuePointer(&iMarker)

xrtValueGetBool函数

精确读取布尔值,类型不匹配时失败。

bool xrtValueGetBool(const xvalue* pValue, bool* pResult)

参数

参数方向约束说明
pValue输入非空、BOOL源值
pResult输出非空接收结果
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配

范例已编译验证

basic · 读布尔

		!xrtValueGetBool(pTrue, &bTrue) ||

xrtValueGetInt函数

精确读取整数值,类型不匹配时失败。

bool xrtValueGetInt(const xvalue* pValue, int64* pResult)

参数

参数方向约束说明
pValue输入非空、INT源值
pResult输出非空接收结果
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配

范例已编译验证

basic · 读整数

		!xrtValueGetInt(arrValues[0], &iVersion) ||

xrtValueGetUInt函数

精确读取无符号整数值,类型不匹配时失败。

bool xrtValueGetUInt(const xvalue* pValue, uint64* pResult)

参数

参数方向约束说明
pValue输入非空、UINT源值
pResult输出非空接收结果
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配

范例已编译验证

object_tour · 读无符号

		(void)xrtValueGetUInt(pU, &uValue);

xrtValueGetFloat函数

精确读取浮点值,类型不匹配时失败。

bool xrtValueGetFloat(const xvalue* pValue, double* pResult)

参数

参数方向约束说明
pValue输入非空、FLOAT源值
pResult输出非空接收结果
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配

范例已编译验证

basic · 读浮点

		!xrtValueGetFloat(arrValues[1], &fVersion) ||

xrtValueGetString函数

借用字符串视图,值释放后视图失效。

bool xrtValueGetString(const xvalue* pValue, xstrview* pResult)

参数

参数方向约束说明
pValue输入非空、STRING源值
pResult输出非空接收视图
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配

范例已编译验证

array_tour · 读字符串

		(void)xrtValueGetString(xrtValueArrayGet(pArray, i), &Text);

xrtValueGetBytes函数

借用二进制视图,值释放后视图失效。

bool xrtValueGetBytes(const xvalue* pValue, xbytesview* pResult)

参数

参数方向约束说明
pValue输入非空、BYTES源值
pResult输出非空接收视图
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配

范例已编译验证

basic · 读二进制

		!xrtValueGetBytes(arrValues[3], &Data) ||

xrtValueGetTime函数

精确读取时间值。

bool xrtValueGetTime(const xvalue* pValue, xtime* pResult)

参数

参数方向约束说明
pValue输入非空、TIME源值
pResult输出非空接收结果
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配

范例已编译验证

basic · 读时间

		!xrtValueGetTime(arrValues[4], &Time) ||

xrtValueGetPointer函数

精确读取不拥有目标的裸指针。

bool xrtValueGetPointer(const xvalue* pValue, ptr* pResult)

参数

参数方向约束说明
pValue输入非空、POINTER源值
pResult输出非空接收指针
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配

范例已编译验证

basic · 读指针

		!xrtValueGetPointer(arrValues[5], &pPointer) ||

xrtValueTruthy函数

按 xlang 语义返回值的真值。

bool xrtValueTruthy(const xvalue* pValue)

参数

参数方向约束说明
pValue输入非空源值
返回值
返回含义失败时状态
true真值—
false非真值—
错误
  • XERR_ARGUMENT — 指针为空或参数非法

范例已编译验证

basic · 真值

		!xrtValueTruthy(arrValues[2]) ||
Native Handle

xrtValueHandleTake函数

接管句柄并清空独立来源槽;Hash 和 Equal 必须同时提供或同时省略。

xvalue* xrtValueHandleTake(ptr* pHandle, const xvaluehandleops* pOps, ptr pUserData)

参数

参数方向约束说明
pHandle输入/输出非空、独立来源槽拥有的句柄
pOps输入同时提供或同时为空句柄策略
pUserData输入任意值策略数据
返回值
返回含义失败时状态
非空新值(引用 1),用后 xrtValueRelease—
NULL创建失败XERR_MEMORY 等
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_VALUE — Hash 与 Equal 只提供一个
  • XERR_STATE — 所有权或快照状态非法

范例已编译验证

containers_lifo · 接管句柄

	pValue = xrtValueHandleTake(&pHandle, &tOps, NULL);

xrtValueGetHandle函数

借用句柄及其策略数据。

bool xrtValueGetHandle(const xvalue* pValue, ptr* pHandle, const xvaluehandleops** pOps, ptr* pUserData)

参数

参数方向约束说明
pValue输入非空、HANDLE源值
pHandle输出允许空接收句柄
pOps输出允许空接收策略表
pUserData输出允许空接收策略数据
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配

范例已编译验证

handle · 借用句柄

		!xrtValueGetHandle(pLeft, &pReadHandle, &pReadOps, NULL) ||

xrtValueTakeHandle函数

取走句柄资源并把所有共享外壳可见的资源状态清空;策略仍保留到值释放。

bool xrtValueTakeHandle(xvalue* pValue, ptr* pHandle)

参数

参数方向约束说明
pValue输入非空、HANDLE源值
pHandle输出非空接收句柄
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_STATE — 句柄已被取走

范例已编译验证

iter_weak · 取走句柄

			xrtValueTakeHandle(pHandleValue, (ptr*)&pBack) &&
Set

xrtValueRetain函数

增加值外壳引用并返回原指针。

xvalue* xrtValueRetain(const xvalue* pValue)

参数

参数方向约束说明
pValue输入非空目标值
返回值
返回含义失败时状态
非空原指针,引用 +1—
NULL参数非法XERR_ARGUMENT
错误
  • XERR_ARGUMENT — 指针为空或参数非法

范例已编译验证

ownership · 外壳引用

	pRetained = xrtValueRetain(pText);

xrtValueRelease函数

释放值外壳引用,允许传入空指针。

void xrtValueRelease(xvalue* pValue)

参数

参数方向约束说明
pValue输入允许空空 = 空操作
返回值
返回含义失败时状态
无引用 -1—
错误
  • 无 — 释放不失败

范例已编译验证

array_tour · 释放引用

		xrtValueRelease(pOwned);

xrtValueClone函数

标量增加引用,容器创建共享 backing 的独立 COW 外壳。

xvalue* xrtValueClone(const xvalue* pValue)

参数

参数方向约束说明
pValue输入非空源值
返回值
返回含义失败时状态
非空新值(引用 1),用后 xrtValueRelease—
NULL创建失败XERR_MEMORY 等
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_MEMORY — 分配失败

范例已编译验证

collections · 浅克隆

	pMerged = xrtValueClone(pLeft);

xrtValueDeepClone函数

递归复制全部可克隆内容。

xvalue* xrtValueDeepClone(const xvalue* pValue)

参数

参数方向约束说明
pValue输入非空源值
返回值
返回含义失败时状态
非空新值(引用 1),用后 xrtValueRelease—
NULL创建失败XERR_MEMORY 等
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_UNSUPPORTED — 含不可克隆的句柄值
  • XERR_MEMORY — 分配失败

范例已编译验证

graph · 深克隆

	pCopy = xrtValueDeepClone(pRoot);

xrtValueClear函数

清空容器并释放其中持有的全部值引用。

bool xrtValueClear(xvalue* pValue)

参数

参数方向约束说明
pValue输入/输出非空、容器目标值
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配

范例已编译验证

array_tour · 清空容器

	xrtValueClear(pArray);

xrtValueReserve函数

保证容器至少可容纳指定数量的元素。

bool xrtValueReserve(xvalue* pValue, size_t iCapacity)

参数

参数方向约束说明
pValue输入/输出非空、容器目标值
iCapacity输入—期望容量
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_RANGE — 容量溢出
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_MEMORY — 分配失败

范例已编译验证

array_tour · 预留容量

	(void)xrtValueReserve(pArray, 100u);

xrtValueTrim函数

释放容器多余容量,保留现有元素。

bool xrtValueTrim(xvalue* pValue)

参数

参数方向约束说明
pValue输入/输出非空、容器目标值
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配

范例已编译验证

array_tour · 收缩容量

	(void)xrtValueTrim(pArray);

xrtValueCount函数

返回任一基础容器的元素数。

size_t xrtValueCount(const xvalue* pValue)

参数

参数方向约束说明
pValue输入非空目标值
返回值
返回含义失败时状态
>= 0元素数—
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配

范例已编译验证

array_tour · 元素数

	for ( size_t i = 0; i < xrtValueCount(pArray); i++ ) {

xrtValueCapacity函数

返回 Array、Set 或 Object 的当前预留容量;IntMap 不承诺连续容量。

size_t xrtValueCapacity(const xvalue* pValue)

参数

参数方向约束说明
pValue输入非空目标值
返回值
返回含义失败时状态
>= 0当前容量—
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配

范例已编译验证

array_tour · 容量查询

	printf("reserved-cap>=%zu", xrtValueCapacity(pArray));

xrtValueArray函数

创建空的稠密动态值数组。

xvalue* xrtValueArray()

参数

参数方向约束说明
无参数———
返回值
返回含义失败时状态
非空新值(引用 1),用后 xrtValueRelease—
NULL创建失败XERR_MEMORY 等
错误
  • XERR_MEMORY — 分配失败

范例已编译验证

array_tour · 创建数组

	xvalue* pArray = xrtValueArray();

xrtValueArrayResolve函数

把现有数组元素的正负索引解析为 0 基位置,失败时保持输出不变。

bool xrtValueArrayResolve(const xvalue* pArray, int64 iIndex, size_t* pResolved)

参数

参数方向约束说明
pArray输入非空、ARRAY目标数组
iIndex输入—正负索引
pResolved输出非空接收 0 基位置
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_RANGE — 索引越界

范例已编译验证

containers · 解析索引

		 !xrtValueArrayResolve(pMutableTags, -1, &iLast) ||

xrtValueArrayGet函数

返回数组指定 0 基索引处借用的值。

xvalue* xrtValueArrayGet(const xvalue* pArray, size_t iIndex)

参数

参数方向约束说明
pArray输入非空、ARRAY目标数组
iIndex输入< 元素数0 基索引
返回值
返回含义失败时状态
非空值借用(来源存活期间有效)—
NULL不存在或越界见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_RANGE — 索引越界

范例已编译验证

array_tour · 按位借用

		(void)xrtValueGetString(xrtValueArrayGet(pArray, i), &Text);

xrtValueArrayAt函数

支持负数倒序索引,越界时返回空指针。

xvalue* xrtValueArrayAt(const xvalue* pArray, int64 iIndex)

参数

参数方向约束说明
pArray输入非空、ARRAY目标数组
iIndex输入—正负索引
返回值
返回含义失败时状态
非空值借用(来源存活期间有效)—
NULL不存在或越界见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_RANGE — 索引越界

范例已编译验证

array_tour · 倒序索引借用

	(void)xrtValueGetString(xrtValueArrayAt(pArray, -1), &Text);

xrtValueArrayEdit函数

返回已经沿 COW 路径分离的可变子容器,标量子项报告类型错误。

xvalue* xrtValueArrayEdit(xvalue* pArray, size_t iIndex)

参数

参数方向约束说明
pArray输入/输出非空、ARRAY目标数组
iIndex输入< 元素数0 基索引
返回值
返回含义失败时状态
非空已分离的可变子容器借用—
NULL标量子项或越界XERR_TYPE / XERR_RANGE
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_RANGE — 索引越界

范例已编译验证

graph · 可变子容器

	pCopyChild = xrtValueArrayEdit(pCopy, 0);

xrtValueArrayAppend函数

增加引用后向数组末尾加入值。

bool xrtValueArrayAppend(xvalue* pArray, const xvalue* pItem)

参数

参数方向约束说明
pArray输入/输出非空、ARRAY目标数组
pItem输入非空要加入的值
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_MEMORY — 分配失败

范例已编译验证

graph · 追加引用

		 !xrtValueArrayAppend(pRoot, pChild) ||

xrtValueArrayAppendTake函数

成功时把来源引用移交给数组并清空来源。

bool xrtValueArrayAppendTake(xvalue* pArray, xvalue** pItem)

参数

参数方向约束说明
pArray输入/输出非空、ARRAY目标数组
pItem输入/输出非空来源槽,成功后清空
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_MEMORY — 分配失败

范例已编译验证

array_tour · 追加移交

		(void)xrtValueArrayAppendTake(pArray, &pB);

xrtValueArrayAppendNew函数

无论成功失败都消费临时值,适合单行构造与加入。

bool xrtValueArrayAppendNew(xvalue* pArray, xvalue* pItem)

参数

参数方向约束说明
pArray输入/输出非空、ARRAY目标数组
pItem输入拥有临时值,总是被消费
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_MEMORY — 分配失败

范例已编译验证

array_tour · 追加消费

	(void)xrtValueArrayAppendNew(pArray, xrtValueString(SV("a")));

xrtValueArrayInsert函数

增加引用后在指定位置插入值。

bool xrtValueArrayInsert(xvalue* pArray, size_t iIndex, const xvalue* pItem)

参数

参数方向约束说明
pArray输入/输出非空、ARRAY目标数组
iIndex输入<= 元素数插入位置
pItem输入非空要插入的值
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_RANGE — 索引越界
  • XERR_MEMORY — 分配失败

范例已编译验证

array_tour · 插入引用

		(void)xrtValueArrayInsert(pArray, 1u, pOwned);   /* 借用 */

xrtValueArrayInsertTake函数

成功时把来源引用移交到指定插入位置。

bool xrtValueArrayInsertTake(xvalue* pArray, size_t iIndex, xvalue** pItem)

参数

参数方向约束说明
pArray输入/输出非空、ARRAY目标数组
iIndex输入<= 元素数插入位置
pItem输入/输出非空来源槽,成功后清空
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_RANGE — 索引越界
  • XERR_MEMORY — 分配失败

范例已编译验证

array_tour · 插入移交

		(void)xrtValueArrayInsertTake(pArray, 1u, &pA);

xrtValueArrayInsertNew函数

无论成功失败都消费临时值并在指定位置插入。

bool xrtValueArrayInsertNew(xvalue* pArray, size_t iIndex, xvalue* pItem)

参数

参数方向约束说明
pArray输入/输出非空、ARRAY目标数组
iIndex输入<= 元素数插入位置
pItem输入拥有临时值,总是被消费
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_RANGE — 索引越界
  • XERR_MEMORY — 分配失败

范例已编译验证

array_tour · 插入消费

		(void)xrtValueArrayInsertNew(pArray, 0u, xrtValueInt(0));

xrtValueArraySet函数

增加引用后替换旧值;同一指针是引用平衡的成功无操作。

bool xrtValueArraySet(xvalue* pArray, size_t iIndex, const xvalue* pItem)

参数

参数方向约束说明
pArray输入/输出非空、ARRAY目标数组
iIndex输入< 元素数0 基索引
pItem输入非空新值
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_RANGE — 索引越界
  • XERR_MEMORY — 分配失败

范例已编译验证

array_tour · 替换引用

		(void)xrtValueArraySet(pArray, 1u, pOwned);      /* 借用替换 */

xrtValueArraySetTake函数

成功时把来源引用移交到指定位置。

bool xrtValueArraySetTake(xvalue* pArray, size_t iIndex, xvalue** pItem)

参数

参数方向约束说明
pArray输入/输出非空、ARRAY目标数组
iIndex输入< 元素数0 基索引
pItem输入/输出非空来源槽,成功后清空
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_RANGE — 索引越界
  • XERR_MEMORY — 分配失败

范例已编译验证

array_tour · 替换移交

		(void)xrtValueArraySetTake(pArray, 1u, &pOwned); /* 移交替换 */

xrtValueArraySetNew函数

无论成功失败都消费临时值并替换指定位置。

bool xrtValueArraySetNew(xvalue* pArray, size_t iIndex, xvalue* pItem)

参数

参数方向约束说明
pArray输入/输出非空、ARRAY目标数组
iIndex输入< 元素数0 基索引
pItem输入拥有临时值,总是被消费
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_RANGE — 索引越界
  • XERR_MEMORY — 分配失败

范例已编译验证

containers · 替换消费

		 !xrtValueArraySetNew(
			pMutableTags,
			iLast,
			xrtValueString(XRT_STR_LITERAL("http"))
		 ) ) {

xrtValueArrayRemove函数

删除数组区间并释放其中的值。

bool xrtValueArrayRemove(xvalue* pArray, size_t iIndex, size_t iCount)

参数

参数方向约束说明
pArray输入/输出非空、ARRAY目标数组
iIndex输入< 元素数区间起点
iCount输入—删除数量
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_RANGE — 索引越界

范例已编译验证

array_tour · 删除区间

	(void)xrtValueArrayRemove(pArray, 1u, 1u);          /* 删掉 x2 */

xrtValueArrayTake函数

从数组移交指定值,调用方获得一个引用。

xvalue* xrtValueArrayTake(xvalue* pArray, size_t iIndex)

参数

参数方向约束说明
pArray输入/输出非空、ARRAY目标数组
iIndex输入< 元素数0 基索引
返回值
返回含义失败时状态
非空移交出的值引用—
NULL越界XERR_RANGE
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_RANGE — 索引越界

范例已编译验证

array_tour · 移交元素

	pTaken = xrtValueArrayTake(pArray, 0u);

xrtValueArrayPop函数

从数组末尾移交一个值。

xvalue* xrtValueArrayPop(xvalue* pArray)

参数

参数方向约束说明
pArray输入/输出非空、ARRAY目标数组
返回值
返回含义失败时状态
非空移交出的值引用—
NULL数组为空XERR_RANGE
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_RANGE — 数组为空

范例已编译验证

array_tour · 弹出末尾

	pTaken = xrtValueArrayPop(pArray);

xrtValueArraySwap函数

交换两个数组元素。

bool xrtValueArraySwap(xvalue* pArray, size_t iLeft, size_t iRight)

参数

参数方向约束说明
pArray输入/输出非空、ARRAY目标数组
iLeft输入< 元素数左索引
iRight输入< 元素数右索引
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_RANGE — 索引越界

范例已编译验证

array_tour · 交换元素

	(void)xrtValueArraySwap(pArray, 2u, 3u);

xrtValueArrayExtend函数

失败原子地把来源数组全部追加到目标数组,允许来源与目标相同。

bool xrtValueArrayExtend(xvalue* pTarget, const xvalue* pSource)

参数

参数方向约束说明
pTarget输入/输出非空、ARRAY目标数组
pSource输入非空、ARRAY来源数组
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_RANGE — 结果尺寸溢出
  • XERR_MEMORY — 分配失败

范例已编译验证

collections_batch · 批量追加

		 !xrtValueArrayExtend(pLeft, pRight) ) {

xrtValueArrayConcat函数

创建按左右顺序连接的新数组。

xvalue* xrtValueArrayConcat(const xvalue* pLeft, const xvalue* pRight)

参数

参数方向约束说明
pLeft输入非空、ARRAY左数组
pRight输入非空、ARRAY右数组
返回值
返回含义失败时状态
非空新值(引用 1),用后 xrtValueRelease—
NULL创建失败XERR_MEMORY 等
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_MEMORY — 分配失败

范例已编译验证

collections_batch · 连接

	pJoined = xrtValueArrayConcat(pLeft, pRight);

xrtValueObject函数

创建保持首次插入顺序的字符串键对象。

xvalue* xrtValueObject()

参数

参数方向约束说明
无参数———
返回值
返回含义失败时状态
非空新值(引用 1),用后 xrtValueRelease—
NULL创建失败XERR_MEMORY 等
错误
  • XERR_MEMORY — 分配失败

范例已编译验证

collections · 创建对象

	xvalue* pDefaults = xrtValueObject();

xrtValueObjectLifo函数

创建保持首次插入顺序、最终按逆插入顺序释放拥有值的字符串键对象。

xvalue* xrtValueObjectLifo()

参数

参数方向约束说明
无参数———
返回值
返回含义失败时状态
非空新值(引用 1),用后 xrtValueRelease—
NULL创建失败XERR_MEMORY 等
错误
  • XERR_MEMORY — 分配失败

范例已编译验证

containers_lifo · 创建 LIFO 对象

	xvalue* pObject = xrtValueObjectLifo();

xrtValueObjectGet函数

返回对象字符串键借用的值,键按完整字节匹配。

xvalue* xrtValueObjectGet(const xvalue* pObject, xstrview Key)

参数

参数方向约束说明
pObject输入非空、OBJECT目标对象
Key输入借用键
返回值
返回含义失败时状态
非空值借用(来源存活期间有效)—
NULL不存在或越界见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • 键缺失返回 NULL 且不设置错误

范例已编译验证

graph · 按键借用

			xrtValueObjectGet(
				pChild,
				XRT_STR_LITERAL("count")
			),

xrtValueObjectAt函数

按首次插入顺序返回借用的键和值;替换已有键不会改变顺序。

xvalue* xrtValueObjectAt(const xvalue* pObject, size_t iIndex, xstrview* pKey)

参数

参数方向约束说明
pObject输入非空、OBJECT目标对象
iIndex输入< 元素数0 基位置
pKey输出允许空接收键视图
返回值
返回含义失败时状态
非空值借用(来源存活期间有效)—
NULL不存在或越界见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_RANGE — 索引越界

范例已编译验证

containers_lifo · 按位借用

		 (xrtValueObjectAt(pObject, 0, &Key) == NULL) ) {

xrtValueObjectEdit函数

返回已经沿 COW 路径分离的可变子容器,标量子项报告类型错误。

xvalue* xrtValueObjectEdit(xvalue* pObject, xstrview Key)

参数

参数方向约束说明
pObject输入/输出非空、OBJECT目标对象
Key输入借用键
返回值
返回含义失败时状态
非空已分离的可变子容器借用—
NULL标量子项或键缺失XERR_TYPE / 不设错
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • 键缺失返回 NULL 且不设置错误

范例已编译验证

containers · 可变子容器

	pMutableTags = xrtValueObjectEdit(
		pCopy,
		XRT_STR_LITERAL("tags")
	);

xrtValueObjectHas函数

判断对象键是否存在。

bool xrtValueObjectHas(const xvalue* pObject, xstrview Key)

参数

参数方向约束说明
pObject输入非空、OBJECT目标对象
Key输入借用键
返回值
返回含义失败时状态
true是存在—
false不是存在—
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配

范例已编译验证

object_tour · 键存在判断

	printf("has=%d ", xrtValueObjectHas(pObject, SV("k")) ? 1 : 0);

xrtValueObjectSet函数

增加引用后设置对象键值;同一指针不分离且保留首次键位置。

bool xrtValueObjectSet(xvalue* pObject, xstrview Key, const xvalue* pItem)

参数

参数方向约束说明
pObject输入/输出非空、OBJECT目标对象
Key输入借用键
pItem输入非空新值
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_MEMORY — 分配失败

范例已编译验证

object_tour · 设置引用

		(void)xrtValueObjectSet(pObject, SV("k"), pOwned);

xrtValueObjectSetTake函数

成功时把来源引用移交到对象键。

bool xrtValueObjectSetTake(xvalue* pObject, xstrview Key, xvalue** pItem)

参数

参数方向约束说明
pObject输入/输出非空、OBJECT目标对象
Key输入借用键
pItem输入/输出非空来源槽,成功后清空
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_MEMORY — 分配失败

范例已编译验证

containers · 设置移交

		 !xrtValueObjectSetTake(
			pResponse,
			XRT_STR_LITERAL("tags"),
			&pTags
		 ) ) {

xrtValueObjectSetNew函数

无论成功失败都消费临时值并设置对象键。

bool xrtValueObjectSetNew(xvalue* pObject, xstrview Key, xvalue* pItem)

参数

参数方向约束说明
pObject输入/输出非空、OBJECT目标对象
Key输入借用键
pItem输入拥有临时值
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_MEMORY — 分配失败

范例已编译验证

collections · 设置消费

		 !xrtValueObjectSetNew(
			pDefaults,
			XRT_STR_LITERAL("timeout"),
			xrtValueInt(30)
		 ) ||

xrtValueObjectRemove函数

删除对象键并释放对应值。

bool xrtValueObjectRemove(xvalue* pObject, xstrview Key)

参数

参数方向约束说明
pObject输入/输出非空、OBJECT目标对象
Key输入借用键
返回值
返回含义失败时状态
true已删除—
false键缺失不设错误
错误
  • 键缺失返回 false 且不设置错误;参数非法 XERR_ARGUMENT

范例已编译验证

object_tour · 删除键

	printf("removed=%d ", xrtValueObjectRemove(pObject, SV("k")) ? 1 : 0);

xrtValueObjectTake函数

移交对象键对应值,缺失时返回空指针。

xvalue* xrtValueObjectTake(xvalue* pObject, xstrview Key)

参数

参数方向约束说明
pObject输入/输出非空、OBJECT目标对象
Key输入借用键
返回值
返回含义失败时状态
非空移交出的值引用—
NULL键缺失不设错误
错误
  • 键缺失返回 NULL 且不设置错误;参数非法 XERR_ARGUMENT

范例已编译验证

object_tour · 移交键值

	pTaken = xrtValueObjectTake(pObject, SV("k2"));

xrtValueObjectMerge函数

按冲突策略失败原子地合并两个对象,并保留目标已有键位置。

bool xrtValueObjectMerge(xvalue* pTarget, const xvalue* pSource, xvaluemergepolicy Policy)

参数

参数方向约束说明
pTarget输入/输出非空、OBJECT目标对象
pSource输入非空、OBJECT来源对象
Policy输入—冲突策略
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_VALUE — 冲突策略拒绝重叠键
  • XERR_MEMORY — 分配失败

范例已编译验证

collections · 合并对象

		 !xrtValueObjectMerge(
			pDefaults,
			pOptions,
			XVALUE_MERGE_REPLACE
		 ) ||

xrtValueObjectFinalizerBindTake函数

消耗一个对象拥有引用,成功绑定后返回同一引用,失败则释放输入并返回 NULL。 失败不安装新回调,也不接管借用上下文;回滚可能执行对象原有的终结器和字段 Drop,原始绑定错误(或调用前已经存在的主错误)不会被这些清理覆盖。 接口不创建额外的上下文分配,也不提供回调代码保活或并发发布安全点。 共享 backing 上的绑定仍按原合同拒绝;不能借此撤销调用方此前已经发布的别名。

xvalue* xrtValueObjectFinalizerBindTake(xvalue* object, xvalueobjectfinalizer finalize, ptr context)

xrtValueObjectFinalizerBind函数

为对象绑定最终释放拥有的值时执行的终化器。

bool xrtValueObjectFinalizerBind(xvalue* pObject, xvalueobjectfinalizer pFinalizer, ptr pUserData)

参数

参数方向约束说明
pObject输入/输出非空、OBJECT目标对象
pFinalizer输入非空终化器
pUserData输入任意值终化器数据
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配

范例已编译验证

iter_weak · 绑定终化器

		(void)xrtValueObjectFinalizerBind(pObject, onFinalize, NULL);

xrtValueIntMap函数

创建空的 int64 键稀疏映射。

xvalue* xrtValueIntMap()

参数

参数方向约束说明
无参数———
返回值
返回含义失败时状态
非空新值(引用 1),用后 xrtValueRelease—
NULL创建失败XERR_MEMORY 等
错误
  • XERR_MEMORY — 分配失败

范例已编译验证

collections_batch · 创建整数映射

	xvalue* pDefaults = xrtValueIntMap();

xrtValueIntMapGet函数

返回稀疏整数键借用的值,缺失是正常结果。

xvalue* xrtValueIntMapGet(const xvalue* pMap, int64 iKey)

参数

参数方向约束说明
pMap输入非空、INT_MAP目标映射
iKey输入—键
返回值
返回含义失败时状态
非空值借用(来源存活期间有效)—
NULL不存在或越界见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • 键缺失返回 NULL 且不设置错误

范例已编译验证

collections_batch · 按键借用

		 !xrtValueGetInt(xrtValueIntMapGet(pDefaults, 1), &iValue) ) {

xrtValueIntMapEdit函数

返回已经沿 COW 路径分离的可变子容器,标量子项报告类型错误。

xvalue* xrtValueIntMapEdit(xvalue* pMap, int64 iKey)

参数

参数方向约束说明
pMap输入/输出非空、INT_MAP目标映射
iKey输入—键
返回值
返回含义失败时状态
非空已分离的可变子容器借用—
NULL标量子项或键缺失XERR_TYPE / 不设错
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • 键缺失返回 NULL 且不设置错误

范例已编译验证

object_tour · 可变子容器

		pSlot = xrtValueIntMapEdit(pMap, 3);

xrtValueIntMapHas函数

判断整数键是否存在。

bool xrtValueIntMapHas(const xvalue* pMap, int64 iKey)

参数

参数方向约束说明
pMap输入非空、INT_MAP目标映射
iKey输入—键
返回值
返回含义失败时状态
true是存在—
false不是存在—
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配

范例已编译验证

object_tour · 键存在判断

	printf("set=%d ", xrtValueIntMapHas(pMap, 2) ? 1 : 0);

xrtValueIntMapSet函数

增加引用后设置整数键值;同一指针是引用平衡的成功无操作。

bool xrtValueIntMapSet(xvalue* pMap, int64 iKey, const xvalue* pItem)

参数

参数方向约束说明
pMap输入/输出非空、INT_MAP目标映射
iKey输入—键
pItem输入非空新值
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_MEMORY — 分配失败

范例已编译验证

object_tour · 设置引用

		(void)xrtValueIntMapSet(pMap, 1, pOwned);

xrtValueIntMapSetTake函数

成功时把来源引用移交到整数键。

bool xrtValueIntMapSetTake(xvalue* pMap, int64 iKey, xvalue** pItem)

参数

参数方向约束说明
pMap输入/输出非空、INT_MAP目标映射
iKey输入—键
pItem输入/输出非空来源槽,成功后清空
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_MEMORY — 分配失败

范例已编译验证

object_tour · 设置移交

		(void)xrtValueIntMapSetTake(pMap, 2, &pOwned);       /* 移交 */

xrtValueIntMapSetNew函数

无论成功失败都消费临时值并设置整数键。

bool xrtValueIntMapSetNew(xvalue* pMap, int64 iKey, xvalue* pItem)

参数

参数方向约束说明
pMap输入/输出非空、INT_MAP目标映射
iKey输入—键
pItem输入拥有临时值
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_MEMORY — 分配失败

范例已编译验证

collections_batch · 设置消费

		 !xrtValueIntMapSetNew(pDefaults, 1, xrtValueInt(30)) ||

xrtValueIntMapRemove函数

删除整数键并释放对应值。

bool xrtValueIntMapRemove(xvalue* pMap, int64 iKey)

参数

参数方向约束说明
pMap输入/输出非空、INT_MAP目标映射
iKey输入—键
返回值
返回含义失败时状态
true已删除—
false键缺失不设错误
错误
  • 键缺失返回 false 且不设置错误;参数非法 XERR_ARGUMENT

范例已编译验证

object_tour · 删除键

	(void)xrtValueIntMapRemove(pMap, 1);

xrtValueIntMapTake函数

移交整数键对应值,缺失时返回空指针。

xvalue* xrtValueIntMapTake(xvalue* pMap, int64 iKey)

参数

参数方向约束说明
pMap输入/输出非空、INT_MAP目标映射
iKey输入—键
返回值
返回含义失败时状态
非空移交出的值引用—
NULL键缺失不设错误
错误
  • 键缺失返回 NULL 且不设置错误;参数非法 XERR_ARGUMENT

范例已编译验证

containers_indexed · 移交键值

	pTaken = xrtValueIntMapTake(pMap, -7);

xrtValueIntMapMerge函数

按冲突策略失败原子地合并两个整数键映射。

bool xrtValueIntMapMerge(xvalue* pTarget, const xvalue* pSource, xvaluemergepolicy Policy)

参数

参数方向约束说明
pTarget输入/输出非空、INT_MAP目标映射
pSource输入非空、INT_MAP来源映射
Policy输入—冲突策略
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_VALUE — 冲突策略拒绝重叠键
  • XERR_MEMORY — 分配失败

范例已编译验证

collections_batch · 合并映射

		 !xrtValueIntMapMerge(
			pDefaults,
			pOverrides,
			XVALUE_MERGE_REPLACE
		 ) ||

xrtValueIntMapTrim函数

释放 IntMap 空闲节点池页并返回实际释放页数。

size_t xrtValueIntMapTrim(xvalue* pMap, size_t iRetainEmpty)

参数

参数方向约束说明
pMap输入/输出非空、INT_MAP目标映射
iRetainEmpty输入—保留页数
返回值
返回含义失败时状态
>= 0实际释放页数—
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配

范例已编译验证

object_tour · 裁剪节点池

	printf("trim=%zu\n", xrtValueIntMapTrim(pMap, 0));
快照迭代

xrtValueIterBegin函数

启动稳定顺序快照;输出不得覆盖 Value,且不能已处于活动状态。

bool xrtValueIterBegin(const xvalue* pValue, xvalueiter* pIterator)

参数

参数方向约束说明
pValue输入非空、容器目标值
pIterator输出非空接收迭代器
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_EXISTS — 迭代器已处于活动状态
  • XERR_MEMORY — 分配失败

范例已编译验证

containers · 启动快照

	if ( !xrtValueIterBegin(pCopy, &tIterator) ) {

xrtValueIterRBegin函数

启动稳定逆序快照;输出不得覆盖 Value,且不能已处于活动状态。

bool xrtValueIterRBegin(const xvalue* pValue, xvalueiter* pIterator)

参数

参数方向约束说明
pValue输入非空、容器目标值
pIterator输出非空接收迭代器
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_EXISTS — 迭代器已处于活动状态
  • XERR_MEMORY — 分配失败

范例已编译验证

iter_weak · 启动逆序快照

		(void)xrtValueIterRBegin(pArray, &rIter);

xrtValueIterNext函数

返回下一借用值及其键;键输出不得覆盖迭代器,正常结束返回空指针。

xvalue* xrtValueIterNext(xvalueiter* pIterator, xvaluekey* pKey)

参数

参数方向约束说明
pIterator输入/输出已启动目标迭代器
pKey输出允许空接收键
返回值
返回含义失败时状态
非空借用值;遍历结束为 NULL—
NULL遍历结束不设错误
错误
  • 遍历结束返回 NULL 且不设置错误;参数非法 XERR_ARGUMENT

范例已编译验证

containers · 下一元素

	while ( (pItem = xrtValueIterNext(&tIterator, &Key)) != NULL ) {

xrtValueIterAdvance函数

三态推进快照;成功项写入借用值,正常结束不设置错误。

xvalueiterresult xrtValueIterAdvance(xvalueiter* pIterator, xvaluekey* pKey, xvalue** ppValue)

参数

参数方向约束说明
pIterator输入/输出已启动目标迭代器
pKey输出允许空接收键
ppValue输出非空接收借用值
返回值
返回含义失败时状态
XVALUE_ITER_ITEM已产出—
XVALUE_ITER_END遍历结束不设错误
XVALUE_ITER_ERROR失败XERR_ARGUMENT / XERR_STATE
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_STATE — 迭代器未启动或已结束

范例已编译验证

iter_weak · 三态推进

		while ( xrtValueIterAdvance(&rIter, &rKey, &pItem) == XVALUE_ITER_ITEM ) {

xrtValueIterEnd函数

结束迭代并释放 backing 快照。

void xrtValueIterEnd(xvalueiter* pIterator)

参数

参数方向约束说明
pIterator输入/输出允许空空 = 空操作
返回值
返回含义失败时状态
无已结束—
错误
  • 无 — 结束不失败

范例已编译验证

containers · 结束快照

	xrtValueIterEnd(&tIterator);

xrtValueIterCreate函数

创建按稳定正序推进的拥有式快照迭代器;调用方必须 Destroy。

xvalueiter* xrtValueIterCreate(const xvalue* pValue)

参数

参数方向约束说明
pValue输入非空、容器目标值
返回值
返回含义失败时状态
非空拥有式迭代器—
NULL创建失败XERR_ARGUMENT 等
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_MEMORY — 分配失败

范例已编译验证

iter_weak · 创建拥有式迭代器

		xvalueiter* pIter = xrtValueIterCreate(pArray);

xrtValueIterRCreate函数

创建按稳定逆序推进的拥有式快照迭代器;调用方必须 Destroy。

xvalueiter* xrtValueIterRCreate(const xvalue* pValue)

参数

参数方向约束说明
pValue输入非空、容器目标值
返回值
返回含义失败时状态
非空拥有式迭代器—
NULL创建失败XERR_ARGUMENT 等
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_MEMORY — 分配失败

范例已编译验证

iter_weak · 创建逆序迭代器

		xvalueiter* pRIter = xrtValueIterRCreate(pArray);

xrtValueIterDestroy函数

结束并释放拥有式迭代器;允许传入空指针。

void xrtValueIterDestroy(xvalueiter* pIterator)

参数

参数方向约束说明
pIterator输入允许空空 = 空操作
返回值
返回含义失败时状态
无已销毁—
错误
  • 无 — 释放不失败

范例已编译验证

iter_weak · 销毁迭代器

		xrtValueIterDestroy(pIter);
批量操作与集合代数

xrtValueSet函数

创建空的可哈希动态值集合。

xvalue* xrtValueSet()

参数

参数方向约束说明
无参数———
返回值
返回含义失败时状态
非空新值(引用 1),用后 xrtValueRelease—
NULL创建失败XERR_MEMORY 等
错误
  • XERR_MEMORY — 分配失败

范例已编译验证

collections · 创建集合

	xvalue* pLeft = xrtValueSet();

xrtValueSetAdd函数

增加引用后把可哈希标量或显式身份容器加入集合。

bool xrtValueSetAdd(xvalue* pSet, const xvalue* pItem)

参数

参数方向约束说明
pSet输入/输出非空、SET目标集合
pItem输入非空要加入的值
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_MEMORY — 分配失败

范例已编译验证

containers_indexed · 加入引用

		 !xrtValueSetAdd(pSet, pQuery) ) {

xrtValueSetAddTake函数

成功时消费来源引用;重复元素同样视为成功。

bool xrtValueSetAddTake(xvalue* pSet, xvalue** pItem)

参数

参数方向约束说明
pSet输入/输出非空、SET目标集合
pItem输入/输出非空来源槽,成功后清空
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_MEMORY — 分配失败

范例已编译验证

set_tour · 加入移交

		(void)xrtValueSetAddTake(pA, &pOwned);

xrtValueSetAddNew函数

无论成功失败都消费临时值并尝试加入集合。

bool xrtValueSetAddNew(xvalue* pSet, xvalue* pItem)

参数

参数方向约束说明
pSet输入/输出非空、SET目标集合
pItem输入拥有临时值,总是被消费
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_MEMORY — 分配失败

范例已编译验证

collections · 加入消费

		 !xrtValueSetAddNew(pLeft, xrtValueString(XRT_STR_LITERAL("read"))) ||

xrtValueSetHas函数

判断等价值是否在集合中。

bool xrtValueSetHas(const xvalue* pSet, const xvalue* pItem)

参数

参数方向约束说明
pSet输入非空、SET目标集合
pItem输入非空查找值
返回值
返回含义失败时状态
true是存在—
false不是存在—
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配

范例已编译验证

containers_indexed · 成员判断

		 !xrtValueSetHas(pSet, pQuery) ) {

xrtValueSetRemove函数

删除等价值并释放集合持有的引用。

bool xrtValueSetRemove(xvalue* pSet, const xvalue* pItem)

参数

参数方向约束说明
pSet输入/输出非空、SET目标集合
pItem输入非空查找值
返回值
返回含义失败时状态
true已删除—
false不存在不设错误
错误
  • 不存在返回 false 且不设置错误;参数非法 XERR_ARGUMENT

范例已编译验证

set_tour · 删除成员

	printf("removed=%d\n", xrtValueSetRemove(pB, xrtValueInt(3)) ? 1 : 0);

xrtValueSetTake函数

移交集合中的规范值,缺失时返回空指针。

xvalue* xrtValueSetTake(xvalue* pSet, const xvalue* pItem)

参数

参数方向约束说明
pSet输入/输出非空、SET目标集合
pItem输入非空查找值
返回值
返回含义失败时状态
非空移交出的值引用—
NULL不存在不设错误
错误
  • 不存在返回 NULL 且不设置错误;参数非法 XERR_ARGUMENT

范例已编译验证

set_tour · 移交成员

	pTaken = xrtValueSetTake(pA, xrtValueInt(2));

xrtValueSetMerge函数

失败原子地把来源集合中的缺失元素追加到目标集合。

bool xrtValueSetMerge(xvalue* pTarget, const xvalue* pSource)

参数

参数方向约束说明
pTarget输入/输出非空、SET目标集合
pSource输入非空、SET来源集合
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_MEMORY — 分配失败

范例已编译验证

collections · 合并集合

		 !xrtValueSetMerge(pMerged, pRight) ||

xrtValueSetEqual函数

判断两个集合是否拥有相同元素。

bool xrtValueSetEqual(const xvalue* pLeft, const xvalue* pRight)

参数

参数方向约束说明
pLeft输入非空、SET左集合
pRight输入非空、SET右集合
返回值
返回含义失败时状态
true是相同—
false不是相同—
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配

范例已编译验证

collections · 集合相等

		 !xrtValueSetEqual(pMerged, pUnion) ) {

xrtValueSetUnion函数

创建两个集合的并集,结果先保持左集合顺序。

xvalue* xrtValueSetUnion(const xvalue* pLeft, const xvalue* pRight)

参数

参数方向约束说明
pLeft输入非空、SET左集合
pRight输入非空、SET右集合
返回值
返回含义失败时状态
非空新值(引用 1),用后 xrtValueRelease—
NULL创建失败XERR_MEMORY 等
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_MEMORY — 分配失败

范例已编译验证

collections · 并集

	pUnion = xrtValueSetUnion(pLeft, pRight);

xrtValueSetIntersection函数

创建两个集合的交集,结果保持左集合顺序。

xvalue* xrtValueSetIntersection(const xvalue* pLeft, const xvalue* pRight)

参数

参数方向约束说明
pLeft输入非空、SET左集合
pRight输入非空、SET右集合
返回值
返回含义失败时状态
非空新值(引用 1),用后 xrtValueRelease—
NULL创建失败XERR_MEMORY 等
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_MEMORY — 分配失败

范例已编译验证

set_tour · 交集

	pResult = xrtValueSetIntersection(pA, pB);

xrtValueSetDifference函数

创建左集合相对右集合的差集。

xvalue* xrtValueSetDifference(const xvalue* pLeft, const xvalue* pRight)

参数

参数方向约束说明
pLeft输入非空、SET左集合
pRight输入非空、SET右集合
返回值
返回含义失败时状态
非空新值(引用 1),用后 xrtValueRelease—
NULL创建失败XERR_MEMORY 等
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_MEMORY — 分配失败

范例已编译验证

set_tour · 差集

	pResult = xrtValueSetDifference(pA, pB);

xrtValueSetSymmetricDifference函数

创建两个集合的对称差集,右侧独有元素追加在左侧独有元素之后。

xvalue* xrtValueSetSymmetricDifference(const xvalue* pLeft, const xvalue* pRight)

参数

参数方向约束说明
pLeft输入非空、SET左集合
pRight输入非空、SET右集合
返回值
返回含义失败时状态
非空新值(引用 1),用后 xrtValueRelease—
NULL创建失败XERR_MEMORY 等
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_MEMORY — 分配失败

范例已编译验证

set_tour · 对称差集

	pResult = xrtValueSetSymmetricDifference(pA, pB);

xrtValueSetIsSubset函数

判断左集合是否为右集合的子集,可选择严格子集。

bool xrtValueSetIsSubset(const xvalue* pLeft, const xvalue* pRight, bool bProper)

参数

参数方向约束说明
pLeft输入非空、SET左集合
pRight输入非空、SET右集合
bProper输入—是否严格
返回值
返回含义失败时状态
true是子集—
false不是子集—
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配

范例已编译验证

set_tour · 子集判断

		xrtValueSetIsSubset(pA, pBig, false) ? 1 : 0,

xrtValueSetIsSuperset函数

判断左集合是否为右集合的超集,可选择严格超集。

bool xrtValueSetIsSuperset(const xvalue* pLeft, const xvalue* pRight, bool bProper)

参数

参数方向约束说明
pLeft输入非空、SET左集合
pRight输入非空、SET右集合
bProper输入—是否严格
返回值
返回含义失败时状态
true是超集—
false不是超集—
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配

范例已编译验证

set_tour · 超集判断

		xrtValueSetIsSuperset(pBig, pSmall, false) ? 1 : 0);

xrtValueSetIsDisjoint函数

判断两个集合是否没有任何共同元素。

bool xrtValueSetIsDisjoint(const xvalue* pLeft, const xvalue* pRight)

参数

参数方向约束说明
pLeft输入非空、SET左集合
pRight输入非空、SET右集合
返回值
返回含义失败时状态
true是无共同元素—
false不是无共同元素—
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配

范例已编译验证

collections · 互斥判断

		 !xrtValueSetIsDisjoint(pLeft, pRight) ) {
值图

xrtValueType函数

返回值类型,空指针返回 INVALID。

xvaluetype xrtValueType(const xvalue* pValue)

参数

参数方向约束说明
pValue输入非空目标值
返回值
返回含义失败时状态
类型枚举当前类型—
错误
  • 无 — 空指针返回 INVALID 不设错

范例已编译验证

basic · 类型查询

		(xrtValueType(arrValues[2]) != XVALUE_STRING) ||

xrtValueTypeName函数

返回稳定的类型名称。

cstr xrtValueTypeName(xvaluetype Type)

参数

参数方向约束说明
Type输入—类型枚举
返回值
返回含义失败时状态
非空静态类型名称—
错误
  • 无 — 纯查询,不设置错误

范例已编译验证

basic · 类型名称

	printf("time type: %s\n", xrtValueTypeName(xrtValueType(arrValues[4])));

xrtValueIs函数

判断值是否具有指定类型。

bool xrtValueIs(const xvalue* pValue, xvaluetype Type)

参数

参数方向约束说明
pValue输入非空目标值
Type输入—类型枚举
返回值
返回含义失败时状态
true是该类型—
false不是该类型—
错误
  • XERR_ARGUMENT — 指针为空或参数非法

范例已编译验证

basic · 类型判断

		!xrtValueIs(arrValues[2], XVALUE_STRING) ||

xrtValueIsNumber函数

判断值是否为整数或浮点数。

bool xrtValueIsNumber(const xvalue* pValue)

参数

参数方向约束说明
pValue输入非空目标值
返回值
返回含义失败时状态
true是数值—
false不是数值—
错误
  • XERR_ARGUMENT — 指针为空或参数非法

范例已编译验证

basic · 数值判断

		!xrtValueIsNumber(arrValues[0]) ||

xrtValueIsContainer函数

判断值是否为四种基础容器之一。

bool xrtValueIsContainer(const xvalue* pValue)

参数

参数方向约束说明
pValue输入非空目标值
返回值
返回含义失败时状态
true是容器—
false不是容器—
错误
  • XERR_ARGUMENT — 指针为空或参数非法

范例已编译验证

basic · 容器判断

		xrtValueIsContainer(arrValues[0]) ||

xrtValueIsWeakRef函数

判断值是否是由 xrtValueWeakRef 创建的弱引用。

bool xrtValueIsWeakRef(const xvalue* pValue)

参数

参数方向约束说明
pValue输入非空目标值
返回值
返回含义失败时状态
true是弱引用—
false不是弱引用—
错误
  • XERR_ARGUMENT — 指针为空或参数非法

范例已编译验证

iter_weak · 弱引用判断

	printf("weak: is=%d", xrtValueIsWeakRef(pWeak) ? 1 : 0);

xrtValueTypeId函数

返回调用者绑定的不透明语义类型身份;未绑定或空指针返回零。

uint64 xrtValueTypeId(const xvalue* pValue)

参数

参数方向约束说明
pValue输入非空目标值
返回值
返回含义失败时状态
>= 0绑定的身份;未绑定为 0—
错误
  • 无 — 纯查询,不设置错误

范例已编译验证

iter_weak · 语义类型身份

			(unsigned long long)xrtValueTypeId(pObject));

xrtValueTypeIdBind函数

为值绑定不透明语义类型身份。

bool xrtValueTypeIdBind(xvalue* pValue, uint64 iTypeId)

参数

参数方向约束说明
pValue输入/输出非空目标值
iTypeId输入非零身份标识
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_VALUE — 身份为零或已绑定

范例已编译验证

iter_weak · 绑定身份

		(void)xrtValueTypeIdBind(pObject, 77u);

xrtValueTypeIdRebind函数

仅在值外壳唯一拥有时,把既有语义类型身份替换为新的非零身份。

bool xrtValueTypeIdRebind(xvalue* pValue, uint64 iTypeId)

参数

参数方向约束说明
pValue输入/输出非空、唯一拥有目标值
iTypeId输入非零新身份
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_STATE — 外壳非唯一拥有
  • XERR_VALUE — 未绑定或新身份为零

范例已编译验证

iter_weak · 重绑身份

		(void)xrtValueTypeIdRebind(pObject, 88u);

xrtValueIdentityBind函数

为容器绑定自定义哈希与相等函数,使其可加入集合。

bool xrtValueIdentityBind(xvalue* pValue, xvalueidentityhash pHash, xvalueidentityequal pEqual, ptr pUserData)

参数

参数方向约束说明
pValue输入/输出非空、容器目标值
pHash输入非空哈希函数
pEqual输入非空相等函数
pUserData输入任意值回调数据
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配
  • XERR_STATE — 容器已绑定或非空

范例已编译验证

iter_weak · 绑定身份函数

				xrtValueIdentityBind(pSet, intHash, intEqual, NULL) ? 1 : 0);

xrtValueHash函数

为可哈希标量或显式身份容器计算一致哈希;指针和句柄哈希只在当前进程内有效。

bool xrtValueHash(const xvalue* pValue, uint64* pHash)

参数

参数方向约束说明
pValue输入非空目标值
pHash输出非空接收哈希
返回值
返回含义失败时状态
true成功—
false失败见错误
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配

范例已编译验证

basic · 一致哈希

		!xrtValueHash(arrValues[0], &iIntHash) ||

xrtValueEqual函数

按数值与标量内容判断相等;不可比较句柄和容器报告类型错误。

bool xrtValueEqual(const xvalue* pLeft, const xvalue* pRight)

参数

参数方向约束说明
pLeft输入非空左值
pRight输入非空右值
返回值
返回含义失败时状态
true是相等—
false不是相等—
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配

范例已编译验证

graph · 深度相等

		 !xrtValueEqual(pRoot, pCopy) ||

xrtValueScalarEqual函数

按标量数值判断相等。

bool xrtValueScalarEqual(const xvalue* pLeft, const xvalue* pRight)

参数

参数方向约束说明
pLeft输入非空左值
pRight输入非空右值
返回值
返回含义失败时状态
true是相等—
false不是相等—
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配

范例已编译验证

basic · 标量相等

		!xrtValueScalarEqual(arrValues[0], arrValues[1]) ||

xrtValueWeakRef函数

为动态 Value 创建一个拥有独立生命周期的弱引用值。

xvalue* xrtValueWeakRef(const xvalue* pTarget)

参数

参数方向约束说明
pTarget输入非空目标值
返回值
返回含义失败时状态
非空新值(引用 1),用后 xrtValueRelease—
NULL创建失败XERR_MEMORY 等
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_STATE — 目标是静态标量单例
  • XERR_MEMORY — 分配失败

范例已编译验证

iter_weak · 创建弱引用

	pWeak = xrtValueWeakRef(pTarget);

xrtValueWeakRefExpired函数

判断弱引用目标是否已经结束强生命周期。

bool xrtValueWeakRefExpired(const xvalue* pWeak)

参数

参数方向约束说明
pWeak输入非空、WEAK弱引用
返回值
返回含义失败时状态
true是过期—
false不是过期—
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配

范例已编译验证

iter_weak · 过期判断

		xrtValueWeakRefExpired(pWeak) ? 1 : 0);

xrtValueWeakRefLock函数

尝试提升弱引用;过期时返回进程期 null 单例。

xvalue* xrtValueWeakRefLock(const xvalue* pWeak)

参数

参数方向约束说明
pWeak输入非空、WEAK弱引用
返回值
返回含义失败时状态
非空提升后的强引用(过期时为 null 单例)—
错误
  • XERR_ARGUMENT — 指针为空或参数非法
  • XERR_TYPE — 值类型与操作不匹配

范例已编译验证

iter_weak · 提升弱引用

	pLocked = xrtValueWeakRefLock(pWeak);
托管快照游标

xvalueobjectownershipdiscoverv1类型

收集器的只读 visitor。Reference 是真实 backing 的借用身份,context 是 该 backing 共享的 lifetime 原始 UserData,最后一参是枚举调用方数据。 true 继续,false 停止;不得把借用身份当作新的强拥有槽。

typedef bool(*xvalueobjectownershipdiscoverv1)(xrtownershipref Reference, const void* pLifetimeContext, ptr pContext)

xrtValueObjectOwnershipDiscoverV1函数

bool xrtValueObjectOwnershipDiscoverV1(const xvalueobjectownershipv1* pExpectedPolicy, xvalueobjectownershipdiscoverv1 pVisit, ptr pContext)

参数

参数方向约束说明
pExpectedPolicy输入非空、有效、不可变、常驻独立批准的精确 descriptor 身份
pVisit输入非空、只读接收每个实际 backing 的借用身份和 lifetime context
pContext输入可空visitor 的调用方上下文
返回值
返回值说明
true完整枚举符合指定 policy 的所有 backing
false参数非法、登记状态不一致或 visitor 拒绝

已调用 visitor 的效果不回滚;失败时必须丢弃部分锚点列表。

错误
  • XERR_ARGUMENT:policy 无效或 visitor 为空。
  • XERR_STATE:登记中的 policy/lifetime 身份不一致。
  • visitor 自身失败的诊断原样保留;仅返回 false 不凭空制造诊断。

范例已编译验证

discovery 在真实独占 freeze 中只读观察, 不收集、不释放节点,也不抵扣引用: 这是收集器的内部支撑接口,不是新的自动 GC 或语言公共容器 API。传入确切、 不可变、常驻的 ownership policy 身份,在调用方保持的独占 ownership freeze 内枚举本 XRT 实例当前登记的物理 Object backing。Reference 和 lifetime 的原始 UserData 都是借用,可能含 NULL context;不会取得引用、构造反向 强边或把这些锚点当作外部根。它们只能用于 snapshot 的 anchors,不能加入 internal slots 抵扣引用。所有传递节点仍须在 Count/Trace 之前逐项准入。 BindV1 才登记;COW/deep-clone 的不同 backing 分别登记,共享外壳不重复。 普通对象和其他 policy 不登记。每个对象 backing 增加两个内部指针,无新 分配;普通未绑定对象不取得登记锁,紧凑 Value 外壳布局和公开 ABI 不变。 登记在 mutation 内用短锁串行链接修改;freeze 内枚举不等待参与者锁。 实际终止释放在自身 scope 外执行子释放之前摘除,Clear 在退休 lifetime context 前摘除。不能只保存创建时 shell 的地址来替代它:原 shell 结束后, 深拷贝 backing 或原生游标仍可能持有共享 lifetime。 pVisit 应只读,可筛选或收集锚点,不得修改/释放节点、执行它们的回调或 破坏 freeze。false 停止枚举,不回滚已经发生的 visitor 效果,不凭空替换 visitor 的错误;调用者必须丢弃部分锚点列表。无效 policy 或 NULL visitor 返回 false 并报告参数错误。运行/终结中的 backing 仍可被发现,但不能因 登记就跳过正式图准入的拒绝边界。未知 policy、任意 lifetime 和子句柄不会 因此得到认证,模块卸载仍需要独立的实际图、销毁计划与代码保活合同。 value_object_discovery_tests 使用两套真实实现布局,覆盖独立 COW/深拷贝、 原 shell 提前结束、两套相同回调但不同 descriptor 身份、真实外部强根、 带 native 拥有字段的脱根循环、完整字段上的一次性语义析构、Clear/abort、 工厂/克隆的完整 OOM 前缀及四个原生线程对 freeze 的竞争。专项脚本保留 既有 construction/copy/publication/finalizer/cursor/adapter 人口,不以原生 测试替代 xlang 的宿主发现接入或实际 TCC 退役证明。

    bool ok=xrtValueObjectOwnershipDiscoverV1(&policy,observe,&result);
补充参考 · 契约见公共头注释

xrtValueOwnershipAdapterV1函数

契约注释见公共头文件。

XRT_API const xrtownershipadapterv1* xrtValueOwnershipAdapterV1(xrtownershipref Reference)

xrtValueObjectOwnershipBindV1函数

契约注释见公共头文件。

XRT_API bool xrtValueObjectOwnershipBindV1(xvalue* pObject, const xvalueobjectownershipv1* pPolicy)

xrtValueObjectIdentityBindV1函数

契约注释见公共头文件。

XRT_API bool xrtValueObjectIdentityBindV1(xvalue* pObject, xvalueidentityhash pHash, xvalueidentityequal pEqual, const xvalueobjectownershipv1* pExpectedPolicy)

xrtValueObjectOwnershipAdapterV1函数

契约注释见公共头文件。

XRT_API const xrtownershipadapterv1* xrtValueObjectOwnershipAdapterV1(xrtownershipref Reference, const xvalueobjectownershipv1* pExpectedPolicy)

xrtValueHandleOwnershipAdapterV1函数

契约注释见公共头文件。

XRT_API const xrtownershipadapterv1* xrtValueHandleOwnershipAdapterV1(xrtownershipref Reference, const xvaluehandleops* pExpectedOps, xvalueownershiptrace pExpectedTrace)

xrtValueHandleOwnershipBind函数

契约注释见公共头文件。

XRT_API bool xrtValueHandleOwnershipBind(xvalue* pValue, xvalueownershiptrace pTrace)

xrtValueHandleOwnershipBindPhased函数

契约注释见公共头文件。

XRT_API bool xrtValueHandleOwnershipBindPhased(xvalue* pValue, xvalueownershiptrace pTrace)

xrtValueObjectFinalizerBindOwned函数

契约注释见公共头文件。

XRT_API bool xrtValueObjectFinalizerBindOwned(xvalue* pObject, xvalueobjectfinalizer pFinalizer, ptr pUserData, xrtownershiptrace pTrace, xvalueobjectfinalizerrelease pRelease)

xrtValueObjectFinalizerPrepareOwned函数

契约注释见公共头文件。

XRT_API bool xrtValueObjectFinalizerPrepareOwned(xvalue* pObject, xvalueobjectfinalizer pFinalizer, ptr pUserData, xrtownershiptrace pTrace, xvalueobjectfinalizerrelease pRelease)

xrtValueObjectFinalizerCommit函数

契约注释见公共头文件。

XRT_API bool xrtValueObjectFinalizerCommit(xvalue* pObject)

xrtValueObjectLifetimeBindOwned函数

契约注释见公共头文件。

XRT_API bool xrtValueObjectLifetimeBindOwned(xvalue* pObject, ptr pUserData, xrtownershiptrace pTrace, xvalueobjectfinalizerrelease pRelease)

xrtValueObjectConstructionPrepare函数

契约注释见公共头文件。

XRT_API bool xrtValueObjectConstructionPrepare(xvalue* pObject)

xrtValueObjectConstructionCommit函数

契约注释见公共头文件。

XRT_API bool xrtValueObjectConstructionCommit(xvalue* pObject)

xrtValueIterOwnership函数

契约注释见公共头文件。

XRT_API xrtownershipref xrtValueIterOwnership(const xvalueiter* pIterator)

xrtValueCursorCreate函数

契约注释见公共头文件。

XRT_API xvaluecursor* xrtValueCursorCreate(const xvalue* pValue)

xrtValueCursorRetain函数

契约注释见公共头文件。

XRT_API xvaluecursor* xrtValueCursorRetain(xvaluecursor* pCursor)

xrtValueCursorAdvance函数

契约注释见公共头文件。

XRT_API xvalueiterresult xrtValueCursorAdvance(xvaluecursor* pCursor, xvaluekey* pKey, xvalue** ppValue)

xrtValueCursorOwnership函数

契约注释见公共头文件。

XRT_API xrtownershipref xrtValueCursorOwnership(const xvaluecursor* pCursor)

xrtValueCursorOwnershipAdapterV1函数

契约注释见公共头文件。

XRT_API const xrtownershipadapterv1* xrtValueCursorOwnershipAdapterV1(xrtownershipref Reference)

常量索引常量

以下常量在本页所属头文件中定义,语义见公共头注释。

常量说明
XRT_VALUE_DEPTH_MAX见头文件注释
XVALUE_ARRAY见头文件注释
XVALUE_BOOL见头文件注释
XVALUE_BYTES见头文件注释
XVALUE_CHAR见头文件注释
XVALUE_FLOAT见头文件注释
XVALUE_HANDLE见头文件注释
XVALUE_INT见头文件注释
XVALUE_INT_MAP见头文件注释
XVALUE_INVALID见头文件注释
XVALUE_ITER_END见头文件注释
XVALUE_ITER_ERROR见头文件注释
XVALUE_ITER_ITEM见头文件注释
XVALUE_KEY_INDEX见头文件注释
XVALUE_KEY_INT见头文件注释
XVALUE_KEY_NONE见头文件注释
XVALUE_KEY_STRING见头文件注释
XVALUE_MERGE_ERROR见头文件注释
XVALUE_MERGE_KEEP见头文件注释
XVALUE_MERGE_REPLACE见头文件注释
XVALUE_NULL见头文件注释
XVALUE_OBJECT见头文件注释
XVALUE_POINTER见头文件注释
XVALUE_SET见头文件注释
XVALUE_STRING见头文件注释
XVALUE_TIME见头文件注释
XVALUE_UINT见头文件注释