cameleer-core 0.5.1

Core of Cameleer: exchanges, routes, EIPs, DSL, languages, core components
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

//! Template components: `string-template:`, `velocity:` and `freemarker:`.
//!
//! Each component uses a real engine implemented in this crate (see
//! [`velocity`](super::velocity), [`freemarker`](super::freemarker) and
//! [`stringtemplate`](super::stringtemplate)) and shares the data model and the options of
//! [`template_support`](super::template_support) (`body`, `headers`, `exchange.properties`,
//! `variables`, `request`/`in`, `camelContext` with `allowContextMapAll`).
//!
//! - `string-template:file.st?delimiterStart=<&delimiterStop=>` — headers
//!   `CamelStringTemplateTemplate`/`CamelStringTemplateResourceUri`.
//! - `velocity:file.vm` — headers `CamelVelocityTemplate`/`CamelVelocityResourceUri`,
//!   `CamelVelocityContext` (a map used as the whole context) and
//!   `CamelVelocitySupplementalContext` (a map merged into the context).
//! - `freemarker:file.ftl` — headers `CamelFreemarkerTemplate`/`CamelFreemarkerResourceUri`
//!   and `CamelFreemarkerDataModel` (a map used as the data model).

use std::any::Any;
use std::sync::Arc;

use crate::context::CamelContext;
use crate::error::Result;
use crate::spi::{Component, Endpoint};
use crate::util::Parameters;

pub use super::freemarker::FreemarkerEngine;
pub use super::stringtemplate::StringTemplateEngine;
pub use super::velocity::VelocityEngine;

use super::template_support::{TemplateEndpoint, TemplateEngine, TemplateHeaders, TemplateOptions};

fn create(
    ctx: &CamelContext,
    uri: &str,
    remaining: &str,
    params: &mut Parameters,
    headers: TemplateHeaders,
    engine: Arc<dyn TemplateEngine>,
) -> Result<Arc<dyn Endpoint>> {
    let options = TemplateOptions::from_params(params)?;
    Ok(Arc::new(TemplateEndpoint::new(ctx, uri, remaining, options, headers, engine)?))
}

/// The `string-template` component.
#[derive(Default)]
pub struct StringTemplateComponent;

impl Component for StringTemplateComponent {
    fn create_endpoint(&self, ctx: &CamelContext, uri: &str, remaining: &str, params: &mut Parameters) -> Result<Arc<dyn Endpoint>> {
        let engine = StringTemplateEngine {
            start: params.take("delimiterStart").and_then(|s| s.chars().next()).unwrap_or('<'),
            stop: params.take("delimiterStop").and_then(|s| s.chars().next()).unwrap_or('>'),
        };
        let headers = TemplateHeaders { template: "CamelStringTemplateTemplate", resource_uri: "CamelStringTemplateResourceUri", data_model: None, supplemental: None };
        create(ctx, uri, remaining, params, headers, Arc::new(engine))
    }
    fn as_any(&self) -> &dyn Any {
        self
    }
}

/// The `velocity` component.
#[derive(Default)]
pub struct VelocityComponent;

impl Component for VelocityComponent {
    fn create_endpoint(&self, ctx: &CamelContext, uri: &str, remaining: &str, params: &mut Parameters) -> Result<Arc<dyn Endpoint>> {
        for k in ["loaderCache", "propertiesFile"] {
            params.take(k);
        }
        let headers = TemplateHeaders {
            template: "CamelVelocityTemplate",
            resource_uri: "CamelVelocityResourceUri",
            data_model: Some("CamelVelocityContext"),
            supplemental: Some("CamelVelocitySupplementalContext"),
        };
        create(ctx, uri, remaining, params, headers, Arc::new(VelocityEngine))
    }
    fn as_any(&self) -> &dyn Any {
        self
    }
}

/// The `freemarker` component.
#[derive(Default)]
pub struct FreemarkerComponent;

impl Component for FreemarkerComponent {
    fn create_endpoint(&self, ctx: &CamelContext, uri: &str, remaining: &str, params: &mut Parameters) -> Result<Arc<dyn Endpoint>> {
        for k in ["configuration", "templateUpdateDelay", "localizedLookup"] {
            params.take(k);
        }
        let headers = TemplateHeaders {
            template: "CamelFreemarkerTemplate",
            resource_uri: "CamelFreemarkerResourceUri",
            data_model: Some("CamelFreemarkerDataModel"),
            supplemental: None,
        };
        create(ctx, uri, remaining, params, headers, Arc::new(FreemarkerEngine))
    }
    fn as_any(&self) -> &dyn Any {
        self
    }
}