fluencelabs/jsonpath
1
0
Fork 0
mirror of https://github.com/fluencelabs/jsonpath synced 2025-04-25 01:12:17 +00:00
Code Issues Projects Releases Wiki Activity

remove alloc, dealloc in wasm

Browse Source
This commit is contained in:
freestrings 2019-05-27 11:42:46 +09:00
parent d2a5d9092e
commit 3f89b9b183
14 changed files with 176 additions and 398 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
README.md
View File

@ -32,7 +32,6 @@ It is JsonPath [JsonPath](https://goessner.net/articles/JsonPath/) engine writte
- [Javascript - jsonpath.select(json: string|object, jsonpath: string)](#javascript---jsonpathselectjson-stringobject-jsonpath-string)
- [Javascript - jsonpath.compile(jsonpath: string)](#javascript---jsonpathcompilejsonpath-string)
- [Javascript - jsonpath.selector(json: string|object)](#javascript---jsonpathselectorjson-stringobject)
- [Javascript - allocJson, deallocJson (Webassembly Only)](#javascript---allocjson-deallocjson-webassembly-only)
- [Javascript - Other Examples](https://github.com/freestrings/jsonpath/wiki/Javascript-examples)
---
@ -532,60 +531,4 @@ console.log(
);
// => true, true
```
#### Javascript - allocJson, deallocJson (Webassembly Only)
wasm-bindgen은 Javascript와 Webassembly간 값을 주고받을 때 JSON 객체는 String으로 변환되기 때문에, 반복해서 사용되는 JSON 객체는 Webassembly 영역에 생성해 두면 성능에 도움이 된다.
Since wasm-bindgen converts JSON objects to String when exchanging values between Javascript and Webassembly, creating frequently used JSON objects in the WebAssembly area helps performance.
```javascript
const jsonpath = require('jsonpath-wasm');
let jsonObj = {
"school": {
"friends": [
{"name": "친구1", "age": 20},
{"name": "친구2", "age": 20}
]
},
"friends": [
{"name": "친구3", "age": 30},
{"name": "친구4"}
]
};
// allocate jsonObj in webassembly
let ptr = jsonpath.allocJson(jsonObj);
// `0` is invalid pointer
if(ptr == 0) {
console.error('invalid ptr');
}
let path = '$..friends[0]';
let template = jsonpath.compile(path);
let selector = jsonpath.selector(jsonObj);
// create selector as pointer
let ptrSelector = jsonpath.selector(ptr);
let ret1 = selector(path)
let ret2 = ptrSelector(path)
let ret3 = template(jsonObj);
// select as pointer
let ret4 = template(ptr);
let ret5 = jsonpath.select(jsonObj, path);
// select as pointer
let ret6 = jsonpath.select(ptr, path);
console.log(
JSON.stringify(ret1) == JSON.stringify(ret2),
JSON.stringify(ret1) == JSON.stringify(ret3),
JSON.stringify(ret1) == JSON.stringify(ret4),
JSON.stringify(ret1) == JSON.stringify(ret5),
JSON.stringify(ret1) == JSON.stringify(ret6));
// => true true true true true
jsonpath.deallocJson(ptr);
```
```

10
benches/bench.rs
View File

@ -160,4 +160,14 @@ fn refval_copy(b: &mut Bencher) {
}
}
});
}
#[bench]
fn value_clone(b: &mut Bencher) {
let json = get_json();
b.iter(move || {
for _ in 1..100 {
let _ = json.clone();
}
});
}

87
benches/bench_example.rs
View File

@ -12,6 +12,7 @@ use std::io::Read;
use serde_json::Value;
use self::test::Bencher;
use jsonpath::ref_value::model::RefValueWrapper;
fn read_json(path: &str) -> String {
let mut f = std::fs::File::open(path).unwrap();
@ -50,32 +51,70 @@ fn get_path(i: usize) -> &'static str {
paths[i]
}
macro_rules! example {
fn _as_value(b: &mut Bencher, index: usize) {
let json = get_json();
b.iter(move || {
for _ in 1..100 {
let _ = jsonpath::select(&json, get_path(index));
}
});
}
fn _as_ref_value(b: &mut Bencher, index: usize) {
let ref json = get_json();
let rv: RefValueWrapper = json.into();
b.iter(move || {
for _ in 1..100 {
let mut selector = jsonpath::Selector::new();
let _ = selector.path(get_path(index));
let _ = selector.value_from_ref_value(rv.clone());
let _ = selector.select_as_value();
}
});
}
macro_rules! example_val {
($name:ident, $i:expr) => {
#[bench]
fn $name(b: &mut Bencher) {
let json = get_json();
b.iter(move || {
for _ in 1..100 {
let _ = jsonpath::select(&json, get_path($i));
}
});
}
fn $name(b: &mut Bencher) { _as_value(b, $i); }
};
}
example!(example0, 0);
example!(example1, 1);
example!(example2, 2);
example!(example3, 3);
example!(example4, 4);
example!(example5, 5);
example!(example6, 6);
example!(example7, 7);
example!(example8, 8);
example!(example9, 9);
example!(example10, 10);
example!(example11, 11);
example!(example12, 12);
example!(example13, 13);
example!(example14, 14);
macro_rules! example_val_ref {
($name:ident, $i:expr) => {
#[bench]
fn $name(b: &mut Bencher) { _as_ref_value(b, $i); }
};
}
example_val!(example_val_0, 0);
example_val!(example_val_1, 1);
example_val!(example_val_2, 2);
example_val!(example_val_3, 3);
example_val!(example_val_4, 4);
example_val!(example_val_5, 5);
example_val!(example_val_6, 6);
example_val!(example_val_7, 7);
example_val!(example_val_8, 8);
example_val!(example_val_9, 9);
example_val!(example_val_10, 10);
example_val!(example_val_11, 11);
example_val!(example_val_12, 12);
example_val!(example_val_13, 13);
example_val!(example_val_14, 14);
example_val_ref!(example_val_ref_0, 0);
example_val_ref!(example_val_ref_1, 1);
example_val_ref!(example_val_ref_2, 2);
example_val_ref!(example_val_ref_3, 3);
example_val_ref!(example_val_ref_4, 4);
example_val_ref!(example_val_ref_5, 5);
example_val_ref!(example_val_ref_6, 6);
example_val_ref!(example_val_ref_7, 7);
example_val_ref!(example_val_ref_8, 8);
example_val_ref!(example_val_ref_9, 9);
example_val_ref!(example_val_ref_10, 10);
example_val_ref!(example_val_ref_11, 11);
example_val_ref!(example_val_ref_12, 12);
example_val_ref!(example_val_ref_13, 13);
example_val_ref!(example_val_ref_14, 14);

33
benches/javascript/bench.js
View File

@ -92,45 +92,12 @@ function wasmCompile() {
}
}
function wasmCompileAlloc() {
let ptr = jpw.allocJson(getJson());
if (ptr == 0) {
console.error('Invalid pointer');
return;
}
try {
let template = jpw.compile(path);
for (var i = 0; i < iter; i++) {
let _ = template(ptr);
}
} finally {
jpw.deallocJson(ptr);
}
}
function wasmSelect() {
for (var i = 0; i < iter; i++) {
let _ = jpw.select(getJson(), path);
}
}
function wasmSelectAlloc() {
let ptr = jpw.allocJson(getJson());
if (ptr == 0) {
console.error('Invalid pointer');
return;
}
try {
for (var i = 0; i < iter; i++) {
let _ = jpw.select(ptr, path);
}
} finally {
jpw.deallocJson(ptr);
}
}
function wasmSelectorClass() {
let selector = new jpw.Selector();
for (var i = 0; i < iter; i++) {

17
src/filter/term.rs
View File

@ -1,9 +1,6 @@
use super::cmp::*;
use super::value_filter::ValueFilterKey;
use super::value_manager::*;
use std::cell::RefCell;
use select::path_map::PathMap;
use std::sync::Arc;
#[derive(Debug)]
pub enum TermContext {
@ -55,7 +52,7 @@ impl TermContext {
}
}
fn cmp_cond(&self, other: &TermContext, cmp_cond_type: CmpCondType, path_map: Arc<RefCell<PathMap>>) -> TermContext {
fn cmp_cond(&self, other: &TermContext, cmp_cond_type: CmpCondType) -> TermContext {
match self {
TermContext::Constants(et) => {
match other {
@ -70,7 +67,7 @@ impl TermContext {
}
}
TermContext::Json(_, v) => {
TermContext::Json(None, ValueManager::new(v.get_val().clone(), false, path_map))
TermContext::Json(None, ValueManager::new(v.get_val().clone(), false))
}
}
}
@ -83,7 +80,7 @@ impl TermContext {
}
}
_ => {
TermContext::Json(None, ValueManager::new(v.get_val().clone(), false, path_map))
TermContext::Json(None, ValueManager::new(v.get_val().clone(), false))
}
}
}
@ -120,12 +117,12 @@ impl TermContext {
self.cmp(other, CmpLe, false)
}
pub fn and(&mut self, other: &mut TermContext, path_map: Arc<RefCell<PathMap>>) -> TermContext {
self.cmp_cond(other, CmpCondType::And, path_map)
pub fn and(&mut self, other: &mut TermContext) -> TermContext {
self.cmp_cond(other, CmpCondType::And)
}
pub fn or(&mut self, other: &mut TermContext, path_map: Arc<RefCell<PathMap>>) -> TermContext {
self.cmp_cond(other, CmpCondType::Or, path_map)
pub fn or(&mut self, other: &mut TermContext) -> TermContext {
self.cmp_cond(other, CmpCondType::Or)
}
}

22
src/filter/value_filter.rs
View File

@ -1,6 +1,4 @@
use std::cell::RefCell;
use std::ops::Deref;
use std::sync::Arc;
use serde_json::Value;
@ -8,7 +6,6 @@ use filter::term::*;
use filter::value_manager::*;
use parser::parser::{FilterToken, NodeVisitor, ParseToken};
use ref_value::model::*;
use select::path_map::PathMap;
#[derive(Debug, Clone)]
pub enum ValueFilterKey {
@ -52,16 +49,14 @@ pub struct ValueFilter {
value_mgr: ValueManager,
last_key: Option<ValueFilterKey>,
is_relative: bool,
path_map: Arc<RefCell<PathMap>>,
}
impl ValueFilter {
pub fn new(v: RefValueWrapper, is_leaves: bool, is_relative: bool, path_map: Arc<RefCell<PathMap>>) -> Self {
pub fn new(v: RefValueWrapper, is_leaves: bool, is_relative: bool) -> Self {
ValueFilter {
value_mgr: ValueManager::new(v, is_leaves, path_map.clone()),
value_mgr: ValueManager::new(v, is_leaves),
last_key: None,
is_relative,
path_map,
}
}
@ -69,7 +64,7 @@ impl ValueFilter {
let mut buf = Vec::new();
collect_all(key, &self.value_mgr.get_val(), &mut buf);
trace!("step_leaves - {:?}", buf);
self.value_mgr = ValueManager::new(RefValue::Array(buf).into(), true, self.path_map.clone());
self.value_mgr = ValueManager::new(RefValue::Array(buf).into(), true);
}
pub fn step_leaves_all(&mut self) -> &ValueManager {
@ -136,17 +131,15 @@ impl ValueFilter {
pub struct JsonValueFilter {
json: RefValueWrapper,
path_map: Arc<RefCell<PathMap>>,
filter_stack: Vec<ValueFilter>,
token_stack: Vec<ParseToken>,
term_stack: Vec<TermContext>,
}
impl JsonValueFilter {
pub fn new(json: RefValueWrapper, path_map: Arc<RefCell<PathMap>>) -> Self {
pub fn new(json: RefValueWrapper) -> Self {
JsonValueFilter {
json,
path_map,
filter_stack: Vec::new(),
token_stack: Vec::new(),
term_stack: Vec::new(),
@ -164,7 +157,6 @@ impl JsonValueFilter {
ValueFilter::new(vf.value_mgr.get_val().clone(),
vf.value_mgr.is_leaves(),
is_relative,
self.path_map.clone(),
)
})
.and_then(|vf| {
@ -175,7 +167,6 @@ impl JsonValueFilter {
self.json.clone(),
false,
is_relative,
self.path_map.clone(),
);
self.filter_stack.push(vf);
}
@ -187,7 +178,6 @@ impl JsonValueFilter {
v,
is_leaves,
false,
self.path_map.clone(),
));
return;
}
@ -348,8 +338,8 @@ impl JsonValueFilter {
FilterToken::GreaterOrEqual => left.ge(&mut right),
FilterToken::Little => left.lt(&mut right),
FilterToken::LittleOrEqual => left.le(&mut right),
FilterToken::And => left.and(&mut right, self.path_map.clone()),
FilterToken::Or => left.or(&mut right, self.path_map.clone()),
FilterToken::And => left.and(&mut right),
FilterToken::Or => left.or(&mut right),
};
self.term_stack.push(tc);
}

27
src/filter/value_manager.rs
View File

@ -1,12 +1,9 @@
use std::cell::RefCell;
use std::ops::Deref;
use std::sync::Arc;
use indexmap::{IndexMap, IndexSet};
use serde_json::Value;
use ref_value::model::*;
use select::path_map::PathMap;
use super::cmp::*;
use super::term::*;
@ -176,13 +173,12 @@ pub type ValueWrapper = ValueManager;
#[derive(Debug)]
pub struct ValueManager {
val: RefValueWrapper,
path_map: Arc<RefCell<PathMap>>,
is_leaves: bool,
}
impl ValueManager {
pub fn new(val: RefValueWrapper, is_leaves: bool, path_map: Arc<RefCell<PathMap>>) -> Self {
ValueManager { val, is_leaves, path_map }
pub fn new(val: RefValueWrapper, is_leaves: bool) -> Self {
ValueManager { val, is_leaves }
}
pub fn is_leaves(&self) -> bool {
@ -226,16 +222,13 @@ impl ValueManager {
}
let ret = set.into_iter().collect();
Self::new(
RefValue::Array(ret).into(),
false,
self.path_map.clone())
Self::new(RefValue::Array(ret).into(), false)
}
_ => {
if cmp_with_term(&self.val, et, &cmp, false, reverse) {
Self::new(self.val.clone(), false, self.path_map.clone())
Self::new(self.val.clone(), false)
} else {
Self::new(RefValue::Null.into(), false, self.path_map.clone())
Self::new(RefValue::Null.into(), false)
}
}
}
@ -427,7 +420,7 @@ impl ValueManager {
}
let vec = ret.into_iter().map(|v| v.clone()).collect();
ValueManager::new(RefValue::Array(vec).into(), false, self.path_map.clone())
ValueManager::new(RefValue::Array(vec).into(), false)
}
pub fn intersect(&self, other: &Self) -> Self {
@ -450,7 +443,7 @@ impl ValueManager {
}
let vec = ret.into_iter().map(|v| v.clone()).collect();
ValueManager::new(RefValue::Array(vec).into(), false, self.path_map.clone())
ValueManager::new(RefValue::Array(vec).into(), false)
}
pub fn union(&self, other: &Self) -> Self {
@ -478,7 +471,7 @@ impl ValueManager {
}
let vec = ret.into_iter().map(|v| v.clone()).collect();
ValueManager::new(RefValue::Array(vec).into(), false, self.path_map.clone())
ValueManager::new(RefValue::Array(vec).into(), false)
}
pub fn into_term(&self, key: &Option<ValueFilterKey>) -> TermContext {
@ -489,7 +482,7 @@ impl ValueManager {
_ => TermContext::Json(match key {
Some(vk) => Some(vk.clone()),
_ => None
}, ValueManager::new(self.val.clone(), false, self.path_map.clone()))
}, ValueManager::new(self.val.clone(), false))
}
}
@ -519,6 +512,6 @@ impl ValueManager {
_ => self.val.clone()
};
ValueManager::new(v, false, self.path_map.clone())
ValueManager::new(v, false)
}
}

3
src/select/mod.rs
View File

@ -1,3 +1,2 @@
pub mod selector;
pub mod modifiable;
pub mod path_map;
pub mod modifiable;

53
src/select/path_map.rs
View File

@ -1,53 +0,0 @@
//use std::collections::HashMap;
use std::ops::Deref;
use ref_value::model::{RefValue, RefValueWrapper};
use indexmap::IndexMap;
#[derive(Debug)]
pub struct PathMap {
map: IndexMap<RefValueWrapper, String>
}
impl PathMap {
pub(in select) fn new() -> Self {
PathMap { map: IndexMap::new() }
}
pub fn get_path(&self, v: &RefValueWrapper) -> Option<&String> {
self.map.get(v)
}
pub(in select) fn replace(&mut self, v: &RefValueWrapper) {
self.map.clear();
self.walk("".to_string(), v);
}
fn walk(&mut self, parent_path: String, v: &RefValueWrapper) {
if &parent_path == "" {
self.map.insert(v.clone(), "/".to_string());
} else {
self.map.insert(v.clone(), parent_path.clone());
}
match v.deref() {
RefValue::Object(map) => {
for (key, value) in map {
self.walk(format!("{}/{}", &parent_path, key), value);
}
}
RefValue::Array(vec) => {
for (index, value) in vec.iter().enumerate() {
self.walk(format!("{}/{}", &parent_path, index), value);
}
}
_ => {}
};
}
pub fn print(&self) {
for (k, v) in &self.map {
println!("{:?} : {}", k, v);
}
}
}

15
src/select/selector.rs
View File

@ -7,9 +7,6 @@ use filter::value_filter::*;
use parser::parser::*;
use ref_value;
use ref_value::model::*;
use select::path_map::PathMap;
use std::sync::Arc;
use std::cell::RefCell;
/// Utility. Functions like jsonpath::selector or jsonpath::compile are also implemented using this structure.
///
@ -110,12 +107,11 @@ use std::cell::RefCell;
pub struct Selector {
pub(crate) node: Option<Node>,
pub(crate) value: Option<RefValueWrapper>,
path_builder: Arc<RefCell<PathMap>>,
}
impl Selector {
pub fn new() -> Self {
Selector { node: None, value: None, path_builder: Arc::new(RefCell::new(PathMap::new())) }
Selector { node: None, value: None }
}
fn set_value(&mut self, value: RefValueWrapper) {
@ -157,8 +153,7 @@ impl Selector {
fn jf(&self) -> result::Result<JsonValueFilter, String> {
match &self.value {
Some(v) => Ok(JsonValueFilter::new(v.clone(),
self.path_builder.clone())),
Some(v) => Ok(JsonValueFilter::new(v.clone())),
_ => return Err(SelectorErrorMessage::EmptyValue.to_string())
}
}
@ -194,10 +189,6 @@ impl Selector {
serde_json::to_string(self.select()?.deref()).map_err(|e| e.to_string())
}
pub fn select_as_value2(&self) {
let _ = &self.select();
}
pub fn select_as_value(&self) -> result::Result<Value, String> {
Ok((&self.select()?).into())
}
@ -212,7 +203,7 @@ impl Selector {
match func((&self.select()?).into()).map(|ref v| v.into()) {
Some(value) => {
self.set_value(value)
},
}
_ => {}
}
Ok(self)

107
tests/filter.rs
View File

@ -8,19 +8,18 @@ use std::io::Read;
use serde_json::Value;
use jsonpath::filter::value_filter::{JsonValueFilter, ValueFilter};
use jsonpath::parser::parser::Parser;
use jsonpath::Selector;
use jsonpath::filter::value_filter::ValueFilter;
fn setup() {
let _ = env_logger::try_init();
}
//fn new_value_filter(file: &str) -> ValueFilter {
// let string = read_json(file);
// let json: Value = serde_json::from_str(string.as_str()).unwrap();
// ValueFilter::new((&json).into(), false, false)
//}
fn new_value_filter(file: &str) -> ValueFilter {
let string = read_json(file);
let json: Value = serde_json::from_str(string.as_str()).unwrap();
ValueFilter::new((&json).into(), false, false)
}
fn selector(path: &str, file: &str) -> Selector {
let string = read_json(file);
@ -37,53 +36,53 @@ fn read_json(path: &str) -> String {
contents
}
//#[test]
//fn step_in() {
// setup();
//
// let mut jf = new_value_filter("./benches/data_obj.json");
// {
// let current = jf.step_in_str("friends");
// assert_eq!(current.is_array(), true);
// }
//
// let mut jf = new_value_filter("./benches/data_array.json");
// {
// let current = jf.step_in_num(&1.0);
// assert_eq!(current.get_val().is_object(), true);
// }
// {
// let current = jf.step_in_str("friends");
// assert_eq!(current.is_array(), true);
// }
// let mut jf = new_value_filter("./benches/data_obj.json");
// {
// jf.step_in_str("school");
// jf.step_in_str("friends");
// jf.step_in_all();
// let current = jf.step_in_str("name");
// let friends = json!([
// "Millicent Norman",
// "Vincent Cannon",
// "Gray Berry"
// ]);
//
// assert_eq!(friends, current.into_value());
// }
// let mut jf = new_value_filter("./benches/data_obj.json");
// {
// let current = jf.step_leaves_str("name");
// let names = json!([
// "Leonor Herman",
// "Millicent Norman",
// "Vincent Cannon",
// "Gray Berry",
// "Vincent Cannon",
// "Gray Berry"
// ]);
// assert_eq!(names, current.into_value());
// }
//}
#[test]
fn step_in() {
setup();
let mut jf = new_value_filter("./benches/data_obj.json");
{
let current = jf.step_in_str("friends");
assert_eq!(current.is_array(), true);
}
let mut jf = new_value_filter("./benches/data_array.json");
{
let current = jf.step_in_num(&1.0);
assert_eq!(current.get_val().is_object(), true);
}
{
let current = jf.step_in_str("friends");
assert_eq!(current.is_array(), true);
}
let mut jf = new_value_filter("./benches/data_obj.json");
{
jf.step_in_str("school");
jf.step_in_str("friends");
jf.step_in_all();
let current = jf.step_in_str("name");
let friends = json!([
"Millicent Norman",
"Vincent Cannon",
"Gray Berry"
]);
assert_eq!(friends, current.into_value());
}
let mut jf = new_value_filter("./benches/data_obj.json");
{
let current = jf.step_leaves_str("name");
let names = json!([
"Leonor Herman",
"Millicent Norman",
"Vincent Cannon",
"Gray Berry",
"Vincent Cannon",
"Gray Berry"
]);
assert_eq!(names, current.into_value());
}
}
#[test]
fn array() {

118
wasm/src/lib.rs
View File

@ -1,18 +1,14 @@
extern crate cfg_if;
extern crate js_sys;
extern crate jsonpath_lib as jsonpath;
#[macro_use]
extern crate lazy_static;
extern crate serde;
extern crate serde_json;
extern crate wasm_bindgen;
extern crate web_sys;
use std::collections::HashMap;
use std::ops::Deref;
use std::result;
use std::result::Result;
use std::sync::{Mutex, Arc};
use cfg_if::cfg_if;
use jsonpath::filter::value_filter::JsonValueFilter;
@ -23,8 +19,6 @@ use serde_json::Value;
use wasm_bindgen::*;
use wasm_bindgen::prelude::*;
use web_sys::console;
use std::cell::RefCell;
use jsonpath::select::path_map::PathMap;
cfg_if! {
if #[cfg(feature = "wee_alloc")] {
@ -45,14 +39,13 @@ cfg_if! {
}
fn filter_ref_value(json: RefValueWrapper, node: Node) -> JsValue {
// let mut jf = JsonValueFilter::new(json, Arc::new(RefCell::new(PathMap::new())));
// jf.visit(node);
// let taken = &jf.clone_value();
// match JsValue::from_serde(taken.deref()) {
// Ok(js_value) => js_value,
// Err(e) => JsValue::from_str(&format!("Json deserialize error: {:?}", e))
// }
JsValue::from_str("")
let mut jf = JsonValueFilter::new(json);
jf.visit(node);
let taken = &jf.clone_value();
match JsValue::from_serde(taken.deref()) {
Ok(js_value) => js_value,
Err(e) => JsValue::from_str(&format!("Json deserialize error: {:?}", e))
}
}
fn into_serde_json<D>(js_value: &JsValue) -> Result<D, String>
@ -80,51 +73,7 @@ fn into_ref_value(js_value: &JsValue, node: Node) -> JsValue {
}
fn get_ref_value(js_value: JsValue, node: Node) -> JsValue {
// match js_value.as_f64() {
// Some(val) => {
// match CACHE_JSON.lock().unwrap().get(&(val as usize)) {
// Some(json) => filter_ref_value(json.clone(), node),
// _ => JsValue::from_str("Invalid pointer")
// }
// }
// _ => into_ref_value(&js_value, node)
// }
JsValue::from_str("")
}
//lazy_static! {
// static ref CACHE_JSON: Mutex<HashMap<usize, RefValueWrapper>> = Mutex::new(HashMap::new());
// static ref CACHE_JSON_IDX: Mutex<usize> = Mutex::new(0);
//}
#[wasm_bindgen(js_name = allocJson)]
pub extern fn alloc_json(js_value: JsValue) -> usize {
// let result: result::Result<RefValue, String> = into_serde_json(&js_value);
// match result {
// Ok(json) => {
// let mut map = CACHE_JSON.lock().unwrap();
// if map.len() >= std::u8::MAX as usize {
// return 0;
// }
//
// let mut idx = CACHE_JSON_IDX.lock().unwrap();
// *idx += 1;
// map.insert(*idx, json.into());
// *idx
// }
// Err(e) => {
// console::error_1(&e.into());
// 0
// }
// }
0
}
#[wasm_bindgen(js_name = deallocJson)]
pub extern fn dealloc_json(ptr: usize) -> bool {
// let mut map = CACHE_JSON.lock().unwrap();
// map.remove(&ptr).is_some()
false
into_ref_value(&js_value, node)
}
#[wasm_bindgen]
@ -145,35 +94,22 @@ pub fn compile(path: &str) -> JsValue {
#[wasm_bindgen]
pub fn selector(js_value: JsValue) -> JsValue {
// let json = match js_value.as_f64() {
// Some(val) => {
// match CACHE_JSON.lock().unwrap().get(&(val as usize)) {
// Some(json) => json.clone(),
// _ => return JsValue::from_str("Invalid pointer")
// }
// }
// _ => {
// match into_serde_json::<RefValue>(&js_value) {
// Ok(json) => json.into(),
// Err(e) => return JsValue::from_str(e.as_str())
// }
// }
let json: RefValueWrapper = match into_serde_json::<RefValue>(&js_value) {
Ok(json) => json.into(),
Err(e) => return JsValue::from_str(e.as_str())
};
// };
let cb = Closure::wrap(Box::new(move |path: String| {
let mut parser = Parser::new(path.as_str());
match parser.compile() {
Ok(node) => filter_ref_value(json.clone(), node),
Err(e) => return JsValue::from_str(e.as_str())
}
}) as Box<Fn(String) -> JsValue>);
// let cb = Closure::wrap(Box::new(move |path: String| {
// let mut parser = Parser::new(path.as_str());
// match parser.compile() {
// Ok(node) => filter_ref_value(json.clone(), node),
// Err(e) => return JsValue::from_str(e.as_str())
// }
// }) as Box<Fn(String) -> JsValue>);
//
// let ret = cb.as_ref().clone();
// cb.forget();
// ret
JsValue::from_str("")
let ret = cb.as_ref().clone();
cb.forget();
ret
}
#[wasm_bindgen]
@ -279,14 +215,4 @@ impl Selector {
let v = self.selector.get().map_err(|e| JsValue::from_str(&e.to_string()))?;
JsValue::from_serde(&v).map_err(|e| JsValue::from_str(&e.to_string()))
}
}
#[wasm_bindgen(catch)]
pub fn testa(js_value: JsValue, path: &str, iter: usize) -> result::Result<(), JsValue> {
for _ in 0..iter {
let mut parser = Parser::new(path);
let node = parser.compile().unwrap();
into_ref_value(&js_value, node);
}
Ok(())
}

14
wasm/tests/web.rs
View File

@ -95,20 +95,6 @@ fn selector() {
assert_eq!(json, target_json());
}
#[wasm_bindgen_test]
fn alloc_dealloc_json() {
let ptr = jsonpath::alloc_json(JsValue::from_str(json_str()));
assert_eq!(ptr > 0, true);
let json: Value = jsonpath::select(JsValue::from_f64(ptr as f64), "$..book[2]").into_serde().unwrap();
assert_eq!(json, target_json());
assert_eq!(jsonpath::dealloc_json(ptr), true);
let err = jsonpath::select(JsValue::from_f64(ptr as f64), "$..book[2]").as_string().unwrap();
assert_eq!(err, "Invalid pointer".to_string());
}
#[wasm_bindgen_test]
fn selector_struct() {
let mut selector = jsonpath::Selector::new();

9
wasm/www_bench/index.js
View File

@ -61,9 +61,6 @@ let path = '$..book[?(@.price<30 && @.category=="fiction")]';
let template = jpw.compile(path);
let selector = jpw.selector(json);
let ptr = jpw.allocJson(json);
if(ptr == 0) console.error('invalid ptr');
let iterCount = 2000;
run('jsonpath', iterCount, function() { jp.query(json, path) })
@ -73,15 +70,9 @@ run('jsonpath', iterCount, function() { jp.query(json, path) })
.then(function() {
return run('jsonpath-wasm- compile', iterCount, function() { template(json) });
})
.then(function() {
return run('jsonpath-wasm- compile-alloc', iterCount, function() { template(ptr) });
})
.then(function() {
return run('jsonpath-wasm- select', iterCount, function() { jpw.select(json, path) });
})
.then(function() {
return run('jsonpath-wasm- select-alloc', iterCount, function() { jpw.select(ptr, path) });
})
.finally(function() {
if(!jpw.deallocJson(ptr)) {
console.error('fail to dealloc');