1use crate::dependencies::{Dependency, Patch, RegistryPatch, TargetDependencies};
2use serde::ser::{SerializeMap, Serializer};
3use serde_derive::{Deserialize, Serialize};
4use serde_json::Value;
5use std::collections::BTreeMap as Map;
6use std::ffi::OsStr;
7use std::path::PathBuf;
8
9#[derive(#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications,
clippy :: absolute_paths,)]
const _: () =
{
#[allow(unused_extern_crates, clippy :: useless_attribute)]
extern crate serde as _serde;
;
#[automatically_derived]
impl _serde::Serialize for Manifest {
fn serialize<__S>(&self, __serializer: __S)
-> _serde::__private228::Result<__S::Ok, __S::Error> where
__S: _serde::Serializer {
let mut __serde_state =
_serde::Serializer::serialize_struct(__serializer,
"Manifest",
false as usize +
if Vec::is_empty(&self.cargo_features) { 0 } else { 1 } + 1
+ if Map::is_empty(&self.features) { 0 } else { 1 } + 1 +
if Map::is_empty(&self.target) { 0 } else { 1 } + 1 +
if Option::is_none(&self.workspace) { 0 } else { 1 } +
if empty_patch(&self.patch) { 0 } else { 1 } +
if Map::is_empty(&self.replace) { 0 } else { 1 } +
if Map::is_empty(&self.profile) { 0 } else { 1 })?;
if !Vec::is_empty(&self.cargo_features) {
_serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
"cargo-features", &self.cargo_features)?;
} else {
_serde::ser::SerializeStruct::skip_field(&mut __serde_state,
"cargo-features")?;
}
_serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
"package", &self.package)?;
if !Map::is_empty(&self.features) {
_serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
"features", &self.features)?;
} else {
_serde::ser::SerializeStruct::skip_field(&mut __serde_state,
"features")?;
}
_serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
"dependencies", &self.dependencies)?;
if !Map::is_empty(&self.target) {
_serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
"target", &self.target)?;
} else {
_serde::ser::SerializeStruct::skip_field(&mut __serde_state,
"target")?;
}
_serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
"bin", &self.bins)?;
if !Option::is_none(&self.workspace) {
_serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
"workspace", &self.workspace)?;
} else {
_serde::ser::SerializeStruct::skip_field(&mut __serde_state,
"workspace")?;
}
if !empty_patch(&self.patch) {
_serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
"patch",
&{
#[doc(hidden)]
struct __SerializeWith<'__a> {
values: (&'__a Map<String, RegistryPatch>,),
phantom: _serde::__private228::PhantomData<Manifest>,
}
#[automatically_derived]
impl<'__a> _serde::Serialize for __SerializeWith<'__a> {
fn serialize<__S>(&self, __s: __S)
-> _serde::__private228::Result<__S::Ok, __S::Error> where
__S: _serde::Serializer {
serialize_patch(self.values.0, __s)
}
}
__SerializeWith {
values: (&self.patch,),
phantom: _serde::__private228::PhantomData::<Manifest>,
}
})?;
} else {
_serde::ser::SerializeStruct::skip_field(&mut __serde_state,
"patch")?;
}
if !Map::is_empty(&self.replace) {
_serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
"replace", &self.replace)?;
} else {
_serde::ser::SerializeStruct::skip_field(&mut __serde_state,
"replace")?;
}
if !Map::is_empty(&self.profile) {
_serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
"profile", &self.profile)?;
} else {
_serde::ser::SerializeStruct::skip_field(&mut __serde_state,
"profile")?;
}
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};Serialize, #[automatically_derived]
impl ::core::fmt::Debug for Manifest {
#[inline]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
let names: &'static _ =
&["cargo_features", "package", "features", "dependencies",
"target", "bins", "workspace", "patch", "replace",
"profile"];
let values: &[&dyn ::core::fmt::Debug] =
&[&self.cargo_features, &self.package, &self.features,
&self.dependencies, &self.target, &self.bins,
&self.workspace, &self.patch, &self.replace,
&&self.profile];
::core::fmt::Formatter::debug_struct_fields_finish(f, "Manifest",
names, values)
}
}Debug)]
10pub struct Manifest {
11 #[serde(rename = "cargo-features", skip_serializing_if = "Vec::is_empty")]
12 pub cargo_features: Vec<String>,
13 pub package: Package,
14 #[serde(skip_serializing_if = "Map::is_empty")]
15 pub features: Map<String, Vec<String>>,
16 pub dependencies: Map<String, Dependency>,
17 #[serde(skip_serializing_if = "Map::is_empty")]
18 pub target: Map<String, TargetDependencies>,
19 #[serde(rename = "bin")]
20 pub bins: Vec<Bin>,
21 #[serde(skip_serializing_if = "Option::is_none")]
22 pub workspace: Option<Workspace>,
23 #[serde(
24 serialize_with = "serialize_patch",
25 skip_serializing_if = "empty_patch"
26 )]
27 pub patch: Map<String, RegistryPatch>,
28 #[serde(skip_serializing_if = "Map::is_empty")]
29 pub replace: Map<String, Patch>,
30 #[serde(skip_serializing_if = "Map::is_empty")]
31 pub profile: Map<String, Value>,
32}
33
34#[derive(#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications,
clippy :: absolute_paths,)]
const _: () =
{
#[allow(unused_extern_crates, clippy :: useless_attribute)]
extern crate serde as _serde;
;
#[automatically_derived]
impl _serde::Serialize for Package {
fn serialize<__S>(&self, __serializer: __S)
-> _serde::__private228::Result<__S::Ok, __S::Error> where
__S: _serde::Serializer {
let mut __serde_state =
_serde::Serializer::serialize_struct(__serializer,
"Package",
false as usize + 1 + 1 + 1 +
if Option::is_none(&self.resolver) { 0 } else { 1 } + 1)?;
_serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
"name", &self.name)?;
_serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
"version", &self.version)?;
_serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
"edition", &self.edition)?;
if !Option::is_none(&self.resolver) {
_serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
"resolver", &self.resolver)?;
} else {
_serde::ser::SerializeStruct::skip_field(&mut __serde_state,
"resolver")?;
}
_serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
"publish", &self.publish)?;
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};Serialize, #[automatically_derived]
impl ::core::fmt::Debug for Package {
#[inline]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::debug_struct_field5_finish(f, "Package",
"name", &self.name, "version", &self.version, "edition",
&self.edition, "resolver", &self.resolver, "publish",
&&self.publish)
}
}Debug)]
35pub struct Package {
36 pub name: String,
37 pub version: String,
38 pub edition: Edition,
39 #[serde(skip_serializing_if = "Option::is_none")]
40 pub resolver: Option<String>,
41 pub publish: bool,
42}
43
44#[derive(#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications,
clippy :: absolute_paths,)]
const _: () =
{
#[allow(unused_extern_crates, clippy :: useless_attribute)]
extern crate serde as _serde;
;
#[automatically_derived]
impl _serde::Serialize for Edition {
fn serialize<__S>(&self, __serializer: __S)
-> _serde::__private228::Result<__S::Ok, __S::Error> where
__S: _serde::Serializer {
match *self {
Edition::E2015 =>
_serde::Serializer::serialize_unit_variant(__serializer,
"Edition", 0u32, "2015"),
Edition::E2018 =>
_serde::Serializer::serialize_unit_variant(__serializer,
"Edition", 1u32, "2018"),
Edition::E2021 =>
_serde::Serializer::serialize_unit_variant(__serializer,
"Edition", 2u32, "2021"),
Edition::E2024 =>
_serde::Serializer::serialize_unit_variant(__serializer,
"Edition", 3u32, "2024"),
}
}
}
};Serialize, #[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications,
clippy :: absolute_paths,)]
const _: () =
{
#[allow(unused_extern_crates, clippy :: useless_attribute)]
extern crate serde as _serde;
;
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for Edition {
fn deserialize<__D>(__deserializer: __D)
-> _serde::__private228::Result<Self, __D::Error> where
__D: _serde::Deserializer<'de> {
#[allow(non_camel_case_types)]
#[doc(hidden)]
enum __Field { __field0, __field1, __field2, __field3, }
#[doc(hidden)]
struct __FieldVisitor;
#[automatically_derived]
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
type Value = __Field;
fn expecting(&self,
__formatter: &mut _serde::__private228::Formatter)
-> _serde::__private228::fmt::Result {
_serde::__private228::Formatter::write_str(__formatter,
"variant identifier")
}
fn visit_u64<__E>(self, __value: u64)
-> _serde::__private228::Result<Self::Value, __E> where
__E: _serde::de::Error {
match __value {
0u64 => _serde::__private228::Ok(__Field::__field0),
1u64 => _serde::__private228::Ok(__Field::__field1),
2u64 => _serde::__private228::Ok(__Field::__field2),
3u64 => _serde::__private228::Ok(__Field::__field3),
_ =>
_serde::__private228::Err(_serde::de::Error::invalid_value(_serde::de::Unexpected::Unsigned(__value),
&"variant index 0 <= i < 4")),
}
}
fn visit_str<__E>(self, __value: &str)
-> _serde::__private228::Result<Self::Value, __E> where
__E: _serde::de::Error {
match __value {
"2015" => _serde::__private228::Ok(__Field::__field0),
"2018" => _serde::__private228::Ok(__Field::__field1),
"2021" => _serde::__private228::Ok(__Field::__field2),
"2024" => _serde::__private228::Ok(__Field::__field3),
_ => {
_serde::__private228::Err(_serde::de::Error::unknown_variant(__value,
VARIANTS))
}
}
}
fn visit_bytes<__E>(self, __value: &[u8])
-> _serde::__private228::Result<Self::Value, __E> where
__E: _serde::de::Error {
match __value {
b"2015" => _serde::__private228::Ok(__Field::__field0),
b"2018" => _serde::__private228::Ok(__Field::__field1),
b"2021" => _serde::__private228::Ok(__Field::__field2),
b"2024" => _serde::__private228::Ok(__Field::__field3),
_ => {
let __value =
&_serde::__private228::from_utf8_lossy(__value);
_serde::__private228::Err(_serde::de::Error::unknown_variant(__value,
VARIANTS))
}
}
}
}
#[automatically_derived]
impl<'de> _serde::Deserialize<'de> for __Field {
#[inline]
fn deserialize<__D>(__deserializer: __D)
-> _serde::__private228::Result<Self, __D::Error> where
__D: _serde::Deserializer<'de> {
_serde::Deserializer::deserialize_identifier(__deserializer,
__FieldVisitor)
}
}
#[doc(hidden)]
struct __Visitor<'de> {
marker: _serde::__private228::PhantomData<Edition>,
lifetime: _serde::__private228::PhantomData<&'de ()>,
}
#[automatically_derived]
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = Edition;
fn expecting(&self,
__formatter: &mut _serde::__private228::Formatter)
-> _serde::__private228::fmt::Result {
_serde::__private228::Formatter::write_str(__formatter,
"enum Edition")
}
fn visit_enum<__A>(self, __data: __A)
-> _serde::__private228::Result<Self::Value, __A::Error>
where __A: _serde::de::EnumAccess<'de> {
match _serde::de::EnumAccess::variant(__data)? {
(__Field::__field0, __variant) => {
_serde::de::VariantAccess::unit_variant(__variant)?;
_serde::__private228::Ok(Edition::E2015)
}
(__Field::__field1, __variant) => {
_serde::de::VariantAccess::unit_variant(__variant)?;
_serde::__private228::Ok(Edition::E2018)
}
(__Field::__field2, __variant) => {
_serde::de::VariantAccess::unit_variant(__variant)?;
_serde::__private228::Ok(Edition::E2021)
}
(__Field::__field3, __variant) => {
_serde::de::VariantAccess::unit_variant(__variant)?;
_serde::__private228::Ok(Edition::E2024)
}
}
}
}
#[doc(hidden)]
const VARIANTS: &'static [&'static str] =
&["2015", "2018", "2021", "2024"];
_serde::Deserializer::deserialize_enum(__deserializer,
"Edition", VARIANTS,
__Visitor {
marker: _serde::__private228::PhantomData::<Edition>,
lifetime: _serde::__private228::PhantomData,
})
}
}
};Deserialize, #[automatically_derived]
impl ::core::default::Default for Edition {
#[inline]
fn default() -> Edition { Self::E2015 }
}Default, #[automatically_derived]
impl ::core::fmt::Debug for Edition {
#[inline]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::write_str(f,
match self {
Edition::E2015 => "E2015",
Edition::E2018 => "E2018",
Edition::E2021 => "E2021",
Edition::E2024 => "E2024",
})
}
}Debug)]
45pub enum Edition {
46 #[default]
47 #[serde(rename = "2015")]
48 E2015,
49 #[serde(rename = "2018")]
50 E2018,
51 #[serde(rename = "2021")]
52 E2021,
53 #[serde(rename = "2024")]
54 E2024,
55}
56
57#[derive(#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications,
clippy :: absolute_paths,)]
const _: () =
{
#[allow(unused_extern_crates, clippy :: useless_attribute)]
extern crate serde as _serde;
;
#[automatically_derived]
impl _serde::Serialize for Bin {
fn serialize<__S>(&self, __serializer: __S)
-> _serde::__private228::Result<__S::Ok, __S::Error> where
__S: _serde::Serializer {
let mut __serde_state =
_serde::Serializer::serialize_struct(__serializer, "Bin",
false as usize + 1 + 1)?;
_serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
"name", &self.name)?;
_serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
"path", &self.path)?;
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};Serialize, #[automatically_derived]
impl ::core::fmt::Debug for Bin {
#[inline]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::debug_struct_field2_finish(f, "Bin", "name",
&self.name, "path", &&self.path)
}
}Debug)]
58pub struct Bin {
59 pub name: Name,
60 pub path: PathBuf,
61}
62
63#[derive(#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications,
clippy :: absolute_paths,)]
const _: () =
{
#[allow(unused_extern_crates, clippy :: useless_attribute)]
extern crate serde as _serde;
;
#[automatically_derived]
impl _serde::Serialize for Name {
fn serialize<__S>(&self, __serializer: __S)
-> _serde::__private228::Result<__S::Ok, __S::Error> where
__S: _serde::Serializer {
_serde::Serializer::serialize_newtype_struct(__serializer,
"Name", &self.0)
}
}
};Serialize, #[automatically_derived]
impl ::core::clone::Clone for Name {
#[inline]
fn clone(&self) -> Name { Name(::core::clone::Clone::clone(&self.0)) }
}Clone, #[automatically_derived]
impl ::core::fmt::Debug for Name {
#[inline]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::debug_tuple_field1_finish(f, "Name", &&self.0)
}
}Debug)]
64pub struct Name(pub String);
65
66#[derive(#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications,
clippy :: absolute_paths,)]
const _: () =
{
#[allow(unused_extern_crates, clippy :: useless_attribute)]
extern crate serde as _serde;
;
#[automatically_derived]
impl _serde::Serialize for Workspace {
fn serialize<__S>(&self, __serializer: __S)
-> _serde::__private228::Result<__S::Ok, __S::Error> where
__S: _serde::Serializer {
let mut __serde_state =
_serde::Serializer::serialize_struct(__serializer,
"Workspace",
false as usize +
if Map::is_empty(&self.dependencies) { 0 } else { 1 })?;
if !Map::is_empty(&self.dependencies) {
_serde::ser::SerializeStruct::serialize_field(&mut __serde_state,
"dependencies", &self.dependencies)?;
} else {
_serde::ser::SerializeStruct::skip_field(&mut __serde_state,
"dependencies")?;
}
_serde::ser::SerializeStruct::end(__serde_state)
}
}
};Serialize, #[automatically_derived]
impl ::core::fmt::Debug for Workspace {
#[inline]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::debug_struct_field1_finish(f, "Workspace",
"dependencies", &&self.dependencies)
}
}Debug)]
67pub struct Workspace {
68 #[serde(skip_serializing_if = "Map::is_empty")]
69 pub dependencies: Map<String, Dependency>,
70}
71
72impl AsRef<OsStr> for Name {
73 fn as_ref(&self) -> &OsStr {
74 self.0.as_ref()
75 }
76}
77
78fn serialize_patch<S>(patch: &Map<String, RegistryPatch>, serializer: S) -> Result<S::Ok, S::Error>
79where
80 S: Serializer,
81{
82 let mut map = serializer.serialize_map(None)?;
83 for (registry, patch) in patch {
84 if !patch.crates.is_empty() {
85 map.serialize_entry(registry, patch)?;
86 }
87 }
88 map.end()
89}
90
91fn empty_patch(patch: &Map<String, RegistryPatch>) -> bool {
92 patch
93 .values()
94 .all(|registry_patch| registry_patch.crates.is_empty())
95}