Struct cargo_toml::Manifest

pub struct Manifest<Metadata = Value> {

    pub package: Option<Package<Metadata>>,
    pub workspace: Option<Workspace>,
    pub dependencies: DepsSet,
    pub dev_dependencies: DepsSet,
    pub build_dependencies: DepsSet,
    pub target: TargetDepsSet,
    pub features: FeatureSet,
    pub patch: PatchSet,
    pub lib: Option<Product>,
    pub profile: Profiles,
    pub badges: Badges,
    pub bin: Vec<Product>,
    pub bench: Vec<Product>,
    pub test: Vec<Product>,
    pub example: Vec<Product>,
}

The top-level Cargo.toml structure

The Metadata is a type for [package.metadata] table. You can replace it with your own struct type if you use the metadata and don’t want to use the catch-all Value type.

Fields

package: Option<Package<Metadata>>

workspace: Option<Workspace>

dependencies: DepsSet

dev_dependencies: DepsSet

build_dependencies: DepsSet

target: TargetDepsSet

features: FeatureSet

patch: PatchSet

lib: Option<Product>

Note that due to autolibs feature this is not the complete list unless you run complete_from_path

profile: Profiles

badges: Badges

bin: Vec<Product>

Note that due to autobins feature this is not the complete list unless you run complete_from_path

bench: Vec<Product>

test: Vec<Product>

example: Vec<Product>

Implementations

impl Manifest<Value>

pub fn from_slice(cargo_toml_content: &[u8]) -> Result<Self, Error>

Parse contents of a Cargo.toml file already loaded as a byte slice.

It does not call complete_from_path, so may be missing implicit data.

pub fn from_path(cargo_toml_path: impl AsRef<Path>) -> Result<Self, Error>

Parse contents from a Cargo.toml file on disk.

Calls complete_from_path.

pub fn from_str(cargo_toml_content: &str) -> Result<Self, Error>

Parse contents of a Cargo.toml file loaded as a string

Note: this is not a file name, but file’s content. See from_path.

It does not call complete_from_path, so may be missing implicit data.

impl<Metadata: for<'a> Deserialize<'a>> Manifest<Metadata>

pub fn from_slice_with_metadata(
    cargo_toml_content: &[u8]
) -> Result<Self, Error>

Parse Cargo.toml, and parse its [package.metadata] into a custom Serde-compatible type.package

It does not call complete_from_path, so may be missing implicit data.

pub fn from_path_with_metadata(
    cargo_toml_path: impl AsRef<Path>
) -> Result<Self, Error>

Parse contents from Cargo.toml file on disk, with custom Serde-compatible metadata type.

Calls complete_from_path

pub fn complete_from_path(&mut self, path: &Path) -> Result<(), Error>

Cargo.toml doesn’t contain explicit information about [lib] and [[bin]], which are inferred based on files on disk.

This scans the disk to make the data in the manifest as complete as possible.

pub fn complete_from_abstract_filesystem(
    &mut self,
    fs: impl AbstractFilesystem
) -> Result<(), Error>

Cargo.toml doesn’t contain explicit information about [lib] and [[bin]], which are inferred based on files on disk.

You can provide any implementation of directory scan, which doesn’t have to be reading straight from disk (might scan a tarball or a git repo, for example).

Trait Implementations

impl<Metadata: Clone> Clone for Manifest<Metadata>

fn clone(&self) -> Manifest<Metadata>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Metadata: Debug> Debug for Manifest<Metadata>

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

Formats the value using the given formatter.

impl<'de, Metadata> Deserialize<'de> for Manifest<Metadata> where
    Metadata: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<Metadata: PartialEq> PartialEq<Manifest<Metadata>> for Manifest<Metadata>

fn eq(&self, other: &Manifest<Metadata>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Manifest<Metadata>) -> bool

This method tests for !=.

impl<Metadata> Serialize for Manifest<Metadata> where
    Metadata: Serialize, 

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

Serialize this value into the given Serde serializer.

impl<Metadata> StructuralPartialEq for Manifest<Metadata>