v_common_onto/
individual.rs

1use crate::datatype::{DataType, Lang};
2use crate::parser::*;
3use crate::resource::{Resource, Value};
4use chrono::offset::LocalResult::Single;
5use chrono::{DateTime, Local, NaiveDateTime, TimeZone};
6use num::FromPrimitive;
7use num_traits::pow;
8use rust_decimal::Decimal;
9use std::collections::HashMap;
10use std::fmt;
11use std::io::{Error, ErrorKind};
12use std::ops::Sub;
13use std::str::FromStr;
14
15#[derive(PartialEq, Debug, Clone)]
16pub enum IndividualError {
17    None,
18    ParseError,
19}
20
21#[derive(Debug)]
22pub struct IndividualObj {
23    pub(crate) uri: String,
24    pub(crate) resources: HashMap<String, Vec<Resource>>,
25}
26
27#[derive(Debug)]
28pub struct RawObj {
29    pub data: Vec<u8>,
30    pub(crate) cur: u64,
31    pub(crate) len_predicates: u32,
32    pub(crate) cur_predicates: u32,
33    pub(crate) raw_type: RawType,
34}
35
36impl RawObj {
37    pub fn new(buff: Vec<u8>) -> RawObj {
38        RawObj {
39            data: buff,
40            raw_type: RawType::Unknown,
41            cur: 0,
42            len_predicates: 0,
43            cur_predicates: 0,
44        }
45    }
46
47    pub fn new_empty() -> RawObj {
48        RawObj {
49            data: Vec::new(),
50            raw_type: RawType::Unknown,
51            cur: 0,
52            len_predicates: 0,
53            cur_predicates: 0,
54        }
55    }
56}
57
58#[derive(Debug)]
59pub struct Individual {
60    pub(crate) obj: IndividualObj,
61    pub(crate) raw: RawObj,
62}
63
64impl Default for Individual {
65    fn default() -> Self {
66        Individual {
67            obj: IndividualObj::default(),
68            raw: RawObj::new_empty(),
69        }
70    }
71}
72
73impl Individual {
74    pub fn new_raw(raw: RawObj) -> Self {
75        Individual {
76            obj: IndividualObj::default(),
77            raw,
78        }
79    }
80
81    pub fn new_from_obj(obj: &IndividualObj) -> Self {
82        let mut new_obj = IndividualObj {
83            uri: obj.uri.to_owned(),
84            resources: Default::default(),
85        };
86
87        for (predicate, resources) in obj.resources.iter() {
88            let mut new_resources = vec![];
89            for r in resources {
90                new_resources.push(r.get_copy());
91            }
92            new_obj.resources.insert(predicate.to_owned(), new_resources);
93        }
94
95        Individual {
96            obj: new_obj,
97            raw: RawObj {
98                data: vec![],
99                cur: 0,
100                len_predicates: 0,
101                cur_predicates: 0,
102                raw_type: RawType::Cbor,
103            },
104        }
105    }
106
107    pub fn is_empty(&self) -> bool {
108        self.obj.resources.is_empty()
109    }
110
111    pub fn get_obj(&self) -> &IndividualObj {
112        &self.obj
113    }
114
115    pub fn remove(&mut self, predicate: &str) -> bool {
116        self.obj.remove(predicate)
117    }
118
119    pub fn clear(&mut self, predicate: &str) {
120        self.obj.clear(predicate);
121    }
122
123    pub fn add_bool(&mut self, predicate: &str, b: bool) {
124        self.obj.add_bool(predicate, b)
125    }
126
127    pub fn set_bool(&mut self, predicate: &str, b: bool) {
128        self.obj.set_bool(predicate, b)
129    }
130
131    pub fn add_datetime(&mut self, predicate: &str, i: i64) {
132        self.obj.add_datetime(predicate, i)
133    }
134
135    pub fn add_datetime_from_str(&mut self, predicate: &str, value: &str) {
136        if value.contains('Z') {
137            if let Ok(v) = DateTime::parse_from_rfc3339(&value) {
138                self.add_datetime(&predicate, v.timestamp());
139            } else {
140                error!("fail parse [{}] to datetime", value);
141            }
142        } else {
143            let ndt;
144            if value.len() == 10 {
145                if value.contains('.') {
146                    ndt = NaiveDateTime::parse_from_str(&(value.to_owned() + "T00:00:00"), "%d.%m.%YT%H:%M:%S");
147                } else {
148                    ndt = NaiveDateTime::parse_from_str(&(value.to_owned() + "T00:00:00"), "%Y-%m-%dT%H:%M:%S");
149                }
150            } else {
151                ndt = NaiveDateTime::parse_from_str(&value, "%Y-%m-%dT%H:%M:%S")
152            }
153
154            if let Ok(v) = ndt {
155                if let Single(offset) = Local.offset_from_local_datetime(&v) {
156                    self.add_datetime(&predicate, v.sub(offset).timestamp());
157                } else {
158                    self.add_datetime(&predicate, v.timestamp());
159                }
160            } else {
161                error!("fail parse [{}] to datetime", value);
162            }
163        }
164    }
165
166    pub fn set_datetime(&mut self, predicate: &str, i: i64) {
167        self.obj.set_datetime(predicate, i)
168    }
169
170    pub fn add_binary(&mut self, predicate: &str, v: Vec<u8>) {
171        self.obj.add_binary(predicate, v)
172    }
173
174    pub fn set_binary(&mut self, predicate: &str, v: Vec<u8>) {
175        self.obj.set_binary(predicate, v)
176    }
177
178    pub fn add_integer(&mut self, predicate: &str, i: i64) {
179        self.obj.add_integer(predicate, i)
180    }
181
182    pub fn set_resources(&mut self, predicate: &str, v: &[Resource]) {
183        for el in v.iter() {
184            match el.rtype {
185                DataType::String => self.set_string(predicate, el.get_str(), el.get_lang()),
186                DataType::Uri => self.set_uri(predicate, el.get_uri()),
187                DataType::Datetime => self.set_datetime(predicate, el.get_datetime()),
188                DataType::Integer => self.set_integer(predicate, el.get_int()),
189                DataType::Decimal => {
190                    let d = el.get_num();
191                    self.set_decimal_d(predicate, d.0, d.1);
192                }
193                DataType::Boolean => self.set_bool(predicate, el.get_bool()),
194                DataType::Binary => {}
195            }
196        }
197    }
198
199    pub fn set_integer(&mut self, predicate: &str, i: i64) {
200        self.obj.set_integer(predicate, i)
201    }
202
203    pub fn add_decimal_d(&mut self, predicate: &str, mantissa: i64, exponent: i64) {
204        self.obj.add_decimal_d(predicate, mantissa, exponent)
205    }
206
207    pub fn add_decimal_from_str(&mut self, predicate: &str, value: &str) {
208        if let Ok(v) = Decimal::from_str(value) {
209            let exp = -(v.scale() as i32);
210            if let Ok(m) = value.replace('.', "").parse::<i64>() {
211                self.add_decimal_d(&predicate, m, exp as i64);
212            }
213        } else {
214            error!("fail parse [{}] to decimal", value);
215        }
216    }
217
218    pub fn add_decimal_from_i64(&mut self, predicate: &str, value: i64) {
219        self.add_decimal_d(&predicate, value, 0);
220    }
221
222    pub fn add_decimal_from_f64(&mut self, predicate: &str, value: f64) {
223        if let Some(v) = Decimal::from_f64(value) {
224            let exp = v.scale() as usize;
225            let p: i64 = pow(10, exp);
226            let mantissa: f64 = value * p as f64;
227            self.add_decimal_d(&predicate, mantissa as i64, -(exp as i64));
228        } else {
229            error!("fail parse [{}] to decimal", value);
230        }
231    }
232
233    pub fn set_decimal_d(&mut self, predicate: &str, mantissa: i64, exponent: i64) {
234        self.obj.set_decimal_d(predicate, mantissa, exponent)
235    }
236
237    pub fn add_uri(&mut self, predicate: &str, s: &str) {
238        self.obj.add_uri(predicate, s)
239    }
240
241    pub fn set_uri(&mut self, predicate: &str, s: &str) {
242        self.obj.set_uri(predicate, s)
243    }
244
245    pub fn set_uris(&mut self, predicate: &str, ss: Vec<String>) {
246        self.obj.set_uris(predicate, ss)
247    }
248
249    pub fn add_string(&mut self, predicate: &str, s: &str, lang: Lang) {
250        self.obj.add_string(predicate, s, lang)
251    }
252
253    pub fn set_string(&mut self, predicate: &str, s: &str, lang: Lang) {
254        self.obj.set_string(predicate, s, lang)
255    }
256
257    pub fn set_raw(&mut self, data: &[u8]) {
258        self.raw.data = data.to_vec();
259    }
260
261    pub fn get_raw_len(&self) -> usize {
262        self.raw.data.len()
263    }
264
265    pub fn set_id(&mut self, id: &str) -> &mut Self {
266        self.obj.uri = id.to_owned();
267        self
268    }
269
270    pub fn get_id(&self) -> &str {
271        &self.obj.uri
272    }
273
274    pub fn is_exists(&mut self, predicate: &str) -> bool {
275        for _ in 0..2 {
276            match self.obj.resources.get(predicate) {
277                Some(v) => {
278                    return !v.is_empty();
279                }
280                None => {
281                    if self.raw.cur < self.raw.data.len() as u64 {
282                        // next parse
283                        if !parse_to_predicate(predicate, self) {
284                            break;
285                        }
286                    } else {
287                        break;
288                    }
289                }
290            }
291        }
292        false
293    }
294
295    pub fn any_exists(&mut self, predicate: &str, values: &[&str]) -> bool {
296        for _ in 0..2 {
297            match self.obj.resources.get(predicate) {
298                Some(v) => {
299                    for el in v {
300                        if let Value::Str(s, _l) = &el.value {
301                            for ve in values {
302                                if str::eq(ve, s) {
303                                    return true;
304                                }
305                            }
306                        } else if let Value::Uri(s) = &el.value {
307                            for ve in values {
308                                if str::eq(ve, s) {
309                                    return true;
310                                }
311                            }
312                        }
313                    }
314                }
315                None => {
316                    if self.raw.cur < self.raw.data.len() as u64 {
317                        // next parse
318                        if !parse_to_predicate(predicate, self) {
319                            break;
320                        }
321                    } else {
322                        break;
323                    }
324                }
325            }
326        }
327        false
328    }
329
330    pub fn any_exists_v(&mut self, predicate: &str, values: &[String]) -> bool {
331        for _ in 0..2 {
332            match self.obj.resources.get(predicate) {
333                Some(v) => {
334                    for el in v {
335                        if let Value::Str(s, _l) = &el.value {
336                            for ve in values {
337                                if str::eq(ve, s) {
338                                    return true;
339                                }
340                            }
341                        } else if let Value::Uri(s) = &el.value {
342                            for ve in values {
343                                if str::eq(ve, s) {
344                                    return true;
345                                }
346                            }
347                        }
348                    }
349                }
350                None => {
351                    if self.raw.cur < self.raw.data.len() as u64 {
352                        // next parse
353                        if !parse_to_predicate(predicate, self) {
354                            break;
355                        }
356                    } else {
357                        break;
358                    }
359                }
360            }
361        }
362        false
363    }
364
365    pub fn is_exists_bool(&mut self, predicate: &str, value: bool) -> bool {
366        for _ in 0..2 {
367            match self.obj.resources.get(predicate) {
368                Some(v) => {
369                    for el in v {
370                        if let Value::Bool(v) = &el.value {
371                            if bool::eq(&value, v) {
372                                return true;
373                            }
374                        }
375                    }
376                }
377                None => {
378                    if self.raw.cur < self.raw.data.len() as u64 {
379                        // next parse
380                        if !parse_to_predicate(predicate, self) {
381                            break;
382                        }
383                    } else {
384                        break;
385                    }
386                }
387            }
388        }
389        false
390    }
391
392    pub fn get_resources(&mut self, predicate: &str) -> Option<Vec<Resource>> {
393        for _ in 0..2 {
394            match self.obj.resources.get(predicate) {
395                Some(v) => {
396                    return Some(v.iter().map(|el| el.get_copy()).collect::<Vec<Resource>>());
397                }
398                None => {
399                    if self.raw.cur < self.raw.data.len() as u64 {
400                        // next parse
401                        if !parse_to_predicate(predicate, self) {
402                            break;
403                        }
404                    } else {
405                        break;
406                    }
407                }
408            }
409        }
410        None
411    }
412
413    pub fn get_literals(&mut self, predicate: &str) -> Option<Vec<String>> {
414        for _ in 0..2 {
415            match self.obj.resources.get(predicate) {
416                Some(v) => {
417                    return Some(
418                        v.iter()
419                            .map(|el| {
420                                if let Value::Str(s, _l) = &el.value {
421                                    s.to_string()
422                                } else if let Value::Uri(s) = &el.value {
423                                    s.to_string()
424                                } else {
425                                    "".to_string()
426                                }
427                            })
428                            .collect::<Vec<String>>(),
429                    );
430                }
431                None => {
432                    if self.raw.cur < self.raw.data.len() as u64 {
433                        // next parse
434                        if !parse_to_predicate(predicate, self) {
435                            break;
436                        }
437                    } else {
438                        break;
439                    }
440                }
441            }
442        }
443        None
444    }
445
446    pub fn get_literals_nm(&self, predicate: &str) -> Option<Vec<String>> {
447        self.obj.resources.get(predicate).map(|v| {
448            v.iter()
449                .map(|el| {
450                    if let Value::Str(s, _l) = &el.value {
451                        s.to_string()
452                    } else if let Value::Uri(s) = &el.value {
453                        s.to_string()
454                    } else {
455                        "".to_string()
456                    }
457                })
458                .collect::<Vec<String>>()
459        })
460    }
461
462    pub fn get_first_literal_or_err(&mut self, predicate: &str) -> Result<String, std::io::Error> {
463        if let Some(v) = self.get_first_literal(predicate) {
464            Ok(v)
465        } else {
466            Err(Error::new(ErrorKind::NotFound, predicate))
467        }
468    }
469
470    pub fn get_first_literal(&mut self, predicate: &str) -> Option<String> {
471        for _ in 0..2 {
472            match self.obj.resources.get(predicate) {
473                Some(v) => match &v[0].value {
474                    Value::Str(s, _l) => {
475                        return Some(s.to_string());
476                    }
477                    Value::Uri(s) => {
478                        return Some(s.to_string());
479                    }
480                    _ => {
481                        return None;
482                    }
483                },
484                None => {
485                    if self.raw.cur < self.raw.data.len() as u64 {
486                        // next parse
487                        if !parse_to_predicate(predicate, self) {
488                            break;
489                        }
490                    } else {
491                        break;
492                    }
493                }
494            }
495        }
496        None
497    }
498
499    pub fn get_first_literal_with_lang(&mut self, predicate: &str, lang: &[Lang]) -> Option<String> {
500        for _ in 0..2 {
501            match self.obj.resources.get(predicate) {
502                Some(v) => {
503                    for r in v.iter() {
504                        match &r.value {
505                            Value::Str(s, l) => {
506                                if lang.contains(l) {
507                                    return Some(s.to_string());
508                                }
509                            }
510                            Value::Uri(s) => {
511                                return Some(s.to_string());
512                            }
513                            _ => {
514                                return None;
515                            }
516                        }
517                    }
518                }
519                None => {
520                    if self.raw.cur < self.raw.data.len() as u64 {
521                        // next parse
522                        if !parse_to_predicate(predicate, self) {
523                            break;
524                        }
525                    } else {
526                        break;
527                    }
528                }
529            }
530        }
531        None
532    }
533
534    pub fn get_first_bool(&mut self, predicate: &str) -> Option<bool> {
535        for _ in 0..2 {
536            match self.obj.resources.get(predicate) {
537                Some(v) => match &v[0].value {
538                    Value::Bool(s) => {
539                        return Some(*s);
540                    }
541                    _ => {
542                        return None;
543                    }
544                },
545                None => {
546                    if self.raw.cur < self.raw.data.len() as u64 {
547                        // next parse
548                        if !parse_to_predicate(predicate, self) {
549                            break;
550                        }
551                    } else {
552                        break;
553                    }
554                }
555            }
556        }
557        None
558    }
559
560    pub fn get_first_binobj(&mut self, predicate: &str) -> Option<Vec<u8>> {
561        for _ in 0..2 {
562            match self.obj.resources.get(predicate) {
563                Some(v) => match &v[0].value {
564                    Value::Binary(s) => {
565                        return Some(s.clone());
566                    }
567                    _ => {
568                        return None;
569                    }
570                },
571                None => {
572                    if self.raw.cur < self.raw.data.len() as u64 {
573                        // next parse
574                        if !parse_to_predicate(predicate, self) {
575                            break;
576                        }
577                    } else {
578                        break;
579                    }
580                }
581            }
582        }
583        None
584    }
585
586    pub fn get_first_integer(&mut self, predicate: &str) -> Option<i64> {
587        for _ in 0..2 {
588            match self.obj.resources.get(predicate) {
589                Some(v) => {
590                    if let Value::Int(i) = &v[0].value {
591                        return Some(*i);
592                    }
593                }
594                None => {
595                    if self.raw.cur < self.raw.data.len() as u64 {
596                        // next parse
597                        if !parse_to_predicate(predicate, self) {
598                            break;
599                        }
600                    } else {
601                        break;
602                    }
603                }
604            }
605        }
606        None
607    }
608
609    pub fn get_first_number(&mut self, predicate: &str) -> Option<(i64, i64)> {
610        for _ in 0..2 {
611            match self.obj.resources.get(predicate) {
612                Some(v) => {
613                    if let Value::Num(m, e) = &v[0].value {
614                        return Some((*m, *e));
615                    }
616                }
617                None => {
618                    if self.raw.cur < self.raw.data.len() as u64 {
619                        // next parse
620                        if !parse_to_predicate(predicate, self) {
621                            break;
622                        }
623                    } else {
624                        break;
625                    }
626                }
627            }
628        }
629        None
630    }
631
632    pub fn get_first_datetime(&mut self, predicate: &str) -> Option<i64> {
633        for _ in 0..2 {
634            match self.obj.resources.get(predicate) {
635                Some(v) => {
636                    if let Value::Datetime(i) = &v[0].value {
637                        return Some(*i);
638                    }
639                }
640                None => {
641                    if self.raw.cur < self.raw.data.len() as u64 {
642                        // next parse
643                        if !parse_to_predicate(predicate, self) {
644                            break;
645                        }
646                    } else {
647                        break;
648                    }
649                }
650            }
651        }
652        None
653    }
654
655    pub fn get_first_float(&mut self, predicate: &str) -> Option<f64> {
656        for _ in 0..2 {
657            match self.obj.resources.get(predicate) {
658                Some(v) => {
659                    return Some(v[0].get_float());
660                }
661                None => {
662                    if self.raw.cur < self.raw.data.len() as u64 {
663                        // next parse
664                        if !parse_to_predicate(predicate, self) {
665                            break;
666                        }
667                    } else {
668                        break;
669                    }
670                }
671            }
672        }
673        None
674    }
675
676    pub fn parse_all(&mut self) -> &mut Individual {
677        while self.raw.cur < self.raw.data.len() as u64 {
678            // next parse
679            if !parse_to_predicate("?", self) {
680                break;
681            }
682        }
683
684        self
685    }
686
687    pub fn apply_predicate_as_set(&mut self, predicate: &str, new_data: &mut Individual) {
688        if let Some(v) = new_data.obj.resources.get(predicate) {
689            self.obj.set_resources(predicate, v);
690        }
691    }
692
693    pub fn apply_predicate_as_add_unique(&mut self, predicate: &str, new_data: &mut Individual) {
694        if let Some(v) = new_data.obj.resources.get(predicate) {
695            self.obj.add_unique_resources(predicate, v);
696        }
697    }
698
699    pub fn apply_predicate_as_remove(&mut self, predicate: &str, new_data: &mut Individual) {
700        if let Some(exclude) = new_data.obj.resources.get(predicate) {
701            self.obj.exclude_and_set_resources(predicate, exclude);
702        }
703    }
704
705    pub fn get_predicates(&mut self) -> Vec<String> {
706        self.parse_all();
707        let mut res: Vec<String> = Vec::new();
708
709        for (key, _vals) in self.obj.resources.iter() {
710            res.push(key.to_string());
711        }
712        res
713    }
714
715    pub fn get_predicates_nm(&self) -> Vec<String> {
716        let mut res: Vec<String> = Vec::new();
717
718        for (key, _vals) in self.obj.resources.iter() {
719            res.push(key.to_string());
720        }
721        res
722    }
723
724    pub fn get_predicates_of_type(&mut self, rtype: DataType) -> Vec<String> {
725        self.parse_all();
726        let mut res: Vec<String> = Vec::new();
727
728        for (key, vals) in self.obj.resources.iter() {
729            for val in vals.iter() {
730                if val.rtype == rtype {
731                    res.push(key.to_string());
732                    break;
733                }
734            }
735        }
736        res
737    }
738
739    pub fn compare(&self, b: &Individual, ignore_predicates: Vec<&str>) -> bool {
740        if self.obj.uri != b.obj.uri {
741            return false;
742        }
743
744        let keys = self.obj.resources.keys();
745
746        let mut counter_a = 0;
747        for predicate in keys {
748            if ignore_predicates.contains(&predicate.as_str()) {
749                continue;
750            }
751            counter_a += 1;
752            let a_value = self.obj.resources.get(predicate.as_str());
753            let b_value = b.obj.resources.get(predicate.as_str());
754
755            if a_value != b_value {
756                //info!("A != B, uri={}, predicate={}, A={:?}, B={:?}", self.obj.uri, predicate, a_value, b_value);
757                return false;
758            }
759        }
760
761        let mut counter_b = 0;
762        for predicate in b.obj.resources.keys() {
763            if ignore_predicates.contains(&predicate.as_str()) {
764                continue;
765            }
766            counter_b += 1;
767
768            if counter_b > counter_a {
769                return false;
770            }
771        }
772
773        if counter_a != counter_b {
774            return false;
775        }
776
777        true
778    }
779}
780
781impl fmt::Display for Individual {
782    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
783        write!(f, "uri={}, \n {:#?}", self.obj.uri, self.obj.resources)
784    }
785}
786
787impl Default for IndividualObj {
788    fn default() -> Self {
789        IndividualObj {
790            uri: "".to_string(),
791            resources: HashMap::new(),
792        }
793    }
794}
795
796impl IndividualObj {
797    //    pub fn get_predicates(&self) -> Vec<String> {
798    //        self.resources.iter().map(|(key, _)| key.clone()).collect()
799    //    }
800
801    //    pub fn crawl<T>(&mut self, ctx: &mut T, crawler: fn(predicate : &String, value: &Vec<Resource>, ctx: &mut T)) {
802    //        for (k, v) in &self.resources {
803    //            crawler (k, v, ctx);
804    //        }
805    //    }
806
807    pub fn get_resources(&self) -> &HashMap<String, Vec<Resource>> {
808        &self.resources
809    }
810
811    pub fn remove(&mut self, predicate: &str) -> bool {
812        self.resources.remove(predicate).is_some()
813    }
814
815    pub fn clear(&mut self, predicate: &str) {
816        let values = self.resources.entry(predicate.to_owned()).or_default();
817        values.clear();
818    }
819
820    pub fn add_unique_resources(&mut self, predicate: &str, b: &[Resource]) {
821        let values = self.resources.entry(predicate.to_owned()).or_default();
822
823        for el in b.iter() {
824            if !values.contains(el) {
825                values.push(Resource {
826                    rtype: el.rtype.clone(),
827                    order: el.order,
828                    value: el.value.clone(),
829                });
830            }
831        }
832    }
833
834    pub fn remove_resources(&mut self, predicate: &str, b: &[Resource]) {
835        let values = self.resources.entry(predicate.to_owned()).or_default();
836
837        for el in b.iter() {
838            let mut idx = 0;
839            let mut is_found = false;
840            for elv in values.iter() {
841                if elv == el {
842                    is_found = true;
843                    break;
844                }
845                idx += 1;
846            }
847
848            if is_found {
849                values.remove(idx);
850            }
851        }
852    }
853
854    pub fn set_resources(&mut self, predicate: &str, b: &[Resource]) {
855        let values = self.resources.entry(predicate.to_owned()).or_default();
856        values.clear();
857        for el in b.iter() {
858            values.push(Resource {
859                rtype: el.rtype.clone(),
860                order: el.order,
861                value: el.value.clone(),
862            });
863        }
864    }
865
866    pub fn add_resources(&mut self, predicate: &str, b: &[Resource]) {
867        let values = self.resources.entry(predicate.to_owned()).or_default();
868
869        for el in b.iter() {
870            values.push(Resource {
871                rtype: el.rtype.clone(),
872                order: values.len() as u16,
873                value: el.value.clone(),
874            });
875        }
876    }
877
878    pub fn exclude_and_set_resources(&mut self, predicate: &str, exclude: &[Resource]) {
879        let values = self.resources.entry(predicate.to_owned()).or_default();
880        let mut new_values = vec![];
881        for el in values.iter() {
882            if !exclude.contains(el) {
883                new_values.push(Resource {
884                    rtype: el.rtype.clone(),
885                    order: el.order,
886                    value: el.value.clone(),
887                });
888            }
889        }
890
891        if new_values.is_empty() {
892            self.resources.remove(predicate);
893        } else {
894            self.resources.insert(predicate.to_owned(), new_values);
895        }
896    }
897
898    pub fn add_bool(&mut self, predicate: &str, b: bool) {
899        let values = self.resources.entry(predicate.to_owned()).or_default();
900        values.push(Resource {
901            rtype: DataType::Boolean,
902            order: values.len() as u16,
903            value: Value::Bool(b),
904        });
905    }
906
907    pub fn set_bool(&mut self, predicate: &str, b: bool) {
908        let values = self.resources.entry(predicate.to_owned()).or_default();
909        values.clear();
910        values.push(Resource {
911            rtype: DataType::Boolean,
912            order: 0,
913            value: Value::Bool(b),
914        });
915    }
916
917    pub fn add_datetime(&mut self, predicate: &str, i: i64) {
918        let values = self.resources.entry(predicate.to_owned()).or_default();
919        values.push(Resource {
920            rtype: DataType::Datetime,
921            order: values.len() as u16,
922            value: Value::Datetime(i),
923        });
924    }
925
926    pub fn set_datetime(&mut self, predicate: &str, i: i64) {
927        let values = self.resources.entry(predicate.to_owned()).or_default();
928        values.clear();
929        values.push(Resource {
930            rtype: DataType::Datetime,
931            order: 0,
932            value: Value::Datetime(i),
933        });
934    }
935
936    pub fn add_binary(&mut self, predicate: &str, v: Vec<u8>) {
937        let values = self.resources.entry(predicate.to_owned()).or_default();
938        values.push(Resource {
939            rtype: DataType::Binary,
940            order: values.len() as u16,
941            value: Value::Binary(v),
942        });
943    }
944
945    pub fn set_binary(&mut self, predicate: &str, v: Vec<u8>) {
946        let values = self.resources.entry(predicate.to_owned()).or_default();
947        values.clear();
948        values.push(Resource {
949            rtype: DataType::Binary,
950            order: 0,
951            value: Value::Binary(v),
952        });
953    }
954
955    pub fn add_integer(&mut self, predicate: &str, i: i64) {
956        let values = self.resources.entry(predicate.to_owned()).or_default();
957        values.push(Resource {
958            rtype: DataType::Integer,
959            order: values.len() as u16,
960            value: Value::Int(i),
961        });
962    }
963
964    pub fn set_integer(&mut self, predicate: &str, i: i64) {
965        let values = self.resources.entry(predicate.to_owned()).or_default();
966        values.clear();
967        values.push(Resource {
968            rtype: DataType::Integer,
969            order: 0,
970            value: Value::Int(i),
971        });
972    }
973
974    pub fn add_decimal_d(&mut self, predicate: &str, mantissa: i64, exponent: i64) {
975        let values = self.resources.entry(predicate.to_owned()).or_default();
976        values.push(Resource {
977            rtype: DataType::Decimal,
978            order: values.len() as u16,
979            value: Value::Num(mantissa, exponent),
980        });
981    }
982
983    pub fn set_decimal_d(&mut self, predicate: &str, mantissa: i64, exponent: i64) {
984        let values = self.resources.entry(predicate.to_owned()).or_default();
985        values.clear();
986        values.push(Resource {
987            rtype: DataType::Decimal,
988            order: 0,
989            value: Value::Num(mantissa, exponent),
990        });
991    }
992
993    pub fn add_uri(&mut self, predicate: &str, s: &str) {
994        let values = self.resources.entry(predicate.to_owned()).or_default();
995        values.push(Resource {
996            rtype: DataType::Uri,
997            order: values.len() as u16,
998            value: Value::Uri(s.to_owned()),
999        });
1000    }
1001
1002    pub fn set_uri(&mut self, predicate: &str, s: &str) {
1003        let values = self.resources.entry(predicate.to_owned()).or_default();
1004        values.clear();
1005        values.push(Resource {
1006            rtype: DataType::Uri,
1007            order: 0,
1008            value: Value::Uri(s.to_owned()),
1009        });
1010    }
1011
1012    pub fn set_uris(&mut self, predicate: &str, ss: Vec<String>) {
1013        let values = self.resources.entry(predicate.to_owned()).or_default();
1014        values.clear();
1015        for s in ss {
1016            values.push(Resource {
1017                rtype: DataType::Uri,
1018                order: 0,
1019                value: Value::Uri(s.to_owned()),
1020            });
1021        }
1022    }
1023
1024    pub fn add_string(&mut self, predicate: &str, s: &str, lang: Lang) {
1025        let values = self.resources.entry(predicate.to_owned()).or_default();
1026        values.push(Resource {
1027            rtype: DataType::String,
1028            order: values.len() as u16,
1029            value: Value::Str(s.to_owned(), lang),
1030        });
1031    }
1032
1033    pub fn set_string(&mut self, predicate: &str, s: &str, lang: Lang) {
1034        let values = self.resources.entry(predicate.to_owned()).or_default();
1035        values.clear();
1036        values.push(Resource {
1037            rtype: DataType::String,
1038            order: 0,
1039            value: Value::Str(s.to_owned(), lang),
1040        });
1041    }
1042}
v_common_onto/individual.rs

v_common_onto/
individual.rs
