bitcoin-validation 0.1.16-alpha.0

tools for capturing information about block/transaction validation
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

crate::ix!();

/**
  | Template for capturing information
  | about block/transaction validation.
  | This is instantiated by TxValidationState
  | and BlockValidationState for validation
  | information on transactions and blocks
  | respectively.
  |
  */
#[derive(Default)]
pub struct ValidationState<R> {
    mode:          validation_state::ModeState, //{ModeState::M_VALID};
    result:        R,
    reject_reason: String,
    debug_message: String,
}

pub mod validation_state {

    pub enum ModeState {

        /**
          | everything ok
          |
          */
        M_VALID,   

        /**
          | network rule violation (DoS value may
          | be set)
          |
          */
        M_INVALID, 

        /**
          | run-time error
          |
          */
        M_ERROR,   
    }

    impl Default for ModeState {
        fn default() -> Self {
            ModeState::M_VALID
        }
    }
}

impl<R> ValidationState<R> {

    pub fn invalid(&mut self, 
        result:        R,
        reject_reason: Option<&str>,
        debug_message: Option<&str>) -> bool {

        let reject_reason: &str = reject_reason.unwrap_or("");
        let debug_message: &str = debug_message.unwrap_or("");

        todo!();
        /*
            m_result = result;
            m_reject_reason = reject_reason;
            m_debug_message = debug_message;
            if (m_mode != ModeState::M_ERROR) m_mode = ModeState::M_INVALID;
            return false;
        */
    }
    
    pub fn error(&mut self, reject_reason: &String) -> bool {
        
        todo!();
        /*
            if (m_mode == ModeState::M_VALID)
                m_reject_reason = reject_reason;
            m_mode = ModeState::M_ERROR;
            return false;
        */
    }
    
    pub fn is_valid(&self) -> bool {
        
        todo!();
        /*
            return m_mode == ModeState::M_VALID;
        */
    }
    
    pub fn is_invalid(&self) -> bool {
        
        todo!();
        /*
            return m_mode == ModeState::M_INVALID;
        */
    }
    
    pub fn is_error(&self) -> bool {
        
        todo!();
        /*
            return m_mode == ModeState::M_ERROR;
        */
    }
    
    pub fn get_result(&self) -> R {
        
        todo!();
        /*
            return m_result;
        */
    }
    
    pub fn get_reject_reason(&self) -> String {
        
        todo!();
        /*
            return m_reject_reason;
        */
    }
    
    pub fn get_debug_message(&self) -> String {
        
        todo!();
        /*
            return m_debug_message;
        */
    }
    
    pub fn to_string(&self) -> String {
        
        todo!();
        /*
            if (IsValid()) {
                return "Valid";
            }

            if (!m_debug_message.empty()) {
                return m_reject_reason + ", " + m_debug_message;
            }

            return m_reject_reason;
        */
    }
}