A11 (C++ runtime)
Native C++ implementation of the A11 streaming action runtime
Loading...
Searching...
No Matches
values.h
Go to the documentation of this file.
1/*
2 * Copyright 2026 The A11 Authors
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef A11_FLOW_VALUES_H_
18#define A11_FLOW_VALUES_H_
19
20#include <cstddef>
21#include <cstdint>
22#include <deque>
23#include <functional>
24#include <memory>
25#include <optional>
26#include <string>
27#include <string_view>
28#include <utility>
29#include <variant>
30#include <vector>
31
32#include <absl/base/nullability.h>
33#include <absl/container/flat_hash_map.h>
34#include <absl/container/inlined_vector.h>
35#include <absl/numeric/int128.h>
36#include <absl/status/status.h>
37#include <absl/status/statusor.h>
38#include <absl/time/time.h>
39#include <absl/types/span.h>
40
41#include "a11/data/types.h"
42#include "a11/flow/pattern.h"
43#include "a11/flow/plan.h"
44#include "a11/flow/syntax.h"
45#include "a11/flow/temporal.h"
46
47namespace a11::flow {
48
49class Value;
50class WindowBuffer;
51
67 public:
68 virtual ~HostObject() = default;
69
71 [[nodiscard]] virtual std::string Tag() const = 0;
73 [[nodiscard]] virtual std::string Text() const = 0;
75 [[nodiscard]] virtual bool Truthy() const = 0;
77 [[nodiscard]] virtual std::optional<size_t> Size() const = 0;
81 [[nodiscard]] virtual Value Field(std::string_view name) const = 0;
83 [[nodiscard]] virtual Value Element(const Value& key) const = 0;
85 [[nodiscard]] virtual std::optional<Value> FindField(
86 std::string_view name) const;
87 [[nodiscard]] virtual std::optional<Value> FindElement(
88 const Value& key) const;
90 [[nodiscard]] virtual bool Equals(const HostObject& other) const = 0;
91};
92
94class NodeReferenceObject final : public HostObject {
95 public:
97 : reference_(std::move(reference)) {}
98
99 [[nodiscard]] const data::NodeRef& reference() const { return reference_; }
100
101 [[nodiscard]] std::string Tag() const override;
102 [[nodiscard]] std::string Text() const override;
103 [[nodiscard]] bool Truthy() const override;
104 [[nodiscard]] std::optional<size_t> Size() const override;
105 [[nodiscard]] Value Field(std::string_view name) const override;
106 [[nodiscard]] Value Element(const Value& key) const override;
107 [[nodiscard]] std::optional<Value> FindField(
108 std::string_view name) const override;
109 [[nodiscard]] bool Equals(const HostObject& other) const override;
110
111 private:
112 data::NodeRef reference_;
113};
114
116class NodeFragmentObject final : public HostObject {
117 public:
119 : fragment_(std::move(fragment)) {}
120
121 [[nodiscard]] const data::NodeFragment& fragment() const { return fragment_; }
122
123 [[nodiscard]] std::string Tag() const override;
124 [[nodiscard]] std::string Text() const override;
125 [[nodiscard]] bool Truthy() const override;
126 [[nodiscard]] std::optional<size_t> Size() const override;
127 [[nodiscard]] Value Field(std::string_view name) const override;
128 [[nodiscard]] Value Element(const Value& key) const override;
129 [[nodiscard]] std::optional<Value> FindField(
130 std::string_view name) const override;
131 [[nodiscard]] bool Equals(const HostObject& other) const override;
132
133 private:
134 data::NodeFragment fragment_;
135};
136
139class Value {
140 public:
141 enum class Kind {
145 kNull,
146 kBool,
147 kInteger,
148 kDouble,
151 kString,
152 kBytes,
153 kList,
154 kObject,
155 kDuration,
156 kTime,
159 kChunk,
160 kHost,
161 };
162
168 class Pairs;
169
170 Value() = default;
171
172 static Value Null() { return {}; }
173
174 static Value Bool(bool value);
175 static Value Integer(std::int64_t value);
176 static Value Double(double value);
177 static Value TypedInteger(absl::uint128 magnitude, bool negative, int bits,
178 bool is_signed);
179 static Value TypedFloat(double value, int bits);
181 static Value String(std::string value);
183 static Value List(std::vector<Value> items);
184 static Value List(std::vector<Value> items, std::string_view element_type);
185 static Value Object(Pairs pairs);
186 static Value Status(absl::Status status, Pairs fields);
187 static Value Option(std::optional<Value> value);
188
189 bool is_option() const { return option_; }
190
191 static Value Duration(absl::Duration value);
192 static Value Time(absl::Time value);
194 static Value Host(std::shared_ptr<const HostObject> object);
196 static Value Of(const syntax::Constant& constant);
197
198 [[nodiscard]] Kind kind() const { return kind_; }
199
200 [[nodiscard]] bool IsNull() const { return kind_ == Kind::kNull; }
201
202 [[nodiscard]] bool IsNumber() const {
203 return kind_ == Kind::kInteger || kind_ == Kind::kDouble ||
204 kind_ == Kind::kTypedInteger || kind_ == Kind::kTypedFloat;
205 }
206
207 [[nodiscard]] bool IsTimelike() const {
208 return kind_ == Kind::kDuration || kind_ == Kind::kTime;
209 }
210
213 [[nodiscard]] bool IsTextlike() const {
214 return kind_ == Kind::kString || kind_ == Kind::kBytes;
215 }
216
217 [[nodiscard]] bool boolean() const;
218
219 [[nodiscard]] std::int64_t integer() const;
220
221 [[nodiscard]] double number() const;
222
223 [[nodiscard]] absl::uint128 magnitude() const;
224
225 [[nodiscard]] bool negative() const { return negative_; }
226
227 [[nodiscard]] bool numeric_signed() const { return numeric_signed_; }
228
229 [[nodiscard]] int numeric_bits() const { return numeric_bits_; }
230
231 [[nodiscard]] bool is_legacy_number() const {
232 return kind_ == Kind::kDouble || legacy_number_;
233 }
234
235 [[nodiscard]] const std::string& text() const;
236
237 [[nodiscard]] const std::vector<Value>& items() const;
238
239 [[nodiscard]] size_t list_size() const;
240
241 [[nodiscard]] Value list_at(size_t index) const;
242
243 [[nodiscard]] bool has_packed_element_type(std::string_view name) const;
244
245 [[nodiscard]] const Pairs& pairs() const;
246
247 [[nodiscard]] const absl::Status* absl_nullable native_status() const;
248
249 [[nodiscard]] absl::Duration duration() const;
250
251 [[nodiscard]] absl::Time time() const;
252
253 [[nodiscard]] const data::Chunk& chunk() const;
254
255 [[nodiscard]] const HostObject& host() const;
256
257 [[nodiscard]] const std::shared_ptr<const HostObject>& host_object() const;
258
260 [[nodiscard]] const Value* absl_nullable Get(std::string_view key) const;
261
263 friend bool operator==(const Value& left, const Value& right);
264
265 private:
266 friend class WindowBuffer;
267 static Value TextValue(Kind kind, std::string value);
268
269 struct StatusPayload;
270 struct PackedList;
271 struct WindowList;
272 using TextPtr = std::shared_ptr<const std::string>;
273 using ListPtr = std::shared_ptr<const std::vector<Value>>;
274 using PackedListPtr = std::shared_ptr<const PackedList>;
275 using WindowListPtr = std::shared_ptr<const WindowList>;
276 using ObjectPtr = std::shared_ptr<const Pairs>;
277 using StatusPtr = std::shared_ptr<const StatusPayload>;
278 using ChunkPtr = std::shared_ptr<const data::Chunk>;
279 using HostPtr = std::shared_ptr<const HostObject>;
280 using Payload =
281 std::variant<std::monostate, bool, std::int64_t, double, absl::uint128,
282 absl::Duration, absl::Time, std::string, TextPtr, ListPtr,
283 PackedListPtr, WindowListPtr, ObjectPtr, StatusPtr, ChunkPtr,
284 HostPtr>;
285
286 Kind kind_ = Kind::kNull;
287 bool option_ = false;
288 bool negative_ = false;
289 bool numeric_signed_ = true;
290 bool legacy_number_ = false;
291 std::uint8_t numeric_bits_ = 0;
292 Payload payload_;
293};
294
297 public:
298 explicit WindowBuffer(size_t width);
299 std::optional<Value> Push(Value value);
300
301 struct Block;
302
303 private:
304 size_t width_;
305 size_t seen_ = 0;
306 std::deque<Value> small_;
307 std::shared_ptr<Block> previous_;
308 std::shared_ptr<Block> current_;
309};
310
312 : public absl::InlinedVector<std::pair<std::string, Value>, 2> {
313 public:
314 using absl::InlinedVector<std::pair<std::string, Value>, 2>::InlinedVector;
315};
316
326 public:
327 virtual ~HostBridge() = default;
328
333 virtual absl::StatusOr<Value> Coerce(std::string_view tag,
334 const Value& value) = 0;
335
337 virtual absl::StatusOr<Value> FromChunk(const data::Chunk& chunk) = 0;
338
340 virtual absl::StatusOr<data::Chunk> ToChunk(const Value& value,
341 std::string_view mimetype) = 0;
342
344 virtual bool CanPassChunkObject(const data::Chunk& chunk,
345 std::string_view declared_type) const;
346
349 virtual std::vector<absl::StatusOr<Value>> FromChunks(
350 absl::Span<const data::Chunk* const> chunks) {
351 std::vector<absl::StatusOr<Value>> values;
352 values.reserve(chunks.size());
353 for (const data::Chunk* chunk : chunks) {
354 {
355 values.push_back(FromChunk(*chunk));
356 }
357 }
358 return values;
359 }
360
364 virtual std::vector<absl::StatusOr<data::Chunk>> ToChunks(
365 absl::Span<const Value* const> values, std::string_view mimetype) {
366 std::vector<absl::StatusOr<data::Chunk>> chunks;
367 chunks.reserve(values.size());
368 for (const Value* value : values) {
369 chunks.push_back(ToChunk(*value, mimetype));
370 }
371 return chunks;
372 }
373
376 virtual absl::StatusOr<Value> Adopt(const DtoPlan& shape,
377 const Program& program,
378 const Value& value) {
379 (void)shape;
380 (void)program;
381 return value;
382 }
383};
384
386std::unique_ptr<HostBridge> NativeHostBridge();
387
388// --- Reading values ----------------------------------------------------------
389
395Value Lookup(const Value& value, const Value& key);
396std::optional<Value> LookupOptional(const Value& value, const Value& key);
397absl::StatusOr<Value> LookupChecked(const Value& value, const Value& key);
398
400bool Truthy(const Value& value);
401
407int Order(const Value& left, const Value& right);
408
414absl::StatusOr<Value> Add(const Value& left, const Value& right);
415
417std::string AsText(const Value& value);
418
422Value AsNumber(const Value& value);
423std::optional<std::int64_t> ExactInt64(const Value& value);
424
435absl::StatusOr<Value> MatchPattern(std::string_view pattern,
436 std::string_view subject);
437
443Value MatchCompiled(const pattern::Pattern& pattern, std::string_view subject);
444
446double AsDouble(const Value& value);
447
449Value AsJson(const Value& value);
450
452Value Truncate(const Value& value, std::int64_t size);
453
455std::string JsonText(const Value& value);
456
457// --- Times and durations -----------------------------------------------------
458
464double DurationSeconds(absl::Duration value);
465
467absl::Duration AsDuration(const Value& value);
468
470absl::Time AsTime(const Value& value);
471
473std::string DurationText(absl::Duration value, std::string_view spec = {});
474
476std::string TimeText(absl::Time value, std::string_view spec = {});
477
478// --- Formatting --------------------------------------------------------------
479
492std::string Strformat(const Value& format, absl::Span<const Value> arguments);
493
494// --- Evaluation --------------------------------------------------------------
495
504 HostBridge* absl_nullable bridge = nullptr;
505 const Program* absl_nullable shapes = nullptr;
507};
508
517 std::string text;
518 size_t index = 0;
519 std::string spec;
520 std::string flags;
521 std::string width;
522 std::optional<std::string> precision;
523 char conversion = 0;
524};
525
526using FormatTemplate = std::vector<FormatPart>;
527FormatTemplate CompileStrformat(std::string_view text);
528std::string StrformatCompiled(const FormatTemplate& format,
529 absl::Span<const Value> arguments);
530
533 absl::flat_hash_map<std::string, pattern::Pattern> patterns;
534 absl::flat_hash_map<std::string, FormatTemplate> formats;
535 absl::flat_hash_map<const syntax::Node*, Value> folded;
536};
537
539 const PreparedExpressions* absl_nullable prepared = nullptr;
540 std::function<absl::StatusOr<std::optional<Value>>(const syntax::Node&)>
542 std::function<absl::StatusOr<Value>(const syntax::Builtin&)> reference;
543 std::function<bool(const syntax::Node&)> is_option;
544 const absl::flat_hash_map<const syntax::Node*, Value>* absl_nullable bound =
545 nullptr;
548 bool has_it = false;
549 HostBridge* absl_nullable bridge = nullptr;
551 const Program* absl_nullable shapes = nullptr;
552
553 [[nodiscard]] CoerceContext Coercion() const { return {bridge, shapes}; }
554};
555
562absl::StatusOr<Value> Evaluate(const syntax::Node& node,
563 const EvalContext& context);
564
571absl::StatusOr<Value> Coerce(const Value& value,
572 const syntax::TypeExpression& type,
573 const CoerceContext& context);
574
589absl::StatusOr<Value> CoerceShape(const DtoPlan& shape, const Value& value,
590 const CoerceContext& context);
591
596absl::StatusOr<Value> CallBuiltin(
597 std::string_view name, absl::Span<const Value> arguments,
598 HostBridge* absl_nullable bridge,
599 const PreparedExpressions* absl_nullable prepared = nullptr);
600
601// --- Statuses as data --------------------------------------------------------
602
608Value StatusRecord(const absl::Status& status);
609
611Value FailureRecord(const absl::Status& status, Value item, std::int64_t seq);
612
614absl::Status StatusOfRecord(const Value& record);
615
621std::optional<absl::StatusCode> StatusCodeOf(const Value& value);
622
623} // namespace a11::flow
624
625#endif // A11_FLOW_VALUES_H_
What the process running a flow knows and the language does not.
Definition values.h:325
virtual std::vector< absl::StatusOr< data::Chunk > > ToChunks(absl::Span< const Value *const > values, std::string_view mimetype)
Chunks holding values, in order, each with its own outcome.
Definition values.h:364
virtual absl::StatusOr< Value > Coerce(std::string_view tag, const Value &value)=0
Make value a value of the type tag names.
virtual ~HostBridge()=default
virtual bool CanPassChunkObject(const data::Chunk &chunk, std::string_view declared_type) const
Whether a typed port can retain this local object without conversion.
Definition values.cc:1408
virtual std::vector< absl::StatusOr< Value > > FromChunks(absl::Span< const data::Chunk *const > chunks)
Reads a batch in order, retaining a separate result for each chunk.
Definition values.h:349
virtual absl::StatusOr< Value > FromChunk(const data::Chunk &chunk)=0
The value chunk holds.
virtual absl::StatusOr< data::Chunk > ToChunk(const Value &value, std::string_view mimetype)=0
A chunk holding value, in mimetype when one is asked for.
virtual absl::StatusOr< Value > Adopt(const DtoPlan &shape, const Program &program, const Value &value)
Adopts a validated value of a declared shape for the host.
Definition values.h:376
A value only the host knows what to do with.
Definition values.h:66
virtual bool Truthy() const =0
Whether the value counts as true.
virtual Value Field(std::string_view name) const =0
value.name, or a null value when there is no such field.
virtual std::optional< Value > FindElement(const Value &key) const
Definition values.cc:1424
virtual std::string Tag() const =0
The tag the host knows this type by, for a message.
virtual ~HostObject()=default
virtual std::optional< size_t > Size() const =0
How many things it holds, where that means anything.
virtual Value Element(const Value &key) const =0
value[key].
virtual std::optional< Value > FindField(std::string_view name) const
A field or element with its presence retained, including a null value.
Definition values.cc:1419
virtual bool Equals(const HostObject &other) const =0
Whether this is the same value as other, by the host's own equality.
virtual std::string Text() const =0
What as_text gives: what the value is on the wire, not its repr.
A typed raw fragment carried through a fragment-view Flow pipeline.
Definition values.h:116
bool Equals(const HostObject &other) const override
Whether this is the same value as other, by the host's own equality.
Definition values.cc:750
std::optional< Value > FindField(std::string_view name) const override
A field or element with its presence retained, including a null value.
Definition values.cc:742
bool Truthy() const override
Whether the value counts as true.
Definition values.cc:709
Value Element(const Value &key) const override
value[key].
Definition values.cc:738
std::string Tag() const override
The tag the host knows this type by, for a message.
Definition values.cc:701
const data::NodeFragment & fragment() const
Definition values.h:121
Value Field(std::string_view name) const override
value.name, or a null value when there is no such field.
Definition values.cc:717
NodeFragmentObject(data::NodeFragment fragment)
Definition values.h:118
std::optional< size_t > Size() const override
How many things it holds, where that means anything.
Definition values.cc:713
std::string Text() const override
What as_text gives: what the value is on the wire, not its repr.
Definition values.cc:705
A typed reference carried through a fragment-view Flow pipeline.
Definition values.h:94
std::string Text() const override
What as_text gives: what the value is on the wire, not its repr.
Definition values.cc:653
bool Equals(const HostObject &other) const override
Whether this is the same value as other, by the host's own equality.
Definition values.cc:696
Value Field(std::string_view name) const override
value.name, or a null value when there is no such field.
Definition values.cc:665
NodeReferenceObject(data::NodeRef reference)
Definition values.h:96
std::string Tag() const override
The tag the host knows this type by, for a message.
Definition values.cc:649
bool Truthy() const override
Whether the value counts as true.
Definition values.cc:657
std::optional< Value > FindField(std::string_view name) const override
A field or element with its presence retained, including a null value.
Definition values.cc:687
Value Element(const Value &key) const override
value[key].
Definition values.cc:683
const data::NodeRef & reference() const
Definition values.h:99
std::optional< size_t > Size() const override
How many things it holds, where that means anything.
Definition values.cc:661
Definition values.h:312
An immutable Flow value with shared containers and long text.
Definition values.h:139
static Value Null()
Definition values.h:172
bool has_packed_element_type(std::string_view name) const
Definition values.cc:1005
bool is_legacy_number() const
Definition values.h:231
static Value Bool(bool value)
Definition values.cc:1082
static Value TypedFloat(double value, int bits)
Definition values.cc:1115
const std::vector< Value > & items() const
Definition values.cc:975
static Value LegacyNumber(Value value)
Definition values.cc:1123
static Value List(std::vector< Value > items)
Definition values.cc:1148
static Value Bytes(data::Bytes value)
Definition values.cc:1144
const std::shared_ptr< const HostObject > & host_object() const
Definition values.cc:1059
bool negative() const
Definition values.h:225
std::int64_t integer() const
Definition values.cc:955
static Value Object(Pairs pairs)
Definition values.cc:1253
const HostObject & host() const
Definition values.cc:1055
Kind kind() const
Definition values.h:198
const absl::Status *absl_nullable native_status() const
Definition values.cc:1035
const Value *absl_nullable Get(std::string_view key) const
The value at key of an object, or nullptr.
Definition values.cc:1332
static Value String(std::string value)
Definition values.cc:1140
static Value Status(absl::Status status, Pairs fields)
Definition values.cc:1074
bool IsTimelike() const
Definition values.h:207
bool IsNumber() const
Definition values.h:202
double number() const
Definition values.cc:959
Value list_at(size_t index) const
Definition values.cc:995
absl::uint128 magnitude() const
Definition values.cc:963
static Value Integer(std::int64_t value)
Definition values.cc:1089
static Value Double(double value)
Definition values.cc:1096
bool boolean() const
Definition values.cc:951
size_t list_size() const
Definition values.cc:985
const std::string & text() const
Definition values.cc:967
static Value Host(std::shared_ptr< const HostObject > object)
Definition values.cc:1288
static Value Of(const syntax::Constant &constant)
The value a Constant – a literal, or a folded literal expression – is.
Definition values.cc:1298
bool numeric_signed() const
Definition values.h:227
static Value Option(std::optional< Value > value)
Definition values.cc:1063
Kind
Definition values.h:141
@ kChunk
An undecoded chunk, kept whole so a pipe that only moves values re-writes the producer's own bytes an...
@ kNull
A value that is not there: an absent key, an empty stream, a missing header.
absl::Duration duration() const
Definition values.cc:1043
bool IsTextlike() const
Whether the value is one the language itself can take apart: a string or a byte string,...
Definition values.h:213
friend bool operator==(const Value &left, const Value &right)
Whether the two values are equal, as == in a flow decides it.
Definition values.cc:1344
bool is_option() const
Definition values.h:189
const data::Chunk & chunk() const
Definition values.cc:1051
bool IsNull() const
Definition values.h:200
const Pairs & pairs() const
Definition values.cc:1027
static Value TypedInteger(absl::uint128 magnitude, bool negative, int bits, bool is_signed)
Definition values.cc:1104
absl::Time time() const
Definition values.cc:1047
static Value Chunk(data::Chunk chunk)
Definition values.cc:1280
int numeric_bits() const
Definition values.h:229
Builds immutable overlapping lists from append-only blocks.
Definition values.h:296
std::optional< Value > Push(Value value)
Definition values.cc:894
std::string value
Definition discover.cc:100
std::string key
Definition discover.cc:764
std::optional< std::string > text
The text, where the value is a string literal or a name bound to one.
Definition discover.cc:596
std::string type
The type and what follows it: string required, list[a11.Chunk] stream.
Definition format.cc:52
std::string name
The declaration name and its colon.
Definition format.cc:50
std::vector< std::string > arguments
argv for the program, [0] = path.
Definition main.cc:136
std::string Bytes
Raw byte payload; an alias of std::string.
Definition types.h:56
Definition catalogue.cc:29
std::vector< FormatPart > FormatTemplate
Definition values.h:526
std::string StrformatCompiled(const FormatTemplate &parts, absl::Span< const Value > arguments)
Definition values.cc:2234
double DurationSeconds(absl::Duration value)
A duration as a number of seconds, for every duration there is.
Definition values.cc:1911
Value StatusRecord(const absl::Status &status)
A status as the record a flow sees when it looks at an outcome.
Definition values.cc:3926
Value MatchCompiled(const pattern::Pattern &compiled, std::string_view subject)
The same, against a pattern already compiled.
Definition values.cc:1699
std::optional< absl::StatusCode > StatusCodeOf(const Value &value)
The canonical code value names, by name or by number, or nullopt.
Definition values.cc:3952
Value FailureRecord(const absl::Status &status, Value item, std::int64_t seq)
A tolerated stage failure, with the original item and zero-based position.
Definition values.cc:3945
absl::StatusOr< Value > Evaluate(const syntax::Node &node, const EvalContext &context)
Evaluate one expression.
Definition values.cc:3666
absl::StatusOr< Value > Add(const Value &left, const Value &right)
left + right, as an expression means it.
Definition values.cc:3659
std::unique_ptr< HostBridge > NativeHostBridge()
A host bridge backed by the C++ serialization registry.
Definition values.cc:1404
Value AsJson(const Value &value)
Text parsed as JSON; anything already decoded is left alone.
Definition values.cc:1868
absl::StatusOr< Value > MatchPattern(std::string_view text, std::string_view subject)
The fields a pattern pulls out of subject, or null where it does not fit.
Definition values.cc:1689
std::optional< std::int64_t > ExactInt64(const Value &value)
Definition values.cc:1645
std::string DurationText(absl::Duration value, std::string_view spec)
A duration as text: 1m30s by default, or one unit when spec names one.
Definition values.cc:1947
double AsDouble(const Value &value)
AsNumber as a double, for the places that only want the magnitude.
Definition values.cc:1657
Value Lookup(const Value &value, const Value &key)
Take key out of value: a mapping key, an index, or a field.
Definition values.cc:1476
std::string JsonText(const Value &value)
Renders JSON with sorted keys, spaced separators, and escaped non-ASCII.
Definition values.cc:1903
absl::StatusOr< Value > CoerceShape(const DtoPlan &shape, const Value &value, const CoerceContext &context)
Make value a value of shape: fill its defaults, check its bounds, and coerce every field to the type ...
Definition values.cc:3028
absl::StatusOr< Value > LookupChecked(const Value &value, const Value &key)
Definition values.cc:1465
int Order(const Value &left, const Value &right)
Where two values sit relative to one another: -1, 0 or 1.
Definition values.cc:3655
Value AsNumber(const Value &value)
value as a number, or zero when there is nothing to read.
Definition values.cc:1578
absl::Duration AsDuration(const Value &value)
A duration from a duration, from written text, or from seconds.
Definition values.cc:1921
FormatTemplate CompileStrformat(std::string_view text)
Definition values.cc:2227
bool Truthy(const Value &value)
Whether value counts as true, as an if and a where decide it.
Definition values.cc:1515
absl::StatusOr< Value > Coerce(const Value &value, const syntax::TypeExpression &type, const CoerceContext &context)
Make value a value of the type type names.
Definition values.cc:3074
std::string Strformat(const Value &format, absl::Span< const Value > arguments)
format with each % conversion replaced by one of arguments.
Definition values.cc:2243
absl::Status StatusOfRecord(const Value &record)
The status a record like the one above describes.
Definition values.cc:3980
std::string AsText(const Value &value)
value as text, the way the text stage and builtin render it.
Definition values.cc:1544
absl::StatusOr< Value > CallBuiltin(std::string_view name, absl::Span< const Value > arguments, HostBridge *absl_nullable bridge, const PreparedExpressions *prepared)
Definition values.cc:2299
std::optional< Value > LookupOptional(const Value &value, const Value &key)
Definition values.cc:1432
absl::Time AsTime(const Value &value)
An instant from an instant, from RFC 3339 text, or from epoch seconds.
Definition values.cc:1934
Value Truncate(const Value &value, std::int64_t size)
The first size of a value: characters, bytes, elements or pairs.
Definition values.cc:1876
std::string TimeText(absl::Time value, std::string_view spec)
An instant as text: RFC 3339 in UTC, a strftime pattern, or epoch.
Definition values.cc:2003
absl::Duration Duration
A11 duration; an alias of absl::Duration (nanosecond-aware).
Definition time.h:40
absl::Time Time
A11 instant; an alias of absl::Time (nanosecond-aware).
Definition time.h:42
std::string subject
What to call it in the message: ‘'Source’, orthe pattern`.
Definition resolve.cc:6292
std::string shape
Declared shape of stream values, retained through compatible stages.
Definition resolve.cc:814
graph::RefId node
Graph ref for this result, or [graph::kNone] without a resolved ref.
Definition resolve.cc:809
std::uint32_t seq
Definition sqlite_chunk_store.cc:186
std::string mimetype
Definition sqlite_chunk_store.cc:191
A unit of data: bytes plus optional descriptive metadata.
Definition types.h:173
One piece of a node's stream: an inline chunk or a node reference.
Definition types.h:366
A reference to a (slice of a) logical node, in lieu of inline data.
Definition types.h:311
What coercion needs besides the value and the type.
Definition values.h:503
const Program *absl_nullable shapes
Definition values.h:505
bool allow_temporal_text
Definition values.h:506
HostBridge *absl_nullable bridge
Definition values.h:504
One compiled struct: a shape a port may be typed with.
Definition plan.h:87
Definition values.h:538
std::function< absl::StatusOr< Value >(const syntax::Builtin &)> reference
Definition values.h:542
std::function< absl::StatusOr< std::optional< Value > >(const syntax::Node &)> lookup
Definition values.h:541
HostBridge *absl_nullable bridge
Definition values.h:549
const absl::flat_hash_map< const syntax::Node *, Value > *absl_nullable bound
Definition values.h:544
const Program *absl_nullable shapes
The shapes the program declared, for a cast written inside an expression.
Definition values.h:551
std::function< bool(const syntax::Node &)> is_option
Definition values.h:543
bool has_it
Definition values.h:548
Value it
The value a where/map/group stage is looking at.
Definition values.h:547
const PreparedExpressions *absl_nullable prepared
Definition values.h:539
CoerceContext Coercion() const
Definition values.h:553
What an expression is evaluated against.
Definition values.h:516
std::string width
Definition values.h:521
std::string spec
Definition values.h:519
std::string text
Definition values.h:517
size_t index
Definition values.h:518
std::optional< std::string > precision
Definition values.h:522
std::string flags
Definition values.h:520
char conversion
Definition values.h:523
Immutable, bounded literal preparation shared by execution activations.
Definition values.h:532
absl::flat_hash_map< const syntax::Node *, Value > folded
Definition values.h:535
absl::flat_hash_map< std::string, pattern::Pattern > patterns
Definition values.h:533
absl::flat_hash_map< std::string, FormatTemplate > formats
Definition values.h:534
Every flow and shape one source file declares.
Definition plan.h:200
Definition values.cc:775
Definition values.cc:757
Definition values.cc:859
Definition values.cc:842
name(arg, ...) – one of the language's fixed functions.
Definition syntax.h:278
A literal or folded literal expression, including nested lists and objects.
Definition syntax.h:62
Base of every syntax node: what it is, and where it started.
Definition syntax.h:179
Output format
Definition main.cc:65
A11's core wire value types: chunks, node fragments and messages.
bool is_signed
Definition values.cc:65
int bits
Definition values.cc:64