typhoon-context-macro 0.1.0-alpha.16

TODO
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

use typhoon_syn::{constraints::*, InstructionAccount};

pub trait ContextVisitor {
    fn visit_account(&mut self, account: &InstructionAccount) -> Result<(), syn::Error> {
        self.visit_constraints(&account.constraints)
    }

    fn visit_constraints(&mut self, constraints: &Constraints) -> Result<(), syn::Error> {
        for constraint in &constraints.0 {
            self.visit_constraint(constraint)?;
        }

        Ok(())
    }

    fn visit_constraint(&mut self, constraint: &Constraint) -> Result<(), syn::Error> {
        match constraint {
            Constraint::Init(constraint_init) => self.visit_init(constraint_init),
            Constraint::Payer(constraint_payer) => self.visit_payer(constraint_payer),
            Constraint::Space(constraint_space) => self.visit_space(constraint_space),
            Constraint::Seeded(constraint_seeded) => self.visit_seeded(constraint_seeded),
            Constraint::Seeds(constraint_seeds) => self.visit_seeds(constraint_seeds),
            Constraint::Bump(constraint_bump) => self.visit_bump(constraint_bump),
            Constraint::HasOne(constraint_has_one) => self.visit_has_one(constraint_has_one),
            Constraint::Program(constraint_program) => self.visit_program(constraint_program),
            Constraint::Token(constraint_token) => self.visit_token(constraint_token),
            Constraint::Mint(constraint_mint) => self.visit_mint(constraint_mint),
            Constraint::AssociatedToken(constraint_associated_token) => {
                self.visit_associated_token(constraint_associated_token)
            }
            Constraint::InitIfNeeded(contraint_init_if_needed) => {
                self.visit_init_if_needed(contraint_init_if_needed)
            }
        }
    }

    fn visit_init(&mut self, _constraint: &ConstraintInit) -> Result<(), syn::Error> {
        Ok(())
    }

    fn visit_payer(&mut self, _constraint: &ConstraintPayer) -> Result<(), syn::Error> {
        Ok(())
    }

    fn visit_space(&mut self, _constraint: &ConstraintSpace) -> Result<(), syn::Error> {
        Ok(())
    }

    fn visit_seeded(&mut self, _constraint: &ConstraintSeeded) -> Result<(), syn::Error> {
        Ok(())
    }

    fn visit_seeds(&mut self, _constraint: &ConstraintSeeds) -> Result<(), syn::Error> {
        Ok(())
    }

    fn visit_bump(&mut self, _constraint: &ConstraintBump) -> Result<(), syn::Error> {
        Ok(())
    }

    fn visit_has_one(&mut self, _constraint: &ConstraintHasOne) -> Result<(), syn::Error> {
        Ok(())
    }

    fn visit_program(&mut self, _constraint: &ConstraintProgram) -> Result<(), syn::Error> {
        Ok(())
    }

    fn visit_token(&mut self, _constraint: &ConstraintToken) -> Result<(), syn::Error> {
        Ok(())
    }

    fn visit_mint(&mut self, _constraint: &ConstraintMint) -> Result<(), syn::Error> {
        Ok(())
    }

    fn visit_associated_token(
        &mut self,
        _constraint: &ConstraintAssociatedToken,
    ) -> Result<(), syn::Error> {
        Ok(())
    }

    fn visit_init_if_needed(
        &mut self,
        _constraint: &ConstraintInitIfNeeded,
    ) -> Result<(), syn::Error> {
        Ok(())
    }
}