Struct cargo_manifest::Manifest

pub struct Manifest<Metadata = Value> {

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

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: Option<DepsSet>

dev_dependencies: Option<DepsSet>

build_dependencies: Option<DepsSet>

target: Option<TargetDepsSet>

features: Option<FeatureSet>

bin: Option<Vec<Product>>

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

bench: Option<Vec<Product>>

test: Option<Vec<Product>>

example: Option<Vec<Product>>

patch: Option<PatchSet>

lib: Option<Product>

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

profile: Option<Profiles>

badges: Option<Badges>

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.

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 may not contain explicit information about [lib], [[bin]] and [package].build, 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 may not contain explicit information about [lib], [[bin]] and [package].build, 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.

pub 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 FromStr for Manifest<Value>

type Err = Error

The associated error which can be returned from parsing.

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

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