Struct capnpc::CompilerCommand

pub struct CompilerCommand { /* private fields */ }

A builder object for schema compiler commands.

Implementations

impl CompilerCommand

pub fn new() -> Self

Creates a new, empty command.

pub fn file<P>(&mut self, path: P) -> &mut Self

where P: AsRef<Path>,

Adds a file to be compiled.

pub fn src_prefix<P>(&mut self, prefix: P) -> &mut Self

where P: AsRef<Path>,

Adds a –src-prefix flag. For all files specified for compilation that start with prefix, removes the prefix when computing output filenames.

pub fn import_path<P>(&mut self, dir: P) -> &mut Self

where P: AsRef<Path>,

Adds an –import_path flag. Adds dir to the list of directories searched for absolute imports.

pub fn crate_provides( &mut self, crate_name: impl Into<String>, files: impl IntoIterator<Item = u64> ) -> &mut Self

Specify that crate_name provides generated code for files.

This means that when your schema refers to types defined in files we will generate Rust code that uses identifiers in crate_name.

Arguments

• crate_name: The Rust identifier of the crate
• files: the Capnp file ids the crate provides generated code for

When to use

You only need this when your generated code needs to refer to types in the external crate. If you just want to use an annotation and the argument to that annotation is a builtin type (e.g. $Json.name) this isn’t necessary.

Example

If you write a schema like so

// my_schema.capnp

using Json = import "/capnp/compat/json.capnp";

struct Foo {
    value @0 :Json.Value;
}

you’d look at json.capnp to see its capnp id.

// json.capnp

# Copyright (c) 2015 Sandstorm Development Group, Inc. and contributors ...
@0x8ef99297a43a5e34;

If you want the foo::Builder::get_value method generated for your schema to return a capnp_json::json_capnp::value::Reader you’d add a dependency on capnp_json to your Cargo.toml and specify it provides json.capnp in your build.rs.

// build.rs

capnpc::CompilerCommand::new()
    .crate_provides("json_capnp", [0x8ef99297a43a5e34])
    .file("my_schema.capnp")
    .run()
    .unwrap();

pub fn no_standard_import(&mut self) -> &mut Self

Adds the –no-standard-import flag, indicating that the default import paths of /usr/include and /usr/local/include should not bet included.

pub fn output_path<P>(&mut self, path: P) -> &mut Self

where P: AsRef<Path>,

Sets the output directory of generated code. Default is OUT_DIR

pub fn capnp_executable<P>(&mut self, path: P) -> &mut Self

where P: AsRef<Path>,

Specify the executable which is used for the ‘capnp’ tool. When this method is not called, the command looks for a name ‘capnp’ on the system (e.g. in working directory or in PATH environment variable).

pub fn default_parent_module( &mut self, default_parent_module: Vec<String> ) -> &mut Self

Sets the default parent module. This indicates the scope in your crate where you will add a module containing the generated code. For example, if you set this option to vec!["foo".into(), "bar".into()], and you are generating code for baz.capnp, then your crate should have this structure:

pub mod foo {
   pub mod bar {
       pub mod baz_capnp {
           include!(concat!(env!("OUT_DIR"), "/baz_capnp.rs"));
       }
   }
}

This option can be overridden by the parentModule annotation defined in rust.capnp.

If this option is unset, the default is the crate root.

pub fn raw_code_generator_request_path<P>(&mut self, path: P) -> &mut Self

where P: AsRef<Path>,

If set, the generator will also write a file containing the raw code generator request to the specified path.

pub fn run(&mut self) -> Result<()>

Runs the command. Returns an error if OUT_DIR or a custom output directory was not set, or if capnp compile fails.

Trait Implementations

impl Default for CompilerCommand

fn default() -> CompilerCommand

Returns the “default value” for a type.