#codegen #static #time

build phf_codegen

Codegen library for PHF types

34 releases

0.7.24 Jan 5, 2019
0.7.23 Aug 27, 2018
0.7.22 Apr 28, 2018
0.7.21 Jan 19, 2017
0.7.0 Mar 31, 2015
Download history 21282/week @ 2018-12-20 22438/week @ 2018-12-27 32566/week @ 2019-01-03 35107/week @ 2019-01-10 34418/week @ 2019-01-17 32593/week @ 2019-01-24 33450/week @ 2019-01-31 37127/week @ 2019-02-07 36399/week @ 2019-02-14 40210/week @ 2019-02-21 42214/week @ 2019-02-28 42161/week @ 2019-03-07 43665/week @ 2019-03-14 40156/week @ 2019-03-21 40656/week @ 2019-03-28

122,737 downloads per month
Used in 1,308 crates (40 directly)

MIT license

20KB
421 lines

Rust-PHF

Build Status Latest Version

Documentation

Rust-PHF is a library to generate efficient lookup tables at compile time using perfect hash functions.

It currently uses the CHD algorithm and can generate a 100,000 entry map in roughly .4 seconds. By default statistics are not produced, but if you set the environment variable PHF_STATS it will issue a compiler note about how long it took.

Usage

PHF data structures can be constucted via either the compiler plugins in the phf_macros crate or code generation supported by the phf_codegen crate. Compiler plugins are not a stable part of Rust at the moment, so phf_macros can only be used with nightlies.

The phf/core feature will compile the phf crate with a dependency on libcore instead of libstd, enabling use in environments where libstd will not work.

phf_macros

#![feature(proc_macro_hygiene)]

use phf::phf_map;

#[derive(Clone)]
pub enum Keyword {
    Loop,
    Continue,
    Break,
    Fn,
    Extern,
}

static KEYWORDS: phf::Map<&'static str, Keyword> = phf_map! {
    "loop" => Keyword::Loop,
    "continue" => Keyword::Continue,
    "break" => Keyword::Break,
    "fn" => Keyword::Fn,
    "extern" => Keyword::Extern,
};

pub fn parse_keyword(keyword: &str) -> Option<Keyword> {
    KEYWORDS.get(keyword).cloned()
}
[dependencies]
phf = { version = "0.7", features = ["macros"] }

phf_codegen

build.rs

extern crate phf_codegen;

use std::env;
use std::fs::File;
use std::io::{BufWriter, Write};
use std::path::Path;

fn main() {
    let path = Path::new(&env::var("OUT_DIR").unwrap()).join("codegen.rs");
    let mut file = BufWriter::new(File::create(&path).unwrap());

    write!(&mut file, "static KEYWORDS: phf::Map<&'static str, Keyword> = ").unwrap();
    phf_codegen::Map::new()
        .entry("loop", "Keyword::Loop")
        .entry("continue", "Keyword::Continue")
        .entry("break", "Keyword::Break")
        .entry("fn", "Keyword::Fn")
        .entry("extern", "Keyword::Extern")
        .build(&mut file)
        .unwrap();
    write!(&mut file, ";\n").unwrap();
}

lib.rs

extern crate phf;

#[derive(Clone)]
enum Keyword {
    Loop,
    Continue,
    Break,
    Fn,
    Extern,
}

include!(concat!(env!("OUT_DIR"), "/codegen.rs"));

pub fn parse_keyword(keyword: &str) -> Option<Keyword> {
    KEYWORDS.get(keyword).cloned()
}

Dependencies

~1MB
~10K SLoC