zero4rs 2.0.0

zero4rs is a powerful, pragmatic, and extremely fast web framework for Rust
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

use anyhow::Result;
use mime::Mime;
use serde::ser::SerializeMap;
use serde::{Serialize, Serializer};

use rustube::Stream;

use crate::core::youtube::args::output_level::OutputLevel;

#[derive(Debug)]
pub struct StreamSerializer {
    pub output_level: OutputLevel,
    pub stream: Stream,
}

impl Serialize for StreamSerializer {
    fn serialize<S>(&self, serializer: S) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
    where
        S: Serializer,
    {
        macro_rules! serialize {
            ($self:ident, $map:ident; $($level:expr => { $($field:ident $(with $func:ident)?),* $(,)? })*) => {
                $(
                    if self.output_level.contains($level) {
                        $(
                            $map.serialize_entry(
                                stringify!($field),
                                &serialize!{ @__ser($self.stream.$field $(=> $func)?) }
                            )?;
                        )*
                    }
                )*
            };
            (@__ser($field:expr)) => { $field };
            (@__ser($field:expr => $func:ident)) => { $func(&$field) };
        }

        let mut map = serializer.serialize_map(None)?;

        serialize!(self, map;
            OutputLevel::URL => {
                signature_cipher
            }

            OutputLevel::GENERAL => {
                mime with serialize_mime, quality, includes_video_track, includes_audio_track,
                approx_duration_ms
            }
            OutputLevel::GENERAL | OutputLevel::VERBOSE => {
                codecs, is_progressive
            }

            OutputLevel::VIDEO_TRACK => {
                height, width, quality_label, fps
            }
            OutputLevel::VIDEO_TRACK | OutputLevel::VERBOSE => {
                format_type, color_info, high_replication, is_otf
            }

            OutputLevel::AUDIO_TRACK => {
                audio_quality, bitrate, audio_sample_rate, audio_channels, loudness_db
            }
            OutputLevel::AUDIO_TRACK | OutputLevel::VERBOSE => {
                average_bitrate
            }

            OutputLevel::all() => {
                index_range, init_range, itag, last_modified, projection_type
            }
        );

        map.end()
    }
}

fn serialize_mime(mime: &Mime) -> &str {
    mime.as_ref()
}