Skip to content
This repository was archived by the owner on Jun 16, 2022. It is now read-only.

Commit 814c092

Browse files
ADRFranklinADRFranklin
committed
Added global template variables
1 parent 61accc4 commit 814c092

File tree

4 files changed

+120
-72
lines changed

4 files changed

+120
-72
lines changed

‎src/lib.rs‎

Lines changed: 5 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -5,14 +5,16 @@ extern crate log;
55
mod plugin;
66

77
use std::collections::HashMap;
8-
use crate::plugin::Templates;
8+
use crate::plugin::*;
99
use samp::initialize_plugin;
1010

1111
initialize_plugin!(
1212
natives: [
1313
Templates::create_template,
1414
Templates::render_template,
15-
Templates::create_template_var,
15+
Templates::make_template_var_int,
16+
Templates::make_template_var_float,
17+
Templates::make_template_var_string,
1618
],
1719
{
1820
let samp_logger = samp::plugin::logger()
@@ -30,7 +32,7 @@ initialize_plugin!(
3032
Templates {
3133
pool: HashMap::new(),
3234
id: 0,
33-
variables: liquid::value::Object::new()
35+
globals: liquid::value::Object::new()
3436
}
3537
}
3638
);

‎src/plugin.rs‎

Lines changed: 105 additions & 57 deletions
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,14 @@
1-
use std::collections::HashMap;
1+
use liquid::value::Object;
2+
use liquid::value::Value;
3+
use log::error;
4+
use samp::native;
25
use samp::prelude::*;
3-
use samp::{native};
4-
use log::{error};
5-
6+
use std::collections::HashMap;
67

78
pub struct Templates {
89
pub pool: HashMap<i32, liquid::Template>,
910
pub id: i32,
10-
pub variables: liquid::value::Object
11+
pub globals: Object,
1112
}
1213

1314
#[derive(Debug)]
@@ -47,11 +48,7 @@ impl Templates {
4748
}
4849

4950
#[native(raw, name = "RenderTemplate")]
50-
pub fn render_template(
51-
&mut self,
52-
_: &Amx,
53-
mut params: samp::args::Args
54-
) -> AmxResult<i32> {
51+
pub fn render_template(&mut self, _: &Amx, mut params: samp::args::Args) -> AmxResult<i32> {
5552
let arg_count = params.count() - 3;
5653
let pairs = if arg_count == 0 || arg_count % 3 == 0 {
5754
arg_count / 3
@@ -60,25 +57,25 @@ impl Templates {
6057
return Ok(1);
6158
};
6259

63-
let template_id = params.next::<i32>().unwrap();
60+
let template_id = params.next::<i32>().unwrap();
6461
let t = match self.pool.get(&template_id) {
6562
Some(t) => t,
6663
None => return Ok(2),
6764
};
6865

6966
let output_str = params.next::<UnsizedBuffer>().unwrap();
70-
let output_len = params.next::<usize>().unwrap();
67+
let output_len = params.next::<usize>().unwrap();
7168

72-
let mut variables = self.variables.clone();
69+
let mut variables = self.globals.clone();
7370

74-
for _ in 0..pairs {
71+
for _ in 0..pairs {
7572
let var_type = match params.next::<Ref<i32>>() {
7673
None => {
7774
error!("invalid type expected int");
7875
return Ok(-1);
7976
}
8077
Some(t) => t,
81-
};
78+
};
8279

8380
let key = match params.next::<AmxString>() {
8481
None => {
@@ -119,54 +116,105 @@ impl Templates {
119116
return Ok(0);
120117
}
121118

122-
#[native(raw, name = "CreateTemplateVar")]
123-
pub fn create_template_var(
119+
#[native(name = "MakeTemplateVarInt")]
120+
pub fn make_template_var_int(
124121
&mut self,
125122
_: &Amx,
126-
mut params: samp::args::Args
123+
namespace: AmxString,
124+
key: AmxString,
125+
value: i32,
127126
) -> AmxResult<i32> {
128-
let arg_count = params.count();
129-
let pairs = if arg_count == 0 || arg_count % 3 == 0 {
130-
arg_count / 3
131-
} else {
132-
error!("invalid variadic argument pattern passed to CreateTemplateVar.");
127+
let namespace_str = namespace.to_string();
128+
if namespace_str.is_empty() {
129+
error!("namespace expects a string, none given.");
133130
return Ok(1);
134-
};
131+
}
135132

136-
for _ in 0..pairs {
137-
let var_type = match params.next::<Ref<i32>>() {
138-
None => {
139-
error!("invalid type expected int");
140-
return Ok(-1);
141-
}
142-
Some(t) => t,
143-
};
133+
let key_str = key.to_string();
134+
if key_str.is_empty() {
135+
error!("key expects a string, none given.");
136+
}
144137

145-
let key = match params.next::<AmxString>() {
146-
None => {
147-
error!("invalid type expected string");
148-
return Ok(-1);
149-
},
150-
Some(k) => k.to_string(),
151-
};
138+
let mut variable: Object = Object::new();
139+
for (key, value) in self.globals.iter() {
140+
if key.to_string() == namespace_str {
141+
variable = value.as_object().unwrap().clone();
142+
break;
143+
}
144+
}
152145

153-
match ArgumentPairType::from_i32(*var_type) {
154-
ArgumentPairType::String => {
155-
let value = params.next::<AmxString>().unwrap().to_string();
156-
self.variables.insert(key.into(), liquid::value::Value::scalar(value));
157-
}
158-
ArgumentPairType::Int => {
159-
let value = params.next::<Ref<i32>>().unwrap();
160-
self.variables.insert(key.into(), liquid::value::Value::scalar(*value));
161-
}
162-
ArgumentPairType::Float => {
163-
let value = params.next::<Ref<f32>>().unwrap();
164-
self.variables.insert(key.into(), liquid::value::Value::scalar(*value as f64));
165-
}
166-
_ => return Ok(3),
167-
};
146+
variable.insert(key_str.into(), Value::scalar(value));
147+
self.globals
148+
.insert(namespace_str.into(), Value::Object(variable));
149+
150+
return Ok(0);
151+
}
152+
153+
#[native(name = "MakeTemplateVarFloat")]
154+
pub fn make_template_var_float(
155+
&mut self,
156+
_: &Amx,
157+
namespace: AmxString,
158+
key: AmxString,
159+
value: f32,
160+
) -> AmxResult<i32> {
161+
let namespace_str = namespace.to_string();
162+
if namespace_str.is_empty() {
163+
error!("namespace expects a string, none given.");
164+
return Ok(1);
165+
}
166+
167+
let key_str = key.to_string();
168+
if key_str.is_empty() {
169+
error!("key expects a string, none given.");
168170
}
169171

172+
let mut variable: Object = Object::new();
173+
for (key, value) in self.globals.iter() {
174+
if key.to_string() == namespace_str {
175+
variable = value.as_object().unwrap().clone();
176+
break;
177+
}
178+
}
179+
180+
variable.insert(key_str.into(), Value::scalar(value as f64));
181+
self.globals
182+
.insert(namespace_str.into(), Value::Object(variable));
183+
184+
return Ok(0);
185+
}
186+
187+
#[native(name = "MakeTemplateVarString")]
188+
pub fn make_template_var_string(
189+
&mut self,
190+
_: &Amx,
191+
namespace: AmxString,
192+
key: AmxString,
193+
value: AmxString,
194+
) -> AmxResult<i32> {
195+
let namespace_str = namespace.to_string();
196+
if namespace_str.is_empty() {
197+
error!("namespace expects a string, none given.");
198+
return Ok(1);
199+
}
200+
201+
let key_str = key.to_string();
202+
if key_str.is_empty() {
203+
error!("key expects a string, none given.");
204+
}
205+
206+
let mut variable: Object = Object::new();
207+
for (key, value) in self.globals.iter() {
208+
if key.to_string() == namespace_str {
209+
variable = value.as_object().unwrap().clone();
210+
break;
211+
}
212+
}
213+
214+
variable.insert(key_str.into(), Value::scalar(value.to_string()));
215+
self.globals
216+
.insert(namespace_str.into(), Value::Object(variable));
217+
170218
return Ok(0);
171219
}
172220

@@ -175,16 +223,16 @@ impl Templates {
175223
self.pool.insert(self.id, template);
176224
self.id
177225
}
178-
}
226+
}
179227

180228
impl Default for Templates {
181229
fn default() -> Self {
182230
Templates {
183231
pool: HashMap::new(),
184232
id: 0,
185-
variables: liquid::value::Object::new()
233+
globals: liquid::value::Object::new(),
186234
}
187235
}
188236
}
189237

190-
impl SampPlugin for Templates {}
238+
impl SampPlugin for Templates {}

‎templates.inc‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -21,4 +21,6 @@ enum {
2121

2222
native Template:CreateTemplate(const template[]);
2323
native RenderTemplate(Template:id, dest[], len, ...);
24-
native CreateTemplateVar(...);
24+
native MakeTemplateVarInt(const namespace[], const key[], value);
25+
native MakeTemplateVarFloat(const namespace[], const key[], Float:value);
26+
native MakeTemplateVarString(const namespace[], const key[], const value[]);

‎test.pwn‎

Lines changed: 7 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -85,18 +85,14 @@ Test:Assignment() {
8585
}
8686

8787
Test:GlobalVariables() {
88-
CreateTemplateVar(
89-
PAIR_FLOAT("float", 70.5)
90-
);
91-
new Template:t = CreateTemplate("\
92-
String: {{ string }}, Int: {{ int }}, Float: {{ float }}");
88+
MakeTemplateVarString("player", "name", "Southclaws");
89+
MakeTemplateVarInt("player", "id", 3720);
90+
MakeTemplateVarFloat("player", "pos_x", 5.5);
91+
new Template:t = CreateTemplate("Name: {{ player.name }}, ID: {{ player.id }}, Pos X: {{ player.pos_x }}");
9392
new rendered[64];
94-
new ret = RenderTemplate(t, rendered, sizeof rendered,
95-
PAIR_STR("string", "Southclaws"),
96-
PAIR_INT("int", 50)
97-
);
93+
new ret = RenderTemplate(t, rendered, sizeof rendered);
9894

9995
printf("ret: %d rendered: '%s'", ret, rendered);
10096
ASSERT(ret == 0);
101-
ASSERT(strcmp(rendered, "String: Southclaws, Int: 50, Float: 70.5") == 0);
102-
}
97+
ASSERT(strcmp(rendered, "Name: Southclaws, ID: 3720, Pos X: 5.5") == 0);
98+
}

0 commit comments

Comments
 (0)