Builders

The builder pattern is useful when you would otherwise require many constructors or where construction has side effects.

Component Builder

Constructs a new component programmatically.

#![allow(unused)]
fn main() {
fn build_component() -> Component {
    ComponentBuilder::new("namespace", "component_name")
        .description("A test component with several properties")
        // Provide properties
        .property("property_1", DataType::String)
        .property_from(PropertyType::new("property_2", DataType::Bool))
        .string_property("property_3")
        .bool_property("property_4")
        .number_property("property_5")
        .array_property("property_6")
        .object_property("property_7")
        .input_property("property_8", DataType::Bool)
        .output_property("property_9", DataType::Bool)
        // Provide extensions
        .extension("security", json!({
            roles: [
                "ADMIN"
            ]
        }))
        .build()
}
}

Entity Type Builder

Constructs a new entity type programmatically.

#![allow(unused)]
fn main() {
fn build_entity_type() -> EntityType {
    EntityTypeBuilder::new("namespace", "entity_type_name")
        .description("A test entity type")
        // Compose with the labeled component
        .component("labeled")
        // Provide additional properties
        .property("property_1", DataType::String)
        .property_from(PropertyType::new("property_2", DataType::Bool))
        .string_property("property_3")
        .bool_property("property_4")
        .number_property("property_5")
        .input_property("property_6", DataType::Bool)
        .output_property("property_7", DataType::Bool)
        // Provide extensions
        .extension("usage", json!("ls [OPTION]... [FILE]..."))
        .build()
}
}

Relation Type Builder

Constructs a new relation type programmatically.

#![allow(unused)]
fn main() {
fn build_relation_type() -> RelationType {
    RelationTypeBuilder::new(
        // Outbound Entity Type
        "teleport",
        // Relation Type Name
        "teleports_to",
        // Inbound Entity Type
        "tele_destination"
    )
        .description("A relation type which connects a teleport with a tele destination. The property weight defines the probability")
        // Compose with the weighted component
        .component("weighted")
        // Provide additional properties
        .property("property_1", DataType::String)
        .property_from(PropertyType::new("property_2", DataType::Bool))
        .string_property("property_3")
        .bool_property("property_4")
        .number_property("property_5")
        .input_property("property_6", DataType::Bool)
        .output_property("property_7", DataType::Bool)
        // Provide extensions
        .extension("flow_arrow_color", json!("#ff7700"))
        .extension("flow_arrow_labeling", json!("teleports from {outbound.name} to {inbound.name}"))
        .build()
}
}

Entity Instance Builder

Constructs a new entity instance programmatically. This is the non-reactive variant.

#![allow(unused)]
fn main() {
fn build_entity_instance(type_name: String) -> EntityInstance {
    EntityInstanceBuilder::new(type_name)
        .id(id)
        .property("property_1", json!("value_1"))
        .get()
}

fn build_entity_instance_from_type(entity_type: EntityType) -> EntityInstance {
    EntityInstanceBuilder::from(entity_type)
        .id(id)
        .property("property_1", json!("value_1"))
        .get()
}
}

Relation Instance Builder

Constructs a new relation instance programmatically. This is the non-reactive variant.

Reactive Entity Instance Builder

Constructs a new reactive entity instance programmatically.

Reactive Relation Instance Builder

Constructs a new reactive relation instance programmatically.

Flow Builder