Struct teo_runtime::namespace::Namespace

pub struct Namespace {

    pub path: Vec<String>,
    pub namespaces: BTreeMap<String, Namespace>,
    pub structs: BTreeMap<String, Struct>,
    pub models: BTreeMap<String, Model>,
    pub enums: BTreeMap<String, Enum>,
    pub interfaces: BTreeMap<String, Interface>,
    pub model_decorators: BTreeMap<String, Decorator>,
    pub model_field_decorators: BTreeMap<String, Decorator>,
    pub model_relation_decorators: BTreeMap<String, Decorator>,
    pub model_property_decorators: BTreeMap<String, Decorator>,
    pub enum_decorators: BTreeMap<String, Decorator>,
    pub enum_member_decorators: BTreeMap<String, Decorator>,
    pub interface_decorators: BTreeMap<String, Decorator>,
    pub interface_field_decorators: BTreeMap<String, Decorator>,
    pub handler_decorators: BTreeMap<String, Decorator>,
    pub pipeline_items: BTreeMap<String, Item>,
    pub middlewares: BTreeMap<String, Definition>,
    pub handlers: BTreeMap<String, Handler>,
    pub handler_templates: BTreeMap<String, Handler>,
    pub model_handler_groups: BTreeMap<String, Group>,
    pub handler_groups: BTreeMap<String, Group>,
    pub server: Option<Server>,
    pub connector: Option<Connector>,
    pub clients: BTreeMap<String, Client>,
    pub entities: BTreeMap<String, Entity>,
    pub debug: Option<Debug>,
    pub admin: Option<Admin>,
    pub middlewares_block: Option<Block>,
    pub database: Option<Database>,
    pub connector_reference: Option<Vec<String>>,
    pub connection: Option<Arc<dyn Connection>>,
    pub middleware_stack: &'static dyn Middleware,
    pub handler_map: Map,
    pub model_opposite_relations_map: BTreeMap<Vec<String>, Vec<(Vec<String>, String)>>,
}

Fields

path: Vec<String>

namespaces: BTreeMap<String, Namespace>

structs: BTreeMap<String, Struct>

models: BTreeMap<String, Model>

enums: BTreeMap<String, Enum>

interfaces: BTreeMap<String, Interface>

model_decorators: BTreeMap<String, Decorator>

model_field_decorators: BTreeMap<String, Decorator>

model_relation_decorators: BTreeMap<String, Decorator>

model_property_decorators: BTreeMap<String, Decorator>

enum_decorators: BTreeMap<String, Decorator>

enum_member_decorators: BTreeMap<String, Decorator>

interface_decorators: BTreeMap<String, Decorator>

interface_field_decorators: BTreeMap<String, Decorator>

handler_decorators: BTreeMap<String, Decorator>

pipeline_items: BTreeMap<String, Item>

middlewares: BTreeMap<String, Definition>

handlers: BTreeMap<String, Handler>

handler_templates: BTreeMap<String, Handler>

model_handler_groups: BTreeMap<String, Group>

handler_groups: BTreeMap<String, Group>

server: Option<Server>

connector: Option<Connector>

clients: BTreeMap<String, Client>

entities: BTreeMap<String, Entity>

debug: Option<Debug>

admin: Option<Admin>

middlewares_block: Option<Block>

database: Option<Database>

connector_reference: Option<Vec<String>>

connection: Option<Arc<dyn Connection>>

middleware_stack: &'static dyn Middleware

handler_map: Map

model_opposite_relations_map: BTreeMap<Vec<String>, Vec<(Vec<String>, String)>>

Implementations

impl Namespace

pub fn main() -> Self

Create a main namespace

pub fn load_standard_library(&mut self) -> Result<()>

pub fn is_main(&self) -> bool

pub fn is_std(&self) -> bool

pub fn path(&self) -> Vec<&str>

pub fn namespace(&self, name: &str) -> Option<&Namespace>

pub fn namespace_mut(&mut self, name: &str) -> Option<&mut Namespace>

pub fn namespace_mut_or_create(&mut self, name: &str) -> &mut Namespace

pub fn namespace_at_path(&self, path: &Vec<&str>) -> Option<&Namespace>

pub fn namespace_mut_at_path( &mut self, path: &Vec<&str> ) -> Option<&mut Namespace>

pub fn namespace_mut_or_create_at_path( &mut self, path: &Vec<&str> ) -> &mut Namespace

pub fn define_model_decorator<F>(&mut self, name: &str, call: F)

where F: Fn(Arguments, &mut Model) -> Result<()> + 'static,

pub fn define_model_field_decorator( &mut self, name: &str, call: impl Fn(Arguments, &mut Field) -> Result<()> + 'static )

pub fn define_model_relation_decorator( &mut self, name: &str, call: impl Fn(Arguments, &mut Relation) -> Result<()> + 'static )

pub fn define_model_property_decorator( &mut self, name: &str, call: impl Fn(Arguments, &mut Property) -> Result<()> + 'static )

pub fn define_enum_decorator( &mut self, name: &str, call: impl Fn(Arguments, &mut Enum) -> Result<()> + 'static )

pub fn define_enum_member_decorator( &mut self, name: &str, call: impl Fn(Arguments, &mut Member) -> Result<()> + 'static )

pub fn define_interface_decorator<F>(&mut self, name: &str, call: F)

where F: Fn(Arguments, &mut Interface) -> Result<()> + 'static,

pub fn define_handler_decorator( &mut self, name: &str, call: impl Fn(Arguments, &mut Handler) -> Result<()> + 'static )

pub fn define_pipeline_item<T>(&mut self, name: &str, call: T)

where T: Call + 'static,

pub fn define_transform_pipeline_item<A, O, F, R>( &mut self, name: &str, call: F )

where A: Send + Sync + 'static, O: Into<Value> + Send + Sync + 'static, R: Into<TransformResult<O>> + Send + Sync + 'static, F: TransformArgument<A, O, R> + 'static,

pub fn define_validator_pipeline_item<T, F, O>(&mut self, name: &str, call: F)

where T: Send + Sync + 'static, F: ValidateArgument<T, O> + 'static, O: Into<ValidateResult> + Send + Sync + 'static,

pub fn define_callback_pipeline_item<T, F, O>(&mut self, name: &str, call: F)

where T: Send + Sync + 'static, F: CallbackArgument<T, O> + 'static, O: Into<CallbackResult> + Send + Sync + 'static,

pub fn define_compare_pipeline_item<T, O, F, E>(&mut self, name: &str, call: F)

where T: Send + Sync + 'static, O: Into<ValidateResult> + Send + Sync + 'static, E: Into<Error> + Error, F: CompareArgument<T, O, E> + 'static,

pub fn define_middleware<T>(&mut self, name: &str, call: T)

where T: Creator + 'static,

pub fn define_model_handler_group<T>(&mut self, name: &str, builder: T)

where T: Fn(&mut Group),

pub fn define_handler<T, F>(&mut self, name: &str, call: F)

where T: 'static, F: 'static + HandlerCtxArgument<T>,

pub fn define_handler_template<T, F>(&mut self, name: &str, call: F)

where T: 'static, F: 'static + HandlerCtxArgument<T>,

pub fn define_handler_group<T>(&mut self, name: &str, builder: T)

where T: Fn(&mut Group),

pub fn define_struct<T>(&mut self, name: &str, builder: T)

where T: Fn(&'static Vec<String>, &mut Struct),

pub fn model_decorator_at_path(&self, path: &Vec<&str>) -> Option<&Decorator>

pub fn model_field_decorator_at_path( &self, path: &Vec<&str> ) -> Option<&Decorator>

pub fn model_relation_decorator_at_path( &self, path: &Vec<&str> ) -> Option<&Decorator>

pub fn model_property_decorator_at_path( &self, path: &Vec<&str> ) -> Option<&Decorator>

pub fn enum_decorator_at_path(&self, path: &Vec<&str>) -> Option<&Decorator>

pub fn enum_member_decorator_at_path( &self, path: &Vec<&str> ) -> Option<&Decorator>

pub fn interface_decorator_at_path( &self, path: &Vec<&str> ) -> Option<&Decorator>

pub fn interface_field_decorator_at_path( &self, path: &Vec<&str> ) -> Option<&Decorator>

pub fn handler_decorator_at_path(&self, path: &Vec<&str>) -> Option<&Decorator>

pub fn pipeline_item_at_path(&self, path: &Vec<&str>) -> Option<&Item>

pub fn struct_at_path(&self, path: &Vec<&str>) -> Option<&Struct>

pub fn enum_at_path(&self, path: &Vec<&str>) -> Option<&Enum>

pub fn model_at_path(&self, path: &Vec<&str>) -> Option<&Model>

pub fn interface_at_path(&self, path: &Vec<&str>) -> Option<&Interface>

pub fn middleware_at_path(&self, path: &Vec<&str>) -> Option<&Definition>

pub fn handler_template_at_path(&self, path: &Vec<&str>) -> Option<&Handler>

pub fn handler_at_path(&self, path: &Vec<&str>) -> Option<&Handler>

pub fn replace_handler_template_at_path( &mut self, path: &Vec<&str>, handler: Handler )

pub fn replace_handler_at_path( &mut self, path: &Vec<&str>, handler: Handler, inside_group: bool )

pub fn connector_reference(&self) -> Option<Vec<&str>>

pub fn opposite_relation( &self, relation: &Relation ) -> (&Model, Option<&Relation>)

Returns the opposite relation of the argument relation.

Arguments

• relation - The relation must be of a model of this graph.

Return Value

A tuple of opposite relation’s model and opposite relation.

pub fn through_relation(&self, relation: &Relation) -> (&Model, &Relation)

Returns the through relation of the argument relation.

Arguments

• relation - The relation must be of a model of this graph. This relation must be a through relation.

Return Value

A tuple of through relation’s model and through model’s local relation.

pub fn through_opposite_relation( &self, relation: &Relation ) -> (&Model, &Relation)

Returns the through opposite relation of the argument relation.

Arguments

• relation - The relation must be of a model of this graph. This relation must be a through relation.

Return Value

A tuple of through relation’s model and through model’s foreign relation.

pub fn models_under_connector(&self) -> Vec<&Model>

pub fn model_opposite_relations( &self, model: &Model ) -> Vec<(&Model, &Relation)>

Get relations of model defined by related model

Trait Implementations

impl Debug for Namespace

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Named for Namespace

fn name(&self) -> &str

impl Serialize for Namespace

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Send for Namespace

impl Sync for Namespace