topcoat-view 0.6.0

A modular, batteries-included Rust web framework for server-rendered apps.
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use topcoat_core::context::Cx;

use crate::{
    Formatter,
    buffer::{Instruction, InstructionPtr, StrPtr, ViewBuffer},
};

/// Executes a view's instruction block into a [`Formatter`].
///
/// Execution starts at the view's entry, descends into nested views through
/// [`Call`](Instruction::Call) instructions, follows the
/// [`Jmp`](Instruction::Jmp) redirects of filled view slots, and finishes
/// when a [`Ret`](Instruction::Ret) is reached with an empty call stack.
pub struct Renderer<'a> {
    buffer: &'a ViewBuffer,
    ptr: InstructionPtr,
    stack: Vec<InstructionPtr>,
}

impl<'a> Renderer<'a> {
    #[must_use]
    pub fn new(buffer: &'a ViewBuffer, entry: InstructionPtr) -> Self {
        Self {
            buffer,
            ptr: entry,
            stack: Vec::new(),
        }
    }

    /// Executes instructions from the entry until the block returns.
    ///
    /// # Panics
    ///
    /// Panics if execution reaches a reserved view slot that was never
    /// filled.
    pub fn execute(&mut self, cx: &Cx, f: &mut Formatter<'_>) {
        use std::fmt::Write;

        let consts = self.buffer.consts();
        let mut int_buffer = itoa::Buffer::new();
        loop {
            let instruction = self.buffer.instruction(self.ptr);
            self.ptr.increment();

            match instruction {
                Instruction::Call { entry } => {
                    self.stack.push(self.ptr);
                    self.ptr = *entry;
                }
                Instruction::Ret => match self.stack.pop() {
                    Some(ptr) => self.ptr = ptr,
                    None => break,
                },
                Instruction::Jmp { entry } => self.ptr = *entry,
                Instruction::Placeholder => {
                    panic!("tried to render a placeholder view before it was filled")
                }
                Instruction::View { ptr } => {
                    let (buffer, entry) = consts.fetch_view(*ptr);
                    Renderer::new(buffer, entry).execute(cx, f);
                }

                Instruction::Bool(inner) => f.write_str(if *inner { "true" } else { "false" }),
                Instruction::I8(inner) => f.write_str(int_buffer.format(*inner)),
                Instruction::I16(inner) => f.write_str(int_buffer.format(*inner)),
                Instruction::I32(inner) => f.write_str(int_buffer.format(*inner)),
                Instruction::I64(inner) => f.write_str(int_buffer.format(*inner)),
                Instruction::Isize(inner) => f.write_str(int_buffer.format(*inner)),
                Instruction::U8(inner) => f.write_str(int_buffer.format(*inner)),
                Instruction::U16(inner) => f.write_str(int_buffer.format(*inner)),
                Instruction::U32(inner) => f.write_str(int_buffer.format(*inner)),
                Instruction::U64(inner) => f.write_str(int_buffer.format(*inner)),
                Instruction::Usize(inner) => f.write_str(int_buffer.format(*inner)),
                Instruction::F32(inner) => write!(f, "{inner}").unwrap(),
                Instruction::F64(inner) => write!(f, "{inner}").unwrap(),
                Instruction::Char { value, context } => context.writer(f).write_char(*value),

                Instruction::PromotedStr { value, context } => {
                    context.writer(f).write_str(value);
                }
                Instruction::StaticStr { ptr, context } => {
                    context.writer(f).write_str(consts.fetch_static_str(*ptr));
                }
                Instruction::Str {
                    offset,
                    len,
                    context,
                } => {
                    let ptr = StrPtr {
                        offset: *offset,
                        len: *len,
                    };
                    context.writer(f).write_str(consts.fetch_str(ptr));
                }
                Instruction::String { ptr, context } => {
                    context.writer(f).write_str(consts.fetch_string(*ptr));
                }
                Instruction::Dyn { ptr, context } => {
                    consts.fetch_dyn(*ptr).render(cx, &mut context.writer(f));
                }

                #[cfg(feature = "http")]
                Instruction::StatusCode(status_code) => f.record_status_code(*status_code),
                #[cfg(feature = "http")]
                Instruction::Headers { ptr } => {
                    f.record_headers(consts.fetch_headers(*ptr).clone());
                }
            }
        }
    }
}