Each `HashMap` instance has a random 128-bit key to use with a keyed hash,
making the order of a set of keys in a given hash table randomized. Rust
provides a [SipHash](https://131002.net/siphash/) implementation for any type
-implementing the `IterBytes` trait.
+implementing the `Hash` trait.
## Double-ended queues
let it = xs.iter().scan((), |_, x| {
calls += 1;
if *x < 3 { Some(x) } else { None }});
-
+
// the iterator will only yield 1 and 2 before returning None
// If we were to call it 5 times, calls would end up as 5, despite
// only 2 values being yielded (and therefore 3 unique calls being
// made). The fuse() adaptor can fix this.
-
+
let mut it = it.fuse();
it.next();
it.next();
#, fuzzy
#| msgid ""
#| "The full list of derivable traits is `Eq`, `TotalEq`, `Ord`, `TotalOrd`, "
-#| "`Encodable` `Decodable`, `Clone`, `DeepClone`, `IterBytes`, `Rand`, "
+#| "`Encodable` `Decodable`, `Clone`, `DeepClone`, `Hash`, `Rand`, "
#| "`Zero`, and `ToStr`."
msgid ""
"The full list of derivable traits is `Eq`, `TotalEq`, `Ord`, `TotalOrd`, "
-"`Encodable` `Decodable`, `Clone`, `DeepClone`, `IterBytes`, `Rand`, "
+"`Encodable` `Decodable`, `Clone`, `DeepClone`, `Hash`, `Rand`, "
"`Default`, `Zero`, and `ToStr`."
msgstr ""
"実装を自動的に導出可能なトレイトは、 `Eq`, `TotalEq`, `Ord`, `TotalOrd`, "
-"`Encodable` `Decodable`, `Clone`, `DeepClone`, `IterBytes`, `Rand`, `Zero`, "
+"`Encodable` `Decodable`, `Clone`, `DeepClone`, `Hash`, `Rand`, `Zero`, "
"および `ToStr` です。."
#. type: Plain text
* Comparison traits: `Eq`, `TotalEq`, `Ord`, `TotalOrd`.
* Serialization: `Encodable`, `Decodable`. These require `serialize`.
* `Clone` and `DeepClone`, to perform (deep) copies.
-* `IterBytes`, to iterate over the bytes in a data type.
+* `Hash`, to iterate over the bytes in a data type.
* `Rand`, to create a random instance of a data type.
* `Default`, to create an empty instance of a data type.
* `Zero`, to create an zero instance of a numeric data type.
The full list of derivable traits is `Eq`, `TotalEq`, `Ord`,
`TotalOrd`, `Encodable` `Decodable`, `Clone`, `DeepClone`,
-`IterBytes`, `Rand`, `Default`, `Zero`, `FromPrimitive` and `Show`.
+`Hash`, `Rand`, `Default`, `Zero`, `FromPrimitive` and `Show`.
# Crates and the module system
syn keyword rustTrait RawPtr
syn keyword rustTrait Buffer Writer Reader Seek
syn keyword rustTrait Str StrVector StrSlice OwnedStr IntoMaybeOwned
-syn keyword rustTrait IterBytes
syn keyword rustTrait ToStr IntoStr
syn keyword rustTrait Tuple1 Tuple2 Tuple3 Tuple4
syn keyword rustTrait Tuple5 Tuple6 Tuple7 Tuple8
use std::num::Bitwise;
-#[deriving(Clone, Eq, IterBytes, ToStr, Encodable, Decodable)]
+#[deriving(Clone, Eq, Hash, ToStr, Encodable, Decodable)]
/// A specialized Set implementation to use enum types.
pub struct EnumSet<E> {
// We must maintain the invariant that no bits are set
use std::cmp::max;
use std::fmt;
-use std::hash_old::Hash;
+use std::hash::{Hash, Hasher, sip};
use std::iter::{FilterMap, Chain, Repeat, Zip};
use std::iter;
use std::mem::replace;
/// hash function for internal state. This means that the order of all hash maps
/// is randomized by keying each hash map randomly on creation.
///
-/// It is required that the keys implement the `Eq` and `Hash` traits, although
-/// this can frequently be achieved by just implementing the `Eq` and
-/// `IterBytes` traits as `Hash` is automatically implemented for types that
-/// implement `IterBytes`.
+/// It is required that the keys implement the `Eq` and `Hash` traits.
pub struct HashMap<K,V> {
priv k0: u64,
priv k1: u64,
#[inline]
fn bucket_for_key(&self, k: &K) -> SearchResult {
- let hash = k.hash_keyed(self.k0, self.k1) as uint;
+ let hash = sip::hash_with_keys(self.k0, self.k1, k) as uint;
self.bucket_for_key_with_hash(hash, k)
}
#[inline]
fn bucket_for_key_equiv<Q:Hash + Equiv<K>>(&self, k: &Q)
-> SearchResult {
- let hash = k.hash_keyed(self.k0, self.k1) as uint;
+ let hash = sip::hash_with_keys(self.k0, self.k1, k) as uint;
self.bucket_for_key_with_hash_equiv(hash, k)
}
self.expand();
}
- let hash = k.hash_keyed(self.k0, self.k1) as uint;
+ let hash = sip::hash_with_keys(self.k0, self.k1, &k) as uint;
self.insert_internal(hash, k, v)
}
/// Removes a key from the map, returning the value at the key if the key
/// was previously in the map.
fn pop(&mut self, k: &K) -> Option<V> {
- let hash = k.hash_keyed(self.k0, self.k1) as uint;
+ let hash = sip::hash_with_keys(self.k0, self.k1, k) as uint;
self.pop_internal(hash, k)
}
}
self.expand();
}
- let hash = k.hash_keyed(self.k0, self.k1) as uint;
+ let hash = sip::hash_with_keys(self.k0, self.k1, &k) as uint;
let idx = match self.bucket_for_key_with_hash(hash, &k) {
TableFull => fail!("Internal logic error"),
FoundEntry(idx) => { found(&k, self.mut_value_for_bucket(idx), a); idx }
impl<
E: Encoder,
- K: Encodable<E> + Hash + IterBytes + Eq,
+ K: Encodable<E> + Hash + Eq,
V: Encodable<E>
> Encodable<E> for HashMap<K, V> {
fn encode(&self, e: &mut E) {
impl<
D: Decoder,
- K: Decodable<D> + Hash + IterBytes + Eq,
+ K: Decodable<D> + Hash + Eq,
V: Decodable<D>
> Decodable<D> for HashMap<K, V> {
fn decode(d: &mut D) -> HashMap<K, V> {
impl<
S: Encoder,
- T: Encodable<S> + Hash + IterBytes + Eq
+ T: Encodable<S> + Hash + Eq
> Encodable<S> for HashSet<T> {
fn encode(&self, s: &mut S) {
s.emit_seq(self.len(), |s| {
impl<
D: Decoder,
- T: Decodable<D> + Hash + IterBytes + Eq
+ T: Decodable<D> + Hash + Eq
> Decodable<D> for HashSet<T> {
fn decode(d: &mut D) -> HashSet<T> {
d.read_seq(|d, len| {
//! ```
use std::container::Container;
-use std::to_bytes::Cb;
+use std::hash::{Hash, sip};
use std::ptr;
use std::cast;
priv tail: *mut LruEntry<K, V>,
}
-impl<K: IterBytes> IterBytes for KeyRef<K> {
- fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- unsafe{ (*self.k).iter_bytes(lsb0, f) }
+impl<K: Hash> Hash for KeyRef<K> {
+ fn hash(&self, s: &mut sip::SipState) {
+ unsafe {(*self.k).hash(s)}
}
}
}
}
-impl<K: IterBytes + Eq, V> LruCache<K, V> {
+impl<K: Hash + Eq, V> LruCache<K, V> {
/// Create an LRU Cache that holds at most `capacity` items.
pub fn new(capacity: uint) -> LruCache<K, V> {
let cache = LruCache {
}
}
-impl<A: ToStr +
IterBytes + Eq, B: ToStr> ToStr for LruCache<A, B> {
+impl<A: ToStr +
Hash + Eq, B: ToStr> ToStr for LruCache<A, B> {
/// Return a string that lists the key-value pairs from most-recently
/// used to least-recently used.
#[inline]
}
}
-impl<K: IterBytes + Eq, V> Container for LruCache<K, V> {
+impl<K: Hash + Eq, V> Container for LruCache<K, V> {
/// Return the number of key-value pairs in the cache.
fn len(&self) -> uint {
self.map.len()
}
}
-impl<K: IterBytes + Eq, V> Mutable for LruCache<K, V> {
+impl<K: Hash + Eq, V> Mutable for LruCache<K, V> {
/// Clear the cache of all key-value pairs.
fn clear(&mut self) {
self.map.clear();
#[allow(missing_doc)];
use std::cmp;
-use std::hash_old::Hash;
+use std::hash::Hash;
use std::io;
use std::mem;
use std::num;
use std::io::BufReader;
use std::cmp::Eq;
use collections::HashMap;
-use std::to_bytes;
+use std::hash::{Hash, sip};
use std::uint;
/// A Uniform Resource Locator (URL). A URL is a form of URI (Uniform Resource
}
}
-impl IterBytes for Url {
- fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
- self.to_str().iter_bytes(lsb0, f)
+impl Hash for Url {
+ fn hash(&self, s: &mut sip::SipState) {
+ self.to_str().hash(s)
}
}
-impl IterBytes for Path {
- fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
- self.to_str().iter_bytes(lsb0, f)
+impl Hash for Path {
+ fn hash(&self, s: &mut sip::SipState) {
+ self.to_str().hash(s)
}
}
/**
* A compiled Unix shell style pattern.
*/
-#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, IterBytes, Default)]
+#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, Hash, Default)]
pub struct Pattern {
priv tokens: ~[PatternToken]
}
-#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, IterBytes)]
+#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, Hash)]
enum PatternToken {
Char(char),
AnyChar,
AnyExcept(~[CharSpecifier])
}
-#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, IterBytes)]
+#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, Hash)]
enum CharSpecifier {
SingleChar(char),
CharRange(char, char)
/**
* Configuration options to modify the behaviour of `Pattern::matches_with(..)`
*/
-#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, IterBytes, Default)]
+#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, Hash, Default)]
pub struct MatchOptions {
/**
use middle::astencode::vtable_decoder_helpers;
use std::u64;
-use std::hash_old::Hash;
+use std::hash;
+use std::hash::Hash;
use std::io;
use std::io::extensions::u64_from_be_bytes;
use std::option;
}
lookup_hash(items,
|a| eq_item(a, item_id),
- (item_id as i64).hash())
+ hash::hash(&(item_id as i64)))
}
fn find_item<'a>(item_id: ast::NodeId, items: ebml::Doc<'a>) -> ebml::Doc<'a> {
use serialize::Encodable;
use std::cast;
use std::cell::{Cell, RefCell};
-use std::hash_old::Hash;
+use std::hash;
+use std::hash::Hash;
use std::io::MemWriter;
use std::str;
use collections::{HashMap, HashSet};
// Path and definition ID indexing
-fn create_index<T:Clone + Hash + IterBytes + 'static>(
+fn create_index<T:Clone + Hash + 'static>(
index: ~[entry<T>])
-> ~[@~[entry<T>]] {
let mut buckets: ~[@RefCell<~[entry<T>]>] = ~[];
buckets.push(@RefCell::new(~[]));
}
for elt in index.iter() {
- let h = elt.val.hash() as uint;
+ let h = hash::hash(&elt.val) as uint;
let mut bucket = buckets[h % 256].borrow_mut();
bucket.get().push((*elt).clone());
}
//
// Note that there is no entry with derefs:3---the type of that expression
// is T, which is not a box.
-#[deriving(Eq, IterBytes)]
+#[deriving(Eq, Hash)]
pub struct root_map_key {
id: ast::NodeId,
derefs: uint
RefBinding,
}
-#[deriving(Eq, IterBytes)]
+#[deriving(Eq, Hash)]
pub enum LoanPath {
LpVar(ast::NodeId), // `x` in doc.rs
LpExtend(@LoanPath, mc::MutabilityCategory, LoanPathElem)
}
-#[deriving(Eq, IterBytes)]
+#[deriving(Eq, Hash)]
pub enum LoanPathElem {
LpDeref(mc::PointerKind), // `*LV` in doc.rs
LpInterior(mc::InteriorKind) // `LV.f` in doc.rs
}
// different kinds of pointers:
-#[deriving(Eq, IterBytes)]
+#[deriving(Eq, Hash)]
pub enum PointerKind {
OwnedPtr,
GcPtr,
// We use the term "interior" to mean "something reachable from the
// base without a pointer dereference", e.g. a field
-#[deriving(Eq, IterBytes)]
+#[deriving(Eq, Hash)]
pub enum InteriorKind {
InteriorField(FieldName),
InteriorElement(ElementKind),
}
-#[deriving(Eq, IterBytes)]
+#[deriving(Eq, Hash)]
pub enum FieldName {
NamedField(ast::Name),
PositionalField(uint)
}
-#[deriving(Eq, IterBytes)]
+#[deriving(Eq, Hash)]
pub enum ElementKind {
VecElement,
StrElement,
OtherElement,
}
-#[deriving(Eq, IterBytes)]
+#[deriving(Eq, Hash)]
pub enum MutabilityCategory {
McImmutable, // Immutable.
McDeclared, // Directly declared as mutable.
ArgumentIrrefutableMode,
}
-#[deriving(Eq, IterBytes)]
+#[deriving(Eq, Hash)]
enum Namespace {
TypeNS,
ValueNS
}
// Used to identify cached monomorphized functions and vtables
-#[deriving(Eq,IterBytes)]
+#[deriving(Eq,Hash)]
pub enum mono_param_id {
mono_precise(ty::t, Option<@~[mono_id]>),
mono_any,
datum::RvalueMode),
}
-#[deriving(Eq,IterBytes)]
+#[deriving(Eq,Hash)]
pub enum MonoDataClass {
MonoBits, // Anything not treated differently from arbitrary integer data
MonoNonNull, // Non-null pointers (used for optional-pointer optimization)
}
-#[deriving(Eq,IterBytes)]
+#[deriving(Eq,Hash)]
pub struct mono_id_ {
def: ast::DefId,
params: ~[mono_param_id]
fn drop(&mut self) { }
}
-#[deriving(Eq, IterBytes)]
+#[deriving(Eq, Hash)]
pub enum RvalueMode {
/// `val` is a pointer to the actual value (and thus has type *T)
ByRef,
use std::cast;
use std::cell::{Cell, RefCell};
use std::cmp;
+use std::hash::{Hash, sip};
use std::ops;
use std::rc::Rc;
-use std::to_bytes;
use std::to_str::ToStr;
use std::vec;
use collections::{HashMap, HashSet};
// Data types
-#[deriving(Eq, IterBytes)]
+#[deriving(Eq, Hash)]
pub struct field {
ident: ast::Ident,
mt: mt
methods: ~[@Method]
}
-#[deriving(Clone, Eq, IterBytes)]
+#[deriving(Clone, Eq, Hash)]
pub struct mt {
ty: t,
mutbl: ast::Mutability,
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes, ToStr)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash, ToStr)]
pub enum vstore {
vstore_fixed(uint),
vstore_uniq,
vstore_slice(Region)
}
-#[deriving(Clone, Eq, IterBytes, Encodable, Decodable, ToStr)]
+#[deriving(Clone, Eq, Hash, Encodable, Decodable, ToStr)]
pub enum TraitStore {
UniqTraitStore, // ~Trait
RegionTraitStore(Region), // &Trait
// Contains information needed to resolve types and (in the future) look up
// the types of AST nodes.
-#[deriving(Eq,IterBytes)]
+#[deriving(Eq,Hash)]
pub struct creader_cache_key {
cnum: CrateNum,
pos: uint,
}
}
-// NB: Do not replace this with #[deriving(IterBytes)], as above. (Figured
-// this out the hard way.)
-impl to_bytes::IterBytes for intern_key {
- fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
+impl Hash for intern_key {
+ fn hash(&self, s: &mut sip::SipState) {
unsafe {
- (*self.sty).iter_bytes(lsb0, f)
+ (*self.sty).hash(s)
}
}
}
}
pub fn type_id(t: t) -> uint { get(t).id }
-#[deriving(Clone, Eq, IterBytes)]
+#[deriving(Clone, Eq, Hash)]
pub struct BareFnTy {
purity: ast::Purity,
abis: AbiSet,
sig: FnSig
}
-#[deriving(Clone, Eq, IterBytes)]
+#[deriving(Clone, Eq, Hash)]
pub struct ClosureTy {
purity: ast::Purity,
sigil: ast::Sigil,
* - `output` is the return type.
* - `variadic` indicates whether this is a varidic function. (only true for foreign fns)
*/
-#[deriving(Clone, Eq, IterBytes)]
+#[deriving(Clone, Eq, Hash)]
pub struct FnSig {
binder_id: ast::NodeId,
inputs: ~[t],
variadic: bool
}
-#[deriving(Clone, Eq, IterBytes)]
+#[deriving(Clone, Eq, Hash)]
pub struct param_ty {
idx: uint,
def_id: DefId
}
/// Representation of regions:
-#[deriving(Clone, Eq, IterBytes, Encodable, Decodable, ToStr, Show)]
+#[deriving(Clone, Eq, Hash, Encodable, Decodable, ToStr, Show)]
pub enum Region {
// Region bound in a type or fn declaration which will be
// substituted 'early' -- that is, at the same time when type
* the original var id (that is, the root variable that is referenced
* by the upvar) and the id of the closure expression.
*/
-#[deriving(Clone, Eq, IterBytes)]
+#[deriving(Clone, Eq, Hash)]
pub struct UpvarId {
var_id: ast::NodeId,
closure_expr_id: ast::NodeId,
}
-#[deriving(Clone, Eq, IterBytes)]
+#[deriving(Clone, Eq, Hash)]
pub enum BorrowKind {
/// Data must be immutable and is aliasable.
ImmBorrow,
}
}
-#[deriving(Clone, Eq, TotalOrd, TotalEq, IterBytes, Encodable, Decodable, ToStr, Show)]
+#[deriving(Clone, Eq, TotalOrd, TotalEq, Hash, Encodable, Decodable, ToStr, Show)]
pub struct FreeRegion {
scope_id: NodeId,
bound_region: BoundRegion
}
-#[deriving(Clone, Eq, TotalEq, TotalOrd, IterBytes, Encodable, Decodable, ToStr, Show)]
+#[deriving(Clone, Eq, TotalEq, TotalOrd, Hash, Encodable, Decodable, ToStr, Show)]
pub enum BoundRegion {
/// An anonymous region parameter for a given fn (&T)
BrAnon(uint),
* Represents the values to use when substituting lifetime parameters.
* If the value is `ErasedRegions`, then this subst is occurring during
* trans, and all region parameters will be replaced with `ty::ReStatic`. */
-#[deriving(Clone, Eq, IterBytes)]
+#[deriving(Clone, Eq, Hash)]
pub enum RegionSubsts {
ErasedRegions,
NonerasedRegions(OptVec<ty::Region>)
* - `self_ty` is the type to which `self` should be remapped, if any. The
* `self` type is rather funny in that it can only appear on traits and is
* always substituted away to the implementing type for a trait. */
-#[deriving(Clone, Eq, IterBytes)]
+#[deriving(Clone, Eq, Hash)]
pub struct substs {
self_ty: Option<ty::t>,
tps: ~[t],
// NB: If you change this, you'll probably want to change the corresponding
// AST structure in libsyntax/ast.rs as well.
-#[deriving(Clone, Eq, IterBytes)]
+#[deriving(Clone, Eq, Hash)]
pub enum sty {
ty_nil,
ty_bot,
ty_unboxed_vec(mt),
}
-#[deriving(Eq, IterBytes)]
+#[deriving(Eq, Hash)]
pub struct TraitRef {
def_id: DefId,
substs: substs
terr_variadic_mismatch(expected_found<bool>)
}
-#[deriving(Eq, IterBytes)]
+#[deriving(Eq, Hash)]
pub struct ParamBounds {
builtin_bounds: BuiltinBounds,
trait_bounds: ~[@TraitRef]
pub type BuiltinBounds = EnumSet<BuiltinBound>;
-#[deriving(Clone, Encodable, Eq, Decodable, IterBytes, ToStr)]
+#[deriving(Clone, Encodable, Eq, Decodable, Hash, ToStr)]
#[repr(uint)]
pub enum BuiltinBound {
BoundStatic,
}
}
-#[deriving(Clone, Eq, IterBytes)]
+#[deriving(Clone, Eq, Hash)]
pub struct TyVid(uint);
-#[deriving(Clone, Eq, IterBytes)]
+#[deriving(Clone, Eq, Hash)]
pub struct IntVid(uint);
-#[deriving(Clone, Eq, IterBytes)]
+#[deriving(Clone, Eq, Hash)]
pub struct FloatVid(uint);
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes, Show)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash, Show)]
pub struct RegionVid {
id: uint
}
-#[deriving(Clone, Eq, IterBytes)]
+#[deriving(Clone, Eq, Hash)]
pub enum InferTy {
TyVar(TyVid),
IntVar(IntVid),
FloatVar(FloatVid)
}
-#[deriving(Clone, Encodable, Decodable, IterBytes, ToStr, Show)]
+#[deriving(Clone, Encodable, Decodable, Hash, ToStr, Show)]
pub enum InferRegion {
ReVar(RegionVid),
ReSkolemized(uint, BoundRegion)
/// Creates a hash of the type `t` which will be the same no matter what crate
/// context it's calculated within. This is used by the `type_id` intrinsic.
pub fn hash_crate_independent(tcx: ctxt, t: t, local_hash: ~str) -> u64 {
- use std::hash_old::{SipState, Streaming};
+ use std::hash::{sip, Hash};
- let mut hash = SipState::new(0, 0);
- let region = |_hash: &mut SipState, r: Region| {
+ let mut hash = sip::SipState::new(0, 0);
+ macro_rules! byte( ($b:expr) => { ($b as u8).hash(&mut hash) } );
+ macro_rules! hash( ($e:expr) => { $e.hash(&mut hash) } );
+
+ let region = |_hash: &mut sip::SipState, r: Region| {
match r {
ReStatic => {}
}
}
};
- let vstore = |hash: &mut SipState, v: vstore| {
+ let vstore = |hash: &mut sip::SipState, v: vstore| {
match v {
- vstore_fixed(_) => hash.input([0]),
- vstore_uniq => hash.input([1]),
+ vstore_fixed(_) => 0u8.hash(hash),
+ vstore_uniq => 1u8.hash(hash),
vstore_slice(r) => {
- hash.input([3]);
+ 2u8.hash(hash);
region(hash, r);
}
}
};
- let did = |hash: &mut SipState, did: DefId| {
+ let did = |hash: &mut sip::SipState, did: DefId| {
let h = if ast_util::is_local(did) {
local_hash.clone()
} else {
tcx.sess.cstore.get_crate_hash(did.krate)
};
- hash.input(h.as_bytes());
- iter(hash, &did.node);
+ h.as_bytes().hash(hash);
+ did.node.hash(hash);
};
- let mt = |hash: &mut SipState, mt: mt| {
- iter(hash, &mt.mutbl);
+ let mt = |hash: &mut sip::SipState, mt: mt| {
+ mt.mutbl.hash(hash);
};
- fn iter<T: IterBytes>(hash: &mut SipState, t: &T) {
- t.iter_bytes(true, |bytes| { hash.input(bytes); true });
- }
ty::walk_ty(t, |t| {
match ty::get(t).sty {
- ty_nil => hash.input([0]),
- ty_bot => hash.input([1]),
- ty_bool => hash.input([2]),
- ty_char => hash.input([3]),
+ ty_nil => byte!(0),
+ ty_bot => byte!(1),
+ ty_bool => byte!(2),
+ ty_char => byte!(3),
ty_int(i) => {
- hash.input([4]);
- iter(&mut hash, &i);
+ byte!(4);
+ hash!(i);
}
ty_uint(u) => {
- hash.input([5]);
- iter(&mut hash, &u);
+ byte!(5);
+ hash!(u);
}
ty_float(f) => {
- hash.input([6]);
- iter(&mut hash, &f);
+ byte!(6);
+ hash!(f);
}
ty_str(v) => {
- hash.input([7]);
- vstore(&mut hash, v);
+ byte!(7);
+ hash!(v);
}
ty_enum(d, _) => {
- hash.input([8]);
- did(&mut hash, d);
+ byte!(8);
+ hash!(d)
}
ty_box(_) => {
- hash.input([9]);
+ byte!(9);
}
ty_uniq(_) => {
- hash.input([10]);
+ byte!(10);
}
ty_vec(m, v) => {
- hash.input([11]);
+ byte!(11);
mt(&mut hash, m);
vstore(&mut hash, v);
}
ty_ptr(m) => {
- hash.input([12]);
+ byte!(12);
mt(&mut hash, m);
}
ty_rptr(r, m) => {
- hash.input([13]);
+ byte!(13);
region(&mut hash, r);
mt(&mut hash, m);
}
ty_bare_fn(ref b) => {
- hash.input([14]);
- iter(&mut hash, &b.purity);
- iter(&mut hash, &b.abis);
+ byte!(14);
+ hash!(b.purity);
+ hash!(b.abis);
}
ty_closure(ref c) => {
- hash.input([15]);
- iter(&mut hash, &c.purity);
- iter(&mut hash, &c.sigil);
- iter(&mut hash, &c.onceness);
- iter(&mut hash, &c.bounds);
+ byte!(15);
+ hash!(c.purity);
+ hash!(c.sigil);
+ hash!(c.onceness);
+ hash!(c.bounds);
region(&mut hash, c.region);
}
ty_trait(d, _, store, m, bounds) => {
- hash.input([17]);
+ byte!(17);
did(&mut hash, d);
match store {
- UniqTraitStore => hash.input([0]),
+ UniqTraitStore => byte!(0),
RegionTraitStore(r) => {
- hash.input([1]);
+ byte!(1)
region(&mut hash, r);
}
}
- iter(&mut hash, &m);
- iter(&mut hash, &bounds);
+ hash!(m);
+ hash!(bounds);
}
ty_struct(d, _) => {
- hash.input([18]);
+ byte!(18);
did(&mut hash, d);
}
ty_tup(ref inner) => {
- hash.input([19]);
- iter(&mut hash, &inner.len());
+ byte!(19);
+ hash!(inner.len());
}
ty_param(p) => {
- hash.input([20]);
- iter(&mut hash, &p.idx);
+ byte!(20);
+ hash!(p.idx);
did(&mut hash, p.def_id);
}
ty_self(d) => {
- hash.input([21]);
+ byte!(21);
did(&mut hash, d);
}
ty_infer(_) => unreachable!(),
- ty_err => hash.input([23]),
+ ty_err => byte!(23),
ty_unboxed_vec(m) => {
- hash.input([24]);
+ byte!(24);
mt(&mut hash, m);
}
}
});
- hash.result_u64()
+ hash.result()
}
impl Variance {
mod doc;
-#[deriving(Eq, IterBytes)]
+#[deriving(Eq, Hash)]
enum Constraint {
ConstrainVarSubVar(RegionVid, RegionVid),
ConstrainRegSubVar(Region, RegionVid),
ConstrainRegSubReg(Region, Region),
}
-#[deriving(Eq, IterBytes)]
+#[deriving(Eq, Hash)]
struct TwoRegions {
a: Region,
b: Region,
use container::Container;
use cast;
use fmt;
+use hash::{Hash, sip};
use iter::Iterator;
use vec::{ImmutableVector, MutableVector, Vector};
-use to_bytes::IterBytes;
use option::{Option, Some, None};
/// Datatype to hold one ascii character. It wraps a `u8`, with the highest bit always zero.
}
}
-impl IterBytes for Ascii {
+impl Hash for Ascii {
#[inline]
- fn iter_bytes(&self, _lsb0: bool, f: |buf: &[u8]| -> bool) -> bool {
- f([self.to_byte()])
+ fn hash(&self, s: &mut sip::SipState) {
+ self.to_byte().hash(s)
}
}
}
/// A selector for what pluralization a plural method should take
-#[deriving(Eq, IterBytes)]
+#[deriving(Eq, Hash)]
pub enum PluralSelector {
/// One of the plural keywords should be used
Keyword(PluralKeyword),
/// specially placed in the `Plural` variant of `Method`
///
/// http://www.icu-project.org/apiref/icu4c/classicu_1_1PluralRules.html
-#[deriving(Eq, IterBytes)]
+#[deriving(Eq, Hash)]
#[allow(missing_doc)]
pub enum PluralKeyword {
Zero, One, Two, Few, Many
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-/*!
- * Implementation of SipHash 2-4
- *
- * See: http://131002.net/siphash/
- *
- * Consider this as a main "general-purpose" hash for all hashtables: it
- * runs at good speed (competitive with spooky and city) and permits
- * strong _keyed_ hashing. Key your hashtables from a strong RNG,
- * such as rand::rng.
- *
- * Although the SipHash algorithm is considered to be cryptographically
- * strong, this implementation has not been reviewed for such purposes.
- * As such, all cryptographic uses of this implementation are strongly
- * discouraged.
- */
-
-#[allow(missing_doc)];
-
-use container::Container;
-use io::{Writer, IoResult};
-use iter::Iterator;
-use option::{Some, None};
-use result::Ok;
-use str::OwnedStr;
-use to_bytes::IterBytes;
-use vec::ImmutableVector;
-
-// Alias `SipState` to `State`.
-pub use State = hash_old::SipState;
-
-/**
- * Types that can meaningfully be hashed should implement this.
- *
- * Note that this trait is likely to change somewhat as it is
- * closely related to `to_bytes::IterBytes` and in almost all
- * cases presently the two are (and must be) used together.
- *
- * In general, most types only need to implement `IterBytes`,
- * and the implementation of `Hash` below will take care of
- * the rest. This is the recommended approach, since constructing
- * good keyed hash functions is quite difficult.
- */
-pub trait Hash {
- /**
- * Compute a "keyed" hash of the value implementing the trait,
- * taking `k0` and `k1` as "keying" parameters that randomize or
- * otherwise perturb the hash function in such a way that a
- * hash table built using such "keyed hash functions" cannot
- * be made to perform linearly by an attacker controlling the
- * hashtable's contents.
- *
- * In practical terms, we implement this using the SipHash 2-4
- * function and require most types to only implement the
- * IterBytes trait, that feeds SipHash.
- */
- fn hash_keyed(&self, k0: u64, k1: u64) -> u64;
-
- #[inline]
- fn hash(&self) -> u64 { self.hash_keyed(0,0) }
-}
-
-/// Streaming hash-functions should implement this.
-pub trait Streaming {
- fn input(&mut self, &[u8]);
- // These can be refactored some when we have default methods.
- fn result_bytes(&mut self) -> ~[u8];
- fn result_str(&mut self) -> ~str;
- fn result_u64(&mut self) -> u64;
- fn reset(&mut self);
-}
-
-impl<A:IterBytes> Hash for A {
- #[inline]
- fn hash_keyed(&self, k0: u64, k1: u64) -> u64 {
- let mut s = State::new(k0, k1);
- self.iter_bytes(true, |bytes| {
- s.input(bytes);
- true
- });
- s.result_u64()
- }
-}
-
-#[inline]
-pub fn default_state() -> State {
- State::new(0, 0)
-}
-
-struct SipState {
- k0: u64,
- k1: u64,
- length: uint, // how many bytes we've processed
- v0: u64, // hash state
- v1: u64,
- v2: u64,
- v3: u64,
- tail: [u8, ..8], // unprocessed bytes
- ntail: uint, // how many bytes in tail are valid
-}
-
-impl SipState {
- #[inline]
- fn new(key0: u64, key1: u64) -> SipState {
- let mut state = SipState {
- k0: key0,
- k1: key1,
- length: 0,
- v0: 0,
- v1: 0,
- v2: 0,
- v3: 0,
- tail: [ 0, 0, 0, 0, 0, 0, 0, 0 ],
- ntail: 0,
- };
- state.reset();
- state
- }
-}
-
-// sadly, these macro definitions can't appear later,
-// because they're needed in the following defs;
-// this design could be improved.
-
-macro_rules! u8to64_le (
- ($buf:expr, $i:expr) =>
- ($buf[0+$i] as u64 |
- $buf[1+$i] as u64 << 8 |
- $buf[2+$i] as u64 << 16 |
- $buf[3+$i] as u64 << 24 |
- $buf[4+$i] as u64 << 32 |
- $buf[5+$i] as u64 << 40 |
- $buf[6+$i] as u64 << 48 |
- $buf[7+$i] as u64 << 56)
-)
-
-macro_rules! rotl (
- ($x:expr, $b:expr) =>
- (($x << $b) | ($x >> (64 - $b)))
-)
-
-macro_rules! compress (
- ($v0:expr, $v1:expr, $v2:expr, $v3:expr) =>
- ({
- $v0 += $v1; $v1 = rotl!($v1, 13); $v1 ^= $v0;
- $v0 = rotl!($v0, 32);
- $v2 += $v3; $v3 = rotl!($v3, 16); $v3 ^= $v2;
- $v0 += $v3; $v3 = rotl!($v3, 21); $v3 ^= $v0;
- $v2 += $v1; $v1 = rotl!($v1, 17); $v1 ^= $v2;
- $v2 = rotl!($v2, 32);
- })
-)
-
-
-impl Writer for SipState {
- // Methods for io::writer
- #[inline]
- fn write(&mut self, msg: &[u8]) -> IoResult<()> {
- let length = msg.len();
- self.length += length;
-
- let mut needed = 0u;
-
- if self.ntail != 0 {
- needed = 8 - self.ntail;
-
- if length < needed {
- let mut t = 0;
- while t < length {
- self.tail[self.ntail+t] = msg[t];
- t += 1;
- }
- self.ntail += length;
- return Ok(())
- }
-
- let mut t = 0;
- while t < needed {
- self.tail[self.ntail+t] = msg[t];
- t += 1;
- }
-
- let m = u8to64_le!(self.tail, 0);
-
- self.v3 ^= m;
- compress!(self.v0, self.v1, self.v2, self.v3);
- compress!(self.v0, self.v1, self.v2, self.v3);
- self.v0 ^= m;
-
- self.ntail = 0;
- }
-
- // Buffered tail is now flushed, process new input.
- let len = length - needed;
- let end = len & (!0x7);
- let left = len & 0x7;
-
- let mut i = needed;
- while i < end {
- let mi = u8to64_le!(msg, i);
-
- self.v3 ^= mi;
- compress!(self.v0, self.v1, self.v2, self.v3);
- compress!(self.v0, self.v1, self.v2, self.v3);
- self.v0 ^= mi;
-
- i += 8;
- }
-
- let mut t = 0u;
- while t < left {
- self.tail[t] = msg[i+t];
- t += 1
- }
- self.ntail = left;
- Ok(())
- }
-}
-
-impl Streaming for SipState {
- #[inline]
- fn input(&mut self, buf: &[u8]) {
- self.write(buf).unwrap();
- }
-
- #[inline]
- fn result_u64(&mut self) -> u64 {
- let mut v0 = self.v0;
- let mut v1 = self.v1;
- let mut v2 = self.v2;
- let mut v3 = self.v3;
-
- let mut b : u64 = (self.length as u64 & 0xff) << 56;
-
- if self.ntail > 0 { b |= self.tail[0] as u64 << 0; }
- if self.ntail > 1 { b |= self.tail[1] as u64 << 8; }
- if self.ntail > 2 { b |= self.tail[2] as u64 << 16; }
- if self.ntail > 3 { b |= self.tail[3] as u64 << 24; }
- if self.ntail > 4 { b |= self.tail[4] as u64 << 32; }
- if self.ntail > 5 { b |= self.tail[5] as u64 << 40; }
- if self.ntail > 6 { b |= self.tail[6] as u64 << 48; }
-
- v3 ^= b;
- compress!(v0, v1, v2, v3);
- compress!(v0, v1, v2, v3);
- v0 ^= b;
-
- v2 ^= 0xff;
- compress!(v0, v1, v2, v3);
- compress!(v0, v1, v2, v3);
- compress!(v0, v1, v2, v3);
- compress!(v0, v1, v2, v3);
-
- return v0 ^ v1 ^ v2 ^ v3;
- }
-
- fn result_bytes(&mut self) -> ~[u8] {
- let h = self.result_u64();
- ~[(h >> 0) as u8,
- (h >> 8) as u8,
- (h >> 16) as u8,
- (h >> 24) as u8,
- (h >> 32) as u8,
- (h >> 40) as u8,
- (h >> 48) as u8,
- (h >> 56) as u8,
- ]
- }
-
- fn result_str(&mut self) -> ~str {
- let r = self.result_bytes();
- let mut s = ~"";
- for b in r.iter() {
- s.push_str(format!("{:x}", *b));
- }
- s
- }
-
- #[inline]
- fn reset(&mut self) {
- self.length = 0;
- self.v0 = self.k0 ^ 0x736f6d6570736575;
- self.v1 = self.k1 ^ 0x646f72616e646f6d;
- self.v2 = self.k0 ^ 0x6c7967656e657261;
- self.v3 = self.k1 ^ 0x7465646279746573;
- self.ntail = 0;
- }
-}
-
-#[cfg(test)]
-mod tests {
- use super::{Hash, Streaming, SipState};
- use iter::Iterator;
- use num::ToStrRadix;
- use option::Some;
- use str::OwnedStr;
- use to_bytes::IterBytes;
- use vec::{Vector, OwnedVector, ImmutableVector};
-
- // Hash just the bytes of the slice, without length prefix
- struct Bytes<'a>(&'a [u8]);
- impl<'a> IterBytes for Bytes<'a> {
- fn iter_bytes(&self, _lsb0: bool, f: |&[u8]| -> bool) -> bool {
- let Bytes(v) = *self;
- f(v)
- }
- }
-
- #[test]
- fn test_siphash() {
- let vecs : [[u8, ..8], ..64] = [
- [ 0x31, 0x0e, 0x0e, 0xdd, 0x47, 0xdb, 0x6f, 0x72, ],
- [ 0xfd, 0x67, 0xdc, 0x93, 0xc5, 0x39, 0xf8, 0x74, ],
- [ 0x5a, 0x4f, 0xa9, 0xd9, 0x09, 0x80, 0x6c, 0x0d, ],
- [ 0x2d, 0x7e, 0xfb, 0xd7, 0x96, 0x66, 0x67, 0x85, ],
- [ 0xb7, 0x87, 0x71, 0x27, 0xe0, 0x94, 0x27, 0xcf, ],
- [ 0x8d, 0xa6, 0x99, 0xcd, 0x64, 0x55, 0x76, 0x18, ],
- [ 0xce, 0xe3, 0xfe, 0x58, 0x6e, 0x46, 0xc9, 0xcb, ],
- [ 0x37, 0xd1, 0x01, 0x8b, 0xf5, 0x00, 0x02, 0xab, ],
- [ 0x62, 0x24, 0x93, 0x9a, 0x79, 0xf5, 0xf5, 0x93, ],
- [ 0xb0, 0xe4, 0xa9, 0x0b, 0xdf, 0x82, 0x00, 0x9e, ],
- [ 0xf3, 0xb9, 0xdd, 0x94, 0xc5, 0xbb, 0x5d, 0x7a, ],
- [ 0xa7, 0xad, 0x6b, 0x22, 0x46, 0x2f, 0xb3, 0xf4, ],
- [ 0xfb, 0xe5, 0x0e, 0x86, 0xbc, 0x8f, 0x1e, 0x75, ],
- [ 0x90, 0x3d, 0x84, 0xc0, 0x27, 0x56, 0xea, 0x14, ],
- [ 0xee, 0xf2, 0x7a, 0x8e, 0x90, 0xca, 0x23, 0xf7, ],
- [ 0xe5, 0x45, 0xbe, 0x49, 0x61, 0xca, 0x29, 0xa1, ],
- [ 0xdb, 0x9b, 0xc2, 0x57, 0x7f, 0xcc, 0x2a, 0x3f, ],
- [ 0x94, 0x47, 0xbe, 0x2c, 0xf5, 0xe9, 0x9a, 0x69, ],
- [ 0x9c, 0xd3, 0x8d, 0x96, 0xf0, 0xb3, 0xc1, 0x4b, ],
- [ 0xbd, 0x61, 0x79, 0xa7, 0x1d, 0xc9, 0x6d, 0xbb, ],
- [ 0x98, 0xee, 0xa2, 0x1a, 0xf2, 0x5c, 0xd6, 0xbe, ],
- [ 0xc7, 0x67, 0x3b, 0x2e, 0xb0, 0xcb, 0xf2, 0xd0, ],
- [ 0x88, 0x3e, 0xa3, 0xe3, 0x95, 0x67, 0x53, 0x93, ],
- [ 0xc8, 0xce, 0x5c, 0xcd, 0x8c, 0x03, 0x0c, 0xa8, ],
- [ 0x94, 0xaf, 0x49, 0xf6, 0xc6, 0x50, 0xad, 0xb8, ],
- [ 0xea, 0xb8, 0x85, 0x8a, 0xde, 0x92, 0xe1, 0xbc, ],
- [ 0xf3, 0x15, 0xbb, 0x5b, 0xb8, 0x35, 0xd8, 0x17, ],
- [ 0xad, 0xcf, 0x6b, 0x07, 0x63, 0x61, 0x2e, 0x2f, ],
- [ 0xa5, 0xc9, 0x1d, 0xa7, 0xac, 0xaa, 0x4d, 0xde, ],
- [ 0x71, 0x65, 0x95, 0x87, 0x66, 0x50, 0xa2, 0xa6, ],
- [ 0x28, 0xef, 0x49, 0x5c, 0x53, 0xa3, 0x87, 0xad, ],
- [ 0x42, 0xc3, 0x41, 0xd8, 0xfa, 0x92, 0xd8, 0x32, ],
- [ 0xce, 0x7c, 0xf2, 0x72, 0x2f, 0x51, 0x27, 0x71, ],
- [ 0xe3, 0x78, 0x59, 0xf9, 0x46, 0x23, 0xf3, 0xa7, ],
- [ 0x38, 0x12, 0x05, 0xbb, 0x1a, 0xb0, 0xe0, 0x12, ],
- [ 0xae, 0x97, 0xa1, 0x0f, 0xd4, 0x34, 0xe0, 0x15, ],
- [ 0xb4, 0xa3, 0x15, 0x08, 0xbe, 0xff, 0x4d, 0x31, ],
- [ 0x81, 0x39, 0x62, 0x29, 0xf0, 0x90, 0x79, 0x02, ],
- [ 0x4d, 0x0c, 0xf4, 0x9e, 0xe5, 0xd4, 0xdc, 0xca, ],
- [ 0x5c, 0x73, 0x33, 0x6a, 0x76, 0xd8, 0xbf, 0x9a, ],
- [ 0xd0, 0xa7, 0x04, 0x53, 0x6b, 0xa9, 0x3e, 0x0e, ],
- [ 0x92, 0x59, 0x58, 0xfc, 0xd6, 0x42, 0x0c, 0xad, ],
- [ 0xa9, 0x15, 0xc2, 0x9b, 0xc8, 0x06, 0x73, 0x18, ],
- [ 0x95, 0x2b, 0x79, 0xf3, 0xbc, 0x0a, 0xa6, 0xd4, ],
- [ 0xf2, 0x1d, 0xf2, 0xe4, 0x1d, 0x45, 0x35, 0xf9, ],
- [ 0x87, 0x57, 0x75, 0x19, 0x04, 0x8f, 0x53, 0xa9, ],
- [ 0x10, 0xa5, 0x6c, 0xf5, 0xdf, 0xcd, 0x9a, 0xdb, ],
- [ 0xeb, 0x75, 0x09, 0x5c, 0xcd, 0x98, 0x6c, 0xd0, ],
- [ 0x51, 0xa9, 0xcb, 0x9e, 0xcb, 0xa3, 0x12, 0xe6, ],
- [ 0x96, 0xaf, 0xad, 0xfc, 0x2c, 0xe6, 0x66, 0xc7, ],
- [ 0x72, 0xfe, 0x52, 0x97, 0x5a, 0x43, 0x64, 0xee, ],
- [ 0x5a, 0x16, 0x45, 0xb2, 0x76, 0xd5, 0x92, 0xa1, ],
- [ 0xb2, 0x74, 0xcb, 0x8e, 0xbf, 0x87, 0x87, 0x0a, ],
- [ 0x6f, 0x9b, 0xb4, 0x20, 0x3d, 0xe7, 0xb3, 0x81, ],
- [ 0xea, 0xec, 0xb2, 0xa3, 0x0b, 0x22, 0xa8, 0x7f, ],
- [ 0x99, 0x24, 0xa4, 0x3c, 0xc1, 0x31, 0x57, 0x24, ],
- [ 0xbd, 0x83, 0x8d, 0x3a, 0xaf, 0xbf, 0x8d, 0xb7, ],
- [ 0x0b, 0x1a, 0x2a, 0x32, 0x65, 0xd5, 0x1a, 0xea, ],
- [ 0x13, 0x50, 0x79, 0xa3, 0x23, 0x1c, 0xe6, 0x60, ],
- [ 0x93, 0x2b, 0x28, 0x46, 0xe4, 0xd7, 0x06, 0x66, ],
- [ 0xe1, 0x91, 0x5f, 0x5c, 0xb1, 0xec, 0xa4, 0x6c, ],
- [ 0xf3, 0x25, 0x96, 0x5c, 0xa1, 0x6d, 0x62, 0x9f, ],
- [ 0x57, 0x5f, 0xf2, 0x8e, 0x60, 0x38, 0x1b, 0xe5, ],
- [ 0x72, 0x45, 0x06, 0xeb, 0x4c, 0x32, 0x8a, 0x95, ]
- ];
-
- let k0 = 0x_07_06_05_04_03_02_01_00_u64;
- let k1 = 0x_0f_0e_0d_0c_0b_0a_09_08_u64;
- let mut buf : ~[u8] = ~[];
- let mut t = 0;
- let mut stream_inc = SipState::new(k0, k1);
- let mut stream_full = SipState::new(k0, k1);
-
- fn to_hex_str(r: &[u8, ..8]) -> ~str {
- let mut s = ~"";
- for b in r.iter() {
- s.push_str(format!("{:x}", *b));
- }
- s
- }
-
- while t < 64 {
- debug!("siphash test {}", t);
- let vec = u8to64_le!(vecs[t], 0);
- let out = Bytes(buf.as_slice()).hash_keyed(k0, k1);
- debug!("got {:?}, expected {:?}", out, vec);
- assert_eq!(vec, out);
-
- stream_full.reset();
- stream_full.input(buf);
- let f = stream_full.result_str();
- let i = stream_inc.result_str();
- let v = to_hex_str(&vecs[t]);
- debug!("{}: ({}) => inc={} full={}", t, v, i, f);
-
- assert!(f == i && f == v);
-
- buf.push(t as u8);
- stream_inc.input([t as u8]);
-
- t += 1;
- }
- }
-
- #[test] #[cfg(target_arch = "arm")]
- fn test_hash_uint() {
- let val = 0xdeadbeef_deadbeef_u64;
- assert!((val as u64).hash() != (val as uint).hash());
- assert_eq!((val as u32).hash(), (val as uint).hash());
- }
- #[test] #[cfg(target_arch = "x86_64")]
- fn test_hash_uint() {
- let val = 0xdeadbeef_deadbeef_u64;
- assert_eq!((val as u64).hash(), (val as uint).hash());
- assert!((val as u32).hash() != (val as uint).hash());
- }
- #[test] #[cfg(target_arch = "x86")]
- fn test_hash_uint() {
- let val = 0xdeadbeef_deadbeef_u64;
- assert!((val as u64).hash() != (val as uint).hash());
- assert_eq!((val as u32).hash(), (val as uint).hash());
- }
-
- #[test]
- fn test_hash_idempotent() {
- let val64 = 0xdeadbeef_deadbeef_u64;
- val64.hash() == val64.hash();
- let val32 = 0xdeadbeef_u32;
- val32.hash() == val32.hash();
- }
-
- #[test]
- fn test_hash_no_bytes_dropped_64() {
- let val = 0xdeadbeef_deadbeef_u64;
-
- assert!(val.hash() != zero_byte(val, 0).hash());
- assert!(val.hash() != zero_byte(val, 1).hash());
- assert!(val.hash() != zero_byte(val, 2).hash());
- assert!(val.hash() != zero_byte(val, 3).hash());
- assert!(val.hash() != zero_byte(val, 4).hash());
- assert!(val.hash() != zero_byte(val, 5).hash());
- assert!(val.hash() != zero_byte(val, 6).hash());
- assert!(val.hash() != zero_byte(val, 7).hash());
-
- fn zero_byte(val: u64, byte: uint) -> u64 {
- assert!(byte < 8);
- val & !(0xff << (byte * 8))
- }
- }
-
- #[test]
- fn test_hash_no_bytes_dropped_32() {
- let val = 0xdeadbeef_u32;
-
- assert!(val.hash() != zero_byte(val, 0).hash());
- assert!(val.hash() != zero_byte(val, 1).hash());
- assert!(val.hash() != zero_byte(val, 2).hash());
- assert!(val.hash() != zero_byte(val, 3).hash());
-
- fn zero_byte(val: u32, byte: uint) -> u32 {
- assert!(byte < 4);
- val & !(0xff << (byte * 8))
- }
- }
-
- #[test]
- fn test_float_hashes_differ() {
- assert!(0.0.hash() != 1.0.hash());
- assert!(1.0.hash() != (-1.0).hash());
- }
-
- #[test]
- fn test_float_hashes_of_zero() {
- assert_eq!(0.0.hash(), (-0.0).hash());
- }
-
- #[test]
- fn test_hash_no_concat_alias() {
- let s = ("aa", "bb");
- let t = ("aabb", "");
- let u = ("a", "abb");
-
- let v = (&[1u8], &[0u8, 0], &[0u8]);
- let w = (&[1u8, 0, 0, 0], &[], &[]);
-
- assert!(v != w);
- assert!(s.hash() != t.hash() && s.hash() != u.hash());
- assert!(v.hash() != w.hash());
- }
-}
/// `TypeId` represents a globally unique identifier for a type
#[lang="type_id"] // This needs to be kept in lockstep with the code in trans/intrinsic.rs and
// middle/lang_items.rs
-#[deriving(Eq, IterBytes)]
+#[deriving(Eq, Hash)]
#[cfg(not(test))]
pub struct TypeId {
priv t: u64,
use option::{Option, None, Some};
use str::StrSlice;
use to_str::ToStr;
-use to_bytes::IterBytes;
use vec::{MutableCloneableVector, ImmutableVector, MutableVector};
pub type Port = u16;
-#[deriving(Eq, TotalEq, Clone, IterBytes)]
+#[deriving(Eq, TotalEq, Clone, Hash)]
pub enum IpAddr {
Ipv4Addr(u8, u8, u8, u8),
Ipv6Addr(u16, u16, u16, u16, u16, u16, u16, u16)
}
}
-#[deriving(Eq, TotalEq, Clone, IterBytes)]
+#[deriving(Eq, TotalEq, Clone, Hash)]
pub struct SocketAddr {
ip: IpAddr,
port: Port,
mod test {
use prelude::*;
use super::*;
- use to_bytes::ToBytes;
#[test]
fn test_from_str_ipv4() {
assert!(a1.to_str() == ~"::ffff:192.0.2.128" || a1.to_str() == ~"::FFFF:192.0.2.128");
assert_eq!(Ipv6Addr(8, 9, 10, 11, 12, 13, 14, 15).to_str(), ~"8:9:a:b:c:d:e:f");
}
-
- #[test]
- fn ipv4_addr_to_bytes() {
- Ipv4Addr(123, 20, 12, 56).to_bytes(true);
- }
-
- #[test]
- fn socket_addr_to_bytes() {
- SocketAddr { ip: Ipv4Addr(1, 2, 3, 4), port: 1234 }.to_bytes(true);
- }
}
use vec::{ImmutableVector, OwnedVector};
#[repr(int)]
-#[deriving(Eq, IterBytes)]
+#[deriving(Eq, Hash)]
pub enum Signum {
/// Equivalent to SIGBREAK, delivered when the user presses Ctrl-Break.
Break = 21i,
pub mod num;
pub mod iter;
pub mod to_str;
-pub mod to_bytes;
pub mod clone;
-pub mod hash_old;
pub mod hash;
pub mod container;
pub mod default;
pub use os;
pub use rt;
pub use str;
- pub use to_bytes;
pub use to_str;
pub use unstable;
}
use clone::Clone;
use cmp::Eq;
use from_str::FromStr;
+use hash::{Hash, sip};
use iter::{AdditiveIterator, Extendable, Iterator, Map};
use option::{Option, None, Some};
use str;
use str::Str;
-use to_bytes::IterBytes;
use vec;
use vec::{CloneableVector, RevSplits, Splits, Vector, VectorVector,
ImmutableEqVector, OwnedVector, ImmutableVector, OwnedCloneableVector};
}
}
-impl IterBytes for Path {
+impl Hash for Path {
#[inline]
- fn iter_bytes(&self, lsb0: bool, f: |buf: &[u8]| -> bool) -> bool {
- self.repr.iter_bytes(lsb0, f)
+ fn hash(&self, s: &mut sip::SipState) {
+ self.repr.hash(s)
}
}
use container::Container;
use cmp::Eq;
use from_str::FromStr;
+use hash::{Hash, sip};
use iter::{AdditiveIterator, DoubleEndedIterator, Extendable, Rev, Iterator, Map};
use option::{Option, Some, None};
use str;
use str::{CharSplits, OwnedStr, Str, StrVector, StrSlice};
-use to_bytes::IterBytes;
use vec::{Vector, OwnedVector, ImmutableVector};
use super::{contains_nul, BytesContainer, GenericPath, GenericPathUnsafe};
}
}
-impl IterBytes for Path {
+impl Hash for Path {
#[inline]
- fn iter_bytes(&self, lsb0: bool, f: |&[u8]| -> bool) -> bool {
- self.repr.iter_bytes(lsb0, f)
+ fn hash(&self, s: &mut sip::SipState) {
+ self.repr.hash(s)
}
}
pub use ptr::RawPtr;
pub use io::{Buffer, Writer, Reader, Seek};
pub use str::{Str, StrVector, StrSlice, OwnedStr, IntoMaybeOwned};
-pub use to_bytes::IterBytes;
pub use to_str::{ToStr, IntoStr};
pub use tuple::{Tuple1, Tuple2, Tuple3, Tuple4};
pub use tuple::{Tuple5, Tuple6, Tuple7, Tuple8};
use cmp::{Eq, TotalEq, Ord, TotalOrd, Equiv, Ordering};
use container::{Container, Mutable};
use fmt;
+use hash::{Hash, sip};
use iter::{Iterator, FromIterator, Extendable, range};
use iter::{Filter, AdditiveIterator, Map};
use iter::{Rev, DoubleEndedIterator, ExactSize};
use vec::{OwnedVector, OwnedCloneableVector, ImmutableVector, MutableVector};
use vec_ng::Vec;
use default::Default;
-use to_bytes::{IterBytes, Cb};
use raw::Repr;
/*
fn default() -> MaybeOwned<'a> { Slice("") }
}
-impl<'a> IterBytes for MaybeOwned<'a> {
+impl<'a> Hash for MaybeOwned<'a> {
#[inline]
- fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- match *self {
- Slice(s) => s.iter_bytes(lsb0, f),
- Owned(ref s) => s.iter_bytes(lsb0, f)
- }
+ fn hash(&self, s: &mut sip::SipState) {
+ self.as_slice().hash(s)
}
}
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-/*!
-
-The `ToBytes` and `IterBytes` traits for converting to raw bytes
-
-*/
-
-use cast;
-use container::Container;
-use iter::Iterator;
-use option::{None, Option, Some};
-use rc::Rc;
-use str::{Str, StrSlice};
-use vec::{Vector, ImmutableVector};
-use vec_ng::Vec;
-
-pub type Cb<'a> = 'a |buf: &[u8]| -> bool;
-
-///
-/// A trait to implement in order to make a type hashable;
-/// This works in combination with the trait `std::hash::Hash`, and
-/// may in the future be merged with that trait or otherwise
-/// modified when default methods and trait inheritance are
-/// completed.
-///
-/// IterBytes should be implemented so that the extent of the
-/// produced byte stream can be discovered, given the original
-/// type.
-/// For example, the IterBytes implementation for vectors emits
-/// its length first, and enums should emit their discriminant.
-///
-pub trait IterBytes {
- /// Call the provided callback `f` one or more times with
- /// byte-slices that should be used when computing a hash
- /// value or otherwise "flattening" the structure into
- /// a sequence of bytes. The `lsb0` parameter conveys
- /// whether the caller is asking for little-endian bytes
- /// (`true`) or big-endian (`false`); this should only be
- /// relevant in implementations that represent a single
- /// multi-byte datum such as a 32 bit integer or 64 bit
- /// floating-point value. It can be safely ignored for
- /// larger structured types as they are usually processed
- /// left-to-right in declaration order, regardless of
- /// underlying memory endianness.
- ///
- fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool;
-}
-
-impl IterBytes for bool {
- #[inline]
- fn iter_bytes(&self, _lsb0: bool, f: Cb) -> bool {
- f([
- *self as u8
- ])
- }
-}
-
-impl IterBytes for u8 {
- #[inline]
- fn iter_bytes(&self, _lsb0: bool, f: Cb) -> bool {
- f([
- *self
- ])
- }
-}
-
-impl IterBytes for u16 {
- #[inline]
- fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- if lsb0 {
- f([
- *self as u8,
- (*self >> 8) as u8
- ])
- } else {
- f([
- (*self >> 8) as u8,
- *self as u8
- ])
- }
- }
-}
-
-impl IterBytes for u32 {
- #[inline]
- fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- if lsb0 {
- f([
- *self as u8,
- (*self >> 8) as u8,
- (*self >> 16) as u8,
- (*self >> 24) as u8,
- ])
- } else {
- f([
- (*self >> 24) as u8,
- (*self >> 16) as u8,
- (*self >> 8) as u8,
- *self as u8
- ])
- }
- }
-}
-
-impl IterBytes for u64 {
- #[inline]
- fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- if lsb0 {
- f([
- *self as u8,
- (*self >> 8) as u8,
- (*self >> 16) as u8,
- (*self >> 24) as u8,
- (*self >> 32) as u8,
- (*self >> 40) as u8,
- (*self >> 48) as u8,
- (*self >> 56) as u8
- ])
- } else {
- f([
- (*self >> 56) as u8,
- (*self >> 48) as u8,
- (*self >> 40) as u8,
- (*self >> 32) as u8,
- (*self >> 24) as u8,
- (*self >> 16) as u8,
- (*self >> 8) as u8,
- *self as u8
- ])
- }
- }
-}
-
-impl IterBytes for i8 {
- #[inline]
- fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- (*self as u8).iter_bytes(lsb0, f)
- }
-}
-
-impl IterBytes for i16 {
- #[inline]
- fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- (*self as u16).iter_bytes(lsb0, f)
- }
-}
-
-impl IterBytes for i32 {
- #[inline]
- fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- (*self as u32).iter_bytes(lsb0, f)
- }
-}
-
-impl IterBytes for i64 {
- #[inline]
- fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- (*self as u64).iter_bytes(lsb0, f)
- }
-}
-
-impl IterBytes for char {
- #[inline]
- fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- (*self as u32).iter_bytes(lsb0, f)
- }
-}
-
-#[cfg(target_word_size = "32")]
-impl IterBytes for uint {
- #[inline]
- fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- (*self as u32).iter_bytes(lsb0, f)
- }
-}
-
-#[cfg(target_word_size = "64")]
-impl IterBytes for uint {
- #[inline]
- fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- (*self as u64).iter_bytes(lsb0, f)
- }
-}
-
-impl IterBytes for int {
- #[inline]
- fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- (*self as uint).iter_bytes(lsb0, f)
- }
-}
-
-impl IterBytes for f32 {
- #[inline]
- fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- let i: u32 = unsafe {
- // 0.0 == -0.0 so they should also have the same hashcode
- cast::transmute(if *self == -0.0 { 0.0 } else { *self })
- };
- i.iter_bytes(lsb0, f)
- }
-}
-
-impl IterBytes for f64 {
- #[inline]
- fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- let i: u64 = unsafe {
- // 0.0 == -0.0 so they should also have the same hashcode
- cast::transmute(if *self == -0.0 { 0.0 } else { *self })
- };
- i.iter_bytes(lsb0, f)
- }
-}
-
-impl<'a,A:IterBytes> IterBytes for &'a [A] {
- #[inline]
- fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- self.len().iter_bytes(lsb0, |b| f(b)) &&
- self.iter().advance(|elt| elt.iter_bytes(lsb0, |b| f(b)))
- }
-}
-
-impl<A: IterBytes> IterBytes for (A, ) {
- fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- match *self {
- (ref a, ) => a.iter_bytes(lsb0, |b| f(b))
- }
- }
-}
-
-macro_rules! iter_bytes_tuple(
- ($($A:ident),+) => (
- impl<$($A: IterBytes),+> IterBytes for ($($A),+) {
- fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- match *self {
- ($(ref $A),+) => {
- $(
- $A .iter_bytes(lsb0, |b| f(b))
- )&&+
- }
- }
- }
- }
- )
-)
-
-iter_bytes_tuple!(A, B)
-iter_bytes_tuple!(A, B, C)
-iter_bytes_tuple!(A, B, C, D)
-iter_bytes_tuple!(A, B, C, D, E)
-iter_bytes_tuple!(A, B, C, D, E, F)
-iter_bytes_tuple!(A, B, C, D, E, F, G)
-iter_bytes_tuple!(A, B, C, D, E, F, G, H)
-
-impl<A:IterBytes> IterBytes for ~[A] {
- #[inline]
- fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- self.as_slice().iter_bytes(lsb0, f)
- }
-}
-
-impl<A:IterBytes> IterBytes for Vec<A> {
- #[inline]
- fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- self.as_slice().iter_bytes(lsb0, f)
- }
-}
-
-impl<'a> IterBytes for &'a str {
- #[inline]
- fn iter_bytes(&self, _lsb0: bool, f: Cb) -> bool {
- // Terminate the string with a byte that does not appear in UTF-8
- f(self.as_bytes()) && f([0xFF])
- }
-}
-
-impl IterBytes for ~str {
- #[inline]
- fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- self.as_slice().iter_bytes(lsb0, f)
- }
-}
-
-impl<A:IterBytes> IterBytes for Option<A> {
- #[inline]
- fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- match *self {
- Some(ref a) => 0u8.iter_bytes(lsb0, |b| f(b)) && a.iter_bytes(lsb0, |b| f(b)),
- None => 1u8.iter_bytes(lsb0, f)
- }
- }
-}
-
-impl<'a,A:IterBytes> IterBytes for &'a A {
- #[inline]
- fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- (**self).iter_bytes(lsb0, f)
- }
-}
-
-impl<A:IterBytes> IterBytes for @A {
- #[inline]
- fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- (**self).iter_bytes(lsb0, f)
- }
-}
-
-impl<A:IterBytes> IterBytes for Rc<A> {
- #[inline]
- fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- self.borrow().iter_bytes(lsb0, f)
- }
-}
-
-impl<A:IterBytes> IterBytes for ~A {
- #[inline]
- fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- (**self).iter_bytes(lsb0, f)
- }
-}
-
-// NB: raw-pointer IterBytes does _not_ dereference
-// to the target; it just gives you the pointer-bytes.
-impl<A> IterBytes for *A {
- #[inline]
- fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- (*self as uint).iter_bytes(lsb0, f)
- }
-}
-
-impl<A> IterBytes for *mut A {
- #[inline]
- fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- (*self as uint).iter_bytes(lsb0, f)
- }
-}
-
-/// A trait for converting a value to a list of bytes.
-pub trait ToBytes {
- /// Converts the current value to a list of bytes. This is equivalent to
- /// invoking iter_bytes on a type and collecting all yielded values in an
- /// array
- fn to_bytes(&self, lsb0: bool) -> ~[u8];
-}
-
-impl<A:IterBytes> ToBytes for A {
- fn to_bytes(&self, lsb0: bool) -> ~[u8] {
- use io::Writer;
-
- let mut m = ::io::MemWriter::new();
- self.iter_bytes(lsb0, |bytes| {
- m.write(bytes).unwrap();
- true
- });
- m.unwrap()
- }
-}
-
-#[cfg(test)]
-mod test {
- use super::*;
- // just test to see if it compiles:
- #[test] fn iterbytes_compiles () {
- takes_iterbytes((3,4,5,false));
- }
- fn takes_iterbytes<T : IterBytes>(_x : T) {}
-}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::to_bytes;
+use std::hash::{Hash, sip};
#[deriving(Eq)]
pub enum Os { OsWin32, OsMacos, OsLinux, OsAndroid, OsFreebsd, }
Archs(u32) // Multiple architectures (bitset)
}
-#[deriving(Clone, Eq, Encodable, Decodable)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct AbiSet {
priv bits: u32 // each bit represents one of the abis below
}
}
}
-impl to_bytes::IterBytes for Abi {
- fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
- self.index().iter_bytes(lsb0, f)
- }
-}
-
-impl to_bytes::IterBytes for AbiSet {
- fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
- self.bits.iter_bytes(lsb0, f)
+impl Hash for Abi {
+ fn hash(&self, s: &mut sip::SipState) {
+ self.index().hash(s)
}
}
// table) and a SyntaxContext to track renaming and
// macro expansion per Flatt et al., "Macros
// That Work Together"
-#[deriving(Clone, IterBytes, ToStr, TotalEq, TotalOrd, Show)]
+#[deriving(Clone, Hash, ToStr, TotalEq, TotalOrd, Show)]
pub struct Ident { name: Name, ctxt: SyntaxContext }
impl Ident {
pub static EMPTY_CTXT : SyntaxContext = 0;
pub static ILLEGAL_CTXT : SyntaxContext = 1;
-#[deriving(Eq, Encodable, Decodable,IterBytes)]
+#[deriving(Eq, Encodable, Decodable,Hash)]
pub enum SyntaxContext_ {
EmptyCtxt,
Mark (Mrk,SyntaxContext),
/// Function name (not all functions have names)
pub type FnIdent = Option<Ident>;
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct Lifetime {
id: NodeId,
span: Span,
// for instance: std::cmp::Eq . It's represented
// as a sequence of identifiers, along with a bunch
// of supporting information.
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct Path {
span: Span,
/// A `::foo` path, is relative to the crate root rather than current
/// A segment of a path: an identifier, an optional lifetime, and a set of
/// types.
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct PathSegment {
/// The identifier portion of this path segment.
identifier: Ident,
pub type NodeId = u32;
-#[deriving(Clone, TotalEq, TotalOrd, Eq, Encodable, Decodable, IterBytes, ToStr, Show)]
+#[deriving(Clone, TotalEq, TotalOrd, Eq, Encodable, Decodable, Hash, ToStr, Show)]
pub struct DefId {
krate: CrateNum,
node: NodeId,
// typeck::collect::compute_bounds matches these against
// the "special" built-in traits (see middle::lang_items) and
// detects Copy, Send, Send, and Freeze.
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum TyParamBound {
TraitTyParamBound(TraitRef),
RegionTyParamBound
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct TyParam {
ident: Ident,
id: NodeId,
default: Option<P<Ty>>
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct Generics {
lifetimes: OptVec<Lifetime>,
ty_params: OptVec<TyParam>,
}
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum MethodProvenance {
FromTrait(DefId),
FromImpl(DefId),
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum Def {
DefFn(DefId, Purity),
DefStaticMethod(/* method */ DefId, MethodProvenance, Purity),
DefMethod(DefId /* method */, Option<DefId> /* trait */),
}
-#[deriving(Clone, Eq, IterBytes, Encodable, Decodable, ToStr)]
+#[deriving(Clone, Eq, Hash, Encodable, Decodable, ToStr)]
pub enum DefRegion {
DefStaticRegion,
DefEarlyBoundRegion(/* index */ uint, /* lifetime decl */ NodeId),
// used to drive conditional compilation
pub type CrateConfig = ~[@MetaItem];
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct Crate {
module: Mod,
attrs: ~[Attribute],
pub type MetaItem = Spanned<MetaItem_>;
-#[deriving(Clone, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Encodable, Decodable, Hash)]
pub enum MetaItem_ {
MetaWord(InternedString),
MetaList(InternedString, ~[@MetaItem]),
}
}
-#[deriving(Clone, Eq, Encodable, Decodable,IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable,Hash)]
pub struct Block {
view_items: ~[ViewItem],
stmts: ~[@Stmt],
span: Span,
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct Pat {
id: NodeId,
node: Pat_,
span: Span,
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct FieldPat {
ident: Ident,
pat: @Pat,
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum BindingMode {
BindByRef(Mutability),
BindByValue(Mutability),
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum Pat_ {
PatWild,
PatWildMulti,
PatVec(~[@Pat], Option<@Pat>, ~[@Pat])
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum Mutability {
MutMutable,
MutImmutable,
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum Sigil {
BorrowedSigil,
OwnedSigil,
}
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum ExprVstore {
ExprVstoreUniq, // ~[1,2,3,4]
ExprVstoreSlice, // &[1,2,3,4]
ExprVstoreMutSlice, // &mut [1,2,3,4]
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum BinOp {
BiAdd,
BiSub,
BiGt,
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum UnOp {
UnBox,
UnUniq,
pub type Stmt = Spanned<Stmt_>;
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum Stmt_ {
// could be an item or a local (let) binding:
StmtDecl(@Decl, NodeId),
// FIXME (pending discussion of #1697, #2178...): local should really be
// a refinement on pat.
/// Local represents a `let` statement, e.g., `let <pat>:<ty> = <expr>;`
-#[deriving(Eq, Encodable, Decodable,IterBytes)]
+#[deriving(Eq, Encodable, Decodable,Hash)]
pub struct Local {
ty: P<Ty>,
pat: @Pat,
pub type Decl = Spanned<Decl_>;
-#[deriving(Eq, Encodable, Decodable,IterBytes)]
+#[deriving(Eq, Encodable, Decodable,Hash)]
pub enum Decl_ {
// a local (let) binding:
DeclLocal(@Local),
DeclItem(@Item),
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct Arm {
pats: ~[@Pat],
guard: Option<@Expr>,
body: P<Block>,
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct Field {
ident: SpannedIdent,
expr: @Expr,
pub type SpannedIdent = Spanned<Ident>;
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum BlockCheckMode {
DefaultBlock,
UnsafeBlock(UnsafeSource),
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum UnsafeSource {
CompilerGenerated,
UserProvided,
}
-#[deriving(Clone, Eq, Encodable, Decodable,IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable,Hash)]
pub struct Expr {
id: NodeId,
node: Expr_,
}
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum Expr_ {
ExprVstore(@Expr, ExprVstore),
// First expr is the place; second expr is the value.
// else knows what to do with them, so you'll probably get a syntax
// error.
//
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
#[doc="For macro invocations; parsing is delegated to the macro"]
pub enum TokenTree {
// a single token
//
pub type Matcher = Spanned<Matcher_>;
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum Matcher_ {
// match one token
MatchTok(::parse::token::Token),
// is being invoked, and the vector of token-trees contains the source
// of the macro invocation.
// There's only one flavor, now, so this could presumably be simplified.
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum Mac_ {
MacInvocTT(Path, ~[TokenTree], SyntaxContext), // new macro-invocation
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum StrStyle {
CookedStr,
RawStr(uint)
pub type Lit = Spanned<Lit_>;
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum Lit_ {
LitStr(InternedString, StrStyle),
LitBinary(Rc<~[u8]>),
// NB: If you change this, you'll probably want to change the corresponding
// type structure in middle/ty.rs as well.
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct MutTy {
ty: P<Ty>,
mutbl: Mutability,
}
-#[deriving(Eq, Encodable, Decodable,IterBytes)]
+#[deriving(Eq, Encodable, Decodable,Hash)]
pub struct TypeField {
ident: Ident,
mt: MutTy,
span: Span,
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct TypeMethod {
ident: Ident,
attrs: ~[Attribute],
// A trait method is either required (meaning it doesn't have an
// implementation, just a signature) or provided (meaning it has a default
// implementation).
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum TraitMethod {
Required(TypeMethod),
Provided(@Method),
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum IntTy {
TyI,
TyI8,
}
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum UintTy {
TyU,
TyU8,
}
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum FloatTy {
TyF32,
TyF64,
}
// NB Eq method appears below.
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct Ty {
id: NodeId,
node: Ty_,
}
// Not represented directly in the AST, referred to by name through a ty_path.
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum PrimTy {
TyInt(IntTy),
TyUint(UintTy),
TyChar
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum Onceness {
Once,
Many
}
}
-#[deriving(Eq, Encodable, Decodable,IterBytes)]
+#[deriving(Eq, Encodable, Decodable,Hash)]
pub struct ClosureTy {
sigil: Sigil,
region: Option<Lifetime>,
bounds: Option<OptVec<TyParamBound>>,
}
-#[deriving(Eq, Encodable, Decodable,IterBytes)]
+#[deriving(Eq, Encodable, Decodable, Hash)]
pub struct BareFnTy {
purity: Purity,
abis: AbiSet,
decl: P<FnDecl>
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum Ty_ {
TyNil,
TyBot, /* bottom type */
TyInfer,
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum AsmDialect {
AsmAtt,
AsmIntel
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct InlineAsm {
asm: InternedString,
asm_str_style: StrStyle,
dialect: AsmDialect
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct Arg {
ty: P<Ty>,
pat: @Pat,
}
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct FnDecl {
inputs: ~[Arg],
output: P<Ty>,
variadic: bool
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum Purity {
UnsafeFn, // declared with "unsafe fn"
ImpureFn, // declared with "fn"
}
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum RetStyle {
NoReturn, // functions with return type _|_ that always
// raise an error or exit (i.e. never return to the caller)
Return, // everything else
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum ExplicitSelf_ {
SelfStatic, // no self
SelfValue, // `self`
pub type ExplicitSelf = Spanned<ExplicitSelf_>;
-#[deriving(Eq, Encodable, Decodable,IterBytes)]
+#[deriving(Eq, Encodable, Decodable,Hash)]
pub struct Method {
ident: Ident,
attrs: ~[Attribute],
vis: Visibility,
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct Mod {
view_items: ~[ViewItem],
items: ~[@Item],
}
-#[deriving(Clone, Eq, Encodable, Decodable,IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable,Hash)]
pub struct ForeignMod {
abis: AbiSet,
view_items: ~[ViewItem],
items: ~[@ForeignItem],
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct VariantArg {
ty: P<Ty>,
id: NodeId,
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum VariantKind {
TupleVariantKind(~[VariantArg]),
StructVariantKind(@StructDef),
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct EnumDef {
variants: ~[P<Variant>],
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct Variant_ {
name: Ident,
attrs: ~[Attribute],
pub type Variant = Spanned<Variant_>;
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct PathListIdent_ {
name: Ident,
id: NodeId,
pub type ViewPath = Spanned<ViewPath_>;
-#[deriving(Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Eq, Encodable, Decodable, Hash)]
pub enum ViewPath_ {
// quux = foo::bar::baz
ViewPathList(Path, ~[PathListIdent], NodeId)
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct ViewItem {
node: ViewItem_,
attrs: ~[Attribute],
span: Span,
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum ViewItem_ {
// ident: name used to refer to this crate in the code
// optional (InternedString,StrStyle): if present, this is a location
// Distinguishes between Attributes that decorate items and Attributes that
// are contained as statements within items. These two cases need to be
// distinguished for pretty-printing.
-#[deriving(Clone, Eq, Encodable, Decodable,IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable,Hash)]
pub enum AttrStyle {
AttrOuter,
AttrInner,
}
// doc-comments are promoted to attributes that have is_sugared_doc = true
-#[deriving(Clone, Eq, Encodable, Decodable,IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable,Hash)]
pub struct Attribute_ {
style: AttrStyle,
value: @MetaItem,
If this impl is an ItemImpl, the impl_id is redundant (it could be the
same as the impl's node id).
*/
-#[deriving(Clone, Eq, Encodable, Decodable,IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable,Hash)]
pub struct TraitRef {
path: Path,
ref_id: NodeId,
}
-#[deriving(Clone, Eq, Encodable, Decodable,IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable,Hash)]
pub enum Visibility {
Public,
Private,
}
}
-#[deriving(Clone, Eq, Encodable, Decodable,IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable,Hash)]
pub struct StructField_ {
kind: StructFieldKind,
id: NodeId,
pub type StructField = Spanned<StructField_>;
-#[deriving(Clone, Eq, Encodable, Decodable,IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable,Hash)]
pub enum StructFieldKind {
NamedField(Ident, Visibility),
UnnamedField // element of a tuple-like struct
}
-#[deriving(Eq, Encodable, Decodable,IterBytes)]
+#[deriving(Eq, Encodable, Decodable,Hash)]
pub struct StructDef {
fields: ~[StructField], /* fields, not including ctor */
/* ID of the constructor. This is only used for tuple- or enum-like
FIXME (#3300): Should allow items to be anonymous. Right now
we just use dummy names for anon items.
*/
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct Item {
ident: Ident,
attrs: ~[Attribute],
span: Span,
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub enum Item_ {
ItemStatic(P<Ty>, Mutability, @Expr),
ItemFn(P<FnDecl>, Purity, AbiSet, Generics, P<Block>),
ItemMac(Mac),
}
-#[deriving(Eq, Encodable, Decodable,IterBytes)]
+#[deriving(Eq, Encodable, Decodable,Hash)]
pub struct ForeignItem {
ident: Ident,
attrs: ~[Attribute],
vis: Visibility,
}
-#[deriving(Eq, Encodable, Decodable,IterBytes)]
+#[deriving(Eq, Encodable, Decodable,Hash)]
pub enum ForeignItem_ {
ForeignItemFn(P<FnDecl>, Generics),
ForeignItemStatic(P<Ty>, /* is_mutbl */ bool),
// The data we save and restore about an inlined item or method. This is not
// part of the AST that we parse from a file, but it becomes part of the tree
// that we trans.
-#[deriving(Eq, Encodable, Decodable,IterBytes)]
+#[deriving(Eq, Encodable, Decodable,Hash)]
pub enum InlinedItem {
IIItem(@Item),
IIMethod(DefId /* impl id */, bool /* is provided */, @Method),
/// A byte offset. Keep this small (currently 32-bits), as AST contains
/// a lot of them.
-#[deriving(Clone, Eq, IterBytes, Ord)]
+#[deriving(Clone, Eq, Hash, Ord)]
pub struct BytePos(u32);
/// A character offset. Because of multibyte utf8 characters, a byte offset
/// is not equivalent to a character offset. The CodeMap will convert BytePos
/// values to CharPos values as necessary.
-#[deriving(Eq,IterBytes, Ord)]
+#[deriving(Eq,Hash, Ord)]
pub struct CharPos(uint);
// FIXME: Lots of boilerplate in these impls, but so far my attempts to fix
relative to FileMaps. Methods on the CodeMap can be used to relate spans back
to the original source.
*/
-#[deriving(Clone, IterBytes)]
+#[deriving(Clone, Hash)]
pub struct Span {
lo: BytePos,
hi: BytePos,
pub static DUMMY_SP: Span = Span { lo: BytePos(0), hi: BytePos(0), expn_info: None };
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, Hash)]
pub struct Spanned<T> {
node: T,
span: Span,
pub struct FileMapAndLine {fm: @FileMap, line: uint}
pub struct FileMapAndBytePos {fm: @FileMap, pos: BytePos}
-#[deriving(Clone, IterBytes)]
+#[deriving(Clone, Hash)]
pub enum MacroFormat {
// e.g. #[deriving(...)] <item>
MacroAttribute,
MacroBang
}
-#[deriving(Clone, IterBytes)]
+#[deriving(Clone, Hash)]
pub struct NameAndSpan {
name: ~str,
// the format with which the macro was invoked.
}
/// Extra information for tracking macro expansion of spans
-#[deriving(IterBytes)]
+#[deriving(Hash)]
pub struct ExpnInfo {
call_site: Span,
callee: NameAndSpan
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use ast::{MetaItem, Item, Expr, BiAnd};
-use codemap::Span;
-use ext::base::ExtCtxt;
-use ext::build::AstBuilder;
-use ext::deriving::generic::*;
-
-
-pub fn expand_deriving_iter_bytes(cx: &mut ExtCtxt,
- span: Span,
- mitem: @MetaItem,
- item: @Item,
- push: |@Item|) {
- let trait_def = TraitDef {
- span: span,
- attributes: ~[],
- path: Path::new(~["std", "to_bytes", "IterBytes"]),
- additional_bounds: ~[],
- generics: LifetimeBounds::empty(),
- methods: ~[
- MethodDef {
- name: "iter_bytes",
- generics: LifetimeBounds::empty(),
- explicit_self: borrowed_explicit_self(),
- args: ~[
- Literal(Path::new(~["bool"])),
- Literal(Path::new(~["std", "to_bytes", "Cb"]))
- ],
- ret_ty: Literal(Path::new(~["bool"])),
- inline: true,
- const_nonmatching: false,
- combine_substructure: iter_bytes_substructure
- }
- ]
- };
-
- trait_def.expand(cx, mitem, item, push)
-}
-
-fn iter_bytes_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) -> @Expr {
- let (lsb0, f)= match substr.nonself_args {
- [l, f] => (l, f),
- _ => cx.span_bug(trait_span, "incorrect number of arguments in `deriving(IterBytes)`")
- };
- // Build the "explicitly borrowed" stack closure, "|_buf| f(_buf)".
- let blk_arg = cx.ident_of("_buf");
- let borrowed_f =
- cx.lambda_expr_1(trait_span,
- cx.expr_call(trait_span, f, ~[cx.expr_ident(trait_span, blk_arg)]),
- blk_arg);
-
- let iter_bytes_ident = substr.method_ident;
- let call_iterbytes = |span, thing_expr| {
- cx.expr_method_call(span,
- thing_expr,
- iter_bytes_ident,
- ~[lsb0, borrowed_f])
- };
- let mut exprs = ~[];
- let fields;
- match *substr.fields {
- Struct(ref fs) => {
- fields = fs
- }
- EnumMatching(index, ref variant, ref fs) => {
- // Determine the discriminant. We will feed this value to the byte
- // iteration function.
- let discriminant = match variant.node.disr_expr {
- Some(d)=> d,
- None => cx.expr_uint(trait_span, index)
- };
-
- exprs.push(call_iterbytes(trait_span, discriminant));
-
- fields = fs;
- }
- _ => cx.span_bug(trait_span, "impossible substructure in `deriving(IterBytes)`")
- }
-
- for &FieldInfo { self_, span, .. } in fields.iter() {
- exprs.push(call_iterbytes(span, self_));
- }
-
- if exprs.len() == 0 {
- cx.span_bug(trait_span, "#[deriving(IterBytes)] needs at least one field");
- }
-
- exprs.slice(1, exprs.len()).iter().fold(exprs[0], |prev, me| {
- cx.expr_binary(trait_span, BiAnd, prev, *me)
- })
-}
use codemap::Span;
pub mod clone;
-pub mod iter_bytes;
pub mod encodable;
pub mod decodable;
pub mod hash;
"Clone" => expand!(clone::expand_deriving_clone),
"DeepClone" => expand!(clone::expand_deriving_deep_clone),
- "IterBytes" => expand!(iter_bytes::expand_deriving_iter_bytes),
"Hash" => expand!(hash::expand_deriving_hash),
"Encodable" => expand!(encodable::expand_deriving_encodable),
use std::vec;
-#[deriving(Clone, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Encodable, Decodable, Hash)]
pub enum OptVec<T> {
Empty,
Vec(~[T])
use parse::parser::Parser;
use parse::token;
-use std::to_bytes;
-
/// The specific types of unsupported syntax
-#[deriving(Eq)]
+#[deriving(Eq, Hash)]
pub enum ObsoleteSyntax {
ObsoleteSwap,
ObsoleteUnsafeBlock,
ObsoleteManagedVec,
}
-impl to_bytes::IterBytes for ObsoleteSyntax {
- #[inline]
- fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
- (*self as uint).iter_bytes(lsb0, f)
- }
-}
-
pub trait ParserObsoleteMethods {
/// Reports an obsolete syntax non-fatal error.
fn obsolete(&mut self, sp: Span, kind: ObsoleteSyntax);
use std::path::BytesContainer;
#[allow(non_camel_case_types)]
-#[deriving(Clone, Encodable, Decodable, Eq, IterBytes)]
+#[deriving(Clone, Encodable, Decodable, Eq, Hash)]
pub enum BinOp {
PLUS,
MINUS,
}
#[allow(non_camel_case_types)]
-#[deriving(Clone, Encodable, Decodable, Eq, IterBytes)]
+#[deriving(Clone, Encodable, Decodable, Eq, Hash)]
pub enum Token {
/* Expression-operator symbols. */
EQ,
EOF,
}
-#[deriving(Clone, Encodable, Decodable, Eq, IterBytes)]
+#[deriving(Clone, Encodable, Decodable, Eq, Hash)]
/// For interpolation during macro expansion.
pub enum Nonterminal {
NtItem(@ast::Item),
/// destroyed. In particular, they must not access string contents. This can
/// be fixed in the future by just leaking all strings until task death
/// somehow.
-#[deriving(Clone, Eq, IterBytes, Ord, TotalEq, TotalOrd)]
+#[deriving(Clone, Eq, Hash, Ord, TotalEq, TotalOrd)]
pub struct InternedString {
priv string: RcStr,
}
use std::cast;
use std::cell::RefCell;
use std::cmp::Equiv;
-use std::hash_old::Hash;
+use std::hash::Hash;
use std::rc::Rc;
pub struct Interner<T> {
}
// when traits can extend traits, we should extend index<Name,T> to get []
-impl<T:Eq + IterBytes + Hash + Freeze + Clone + 'static> Interner<T> {
+impl<T:Eq + Hash + Freeze + Clone + 'static> Interner<T> {
pub fn new() -> Interner<T> {
Interner {
map: RefCell::new(HashMap::new()),
vect.get().len()
}
- pub fn find_equiv<Q:Hash + IterBytes + Equiv<T>>(&self, val: &Q)
+ pub fn find_equiv<Q:Hash + Equiv<T>>(&self, val: &Q)
-> Option<Name> {
let map = self.map.borrow();
match map.get().find_equiv(val) {
}
}
-#[deriving(Clone, Eq, IterBytes, Ord)]
+#[deriving(Clone, Eq, Hash, Ord)]
pub struct RcStr {
priv string: Rc<~str>,
}
vect.get().len()
}
- pub fn find_equiv<Q:Hash + IterBytes + Equiv<RcStr>>(&self, val: &Q)
+ pub fn find_equiv<Q:Hash + Equiv<RcStr>>(&self, val: &Q)
-> Option<Name> {
let map = self.map.borrow();
match map.get().find_equiv(val) {
use std::rand::Rng;
use std::cmp::Eq;
use std::cast::{transmute,transmute_copy};
-use std::to_bytes::{IterBytes, Cb};
+use std::hash::{Hash, sip};
use serialize::{Encoder, Encodable, Decoder, Decodable};
/// The 128-bit number stored in 16 bytes
bytes: UuidBytes
}
-impl IterBytes for Uuid {
- fn iter_bytes(&self, _: bool, f: Cb) -> bool {
- f(self.bytes.slice_from(0))
+impl Hash for Uuid {
+ fn hash(&self, s: &mut sip::SipState) {
+ self.bytes.slice_from(0).hash(s)
}
}
// function calls, then being in a submodule will (correctly)
// cause errors about unrecognised module `std` (or `extra`)
#[deriving(Eq, Ord, TotalEq, TotalOrd,
- IterBytes,
Clone, DeepClone,
ToStr, Rand,
Encodable, Decodable)]
enum A { A1(uint), A2(int) }
#[deriving(Eq, Ord, TotalEq, TotalOrd,
- IterBytes,
Clone, DeepClone,
ToStr, Rand,
Encodable, Decodable)]
struct B { x: uint, y: int }
#[deriving(Eq, Ord, TotalEq, TotalOrd,
- IterBytes,
Clone, DeepClone,
ToStr, Rand,
Encodable, Decodable)]
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::hash_old::Hash;
-
#[deriving(Eq)]
#[deriving(Clone)]
-#[deriving(IterBytes)]
struct Foo {
bar: uint,
baz: int
a == a; // check for Eq impl w/o testing its correctness
a.clone(); // check for Clone impl w/o testing its correctness
- a.hash(); // check for IterBytes impl w/o testing its correctness
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::hash_old::Hash;
-
-#[deriving(Eq, Clone, IterBytes)]
+#[deriving(Eq, Clone)]
struct Foo {
bar: uint,
baz: int
a == a; // check for Eq impl w/o testing its correctness
a.clone(); // check for Clone impl w/o testing its correctness
- a.hash(); // check for IterBytes impl w/o testing its correctness
}
--- /dev/null
+// ignore-fast
+
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[deriving(Hash)]
+enum Foo {
+ Bar(int, char),
+ Baz(char, int)
+}
+
+#[deriving(Hash)]
+enum A {
+ B,
+ C,
+ D,
+ E
+}
+
+pub fn main(){}
--- /dev/null
+// ignore-fast
+
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[deriving(Hash)]
+struct Foo {
+ x: int,
+ y: int,
+ z: int
+}
+
+pub fn main() {}
+++ /dev/null
-// ignore-fast
-
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[deriving(IterBytes)]
-enum Foo {
- Bar(int, char),
- Baz(char, int)
-}
-
-#[deriving(IterBytes)]
-enum A {
- B,
- C,
- D,
- E
-}
-
-pub fn main(){}
+++ /dev/null
-// ignore-fast
-
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[deriving(IterBytes)]
-struct Foo {
- x: int,
- y: int,
- z: int
-}
-
-pub fn main() {}
// except according to those terms.
#[deriving(Eq)]
-#[deriving(IterBytes)]
+#[deriving(Hash)]
struct Foo<T> {
x: int,
y: T,
}
}
-#[deriving(Eq, IterBytes)]
+#[deriving(Eq, Hash)]
struct NodeId {
id: uint
}
extern crate other1 = "typeid-intrinsic";
extern crate other2 = "typeid-intrinsic2";
-use std::hash_old::Hash;
+use std::hash;
use std::intrinsics;
use std::intrinsics::TypeId;
// check it has a hash
let (a, b) = (TypeId::of::<uint>(), TypeId::of::<uint>());
- assert_eq!(a.hash(), b.hash());
+ assert_eq!(hash::hash(&a), hash::hash(&b));
}
projects / rust.git / commitdiff