/// Returns true if the package (`sum`) can fulfill this dependency request.
pub fn matches_ignoring_source(&self, sum: &Summary) -> bool {
- self.name() == sum.package_id().name() &&
+ self.name() == &*sum.package_id().name() &&
self.version_req().matches(sum.package_id().version())
}
/// Returns true if the package (`id`) can fulfill this dependency request.
pub fn matches_id(&self, id: &PackageId) -> bool {
- self.inner.name == id.name() &&
+ self.inner.name == &*id.name() &&
(self.inner.only_match_name || (self.inner.req.matches(id.version()) &&
&self.inner.source_id == id.source_id()))
}
use std::mem;
use std::cmp::Ordering;
use std::ops::Deref;
+use std::hash::{Hash, Hasher};
pub fn leek(s: String) -> &'static str {
let boxed = s.into_boxed_str();
RwLock::new(HashSet::new());
}
-#[derive(Eq, PartialEq, Hash, Clone, Copy)]
+#[derive(Eq, PartialEq, Clone, Copy)]
pub struct InternedString {
ptr: *const u8,
len: usize,
cache.insert(s);
InternedString { ptr: s.as_ptr(), len: s.len() }
}
+ pub fn to_inner(&self) -> &'static str {
+ unsafe {
+ let slice = slice::from_raw_parts(self.ptr, self.len);
+ &str::from_utf8_unchecked(slice)
+ }
+ }
}
impl Deref for InternedString {
type Target = str;
fn deref(&self) -> &'static str {
- unsafe {
- let slice = slice::from_raw_parts(self.ptr, self.len);
- &str::from_utf8_unchecked(slice)
- }
+ self.to_inner()
+ }
+}
+
+impl Hash for InternedString {
+ fn hash<H: Hasher>(&self, state: &mut H) {
+ self.to_inner().hash(state);
}
}
impl fmt::Debug for InternedString {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- let str: &str = &*self;
- write!(f, "InternedString {{ {} }}", str)
+ write!(f, "InternedString {{ {} }}", self.to_inner())
+ }
+}
+
+impl fmt::Display for InternedString {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ write!(f, "{}", self.to_inner())
}
}
impl Ord for InternedString {
fn cmp(&self, other: &InternedString) -> Ordering {
- let str: &str = &*self;
- str.cmp(&*other)
+ self.to_inner().cmp(&*other)
}
}
pub fn exclude(&self) -> &[String] { &self.exclude }
pub fn include(&self) -> &[String] { &self.include }
pub fn metadata(&self) -> &ManifestMetadata { &self.metadata }
- pub fn name(&self) -> &str { self.package_id().name() }
+ pub fn name(&self) -> &str { self.package_id().name().to_inner() }
pub fn package_id(&self) -> &PackageId { self.summary.package_id() }
pub fn summary(&self) -> &Summary { &self.summary }
pub fn targets(&self) -> &[Target] { &self.targets }
let description = manmeta.description.as_ref().map(String::as_ref);
SerializedPackage {
- name: package_id.name(),
+ name: &*package_id.name(),
version: &package_id.version().to_string(),
id: package_id,
license,
/// Get the path to the manifest
pub fn manifest_path(&self) -> &Path { &self.manifest_path }
/// Get the name of the package
- pub fn name(&self) -> &str { self.package_id().name() }
+ pub fn name(&self) -> &str { self.package_id().name().to_inner() }
/// Get the PackageId object for the package (fully defines a package)
pub fn package_id(&self) -> &PackageId { self.manifest.package_id() }
/// Get the root folder of the package
use util::{CargoResult, ToSemver};
use core::source::SourceId;
+use core::interning::InternedString;
/// Identifier for a specific version of a package in a specific source.
#[derive(Clone)]
#[derive(PartialEq, PartialOrd, Eq, Ord)]
struct PackageIdInner {
- name: String,
+ name: InternedString,
version: semver::Version,
source_id: SourceId,
}
Ok(PackageId {
inner: Arc::new(PackageIdInner {
- name: name.to_string(),
+ name: InternedString::new(name),
version,
source_id,
}),
let v = version.to_semver()?;
Ok(PackageId {
inner: Arc::new(PackageIdInner {
- name: name.to_string(),
+ name: InternedString::new(name),
version: v,
source_id: sid.clone(),
}),
})
}
- pub fn name(&self) -> &str { &self.inner.name }
+ pub fn name(&self) -> InternedString { self.inner.name }
pub fn version(&self) -> &semver::Version { &self.inner.version }
pub fn source_id(&self) -> &SourceId { &self.inner.source_id }
pub fn with_precise(&self, precise: Option<String>) -> PackageId {
PackageId {
inner: Arc::new(PackageIdInner {
- name: self.inner.name.to_string(),
+ name: self.inner.name,
version: self.inner.version.clone(),
source_id: self.inner.source_id.with_precise(precise),
}),
pub fn with_source_id(&self, source: &SourceId) -> PackageId {
PackageId {
inner: Arc::new(PackageIdInner {
- name: self.inner.name.to_string(),
+ name: self.inner.name,
version: self.inner.version.clone(),
source_id: source.clone(),
}),
}
pub fn matches(&self, package_id: &PackageId) -> bool {
- if self.name() != package_id.name() { return false }
+ if self.name() != &*package_id.name() { return false }
if let Some(ref v) = self.version {
if v != package_id.version() {
let v = patches.get(dep.source_id().url()).map(|vec| {
let dep2 = dep.clone();
let mut iter = vec.iter().filter(move |p| {
- dep2.name() == p.name() &&
+ dep2.name() == &*p.name() &&
dep2.version_req().matches(p.version())
});
(iter.next(), iter)
assert!(remaining.next().is_none());
let patch_source = patch_id.source_id();
let patch_locked = locked.get(patch_source).and_then(|m| {
- m.get(patch_id.name())
+ m.get(&*patch_id.name())
}).map(|list| {
list.iter().any(|&(ref id, _)| id == patch_id)
}).unwrap_or(false);
for &(p, r) in features_errors.iter() {
if let ConflictReason::MissingFeatures(ref features) = *r {
msg.push_str("\n\nthe package `");
- msg.push_str(p.name());
+ msg.push_str(&*p.name());
msg.push_str("` depends on `");
msg.push_str(dep.name());
msg.push_str("`, with features: `");
method: &Method) -> CargoResult<bool> {
let id = summary.package_id();
let prev = self.activations
- .entry((InternedString::new(id.name()), id.source_id().clone()))
+ .entry((id.name(), id.source_id().clone()))
.or_insert_with(||Rc::new(Vec::new()));
if !prev.iter().any(|c| c == summary) {
self.resolve_graph.push(GraphNode::Add(id.clone()));
}
fn is_active(&self, id: &PackageId) -> bool {
- self.activations.get(&(InternedString::new(id.name()), id.source_id().clone()))
+ self.activations.get(&(id.name(), id.source_id().clone()))
.map(|v| v.iter().any(|s| s.package_id() == id))
.unwrap_or(false)
}
}
pub fn package_id(&self) -> &PackageId { &self.inner.package_id }
- pub fn name(&self) -> &str { self.package_id().name() }
+ pub fn name(&self) -> &str { self.package_id().name().to_inner() }
pub fn version(&self) -> &Version { self.package_id().version() }
pub fn source_id(&self) -> &SourceId { self.package_id().source_id() }
pub fn dependencies(&self) -> &[Dependency] { &self.inner.dependencies }
resolve: &'a Resolve) ->
Vec<(Vec<&'a PackageId>, Vec<&'a PackageId>)> {
fn key(dep: &PackageId) -> (&str, &SourceId) {
- (dep.name(), dep.source_id())
+ (dep.name().to_inner(), dep.source_id())
}
// Removes all package ids in `b` from `a`. Note that this is somewhat
let deps = self.resolve.deps(id);
let mut ret = deps.filter(|dep| {
unit.pkg.dependencies().iter().filter(|d| {
- d.name() == dep.name() && d.version_req().matches(dep.version())
+ d.name() == &*dep.name() && d.version_req().matches(dep.version())
}).any(|d| {
// If this target is a build command, then we only want build
// dependencies, otherwise we want everything *other than* build
fn doc_deps(&self, unit: &Unit<'a>) -> CargoResult<Vec<Unit<'a>>> {
let deps = self.resolve.deps(unit.pkg.package_id()).filter(|dep| {
unit.pkg.dependencies().iter().filter(|d| {
- d.name() == dep.name()
+ d.name() == &*dep.name()
}).any(|dep| {
match dep.kind() {
DepKind::Normal => self.dep_platform_activated(dep,
pkg: &PackageId,
load: &mut RegistryData)
-> CargoResult<String> {
- let name = pkg.name();
+ let name = &*pkg.name();
let version = pkg.version();
if let Some(s) = self.hashes.get(name).and_then(|v| v.get(version)) {
return Ok(s.clone())
// differ due to historical Cargo bugs. To paper over these we trash the
// *summary* loaded from the Cargo.toml we just downloaded with the one
// we loaded from the index.
- let summaries = self.index.summaries(package.name(), &mut *self.ops)?;
+ let summaries = self.index.summaries(&*package.name(), &mut *self.ops)?;
let summary = summaries.iter().map(|s| &s.0).find(|s| {
s.package_id() == package
}).expect("summary not found");
write!(url, "/{}/{}/download", CRATE_TEMPLATE, VERSION_TEMPLATE).unwrap();
}
let url = url
- .replace(CRATE_TEMPLATE, pkg.name())
+ .replace(CRATE_TEMPLATE, &*pkg.name())
.replace(VERSION_TEMPLATE, &pkg.version().to_string())
.to_url()?;
projects / cargo.git / commitdiff