Struct Aoc

pub struct Aoc {
    pub year: Option<i32>,
    pub day: Option<u32>,
    pub level: Level,
    pub title: Option<String>,
    pub stars: Option<u8>,
    pub solution: HashMap<Level, String>,
    /* private fields */
}

A cache entry for a single day, containing all data related to that day’s problem

Fields

year: Option<i32>

day: Option<u32>

level: Level

title: Option<String>

stars: Option<u8>

solution: HashMap<Level, String>

Implementations

impl Aoc

pub fn new() -> Self

Examples found in repository

examples/day01.rs (line 6)

fn main() {
    let mut aoc = Aoc::new()
        .year(Some(2019))
        .day(Some(1))
        .cookie_file("./examples/cookie")
        .init()
        .unwrap();

    let input = if let Ok(i) = aoc.get_input(false) {
        i
    } else {
        "you probably need to add a valid cookie".to_string()
    };

    println!("{}", input);
}

examples/day02.rs (line 6)

fn main() {
    let mut aoc = Aoc::new()
        .year(Some(2019))
        .day(Some(2))
        .cookie("yoursessioncookiedatagoeshere")
        .init()
        .unwrap();

    let input = if let Ok(i) = aoc.get_input(false) {
        i
    } else {
        "you probably need to add a valid cookie".to_string()
    };

    println!("{}", input);
}

pub fn year(self, year: Option<i32>) -> Self

Set the year

Examples found in repository

examples/day01.rs (line 7)

fn main() {
    let mut aoc = Aoc::new()
        .year(Some(2019))
        .day(Some(1))
        .cookie_file("./examples/cookie")
        .init()
        .unwrap();

    let input = if let Ok(i) = aoc.get_input(false) {
        i
    } else {
        "you probably need to add a valid cookie".to_string()
    };

    println!("{}", input);
}

examples/day02.rs (line 7)

fn main() {
    let mut aoc = Aoc::new()
        .year(Some(2019))
        .day(Some(2))
        .cookie("yoursessioncookiedatagoeshere")
        .init()
        .unwrap();

    let input = if let Ok(i) = aoc.get_input(false) {
        i
    } else {
        "you probably need to add a valid cookie".to_string()
    };

    println!("{}", input);
}

pub fn day(self, day: Option<u32>) -> Self

Set the day

Examples found in repository

examples/day01.rs (line 8)

fn main() {
    let mut aoc = Aoc::new()
        .year(Some(2019))
        .day(Some(1))
        .cookie_file("./examples/cookie")
        .init()
        .unwrap();

    let input = if let Ok(i) = aoc.get_input(false) {
        i
    } else {
        "you probably need to add a valid cookie".to_string()
    };

    println!("{}", input);
}

examples/day02.rs (line 8)

fn main() {
    let mut aoc = Aoc::new()
        .year(Some(2019))
        .day(Some(2))
        .cookie("yoursessioncookiedatagoeshere")
        .init()
        .unwrap();

    let input = if let Ok(i) = aoc.get_input(false) {
        i
    } else {
        "you probably need to add a valid cookie".to_string()
    };

    println!("{}", input);
}

pub fn cookie(self, cookie: &str) -> Self

Set cookie string

Examples found in repository

examples/day02.rs (line 9)

fn main() {
    let mut aoc = Aoc::new()
        .year(Some(2019))
        .day(Some(2))
        .cookie("yoursessioncookiedatagoeshere")
        .init()
        .unwrap();

    let input = if let Ok(i) = aoc.get_input(false) {
        i
    } else {
        "you probably need to add a valid cookie".to_string()
    };

    println!("{}", input);
}

pub fn cookie_file(self, path: impl AsRef<Path>) -> Self

Set cookie file

Examples found in repository

examples/day01.rs (line 9)

fn main() {
    let mut aoc = Aoc::new()
        .year(Some(2019))
        .day(Some(1))
        .cookie_file("./examples/cookie")
        .init()
        .unwrap();

    let input = if let Ok(i) = aoc.get_input(false) {
        i
    } else {
        "you probably need to add a valid cookie".to_string()
    };

    println!("{}", input);
}

pub fn cache<P>(self, path: Option<&Path>) -> Self

Set the cache path

pub fn parse_cli(self, status: bool) -> Self

Enable or disable CLI argument parsing

If enabled, the binary’s arguments will be parsed, allowing for example, to choose a file to read in as alternative input data, rather than using the input data fetched from Advent of Code.

pub fn init(self) -> Result<Self, Error>

Initialise (finish building)

Examples found in repository

examples/day01.rs (line 10)

fn main() {
    let mut aoc = Aoc::new()
        .year(Some(2019))
        .day(Some(1))
        .cookie_file("./examples/cookie")
        .init()
        .unwrap();

    let input = if let Ok(i) = aoc.get_input(false) {
        i
    } else {
        "you probably need to add a valid cookie".to_string()
    };

    println!("{}", input);
}

examples/day02.rs (line 10)

fn main() {
    let mut aoc = Aoc::new()
        .year(Some(2019))
        .day(Some(2))
        .cookie("yoursessioncookiedatagoeshere")
        .init()
        .unwrap();

    let input = if let Ok(i) = aoc.get_input(false) {
        i
    } else {
        "you probably need to add a valid cookie".to_string()
    };

    println!("{}", input);
}

pub fn get_input(&mut self, force: bool) -> Result<String, Error>

Get the input data

Examples found in repository

examples/day01.rs (line 13)

fn main() {
    let mut aoc = Aoc::new()
        .year(Some(2019))
        .day(Some(1))
        .cookie_file("./examples/cookie")
        .init()
        .unwrap();

    let input = if let Ok(i) = aoc.get_input(false) {
        i
    } else {
        "you probably need to add a valid cookie".to_string()
    };

    println!("{}", input);
}

examples/day02.rs (line 13)

fn main() {
    let mut aoc = Aoc::new()
        .year(Some(2019))
        .day(Some(2))
        .cookie("yoursessioncookiedatagoeshere")
        .init()
        .unwrap();

    let input = if let Ok(i) = aoc.get_input(false) {
        i
    } else {
        "you probably need to add a valid cookie".to_string()
    };

    println!("{}", input);
}

pub fn to_json(&self) -> Result<String, Error>

get a JSON representation for the AoC problem

pub fn from_json(json: &str) -> Result<Self, Error>

get an AoC problem from JSON representation

pub fn write_json_to(&self, path: impl AsRef<Path>) -> Result<(), Error>

Save problem to path as JSON

pub fn load_json_from(path: impl AsRef<Path>) -> Result<Self, Error>

Load the problem from JSON

pub fn write(&self) -> Result<(), Error>

Write JSON cache

pub fn advance(&mut self) -> Result<(), Error>

pub fn get_time_until_release()

Get time until release

Trait Implementations

impl Clone for Aoc

fn clone(&self) -> Aoc

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Aoc

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

Formats the value using the given formatter.

impl Default for Aoc

fn default() -> Aoc

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Aoc

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Aoc

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.