tiny.preserves.Records

1/// Returns a namespace of protocol record builders for `Value(D)`. Code whose values hold embedded2/// values of one type calls it once at compile time, for every protocol record builder over those3/// values. `D` has to provide `eql`, `order`, `deinit` and `clone`, or the call is a compile error.4/// Every builder allocates a copy of the label, one label cell and a copy of the field slice, all5/// with `alloc`. The record takes the field values the caller passes, and `deinit` on the record6/// frees the label, the fields and the record's own storage. On failure a builder frees its label7/// and leaves the fields with the caller.8pub fn Records(comptime D: type) type {9    domain_mod.assertIsDomain(D);10    const V = Value(D);11    const H = constructors_mod.Constructors(D);12    return struct {13        fn recordWithSymbol(alloc: Allocator, symbol_name: []const u8, fields: []const V) !V {14            var label = try V.initSymbol(alloc, symbol_name);15            errdefer label.deinit(alloc);16            return try H.record(alloc, label, fields);17        }1819        /// Returns `<Observe pattern observer>`, for code that asks to observe a pattern. For20        /// `AnyEmbedded` values, an observer other than an embedded value is moved into a new cell21        /// and wrapped as an embedded value that owns it. The wrapped observer compares, hashes,22        /// copies and frees through the value it holds. An observer that is already an embedded23        /// value goes in as it is. When the embedded values have a type other than `AnyEmbedded`,24        /// every observer goes in as it is. On failure the call frees the wrapper cell and leaves25        /// `pattern` and `observer` with the caller.26        pub fn observeRecord(alloc: Allocator, pattern: V, observer: V) !V {27            var wrapped_ptr: ?*V = null;28            const obs: V = observer_wrap: {29                if (D == AnyEmbedded) {30                    switch (observer) {31                        .embedded => break :observer_wrap observer,32                        else => {33                            const val_ptr = try alloc.create(V);34                            val_ptr.* = observer;35                            wrapped_ptr = val_ptr;36                            break :observer_wrap V{ .embedded = AnyEmbedded{37                                .value = @ptrCast(val_ptr),38                                .semantic_ops = embedded_mod.parsedEmbeddedOps(V),39                                .deinit_fn = embedded_mod.parsedEmbeddedDeinit(V),40                                .clone_fn = embedded_mod.parsedEmbeddedClone(V),41                            } };42                        },43                    }44                }45                break :observer_wrap observer;46            };47            errdefer if (wrapped_ptr) |ptr| alloc.destroy(ptr);48            return recordWithSymbol(alloc, symbols_mod.SYM_OBSERVE.name, &.{ pattern, obs });49        }5051        /// Returns `<Synced>`, a record with zero fields.52        pub fn syncedRecord(alloc: Allocator) !V {53            return recordWithSymbol(alloc, symbols_mod.SYM_SYNCED.name, &.{});54        }5556        /// Returns `<RequireService name>`.57        pub fn requireServiceRecord(alloc: Allocator, name: V) !V {58            return recordWithSymbol(alloc, symbols_mod.SYM_REQUIRE_SERVICE.name, &.{name});59        }6061        /// Returns `<RunService name>`.62        pub fn runServiceRecord(alloc: Allocator, name: V) !V {63            return recordWithSymbol(alloc, symbols_mod.SYM_RUN_SERVICE.name, &.{name});64        }6566        /// Returns `<ServiceState name state>`.67        pub fn serviceStateRecord(alloc: Allocator, name: V, state: V) !V {68            return recordWithSymbol(alloc, symbols_mod.SYM_SERVICE_STATE.name, &.{ name, state });69        }7071        /// Returns `<ServiceObject name obj>`.72        pub fn serviceObjectRecord(alloc: Allocator, name: V, obj: V) !V {73            return recordWithSymbol(alloc, symbols_mod.SYM_SERVICE_OBJECT.name, &.{ name, obj });74        }7576        /// Returns `<ReactorError stage facet reactor err>`, a record with four fields.77        pub fn reactorErrorRecord(alloc: Allocator, stage: V, facet: V, reactor: V, err: V) !V {78            return recordWithSymbol(alloc, symbols_mod.SYM_REACTOR_ERROR.name, &.{ stage, facet, reactor, err });79        }8081        /// Returns `<EntityRuntime kind observe during>`.82        pub fn entityRuntimeRecord(alloc: Allocator, kind: V, observe: V, during: V) !V {83            return recordWithSymbol(alloc, symbols_mod.SYM_ENTITY_RUNTIME.name, &.{ kind, observe, during });84        }8586        /// Returns `<ServiceDependency depender dependee>`.87        pub fn serviceDependencyRecord(alloc: Allocator, depender: V, dependee: V) !V {88            return recordWithSymbol(alloc, symbols_mod.SYM_SERVICE_DEPENDENCY.name, &.{ depender, dependee });89        }9091        /// Returns `<RestartService name>`.92        pub fn restartServiceRecord(alloc: Allocator, name: V) !V {93            return recordWithSymbol(alloc, symbols_mod.SYM_RESTART_SERVICE.name, &.{name});94        }95    };96}

1pub const Records = records_mod.Records;