/// ```
#[unsafe_no_drop_flag]
pub struct Arc<T> {
- priv x: *mut ArcInner<T>,
+ x: *mut ArcInner<T>,
}
/// A weak pointer to an `Arc`.
/// used to break cycles between `Arc` pointers.
#[unsafe_no_drop_flag]
pub struct Weak<T> {
- priv x: *mut ArcInner<T>,
+ x: *mut ArcInner<T>,
}
struct ArcInner<T> {
/// An extension of `pipes::stream` that allows both sending and receiving.
pub struct DuplexStream<S, R> {
- priv tx: Sender<S>,
- priv rx: Receiver<R>,
+ tx: Sender<S>,
+ rx: Receiver<R>,
}
/// Creates a bidirectional stream.
/// A type encapsulating the result of a computation which may not be complete
pub struct Future<A> {
-
priv state: FutureState<A>,
+ state: FutureState<A>,
}
enum FutureState<A> {
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
html_root_url = "http://static.rust-lang.org/doc/master")]
#![feature(phase)]
-#![deny(missing_doc, deprecated_owned_vector)]
+#![deny(deprecated_owned_vector)]
+
+// #![deny(missing_doc)] // NOTE: uncomment after a stage0 snap
+#![allow(missing_doc)] // NOTE: remove after a stage0 snap
+#![allow(visible_private_types)] // NOTE: remove after a stage0 snap
#[cfg(test)]
#[phase(syntax, link)] extern crate log;
/// A condition variable, a mechanism for unlock-and-descheduling and
/// signaling, for use with the lock types.
pub struct Condvar<'a> {
- priv name: &'static str,
+ name: &'static str,
// n.b. Inner must be after PoisonOnFail because we must set the poison flag
// *inside* the mutex, and struct fields are destroyed top-to-bottom
// (destroy the lock guard last).
- priv poison: PoisonOnFail<'a>,
- priv inner: Inner<'a>,
+ poison: PoisonOnFail<'a>,
+ inner: Inner<'a>,
}
impl<'a> Condvar<'a> {
/// }
/// ```
pub struct Mutex<T> {
- priv lock: raw::Mutex,
- priv failed: Unsafe<bool>,
- priv data: Unsafe<T>,
+ lock: raw::Mutex,
+ failed: Unsafe<bool>,
+ data: Unsafe<T>,
}
/// An guard which is created by locking a mutex. Through this guard the
/// underlying data can be accessed.
pub struct MutexGuard<'a, T> {
- priv data: &'a mut T,
+ data: &'a mut T,
/// Inner condition variable connected to the locked mutex that this guard
/// was created from. This can be used for atomic-unlock-and-deschedule.
- cond: Condvar<'a>,
+ pub cond: Condvar<'a>,
}
impl<T: Send> Mutex<T> {
/// println!("{}", *val);
/// ```
pub struct RWLock<T> {
- priv lock: raw::RWLock,
- priv failed: Unsafe<bool>,
- priv data: Unsafe<T>,
+ lock: raw::RWLock,
+ failed: Unsafe<bool>,
+ data: Unsafe<T>,
}
/// A guard which is created by locking an rwlock in write mode. Through this
/// guard the underlying data can be accessed.
pub struct RWLockWriteGuard<'a, T> {
- priv data: &'a mut T,
+ data: &'a mut T,
/// Inner condition variable that can be used to sleep on the write mode of
/// this rwlock.
- cond: Condvar<'a>,
+ pub cond: Condvar<'a>,
}
/// A guard which is created by locking an rwlock in read mode. Through this
/// guard the underlying data can be accessed.
pub struct RWLockReadGuard<'a, T> {
- priv data: &'a T,
- priv guard: raw::RWLockReadGuard<'a>,
+ data: &'a T,
+ guard: raw::RWLockReadGuard<'a>,
}
impl<T: Send + Share> RWLock<T> {
/// }
/// ```
pub struct Barrier {
- priv lock: Mutex<BarrierState>,
- priv num_tasks: uint,
+ lock: Mutex<BarrierState>,
+ num_tasks: uint,
}
// The inner state of a double barrier
// initialization.
pub struct Node<T> {
- next: atomics::AtomicUint,
- data: T,
+ pub next: atomics::AtomicUint,
+ pub data: T,
}
pub struct DummyNode {
- next: atomics::AtomicUint,
+ pub next: atomics::AtomicUint,
}
pub struct Queue<T> {
- head: atomics::AtomicUint,
- tail: Unsafe<*mut Node<T>>,
- stub: DummyNode,
+ pub head: atomics::AtomicUint,
+ pub tail: Unsafe<*mut Node<T>>,
+ pub stub: DummyNode,
}
impl<T: Send> Queue<T> {
/// drop(guard); // unlock the lock
/// ```
pub struct Mutex {
- priv lock: StaticMutex,
+ lock: StaticMutex,
}
#[deriving(Eq, Show)]
/// ```
pub struct StaticMutex {
/// Current set of flags on this mutex
- priv state: atomics::AtomicUint,
+ state: atomics::AtomicUint,
/// an OS mutex used by native threads
- priv lock: mutex::StaticNativeMutex,
+ lock: mutex::StaticNativeMutex,
/// Type of locking operation currently on this mutex
- priv flavor: Unsafe<Flavor>,
+ flavor: Unsafe<Flavor>,
/// uint-cast of the green thread waiting for this mutex
- priv green_blocker: Unsafe<uint>,
+ green_blocker: Unsafe<uint>,
/// uint-cast of the native thread waiting for this mutex
- priv native_blocker: Unsafe<uint>,
+ native_blocker: Unsafe<uint>,
/// A concurrent mpsc queue used by green threads, along with a count used
/// to figure out when to dequeue and enqueue.
- priv q: q::Queue<uint>,
- priv green_cnt: atomics::AtomicUint,
+ q: q::Queue<uint>,
+ green_cnt: atomics::AtomicUint,
}
/// An RAII implementation of a "scoped lock" of a mutex. When this structure is
/// dropped (falls out of scope), the lock will be unlocked.
#[must_use]
pub struct Guard<'a> {
- priv lock: &'a StaticMutex,
+ lock: &'a StaticMutex,
}
/// Static initialization of a mutex. This constant can be used to initialize
/// }
/// ```
pub struct Once {
- priv mutex: StaticMutex,
- priv cnt: atomics::AtomicInt,
- priv lock_cnt: atomics::AtomicInt,
+ mutex: StaticMutex,
+ cnt: atomics::AtomicInt,
+ lock_cnt: atomics::AtomicInt,
}
/// Initialization value for static `Once` values.
pub struct Condvar<'a> {
// The 'Sem' object associated with this condvar. This is the one that's
// atomically-unlocked-and-descheduled upon and reacquired during wakeup.
- priv sem: &'a Sem<Vec<WaitQueue> >,
+ sem: &'a Sem<Vec<WaitQueue> >,
// This is (can be) an extra semaphore which is held around the reacquire
// operation on the first one. This is only used in cvars associated with
// rwlocks, and is needed to ensure that, when a downgrader is trying to
// hand off the access lock (which would be the first field, here), a 2nd
// writer waking up from a cvar wait can't race with a reader to steal it,
// See the comment in write_cond for more detail.
- priv order: ReacquireOrderLock<'a>,
+ order: ReacquireOrderLock<'a>,
// Make sure condvars are non-copyable.
- priv nocopy: marker::NoCopy,
+ nocopy: marker::NoCopy,
}
impl<'a> Condvar<'a> {
/// A counting, blocking, bounded-waiting semaphore.
pub struct Semaphore {
- priv sem: Sem<()>,
+ sem: Sem<()>,
}
/// An RAII guard used to represent an acquired resource to a semaphore. When
/// dropped, this value will release the resource back to the semaphore.
#[must_use]
pub struct SemaphoreGuard<'a> {
- priv guard: SemGuard<'a, ()>,
+ guard: SemGuard<'a, ()>,
}
impl Semaphore {
/// A task which fails while holding a mutex will unlock the mutex as it
/// unwinds.
pub struct Mutex {
- priv sem: Sem<Vec<WaitQueue>>,
+ sem: Sem<Vec<WaitQueue>>,
}
/// An RAII structure which is used to gain access to a mutex's condition
/// corresponding mutex is also unlocked.
#[must_use]
pub struct MutexGuard<'a> {
- priv guard: SemGuard<'a, Vec<WaitQueue>>,
+ guard: SemGuard<'a, Vec<WaitQueue>>,
/// Inner condition variable which is connected to the outer mutex, and can
/// be used for atomic-unlock-and-deschedule.
- cond: Condvar<'a>,
+ pub cond: Condvar<'a>,
}
impl Mutex {
/// A task which fails while holding an rwlock will unlock the rwlock as it
/// unwinds.
pub struct RWLock {
- priv order_lock: Semaphore,
- priv access_lock: Sem<Vec<WaitQueue>>,
+ order_lock: Semaphore,
+ access_lock: Sem<Vec<WaitQueue>>,
// The only way the count flag is ever accessed is with xadd. Since it is
// a read-modify-write operation, multiple xadds on different cores will
//
// FIXME(#6598): The atomics module has no relaxed ordering flag, so I use
// acquire/release orderings superfluously. Change these someday.
- priv read_count: atomics::AtomicUint,
+ read_count: atomics::AtomicUint,
}
/// An RAII helper which is created by acquiring a read lock on an RWLock. When
/// dropped, this will unlock the RWLock.
#[must_use]
pub struct RWLockReadGuard<'a> {
- priv lock: &'a RWLock,
+ lock: &'a RWLock,
}
/// An RAII helper which is created by acquiring a write lock on an RWLock. When
/// A value of this type can also be consumed to downgrade to a read-only lock.
#[must_use]
pub struct RWLockWriteGuard<'a> {
- priv lock: &'a RWLock,
+ lock: &'a RWLock,
/// Inner condition variable that is connected to the write-mode of the
/// outer rwlock.
- cond: Condvar<'a>,
+ pub cond: Condvar<'a>,
}
impl RWLock {
}
pub struct TaskPool<T> {
- priv channels: Vec<Sender<Msg<T>>>,
- priv next_index: uint,
+ channels: Vec<Sender<Msg<T>>>,
+ next_index: uint,
}
#[unsafe_destructor]
projects / rust.git / commitdiff