Struct aocf::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

Examples found in repository

src/lib.rs (line 238)

    pub fn write_json_to(&self, path: impl AsRef<Path>) -> Result<(), Error> {
        ensure_parent_dir(path.as_ref())?;
        let mut file = File::create(path)?;
        file.write_all(self.to_json()?.as_bytes())?;
        Ok(())
    }

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

get an AoC problem from JSON representation

Examples found in repository

src/lib.rs (line 245)

    pub fn load_json_from(path: impl AsRef<Path>) -> Result<Self, Error> {
        let json = read_to_string(path)?;
        Self::from_json(&json)
    }

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

Save problem to path as JSON

Examples found in repository

src/lib.rs (line 251)

    pub fn write(&self) -> Result<(), Error> {
        if let Some(ref p) = self.cache_path {
            self.write_json_to(p)
        } else {
            self.write_json_to(self.get_default_cache_path()?)
        }
    }

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

Load the problem from JSON

Examples found in repository

src/lib.rs (line 266)

    fn load(&self) -> Result<Self, Error> {
        if let Some(ref p) = self.cache_path {
            Self::load_json_from(p)
        } else {
            Self::load_json_from(self.get_default_cache_path()?)
        }
    }

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

Write JSON cache

Examples found in repository

src/lib.rs (line 196)

    pub fn get_input(&mut self, force: bool) -> Result<String, Error> {
        // Input file provided on CLI, read it
        if let Some(file) = &self.input_file {
            return Ok(read_to_string(file)?.trim().to_string())
        }

        // We are piped, read the piped data
        if !self.stream {
            let stdin = io::stdin();

            let data = stdin.lock().lines()
                .flatten()
                .fold(String::new(), |mut acc, line| {
                    acc.push_str(&format!("{}\n", line));
                    acc
                });

            return Ok(data);
        }

        // Get input data from adventofcode.com
        if self.input.is_none() || force {
            let input = http::get_input(self)?;
            self.input = Some(input);
        }

        self.write()?;

        Ok(self.input.clone().unwrap())
    }

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 copy of the value.

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.