RuleBuilder.h header

enum class OperandKind { Literal, SameObject, Traversed, NamedObject }

What the right-hand side of a comparison is.

enum class RuleOperator { Equals, NotEquals, LessThan, LessOrEqual, GreaterThan, GreaterOrEqual, Contains, NotContains, StartsWith, EndsWith, Matches, LengthAtLeast, LengthAtMost, IsTrue, IsFalse, IsEmpty, IsNotEmpty, CountEquals, CountAtLeast, CountAtMost, ListContains, ListExcludes, AllAbove, AllBelow, AnyAbove, HasKey }

What a rule can assert about a property, in the vocabulary a person picks from.

Offered by the property's TYPE, never in full. A menu that let an author ask whether a number starts with a word, or whether a date is longer than five, is a menu that produces rules which are not wrong so much as meaningless – and the author finds out from a conflict report weeks later. Every one of these compiles to an expression in the shared language (see toExpression), so the builder is a way of WRITING the expression, never a second engine with its own opinions.

std::optional< BuiltRule > ew::app::expression::fromExpression(const ew::core::project::Project &project, const QString &expression)

The rule expression describes, or std::nullopt when it says something the builder cannot.

The round trip is the feature, not a convenience: an author who drops to the raw editor to write something the menus cannot say must be able to come back, and a builder that silently discarded what it did not understand would eat their rule. Anything this cannot read stays in the raw editor, and the builder says so rather than guessing.

QString ew::app::expression::operatorPhrase(RuleOperator op)

The phrase op reads as in the rule's plain-language readout ("must be less than").

bool ew::app::expression::operatorTakesOperand(RuleOperator op)

Whether op compares against a second operand at all (false for is-true, is-empty, ...).

std::vector< RuleOperator > ew::app::expression::operatorsFor(ew::core::taxonomy::FieldType type, ew::core::taxonomy::FieldType elementType=ew::core::taxonomy::FieldType::Text)

The operators a property of type can meaningfully carry, in the order a menu should offer them. elementType is the List's element type, ignored for every other type.

std::vector< PropertyChoice > ew::app::expression::propertyChoicesFor(const ew::core::project::Project &project, const ew::core::entity::Entity &sample)

The properties a rule about sample can be written over: its own, its blocks' members, and one hop through each reference (including through a list of them, as inventory[].weight).

Read off a real object rather than a category, because that is the only place the answer is complete: a property can arrive from a category chain, from another entity's own properties crossing a boundary, or from the object itself, and asking the taxonomy alone would silently leave out the last two.

One hop, not two: two would enumerate the codex, and the raw editor is there for the rest.

QString ew::app::expression::readout(const ew::core::project::Project &project, const BuiltRule &rule, const QString &subject)

The plain-language readout of rule – "Sue's money must be less than John's money".

Shown above the builder at all times, because a menu of three dropdowns is a shape rather than a sentence, and the mistake it hides is picking the wrong one of two similarly-named properties.

std::optional< RuleOperator > ew::app::expression::ruleOperatorFromToken(QStringView token)

Parses an operator token; std::nullopt when unrecognized.

QString ew::app::expression::toExpression(const ew::core::project::Project &project, const BuiltRule &rule)

The expression rule means, ready to store on a ContinuityRule.

Object references come out in their stored form (by id), so a rule the builder wrote survives renaming exactly as a hand-written one does.

QString ew::app::expression::toToken(RuleOperator op)

The stable serialization token for op ("equals", "starts-with", "all-above").