1extern crate fraction;
2extern crate num;
3
4use self::fraction::{BigFraction, Fraction};
5use self::num::{BigInt, BigUint};
6
7use crate::model::style::{CommonStyles, Style};
8use crate::model::{Tagged, TaggedValue};
9
10use crate::model::yaml::binary;
11use crate::model::yaml::bool::BoolValue;
12use crate::model::yaml::float::FloatValue;
13use crate::model::yaml::int::IntValue;
14use crate::model::yaml::map::MapValue;
15use crate::model::yaml::null::NullValue;
16use crate::model::yaml::omap::OmapValue;
17use crate::model::yaml::pairs::PairsValue;
18use crate::model::yaml::seq::SeqValue;
19use crate::model::yaml::set::SetValue;
20use crate::model::yaml::str::StrValue;
21
22use crate::model::yamlette::incognitum::IncognitumValue;
23
24use crate::orchestra::{OrchError, Orchestra};
25
26use std::borrow::{Borrow, Cow};
27use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedList, VecDeque};
28use std::hash::Hash;
29
30pub struct EmptyList;
31pub struct EmptyDict;
32pub struct BinaryValue(pub Vec<u8>);
33pub struct Omap<Data>(pub Data);
34pub struct Pairs<Data>(pub Data);
35pub struct Set<Data>(pub Data);
36
37pub fn apply_styles(tagged: &mut dyn Tagged, styles: &mut [&mut dyn Style]) {
38 for style in styles {
39 style.tagged_styles_apply(tagged);
40 }
41}
42
43pub trait Chord {
44 fn chord_size(&self) -> usize;
45
46 fn play(
47 self,
48 orchestra: &Orchestra,
49 level: usize,
50 alias: Option<Cow<'static, str>>,
51 cs: CommonStyles,
52 vs: &mut [&mut dyn Style],
53 ) -> Result<(), OrchError>;
54}
55
56impl Chord for IncognitumValue {
57 fn chord_size(&self) -> usize {
58 1
59 }
60
61 fn play(
62 self,
63 orchestra: &Orchestra,
64 level: usize,
65 _alias: Option<Cow<'static, str>>,
66 _cs: CommonStyles,
67 vs: &mut [&mut dyn Style],
68 ) -> Result<(), OrchError> {
69
70 let mut val = self.clone();
71 apply_styles(&mut val, vs);
72
73 orchestra.play(level, TaggedValue::from(val))
74 }
75}
76
77impl Chord for EmptyList {
78 fn chord_size(&self) -> usize {
79 1
80 }
81
82 fn play(
83 self,
84 orchestra: &Orchestra,
85 level: usize,
86 alias: Option<Cow<'static, str>>,
87 cs: CommonStyles,
88 vs: &mut [&mut dyn Style],
89 ) -> Result<(), OrchError> {
90 let mut val = SeqValue::new(cs, alias);
91 apply_styles(&mut val, vs);
92
93 orchestra.play(level, TaggedValue::from(val))
94 }
95}
96
97impl Chord for EmptyDict {
98 fn chord_size(&self) -> usize {
99 1
100 }
101
102 fn play(
103 self,
104 orchestra: &Orchestra,
105 level: usize,
106 alias: Option<Cow<'static, str>>,
107 cs: CommonStyles,
108 vs: &mut [&mut dyn Style],
109 ) -> Result<(), OrchError> {
110 let mut val = MapValue::new(cs, alias);
111 apply_styles(&mut val, vs);
112
113 orchestra.play(level, TaggedValue::from(val))
114 }
115}
116
117impl Chord for bool {
118 fn chord_size(&self) -> usize {
119 1
120 }
121
122 fn play(
123 self,
124 orchestra: &Orchestra,
125 level: usize,
126 alias: Option<Cow<'static, str>>,
127 cs: CommonStyles,
128 vs: &mut [&mut dyn Style],
129 ) -> Result<(), OrchError> {
130 let mut val = BoolValue::new(self, cs, alias);
131 apply_styles(&mut val, vs);
132
133 orchestra.play(level, TaggedValue::from(val))
134 }
135}
136
137impl Chord for char {
138 fn chord_size(&self) -> usize {
139 1
140 }
141
142 fn play(
143 self,
144 orchestra: &Orchestra,
145 level: usize,
146 alias: Option<Cow<'static, str>>,
147 cs: CommonStyles,
148 vs: &mut [&mut dyn Style],
149 ) -> Result<(), OrchError> {
150 let mut val = StrValue::new(Cow::from(self.to_string()), cs, alias);
151 apply_styles(&mut val, vs);
152
153 orchestra.play(level, TaggedValue::from(val))
154 }
155}
156
157impl Chord for &'static str {
158 fn chord_size(&self) -> usize {
159 1
160 }
161
162 fn play(
163 self,
164 orchestra: &Orchestra,
165 level: usize,
166 alias: Option<Cow<'static, str>>,
167 cs: CommonStyles,
168 vs: &mut [&mut dyn Style],
169 ) -> Result<(), OrchError> {
170 let mut val = StrValue::new(Cow::from(self), cs, alias);
171 apply_styles(&mut val, vs);
172
173 orchestra.play(level, TaggedValue::from(val))
174 }
175}
176
177impl Chord for String {
178 fn chord_size(&self) -> usize {
179 1
180 }
181
182 fn play(
183 self,
184 orchestra: &Orchestra,
185 level: usize,
186 alias: Option<Cow<'static, str>>,
187 cs: CommonStyles,
188 vs: &mut [&mut dyn Style],
189 ) -> Result<(), OrchError> {
190 let mut val = StrValue::new(Cow::from(self), cs, alias);
191 apply_styles(&mut val, vs);
192
193 orchestra.play(level, TaggedValue::from(val))
194 }
195}
196
197macro_rules! int_impl_for {
198 ( $($t:ty),* ) => {
199 $(
200 impl Chord for $t {
201 fn chord_size (&self) -> usize { 1 }
202
203 fn play (self, orchestra: &Orchestra, level: usize, alias: Option<Cow<'static, str>>, cs: CommonStyles, vs: &mut [&mut dyn Style]) -> Result<(), OrchError> {
204 let mut val = IntValue::from (self);
205
206 val.init_common_styles (cs);
207 val.set_alias (alias);
208 apply_styles (&mut val, vs);
209
210 orchestra.play (level, TaggedValue::from (val))
211 }
212 }
213 )*
214 };
215}
216
217int_impl_for!(u8, i8, u16, i16, u32, i32, u64, i64, usize, isize, BigUint, BigInt);
218
219macro_rules! float_impl_for {
220 ( $($t:ty),* ) => {
221 $(
222 impl Chord for $t {
223 fn chord_size (&self) -> usize { 1 }
224
225 fn play (self, orchestra: &Orchestra, level: usize, alias: Option<Cow<'static, str>>, cs: CommonStyles, vs: &mut [&mut dyn Style]) -> Result<(), OrchError> {
226 let mut val = FloatValue::from (self);
227
228 val.init_common_styles (cs);
229 val.set_alias (alias);
230 apply_styles (&mut val, vs);
231
232 orchestra.play (level, TaggedValue::from (val))
233 }
234 }
235 )*
236 };
237}
238
239float_impl_for!(f32, f64, Fraction, BigFraction);
240
241impl Chord for () {
242 fn chord_size(&self) -> usize {
243 1
244 }
245
246 fn play(
247 self,
248 orchestra: &Orchestra,
249 level: usize,
250 alias: Option<Cow<'static, str>>,
251 cs: CommonStyles,
252 vs: &mut [&mut dyn Style],
253 ) -> Result<(), OrchError> {
254 let mut val = NullValue::new(cs, alias);
255 apply_styles(&mut val, vs);
256
257 orchestra.play(level, TaggedValue::from(val))
258 }
259}
260
261impl Chord for BinaryValue {
262 fn chord_size(&self) -> usize {
263 1
264 }
265
266 fn play(
267 self,
268 orchestra: &Orchestra,
269 level: usize,
270 alias: Option<Cow<'static, str>>,
271 cs: CommonStyles,
272 vs: &mut [&mut dyn Style],
273 ) -> Result<(), OrchError> {
274 let mut val = binary::BinaryValue::new(self.0, cs, alias);
275 apply_styles(&mut val, vs);
276
277 orchestra.play(level, TaggedValue::from(val))
278 }
279}
280
281impl<T> Chord for Vec<T>
282where
283 T: Chord,
284{
285 fn chord_size(&self) -> usize {
286 let mut len = 1;
287 for element in self {
288 len += element.chord_size();
289 }
290 len
291 }
292
293 fn play(
294 self,
295 orchestra: &Orchestra,
296 level: usize,
297 alias: Option<Cow<'static, str>>,
298 cs: CommonStyles,
299 vs: &mut [&mut dyn Style],
300 ) -> Result<(), OrchError> {
301 let mut val = SeqValue::new(cs, alias);
302 apply_styles(&mut val, vs);
303
304 orchestra.play(level, TaggedValue::from(val))?;
305
306 for element in self {
307 element.play(orchestra, level + 1, None, cs, vs)?;
308 }
309
310 Ok(())
311 }
312}
313
314impl<T> Chord for VecDeque<T>
315where
316 T: Chord,
317{
318 fn chord_size(&self) -> usize {
319 let mut len = 1;
320 for element in self {
321 len += element.chord_size();
322 }
323 len
324 }
325
326 fn play(
327 self,
328 orchestra: &Orchestra,
329 level: usize,
330 alias: Option<Cow<'static, str>>,
331 cs: CommonStyles,
332 vs: &mut [&mut dyn Style],
333 ) -> Result<(), OrchError> {
334 let mut val = SeqValue::new(cs, alias);
335 apply_styles(&mut val, vs);
336
337 orchestra.play(level, TaggedValue::from(val))?;
338
339 for element in self {
340 element.play(orchestra, level + 1, None, cs, vs)?;
341 }
342
343 Ok(())
344 }
345}
346
347impl<T> Chord for LinkedList<T>
348where
349 T: Chord,
350{
351 fn chord_size(&self) -> usize {
352 let mut len = 1;
353 for element in self {
354 len += element.chord_size();
355 }
356 len
357 }
358
359 fn play(
360 self,
361 orchestra: &Orchestra,
362 level: usize,
363 alias: Option<Cow<'static, str>>,
364 cs: CommonStyles,
365 vs: &mut [&mut dyn Style],
366 ) -> Result<(), OrchError> {
367 let mut val = SeqValue::new(cs, alias);
368 apply_styles(&mut val, vs);
369
370 orchestra.play(level, TaggedValue::from(val))?;
371
372 for element in self {
373 element.play(orchestra, level + 1, None, cs, vs)?;
374 }
375
376 Ok(())
377 }
378}
379
380impl<T> Chord for BinaryHeap<T>
381where
382 T: Chord + Ord,
383{
384 fn chord_size(&self) -> usize {
385 let mut len = 1;
386 for element in self {
387 len += element.chord_size();
388 }
389 len
390 }
391
392 fn play(
393 self,
394 orchestra: &Orchestra,
395 level: usize,
396 alias: Option<Cow<'static, str>>,
397 cs: CommonStyles,
398 vs: &mut [&mut dyn Style],
399 ) -> Result<(), OrchError> {
400 let mut val = SeqValue::new(cs, alias);
401 apply_styles(&mut val, vs);
402
403 orchestra.play(level, TaggedValue::from(val))?;
404
405 for element in self {
406 element.play(orchestra, level + 1, None, cs, vs)?;
407 }
408
409 Ok(())
410 }
411}
412
413impl<K, V> Chord for HashMap<K, V>
414where
415 K: Chord + Eq + Hash,
416 V: Chord,
417{
418 fn chord_size(&self) -> usize {
419 let mut len = 1;
420 for (key, val) in self {
421 len += key.chord_size();
422 len += val.chord_size();
423 }
424 len
425 }
426
427 fn play(
428 self,
429 orchestra: &Orchestra,
430 level: usize,
431 alias: Option<Cow<'static, str>>,
432 cs: CommonStyles,
433 vs: &mut [&mut dyn Style],
434 ) -> Result<(), OrchError> {
435 let mut val = MapValue::new(cs, alias);
436 apply_styles(&mut val, vs);
437
438 orchestra.play(level, TaggedValue::from(val))?;
439
440 for (key, val) in self {
441 key.play(orchestra, level + 1, None, cs, vs)?;
442 val.play(orchestra, level + 1, None, cs, vs)?;
443 }
444
445 Ok(())
446 }
447}
448
449impl<K, V> Chord for BTreeMap<K, V>
450where
451 K: Chord,
452 V: Chord,
453{
454 fn chord_size(&self) -> usize {
455 let mut len = 1;
456 for (key, val) in self {
457 len += key.chord_size();
458 len += val.chord_size();
459 }
460 len
461 }
462
463 fn play(
464 self,
465 orchestra: &Orchestra,
466 level: usize,
467 alias: Option<Cow<'static, str>>,
468 cs: CommonStyles,
469 vs: &mut [&mut dyn Style],
470 ) -> Result<(), OrchError> {
471 let mut val = MapValue::new(cs, alias);
472 apply_styles(&mut val, vs);
473
474 orchestra.play(level, TaggedValue::from(val))?;
475
476 for (key, val) in self {
477 key.play(orchestra, level + 1, None, cs, vs)?;
478 val.play(orchestra, level + 1, None, cs, vs)?;
479 }
480
481 Ok(())
482 }
483}
484
485impl<K, V> Chord for Omap<BTreeMap<K, V>>
486where
487 K: Chord,
488 V: Chord,
489{
490 fn chord_size(&self) -> usize {
491 let mut len = 1;
492 for (key, val) in self.0.borrow().into_iter() {
493 len += key.chord_size();
494 len += val.chord_size();
495 }
496 len
497 }
498
499 fn play(
500 self,
501 orchestra: &Orchestra,
502 level: usize,
503 alias: Option<Cow<'static, str>>,
504 cs: CommonStyles,
505 vs: &mut [&mut dyn Style],
506 ) -> Result<(), OrchError> {
507 let mut val = OmapValue::new(cs, alias);
508 apply_styles(&mut val, vs);
509
510 orchestra.play(level, TaggedValue::from(val))?;
511
512 for (key, val) in self.0.into_iter() {
513 key.play(orchestra, level + 1, None, cs, vs)?;
514 val.play(orchestra, level + 1, None, cs, vs)?;
515 }
516
517 Ok(())
518 }
519}
520
521impl<K, V> Chord for Pairs<BTreeMap<K, V>>
522where
523 K: Chord,
524 V: Chord,
525{
526 fn chord_size(&self) -> usize {
527 let mut len = 1;
528 for (key, val) in self.0.borrow().into_iter() {
529 len += key.chord_size();
530 len += val.chord_size();
531 }
532 len
533 }
534
535 fn play(
536 self,
537 orchestra: &Orchestra,
538 level: usize,
539 alias: Option<Cow<'static, str>>,
540 cs: CommonStyles,
541 vs: &mut [&mut dyn Style],
542 ) -> Result<(), OrchError> {
543 let mut val = PairsValue::new(cs, alias);
544 apply_styles(&mut val, vs);
545
546 orchestra.play(level, TaggedValue::from(val))?;
547
548 for (key, val) in self.0.into_iter() {
549 key.play(orchestra, level + 1, None, cs, vs)?;
550 val.play(orchestra, level + 1, None, cs, vs)?;
551 }
552
553 Ok(())
554 }
555}
556
557impl<K, V> Chord for Omap<Vec<(K, V)>>
558where
559 K: Chord,
560 V: Chord,
561{
562 fn chord_size(&self) -> usize {
563 let mut len = 1;
564 for &(ref key, ref val) in self.0.iter() {
565 len += key.chord_size();
566 len += val.chord_size();
567 }
568 len
569 }
570
571 fn play(
572 self,
573 orchestra: &Orchestra,
574 level: usize,
575 alias: Option<Cow<'static, str>>,
576 cs: CommonStyles,
577 vs: &mut [&mut dyn Style],
578 ) -> Result<(), OrchError> {
579 let mut val = OmapValue::new(cs, alias);
580 apply_styles(&mut val, vs);
581
582 orchestra.play(level, TaggedValue::from(val))?;
583
584 for (key, val) in self.0.into_iter() {
585 key.play(orchestra, level + 1, None, cs, vs)?;
586 val.play(orchestra, level + 1, None, cs, vs)?;
587 }
588
589 Ok(())
590 }
591}
592
593impl<K, V> Chord for Pairs<Vec<(K, V)>>
594where
595 K: Chord,
596 V: Chord,
597{
598 fn chord_size(&self) -> usize {
599 let mut len = 1;
600 for &(ref key, ref val) in self.0.iter() {
601 len += key.chord_size();
602 len += val.chord_size();
603 }
604 len
605 }
606
607 fn play(
608 self,
609 orchestra: &Orchestra,
610 level: usize,
611 alias: Option<Cow<'static, str>>,
612 cs: CommonStyles,
613 vs: &mut [&mut dyn Style],
614 ) -> Result<(), OrchError> {
615 let mut val = PairsValue::new(cs, alias);
616 apply_styles(&mut val, vs);
617
618 orchestra.play(level, TaggedValue::from(val))?;
619
620 for (key, val) in self.0.into_iter() {
621 key.play(orchestra, level + 1, None, cs, vs)?;
622 val.play(orchestra, level + 1, None, cs, vs)?;
623 }
624
625 Ok(())
626 }
627}
628
629impl<T> Chord for HashSet<T>
630where
631 T: Chord + Eq + Hash,
632{
633 fn chord_size(&self) -> usize {
634 let mut len = 1;
635 for element in self {
636 len += element.chord_size();
637 }
638 len
639 }
640
641 fn play(
642 self,
643 orchestra: &Orchestra,
644 level: usize,
645 alias: Option<Cow<'static, str>>,
646 cs: CommonStyles,
647 vs: &mut [&mut dyn Style],
648 ) -> Result<(), OrchError> {
649 let mut val = SeqValue::new(cs, alias);
650 apply_styles(&mut val, vs);
651
652 orchestra.play(level, TaggedValue::from(val))?;
653
654 for element in self {
655 element.play(orchestra, level + 1, None, cs, vs)?;
656 }
657
658 Ok(())
659 }
660}
661
662impl<T> Chord for BTreeSet<T>
663where
664 T: Chord,
665{
666 fn chord_size(&self) -> usize {
667 let mut len = 1;
668 for element in self {
669 len += element.chord_size();
670 }
671 len
672 }
673
674 fn play(
675 self,
676 orchestra: &Orchestra,
677 level: usize,
678 alias: Option<Cow<'static, str>>,
679 cs: CommonStyles,
680 vs: &mut [&mut dyn Style],
681 ) -> Result<(), OrchError> {
682 let mut val = SeqValue::new(cs, alias);
683 apply_styles(&mut val, vs);
684
685 orchestra.play(level, TaggedValue::from(val))?;
686
687 for element in self {
688 element.play(orchestra, level + 1, None, cs, vs)?;
689 }
690
691 Ok(())
692 }
693}
694
695impl<T> Chord for Set<HashSet<T>>
696where
697 T: Chord + Eq + Hash,
698{
699 fn chord_size(&self) -> usize {
700 let mut len = 1;
701 for element in self.0.iter() {
702 len += element.chord_size();
703 }
704 len
705 }
706
707 fn play(
708 self,
709 orchestra: &Orchestra,
710 level: usize,
711 alias: Option<Cow<'static, str>>,
712 cs: CommonStyles,
713 vs: &mut [&mut dyn Style],
714 ) -> Result<(), OrchError> {
715 let mut val = SetValue::new(cs, alias);
716 apply_styles(&mut val, vs);
717
718 orchestra.play(level, TaggedValue::from(val))?;
719
720 for element in self.0 {
721 element.play(orchestra, level + 1, None, cs, vs)?;
722 }
723
724 Ok(())
725 }
726}
727
728impl<T> Chord for Set<BTreeSet<T>>
729where
730 T: Chord,
731{
732 fn chord_size(&self) -> usize {
733 let mut len = 1;
734 for element in self.0.iter() {
735 len += element.chord_size();
736 }
737 len
738 }
739
740 fn play(
741 self,
742 orchestra: &Orchestra,
743 level: usize,
744 alias: Option<Cow<'static, str>>,
745 cs: CommonStyles,
746 vs: &mut [&mut dyn Style],
747 ) -> Result<(), OrchError> {
748 let mut val = SetValue::new(cs, alias);
749 apply_styles(&mut val, vs);
750
751 orchestra.play(level, TaggedValue::from(val))?;
752
753 for element in self.0 {
754 element.play(orchestra, level + 1, None, cs, vs)?;
755 }
756
757 Ok(())
758 }
759}
760
761impl<T> Chord for Set<Vec<T>>
762where
763 T: Chord,
764{
765 fn chord_size(&self) -> usize {
766 let mut len = 1;
767 for element in self.0.iter() {
768 len += element.chord_size();
769 }
770 len
771 }
772
773 fn play(
774 self,
775 orchestra: &Orchestra,
776 level: usize,
777 alias: Option<Cow<'static, str>>,
778 cs: CommonStyles,
779 vs: &mut [&mut dyn Style],
780 ) -> Result<(), OrchError> {
781 let mut val = SetValue::new(cs, alias);
782 apply_styles(&mut val, vs);
783
784 orchestra.play(level, TaggedValue::from(val))?;
785
786 for element in self.0 {
787 element.play(orchestra, level + 1, None, cs, vs)?;
788 }
789
790 Ok(())
791 }
792}