Enum State 

pub enum State<T> {
    Tampered(T),
    Untampered(T),
}

The state of the protected integer

use protected_integer::ProtectedInteger;
let some_protected = ProtectedInteger::new(114514);

let state = some_protected.get();
println!("is_tampered: {}", state.is_tampered());
println!("is_untampered: {}", state.is_untampered());
println!("to_value: {}", state.to_value());

Variants

Tampered(T)

Untampered(T)

Implementations

impl<T> State<T>

pub fn is_tampered(&self) -> bool

pub fn is_untampered(&self) -> bool

Check if the value is untampered

pub fn to_value(self) -> T

Converts the state to the value WARN: This will ignore whether the value is tampered or not, and consume the state

Examples found in repository

examples/hacking_test.rs (line 5)

fn main() {
    let mut money:ProtectedInteger<i16> = ProtectedInteger::new(123);
    println!("The initial amount of money is {}", money.get().to_value());
    println!("Press Enter to increment it by 1");
    println!("Try searching and modifying this value with Cheat Engine");
    println!("Input 'quit' to exit");
    loop {
        let mut input = String::new();
        std::io::stdin().read_line(&mut input).unwrap();
        let input = input.trim();
        if input == "quit" {
            println!("Exiting...");
            break;
        }
        if !money.check() {
            println!("Hacking detected!");
        }
        money.set(money.get().to_value() + 1);        
        println!("The money is now {}", money.get().to_value());
    }
}

Trait Implementations

impl<T: Clone> Clone for State<T>

fn clone(&self) -> State<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for State<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Copy> Copy for State<T>