file_name
large_stringlengths 4
69
| prefix
large_stringlengths 0
26.7k
| suffix
large_stringlengths 0
24.8k
| middle
large_stringlengths 0
2.12k
| fim_type
large_stringclasses 4
values |
|---|---|---|---|---|
kqueue.rs | use std::{cmp, fmt, ptr};
use std::os::raw::c_int;
use std::os::unix::io::RawFd;
use std::collections::HashMap;
use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
use std::time::Duration;
use libc::{self, time_t};
use {io, Ready, PollOpt, Token};
use event::{self, Event};
use sys::unix::cvt;
use sys::unix::io::set_cloexec;
/// Each Selector has a globally unique(ish) ID associated with it. This ID
/// gets tracked by `TcpStream`, `TcpListener`, etc... when they are first
/// registered with the `Selector`. If a type that is previously associated with
/// a `Selector` attempts to register itself with a different `Selector`, the
/// operation will return with an error. This matches windows behavior.
static NEXT_ID: AtomicUsize = ATOMIC_USIZE_INIT;
macro_rules! kevent {
($id: expr, $filter: expr, $flags: expr, $data: expr) => {
libc::kevent {
ident: $id as ::libc::uintptr_t,
filter: $filter,
flags: $flags,
fflags: 0,
data: 0,
udata: $data as *mut _,
}
}
}
pub struct Selector {
id: usize,
kq: RawFd,
}
impl Selector {
pub fn new() -> io::Result<Selector> {
// offset by 1 to avoid choosing 0 as the id of a selector
let id = NEXT_ID.fetch_add(1, Ordering::Relaxed) + 1;
let kq = unsafe { try!(cvt(libc::kqueue())) };
drop(set_cloexec(kq));
Ok(Selector {
id: id,
kq: kq,
})
}
pub fn id(&self) -> usize {
self.id
}
pub fn select(&self, evts: &mut Events, awakener: Token, timeout: Option<Duration>) -> io::Result<bool> {
let timeout = timeout.map(|to| {
libc::timespec {
tv_sec: cmp::min(to.as_secs(), time_t::max_value() as u64) as time_t,
tv_nsec: to.subsec_nanos() as libc::c_long,
}
});
let timeout = timeout.as_ref().map(|s| s as *const _).unwrap_or(ptr::null_mut());
unsafe {
let cnt = try!(cvt(libc::kevent(self.kq,
ptr::null(),
0,
evts.sys_events.0.as_mut_ptr(),
// FIXME: needs a saturating cast here.
evts.sys_events.0.capacity() as c_int,
timeout)));
evts.sys_events.0.set_len(cnt as usize);
Ok(evts.coalesce(awakener))
}
}
pub fn register(&self, fd: RawFd, token: Token, interests: Ready, opts: PollOpt) -> io::Result<()> {
trace!("registering; token={:?}; interests={:?}", token, interests);
let flags = if opts.contains(PollOpt::edge()) { libc::EV_CLEAR } else { 0 } |
if opts.contains(PollOpt::oneshot()) { libc::EV_ONESHOT } else { 0 } |
libc::EV_RECEIPT;
unsafe {
let r = if interests.contains(Ready::readable()) { libc::EV_ADD } else { libc::EV_DELETE };
let w = if interests.contains(Ready::writable()) { libc::EV_ADD } else { libc::EV_DELETE };
let mut changes = [
kevent!(fd, libc::EVFILT_READ, flags | r, usize::from(token)),
kevent!(fd, libc::EVFILT_WRITE, flags | w, usize::from(token)),
];
try!(cvt(libc::kevent(self.kq, changes.as_ptr(), changes.len() as c_int,
changes.as_mut_ptr(), changes.len() as c_int,
::std::ptr::null())));
for change in changes.iter() {
debug_assert_eq!(change.flags & libc::EV_ERROR, libc::EV_ERROR);
if change.data!= 0 {
// there’s some error, but we want to ignore ENOENT error for EV_DELETE
let orig_flags = if change.filter == libc::EVFILT_READ { r } else { w };
if!(change.data as i32 == libc::ENOENT && orig_flags & libc::EV_DELETE!= 0) {
return Err(::std::io::Error::from_raw_os_error(change.data as i32));
}
}
}
Ok(())
}
}
pub fn reregister(&self, fd: RawFd, token: Token, interests: Ready, opts: PollOpt) -> io::Result<()> {
// Just need to call register here since EV_ADD is a mod if already
// registered
self.register(fd, token, interests, opts)
}
pub fn deregister(&self, fd: RawFd) -> io::Result<()> {
unsafe {
// EV_RECEIPT is a nice way to apply changes and get back per-event results while not
// draining the actual changes.
let filter = libc::EV_DELETE | libc::EV_RECEIPT;
let mut changes = [
kevent!(fd, libc::EVFILT_READ, filter, ptr::null_mut()),
kevent!(fd, libc::EVFILT_WRITE, filter, ptr::null_mut()),
];
try!(cvt(libc::kevent(self.kq, changes.as_ptr(), changes.len() as c_int,
changes.as_mut_ptr(), changes.len() as c_int,
::std::ptr::null())).map(|_| ()));
if changes[0].data as i32 == libc::ENOENT && changes[1].data as i32 == libc::ENOENT {
return Err(::std::io::Error::from_raw_os_error(changes[0].data as i32));
}
for change in changes.iter() {
debug_assert_eq!(libc::EV_ERROR & change.flags, libc::EV_ERROR);
if change.data!= 0 && change.data as i32!= libc::ENOENT {
return Err(::std::io::Error::from_raw_os_error(changes[0].data as i32));
}
}
Ok(())
}
}
}
impl fmt::Debug for Selector {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
fmt.debug_struct("Selector")
.field("id", &self.id)
.field("kq", &self.kq)
.finish()
}
}
impl Drop for Selector {
fn drop(&mut self) {
unsafe {
let _ = libc::close(self.kq);
}
}
}
pub struct Events {
sys_events: KeventList,
events: Vec<Event>,
event_map: HashMap<Token, usize>,
}
struct KeventList(Vec<libc::kevent>);
unsafe impl Send for KeventList {}
unsafe impl Sync for KeventList {}
impl Events {
pub fn with_capacity(cap: usize) -> Events {
Events {
sys_events: KeventList(Vec::with_capacity(cap)),
events: Vec::with_capacity(cap),
event_map: HashMap::with_capacity(cap)
}
}
#[inline]
pub fn len(&self) -> usize {
self.events.len()
}
#[inline]
pub fn capacity(&self) -> usize {
self.events.capacity()
}
#[inline]
pub fn is_empty(&self) -> bool {
self.events.is_empty()
}
pub fn get(&self, idx: usize) -> Option<Event> {
self.events.get(idx).map(|e| *e)
}
fn coalesce(&mut self, awakener: Token) -> bool {
let mut ret = false;
self.events.clear();
self.event_map.clear();
for e in self.sys_events.0.iter() {
let token = Token(e.udata as usize);
let len = self.events.len();
if token == awakener {
// TODO: Should this return an error if event is an error. It
// is not critical as spurious wakeups are permitted.
ret = true;
continue;
}
let idx = *self.event_map.entry(token)
.or_insert(len);
if idx == len {
// New entry, insert the default
self.events.push(Event::new(Ready::none(), token));
}
if e.flags & libc::EV_ERROR!= 0 {
event::kind_mut(&mut self.events[idx]).insert(Ready::error());
}
if e.filter == libc::EVFILT_READ {
event::kind_mut(&mut self.events[idx]).insert(Ready::readable());
} else if e.filter == libc::EVFILT_WRITE {
| if e.flags & libc::EV_EOF!= 0 {
event::kind_mut(&mut self.events[idx]).insert(Ready::hup());
// When the read end of the socket is closed, EV_EOF is set on
// flags, and fflags contains the error if there is one.
if e.fflags!= 0 {
event::kind_mut(&mut self.events[idx]).insert(Ready::error());
}
}
}
ret
}
pub fn push_event(&mut self, event: Event) {
self.events.push(event);
}
}
impl fmt::Debug for Events {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
write!(fmt, "Events {{ len: {} }}", self.sys_events.0.len())
}
}
#[test]
fn does_not_register_rw() {
use ::deprecated::{EventLoopBuilder, Handler};
use ::unix::EventedFd;
struct Nop;
impl Handler for Nop {
type Timeout = ();
type Message = ();
}
// registering kqueue fd will fail if write is requested (On anything but some versions of OS
// X)
let kq = unsafe { libc::kqueue() };
let kqf = EventedFd(&kq);
let mut evtloop = EventLoopBuilder::new().build::<Nop>().expect("evt loop builds");
evtloop.register(&kqf, Token(1234), Ready::readable(),
PollOpt::edge() | PollOpt::oneshot()).unwrap();
}
| event::kind_mut(&mut self.events[idx]).insert(Ready::writable());
}
| conditional_block |
kqueue.rs | use std::{cmp, fmt, ptr};
use std::os::raw::c_int;
use std::os::unix::io::RawFd;
use std::collections::HashMap;
use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
use std::time::Duration;
use libc::{self, time_t};
use {io, Ready, PollOpt, Token};
use event::{self, Event};
use sys::unix::cvt;
use sys::unix::io::set_cloexec;
/// Each Selector has a globally unique(ish) ID associated with it. This ID
/// gets tracked by `TcpStream`, `TcpListener`, etc... when they are first
/// registered with the `Selector`. If a type that is previously associated with
/// a `Selector` attempts to register itself with a different `Selector`, the
/// operation will return with an error. This matches windows behavior.
static NEXT_ID: AtomicUsize = ATOMIC_USIZE_INIT;
macro_rules! kevent {
($id: expr, $filter: expr, $flags: expr, $data: expr) => {
libc::kevent {
ident: $id as ::libc::uintptr_t,
filter: $filter,
flags: $flags,
fflags: 0,
data: 0,
udata: $data as *mut _,
}
}
}
pub struct Selector {
id: usize,
kq: RawFd,
}
impl Selector {
pub fn new() -> io::Result<Selector> {
// offset by 1 to avoid choosing 0 as the id of a selector
let id = NEXT_ID.fetch_add(1, Ordering::Relaxed) + 1;
let kq = unsafe { try!(cvt(libc::kqueue())) };
drop(set_cloexec(kq));
Ok(Selector {
id: id,
kq: kq,
})
}
pub fn id(&self) -> usize {
self.id
}
pub fn select(&self, evts: &mut Events, awakener: Token, timeout: Option<Duration>) -> io::Result<bool> {
let timeout = timeout.map(|to| {
libc::timespec {
tv_sec: cmp::min(to.as_secs(), time_t::max_value() as u64) as time_t,
tv_nsec: to.subsec_nanos() as libc::c_long,
}
});
let timeout = timeout.as_ref().map(|s| s as *const _).unwrap_or(ptr::null_mut());
unsafe {
let cnt = try!(cvt(libc::kevent(self.kq,
ptr::null(),
0,
evts.sys_events.0.as_mut_ptr(),
// FIXME: needs a saturating cast here.
evts.sys_events.0.capacity() as c_int,
timeout)));
evts.sys_events.0.set_len(cnt as usize);
Ok(evts.coalesce(awakener))
}
}
pub fn register(&self, fd: RawFd, token: Token, interests: Ready, opts: PollOpt) -> io::Result<()> {
trace!("registering; token={:?}; interests={:?}", token, interests);
let flags = if opts.contains(PollOpt::edge()) { libc::EV_CLEAR } else { 0 } |
if opts.contains(PollOpt::oneshot()) { libc::EV_ONESHOT } else { 0 } |
libc::EV_RECEIPT;
unsafe {
let r = if interests.contains(Ready::readable()) { libc::EV_ADD } else { libc::EV_DELETE };
let w = if interests.contains(Ready::writable()) { libc::EV_ADD } else { libc::EV_DELETE };
let mut changes = [
kevent!(fd, libc::EVFILT_READ, flags | r, usize::from(token)),
kevent!(fd, libc::EVFILT_WRITE, flags | w, usize::from(token)),
];
try!(cvt(libc::kevent(self.kq, changes.as_ptr(), changes.len() as c_int,
changes.as_mut_ptr(), changes.len() as c_int,
::std::ptr::null())));
for change in changes.iter() {
debug_assert_eq!(change.flags & libc::EV_ERROR, libc::EV_ERROR);
if change.data!= 0 {
// there’s some error, but we want to ignore ENOENT error for EV_DELETE
let orig_flags = if change.filter == libc::EVFILT_READ { r } else { w };
if!(change.data as i32 == libc::ENOENT && orig_flags & libc::EV_DELETE!= 0) {
return Err(::std::io::Error::from_raw_os_error(change.data as i32));
}
}
}
Ok(())
}
}
pub fn reregister(&self, fd: RawFd, token: Token, interests: Ready, opts: PollOpt) -> io::Result<()> {
// Just need to call register here since EV_ADD is a mod if already
// registered
self.register(fd, token, interests, opts)
}
pub fn deregister(&self, fd: RawFd) -> io::Result<()> {
unsafe {
// EV_RECEIPT is a nice way to apply changes and get back per-event results while not
// draining the actual changes.
let filter = libc::EV_DELETE | libc::EV_RECEIPT;
let mut changes = [
kevent!(fd, libc::EVFILT_READ, filter, ptr::null_mut()),
kevent!(fd, libc::EVFILT_WRITE, filter, ptr::null_mut()),
];
try!(cvt(libc::kevent(self.kq, changes.as_ptr(), changes.len() as c_int,
changes.as_mut_ptr(), changes.len() as c_int,
::std::ptr::null())).map(|_| ()));
if changes[0].data as i32 == libc::ENOENT && changes[1].data as i32 == libc::ENOENT {
return Err(::std::io::Error::from_raw_os_error(changes[0].data as i32));
}
for change in changes.iter() {
debug_assert_eq!(libc::EV_ERROR & change.flags, libc::EV_ERROR);
if change.data!= 0 && change.data as i32!= libc::ENOENT {
return Err(::std::io::Error::from_raw_os_error(changes[0].data as i32));
}
}
Ok(())
}
}
}
impl fmt::Debug for Selector {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
fmt.debug_struct("Selector")
.field("id", &self.id)
.field("kq", &self.kq)
.finish()
}
}
impl Drop for Selector {
fn drop(&mut self) {
unsafe {
let _ = libc::close(self.kq);
}
}
}
pub struct Events {
sys_events: KeventList,
events: Vec<Event>,
event_map: HashMap<Token, usize>,
}
struct KeventList(Vec<libc::kevent>);
unsafe impl Send for KeventList {}
unsafe impl Sync for KeventList {}
impl Events {
pub fn wi | ap: usize) -> Events {
Events {
sys_events: KeventList(Vec::with_capacity(cap)),
events: Vec::with_capacity(cap),
event_map: HashMap::with_capacity(cap)
}
}
#[inline]
pub fn len(&self) -> usize {
self.events.len()
}
#[inline]
pub fn capacity(&self) -> usize {
self.events.capacity()
}
#[inline]
pub fn is_empty(&self) -> bool {
self.events.is_empty()
}
pub fn get(&self, idx: usize) -> Option<Event> {
self.events.get(idx).map(|e| *e)
}
fn coalesce(&mut self, awakener: Token) -> bool {
let mut ret = false;
self.events.clear();
self.event_map.clear();
for e in self.sys_events.0.iter() {
let token = Token(e.udata as usize);
let len = self.events.len();
if token == awakener {
// TODO: Should this return an error if event is an error. It
// is not critical as spurious wakeups are permitted.
ret = true;
continue;
}
let idx = *self.event_map.entry(token)
.or_insert(len);
if idx == len {
// New entry, insert the default
self.events.push(Event::new(Ready::none(), token));
}
if e.flags & libc::EV_ERROR!= 0 {
event::kind_mut(&mut self.events[idx]).insert(Ready::error());
}
if e.filter == libc::EVFILT_READ {
event::kind_mut(&mut self.events[idx]).insert(Ready::readable());
} else if e.filter == libc::EVFILT_WRITE {
event::kind_mut(&mut self.events[idx]).insert(Ready::writable());
}
if e.flags & libc::EV_EOF!= 0 {
event::kind_mut(&mut self.events[idx]).insert(Ready::hup());
// When the read end of the socket is closed, EV_EOF is set on
// flags, and fflags contains the error if there is one.
if e.fflags!= 0 {
event::kind_mut(&mut self.events[idx]).insert(Ready::error());
}
}
}
ret
}
pub fn push_event(&mut self, event: Event) {
self.events.push(event);
}
}
impl fmt::Debug for Events {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
write!(fmt, "Events {{ len: {} }}", self.sys_events.0.len())
}
}
#[test]
fn does_not_register_rw() {
use ::deprecated::{EventLoopBuilder, Handler};
use ::unix::EventedFd;
struct Nop;
impl Handler for Nop {
type Timeout = ();
type Message = ();
}
// registering kqueue fd will fail if write is requested (On anything but some versions of OS
// X)
let kq = unsafe { libc::kqueue() };
let kqf = EventedFd(&kq);
let mut evtloop = EventLoopBuilder::new().build::<Nop>().expect("evt loop builds");
evtloop.register(&kqf, Token(1234), Ready::readable(),
PollOpt::edge() | PollOpt::oneshot()).unwrap();
}
| th_capacity(c | identifier_name |
kqueue.rs | use std::{cmp, fmt, ptr};
use std::os::raw::c_int;
use std::os::unix::io::RawFd;
use std::collections::HashMap;
use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
use std::time::Duration;
use libc::{self, time_t};
use {io, Ready, PollOpt, Token};
use event::{self, Event};
use sys::unix::cvt;
use sys::unix::io::set_cloexec;
/// Each Selector has a globally unique(ish) ID associated with it. This ID
/// gets tracked by `TcpStream`, `TcpListener`, etc... when they are first
/// registered with the `Selector`. If a type that is previously associated with
/// a `Selector` attempts to register itself with a different `Selector`, the
/// operation will return with an error. This matches windows behavior.
static NEXT_ID: AtomicUsize = ATOMIC_USIZE_INIT;
macro_rules! kevent {
($id: expr, $filter: expr, $flags: expr, $data: expr) => {
libc::kevent {
ident: $id as ::libc::uintptr_t,
filter: $filter,
flags: $flags,
fflags: 0,
data: 0,
udata: $data as *mut _,
}
}
}
pub struct Selector {
id: usize,
kq: RawFd,
}
impl Selector {
pub fn new() -> io::Result<Selector> {
// offset by 1 to avoid choosing 0 as the id of a selector
let id = NEXT_ID.fetch_add(1, Ordering::Relaxed) + 1;
let kq = unsafe { try!(cvt(libc::kqueue())) };
drop(set_cloexec(kq));
Ok(Selector {
id: id,
kq: kq,
})
}
pub fn id(&self) -> usize {
self.id
}
pub fn select(&self, evts: &mut Events, awakener: Token, timeout: Option<Duration>) -> io::Result<bool> {
let timeout = timeout.map(|to| {
libc::timespec {
tv_sec: cmp::min(to.as_secs(), time_t::max_value() as u64) as time_t,
tv_nsec: to.subsec_nanos() as libc::c_long,
}
});
let timeout = timeout.as_ref().map(|s| s as *const _).unwrap_or(ptr::null_mut());
unsafe {
let cnt = try!(cvt(libc::kevent(self.kq,
ptr::null(),
0,
evts.sys_events.0.as_mut_ptr(),
// FIXME: needs a saturating cast here.
evts.sys_events.0.capacity() as c_int,
timeout)));
evts.sys_events.0.set_len(cnt as usize);
Ok(evts.coalesce(awakener))
}
}
pub fn register(&self, fd: RawFd, token: Token, interests: Ready, opts: PollOpt) -> io::Result<()> {
trace!("registering; token={:?}; interests={:?}", token, interests);
let flags = if opts.contains(PollOpt::edge()) { libc::EV_CLEAR } else { 0 } |
if opts.contains(PollOpt::oneshot()) { libc::EV_ONESHOT } else { 0 } |
libc::EV_RECEIPT;
unsafe {
let r = if interests.contains(Ready::readable()) { libc::EV_ADD } else { libc::EV_DELETE };
let w = if interests.contains(Ready::writable()) { libc::EV_ADD } else { libc::EV_DELETE };
let mut changes = [ | ::std::ptr::null())));
for change in changes.iter() {
debug_assert_eq!(change.flags & libc::EV_ERROR, libc::EV_ERROR);
if change.data!= 0 {
// there’s some error, but we want to ignore ENOENT error for EV_DELETE
let orig_flags = if change.filter == libc::EVFILT_READ { r } else { w };
if!(change.data as i32 == libc::ENOENT && orig_flags & libc::EV_DELETE!= 0) {
return Err(::std::io::Error::from_raw_os_error(change.data as i32));
}
}
}
Ok(())
}
}
pub fn reregister(&self, fd: RawFd, token: Token, interests: Ready, opts: PollOpt) -> io::Result<()> {
// Just need to call register here since EV_ADD is a mod if already
// registered
self.register(fd, token, interests, opts)
}
pub fn deregister(&self, fd: RawFd) -> io::Result<()> {
unsafe {
// EV_RECEIPT is a nice way to apply changes and get back per-event results while not
// draining the actual changes.
let filter = libc::EV_DELETE | libc::EV_RECEIPT;
let mut changes = [
kevent!(fd, libc::EVFILT_READ, filter, ptr::null_mut()),
kevent!(fd, libc::EVFILT_WRITE, filter, ptr::null_mut()),
];
try!(cvt(libc::kevent(self.kq, changes.as_ptr(), changes.len() as c_int,
changes.as_mut_ptr(), changes.len() as c_int,
::std::ptr::null())).map(|_| ()));
if changes[0].data as i32 == libc::ENOENT && changes[1].data as i32 == libc::ENOENT {
return Err(::std::io::Error::from_raw_os_error(changes[0].data as i32));
}
for change in changes.iter() {
debug_assert_eq!(libc::EV_ERROR & change.flags, libc::EV_ERROR);
if change.data!= 0 && change.data as i32!= libc::ENOENT {
return Err(::std::io::Error::from_raw_os_error(changes[0].data as i32));
}
}
Ok(())
}
}
}
impl fmt::Debug for Selector {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
fmt.debug_struct("Selector")
.field("id", &self.id)
.field("kq", &self.kq)
.finish()
}
}
impl Drop for Selector {
fn drop(&mut self) {
unsafe {
let _ = libc::close(self.kq);
}
}
}
pub struct Events {
sys_events: KeventList,
events: Vec<Event>,
event_map: HashMap<Token, usize>,
}
struct KeventList(Vec<libc::kevent>);
unsafe impl Send for KeventList {}
unsafe impl Sync for KeventList {}
impl Events {
pub fn with_capacity(cap: usize) -> Events {
Events {
sys_events: KeventList(Vec::with_capacity(cap)),
events: Vec::with_capacity(cap),
event_map: HashMap::with_capacity(cap)
}
}
#[inline]
pub fn len(&self) -> usize {
self.events.len()
}
#[inline]
pub fn capacity(&self) -> usize {
self.events.capacity()
}
#[inline]
pub fn is_empty(&self) -> bool {
self.events.is_empty()
}
pub fn get(&self, idx: usize) -> Option<Event> {
self.events.get(idx).map(|e| *e)
}
fn coalesce(&mut self, awakener: Token) -> bool {
let mut ret = false;
self.events.clear();
self.event_map.clear();
for e in self.sys_events.0.iter() {
let token = Token(e.udata as usize);
let len = self.events.len();
if token == awakener {
// TODO: Should this return an error if event is an error. It
// is not critical as spurious wakeups are permitted.
ret = true;
continue;
}
let idx = *self.event_map.entry(token)
.or_insert(len);
if idx == len {
// New entry, insert the default
self.events.push(Event::new(Ready::none(), token));
}
if e.flags & libc::EV_ERROR!= 0 {
event::kind_mut(&mut self.events[idx]).insert(Ready::error());
}
if e.filter == libc::EVFILT_READ {
event::kind_mut(&mut self.events[idx]).insert(Ready::readable());
} else if e.filter == libc::EVFILT_WRITE {
event::kind_mut(&mut self.events[idx]).insert(Ready::writable());
}
if e.flags & libc::EV_EOF!= 0 {
event::kind_mut(&mut self.events[idx]).insert(Ready::hup());
// When the read end of the socket is closed, EV_EOF is set on
// flags, and fflags contains the error if there is one.
if e.fflags!= 0 {
event::kind_mut(&mut self.events[idx]).insert(Ready::error());
}
}
}
ret
}
pub fn push_event(&mut self, event: Event) {
self.events.push(event);
}
}
impl fmt::Debug for Events {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
write!(fmt, "Events {{ len: {} }}", self.sys_events.0.len())
}
}
#[test]
fn does_not_register_rw() {
use ::deprecated::{EventLoopBuilder, Handler};
use ::unix::EventedFd;
struct Nop;
impl Handler for Nop {
type Timeout = ();
type Message = ();
}
// registering kqueue fd will fail if write is requested (On anything but some versions of OS
// X)
let kq = unsafe { libc::kqueue() };
let kqf = EventedFd(&kq);
let mut evtloop = EventLoopBuilder::new().build::<Nop>().expect("evt loop builds");
evtloop.register(&kqf, Token(1234), Ready::readable(),
PollOpt::edge() | PollOpt::oneshot()).unwrap();
} | kevent!(fd, libc::EVFILT_READ, flags | r, usize::from(token)),
kevent!(fd, libc::EVFILT_WRITE, flags | w, usize::from(token)),
];
try!(cvt(libc::kevent(self.kq, changes.as_ptr(), changes.len() as c_int,
changes.as_mut_ptr(), changes.len() as c_int, | random_line_split |
mod.rs | // +--------------------------------------------------------------------------+
// | Copyright 2016 Matthew D. Steele <[email protected]> |
// | |
// | This file is part of System Syzygy. |
// | |
// | System Syzygy is free software: you can redistribute it and/or modify it |
// | under the terms of the GNU General Public License as published by the |
// | Free Software Foundation, either version 3 of the License, or (at your |
// | option) any later version. |
// | |
// | System Syzygy is distributed in the hope that it will be useful, but |
// | WITHOUT ANY WARRANTY; without even the implied warranty of |
// | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
// | General Public License for details. |
// | |
// | You should have received a copy of the GNU General Public License along |
// | with System Syzygy. If not, see <http://www.gnu.org/licenses/>. |
// +--------------------------------------------------------------------------+
mod action;
mod background;
mod canvas;
mod element;
mod event;
mod font;
mod loader;
mod resources;
mod sound;
mod sprite;
mod window;
pub use self::action::Action;
pub use self::background::Background;
pub use self::canvas::{Align, Canvas};
pub use self::element::Element; | pub use self::window::Window;
pub use sdl2::rect::{Point, Rect};
pub const FRAME_DELAY_MILLIS: u32 = 40;
// ========================================================================= // | pub use self::event::{Event, KeyMod, Keycode};
pub use self::font::Font;
pub use self::resources::Resources;
pub use self::sound::Sound;
pub use self::sprite::Sprite; | random_line_split |
joiner.rs | use std::os;
use std::str;
use std::io::File;
fn main() {
let args: ~[~str] = os::args();
if args.len()!= 3 {
println!("Usage: {:s} <msg.share1> <msg.share2>", args[0]);
} else {
let share1 = args[1].clone();
let share2 = args[2].clone(); |
match (msg1_file, msg2_file) {
(Some(mut msg1), Some(mut msg2)) => {
let msg1_bytes: ~[u8] = msg1.read_to_end();
let msg2_bytes: ~[u8] = msg2.read_to_end();
let result: ~[u8] = xor(msg1_bytes, msg2_bytes);
print!("{:?}", str::from_utf8(result));
},
(None, _ ) => fail!("Error opening message file: {:s}", share1),
(_,None) => fail!("Error opening message file: {:s}", share2)
}
}
}
fn xor(a: &[u8], b: &[u8]) -> ~[u8] {
let mut ret = ~[];
for i in range(0, a.len()) {
ret.push(a[i] ^ b[i]);
}
ret
} | let path1 = Path::new(share1.clone());
let path2 = Path::new(share2.clone());
let msg1_file = File::open(&path1);
let msg2_file = File::open(&path2); | random_line_split |
joiner.rs | use std::os;
use std::str;
use std::io::File;
fn main() {
let args: ~[~str] = os::args();
if args.len()!= 3 {
println!("Usage: {:s} <msg.share1> <msg.share2>", args[0]);
} else |
}
fn xor(a: &[u8], b: &[u8]) -> ~[u8] {
let mut ret = ~[];
for i in range(0, a.len()) {
ret.push(a[i] ^ b[i]);
}
ret
}
| {
let share1 = args[1].clone();
let share2 = args[2].clone();
let path1 = Path::new(share1.clone());
let path2 = Path::new(share2.clone());
let msg1_file = File::open(&path1);
let msg2_file = File::open(&path2);
match (msg1_file, msg2_file) {
(Some(mut msg1), Some(mut msg2)) => {
let msg1_bytes: ~[u8] = msg1.read_to_end();
let msg2_bytes: ~[u8] = msg2.read_to_end();
let result: ~[u8] = xor(msg1_bytes, msg2_bytes);
print!("{:?}", str::from_utf8(result));
} ,
(None, _ ) => fail!("Error opening message file: {:s}", share1),
(_ ,None) => fail!("Error opening message file: {:s}", share2)
}
} | conditional_block |
joiner.rs | use std::os;
use std::str;
use std::io::File;
fn main() {
let args: ~[~str] = os::args();
if args.len()!= 3 {
println!("Usage: {:s} <msg.share1> <msg.share2>", args[0]);
} else {
let share1 = args[1].clone();
let share2 = args[2].clone();
let path1 = Path::new(share1.clone());
let path2 = Path::new(share2.clone());
let msg1_file = File::open(&path1);
let msg2_file = File::open(&path2);
match (msg1_file, msg2_file) {
(Some(mut msg1), Some(mut msg2)) => {
let msg1_bytes: ~[u8] = msg1.read_to_end();
let msg2_bytes: ~[u8] = msg2.read_to_end();
let result: ~[u8] = xor(msg1_bytes, msg2_bytes);
print!("{:?}", str::from_utf8(result));
},
(None, _ ) => fail!("Error opening message file: {:s}", share1),
(_,None) => fail!("Error opening message file: {:s}", share2)
}
}
}
fn | (a: &[u8], b: &[u8]) -> ~[u8] {
let mut ret = ~[];
for i in range(0, a.len()) {
ret.push(a[i] ^ b[i]);
}
ret
}
| xor | identifier_name |
joiner.rs | use std::os;
use std::str;
use std::io::File;
fn main() {
let args: ~[~str] = os::args();
if args.len()!= 3 {
println!("Usage: {:s} <msg.share1> <msg.share2>", args[0]);
} else {
let share1 = args[1].clone();
let share2 = args[2].clone();
let path1 = Path::new(share1.clone());
let path2 = Path::new(share2.clone());
let msg1_file = File::open(&path1);
let msg2_file = File::open(&path2);
match (msg1_file, msg2_file) {
(Some(mut msg1), Some(mut msg2)) => {
let msg1_bytes: ~[u8] = msg1.read_to_end();
let msg2_bytes: ~[u8] = msg2.read_to_end();
let result: ~[u8] = xor(msg1_bytes, msg2_bytes);
print!("{:?}", str::from_utf8(result));
},
(None, _ ) => fail!("Error opening message file: {:s}", share1),
(_,None) => fail!("Error opening message file: {:s}", share2)
}
}
}
fn xor(a: &[u8], b: &[u8]) -> ~[u8] | {
let mut ret = ~[];
for i in range(0, a.len()) {
ret.push(a[i] ^ b[i]);
}
ret
} | identifier_body |
|
cabi_mips.rs | // Copyright 2012-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.
#![allow(non_uppercase_pattern_statics)]
use libc::c_uint;
use std::cmp;
use llvm;
use llvm::{Integer, Pointer, Float, Double, Struct, Array};
use llvm::{StructRetAttribute, ZExtAttribute};
use middle::trans::cabi::{ArgType, FnType};
use middle::trans::context::CrateContext;
use middle::trans::type_::Type;
fn align_up_to(off: uint, a: uint) -> uint {
return (off + a - 1u) / a * a;
}
fn align(off: uint, ty: Type) -> uint {
let a = ty_align(ty);
return align_up_to(off, a);
}
fn ty_align(ty: Type) -> uint | ty_align(elt)
}
_ => fail!("ty_size: unhandled type")
}
}
fn ty_size(ty: Type) -> uint {
match ty.kind() {
Integer => {
unsafe {
((llvm::LLVMGetIntTypeWidth(ty.to_ref()) as uint) + 7) / 8
}
}
Pointer => 4,
Float => 4,
Double => 8,
Struct => {
if ty.is_packed() {
let str_tys = ty.field_types();
str_tys.iter().fold(0, |s, t| s + ty_size(*t))
} else {
let str_tys = ty.field_types();
let size = str_tys.iter().fold(0, |s, t| align(s, *t) + ty_size(*t));
align(size, ty)
}
}
Array => {
let len = ty.array_length();
let elt = ty.element_type();
let eltsz = ty_size(elt);
len * eltsz
}
_ => fail!("ty_size: unhandled type")
}
}
fn classify_ret_ty(ccx: &CrateContext, ty: Type) -> ArgType {
if is_reg_ty(ty) {
let attr = if ty == Type::i1(ccx) { Some(ZExtAttribute) } else { None };
ArgType::direct(ty, None, None, attr)
} else {
ArgType::indirect(ty, Some(StructRetAttribute))
}
}
fn classify_arg_ty(ccx: &CrateContext, ty: Type, offset: &mut uint) -> ArgType {
let orig_offset = *offset;
let size = ty_size(ty) * 8;
let mut align = ty_align(ty);
align = cmp::min(cmp::max(align, 4), 8);
*offset = align_up_to(*offset, align);
*offset += align_up_to(size, align * 8) / 8;
if is_reg_ty(ty) {
let attr = if ty == Type::i1(ccx) { Some(ZExtAttribute) } else { None };
ArgType::direct(ty, None, None, attr)
} else {
ArgType::direct(
ty,
Some(struct_ty(ccx, ty)),
padding_ty(ccx, align, orig_offset),
None
)
}
}
fn is_reg_ty(ty: Type) -> bool {
return match ty.kind() {
Integer
| Pointer
| Float
| Double => true,
_ => false
};
}
fn padding_ty(ccx: &CrateContext, align: uint, offset: uint) -> Option<Type> {
if ((align - 1 ) & offset) > 0 {
Some(Type::i32(ccx))
} else {
None
}
}
fn coerce_to_int(ccx: &CrateContext, size: uint) -> Vec<Type> {
let int_ty = Type::i32(ccx);
let mut args = Vec::new();
let mut n = size / 32;
while n > 0 {
args.push(int_ty);
n -= 1;
}
let r = size % 32;
if r > 0 {
unsafe {
args.push(Type::from_ref(llvm::LLVMIntTypeInContext(ccx.llcx, r as c_uint)));
}
}
args
}
fn struct_ty(ccx: &CrateContext, ty: Type) -> Type {
let size = ty_size(ty) * 8;
Type::struct_(ccx, coerce_to_int(ccx, size).as_slice(), false)
}
pub fn compute_abi_info(ccx: &CrateContext,
atys: &[Type],
rty: Type,
ret_def: bool) -> FnType {
let ret_ty = if ret_def {
classify_ret_ty(ccx, rty)
} else {
ArgType::direct(Type::void(ccx), None, None, None)
};
let sret = ret_ty.is_indirect();
let mut arg_tys = Vec::new();
let mut offset = if sret { 4 } else { 0 };
for aty in atys.iter() {
let ty = classify_arg_ty(ccx, *aty, &mut offset);
arg_tys.push(ty);
};
return FnType {
arg_tys: arg_tys,
ret_ty: ret_ty,
};
}
| {
match ty.kind() {
Integer => {
unsafe {
((llvm::LLVMGetIntTypeWidth(ty.to_ref()) as uint) + 7) / 8
}
}
Pointer => 4,
Float => 4,
Double => 8,
Struct => {
if ty.is_packed() {
1
} else {
let str_tys = ty.field_types();
str_tys.iter().fold(1, |a, t| cmp::max(a, ty_align(*t)))
}
}
Array => {
let elt = ty.element_type(); | identifier_body |
cabi_mips.rs | // Copyright 2012-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.
#![allow(non_uppercase_pattern_statics)]
use libc::c_uint;
use std::cmp;
use llvm;
use llvm::{Integer, Pointer, Float, Double, Struct, Array};
use llvm::{StructRetAttribute, ZExtAttribute};
use middle::trans::cabi::{ArgType, FnType};
use middle::trans::context::CrateContext;
use middle::trans::type_::Type;
fn align_up_to(off: uint, a: uint) -> uint {
return (off + a - 1u) / a * a;
}
fn align(off: uint, ty: Type) -> uint {
let a = ty_align(ty);
return align_up_to(off, a); | unsafe {
((llvm::LLVMGetIntTypeWidth(ty.to_ref()) as uint) + 7) / 8
}
}
Pointer => 4,
Float => 4,
Double => 8,
Struct => {
if ty.is_packed() {
1
} else {
let str_tys = ty.field_types();
str_tys.iter().fold(1, |a, t| cmp::max(a, ty_align(*t)))
}
}
Array => {
let elt = ty.element_type();
ty_align(elt)
}
_ => fail!("ty_size: unhandled type")
}
}
fn ty_size(ty: Type) -> uint {
match ty.kind() {
Integer => {
unsafe {
((llvm::LLVMGetIntTypeWidth(ty.to_ref()) as uint) + 7) / 8
}
}
Pointer => 4,
Float => 4,
Double => 8,
Struct => {
if ty.is_packed() {
let str_tys = ty.field_types();
str_tys.iter().fold(0, |s, t| s + ty_size(*t))
} else {
let str_tys = ty.field_types();
let size = str_tys.iter().fold(0, |s, t| align(s, *t) + ty_size(*t));
align(size, ty)
}
}
Array => {
let len = ty.array_length();
let elt = ty.element_type();
let eltsz = ty_size(elt);
len * eltsz
}
_ => fail!("ty_size: unhandled type")
}
}
fn classify_ret_ty(ccx: &CrateContext, ty: Type) -> ArgType {
if is_reg_ty(ty) {
let attr = if ty == Type::i1(ccx) { Some(ZExtAttribute) } else { None };
ArgType::direct(ty, None, None, attr)
} else {
ArgType::indirect(ty, Some(StructRetAttribute))
}
}
fn classify_arg_ty(ccx: &CrateContext, ty: Type, offset: &mut uint) -> ArgType {
let orig_offset = *offset;
let size = ty_size(ty) * 8;
let mut align = ty_align(ty);
align = cmp::min(cmp::max(align, 4), 8);
*offset = align_up_to(*offset, align);
*offset += align_up_to(size, align * 8) / 8;
if is_reg_ty(ty) {
let attr = if ty == Type::i1(ccx) { Some(ZExtAttribute) } else { None };
ArgType::direct(ty, None, None, attr)
} else {
ArgType::direct(
ty,
Some(struct_ty(ccx, ty)),
padding_ty(ccx, align, orig_offset),
None
)
}
}
fn is_reg_ty(ty: Type) -> bool {
return match ty.kind() {
Integer
| Pointer
| Float
| Double => true,
_ => false
};
}
fn padding_ty(ccx: &CrateContext, align: uint, offset: uint) -> Option<Type> {
if ((align - 1 ) & offset) > 0 {
Some(Type::i32(ccx))
} else {
None
}
}
fn coerce_to_int(ccx: &CrateContext, size: uint) -> Vec<Type> {
let int_ty = Type::i32(ccx);
let mut args = Vec::new();
let mut n = size / 32;
while n > 0 {
args.push(int_ty);
n -= 1;
}
let r = size % 32;
if r > 0 {
unsafe {
args.push(Type::from_ref(llvm::LLVMIntTypeInContext(ccx.llcx, r as c_uint)));
}
}
args
}
fn struct_ty(ccx: &CrateContext, ty: Type) -> Type {
let size = ty_size(ty) * 8;
Type::struct_(ccx, coerce_to_int(ccx, size).as_slice(), false)
}
pub fn compute_abi_info(ccx: &CrateContext,
atys: &[Type],
rty: Type,
ret_def: bool) -> FnType {
let ret_ty = if ret_def {
classify_ret_ty(ccx, rty)
} else {
ArgType::direct(Type::void(ccx), None, None, None)
};
let sret = ret_ty.is_indirect();
let mut arg_tys = Vec::new();
let mut offset = if sret { 4 } else { 0 };
for aty in atys.iter() {
let ty = classify_arg_ty(ccx, *aty, &mut offset);
arg_tys.push(ty);
};
return FnType {
arg_tys: arg_tys,
ret_ty: ret_ty,
};
} | }
fn ty_align(ty: Type) -> uint {
match ty.kind() {
Integer => { | random_line_split |
cabi_mips.rs | // Copyright 2012-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.
#![allow(non_uppercase_pattern_statics)]
use libc::c_uint;
use std::cmp;
use llvm;
use llvm::{Integer, Pointer, Float, Double, Struct, Array};
use llvm::{StructRetAttribute, ZExtAttribute};
use middle::trans::cabi::{ArgType, FnType};
use middle::trans::context::CrateContext;
use middle::trans::type_::Type;
fn align_up_to(off: uint, a: uint) -> uint {
return (off + a - 1u) / a * a;
}
fn align(off: uint, ty: Type) -> uint {
let a = ty_align(ty);
return align_up_to(off, a);
}
fn ty_align(ty: Type) -> uint {
match ty.kind() {
Integer => {
unsafe {
((llvm::LLVMGetIntTypeWidth(ty.to_ref()) as uint) + 7) / 8
}
}
Pointer => 4,
Float => 4,
Double => 8,
Struct => {
if ty.is_packed() {
1
} else {
let str_tys = ty.field_types();
str_tys.iter().fold(1, |a, t| cmp::max(a, ty_align(*t)))
}
}
Array => {
let elt = ty.element_type();
ty_align(elt)
}
_ => fail!("ty_size: unhandled type")
}
}
fn ty_size(ty: Type) -> uint {
match ty.kind() {
Integer => {
unsafe {
((llvm::LLVMGetIntTypeWidth(ty.to_ref()) as uint) + 7) / 8
}
}
Pointer => 4,
Float => 4,
Double => 8,
Struct => {
if ty.is_packed() {
let str_tys = ty.field_types();
str_tys.iter().fold(0, |s, t| s + ty_size(*t))
} else {
let str_tys = ty.field_types();
let size = str_tys.iter().fold(0, |s, t| align(s, *t) + ty_size(*t));
align(size, ty)
}
}
Array => {
let len = ty.array_length();
let elt = ty.element_type();
let eltsz = ty_size(elt);
len * eltsz
}
_ => fail!("ty_size: unhandled type")
}
}
fn classify_ret_ty(ccx: &CrateContext, ty: Type) -> ArgType {
if is_reg_ty(ty) {
let attr = if ty == Type::i1(ccx) { Some(ZExtAttribute) } else { None };
ArgType::direct(ty, None, None, attr)
} else {
ArgType::indirect(ty, Some(StructRetAttribute))
}
}
fn classify_arg_ty(ccx: &CrateContext, ty: Type, offset: &mut uint) -> ArgType {
let orig_offset = *offset;
let size = ty_size(ty) * 8;
let mut align = ty_align(ty);
align = cmp::min(cmp::max(align, 4), 8);
*offset = align_up_to(*offset, align);
*offset += align_up_to(size, align * 8) / 8;
if is_reg_ty(ty) {
let attr = if ty == Type::i1(ccx) { Some(ZExtAttribute) } else { None };
ArgType::direct(ty, None, None, attr)
} else {
ArgType::direct(
ty,
Some(struct_ty(ccx, ty)),
padding_ty(ccx, align, orig_offset),
None
)
}
}
fn is_reg_ty(ty: Type) -> bool {
return match ty.kind() {
Integer
| Pointer
| Float
| Double => true,
_ => false
};
}
fn padding_ty(ccx: &CrateContext, align: uint, offset: uint) -> Option<Type> {
if ((align - 1 ) & offset) > 0 {
Some(Type::i32(ccx))
} else {
None
}
}
fn coerce_to_int(ccx: &CrateContext, size: uint) -> Vec<Type> {
let int_ty = Type::i32(ccx);
let mut args = Vec::new();
let mut n = size / 32;
while n > 0 {
args.push(int_ty);
n -= 1;
}
let r = size % 32;
if r > 0 {
unsafe {
args.push(Type::from_ref(llvm::LLVMIntTypeInContext(ccx.llcx, r as c_uint)));
}
}
args
}
fn | (ccx: &CrateContext, ty: Type) -> Type {
let size = ty_size(ty) * 8;
Type::struct_(ccx, coerce_to_int(ccx, size).as_slice(), false)
}
pub fn compute_abi_info(ccx: &CrateContext,
atys: &[Type],
rty: Type,
ret_def: bool) -> FnType {
let ret_ty = if ret_def {
classify_ret_ty(ccx, rty)
} else {
ArgType::direct(Type::void(ccx), None, None, None)
};
let sret = ret_ty.is_indirect();
let mut arg_tys = Vec::new();
let mut offset = if sret { 4 } else { 0 };
for aty in atys.iter() {
let ty = classify_arg_ty(ccx, *aty, &mut offset);
arg_tys.push(ty);
};
return FnType {
arg_tys: arg_tys,
ret_ty: ret_ty,
};
}
| struct_ty | identifier_name |
part14.rs | // Rust-101, Part 14: Slices, Arrays, External Dependencies
// ========================================================
// ## Slices
pub fn sort<T: PartialOrd>(data: &mut [T]) {
if data.len() < 2 { return; }
// We decide that the element at 0 is our pivot, and then we move our cursors through the rest of the slice,
// making sure that everything on the left is no larger than the pivot, and everything on the right is no smaller.
let mut lpos = 1;
let mut rpos = data.len();
/* Invariant: pivot is data[0]; everything with index (0,lpos) is <= pivot;
[rpos,len) is >= pivot; lpos < rpos */
loop {
// **Exercise 14.1**: Complete this Quicksort loop. You can use `swap` on slices to swap two elements. Write a
// test function for `sort`.
unimplemented!()
}
// Once our cursors met, we need to put the pivot in the right place.
data.swap(0, lpos-1);
// Finally, we split our slice to sort the two halves. The nice part about slices is that splitting them is cheap:
let (part1, part2) = data.split_at_mut(lpos);
unimplemented!()
}
// **Exercise 14.2**: Since `String` implements `PartialEq`, you can now change the function `output_lines` in the previous part
// to call the sort function above. If you did exercise 13.1, you will have slightly more work. Make sure you sort by the matched line
// only, not by filename or line number!
// Now, we can sort, e.g., an vector of numbers.
fn sort_nums(data: &mut Vec<i32>) {
sort(&mut data[..]);
}
// ## Arrays
fn sort_array() {
let mut array_of_data: [f64; 5] = [1.0, 3.4, 12.7, -9.12, 0.1];
sort(&mut array_of_data);
}
// ## External Dependencies
// I disabled the following module (using a rather bad hack), because it only compiles if `docopt` is linked.
// Remove the attribute of the `rgrep` module to enable compilation.
#[cfg(feature = "disabled")]
pub mod rgrep {
// Now that `docopt` is linked, we can first add it to the namespace with `extern crate` and then import shorter names with `use`.
// We also import some other pieces that we will need.
extern crate docopt;
use self::docopt::Docopt;
use part13::{run, Options, OutputMode};
use std::process;
// The `USAGE` string documents how the program is to be called. It's written in a format that `docopt` can parse.
static USAGE: &'static str = "
Usage: rgrep [-c] [-s] <pattern> <file>...
Options:
-c, --count Count number of matching lines (rather than printing them).
-s, --sort Sort the lines before printing.
";
// This function extracts the rgrep options from the command-line arguments.
fn get_options() -> Options {
// This parses `argv` and exit the program with an error message if it fails. The code is taken from the [`docopt` documentation](http://burntsushi.net/rustdoc/docopt/). <br/>
let args = Docopt::new(USAGE).and_then(|d| d.parse()).unwrap_or_else(|e| e.exit());
// Now we can get all the values out.
let count = args.get_bool("-c");
let sort = args.get_bool("-s");
let pattern = args.get_str("<pattern>");
let files = args.get_vec("<file>");
if count && sort {
println!("Setting both '-c' and '-s' at the same time does not make any sense.");
process::exit(1);
}
// We need to make the strings owned to construct the `Options` instance.
let mode = if count {
OutputMode::Count
} else if sort | else {
OutputMode::Print
};
Options {
files: files.iter().map(|file| file.to_string()).collect(),
pattern: pattern.to_string(),
output_mode: mode,
}
}
// Finally, we can call the `run` function from the previous part on the options extracted using `get_options`. Edit `main.rs` to call this function.
// You can now use `cargo run -- <pattern> <files>` to call your program, and see the argument parser and the threads we wrote previously in action!
pub fn main() {
unimplemented!()
}
}
// **Exercise 14.3**: Wouldn't it be nice if rgrep supported regular expressions? There's already a crate that does all the parsing and matching on regular
// expression, it's called [regex](https://crates.io/crates/regex). Add this crate to the dependencies of your workspace, add an option ("-r") to switch
// the pattern to regular-expression mode, and change `filter_lines` to honor this option. The documentation of regex is available from its crates.io site.
// (You won't be able to use the `regex!` macro if you are on the stable or beta channel of Rust. But it wouldn't help for our use-case anyway.)
| {
OutputMode::SortAndPrint
} | conditional_block |
part14.rs | // Rust-101, Part 14: Slices, Arrays, External Dependencies
// ========================================================
// ## Slices
pub fn sort<T: PartialOrd>(data: &mut [T]) {
if data.len() < 2 { return; }
// We decide that the element at 0 is our pivot, and then we move our cursors through the rest of the slice,
// making sure that everything on the left is no larger than the pivot, and everything on the right is no smaller.
let mut lpos = 1;
let mut rpos = data.len();
/* Invariant: pivot is data[0]; everything with index (0,lpos) is <= pivot;
[rpos,len) is >= pivot; lpos < rpos */
loop {
// **Exercise 14.1**: Complete this Quicksort loop. You can use `swap` on slices to swap two elements. Write a
// test function for `sort`.
unimplemented!()
}
// Once our cursors met, we need to put the pivot in the right place.
data.swap(0, lpos-1);
// Finally, we split our slice to sort the two halves. The nice part about slices is that splitting them is cheap:
let (part1, part2) = data.split_at_mut(lpos);
unimplemented!()
}
// **Exercise 14.2**: Since `String` implements `PartialEq`, you can now change the function `output_lines` in the previous part
// to call the sort function above. If you did exercise 13.1, you will have slightly more work. Make sure you sort by the matched line
// only, not by filename or line number!
// Now, we can sort, e.g., an vector of numbers.
fn sort_nums(data: &mut Vec<i32>) {
sort(&mut data[..]);
}
// ## Arrays
fn sort_array() {
let mut array_of_data: [f64; 5] = [1.0, 3.4, 12.7, -9.12, 0.1];
sort(&mut array_of_data);
}
// ## External Dependencies
// I disabled the following module (using a rather bad hack), because it only compiles if `docopt` is linked.
// Remove the attribute of the `rgrep` module to enable compilation.
#[cfg(feature = "disabled")]
pub mod rgrep {
// Now that `docopt` is linked, we can first add it to the namespace with `extern crate` and then import shorter names with `use`.
// We also import some other pieces that we will need.
extern crate docopt;
use self::docopt::Docopt;
use part13::{run, Options, OutputMode};
use std::process;
// The `USAGE` string documents how the program is to be called. It's written in a format that `docopt` can parse.
static USAGE: &'static str = "
Usage: rgrep [-c] [-s] <pattern> <file>...
Options:
-c, --count Count number of matching lines (rather than printing them).
-s, --sort Sort the lines before printing.
";
// This function extracts the rgrep options from the command-line arguments.
fn get_options() -> Options {
// This parses `argv` and exit the program with an error message if it fails. The code is taken from the [`docopt` documentation](http://burntsushi.net/rustdoc/docopt/). <br/>
let args = Docopt::new(USAGE).and_then(|d| d.parse()).unwrap_or_else(|e| e.exit());
// Now we can get all the values out.
let count = args.get_bool("-c");
let sort = args.get_bool("-s");
let pattern = args.get_str("<pattern>");
let files = args.get_vec("<file>");
if count && sort {
println!("Setting both '-c' and '-s' at the same time does not make any sense.");
process::exit(1);
}
// We need to make the strings owned to construct the `Options` instance.
let mode = if count {
OutputMode::Count
} else if sort {
OutputMode::SortAndPrint
} else {
OutputMode::Print
};
Options {
files: files.iter().map(|file| file.to_string()).collect(),
pattern: pattern.to_string(),
output_mode: mode,
}
}
// Finally, we can call the `run` function from the previous part on the options extracted using `get_options`. Edit `main.rs` to call this function.
// You can now use `cargo run -- <pattern> <files>` to call your program, and see the argument parser and the threads we wrote previously in action!
pub fn main() |
}
// **Exercise 14.3**: Wouldn't it be nice if rgrep supported regular expressions? There's already a crate that does all the parsing and matching on regular
// expression, it's called [regex](https://crates.io/crates/regex). Add this crate to the dependencies of your workspace, add an option ("-r") to switch
// the pattern to regular-expression mode, and change `filter_lines` to honor this option. The documentation of regex is available from its crates.io site.
// (You won't be able to use the `regex!` macro if you are on the stable or beta channel of Rust. But it wouldn't help for our use-case anyway.)
| {
unimplemented!()
} | identifier_body |
part14.rs | // Rust-101, Part 14: Slices, Arrays, External Dependencies
// ========================================================
// ## Slices
pub fn sort<T: PartialOrd>(data: &mut [T]) {
if data.len() < 2 { return; }
// We decide that the element at 0 is our pivot, and then we move our cursors through the rest of the slice,
// making sure that everything on the left is no larger than the pivot, and everything on the right is no smaller.
let mut lpos = 1;
let mut rpos = data.len();
/* Invariant: pivot is data[0]; everything with index (0,lpos) is <= pivot;
[rpos,len) is >= pivot; lpos < rpos */
loop {
// **Exercise 14.1**: Complete this Quicksort loop. You can use `swap` on slices to swap two elements. Write a
// test function for `sort`.
unimplemented!()
}
// Once our cursors met, we need to put the pivot in the right place.
data.swap(0, lpos-1);
// Finally, we split our slice to sort the two halves. The nice part about slices is that splitting them is cheap:
let (part1, part2) = data.split_at_mut(lpos);
unimplemented!()
}
// **Exercise 14.2**: Since `String` implements `PartialEq`, you can now change the function `output_lines` in the previous part
// to call the sort function above. If you did exercise 13.1, you will have slightly more work. Make sure you sort by the matched line
// only, not by filename or line number!
// Now, we can sort, e.g., an vector of numbers.
fn sort_nums(data: &mut Vec<i32>) {
sort(&mut data[..]);
}
// ## Arrays
fn sort_array() {
let mut array_of_data: [f64; 5] = [1.0, 3.4, 12.7, -9.12, 0.1];
sort(&mut array_of_data);
}
// ## External Dependencies
// I disabled the following module (using a rather bad hack), because it only compiles if `docopt` is linked.
// Remove the attribute of the `rgrep` module to enable compilation.
#[cfg(feature = "disabled")]
pub mod rgrep {
// Now that `docopt` is linked, we can first add it to the namespace with `extern crate` and then import shorter names with `use`.
// We also import some other pieces that we will need.
extern crate docopt;
use self::docopt::Docopt;
use part13::{run, Options, OutputMode};
use std::process;
// The `USAGE` string documents how the program is to be called. It's written in a format that `docopt` can parse.
static USAGE: &'static str = "
Usage: rgrep [-c] [-s] <pattern> <file>...
Options:
-c, --count Count number of matching lines (rather than printing them).
-s, --sort Sort the lines before printing.
";
// This function extracts the rgrep options from the command-line arguments.
fn get_options() -> Options {
// This parses `argv` and exit the program with an error message if it fails. The code is taken from the [`docopt` documentation](http://burntsushi.net/rustdoc/docopt/). <br/>
let args = Docopt::new(USAGE).and_then(|d| d.parse()).unwrap_or_else(|e| e.exit());
// Now we can get all the values out.
let count = args.get_bool("-c");
let sort = args.get_bool("-s");
let pattern = args.get_str("<pattern>");
let files = args.get_vec("<file>");
if count && sort {
println!("Setting both '-c' and '-s' at the same time does not make any sense.");
process::exit(1);
}
| let mode = if count {
OutputMode::Count
} else if sort {
OutputMode::SortAndPrint
} else {
OutputMode::Print
};
Options {
files: files.iter().map(|file| file.to_string()).collect(),
pattern: pattern.to_string(),
output_mode: mode,
}
}
// Finally, we can call the `run` function from the previous part on the options extracted using `get_options`. Edit `main.rs` to call this function.
// You can now use `cargo run -- <pattern> <files>` to call your program, and see the argument parser and the threads we wrote previously in action!
pub fn main() {
unimplemented!()
}
}
// **Exercise 14.3**: Wouldn't it be nice if rgrep supported regular expressions? There's already a crate that does all the parsing and matching on regular
// expression, it's called [regex](https://crates.io/crates/regex). Add this crate to the dependencies of your workspace, add an option ("-r") to switch
// the pattern to regular-expression mode, and change `filter_lines` to honor this option. The documentation of regex is available from its crates.io site.
// (You won't be able to use the `regex!` macro if you are on the stable or beta channel of Rust. But it wouldn't help for our use-case anyway.) | // We need to make the strings owned to construct the `Options` instance. | random_line_split |
part14.rs | // Rust-101, Part 14: Slices, Arrays, External Dependencies
// ========================================================
// ## Slices
pub fn sort<T: PartialOrd>(data: &mut [T]) {
if data.len() < 2 { return; }
// We decide that the element at 0 is our pivot, and then we move our cursors through the rest of the slice,
// making sure that everything on the left is no larger than the pivot, and everything on the right is no smaller.
let mut lpos = 1;
let mut rpos = data.len();
/* Invariant: pivot is data[0]; everything with index (0,lpos) is <= pivot;
[rpos,len) is >= pivot; lpos < rpos */
loop {
// **Exercise 14.1**: Complete this Quicksort loop. You can use `swap` on slices to swap two elements. Write a
// test function for `sort`.
unimplemented!()
}
// Once our cursors met, we need to put the pivot in the right place.
data.swap(0, lpos-1);
// Finally, we split our slice to sort the two halves. The nice part about slices is that splitting them is cheap:
let (part1, part2) = data.split_at_mut(lpos);
unimplemented!()
}
// **Exercise 14.2**: Since `String` implements `PartialEq`, you can now change the function `output_lines` in the previous part
// to call the sort function above. If you did exercise 13.1, you will have slightly more work. Make sure you sort by the matched line
// only, not by filename or line number!
// Now, we can sort, e.g., an vector of numbers.
fn sort_nums(data: &mut Vec<i32>) {
sort(&mut data[..]);
}
// ## Arrays
fn | () {
let mut array_of_data: [f64; 5] = [1.0, 3.4, 12.7, -9.12, 0.1];
sort(&mut array_of_data);
}
// ## External Dependencies
// I disabled the following module (using a rather bad hack), because it only compiles if `docopt` is linked.
// Remove the attribute of the `rgrep` module to enable compilation.
#[cfg(feature = "disabled")]
pub mod rgrep {
// Now that `docopt` is linked, we can first add it to the namespace with `extern crate` and then import shorter names with `use`.
// We also import some other pieces that we will need.
extern crate docopt;
use self::docopt::Docopt;
use part13::{run, Options, OutputMode};
use std::process;
// The `USAGE` string documents how the program is to be called. It's written in a format that `docopt` can parse.
static USAGE: &'static str = "
Usage: rgrep [-c] [-s] <pattern> <file>...
Options:
-c, --count Count number of matching lines (rather than printing them).
-s, --sort Sort the lines before printing.
";
// This function extracts the rgrep options from the command-line arguments.
fn get_options() -> Options {
// This parses `argv` and exit the program with an error message if it fails. The code is taken from the [`docopt` documentation](http://burntsushi.net/rustdoc/docopt/). <br/>
let args = Docopt::new(USAGE).and_then(|d| d.parse()).unwrap_or_else(|e| e.exit());
// Now we can get all the values out.
let count = args.get_bool("-c");
let sort = args.get_bool("-s");
let pattern = args.get_str("<pattern>");
let files = args.get_vec("<file>");
if count && sort {
println!("Setting both '-c' and '-s' at the same time does not make any sense.");
process::exit(1);
}
// We need to make the strings owned to construct the `Options` instance.
let mode = if count {
OutputMode::Count
} else if sort {
OutputMode::SortAndPrint
} else {
OutputMode::Print
};
Options {
files: files.iter().map(|file| file.to_string()).collect(),
pattern: pattern.to_string(),
output_mode: mode,
}
}
// Finally, we can call the `run` function from the previous part on the options extracted using `get_options`. Edit `main.rs` to call this function.
// You can now use `cargo run -- <pattern> <files>` to call your program, and see the argument parser and the threads we wrote previously in action!
pub fn main() {
unimplemented!()
}
}
// **Exercise 14.3**: Wouldn't it be nice if rgrep supported regular expressions? There's already a crate that does all the parsing and matching on regular
// expression, it's called [regex](https://crates.io/crates/regex). Add this crate to the dependencies of your workspace, add an option ("-r") to switch
// the pattern to regular-expression mode, and change `filter_lines` to honor this option. The documentation of regex is available from its crates.io site.
// (You won't be able to use the `regex!` macro if you are on the stable or beta channel of Rust. But it wouldn't help for our use-case anyway.)
| sort_array | identifier_name |
regions-trait-1.rs | // 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.
#![feature(box_syntax)]
struct ctxt { v: uint }
trait get_ctxt {
// Here the `&` is bound in the method definition:
fn get_ctxt(&self) -> &ctxt;
}
struct | <'a> { c: &'a ctxt }
impl<'a> get_ctxt for has_ctxt<'a> {
// Here an error occurs because we used `&self` but
// the definition used `&`:
fn get_ctxt(&self) -> &'a ctxt { //~ ERROR method `get_ctxt` has an incompatible type
self.c
}
}
fn get_v(gc: Box<get_ctxt>) -> uint {
gc.get_ctxt().v
}
fn main() {
let ctxt = ctxt { v: 22u };
let hc = has_ctxt { c: &ctxt };
assert_eq!(get_v(box hc as Box<get_ctxt>), 22u);
}
| has_ctxt | identifier_name |
regions-trait-1.rs | // 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.
#![feature(box_syntax)]
struct ctxt { v: uint }
trait get_ctxt {
// Here the `&` is bound in the method definition:
fn get_ctxt(&self) -> &ctxt;
}
struct has_ctxt<'a> { c: &'a ctxt }
impl<'a> get_ctxt for has_ctxt<'a> {
// Here an error occurs because we used `&self` but
// the definition used `&`: |
}
fn get_v(gc: Box<get_ctxt>) -> uint {
gc.get_ctxt().v
}
fn main() {
let ctxt = ctxt { v: 22u };
let hc = has_ctxt { c: &ctxt };
assert_eq!(get_v(box hc as Box<get_ctxt>), 22u);
} | fn get_ctxt(&self) -> &'a ctxt { //~ ERROR method `get_ctxt` has an incompatible type
self.c
} | random_line_split |
filesearch.rs | // 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.
#![allow(non_camel_case_types)]
pub use self::FileMatch::*;
use std::collections::HashSet;
use std::io::fs::PathExtensions;
use std::io::fs;
use std::os;
use util::fs as myfs;
use session::search_paths::{SearchPaths, PathKind};
#[derive(Copy)]
pub enum FileMatch {
FileMatches,
FileDoesntMatch,
}
// A module for searching for libraries
// FIXME (#2658): I'm not happy how this module turned out. Should
// probably just be folded into cstore.
pub struct FileSearch<'a> {
pub sysroot: &'a Path,
pub search_paths: &'a SearchPaths,
pub triple: &'a str,
pub kind: PathKind,
}
impl<'a> FileSearch<'a> {
pub fn for_each_lib_search_path<F>(&self, mut f: F) where
F: FnMut(&Path) -> FileMatch,
{
let mut visited_dirs = HashSet::new();
let mut found = false;
for path in self.search_paths.iter(self.kind) {
match f(path) {
FileMatches => found = true,
FileDoesntMatch => ()
}
visited_dirs.insert(path.as_vec().to_vec());
}
debug!("filesearch: searching lib path");
let tlib_path = make_target_lib_path(self.sysroot,
self.triple);
if!visited_dirs.contains(tlib_path.as_vec()) {
match f(&tlib_path) {
FileMatches => found = true,
FileDoesntMatch => ()
}
}
visited_dirs.insert(tlib_path.as_vec().to_vec());
// Try RUST_PATH
if!found {
let rustpath = rust_path();
for path in rustpath.iter() {
let tlib_path = make_rustpkg_lib_path(
self.sysroot, path, self.triple);
debug!("is {} in visited_dirs? {}", tlib_path.display(),
visited_dirs.contains(&tlib_path.as_vec().to_vec()));
if!visited_dirs.contains(tlib_path.as_vec()) {
visited_dirs.insert(tlib_path.as_vec().to_vec());
// Don't keep searching the RUST_PATH if one match turns up --
// if we did, we'd get a "multiple matching crates" error
match f(&tlib_path) {
FileMatches => {
break;
}
FileDoesntMatch => ()
}
}
}
}
}
pub fn get_lib_path(&self) -> Path {
make_target_lib_path(self.sysroot, self.triple)
}
pub fn search<F>(&self, mut pick: F) where F: FnMut(&Path) -> FileMatch {
self.for_each_lib_search_path(|lib_search_path| {
debug!("searching {}", lib_search_path.display());
match fs::readdir(lib_search_path) {
Ok(files) => {
let mut rslt = FileDoesntMatch;
fn is_rlib(p: & &Path) -> bool {
p.extension_str() == Some("rlib")
}
// Reading metadata out of rlibs is faster, and if we find both
// an rlib and a dylib we only read one of the files of
// metadata, so in the name of speed, bring all rlib files to
// the front of the search list.
let files1 = files.iter().filter(|p| is_rlib(p));
let files2 = files.iter().filter(|p|!is_rlib(p));
for path in files1.chain(files2) {
debug!("testing {}", path.display());
let maybe_picked = pick(path);
match maybe_picked {
FileMatches => {
debug!("picked {}", path.display()); | FileDoesntMatch => {
debug!("rejected {}", path.display());
}
}
}
rslt
}
Err(..) => FileDoesntMatch,
}
});
}
pub fn new(sysroot: &'a Path,
triple: &'a str,
search_paths: &'a SearchPaths,
kind: PathKind) -> FileSearch<'a> {
debug!("using sysroot = {}, triple = {}", sysroot.display(), triple);
FileSearch {
sysroot: sysroot,
search_paths: search_paths,
triple: triple,
kind: kind,
}
}
// Returns a list of directories where target-specific dylibs might be located.
pub fn get_dylib_search_paths(&self) -> Vec<Path> {
let mut paths = Vec::new();
self.for_each_lib_search_path(|lib_search_path| {
paths.push(lib_search_path.clone());
FileDoesntMatch
});
paths
}
// Returns a list of directories where target-specific tool binaries are located.
pub fn get_tools_search_paths(&self) -> Vec<Path> {
let mut p = Path::new(self.sysroot);
p.push(find_libdir(self.sysroot));
p.push(rustlibdir());
p.push(self.triple);
p.push("bin");
vec![p]
}
}
pub fn relative_target_lib_path(sysroot: &Path, target_triple: &str) -> Path {
let mut p = Path::new(find_libdir(sysroot));
assert!(p.is_relative());
p.push(rustlibdir());
p.push(target_triple);
p.push("lib");
p
}
fn make_target_lib_path(sysroot: &Path,
target_triple: &str) -> Path {
sysroot.join(&relative_target_lib_path(sysroot, target_triple))
}
fn make_rustpkg_lib_path(sysroot: &Path,
dir: &Path,
triple: &str) -> Path {
let mut p = dir.join(find_libdir(sysroot));
p.push(triple);
p
}
pub fn get_or_default_sysroot() -> Path {
// Follow symlinks. If the resolved path is relative, make it absolute.
fn canonicalize(path: Option<Path>) -> Option<Path> {
path.and_then(|path|
match myfs::realpath(&path) {
Ok(canon) => Some(canon),
Err(e) => panic!("failed to get realpath: {}", e),
})
}
match canonicalize(os::self_exe_name()) {
Some(mut p) => { p.pop(); p.pop(); p }
None => panic!("can't determine value for sysroot")
}
}
#[cfg(windows)]
static PATH_ENTRY_SEPARATOR: &'static str = ";";
#[cfg(not(windows))]
static PATH_ENTRY_SEPARATOR: &'static str = ":";
/// Returns RUST_PATH as a string, without default paths added
pub fn get_rust_path() -> Option<String> {
os::getenv("RUST_PATH").map(|x| x.to_string())
}
/// Returns the value of RUST_PATH, as a list
/// of Paths. Includes default entries for, if they exist:
/// $HOME/.rust
/// DIR/.rust for any DIR that's the current working directory
/// or an ancestor of it
pub fn rust_path() -> Vec<Path> {
let mut env_rust_path: Vec<Path> = match get_rust_path() {
Some(env_path) => {
let env_path_components =
env_path.split_str(PATH_ENTRY_SEPARATOR);
env_path_components.map(|s| Path::new(s)).collect()
}
None => Vec::new()
};
let mut cwd = os::getcwd().unwrap();
// now add in default entries
let cwd_dot_rust = cwd.join(".rust");
if!env_rust_path.contains(&cwd_dot_rust) {
env_rust_path.push(cwd_dot_rust);
}
if!env_rust_path.contains(&cwd) {
env_rust_path.push(cwd.clone());
}
loop {
if { let f = cwd.filename(); f.is_none() || f.unwrap() == b".." } {
break
}
cwd.set_filename(".rust");
if!env_rust_path.contains(&cwd) && cwd.exists() {
env_rust_path.push(cwd.clone());
}
cwd.pop();
}
let h = os::homedir();
for h in h.iter() {
let p = h.join(".rust");
if!env_rust_path.contains(&p) && p.exists() {
env_rust_path.push(p);
}
}
env_rust_path
}
// The name of the directory rustc expects libraries to be located.
// On Unix should be "lib", on windows "bin"
#[cfg(unix)]
fn find_libdir(sysroot: &Path) -> String {
// FIXME: This is a quick hack to make the rustc binary able to locate
// Rust libraries in Linux environments where libraries might be installed
// to lib64/lib32. This would be more foolproof by basing the sysroot off
// of the directory where librustc is located, rather than where the rustc
// binary is.
//If --libdir is set during configuration to the value other than
// "lib" (i.e. non-default), this value is used (see issue #16552).
match option_env!("CFG_LIBDIR_RELATIVE") {
Some(libdir) if libdir!= "lib" => return libdir.to_string(),
_ => if sysroot.join(primary_libdir_name()).join(rustlibdir()).exists() {
return primary_libdir_name();
} else {
return secondary_libdir_name();
}
}
#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))]
fn primary_libdir_name() -> String {
"lib64".to_string()
}
#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))]
fn primary_libdir_name() -> String {
"lib32".to_string()
}
fn secondary_libdir_name() -> String {
"lib".to_string()
}
}
#[cfg(windows)]
fn find_libdir(_sysroot: &Path) -> String {
"bin".to_string()
}
// The name of rustc's own place to organize libraries.
// Used to be "rustc", now the default is "rustlib"
pub fn rustlibdir() -> String {
"rustlib".to_string()
} | rslt = FileMatches;
} | random_line_split |
filesearch.rs | // 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.
#![allow(non_camel_case_types)]
pub use self::FileMatch::*;
use std::collections::HashSet;
use std::io::fs::PathExtensions;
use std::io::fs;
use std::os;
use util::fs as myfs;
use session::search_paths::{SearchPaths, PathKind};
#[derive(Copy)]
pub enum FileMatch {
FileMatches,
FileDoesntMatch,
}
// A module for searching for libraries
// FIXME (#2658): I'm not happy how this module turned out. Should
// probably just be folded into cstore.
pub struct FileSearch<'a> {
pub sysroot: &'a Path,
pub search_paths: &'a SearchPaths,
pub triple: &'a str,
pub kind: PathKind,
}
impl<'a> FileSearch<'a> {
pub fn for_each_lib_search_path<F>(&self, mut f: F) where
F: FnMut(&Path) -> FileMatch,
| }
visited_dirs.insert(tlib_path.as_vec().to_vec());
// Try RUST_PATH
if!found {
let rustpath = rust_path();
for path in rustpath.iter() {
let tlib_path = make_rustpkg_lib_path(
self.sysroot, path, self.triple);
debug!("is {} in visited_dirs? {}", tlib_path.display(),
visited_dirs.contains(&tlib_path.as_vec().to_vec()));
if!visited_dirs.contains(tlib_path.as_vec()) {
visited_dirs.insert(tlib_path.as_vec().to_vec());
// Don't keep searching the RUST_PATH if one match turns up --
// if we did, we'd get a "multiple matching crates" error
match f(&tlib_path) {
FileMatches => {
break;
}
FileDoesntMatch => ()
}
}
}
}
}
pub fn get_lib_path(&self) -> Path {
make_target_lib_path(self.sysroot, self.triple)
}
pub fn search<F>(&self, mut pick: F) where F: FnMut(&Path) -> FileMatch {
self.for_each_lib_search_path(|lib_search_path| {
debug!("searching {}", lib_search_path.display());
match fs::readdir(lib_search_path) {
Ok(files) => {
let mut rslt = FileDoesntMatch;
fn is_rlib(p: & &Path) -> bool {
p.extension_str() == Some("rlib")
}
// Reading metadata out of rlibs is faster, and if we find both
// an rlib and a dylib we only read one of the files of
// metadata, so in the name of speed, bring all rlib files to
// the front of the search list.
let files1 = files.iter().filter(|p| is_rlib(p));
let files2 = files.iter().filter(|p|!is_rlib(p));
for path in files1.chain(files2) {
debug!("testing {}", path.display());
let maybe_picked = pick(path);
match maybe_picked {
FileMatches => {
debug!("picked {}", path.display());
rslt = FileMatches;
}
FileDoesntMatch => {
debug!("rejected {}", path.display());
}
}
}
rslt
}
Err(..) => FileDoesntMatch,
}
});
}
pub fn new(sysroot: &'a Path,
triple: &'a str,
search_paths: &'a SearchPaths,
kind: PathKind) -> FileSearch<'a> {
debug!("using sysroot = {}, triple = {}", sysroot.display(), triple);
FileSearch {
sysroot: sysroot,
search_paths: search_paths,
triple: triple,
kind: kind,
}
}
// Returns a list of directories where target-specific dylibs might be located.
pub fn get_dylib_search_paths(&self) -> Vec<Path> {
let mut paths = Vec::new();
self.for_each_lib_search_path(|lib_search_path| {
paths.push(lib_search_path.clone());
FileDoesntMatch
});
paths
}
// Returns a list of directories where target-specific tool binaries are located.
pub fn get_tools_search_paths(&self) -> Vec<Path> {
let mut p = Path::new(self.sysroot);
p.push(find_libdir(self.sysroot));
p.push(rustlibdir());
p.push(self.triple);
p.push("bin");
vec![p]
}
}
pub fn relative_target_lib_path(sysroot: &Path, target_triple: &str) -> Path {
let mut p = Path::new(find_libdir(sysroot));
assert!(p.is_relative());
p.push(rustlibdir());
p.push(target_triple);
p.push("lib");
p
}
fn make_target_lib_path(sysroot: &Path,
target_triple: &str) -> Path {
sysroot.join(&relative_target_lib_path(sysroot, target_triple))
}
fn make_rustpkg_lib_path(sysroot: &Path,
dir: &Path,
triple: &str) -> Path {
let mut p = dir.join(find_libdir(sysroot));
p.push(triple);
p
}
pub fn get_or_default_sysroot() -> Path {
// Follow symlinks. If the resolved path is relative, make it absolute.
fn canonicalize(path: Option<Path>) -> Option<Path> {
path.and_then(|path|
match myfs::realpath(&path) {
Ok(canon) => Some(canon),
Err(e) => panic!("failed to get realpath: {}", e),
})
}
match canonicalize(os::self_exe_name()) {
Some(mut p) => { p.pop(); p.pop(); p }
None => panic!("can't determine value for sysroot")
}
}
#[cfg(windows)]
static PATH_ENTRY_SEPARATOR: &'static str = ";";
#[cfg(not(windows))]
static PATH_ENTRY_SEPARATOR: &'static str = ":";
/// Returns RUST_PATH as a string, without default paths added
pub fn get_rust_path() -> Option<String> {
os::getenv("RUST_PATH").map(|x| x.to_string())
}
/// Returns the value of RUST_PATH, as a list
/// of Paths. Includes default entries for, if they exist:
/// $HOME/.rust
/// DIR/.rust for any DIR that's the current working directory
/// or an ancestor of it
pub fn rust_path() -> Vec<Path> {
let mut env_rust_path: Vec<Path> = match get_rust_path() {
Some(env_path) => {
let env_path_components =
env_path.split_str(PATH_ENTRY_SEPARATOR);
env_path_components.map(|s| Path::new(s)).collect()
}
None => Vec::new()
};
let mut cwd = os::getcwd().unwrap();
// now add in default entries
let cwd_dot_rust = cwd.join(".rust");
if!env_rust_path.contains(&cwd_dot_rust) {
env_rust_path.push(cwd_dot_rust);
}
if!env_rust_path.contains(&cwd) {
env_rust_path.push(cwd.clone());
}
loop {
if { let f = cwd.filename(); f.is_none() || f.unwrap() == b".." } {
break
}
cwd.set_filename(".rust");
if!env_rust_path.contains(&cwd) && cwd.exists() {
env_rust_path.push(cwd.clone());
}
cwd.pop();
}
let h = os::homedir();
for h in h.iter() {
let p = h.join(".rust");
if!env_rust_path.contains(&p) && p.exists() {
env_rust_path.push(p);
}
}
env_rust_path
}
// The name of the directory rustc expects libraries to be located.
// On Unix should be "lib", on windows "bin"
#[cfg(unix)]
fn find_libdir(sysroot: &Path) -> String {
// FIXME: This is a quick hack to make the rustc binary able to locate
// Rust libraries in Linux environments where libraries might be installed
// to lib64/lib32. This would be more foolproof by basing the sysroot off
// of the directory where librustc is located, rather than where the rustc
// binary is.
//If --libdir is set during configuration to the value other than
// "lib" (i.e. non-default), this value is used (see issue #16552).
match option_env!("CFG_LIBDIR_RELATIVE") {
Some(libdir) if libdir!= "lib" => return libdir.to_string(),
_ => if sysroot.join(primary_libdir_name()).join(rustlibdir()).exists() {
return primary_libdir_name();
} else {
return secondary_libdir_name();
}
}
#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))]
fn primary_libdir_name() -> String {
"lib64".to_string()
}
#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))]
fn primary_libdir_name() -> String {
"lib32".to_string()
}
fn secondary_libdir_name() -> String {
"lib".to_string()
}
}
#[cfg(windows)]
fn find_libdir(_sysroot: &Path) -> String {
"bin".to_string()
}
// The name of rustc's own place to organize libraries.
// Used to be "rustc", now the default is "rustlib"
pub fn rustlibdir() -> String {
"rustlib".to_string()
}
| {
let mut visited_dirs = HashSet::new();
let mut found = false;
for path in self.search_paths.iter(self.kind) {
match f(path) {
FileMatches => found = true,
FileDoesntMatch => ()
}
visited_dirs.insert(path.as_vec().to_vec());
}
debug!("filesearch: searching lib path");
let tlib_path = make_target_lib_path(self.sysroot,
self.triple);
if !visited_dirs.contains(tlib_path.as_vec()) {
match f(&tlib_path) {
FileMatches => found = true,
FileDoesntMatch => ()
} | identifier_body |
filesearch.rs | // 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.
#![allow(non_camel_case_types)]
pub use self::FileMatch::*;
use std::collections::HashSet;
use std::io::fs::PathExtensions;
use std::io::fs;
use std::os;
use util::fs as myfs;
use session::search_paths::{SearchPaths, PathKind};
#[derive(Copy)]
pub enum FileMatch {
FileMatches,
FileDoesntMatch,
}
// A module for searching for libraries
// FIXME (#2658): I'm not happy how this module turned out. Should
// probably just be folded into cstore.
pub struct FileSearch<'a> {
pub sysroot: &'a Path,
pub search_paths: &'a SearchPaths,
pub triple: &'a str,
pub kind: PathKind,
}
impl<'a> FileSearch<'a> {
pub fn for_each_lib_search_path<F>(&self, mut f: F) where
F: FnMut(&Path) -> FileMatch,
{
let mut visited_dirs = HashSet::new();
let mut found = false;
for path in self.search_paths.iter(self.kind) {
match f(path) {
FileMatches => found = true,
FileDoesntMatch => ()
}
visited_dirs.insert(path.as_vec().to_vec());
}
debug!("filesearch: searching lib path");
let tlib_path = make_target_lib_path(self.sysroot,
self.triple);
if!visited_dirs.contains(tlib_path.as_vec()) {
match f(&tlib_path) {
FileMatches => found = true,
FileDoesntMatch => ()
}
}
visited_dirs.insert(tlib_path.as_vec().to_vec());
// Try RUST_PATH
if!found {
let rustpath = rust_path();
for path in rustpath.iter() {
let tlib_path = make_rustpkg_lib_path(
self.sysroot, path, self.triple);
debug!("is {} in visited_dirs? {}", tlib_path.display(),
visited_dirs.contains(&tlib_path.as_vec().to_vec()));
if!visited_dirs.contains(tlib_path.as_vec()) {
visited_dirs.insert(tlib_path.as_vec().to_vec());
// Don't keep searching the RUST_PATH if one match turns up --
// if we did, we'd get a "multiple matching crates" error
match f(&tlib_path) {
FileMatches => {
break;
}
FileDoesntMatch => ()
}
}
}
}
}
pub fn get_lib_path(&self) -> Path {
make_target_lib_path(self.sysroot, self.triple)
}
pub fn | <F>(&self, mut pick: F) where F: FnMut(&Path) -> FileMatch {
self.for_each_lib_search_path(|lib_search_path| {
debug!("searching {}", lib_search_path.display());
match fs::readdir(lib_search_path) {
Ok(files) => {
let mut rslt = FileDoesntMatch;
fn is_rlib(p: & &Path) -> bool {
p.extension_str() == Some("rlib")
}
// Reading metadata out of rlibs is faster, and if we find both
// an rlib and a dylib we only read one of the files of
// metadata, so in the name of speed, bring all rlib files to
// the front of the search list.
let files1 = files.iter().filter(|p| is_rlib(p));
let files2 = files.iter().filter(|p|!is_rlib(p));
for path in files1.chain(files2) {
debug!("testing {}", path.display());
let maybe_picked = pick(path);
match maybe_picked {
FileMatches => {
debug!("picked {}", path.display());
rslt = FileMatches;
}
FileDoesntMatch => {
debug!("rejected {}", path.display());
}
}
}
rslt
}
Err(..) => FileDoesntMatch,
}
});
}
pub fn new(sysroot: &'a Path,
triple: &'a str,
search_paths: &'a SearchPaths,
kind: PathKind) -> FileSearch<'a> {
debug!("using sysroot = {}, triple = {}", sysroot.display(), triple);
FileSearch {
sysroot: sysroot,
search_paths: search_paths,
triple: triple,
kind: kind,
}
}
// Returns a list of directories where target-specific dylibs might be located.
pub fn get_dylib_search_paths(&self) -> Vec<Path> {
let mut paths = Vec::new();
self.for_each_lib_search_path(|lib_search_path| {
paths.push(lib_search_path.clone());
FileDoesntMatch
});
paths
}
// Returns a list of directories where target-specific tool binaries are located.
pub fn get_tools_search_paths(&self) -> Vec<Path> {
let mut p = Path::new(self.sysroot);
p.push(find_libdir(self.sysroot));
p.push(rustlibdir());
p.push(self.triple);
p.push("bin");
vec![p]
}
}
pub fn relative_target_lib_path(sysroot: &Path, target_triple: &str) -> Path {
let mut p = Path::new(find_libdir(sysroot));
assert!(p.is_relative());
p.push(rustlibdir());
p.push(target_triple);
p.push("lib");
p
}
fn make_target_lib_path(sysroot: &Path,
target_triple: &str) -> Path {
sysroot.join(&relative_target_lib_path(sysroot, target_triple))
}
fn make_rustpkg_lib_path(sysroot: &Path,
dir: &Path,
triple: &str) -> Path {
let mut p = dir.join(find_libdir(sysroot));
p.push(triple);
p
}
pub fn get_or_default_sysroot() -> Path {
// Follow symlinks. If the resolved path is relative, make it absolute.
fn canonicalize(path: Option<Path>) -> Option<Path> {
path.and_then(|path|
match myfs::realpath(&path) {
Ok(canon) => Some(canon),
Err(e) => panic!("failed to get realpath: {}", e),
})
}
match canonicalize(os::self_exe_name()) {
Some(mut p) => { p.pop(); p.pop(); p }
None => panic!("can't determine value for sysroot")
}
}
#[cfg(windows)]
static PATH_ENTRY_SEPARATOR: &'static str = ";";
#[cfg(not(windows))]
static PATH_ENTRY_SEPARATOR: &'static str = ":";
/// Returns RUST_PATH as a string, without default paths added
pub fn get_rust_path() -> Option<String> {
os::getenv("RUST_PATH").map(|x| x.to_string())
}
/// Returns the value of RUST_PATH, as a list
/// of Paths. Includes default entries for, if they exist:
/// $HOME/.rust
/// DIR/.rust for any DIR that's the current working directory
/// or an ancestor of it
pub fn rust_path() -> Vec<Path> {
let mut env_rust_path: Vec<Path> = match get_rust_path() {
Some(env_path) => {
let env_path_components =
env_path.split_str(PATH_ENTRY_SEPARATOR);
env_path_components.map(|s| Path::new(s)).collect()
}
None => Vec::new()
};
let mut cwd = os::getcwd().unwrap();
// now add in default entries
let cwd_dot_rust = cwd.join(".rust");
if!env_rust_path.contains(&cwd_dot_rust) {
env_rust_path.push(cwd_dot_rust);
}
if!env_rust_path.contains(&cwd) {
env_rust_path.push(cwd.clone());
}
loop {
if { let f = cwd.filename(); f.is_none() || f.unwrap() == b".." } {
break
}
cwd.set_filename(".rust");
if!env_rust_path.contains(&cwd) && cwd.exists() {
env_rust_path.push(cwd.clone());
}
cwd.pop();
}
let h = os::homedir();
for h in h.iter() {
let p = h.join(".rust");
if!env_rust_path.contains(&p) && p.exists() {
env_rust_path.push(p);
}
}
env_rust_path
}
// The name of the directory rustc expects libraries to be located.
// On Unix should be "lib", on windows "bin"
#[cfg(unix)]
fn find_libdir(sysroot: &Path) -> String {
// FIXME: This is a quick hack to make the rustc binary able to locate
// Rust libraries in Linux environments where libraries might be installed
// to lib64/lib32. This would be more foolproof by basing the sysroot off
// of the directory where librustc is located, rather than where the rustc
// binary is.
//If --libdir is set during configuration to the value other than
// "lib" (i.e. non-default), this value is used (see issue #16552).
match option_env!("CFG_LIBDIR_RELATIVE") {
Some(libdir) if libdir!= "lib" => return libdir.to_string(),
_ => if sysroot.join(primary_libdir_name()).join(rustlibdir()).exists() {
return primary_libdir_name();
} else {
return secondary_libdir_name();
}
}
#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))]
fn primary_libdir_name() -> String {
"lib64".to_string()
}
#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))]
fn primary_libdir_name() -> String {
"lib32".to_string()
}
fn secondary_libdir_name() -> String {
"lib".to_string()
}
}
#[cfg(windows)]
fn find_libdir(_sysroot: &Path) -> String {
"bin".to_string()
}
// The name of rustc's own place to organize libraries.
// Used to be "rustc", now the default is "rustlib"
pub fn rustlibdir() -> String {
"rustlib".to_string()
}
| search | identifier_name |
mod.rs | // Copyright 2020 The Tink-Rust Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
////////////////////////////////////////////////////////////////////////////////
//! Provide methods to generate, read, write or validate keysets.
mod binary_io;
pub use binary_io::*;
mod handle;
pub use handle::*;
#[cfg(feature = "json")]
#[cfg_attr(docsrs, doc(cfg(feature = "json")))]
mod json_io;
#[cfg(feature = "json")]
pub use json_io::*; | pub use reader::*;
mod validation;
pub use validation::*;
mod writer;
pub use writer::*;
#[cfg(feature = "insecure")]
#[cfg_attr(docsrs, doc(cfg(feature = "insecure")))]
pub mod insecure; | mod manager;
pub use manager::*;
mod mem_io;
pub use mem_io::*;
mod reader; | random_line_split |
os.rs | // Copyright 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.
// FIXME: move various extern bindings from here into liblibc or
// something similar |
use libc;
use libc::{c_int, c_char, c_void};
use prelude::*;
use io::{IoResult, IoError};
use sys::fs::FileDesc;
use ptr;
use os::TMPBUF_SZ;
pub fn errno() -> uint {
use libc::types::os::arch::extra::DWORD;
#[link_name = "kernel32"]
extern "system" {
fn GetLastError() -> DWORD;
}
unsafe {
GetLastError() as uint
}
}
/// Get a detailed string description for the given error number
pub fn error_string(errnum: i32) -> String {
use libc::types::os::arch::extra::DWORD;
use libc::types::os::arch::extra::LPWSTR;
use libc::types::os::arch::extra::LPVOID;
use libc::types::os::arch::extra::WCHAR;
#[link_name = "kernel32"]
extern "system" {
fn FormatMessageW(flags: DWORD,
lpSrc: LPVOID,
msgId: DWORD,
langId: DWORD,
buf: LPWSTR,
nsize: DWORD,
args: *const c_void)
-> DWORD;
}
static FORMAT_MESSAGE_FROM_SYSTEM: DWORD = 0x00001000;
static FORMAT_MESSAGE_IGNORE_INSERTS: DWORD = 0x00000200;
// This value is calculated from the macro
// MAKELANGID(LANG_SYSTEM_DEFAULT, SUBLANG_SYS_DEFAULT)
let langId = 0x0800 as DWORD;
let mut buf = [0 as WCHAR,..TMPBUF_SZ];
unsafe {
let res = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
ptr::null_mut(),
errnum as DWORD,
langId,
buf.as_mut_ptr(),
buf.len() as DWORD,
ptr::null());
if res == 0 {
// Sometimes FormatMessageW can fail e.g. system doesn't like langId,
let fm_err = errno();
return format!("OS Error {} (FormatMessageW() returned error {})", errnum, fm_err);
}
let msg = String::from_utf16(::str::truncate_utf16_at_nul(buf));
match msg {
Some(msg) => format!("OS Error {}: {}", errnum, msg),
None => format!("OS Error {} (FormatMessageW() returned invalid UTF-16)", errnum),
}
}
}
pub unsafe fn pipe() -> IoResult<(FileDesc, FileDesc)> {
// Windows pipes work subtly differently than unix pipes, and their
// inheritance has to be handled in a different way that I do not
// fully understand. Here we explicitly make the pipe non-inheritable,
// which means to pass it to a subprocess they need to be duplicated
// first, as in std::run.
let mut fds = [0,..2];
match libc::pipe(fds.as_mut_ptr(), 1024 as ::libc::c_uint,
(libc::O_BINARY | libc::O_NOINHERIT) as c_int) {
0 => {
assert!(fds[0]!= -1 && fds[0]!= 0);
assert!(fds[1]!= -1 && fds[1]!= 0);
Ok((FileDesc::new(fds[0], true), FileDesc::new(fds[1], true)))
}
_ => Err(IoError::last_error()),
}
} | random_line_split |
|
os.rs | // Copyright 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.
// FIXME: move various extern bindings from here into liblibc or
// something similar
use libc;
use libc::{c_int, c_char, c_void};
use prelude::*;
use io::{IoResult, IoError};
use sys::fs::FileDesc;
use ptr;
use os::TMPBUF_SZ;
pub fn errno() -> uint {
use libc::types::os::arch::extra::DWORD;
#[link_name = "kernel32"]
extern "system" {
fn GetLastError() -> DWORD;
}
unsafe {
GetLastError() as uint
}
}
/// Get a detailed string description for the given error number
pub fn error_string(errnum: i32) -> String {
use libc::types::os::arch::extra::DWORD;
use libc::types::os::arch::extra::LPWSTR;
use libc::types::os::arch::extra::LPVOID;
use libc::types::os::arch::extra::WCHAR;
#[link_name = "kernel32"]
extern "system" {
fn FormatMessageW(flags: DWORD,
lpSrc: LPVOID,
msgId: DWORD,
langId: DWORD,
buf: LPWSTR,
nsize: DWORD,
args: *const c_void)
-> DWORD;
}
static FORMAT_MESSAGE_FROM_SYSTEM: DWORD = 0x00001000;
static FORMAT_MESSAGE_IGNORE_INSERTS: DWORD = 0x00000200;
// This value is calculated from the macro
// MAKELANGID(LANG_SYSTEM_DEFAULT, SUBLANG_SYS_DEFAULT)
let langId = 0x0800 as DWORD;
let mut buf = [0 as WCHAR,..TMPBUF_SZ];
unsafe {
let res = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
ptr::null_mut(),
errnum as DWORD,
langId,
buf.as_mut_ptr(),
buf.len() as DWORD,
ptr::null());
if res == 0 {
// Sometimes FormatMessageW can fail e.g. system doesn't like langId,
let fm_err = errno();
return format!("OS Error {} (FormatMessageW() returned error {})", errnum, fm_err);
}
let msg = String::from_utf16(::str::truncate_utf16_at_nul(buf));
match msg {
Some(msg) => format!("OS Error {}: {}", errnum, msg),
None => format!("OS Error {} (FormatMessageW() returned invalid UTF-16)", errnum),
}
}
}
pub unsafe fn pipe() -> IoResult<(FileDesc, FileDesc)> | {
// Windows pipes work subtly differently than unix pipes, and their
// inheritance has to be handled in a different way that I do not
// fully understand. Here we explicitly make the pipe non-inheritable,
// which means to pass it to a subprocess they need to be duplicated
// first, as in std::run.
let mut fds = [0, ..2];
match libc::pipe(fds.as_mut_ptr(), 1024 as ::libc::c_uint,
(libc::O_BINARY | libc::O_NOINHERIT) as c_int) {
0 => {
assert!(fds[0] != -1 && fds[0] != 0);
assert!(fds[1] != -1 && fds[1] != 0);
Ok((FileDesc::new(fds[0], true), FileDesc::new(fds[1], true)))
}
_ => Err(IoError::last_error()),
}
} | identifier_body |
|
os.rs | // Copyright 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.
// FIXME: move various extern bindings from here into liblibc or
// something similar
use libc;
use libc::{c_int, c_char, c_void};
use prelude::*;
use io::{IoResult, IoError};
use sys::fs::FileDesc;
use ptr;
use os::TMPBUF_SZ;
pub fn errno() -> uint {
use libc::types::os::arch::extra::DWORD;
#[link_name = "kernel32"]
extern "system" {
fn GetLastError() -> DWORD;
}
unsafe {
GetLastError() as uint
}
}
/// Get a detailed string description for the given error number
pub fn error_string(errnum: i32) -> String {
use libc::types::os::arch::extra::DWORD;
use libc::types::os::arch::extra::LPWSTR;
use libc::types::os::arch::extra::LPVOID;
use libc::types::os::arch::extra::WCHAR;
#[link_name = "kernel32"]
extern "system" {
fn FormatMessageW(flags: DWORD,
lpSrc: LPVOID,
msgId: DWORD,
langId: DWORD,
buf: LPWSTR,
nsize: DWORD,
args: *const c_void)
-> DWORD;
}
static FORMAT_MESSAGE_FROM_SYSTEM: DWORD = 0x00001000;
static FORMAT_MESSAGE_IGNORE_INSERTS: DWORD = 0x00000200;
// This value is calculated from the macro
// MAKELANGID(LANG_SYSTEM_DEFAULT, SUBLANG_SYS_DEFAULT)
let langId = 0x0800 as DWORD;
let mut buf = [0 as WCHAR,..TMPBUF_SZ];
unsafe {
let res = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
ptr::null_mut(),
errnum as DWORD,
langId,
buf.as_mut_ptr(),
buf.len() as DWORD,
ptr::null());
if res == 0 |
let msg = String::from_utf16(::str::truncate_utf16_at_nul(buf));
match msg {
Some(msg) => format!("OS Error {}: {}", errnum, msg),
None => format!("OS Error {} (FormatMessageW() returned invalid UTF-16)", errnum),
}
}
}
pub unsafe fn pipe() -> IoResult<(FileDesc, FileDesc)> {
// Windows pipes work subtly differently than unix pipes, and their
// inheritance has to be handled in a different way that I do not
// fully understand. Here we explicitly make the pipe non-inheritable,
// which means to pass it to a subprocess they need to be duplicated
// first, as in std::run.
let mut fds = [0,..2];
match libc::pipe(fds.as_mut_ptr(), 1024 as ::libc::c_uint,
(libc::O_BINARY | libc::O_NOINHERIT) as c_int) {
0 => {
assert!(fds[0]!= -1 && fds[0]!= 0);
assert!(fds[1]!= -1 && fds[1]!= 0);
Ok((FileDesc::new(fds[0], true), FileDesc::new(fds[1], true)))
}
_ => Err(IoError::last_error()),
}
}
| {
// Sometimes FormatMessageW can fail e.g. system doesn't like langId,
let fm_err = errno();
return format!("OS Error {} (FormatMessageW() returned error {})", errnum, fm_err);
} | conditional_block |
os.rs | // Copyright 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.
// FIXME: move various extern bindings from here into liblibc or
// something similar
use libc;
use libc::{c_int, c_char, c_void};
use prelude::*;
use io::{IoResult, IoError};
use sys::fs::FileDesc;
use ptr;
use os::TMPBUF_SZ;
pub fn | () -> uint {
use libc::types::os::arch::extra::DWORD;
#[link_name = "kernel32"]
extern "system" {
fn GetLastError() -> DWORD;
}
unsafe {
GetLastError() as uint
}
}
/// Get a detailed string description for the given error number
pub fn error_string(errnum: i32) -> String {
use libc::types::os::arch::extra::DWORD;
use libc::types::os::arch::extra::LPWSTR;
use libc::types::os::arch::extra::LPVOID;
use libc::types::os::arch::extra::WCHAR;
#[link_name = "kernel32"]
extern "system" {
fn FormatMessageW(flags: DWORD,
lpSrc: LPVOID,
msgId: DWORD,
langId: DWORD,
buf: LPWSTR,
nsize: DWORD,
args: *const c_void)
-> DWORD;
}
static FORMAT_MESSAGE_FROM_SYSTEM: DWORD = 0x00001000;
static FORMAT_MESSAGE_IGNORE_INSERTS: DWORD = 0x00000200;
// This value is calculated from the macro
// MAKELANGID(LANG_SYSTEM_DEFAULT, SUBLANG_SYS_DEFAULT)
let langId = 0x0800 as DWORD;
let mut buf = [0 as WCHAR,..TMPBUF_SZ];
unsafe {
let res = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
ptr::null_mut(),
errnum as DWORD,
langId,
buf.as_mut_ptr(),
buf.len() as DWORD,
ptr::null());
if res == 0 {
// Sometimes FormatMessageW can fail e.g. system doesn't like langId,
let fm_err = errno();
return format!("OS Error {} (FormatMessageW() returned error {})", errnum, fm_err);
}
let msg = String::from_utf16(::str::truncate_utf16_at_nul(buf));
match msg {
Some(msg) => format!("OS Error {}: {}", errnum, msg),
None => format!("OS Error {} (FormatMessageW() returned invalid UTF-16)", errnum),
}
}
}
pub unsafe fn pipe() -> IoResult<(FileDesc, FileDesc)> {
// Windows pipes work subtly differently than unix pipes, and their
// inheritance has to be handled in a different way that I do not
// fully understand. Here we explicitly make the pipe non-inheritable,
// which means to pass it to a subprocess they need to be duplicated
// first, as in std::run.
let mut fds = [0,..2];
match libc::pipe(fds.as_mut_ptr(), 1024 as ::libc::c_uint,
(libc::O_BINARY | libc::O_NOINHERIT) as c_int) {
0 => {
assert!(fds[0]!= -1 && fds[0]!= 0);
assert!(fds[1]!= -1 && fds[1]!= 0);
Ok((FileDesc::new(fds[0], true), FileDesc::new(fds[1], true)))
}
_ => Err(IoError::last_error()),
}
}
| errno | identifier_name |
formatagesource0.rs | use std::fmt::{self, Formatter, Display};
struct City {
name: &'static str,
// Latitude
lat: f32,
// Longitude
lon: f32,
}
impl Display for City {
// `f` est un tampon, cette méthode écrit la chaîne de caractères
// formattée à l'intérieur de ce dernier.
fn fmt(&se | f: &mut Formatter) -> fmt::Result {
let lat_c = if self.lat >= 0.0 { 'N' } else { 'S' };
let lon_c = if self.lon >= 0.0 { 'E' } else { 'W' };
// `write!` est équivalente à `format!`, à l'exception qu'elle écrira
// la chaîne de caractères formatée dans un tampon (le premier argument).
write!(f, "{}: {:.3}°{} {:.3}°{}",
self.name, self.lat.abs(), lat_c, self.lon.abs(), lon_c)
}
}
#[derive(Debug)]
struct Color {
red: u8,
green: u8,
blue: u8,
}
fn main() {
for city in [
City { name: "Dublin", lat: 53.347778, lon: -6.259722 },
City { name: "Oslo", lat: 59.95, lon: 10.75 },
City { name: "Vancouver", lat: 49.25, lon: -123.1 },
].iter() {
println!("{}", *city);
}
for color in [
Color { red: 128, green: 255, blue: 90 },
Color { red: 0, green: 3, blue: 254 },
Color { red: 0, green: 0, blue: 0 },
].iter() {
// Utilisez le marqueur `{}` une fois que vous aurez implémenté
// le trait fmt::Display.
println!("{:?}", *color)
}
} | lf, | identifier_name |
formatagesource0.rs | use std::fmt::{self, Formatter, Display};
struct City {
name: &'static str,
// Latitude
lat: f32,
// Longitude
lon: f32,
}
impl Display for City {
// `f` est un tampon, cette méthode écrit la chaîne de caractères
// formattée à l'intérieur de ce dernier.
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
let lat_c = if self.lat >= 0.0 { 'N' } else { 'S' };
let lon_c = if self.lon >= 0.0 { 'E' } else { 'W' };
// `write!` est équivalente à `format!`, à l'exception qu'elle écrira
// la chaîne de caractères formatée dans un tampon (le premier argument).
write!(f, "{}: {:.3}°{} {:.3}°{}",
self.name, self.lat.abs(), lat_c, self.lon.abs(), lon_c)
}
}
#[derive(Debug)]
struct Color {
red: u8,
green: u8,
blue: u8,
}
fn main() {
for city in [
City { name: "Dublin", lat: 53.347778, lon: -6.259722 },
City { name: "Oslo", lat: 59.95, lon: 10.75 },
City { name: "Vancouver", lat: 49.25, lon: -123.1 },
].iter() {
println!("{}", *city);
}
for color in [
Color { red: 128, green: 255, blue: 90 }, | // le trait fmt::Display.
println!("{:?}", *color)
}
} | Color { red: 0, green: 3, blue: 254 },
Color { red: 0, green: 0, blue: 0 },
].iter() {
// Utilisez le marqueur `{}` une fois que vous aurez implémenté | random_line_split |
formatagesource0.rs | use std::fmt::{self, Formatter, Display};
struct City {
name: &'static str,
// Latitude
lat: f32,
// Longitude
lon: f32,
}
impl Display for City {
// `f` est un tampon, cette méthode écrit la chaîne de caractères
// formattée à l'intérieur de ce dernier.
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
let lat_c = if self.lat >= 0.0 { 'N' } else { 'S' } | let lon_c = if self.lon >= 0.0 { 'E' } else { 'W' };
// `write!` est équivalente à `format!`, à l'exception qu'elle écrira
// la chaîne de caractères formatée dans un tampon (le premier argument).
write!(f, "{}: {:.3}°{} {:.3}°{}",
self.name, self.lat.abs(), lat_c, self.lon.abs(), lon_c)
}
}
#[derive(Debug)]
struct Color {
red: u8,
green: u8,
blue: u8,
}
fn main() {
for city in [
City { name: "Dublin", lat: 53.347778, lon: -6.259722 },
City { name: "Oslo", lat: 59.95, lon: 10.75 },
City { name: "Vancouver", lat: 49.25, lon: -123.1 },
].iter() {
println!("{}", *city);
}
for color in [
Color { red: 128, green: 255, blue: 90 },
Color { red: 0, green: 3, blue: 254 },
Color { red: 0, green: 0, blue: 0 },
].iter() {
// Utilisez le marqueur `{}` une fois que vous aurez implémenté
// le trait fmt::Display.
println!("{:?}", *color)
}
} | ;
| conditional_block |
gtest_attribute.rs | use proc_macro::TokenStream;
use quote::{format_ident, quote, quote_spanned};
use syn::spanned::Spanned;
/// The `gtest` macro can be placed on a function to make it into a Gtest unit test, when linked
/// into a C++ binary that invokes Gtest.
///
/// The `gtest` macro takes two arguments, which are Rust identifiers. The first is the name of the
/// test suite and the second is the name of the test, each of which are converted to a string and
/// given to Gtest. The name of the test function itself does not matter, and need not be unique
/// (it's placed into a unique module based on the Gtest suite + test names.
///
/// The test function must have no arguments. The return value must be either `()` or
/// `std::result::Result<(), E>`. If another return type is found, the test will fail when run. If
/// the return type is a `Result`, then an `Err` is treated as a test failure.
///
/// # Examples
/// ```
/// #[gtest(MathTest, Addition)]
/// fn my_test() {
/// expect_eq!(1 + 1, 2);
/// }
/// ```
///
/// The above adds the function to the Gtest binary as `MathTest.Addtition`:
/// ```
/// [ RUN ] MathTest.Addition
/// [ OK ] MathTest.Addition (0 ms)
/// ```
///
/// A test with a Result return type, and which uses the `?` operator. It will fail if the test
/// returns an `Err`, and print the resulting error string:
/// ```
/// #[gtest(ResultTest, CheckThingWithResult)]
/// fn my_test() -> std::result::Result<(), String> {
/// call_thing_with_result()?;
/// }
/// ```
#[proc_macro_attribute]
pub fn gtest(arg_stream: TokenStream, input: TokenStream) -> TokenStream {
enum GtestAttributeArgument {
TestSuite,
TestName,
}
// Returns a string representation of an identifier argument to the attribute. For example, for
// #[gtest(Foo, Bar)], this function would return "Foo" for position 0 and "Bar" for position 1.
// If the argument is not a Rust identifier or not present, it returns a compiler error as a
// TokenStream to be emitted.
fn get_arg_string(
args: &syn::AttributeArgs,
which: GtestAttributeArgument,
) -> Result<String, TokenStream> {
let pos = match which {
GtestAttributeArgument::TestSuite => 0,
GtestAttributeArgument::TestName => 1,
};
match &args[pos] {
syn::NestedMeta::Meta(syn::Meta::Path(path)) if path.segments.len() == 1 => {
Ok(path.segments[0].ident.to_string())
}
_ => {
let error_stream = match which {
GtestAttributeArgument::TestSuite => {
quote_spanned! {
args[pos].span() =>
compile_error!(
"Expected a test suite name, written as an identifier."
);
}
}
GtestAttributeArgument::TestName => {
quote_spanned! {
args[pos].span() =>
compile_error!(
"Expected a test name, written as an identifier."
);
}
}
};
Err(error_stream.into())
}
}
}
let args = syn::parse_macro_input!(arg_stream as syn::AttributeArgs);
let input_fn = syn::parse_macro_input!(input as syn::ItemFn);
if let Some(asyncness) = input_fn.sig.asyncness {
// TODO(crbug.com/1288947): We can support async functions once we have block_on() support
// which will run a RunLoop until the async test completes. The run_test_fn just needs to be
// generated to `block_on(|| #test_fn)` instead of calling `#test_fn` synchronously.
return quote_spanned! {
asyncness.span =>
compile_error!("async functions are not supported.");
}
.into();
}
let (test_suite_name, test_name) = match args.len() {
2 => {
let suite = match get_arg_string(&args, GtestAttributeArgument::TestSuite) {
Ok(ok) => ok,
Err(error_stream) => return error_stream,
};
let test = match get_arg_string(&args, GtestAttributeArgument::TestName) {
Ok(ok) => ok,
Err(error_stream) => return error_stream,
};
(suite, test)
}
0 | 1 => {
return quote! {
compile_error!(
"Expected two arguments. For example: #[gtest(TestSuite, TestName)].");
}
.into();
}
x => {
return quote_spanned! {
args[x.min(2)].span() =>
compile_error!(
"Expected two arguments. For example: #[gtest(TestSuite, TestName)].");
}
.into();
}
};
// We put the test function and all the code we generate around it into a submodule which is
// uniquely named for the super module based on the Gtest suite and test names. A result of this
// is that if two tests have the same test suite + name, a compiler error would report the
// conflict.
let test_mod = format_ident!("__test_{}_{}", test_suite_name, test_name);
// The run_test_fn identifier is marked #[no_mangle] to work around a codegen bug where the
// function is seen as dead and the compiler omits it from the object files. Since it's
// #[no_mangle], the identifier must be globally unique or we have an ODR violation. To produce
// a unique identifier, we roll our own name mangling by combining the file name and path from
// the source tree root with the Gtest suite and test names and the function itself.
//
// Note that an adversary could still produce a bug here by placing two equal Gtest suite and
// names in a single.rs file but in separate inline submodules.
//
// TODO(danakj): Build a repro and file upstream bug to refer to.
let mangled_function_name = |f: &syn::ItemFn| -> syn::Ident {
let file_name = file!().replace(|c: char|!c.is_ascii_alphanumeric(), "_"); | let test_fn = &input_fn.sig.ident;
// Implements ToTokens to generate a reference to a static-lifetime, null-terminated, C-String
// literal. It is represented as an array of type std::os::raw::c_char which can be either
// signed or unsigned depending on the platform, and it can be passed directly to C++. This
// differs from byte strings and CStr which work with `u8`.
//
// TODO(crbug.com/1298175): Would it make sense to write a c_str_literal!() macro that takes a
// Rust string literal and produces a null-terminated array of `c_char`? Then you could write
// `c_str_literal!(file!())` for example, or implement a `file_c_str!()` in this way. Explore
// using https://crates.io/crates/cstr.
//
// TODO(danakj): Write unit tests for this, and consider pulling this out into its own crate,
// if we don't replace it with c_str_literal!() or the "cstr" crate.
struct CStringLiteral<'a>(&'a str);
impl quote::ToTokens for CStringLiteral<'_> {
fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
let mut c_chars = self.0.chars().map(|c| c as std::os::raw::c_char).collect::<Vec<_>>();
c_chars.push(0);
// Verify there's no embedded nulls as that would be invalid if the literal were put in
// a std::ffi::CString.
assert_eq!(c_chars.iter().filter(|x| **x == 0).count(), 1);
let comment = format!("\"{}\" as [c_char]", self.0);
tokens.extend(quote! {
{
#[doc=#comment]
&[#(#c_chars as std::os::raw::c_char),*]
}
});
}
}
// C-compatible string literals, that can be inserted into the quote! macro.
let test_suite_name_c_bytes = CStringLiteral(&test_suite_name);
let test_name_c_bytes = CStringLiteral(&test_name);
let file_c_bytes = CStringLiteral(file!());
let output = quote! {
mod #test_mod {
use super::*;
use std::error::Error;
use std::fmt::Display;
use std::result::Result;
#[::rust_gtest_interop::small_ctor::ctor]
unsafe fn register_test() {
let r = ::rust_gtest_interop::__private::TestRegistration {
func: #run_test_fn,
test_suite_name: #test_suite_name_c_bytes,
test_name: #test_name_c_bytes,
file: #file_c_bytes,
line: line!(),
};
::rust_gtest_interop::__private::register_test(r);
}
// The function is extern "C" so `register_test()` can pass this fn as a pointer to C++
// where it's registered with gtest.
//
// TODO(crbug.com/1296284): Removing #[no_mangle] makes rustc drop the symbol for the
// test function in the generated rlib which produces linker errors. If we resolve the
// linked bug and emit real object files from rustc for linking, then all the required
// symbols are present and `#[no_mangle]` should go away along with the custom-mangling
// of `run_test_fn`. We can not use `pub` to resolve this unfortunately. When `#[used]`
// is fixed in https://github.com/rust-lang/rust/issues/47384, this may also be
// resolved as well.
#[no_mangle]
extern "C" fn #run_test_fn() {
let catch_result = std::panic::catch_unwind(|| #test_fn());
use ::rust_gtest_interop::TestResult;
let err_message: Option<String> = match catch_result {
Ok(fn_result) => TestResult::into_error_message(fn_result),
Err(_) => Some("Test panicked".to_string()),
};
if let Some(m) = err_message.as_ref() {
::rust_gtest_interop::__private::add_failure_at(file!(), line!(), &m);
}
}
#input_fn
}
};
output.into()
} | format_ident!("{}_{}_{}_{}", file_name, test_suite_name, test_name, f.sig.ident)
};
let run_test_fn = format_ident!("run_test_{}", mangled_function_name(&input_fn));
// The identifier of the function which contains the body of the test. | random_line_split |
gtest_attribute.rs | use proc_macro::TokenStream;
use quote::{format_ident, quote, quote_spanned};
use syn::spanned::Spanned;
/// The `gtest` macro can be placed on a function to make it into a Gtest unit test, when linked
/// into a C++ binary that invokes Gtest.
///
/// The `gtest` macro takes two arguments, which are Rust identifiers. The first is the name of the
/// test suite and the second is the name of the test, each of which are converted to a string and
/// given to Gtest. The name of the test function itself does not matter, and need not be unique
/// (it's placed into a unique module based on the Gtest suite + test names.
///
/// The test function must have no arguments. The return value must be either `()` or
/// `std::result::Result<(), E>`. If another return type is found, the test will fail when run. If
/// the return type is a `Result`, then an `Err` is treated as a test failure.
///
/// # Examples
/// ```
/// #[gtest(MathTest, Addition)]
/// fn my_test() {
/// expect_eq!(1 + 1, 2);
/// }
/// ```
///
/// The above adds the function to the Gtest binary as `MathTest.Addtition`:
/// ```
/// [ RUN ] MathTest.Addition
/// [ OK ] MathTest.Addition (0 ms)
/// ```
///
/// A test with a Result return type, and which uses the `?` operator. It will fail if the test
/// returns an `Err`, and print the resulting error string:
/// ```
/// #[gtest(ResultTest, CheckThingWithResult)]
/// fn my_test() -> std::result::Result<(), String> {
/// call_thing_with_result()?;
/// }
/// ```
#[proc_macro_attribute]
pub fn gtest(arg_stream: TokenStream, input: TokenStream) -> TokenStream {
enum | {
TestSuite,
TestName,
}
// Returns a string representation of an identifier argument to the attribute. For example, for
// #[gtest(Foo, Bar)], this function would return "Foo" for position 0 and "Bar" for position 1.
// If the argument is not a Rust identifier or not present, it returns a compiler error as a
// TokenStream to be emitted.
fn get_arg_string(
args: &syn::AttributeArgs,
which: GtestAttributeArgument,
) -> Result<String, TokenStream> {
let pos = match which {
GtestAttributeArgument::TestSuite => 0,
GtestAttributeArgument::TestName => 1,
};
match &args[pos] {
syn::NestedMeta::Meta(syn::Meta::Path(path)) if path.segments.len() == 1 => {
Ok(path.segments[0].ident.to_string())
}
_ => {
let error_stream = match which {
GtestAttributeArgument::TestSuite => {
quote_spanned! {
args[pos].span() =>
compile_error!(
"Expected a test suite name, written as an identifier."
);
}
}
GtestAttributeArgument::TestName => {
quote_spanned! {
args[pos].span() =>
compile_error!(
"Expected a test name, written as an identifier."
);
}
}
};
Err(error_stream.into())
}
}
}
let args = syn::parse_macro_input!(arg_stream as syn::AttributeArgs);
let input_fn = syn::parse_macro_input!(input as syn::ItemFn);
if let Some(asyncness) = input_fn.sig.asyncness {
// TODO(crbug.com/1288947): We can support async functions once we have block_on() support
// which will run a RunLoop until the async test completes. The run_test_fn just needs to be
// generated to `block_on(|| #test_fn)` instead of calling `#test_fn` synchronously.
return quote_spanned! {
asyncness.span =>
compile_error!("async functions are not supported.");
}
.into();
}
let (test_suite_name, test_name) = match args.len() {
2 => {
let suite = match get_arg_string(&args, GtestAttributeArgument::TestSuite) {
Ok(ok) => ok,
Err(error_stream) => return error_stream,
};
let test = match get_arg_string(&args, GtestAttributeArgument::TestName) {
Ok(ok) => ok,
Err(error_stream) => return error_stream,
};
(suite, test)
}
0 | 1 => {
return quote! {
compile_error!(
"Expected two arguments. For example: #[gtest(TestSuite, TestName)].");
}
.into();
}
x => {
return quote_spanned! {
args[x.min(2)].span() =>
compile_error!(
"Expected two arguments. For example: #[gtest(TestSuite, TestName)].");
}
.into();
}
};
// We put the test function and all the code we generate around it into a submodule which is
// uniquely named for the super module based on the Gtest suite and test names. A result of this
// is that if two tests have the same test suite + name, a compiler error would report the
// conflict.
let test_mod = format_ident!("__test_{}_{}", test_suite_name, test_name);
// The run_test_fn identifier is marked #[no_mangle] to work around a codegen bug where the
// function is seen as dead and the compiler omits it from the object files. Since it's
// #[no_mangle], the identifier must be globally unique or we have an ODR violation. To produce
// a unique identifier, we roll our own name mangling by combining the file name and path from
// the source tree root with the Gtest suite and test names and the function itself.
//
// Note that an adversary could still produce a bug here by placing two equal Gtest suite and
// names in a single.rs file but in separate inline submodules.
//
// TODO(danakj): Build a repro and file upstream bug to refer to.
let mangled_function_name = |f: &syn::ItemFn| -> syn::Ident {
let file_name = file!().replace(|c: char|!c.is_ascii_alphanumeric(), "_");
format_ident!("{}_{}_{}_{}", file_name, test_suite_name, test_name, f.sig.ident)
};
let run_test_fn = format_ident!("run_test_{}", mangled_function_name(&input_fn));
// The identifier of the function which contains the body of the test.
let test_fn = &input_fn.sig.ident;
// Implements ToTokens to generate a reference to a static-lifetime, null-terminated, C-String
// literal. It is represented as an array of type std::os::raw::c_char which can be either
// signed or unsigned depending on the platform, and it can be passed directly to C++. This
// differs from byte strings and CStr which work with `u8`.
//
// TODO(crbug.com/1298175): Would it make sense to write a c_str_literal!() macro that takes a
// Rust string literal and produces a null-terminated array of `c_char`? Then you could write
// `c_str_literal!(file!())` for example, or implement a `file_c_str!()` in this way. Explore
// using https://crates.io/crates/cstr.
//
// TODO(danakj): Write unit tests for this, and consider pulling this out into its own crate,
// if we don't replace it with c_str_literal!() or the "cstr" crate.
struct CStringLiteral<'a>(&'a str);
impl quote::ToTokens for CStringLiteral<'_> {
fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
let mut c_chars = self.0.chars().map(|c| c as std::os::raw::c_char).collect::<Vec<_>>();
c_chars.push(0);
// Verify there's no embedded nulls as that would be invalid if the literal were put in
// a std::ffi::CString.
assert_eq!(c_chars.iter().filter(|x| **x == 0).count(), 1);
let comment = format!("\"{}\" as [c_char]", self.0);
tokens.extend(quote! {
{
#[doc=#comment]
&[#(#c_chars as std::os::raw::c_char),*]
}
});
}
}
// C-compatible string literals, that can be inserted into the quote! macro.
let test_suite_name_c_bytes = CStringLiteral(&test_suite_name);
let test_name_c_bytes = CStringLiteral(&test_name);
let file_c_bytes = CStringLiteral(file!());
let output = quote! {
mod #test_mod {
use super::*;
use std::error::Error;
use std::fmt::Display;
use std::result::Result;
#[::rust_gtest_interop::small_ctor::ctor]
unsafe fn register_test() {
let r = ::rust_gtest_interop::__private::TestRegistration {
func: #run_test_fn,
test_suite_name: #test_suite_name_c_bytes,
test_name: #test_name_c_bytes,
file: #file_c_bytes,
line: line!(),
};
::rust_gtest_interop::__private::register_test(r);
}
// The function is extern "C" so `register_test()` can pass this fn as a pointer to C++
// where it's registered with gtest.
//
// TODO(crbug.com/1296284): Removing #[no_mangle] makes rustc drop the symbol for the
// test function in the generated rlib which produces linker errors. If we resolve the
// linked bug and emit real object files from rustc for linking, then all the required
// symbols are present and `#[no_mangle]` should go away along with the custom-mangling
// of `run_test_fn`. We can not use `pub` to resolve this unfortunately. When `#[used]`
// is fixed in https://github.com/rust-lang/rust/issues/47384, this may also be
// resolved as well.
#[no_mangle]
extern "C" fn #run_test_fn() {
let catch_result = std::panic::catch_unwind(|| #test_fn());
use ::rust_gtest_interop::TestResult;
let err_message: Option<String> = match catch_result {
Ok(fn_result) => TestResult::into_error_message(fn_result),
Err(_) => Some("Test panicked".to_string()),
};
if let Some(m) = err_message.as_ref() {
::rust_gtest_interop::__private::add_failure_at(file!(), line!(), &m);
}
}
#input_fn
}
};
output.into()
}
| GtestAttributeArgument | identifier_name |
gtest_attribute.rs | use proc_macro::TokenStream;
use quote::{format_ident, quote, quote_spanned};
use syn::spanned::Spanned;
/// The `gtest` macro can be placed on a function to make it into a Gtest unit test, when linked
/// into a C++ binary that invokes Gtest.
///
/// The `gtest` macro takes two arguments, which are Rust identifiers. The first is the name of the
/// test suite and the second is the name of the test, each of which are converted to a string and
/// given to Gtest. The name of the test function itself does not matter, and need not be unique
/// (it's placed into a unique module based on the Gtest suite + test names.
///
/// The test function must have no arguments. The return value must be either `()` or
/// `std::result::Result<(), E>`. If another return type is found, the test will fail when run. If
/// the return type is a `Result`, then an `Err` is treated as a test failure.
///
/// # Examples
/// ```
/// #[gtest(MathTest, Addition)]
/// fn my_test() {
/// expect_eq!(1 + 1, 2);
/// }
/// ```
///
/// The above adds the function to the Gtest binary as `MathTest.Addtition`:
/// ```
/// [ RUN ] MathTest.Addition
/// [ OK ] MathTest.Addition (0 ms)
/// ```
///
/// A test with a Result return type, and which uses the `?` operator. It will fail if the test
/// returns an `Err`, and print the resulting error string:
/// ```
/// #[gtest(ResultTest, CheckThingWithResult)]
/// fn my_test() -> std::result::Result<(), String> {
/// call_thing_with_result()?;
/// }
/// ```
#[proc_macro_attribute]
pub fn gtest(arg_stream: TokenStream, input: TokenStream) -> TokenStream {
enum GtestAttributeArgument {
TestSuite,
TestName,
}
// Returns a string representation of an identifier argument to the attribute. For example, for
// #[gtest(Foo, Bar)], this function would return "Foo" for position 0 and "Bar" for position 1.
// If the argument is not a Rust identifier or not present, it returns a compiler error as a
// TokenStream to be emitted.
fn get_arg_string(
args: &syn::AttributeArgs,
which: GtestAttributeArgument,
) -> Result<String, TokenStream> {
let pos = match which {
GtestAttributeArgument::TestSuite => 0,
GtestAttributeArgument::TestName => 1,
};
match &args[pos] {
syn::NestedMeta::Meta(syn::Meta::Path(path)) if path.segments.len() == 1 => {
Ok(path.segments[0].ident.to_string())
}
_ => | }
}
}
let args = syn::parse_macro_input!(arg_stream as syn::AttributeArgs);
let input_fn = syn::parse_macro_input!(input as syn::ItemFn);
if let Some(asyncness) = input_fn.sig.asyncness {
// TODO(crbug.com/1288947): We can support async functions once we have block_on() support
// which will run a RunLoop until the async test completes. The run_test_fn just needs to be
// generated to `block_on(|| #test_fn)` instead of calling `#test_fn` synchronously.
return quote_spanned! {
asyncness.span =>
compile_error!("async functions are not supported.");
}
.into();
}
let (test_suite_name, test_name) = match args.len() {
2 => {
let suite = match get_arg_string(&args, GtestAttributeArgument::TestSuite) {
Ok(ok) => ok,
Err(error_stream) => return error_stream,
};
let test = match get_arg_string(&args, GtestAttributeArgument::TestName) {
Ok(ok) => ok,
Err(error_stream) => return error_stream,
};
(suite, test)
}
0 | 1 => {
return quote! {
compile_error!(
"Expected two arguments. For example: #[gtest(TestSuite, TestName)].");
}
.into();
}
x => {
return quote_spanned! {
args[x.min(2)].span() =>
compile_error!(
"Expected two arguments. For example: #[gtest(TestSuite, TestName)].");
}
.into();
}
};
// We put the test function and all the code we generate around it into a submodule which is
// uniquely named for the super module based on the Gtest suite and test names. A result of this
// is that if two tests have the same test suite + name, a compiler error would report the
// conflict.
let test_mod = format_ident!("__test_{}_{}", test_suite_name, test_name);
// The run_test_fn identifier is marked #[no_mangle] to work around a codegen bug where the
// function is seen as dead and the compiler omits it from the object files. Since it's
// #[no_mangle], the identifier must be globally unique or we have an ODR violation. To produce
// a unique identifier, we roll our own name mangling by combining the file name and path from
// the source tree root with the Gtest suite and test names and the function itself.
//
// Note that an adversary could still produce a bug here by placing two equal Gtest suite and
// names in a single.rs file but in separate inline submodules.
//
// TODO(danakj): Build a repro and file upstream bug to refer to.
let mangled_function_name = |f: &syn::ItemFn| -> syn::Ident {
let file_name = file!().replace(|c: char|!c.is_ascii_alphanumeric(), "_");
format_ident!("{}_{}_{}_{}", file_name, test_suite_name, test_name, f.sig.ident)
};
let run_test_fn = format_ident!("run_test_{}", mangled_function_name(&input_fn));
// The identifier of the function which contains the body of the test.
let test_fn = &input_fn.sig.ident;
// Implements ToTokens to generate a reference to a static-lifetime, null-terminated, C-String
// literal. It is represented as an array of type std::os::raw::c_char which can be either
// signed or unsigned depending on the platform, and it can be passed directly to C++. This
// differs from byte strings and CStr which work with `u8`.
//
// TODO(crbug.com/1298175): Would it make sense to write a c_str_literal!() macro that takes a
// Rust string literal and produces a null-terminated array of `c_char`? Then you could write
// `c_str_literal!(file!())` for example, or implement a `file_c_str!()` in this way. Explore
// using https://crates.io/crates/cstr.
//
// TODO(danakj): Write unit tests for this, and consider pulling this out into its own crate,
// if we don't replace it with c_str_literal!() or the "cstr" crate.
struct CStringLiteral<'a>(&'a str);
impl quote::ToTokens for CStringLiteral<'_> {
fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
let mut c_chars = self.0.chars().map(|c| c as std::os::raw::c_char).collect::<Vec<_>>();
c_chars.push(0);
// Verify there's no embedded nulls as that would be invalid if the literal were put in
// a std::ffi::CString.
assert_eq!(c_chars.iter().filter(|x| **x == 0).count(), 1);
let comment = format!("\"{}\" as [c_char]", self.0);
tokens.extend(quote! {
{
#[doc=#comment]
&[#(#c_chars as std::os::raw::c_char),*]
}
});
}
}
// C-compatible string literals, that can be inserted into the quote! macro.
let test_suite_name_c_bytes = CStringLiteral(&test_suite_name);
let test_name_c_bytes = CStringLiteral(&test_name);
let file_c_bytes = CStringLiteral(file!());
let output = quote! {
mod #test_mod {
use super::*;
use std::error::Error;
use std::fmt::Display;
use std::result::Result;
#[::rust_gtest_interop::small_ctor::ctor]
unsafe fn register_test() {
let r = ::rust_gtest_interop::__private::TestRegistration {
func: #run_test_fn,
test_suite_name: #test_suite_name_c_bytes,
test_name: #test_name_c_bytes,
file: #file_c_bytes,
line: line!(),
};
::rust_gtest_interop::__private::register_test(r);
}
// The function is extern "C" so `register_test()` can pass this fn as a pointer to C++
// where it's registered with gtest.
//
// TODO(crbug.com/1296284): Removing #[no_mangle] makes rustc drop the symbol for the
// test function in the generated rlib which produces linker errors. If we resolve the
// linked bug and emit real object files from rustc for linking, then all the required
// symbols are present and `#[no_mangle]` should go away along with the custom-mangling
// of `run_test_fn`. We can not use `pub` to resolve this unfortunately. When `#[used]`
// is fixed in https://github.com/rust-lang/rust/issues/47384, this may also be
// resolved as well.
#[no_mangle]
extern "C" fn #run_test_fn() {
let catch_result = std::panic::catch_unwind(|| #test_fn());
use ::rust_gtest_interop::TestResult;
let err_message: Option<String> = match catch_result {
Ok(fn_result) => TestResult::into_error_message(fn_result),
Err(_) => Some("Test panicked".to_string()),
};
if let Some(m) = err_message.as_ref() {
::rust_gtest_interop::__private::add_failure_at(file!(), line!(), &m);
}
}
#input_fn
}
};
output.into()
}
| {
let error_stream = match which {
GtestAttributeArgument::TestSuite => {
quote_spanned! {
args[pos].span() =>
compile_error!(
"Expected a test suite name, written as an identifier."
);
}
}
GtestAttributeArgument::TestName => {
quote_spanned! {
args[pos].span() =>
compile_error!(
"Expected a test name, written as an identifier."
);
}
}
};
Err(error_stream.into()) | conditional_block |
no_0064_minimum_path_sum.rs | struct Solution;
impl Solution {
pub fn min_path_sum(grid: Vec<Vec<i32>>) -> i32 {
if grid.is_empty() {
return 0;
}
let (m, n) = (grid.len(), grid[0].len());
let mut arr = vec![std::i32::MAX; n];
arr[0] = 0;
for i in 0..m {
for j in 0..n {
// 选择上面(arr[j])和左面(arr[j-1])最小的那个
if j == 0 {
// 左边没有，只有上面的元素
arr[j] = arr[j] + grid[i][j];
} else {
// 有左边和上边
arr[j] = arr[j].min(arr[j - 1]) + grid[i][j];
}
}
}
arr[n - 1] | }
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_min_path_sum() {
let grid = vec![vec![1, 3, 1], vec![1, 5, 1], vec![4, 2, 1]];
assert_eq!(Solution::min_path_sum(grid), 7);
}
} | } | random_line_split |
no_0064_minimum_path_sum.rs | struct Solution;
impl Solution {
pub fn | (grid: Vec<Vec<i32>>) -> i32 {
if grid.is_empty() {
return 0;
}
let (m, n) = (grid.len(), grid[0].len());
let mut arr = vec![std::i32::MAX; n];
arr[0] = 0;
for i in 0..m {
for j in 0..n {
// 选择上面(arr[j])和左面(arr[j-1])最小的那个
if j == 0 {
// 左边没有，只有上面的元素
arr[j] = arr[j] + grid[i][j];
} else {
// 有左边和上边
arr[j] = arr[j].min(arr[j - 1]) + grid[i][j];
}
}
}
arr[n - 1]
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_min_path_sum() {
let grid = vec![vec![1, 3, 1], vec![1, 5, 1], vec![4, 2, 1]];
assert_eq!(Solution::min_path_sum(grid), 7);
}
}
| min_path_sum | identifier_name |
no_0064_minimum_path_sum.rs | struct Solution;
impl Solution {
pub fn min_path_sum(grid: Vec<Vec<i32>>) -> i32 | arr[n - 1]
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_min_path_sum() {
let grid = vec![vec![1, 3, 1], vec![1, 5, 1], vec![4, 2, 1]];
assert_eq!(Solution::min_path_sum(grid), 7);
}
}
| {
if grid.is_empty() {
return 0;
}
let (m, n) = (grid.len(), grid[0].len());
let mut arr = vec![std::i32::MAX; n];
arr[0] = 0;
for i in 0..m {
for j in 0..n {
// 选择上面(arr[j])和左面(arr[j-1])最小的那个
if j == 0 {
// 左边没有，只有上面的元素
arr[j] = arr[j] + grid[i][j];
} else {
// 有左边和上边
arr[j] = arr[j].min(arr[j - 1]) + grid[i][j];
}
}
}
| identifier_body |
no_0064_minimum_path_sum.rs | struct Solution;
impl Solution {
pub fn min_path_sum(grid: Vec<Vec<i32>>) -> i32 {
if grid.is_empty() |
let (m, n) = (grid.len(), grid[0].len());
let mut arr = vec![std::i32::MAX; n];
arr[0] = 0;
for i in 0..m {
for j in 0..n {
// 选择上面(arr[j])和左面(arr[j-1])最小的那个
if j == 0 {
// 左边没有，只有上面的元素
arr[j] = arr[j] + grid[i][j];
} else {
// 有左边和上边
arr[j] = arr[j].min(arr[j - 1]) + grid[i][j];
}
}
}
arr[n - 1]
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_min_path_sum() {
let grid = vec![vec![1, 3, 1], vec![1, 5, 1], vec![4, 2, 1]];
assert_eq!(Solution::min_path_sum(grid), 7);
}
}
| {
return 0;
} | conditional_block |
issue-59494.rs | fn | <A, B, C>(f: impl Fn(B) -> C, g: impl Fn(A) -> B) -> impl Fn(A) -> C {
move |a: A| -> C { f(g(a)) }
}
fn t8n<A, B, C>(f: impl Fn(A) -> B, g: impl Fn(A) -> C) -> impl Fn(A) -> (B, C)
where
A: Copy,
{
move |a: A| -> (B, C) {
let b = a;
let fa = f(a);
let ga = g(b);
(fa, ga)
}
}
fn main() {
let f = |(_, _)| {};
let g = |(a, _)| a;
let t7 = |env| |a| |b| t7p(f, g)(((env, a), b));
let t8 = t8n(t7, t7p(f, g));
//~^ ERROR: expected a `Fn<(_,)>` closure, found `impl Fn<(((_, _), _),)>
}
| t7p | identifier_name |
issue-59494.rs | fn t7p<A, B, C>(f: impl Fn(B) -> C, g: impl Fn(A) -> B) -> impl Fn(A) -> C |
fn t8n<A, B, C>(f: impl Fn(A) -> B, g: impl Fn(A) -> C) -> impl Fn(A) -> (B, C)
where
A: Copy,
{
move |a: A| -> (B, C) {
let b = a;
let fa = f(a);
let ga = g(b);
(fa, ga)
}
}
fn main() {
let f = |(_, _)| {};
let g = |(a, _)| a;
let t7 = |env| |a| |b| t7p(f, g)(((env, a), b));
let t8 = t8n(t7, t7p(f, g));
//~^ ERROR: expected a `Fn<(_,)>` closure, found `impl Fn<(((_, _), _),)>
}
| {
move |a: A| -> C { f(g(a)) }
} | identifier_body |
issue-59494.rs | fn t7p<A, B, C>(f: impl Fn(B) -> C, g: impl Fn(A) -> B) -> impl Fn(A) -> C {
move |a: A| -> C { f(g(a)) }
}
fn t8n<A, B, C>(f: impl Fn(A) -> B, g: impl Fn(A) -> C) -> impl Fn(A) -> (B, C)
where
A: Copy,
{
move |a: A| -> (B, C) {
let b = a;
let fa = f(a);
let ga = g(b);
(fa, ga)
}
}
fn main() { | let g = |(a, _)| a;
let t7 = |env| |a| |b| t7p(f, g)(((env, a), b));
let t8 = t8n(t7, t7p(f, g));
//~^ ERROR: expected a `Fn<(_,)>` closure, found `impl Fn<(((_, _), _),)>
} | let f = |(_, _)| {}; | random_line_split |
bst.rs | // Copyright 2020 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use log::debug;
#[derive(Debug)]
struct Node<T> {
v: T,
left: NodePtr<T>,
right: NodePtr<T>,
}
type NodePtr<T> = Option<Box<Node<T>>>;
#[derive(Debug)]
pub struct BinarySearchTree<T> {
root: NodePtr<T>,
}
impl<T> Node<T> {
fn new(v: T) -> NodePtr<T> {
Some(Box::new(Self {
v,
left: None,
right: None,
}))
}
}
impl<T> BinarySearchTree<T> {
pub fn new() -> Self {
Self { root: None }
}
fn find_slot(&mut self, v: &T) -> &mut NodePtr<T>
where
T: Ord,
{
let mut current = &mut self.root;
while current.is_some() {
if ¤t.as_ref().unwrap().v == v {
break;
}
use std::cmp::Ordering;
let inner = current.as_mut().unwrap();
match v.cmp(&inner.v) {
Ordering::Less => current = &mut inner.left,
Ordering::Greater => current = &mut inner.right,
Ordering::Equal => unreachable!(),
}
}
current
}
pub fn insert(&mut self, v: T)
where
T: Ord,
{
let slot = self.find_slot(&v);
if slot.is_none() {
*slot = Node::new(v);
}
}
pub fn contains(&self, v: &T) -> bool
where
T: Ord + std::fmt::Debug,
{
let mut current = &self.root;
while let Some(inner) = current {
debug!("Stepping through {:?}", inner.v);
use std::cmp::Ordering;
match v.cmp(&inner.v) {
Ordering::Less => current = &inner.left,
Ordering::Greater => current = &inner.right,
Ordering::Equal => return true,
}
}
false
}
}
impl<T: Ord> std::iter::FromIterator<T> for BinarySearchTree<T> {
fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
let mut tree = BinarySearchTree::default();
tree.extend(iter);
tree
}
}
impl<T> Default for BinarySearchTree<T> {
fn default() -> Self {
Self::new()
}
}
impl<T: Ord> std::iter::Extend<T> for BinarySearchTree<T> {
fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
for i in iter {
self.insert(i);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test] | let mut x = BinarySearchTree::new();
x.insert(5);
x.insert(6);
assert!(x.contains(&5));
assert!(x.contains(&6));
assert!(!x.contains(&7));
}
#[test]
fn test_structure() {
let mut x = BinarySearchTree::new();
x.insert(10);
x.insert(15);
x.insert(17);
x.insert(13);
x.insert(5);
assert!(x.root.as_ref().unwrap().v == 10);
assert!(x.root.as_ref().unwrap().left.as_ref().unwrap().v == 5);
assert!(x.root.as_ref().unwrap().right.as_ref().unwrap().v == 15);
assert!(
x.root
.as_ref()
.unwrap()
.right
.as_ref()
.unwrap()
.left
.as_ref()
.unwrap()
.v
== 13
);
assert!(
x.root
.as_ref()
.unwrap()
.right
.as_ref()
.unwrap()
.right
.as_ref()
.unwrap()
.v
== 17
);
}
} | fn test_insert_contains() { | random_line_split |
bst.rs | // Copyright 2020 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use log::debug;
#[derive(Debug)]
struct | <T> {
v: T,
left: NodePtr<T>,
right: NodePtr<T>,
}
type NodePtr<T> = Option<Box<Node<T>>>;
#[derive(Debug)]
pub struct BinarySearchTree<T> {
root: NodePtr<T>,
}
impl<T> Node<T> {
fn new(v: T) -> NodePtr<T> {
Some(Box::new(Self {
v,
left: None,
right: None,
}))
}
}
impl<T> BinarySearchTree<T> {
pub fn new() -> Self {
Self { root: None }
}
fn find_slot(&mut self, v: &T) -> &mut NodePtr<T>
where
T: Ord,
{
let mut current = &mut self.root;
while current.is_some() {
if ¤t.as_ref().unwrap().v == v {
break;
}
use std::cmp::Ordering;
let inner = current.as_mut().unwrap();
match v.cmp(&inner.v) {
Ordering::Less => current = &mut inner.left,
Ordering::Greater => current = &mut inner.right,
Ordering::Equal => unreachable!(),
}
}
current
}
pub fn insert(&mut self, v: T)
where
T: Ord,
{
let slot = self.find_slot(&v);
if slot.is_none() {
*slot = Node::new(v);
}
}
pub fn contains(&self, v: &T) -> bool
where
T: Ord + std::fmt::Debug,
{
let mut current = &self.root;
while let Some(inner) = current {
debug!("Stepping through {:?}", inner.v);
use std::cmp::Ordering;
match v.cmp(&inner.v) {
Ordering::Less => current = &inner.left,
Ordering::Greater => current = &inner.right,
Ordering::Equal => return true,
}
}
false
}
}
impl<T: Ord> std::iter::FromIterator<T> for BinarySearchTree<T> {
fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
let mut tree = BinarySearchTree::default();
tree.extend(iter);
tree
}
}
impl<T> Default for BinarySearchTree<T> {
fn default() -> Self {
Self::new()
}
}
impl<T: Ord> std::iter::Extend<T> for BinarySearchTree<T> {
fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
for i in iter {
self.insert(i);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_insert_contains() {
let mut x = BinarySearchTree::new();
x.insert(5);
x.insert(6);
assert!(x.contains(&5));
assert!(x.contains(&6));
assert!(!x.contains(&7));
}
#[test]
fn test_structure() {
let mut x = BinarySearchTree::new();
x.insert(10);
x.insert(15);
x.insert(17);
x.insert(13);
x.insert(5);
assert!(x.root.as_ref().unwrap().v == 10);
assert!(x.root.as_ref().unwrap().left.as_ref().unwrap().v == 5);
assert!(x.root.as_ref().unwrap().right.as_ref().unwrap().v == 15);
assert!(
x.root
.as_ref()
.unwrap()
.right
.as_ref()
.unwrap()
.left
.as_ref()
.unwrap()
.v
== 13
);
assert!(
x.root
.as_ref()
.unwrap()
.right
.as_ref()
.unwrap()
.right
.as_ref()
.unwrap()
.v
== 17
);
}
}
| Node | identifier_name |
bst.rs | // Copyright 2020 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use log::debug;
#[derive(Debug)]
struct Node<T> {
v: T,
left: NodePtr<T>,
right: NodePtr<T>,
}
type NodePtr<T> = Option<Box<Node<T>>>;
#[derive(Debug)]
pub struct BinarySearchTree<T> {
root: NodePtr<T>,
}
impl<T> Node<T> {
fn new(v: T) -> NodePtr<T> {
Some(Box::new(Self {
v,
left: None,
right: None,
}))
}
}
impl<T> BinarySearchTree<T> {
pub fn new() -> Self {
Self { root: None }
}
fn find_slot(&mut self, v: &T) -> &mut NodePtr<T>
where
T: Ord,
|
pub fn insert(&mut self, v: T)
where
T: Ord,
{
let slot = self.find_slot(&v);
if slot.is_none() {
*slot = Node::new(v);
}
}
pub fn contains(&self, v: &T) -> bool
where
T: Ord + std::fmt::Debug,
{
let mut current = &self.root;
while let Some(inner) = current {
debug!("Stepping through {:?}", inner.v);
use std::cmp::Ordering;
match v.cmp(&inner.v) {
Ordering::Less => current = &inner.left,
Ordering::Greater => current = &inner.right,
Ordering::Equal => return true,
}
}
false
}
}
impl<T: Ord> std::iter::FromIterator<T> for BinarySearchTree<T> {
fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
let mut tree = BinarySearchTree::default();
tree.extend(iter);
tree
}
}
impl<T> Default for BinarySearchTree<T> {
fn default() -> Self {
Self::new()
}
}
impl<T: Ord> std::iter::Extend<T> for BinarySearchTree<T> {
fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
for i in iter {
self.insert(i);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_insert_contains() {
let mut x = BinarySearchTree::new();
x.insert(5);
x.insert(6);
assert!(x.contains(&5));
assert!(x.contains(&6));
assert!(!x.contains(&7));
}
#[test]
fn test_structure() {
let mut x = BinarySearchTree::new();
x.insert(10);
x.insert(15);
x.insert(17);
x.insert(13);
x.insert(5);
assert!(x.root.as_ref().unwrap().v == 10);
assert!(x.root.as_ref().unwrap().left.as_ref().unwrap().v == 5);
assert!(x.root.as_ref().unwrap().right.as_ref().unwrap().v == 15);
assert!(
x.root
.as_ref()
.unwrap()
.right
.as_ref()
.unwrap()
.left
.as_ref()
.unwrap()
.v
== 13
);
assert!(
x.root
.as_ref()
.unwrap()
.right
.as_ref()
.unwrap()
.right
.as_ref()
.unwrap()
.v
== 17
);
}
}
| {
let mut current = &mut self.root;
while current.is_some() {
if ¤t.as_ref().unwrap().v == v {
break;
}
use std::cmp::Ordering;
let inner = current.as_mut().unwrap();
match v.cmp(&inner.v) {
Ordering::Less => current = &mut inner.left,
Ordering::Greater => current = &mut inner.right,
Ordering::Equal => unreachable!(),
}
}
current
} | identifier_body |
mod.rs | // This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
mod bindings;
use std::{collections::HashMap, ffi::CString, io};
use log::Record;
use crate::stratis::{StratisError, StratisResult};
fn serialize_pairs(pairs: HashMap<String, String>) -> String |
/// Notify systemd that a daemon has started.
#[allow(clippy::implicit_hasher)]
pub fn notify(unset_variable: bool, key_value_pairs: HashMap<String, String>) -> StratisResult<()> {
let serialized_pairs = serialize_pairs(key_value_pairs);
let cstring = CString::new(serialized_pairs)?;
let ret = unsafe { bindings::sd_notify(libc::c_int::from(unset_variable), cstring.as_ptr()) };
if ret < 0 {
Err(StratisError::Io(io::Error::from_raw_os_error(-ret)))
} else {
Ok(())
}
}
/// Send a message to the system log generated from the Rust log crate Record input.
pub fn syslog(record: &Record<'_>) {
let cstring = match CString::new(record.args().to_string()) {
Ok(s) => s,
Err(_) => return,
};
unsafe { bindings::syslog(record.level() as libc::c_int, cstring.as_ptr()) }
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_key_value_pair_serialization() {
let mut hash_map = HashMap::new();
hash_map.insert("READY".to_string(), "1".to_string());
assert_eq!("READY=1\n".to_string(), serialize_pairs(hash_map));
}
}
| {
pairs
.iter()
.map(|(key, value)| format!("{}={}", key, value))
.fold(String::new(), |mut string, key_value_pair| {
string += key_value_pair.as_str();
string += "\n";
string
})
} | identifier_body |
mod.rs | // This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
mod bindings;
use std::{collections::HashMap, ffi::CString, io}; | use log::Record;
use crate::stratis::{StratisError, StratisResult};
fn serialize_pairs(pairs: HashMap<String, String>) -> String {
pairs
.iter()
.map(|(key, value)| format!("{}={}", key, value))
.fold(String::new(), |mut string, key_value_pair| {
string += key_value_pair.as_str();
string += "\n";
string
})
}
/// Notify systemd that a daemon has started.
#[allow(clippy::implicit_hasher)]
pub fn notify(unset_variable: bool, key_value_pairs: HashMap<String, String>) -> StratisResult<()> {
let serialized_pairs = serialize_pairs(key_value_pairs);
let cstring = CString::new(serialized_pairs)?;
let ret = unsafe { bindings::sd_notify(libc::c_int::from(unset_variable), cstring.as_ptr()) };
if ret < 0 {
Err(StratisError::Io(io::Error::from_raw_os_error(-ret)))
} else {
Ok(())
}
}
/// Send a message to the system log generated from the Rust log crate Record input.
pub fn syslog(record: &Record<'_>) {
let cstring = match CString::new(record.args().to_string()) {
Ok(s) => s,
Err(_) => return,
};
unsafe { bindings::syslog(record.level() as libc::c_int, cstring.as_ptr()) }
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_key_value_pair_serialization() {
let mut hash_map = HashMap::new();
hash_map.insert("READY".to_string(), "1".to_string());
assert_eq!("READY=1\n".to_string(), serialize_pairs(hash_map));
}
} | random_line_split |
|
mod.rs | // This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
mod bindings;
use std::{collections::HashMap, ffi::CString, io};
use log::Record;
use crate::stratis::{StratisError, StratisResult};
fn | (pairs: HashMap<String, String>) -> String {
pairs
.iter()
.map(|(key, value)| format!("{}={}", key, value))
.fold(String::new(), |mut string, key_value_pair| {
string += key_value_pair.as_str();
string += "\n";
string
})
}
/// Notify systemd that a daemon has started.
#[allow(clippy::implicit_hasher)]
pub fn notify(unset_variable: bool, key_value_pairs: HashMap<String, String>) -> StratisResult<()> {
let serialized_pairs = serialize_pairs(key_value_pairs);
let cstring = CString::new(serialized_pairs)?;
let ret = unsafe { bindings::sd_notify(libc::c_int::from(unset_variable), cstring.as_ptr()) };
if ret < 0 {
Err(StratisError::Io(io::Error::from_raw_os_error(-ret)))
} else {
Ok(())
}
}
/// Send a message to the system log generated from the Rust log crate Record input.
pub fn syslog(record: &Record<'_>) {
let cstring = match CString::new(record.args().to_string()) {
Ok(s) => s,
Err(_) => return,
};
unsafe { bindings::syslog(record.level() as libc::c_int, cstring.as_ptr()) }
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_key_value_pair_serialization() {
let mut hash_map = HashMap::new();
hash_map.insert("READY".to_string(), "1".to_string());
assert_eq!("READY=1\n".to_string(), serialize_pairs(hash_map));
}
}
| serialize_pairs | identifier_name |
message.rs | /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use {OpaqueStyleAndLayoutData, PendingImage, TrustedNodeAddress};
use app_units::Au;
use euclid::{Point2D, Rect};
use gfx_traits::Epoch;
use ipc_channel::ipc::{IpcReceiver, IpcSender};
use metrics::PaintTimeMetrics;
use msg::constellation_msg::PipelineId;
use net_traits::image_cache::ImageCache;
use profile_traits::mem::ReportsChan;
use rpc::LayoutRPC;
use script_traits::{ConstellationControlMsg, LayoutControlMsg, LayoutMsg as ConstellationMsg};
use script_traits::{ScrollState, UntrustedNodeAddress, WindowSizeData};
use script_traits::Painter;
use servo_arc::Arc as ServoArc;
use servo_atoms::Atom;
use servo_channel::{Receiver, Sender};
use servo_url::ServoUrl;
use std::sync::Arc;
use style::context::QuirksMode;
use style::properties::PropertyId;
use style::selector_parser::PseudoElement;
use style::stylesheets::Stylesheet;
/// Asynchronous messages that script can send to layout.
pub enum Msg {
/// Adds the given stylesheet to the document. The second stylesheet is the
/// insertion point (if it exists, the sheet needs to be inserted before
/// it).
AddStylesheet(ServoArc<Stylesheet>, Option<ServoArc<Stylesheet>>),
/// Removes a stylesheet from the document.
RemoveStylesheet(ServoArc<Stylesheet>),
/// Change the quirks mode.
SetQuirksMode(QuirksMode),
/// Requests a reflow.
Reflow(ScriptReflow),
/// Get an RPC interface.
GetRPC(Sender<Box<LayoutRPC + Send>>),
/// Requests that the layout thread render the next frame of all animations.
TickAnimations,
/// Updates layout's timer for animation testing from script.
///
/// The inner field is the number of *milliseconds* to advance, and the bool
/// field is whether animations should be force-ticked.
AdvanceClockMs(i32, bool),
/// Destroys layout data associated with a DOM node.
///
/// TODO(pcwalton): Maybe think about batching to avoid message traffic.
ReapStyleAndLayoutData(OpaqueStyleAndLayoutData),
/// Requests that the layout thread measure its memory usage. The resulting reports are sent back
/// via the supplied channel.
CollectReports(ReportsChan),
/// Requests that the layout thread enter a quiescent state in which no more messages are
/// accepted except `ExitMsg`. A response message will be sent on the supplied channel when
/// this happens.
PrepareToExit(Sender<()>),
/// Requests that the layout thread immediately shut down. There must be no more nodes left after
/// this, or layout will crash.
ExitNow,
/// Get the last epoch counter for this layout thread.
GetCurrentEpoch(IpcSender<Epoch>),
/// Asks the layout thread whether any Web fonts have yet to load (if true, loads are pending;
/// false otherwise).
GetWebFontLoadState(IpcSender<bool>),
/// Creates a new layout thread.
///
/// This basically exists to keep the script-layout dependency one-way.
CreateLayoutThread(NewLayoutThreadInfo),
/// Set the final Url.
SetFinalUrl(ServoUrl),
/// Tells layout about the new scrolling offsets of each scrollable stacking context.
SetScrollStates(Vec<ScrollState>),
/// Tells layout about a single new scrolling offset from the script. The rest will
/// remain untouched and layout won't forward this back to script.
UpdateScrollStateFromScript(ScrollState),
/// Tells layout that script has added some paint worklet modules.
RegisterPaint(Atom, Vec<Atom>, Box<Painter>),
/// Send to layout the precise time when the navigation started.
SetNavigationStart(u64),
}
#[derive(Debug, PartialEq)]
pub enum NodesFromPointQueryType {
All,
Topmost,
}
#[derive(Debug, PartialEq)]
pub enum QueryMsg {
ContentBoxQuery(TrustedNodeAddress),
ContentBoxesQuery(TrustedNodeAddress),
NodeScrollIdQuery(TrustedNodeAddress),
NodeGeometryQuery(TrustedNodeAddress),
NodeScrollGeometryQuery(TrustedNodeAddress),
ResolvedStyleQuery(TrustedNodeAddress, Option<PseudoElement>, PropertyId),
OffsetParentQuery(TrustedNodeAddress),
StyleQuery(TrustedNodeAddress),
TextIndexQuery(TrustedNodeAddress, Point2D<f32>),
NodesFromPointQuery(Point2D<f32>, NodesFromPointQueryType),
ElementInnerTextQuery(TrustedNodeAddress),
}
/// Any query to perform with this reflow.
#[derive(Debug, PartialEq)]
pub enum ReflowGoal {
Full,
TickAnimations,
LayoutQuery(QueryMsg, u64),
}
impl ReflowGoal {
/// Returns true if the given ReflowQuery needs a full, up-to-date display list to
/// be present or false if it only needs stacking-relative positions.
pub fn needs_display_list(&self) -> bool {
match *self {
ReflowGoal::Full | ReflowGoal::TickAnimations => true,
ReflowGoal::LayoutQuery(ref querymsg, _) => match querymsg {
&QueryMsg::NodesFromPointQuery(..) |
&QueryMsg::TextIndexQuery(..) |
&QueryMsg::ElementInnerTextQuery(_) => true,
&QueryMsg::ContentBoxQuery(_) |
&QueryMsg::ContentBoxesQuery(_) |
&QueryMsg::NodeGeometryQuery(_) |
&QueryMsg::NodeScrollGeometryQuery(_) |
&QueryMsg::NodeScrollIdQuery(_) |
&QueryMsg::ResolvedStyleQuery(..) |
&QueryMsg::OffsetParentQuery(_) |
&QueryMsg::StyleQuery(_) => false,
},
}
}
/// Returns true if the given ReflowQuery needs its display list send to WebRender or
/// false if a layout_thread display list is sufficient.
pub fn needs_display(&self) -> bool {
match *self {
ReflowGoal::Full | ReflowGoal::TickAnimations => true,
ReflowGoal::LayoutQuery(ref querymsg, _) => match querymsg {
&QueryMsg::NodesFromPointQuery(..) |
&QueryMsg::TextIndexQuery(..) |
&QueryMsg::ElementInnerTextQuery(_) => true,
&QueryMsg::ContentBoxQuery(_) |
&QueryMsg::ContentBoxesQuery(_) |
&QueryMsg::NodeGeometryQuery(_) |
&QueryMsg::NodeScrollGeometryQuery(_) |
&QueryMsg::NodeScrollIdQuery(_) |
&QueryMsg::ResolvedStyleQuery(..) |
&QueryMsg::OffsetParentQuery(_) |
&QueryMsg::StyleQuery(_) => false,
},
}
}
}
/// Information needed for a reflow.
pub struct Reflow {
/// A clipping rectangle for the page, an enlarged rectangle containing the viewport.
pub page_clip_rect: Rect<Au>,
}
/// Information derived from a layout pass that needs to be returned to the script thread.
#[derive(Default)]
pub struct ReflowComplete {
/// The list of images that were encountered that are in progress.
pub pending_images: Vec<PendingImage>,
/// The list of nodes that initiated a CSS transition.
pub newly_transitioning_nodes: Vec<UntrustedNodeAddress>,
}
/// Information needed for a script-initiated reflow.
pub struct ScriptReflow {
/// General reflow data.
pub reflow_info: Reflow,
/// The document node.
pub document: TrustedNodeAddress,
/// Whether the document's stylesheets have changed since the last script reflow.
pub stylesheets_changed: bool,
/// The current window size.
pub window_size: WindowSizeData,
/// The channel that we send a notification to.
pub script_join_chan: Sender<ReflowComplete>,
/// The goal of this reflow.
pub reflow_goal: ReflowGoal,
/// The number of objects in the dom #10110
pub dom_count: u32,
}
pub struct | {
pub id: PipelineId,
pub url: ServoUrl,
pub is_parent: bool,
pub layout_pair: (Sender<Msg>, Receiver<Msg>),
pub pipeline_port: IpcReceiver<LayoutControlMsg>,
pub constellation_chan: IpcSender<ConstellationMsg>,
pub script_chan: IpcSender<ConstellationControlMsg>,
pub image_cache: Arc<ImageCache>,
pub content_process_shutdown_chan: Option<IpcSender<()>>,
pub layout_threads: usize,
pub paint_time_metrics: PaintTimeMetrics,
}
| NewLayoutThreadInfo | identifier_name |
message.rs | /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use {OpaqueStyleAndLayoutData, PendingImage, TrustedNodeAddress};
use app_units::Au;
use euclid::{Point2D, Rect};
use gfx_traits::Epoch;
use ipc_channel::ipc::{IpcReceiver, IpcSender};
use metrics::PaintTimeMetrics;
use msg::constellation_msg::PipelineId;
use net_traits::image_cache::ImageCache;
use profile_traits::mem::ReportsChan;
use rpc::LayoutRPC;
use script_traits::{ConstellationControlMsg, LayoutControlMsg, LayoutMsg as ConstellationMsg}; | use script_traits::{ScrollState, UntrustedNodeAddress, WindowSizeData};
use script_traits::Painter;
use servo_arc::Arc as ServoArc;
use servo_atoms::Atom;
use servo_channel::{Receiver, Sender};
use servo_url::ServoUrl;
use std::sync::Arc;
use style::context::QuirksMode;
use style::properties::PropertyId;
use style::selector_parser::PseudoElement;
use style::stylesheets::Stylesheet;
/// Asynchronous messages that script can send to layout.
pub enum Msg {
/// Adds the given stylesheet to the document. The second stylesheet is the
/// insertion point (if it exists, the sheet needs to be inserted before
/// it).
AddStylesheet(ServoArc<Stylesheet>, Option<ServoArc<Stylesheet>>),
/// Removes a stylesheet from the document.
RemoveStylesheet(ServoArc<Stylesheet>),
/// Change the quirks mode.
SetQuirksMode(QuirksMode),
/// Requests a reflow.
Reflow(ScriptReflow),
/// Get an RPC interface.
GetRPC(Sender<Box<LayoutRPC + Send>>),
/// Requests that the layout thread render the next frame of all animations.
TickAnimations,
/// Updates layout's timer for animation testing from script.
///
/// The inner field is the number of *milliseconds* to advance, and the bool
/// field is whether animations should be force-ticked.
AdvanceClockMs(i32, bool),
/// Destroys layout data associated with a DOM node.
///
/// TODO(pcwalton): Maybe think about batching to avoid message traffic.
ReapStyleAndLayoutData(OpaqueStyleAndLayoutData),
/// Requests that the layout thread measure its memory usage. The resulting reports are sent back
/// via the supplied channel.
CollectReports(ReportsChan),
/// Requests that the layout thread enter a quiescent state in which no more messages are
/// accepted except `ExitMsg`. A response message will be sent on the supplied channel when
/// this happens.
PrepareToExit(Sender<()>),
/// Requests that the layout thread immediately shut down. There must be no more nodes left after
/// this, or layout will crash.
ExitNow,
/// Get the last epoch counter for this layout thread.
GetCurrentEpoch(IpcSender<Epoch>),
/// Asks the layout thread whether any Web fonts have yet to load (if true, loads are pending;
/// false otherwise).
GetWebFontLoadState(IpcSender<bool>),
/// Creates a new layout thread.
///
/// This basically exists to keep the script-layout dependency one-way.
CreateLayoutThread(NewLayoutThreadInfo),
/// Set the final Url.
SetFinalUrl(ServoUrl),
/// Tells layout about the new scrolling offsets of each scrollable stacking context.
SetScrollStates(Vec<ScrollState>),
/// Tells layout about a single new scrolling offset from the script. The rest will
/// remain untouched and layout won't forward this back to script.
UpdateScrollStateFromScript(ScrollState),
/// Tells layout that script has added some paint worklet modules.
RegisterPaint(Atom, Vec<Atom>, Box<Painter>),
/// Send to layout the precise time when the navigation started.
SetNavigationStart(u64),
}
#[derive(Debug, PartialEq)]
pub enum NodesFromPointQueryType {
All,
Topmost,
}
#[derive(Debug, PartialEq)]
pub enum QueryMsg {
ContentBoxQuery(TrustedNodeAddress),
ContentBoxesQuery(TrustedNodeAddress),
NodeScrollIdQuery(TrustedNodeAddress),
NodeGeometryQuery(TrustedNodeAddress),
NodeScrollGeometryQuery(TrustedNodeAddress),
ResolvedStyleQuery(TrustedNodeAddress, Option<PseudoElement>, PropertyId),
OffsetParentQuery(TrustedNodeAddress),
StyleQuery(TrustedNodeAddress),
TextIndexQuery(TrustedNodeAddress, Point2D<f32>),
NodesFromPointQuery(Point2D<f32>, NodesFromPointQueryType),
ElementInnerTextQuery(TrustedNodeAddress),
}
/// Any query to perform with this reflow.
#[derive(Debug, PartialEq)]
pub enum ReflowGoal {
Full,
TickAnimations,
LayoutQuery(QueryMsg, u64),
}
impl ReflowGoal {
/// Returns true if the given ReflowQuery needs a full, up-to-date display list to
/// be present or false if it only needs stacking-relative positions.
pub fn needs_display_list(&self) -> bool {
match *self {
ReflowGoal::Full | ReflowGoal::TickAnimations => true,
ReflowGoal::LayoutQuery(ref querymsg, _) => match querymsg {
&QueryMsg::NodesFromPointQuery(..) |
&QueryMsg::TextIndexQuery(..) |
&QueryMsg::ElementInnerTextQuery(_) => true,
&QueryMsg::ContentBoxQuery(_) |
&QueryMsg::ContentBoxesQuery(_) |
&QueryMsg::NodeGeometryQuery(_) |
&QueryMsg::NodeScrollGeometryQuery(_) |
&QueryMsg::NodeScrollIdQuery(_) |
&QueryMsg::ResolvedStyleQuery(..) |
&QueryMsg::OffsetParentQuery(_) |
&QueryMsg::StyleQuery(_) => false,
},
}
}
/// Returns true if the given ReflowQuery needs its display list send to WebRender or
/// false if a layout_thread display list is sufficient.
pub fn needs_display(&self) -> bool {
match *self {
ReflowGoal::Full | ReflowGoal::TickAnimations => true,
ReflowGoal::LayoutQuery(ref querymsg, _) => match querymsg {
&QueryMsg::NodesFromPointQuery(..) |
&QueryMsg::TextIndexQuery(..) |
&QueryMsg::ElementInnerTextQuery(_) => true,
&QueryMsg::ContentBoxQuery(_) |
&QueryMsg::ContentBoxesQuery(_) |
&QueryMsg::NodeGeometryQuery(_) |
&QueryMsg::NodeScrollGeometryQuery(_) |
&QueryMsg::NodeScrollIdQuery(_) |
&QueryMsg::ResolvedStyleQuery(..) |
&QueryMsg::OffsetParentQuery(_) |
&QueryMsg::StyleQuery(_) => false,
},
}
}
}
/// Information needed for a reflow.
pub struct Reflow {
/// A clipping rectangle for the page, an enlarged rectangle containing the viewport.
pub page_clip_rect: Rect<Au>,
}
/// Information derived from a layout pass that needs to be returned to the script thread.
#[derive(Default)]
pub struct ReflowComplete {
/// The list of images that were encountered that are in progress.
pub pending_images: Vec<PendingImage>,
/// The list of nodes that initiated a CSS transition.
pub newly_transitioning_nodes: Vec<UntrustedNodeAddress>,
}
/// Information needed for a script-initiated reflow.
pub struct ScriptReflow {
/// General reflow data.
pub reflow_info: Reflow,
/// The document node.
pub document: TrustedNodeAddress,
/// Whether the document's stylesheets have changed since the last script reflow.
pub stylesheets_changed: bool,
/// The current window size.
pub window_size: WindowSizeData,
/// The channel that we send a notification to.
pub script_join_chan: Sender<ReflowComplete>,
/// The goal of this reflow.
pub reflow_goal: ReflowGoal,
/// The number of objects in the dom #10110
pub dom_count: u32,
}
pub struct NewLayoutThreadInfo {
pub id: PipelineId,
pub url: ServoUrl,
pub is_parent: bool,
pub layout_pair: (Sender<Msg>, Receiver<Msg>),
pub pipeline_port: IpcReceiver<LayoutControlMsg>,
pub constellation_chan: IpcSender<ConstellationMsg>,
pub script_chan: IpcSender<ConstellationControlMsg>,
pub image_cache: Arc<ImageCache>,
pub content_process_shutdown_chan: Option<IpcSender<()>>,
pub layout_threads: usize,
pub paint_time_metrics: PaintTimeMetrics,
} | random_line_split |
|
message.rs | /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use {OpaqueStyleAndLayoutData, PendingImage, TrustedNodeAddress};
use app_units::Au;
use euclid::{Point2D, Rect};
use gfx_traits::Epoch;
use ipc_channel::ipc::{IpcReceiver, IpcSender};
use metrics::PaintTimeMetrics;
use msg::constellation_msg::PipelineId;
use net_traits::image_cache::ImageCache;
use profile_traits::mem::ReportsChan;
use rpc::LayoutRPC;
use script_traits::{ConstellationControlMsg, LayoutControlMsg, LayoutMsg as ConstellationMsg};
use script_traits::{ScrollState, UntrustedNodeAddress, WindowSizeData};
use script_traits::Painter;
use servo_arc::Arc as ServoArc;
use servo_atoms::Atom;
use servo_channel::{Receiver, Sender};
use servo_url::ServoUrl;
use std::sync::Arc;
use style::context::QuirksMode;
use style::properties::PropertyId;
use style::selector_parser::PseudoElement;
use style::stylesheets::Stylesheet;
/// Asynchronous messages that script can send to layout.
pub enum Msg {
/// Adds the given stylesheet to the document. The second stylesheet is the
/// insertion point (if it exists, the sheet needs to be inserted before
/// it).
AddStylesheet(ServoArc<Stylesheet>, Option<ServoArc<Stylesheet>>),
/// Removes a stylesheet from the document.
RemoveStylesheet(ServoArc<Stylesheet>),
/// Change the quirks mode.
SetQuirksMode(QuirksMode),
/// Requests a reflow.
Reflow(ScriptReflow),
/// Get an RPC interface.
GetRPC(Sender<Box<LayoutRPC + Send>>),
/// Requests that the layout thread render the next frame of all animations.
TickAnimations,
/// Updates layout's timer for animation testing from script.
///
/// The inner field is the number of *milliseconds* to advance, and the bool
/// field is whether animations should be force-ticked.
AdvanceClockMs(i32, bool),
/// Destroys layout data associated with a DOM node.
///
/// TODO(pcwalton): Maybe think about batching to avoid message traffic.
ReapStyleAndLayoutData(OpaqueStyleAndLayoutData),
/// Requests that the layout thread measure its memory usage. The resulting reports are sent back
/// via the supplied channel.
CollectReports(ReportsChan),
/// Requests that the layout thread enter a quiescent state in which no more messages are
/// accepted except `ExitMsg`. A response message will be sent on the supplied channel when
/// this happens.
PrepareToExit(Sender<()>),
/// Requests that the layout thread immediately shut down. There must be no more nodes left after
/// this, or layout will crash.
ExitNow,
/// Get the last epoch counter for this layout thread.
GetCurrentEpoch(IpcSender<Epoch>),
/// Asks the layout thread whether any Web fonts have yet to load (if true, loads are pending;
/// false otherwise).
GetWebFontLoadState(IpcSender<bool>),
/// Creates a new layout thread.
///
/// This basically exists to keep the script-layout dependency one-way.
CreateLayoutThread(NewLayoutThreadInfo),
/// Set the final Url.
SetFinalUrl(ServoUrl),
/// Tells layout about the new scrolling offsets of each scrollable stacking context.
SetScrollStates(Vec<ScrollState>),
/// Tells layout about a single new scrolling offset from the script. The rest will
/// remain untouched and layout won't forward this back to script.
UpdateScrollStateFromScript(ScrollState),
/// Tells layout that script has added some paint worklet modules.
RegisterPaint(Atom, Vec<Atom>, Box<Painter>),
/// Send to layout the precise time when the navigation started.
SetNavigationStart(u64),
}
#[derive(Debug, PartialEq)]
pub enum NodesFromPointQueryType {
All,
Topmost,
}
#[derive(Debug, PartialEq)]
pub enum QueryMsg {
ContentBoxQuery(TrustedNodeAddress),
ContentBoxesQuery(TrustedNodeAddress),
NodeScrollIdQuery(TrustedNodeAddress),
NodeGeometryQuery(TrustedNodeAddress),
NodeScrollGeometryQuery(TrustedNodeAddress),
ResolvedStyleQuery(TrustedNodeAddress, Option<PseudoElement>, PropertyId),
OffsetParentQuery(TrustedNodeAddress),
StyleQuery(TrustedNodeAddress),
TextIndexQuery(TrustedNodeAddress, Point2D<f32>),
NodesFromPointQuery(Point2D<f32>, NodesFromPointQueryType),
ElementInnerTextQuery(TrustedNodeAddress),
}
/// Any query to perform with this reflow.
#[derive(Debug, PartialEq)]
pub enum ReflowGoal {
Full,
TickAnimations,
LayoutQuery(QueryMsg, u64),
}
impl ReflowGoal {
/// Returns true if the given ReflowQuery needs a full, up-to-date display list to
/// be present or false if it only needs stacking-relative positions.
pub fn needs_display_list(&self) -> bool {
match *self {
ReflowGoal::Full | ReflowGoal::TickAnimations => true,
ReflowGoal::LayoutQuery(ref querymsg, _) => match querymsg {
&QueryMsg::NodesFromPointQuery(..) |
&QueryMsg::TextIndexQuery(..) |
&QueryMsg::ElementInnerTextQuery(_) => true,
&QueryMsg::ContentBoxQuery(_) |
&QueryMsg::ContentBoxesQuery(_) |
&QueryMsg::NodeGeometryQuery(_) |
&QueryMsg::NodeScrollGeometryQuery(_) |
&QueryMsg::NodeScrollIdQuery(_) |
&QueryMsg::ResolvedStyleQuery(..) |
&QueryMsg::OffsetParentQuery(_) |
&QueryMsg::StyleQuery(_) => false,
},
}
}
/// Returns true if the given ReflowQuery needs its display list send to WebRender or
/// false if a layout_thread display list is sufficient.
pub fn needs_display(&self) -> bool |
}
/// Information needed for a reflow.
pub struct Reflow {
/// A clipping rectangle for the page, an enlarged rectangle containing the viewport.
pub page_clip_rect: Rect<Au>,
}
/// Information derived from a layout pass that needs to be returned to the script thread.
#[derive(Default)]
pub struct ReflowComplete {
/// The list of images that were encountered that are in progress.
pub pending_images: Vec<PendingImage>,
/// The list of nodes that initiated a CSS transition.
pub newly_transitioning_nodes: Vec<UntrustedNodeAddress>,
}
/// Information needed for a script-initiated reflow.
pub struct ScriptReflow {
/// General reflow data.
pub reflow_info: Reflow,
/// The document node.
pub document: TrustedNodeAddress,
/// Whether the document's stylesheets have changed since the last script reflow.
pub stylesheets_changed: bool,
/// The current window size.
pub window_size: WindowSizeData,
/// The channel that we send a notification to.
pub script_join_chan: Sender<ReflowComplete>,
/// The goal of this reflow.
pub reflow_goal: ReflowGoal,
/// The number of objects in the dom #10110
pub dom_count: u32,
}
pub struct NewLayoutThreadInfo {
pub id: PipelineId,
pub url: ServoUrl,
pub is_parent: bool,
pub layout_pair: (Sender<Msg>, Receiver<Msg>),
pub pipeline_port: IpcReceiver<LayoutControlMsg>,
pub constellation_chan: IpcSender<ConstellationMsg>,
pub script_chan: IpcSender<ConstellationControlMsg>,
pub image_cache: Arc<ImageCache>,
pub content_process_shutdown_chan: Option<IpcSender<()>>,
pub layout_threads: usize,
pub paint_time_metrics: PaintTimeMetrics,
}
| {
match *self {
ReflowGoal::Full | ReflowGoal::TickAnimations => true,
ReflowGoal::LayoutQuery(ref querymsg, _) => match querymsg {
&QueryMsg::NodesFromPointQuery(..) |
&QueryMsg::TextIndexQuery(..) |
&QueryMsg::ElementInnerTextQuery(_) => true,
&QueryMsg::ContentBoxQuery(_) |
&QueryMsg::ContentBoxesQuery(_) |
&QueryMsg::NodeGeometryQuery(_) |
&QueryMsg::NodeScrollGeometryQuery(_) |
&QueryMsg::NodeScrollIdQuery(_) |
&QueryMsg::ResolvedStyleQuery(..) |
&QueryMsg::OffsetParentQuery(_) |
&QueryMsg::StyleQuery(_) => false,
},
}
} | identifier_body |
pin_pt.rs | // Zinc, the bare metal stack for rust.
// Copyright 2014 Vladimir "farcaller" Pouzanov <[email protected]>
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use std::rc::Rc;
use syntax::ext::base::ExtCtxt;
use builder::{Builder, TokenString, add_node_dependency};
use node;
use super::pinmap;
pub fn attach(builder: &mut Builder, _: &mut ExtCtxt, node: Rc<node::Node>) {
node.materializer.set(Some(verify as fn(&mut Builder, &mut ExtCtxt, Rc<node::Node>)));
for port_node in node.subnodes().iter() {
port_node.materializer.set(Some(verify as fn(&mut Builder, &mut ExtCtxt, Rc<node::Node>)));
add_node_dependency(&node, port_node);
for pin_node in port_node.subnodes().iter() {
pin_node.materializer.set(Some(build_pin as fn(&mut Builder, &mut ExtCtxt, Rc<node::Node>)));
add_node_dependency(port_node, pin_node);
super::add_node_dependency_on_clock(builder, pin_node);
}
}
}
pub fn verify(_: &mut Builder, cx: &mut ExtCtxt, node: Rc<node::Node>) {
node.expect_no_attributes(cx);
}
fn build_pin(builder: &mut Builder, cx: &mut ExtCtxt, node: Rc<node::Node>) {
let port_node = node.parent.clone().unwrap().upgrade().unwrap();
let ref port_path = port_node.path;
let port_str = format!("Port{}", match port_path.as_str().parse::<usize>().unwrap() {
0...4 => port_path,
other => {
cx.parse_sess().span_diagnostic.span_err(port_node.path_span,
format!("unknown port `{}`, allowed values: 0...4",
other).as_str());
return;
}
});
let port = TokenString(port_str);
if node.name.is_none() {
cx.parse_sess().span_diagnostic.span_err(node.name_span,
"pin node must have a name");
return;
}
let direction_str = if node.get_string_attr("function").is_some() {
"core::option::Option::None"
} else {
match node.get_string_attr("direction").unwrap().as_str() {
"out" => "core::option::Option::Some(zinc::hal::pin::Out)",
"in" => "core::option::Option::Some(zinc::hal::pin::In)",
other => {
let attr = node.get_attr("direction");
cx.parse_sess().span_diagnostic.span_err(attr.value_span,
format!("unknown direction `{}`, allowed values: `in`, `out`",
other).as_str());
return;
}
}
};
let direction = TokenString(direction_str.to_string());
let pin_str = match node.path.as_str().parse::<usize>().unwrap() {
0...31 => &node.path,
other => {
cx.parse_sess().span_diagnostic.span_err(node.path_span,
format!("unknown pin `{}`, allowed values: 0...31",
other).as_str());
return;
}
};
let port_def = pinmap::port_def();
let function_str = match node.get_string_attr("function") {
None => "Gpio".to_string(),
Some(fun) => {
let pins = &port_def[port_path];
let maybe_pin_index: usize = node.path.as_str().parse().unwrap();
let maybe_pin: &Option<pinmap::PinDef> = pins.get(maybe_pin_index).unwrap();
match maybe_pin {
&None => {
cx.parse_sess().span_diagnostic.span_err(
node.get_attr("function").value_span,
format!("unknown pin function `{}`, only GPIO avaliable on this pin",
fun).as_str());
return;
}
&Some(ref pin_funcs) => {
let maybe_func = pin_funcs.get(&fun); | format!("unknown pin function `{}`, allowed functions: {}",
fun, avaliable.join(", ")).as_str());
return;
},
Some(func_idx) => {
format!("AltFunction{}", func_idx)
}
}
}
}
}
};
let function = TokenString(function_str);
let pin = TokenString(format!("{}u8", pin_str));
let pin_name = TokenString(node.name.clone().unwrap());
node.set_type_name("zinc::hal::lpc43xx::pin::Pin".to_string());
let st = quote_stmt!(&*cx,
let $pin_name = zinc::hal::lpc43xx::pin::Pin::new(
zinc::hal::lpc43xx::pin::Port::$port,
$pin,
zinc::hal::lpc43xx::pin::Function::$function,
$direction);
).unwrap();
builder.add_main_statement(st);
}
#[cfg(test)]
mod test {
use builder::Builder;
use test_helpers::{assert_equal_source, with_parsed};
#[test]
fn builds_input_gpio() {
with_parsed("
gpio {
0 {
p1@1 { direction = \"in\"; }
}
}", |cx, failed, pt| {
let mut builder = Builder::new(pt.clone(), cx);
super::build_pin(&mut builder, cx, pt.get_by_name("p1").unwrap());
assert!(unsafe{*failed} == false);
assert!(builder.main_stmts().len() == 1);
assert_equal_source(&builder.main_stmts()[0],
"let p1 = zinc::hal::lpc43xx::pin::Pin::new(
zinc::hal::lpc43xx::pin::Port::Port0,
1u8,
zinc::hal::lpc43xx::pin::Function::Gpio,
core::option::Option::Some(zinc::hal::pin::In));");
});
}
#[test]
fn builds_output_gpio() {
with_parsed("
gpio {
0 {
p2@2 { direction = \"out\"; }
}
}", |cx, failed, pt| {
let mut builder = Builder::new(pt.clone(), cx);
super::build_pin(&mut builder, cx, pt.get_by_name("p2").unwrap());
assert!(unsafe{*failed} == false);
assert!(builder.main_stmts().len() == 1);
assert_equal_source(&builder.main_stmts()[0],
"let p2 = zinc::hal::lpc43xx::pin::Pin::new(
zinc::hal::lpc43xx::pin::Port::Port0,
2u8,
zinc::hal::lpc43xx::pin::Function::Gpio,
core::option::Option::Some(zinc::hal::pin::Out));");
});
}
#[test]
fn builds_altfn_gpio() {
with_parsed("
gpio {
0 {
p3@3 { direction = \"out\"; function = \"ad0_6\"; }
}
}", |cx, failed, pt| {
let mut builder = Builder::new(pt.clone(), cx);
super::build_pin(&mut builder, cx, pt.get_by_name("p3").unwrap());
assert!(unsafe{*failed} == false);
assert!(builder.main_stmts().len() == 1);
assert_equal_source(&builder.main_stmts()[0],
"let p3 = zinc::hal::lpc43xx::pin::Pin::new(
zinc::hal::lpc43xx::pin::Port::Port0,
3u8,
zinc::hal::lpc43xx::pin::Function::AltFunction2,
core::option::Option::None);");
});
}
} | match maybe_func {
None => {
let avaliable: Vec<String> = pin_funcs.keys().map(|k|{k.to_string()}).collect();
cx.parse_sess().span_diagnostic.span_err(
node.get_attr("function").value_span, | random_line_split |
pin_pt.rs | // Zinc, the bare metal stack for rust.
// Copyright 2014 Vladimir "farcaller" Pouzanov <[email protected]>
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use std::rc::Rc;
use syntax::ext::base::ExtCtxt;
use builder::{Builder, TokenString, add_node_dependency};
use node;
use super::pinmap;
pub fn | (builder: &mut Builder, _: &mut ExtCtxt, node: Rc<node::Node>) {
node.materializer.set(Some(verify as fn(&mut Builder, &mut ExtCtxt, Rc<node::Node>)));
for port_node in node.subnodes().iter() {
port_node.materializer.set(Some(verify as fn(&mut Builder, &mut ExtCtxt, Rc<node::Node>)));
add_node_dependency(&node, port_node);
for pin_node in port_node.subnodes().iter() {
pin_node.materializer.set(Some(build_pin as fn(&mut Builder, &mut ExtCtxt, Rc<node::Node>)));
add_node_dependency(port_node, pin_node);
super::add_node_dependency_on_clock(builder, pin_node);
}
}
}
pub fn verify(_: &mut Builder, cx: &mut ExtCtxt, node: Rc<node::Node>) {
node.expect_no_attributes(cx);
}
fn build_pin(builder: &mut Builder, cx: &mut ExtCtxt, node: Rc<node::Node>) {
let port_node = node.parent.clone().unwrap().upgrade().unwrap();
let ref port_path = port_node.path;
let port_str = format!("Port{}", match port_path.as_str().parse::<usize>().unwrap() {
0...4 => port_path,
other => {
cx.parse_sess().span_diagnostic.span_err(port_node.path_span,
format!("unknown port `{}`, allowed values: 0...4",
other).as_str());
return;
}
});
let port = TokenString(port_str);
if node.name.is_none() {
cx.parse_sess().span_diagnostic.span_err(node.name_span,
"pin node must have a name");
return;
}
let direction_str = if node.get_string_attr("function").is_some() {
"core::option::Option::None"
} else {
match node.get_string_attr("direction").unwrap().as_str() {
"out" => "core::option::Option::Some(zinc::hal::pin::Out)",
"in" => "core::option::Option::Some(zinc::hal::pin::In)",
other => {
let attr = node.get_attr("direction");
cx.parse_sess().span_diagnostic.span_err(attr.value_span,
format!("unknown direction `{}`, allowed values: `in`, `out`",
other).as_str());
return;
}
}
};
let direction = TokenString(direction_str.to_string());
let pin_str = match node.path.as_str().parse::<usize>().unwrap() {
0...31 => &node.path,
other => {
cx.parse_sess().span_diagnostic.span_err(node.path_span,
format!("unknown pin `{}`, allowed values: 0...31",
other).as_str());
return;
}
};
let port_def = pinmap::port_def();
let function_str = match node.get_string_attr("function") {
None => "Gpio".to_string(),
Some(fun) => {
let pins = &port_def[port_path];
let maybe_pin_index: usize = node.path.as_str().parse().unwrap();
let maybe_pin: &Option<pinmap::PinDef> = pins.get(maybe_pin_index).unwrap();
match maybe_pin {
&None => {
cx.parse_sess().span_diagnostic.span_err(
node.get_attr("function").value_span,
format!("unknown pin function `{}`, only GPIO avaliable on this pin",
fun).as_str());
return;
}
&Some(ref pin_funcs) => {
let maybe_func = pin_funcs.get(&fun);
match maybe_func {
None => {
let avaliable: Vec<String> = pin_funcs.keys().map(|k|{k.to_string()}).collect();
cx.parse_sess().span_diagnostic.span_err(
node.get_attr("function").value_span,
format!("unknown pin function `{}`, allowed functions: {}",
fun, avaliable.join(", ")).as_str());
return;
},
Some(func_idx) => {
format!("AltFunction{}", func_idx)
}
}
}
}
}
};
let function = TokenString(function_str);
let pin = TokenString(format!("{}u8", pin_str));
let pin_name = TokenString(node.name.clone().unwrap());
node.set_type_name("zinc::hal::lpc43xx::pin::Pin".to_string());
let st = quote_stmt!(&*cx,
let $pin_name = zinc::hal::lpc43xx::pin::Pin::new(
zinc::hal::lpc43xx::pin::Port::$port,
$pin,
zinc::hal::lpc43xx::pin::Function::$function,
$direction);
).unwrap();
builder.add_main_statement(st);
}
#[cfg(test)]
mod test {
use builder::Builder;
use test_helpers::{assert_equal_source, with_parsed};
#[test]
fn builds_input_gpio() {
with_parsed("
gpio {
0 {
p1@1 { direction = \"in\"; }
}
}", |cx, failed, pt| {
let mut builder = Builder::new(pt.clone(), cx);
super::build_pin(&mut builder, cx, pt.get_by_name("p1").unwrap());
assert!(unsafe{*failed} == false);
assert!(builder.main_stmts().len() == 1);
assert_equal_source(&builder.main_stmts()[0],
"let p1 = zinc::hal::lpc43xx::pin::Pin::new(
zinc::hal::lpc43xx::pin::Port::Port0,
1u8,
zinc::hal::lpc43xx::pin::Function::Gpio,
core::option::Option::Some(zinc::hal::pin::In));");
});
}
#[test]
fn builds_output_gpio() {
with_parsed("
gpio {
0 {
p2@2 { direction = \"out\"; }
}
}", |cx, failed, pt| {
let mut builder = Builder::new(pt.clone(), cx);
super::build_pin(&mut builder, cx, pt.get_by_name("p2").unwrap());
assert!(unsafe{*failed} == false);
assert!(builder.main_stmts().len() == 1);
assert_equal_source(&builder.main_stmts()[0],
"let p2 = zinc::hal::lpc43xx::pin::Pin::new(
zinc::hal::lpc43xx::pin::Port::Port0,
2u8,
zinc::hal::lpc43xx::pin::Function::Gpio,
core::option::Option::Some(zinc::hal::pin::Out));");
});
}
#[test]
fn builds_altfn_gpio() {
with_parsed("
gpio {
0 {
p3@3 { direction = \"out\"; function = \"ad0_6\"; }
}
}", |cx, failed, pt| {
let mut builder = Builder::new(pt.clone(), cx);
super::build_pin(&mut builder, cx, pt.get_by_name("p3").unwrap());
assert!(unsafe{*failed} == false);
assert!(builder.main_stmts().len() == 1);
assert_equal_source(&builder.main_stmts()[0],
"let p3 = zinc::hal::lpc43xx::pin::Pin::new(
zinc::hal::lpc43xx::pin::Port::Port0,
3u8,
zinc::hal::lpc43xx::pin::Function::AltFunction2,
core::option::Option::None);");
});
}
}
| attach | identifier_name |
pin_pt.rs | // Zinc, the bare metal stack for rust.
// Copyright 2014 Vladimir "farcaller" Pouzanov <[email protected]>
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use std::rc::Rc;
use syntax::ext::base::ExtCtxt;
use builder::{Builder, TokenString, add_node_dependency};
use node;
use super::pinmap;
pub fn attach(builder: &mut Builder, _: &mut ExtCtxt, node: Rc<node::Node>) {
node.materializer.set(Some(verify as fn(&mut Builder, &mut ExtCtxt, Rc<node::Node>)));
for port_node in node.subnodes().iter() {
port_node.materializer.set(Some(verify as fn(&mut Builder, &mut ExtCtxt, Rc<node::Node>)));
add_node_dependency(&node, port_node);
for pin_node in port_node.subnodes().iter() {
pin_node.materializer.set(Some(build_pin as fn(&mut Builder, &mut ExtCtxt, Rc<node::Node>)));
add_node_dependency(port_node, pin_node);
super::add_node_dependency_on_clock(builder, pin_node);
}
}
}
pub fn verify(_: &mut Builder, cx: &mut ExtCtxt, node: Rc<node::Node>) {
node.expect_no_attributes(cx);
}
fn build_pin(builder: &mut Builder, cx: &mut ExtCtxt, node: Rc<node::Node>) {
let port_node = node.parent.clone().unwrap().upgrade().unwrap();
let ref port_path = port_node.path;
let port_str = format!("Port{}", match port_path.as_str().parse::<usize>().unwrap() {
0...4 => port_path,
other => {
cx.parse_sess().span_diagnostic.span_err(port_node.path_span,
format!("unknown port `{}`, allowed values: 0...4",
other).as_str());
return;
}
});
let port = TokenString(port_str);
if node.name.is_none() {
cx.parse_sess().span_diagnostic.span_err(node.name_span,
"pin node must have a name");
return;
}
let direction_str = if node.get_string_attr("function").is_some() {
"core::option::Option::None"
} else {
match node.get_string_attr("direction").unwrap().as_str() {
"out" => "core::option::Option::Some(zinc::hal::pin::Out)",
"in" => "core::option::Option::Some(zinc::hal::pin::In)",
other => {
let attr = node.get_attr("direction");
cx.parse_sess().span_diagnostic.span_err(attr.value_span,
format!("unknown direction `{}`, allowed values: `in`, `out`",
other).as_str());
return;
}
}
};
let direction = TokenString(direction_str.to_string());
let pin_str = match node.path.as_str().parse::<usize>().unwrap() {
0...31 => &node.path,
other => {
cx.parse_sess().span_diagnostic.span_err(node.path_span,
format!("unknown pin `{}`, allowed values: 0...31",
other).as_str());
return;
}
};
let port_def = pinmap::port_def();
let function_str = match node.get_string_attr("function") {
None => "Gpio".to_string(),
Some(fun) => {
let pins = &port_def[port_path];
let maybe_pin_index: usize = node.path.as_str().parse().unwrap();
let maybe_pin: &Option<pinmap::PinDef> = pins.get(maybe_pin_index).unwrap();
match maybe_pin {
&None => {
cx.parse_sess().span_diagnostic.span_err(
node.get_attr("function").value_span,
format!("unknown pin function `{}`, only GPIO avaliable on this pin",
fun).as_str());
return;
}
&Some(ref pin_funcs) => {
let maybe_func = pin_funcs.get(&fun);
match maybe_func {
None => {
let avaliable: Vec<String> = pin_funcs.keys().map(|k|{k.to_string()}).collect();
cx.parse_sess().span_diagnostic.span_err(
node.get_attr("function").value_span,
format!("unknown pin function `{}`, allowed functions: {}",
fun, avaliable.join(", ")).as_str());
return;
},
Some(func_idx) => {
format!("AltFunction{}", func_idx)
}
}
}
}
}
};
let function = TokenString(function_str);
let pin = TokenString(format!("{}u8", pin_str));
let pin_name = TokenString(node.name.clone().unwrap());
node.set_type_name("zinc::hal::lpc43xx::pin::Pin".to_string());
let st = quote_stmt!(&*cx,
let $pin_name = zinc::hal::lpc43xx::pin::Pin::new(
zinc::hal::lpc43xx::pin::Port::$port,
$pin,
zinc::hal::lpc43xx::pin::Function::$function,
$direction);
).unwrap();
builder.add_main_statement(st);
}
#[cfg(test)]
mod test {
use builder::Builder;
use test_helpers::{assert_equal_source, with_parsed};
#[test]
fn builds_input_gpio() {
with_parsed("
gpio {
0 {
p1@1 { direction = \"in\"; }
}
}", |cx, failed, pt| {
let mut builder = Builder::new(pt.clone(), cx);
super::build_pin(&mut builder, cx, pt.get_by_name("p1").unwrap());
assert!(unsafe{*failed} == false);
assert!(builder.main_stmts().len() == 1);
assert_equal_source(&builder.main_stmts()[0],
"let p1 = zinc::hal::lpc43xx::pin::Pin::new(
zinc::hal::lpc43xx::pin::Port::Port0,
1u8,
zinc::hal::lpc43xx::pin::Function::Gpio,
core::option::Option::Some(zinc::hal::pin::In));");
});
}
#[test]
fn builds_output_gpio() |
#[test]
fn builds_altfn_gpio() {
with_parsed("
gpio {
0 {
p3@3 { direction = \"out\"; function = \"ad0_6\"; }
}
}", |cx, failed, pt| {
let mut builder = Builder::new(pt.clone(), cx);
super::build_pin(&mut builder, cx, pt.get_by_name("p3").unwrap());
assert!(unsafe{*failed} == false);
assert!(builder.main_stmts().len() == 1);
assert_equal_source(&builder.main_stmts()[0],
"let p3 = zinc::hal::lpc43xx::pin::Pin::new(
zinc::hal::lpc43xx::pin::Port::Port0,
3u8,
zinc::hal::lpc43xx::pin::Function::AltFunction2,
core::option::Option::None);");
});
}
}
| {
with_parsed("
gpio {
0 {
p2@2 { direction = \"out\"; }
}
}", |cx, failed, pt| {
let mut builder = Builder::new(pt.clone(), cx);
super::build_pin(&mut builder, cx, pt.get_by_name("p2").unwrap());
assert!(unsafe{*failed} == false);
assert!(builder.main_stmts().len() == 1);
assert_equal_source(&builder.main_stmts()[0],
"let p2 = zinc::hal::lpc43xx::pin::Pin::new(
zinc::hal::lpc43xx::pin::Port::Port0,
2u8,
zinc::hal::lpc43xx::pin::Function::Gpio,
core::option::Option::Some(zinc::hal::pin::Out));");
});
} | identifier_body |
transaction.rs | // Copyright 2015-2017 Parity Technologies (UK) Ltd.
// This file is part of Parity.
// Parity is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Parity is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
//! View onto transaction rlp
use util::{U256, Bytes, Hashable, H256};
use rlp::{Rlp, View};
/// View onto transaction rlp.
pub struct TransactionView<'a> {
rlp: Rlp<'a>
}
impl<'a> TransactionView<'a> {
/// Creates new view onto block from raw bytes.
pub fn new(bytes: &'a [u8]) -> TransactionView<'a> |
/// Creates new view onto block from rlp.
pub fn new_from_rlp(rlp: Rlp<'a>) -> TransactionView<'a> {
TransactionView {
rlp: rlp
}
}
/// Return reference to underlaying rlp.
pub fn rlp(&self) -> &Rlp<'a> {
&self.rlp
}
/// Get the nonce field of the transaction.
pub fn nonce(&self) -> U256 { self.rlp.val_at(0) }
/// Get the gas_price field of the transaction.
pub fn gas_price(&self) -> U256 { self.rlp.val_at(1) }
/// Get the gas field of the transaction.
pub fn gas(&self) -> U256 { self.rlp.val_at(2) }
/// Get the value field of the transaction.
pub fn value(&self) -> U256 { self.rlp.val_at(4) }
/// Get the data field of the transaction.
pub fn data(&self) -> Bytes { self.rlp.val_at(5) }
/// Get the v field of the transaction.
pub fn v(&self) -> u8 { let r: u16 = self.rlp.val_at(6); r as u8 }
/// Get the r field of the transaction.
pub fn r(&self) -> U256 { self.rlp.val_at(7) }
/// Get the s field of the transaction.
pub fn s(&self) -> U256 { self.rlp.val_at(8) }
}
impl<'a> Hashable for TransactionView<'a> {
fn sha3(&self) -> H256 {
self.rlp.as_raw().sha3()
}
}
#[cfg(test)]
mod tests {
use std::str::FromStr;
use rustc_serialize::hex::FromHex;
use util::U256;
use super::TransactionView;
#[test]
fn test_transaction_view() {
let rlp = "f87c80018261a894095e7baea6a6c7c4c2dfeb977efac326af552d870a9d00000000000000000000000000000000000000000000000000000000001ba048b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353a0efffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804".from_hex().unwrap();
let view = TransactionView::new(&rlp);
assert_eq!(view.nonce(), U256::from(0));
assert_eq!(view.gas_price(), U256::from(1));
assert_eq!(view.gas(), U256::from(0x61a8));
assert_eq!(view.value(), U256::from(0xa));
assert_eq!(view.data(), "0000000000000000000000000000000000000000000000000000000000".from_hex().unwrap());
assert_eq!(view.r(), U256::from_str("48b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353").unwrap());
assert_eq!(view.s(), U256::from_str("efffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804").unwrap());
assert_eq!(view.v(), 0x1b);
}
}
| {
TransactionView {
rlp: Rlp::new(bytes)
}
} | identifier_body |
transaction.rs | // Copyright 2015-2017 Parity Technologies (UK) Ltd.
// This file is part of Parity.
// Parity is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
| // GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
//! View onto transaction rlp
use util::{U256, Bytes, Hashable, H256};
use rlp::{Rlp, View};
/// View onto transaction rlp.
pub struct TransactionView<'a> {
rlp: Rlp<'a>
}
impl<'a> TransactionView<'a> {
/// Creates new view onto block from raw bytes.
pub fn new(bytes: &'a [u8]) -> TransactionView<'a> {
TransactionView {
rlp: Rlp::new(bytes)
}
}
/// Creates new view onto block from rlp.
pub fn new_from_rlp(rlp: Rlp<'a>) -> TransactionView<'a> {
TransactionView {
rlp: rlp
}
}
/// Return reference to underlaying rlp.
pub fn rlp(&self) -> &Rlp<'a> {
&self.rlp
}
/// Get the nonce field of the transaction.
pub fn nonce(&self) -> U256 { self.rlp.val_at(0) }
/// Get the gas_price field of the transaction.
pub fn gas_price(&self) -> U256 { self.rlp.val_at(1) }
/// Get the gas field of the transaction.
pub fn gas(&self) -> U256 { self.rlp.val_at(2) }
/// Get the value field of the transaction.
pub fn value(&self) -> U256 { self.rlp.val_at(4) }
/// Get the data field of the transaction.
pub fn data(&self) -> Bytes { self.rlp.val_at(5) }
/// Get the v field of the transaction.
pub fn v(&self) -> u8 { let r: u16 = self.rlp.val_at(6); r as u8 }
/// Get the r field of the transaction.
pub fn r(&self) -> U256 { self.rlp.val_at(7) }
/// Get the s field of the transaction.
pub fn s(&self) -> U256 { self.rlp.val_at(8) }
}
impl<'a> Hashable for TransactionView<'a> {
fn sha3(&self) -> H256 {
self.rlp.as_raw().sha3()
}
}
#[cfg(test)]
mod tests {
use std::str::FromStr;
use rustc_serialize::hex::FromHex;
use util::U256;
use super::TransactionView;
#[test]
fn test_transaction_view() {
let rlp = "f87c80018261a894095e7baea6a6c7c4c2dfeb977efac326af552d870a9d00000000000000000000000000000000000000000000000000000000001ba048b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353a0efffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804".from_hex().unwrap();
let view = TransactionView::new(&rlp);
assert_eq!(view.nonce(), U256::from(0));
assert_eq!(view.gas_price(), U256::from(1));
assert_eq!(view.gas(), U256::from(0x61a8));
assert_eq!(view.value(), U256::from(0xa));
assert_eq!(view.data(), "0000000000000000000000000000000000000000000000000000000000".from_hex().unwrap());
assert_eq!(view.r(), U256::from_str("48b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353").unwrap());
assert_eq!(view.s(), U256::from_str("efffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804").unwrap());
assert_eq!(view.v(), 0x1b);
}
} | // Parity is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | random_line_split |
transaction.rs | // Copyright 2015-2017 Parity Technologies (UK) Ltd.
// This file is part of Parity.
// Parity is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Parity is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
//! View onto transaction rlp
use util::{U256, Bytes, Hashable, H256};
use rlp::{Rlp, View};
/// View onto transaction rlp.
pub struct TransactionView<'a> {
rlp: Rlp<'a>
}
impl<'a> TransactionView<'a> {
/// Creates new view onto block from raw bytes.
pub fn | (bytes: &'a [u8]) -> TransactionView<'a> {
TransactionView {
rlp: Rlp::new(bytes)
}
}
/// Creates new view onto block from rlp.
pub fn new_from_rlp(rlp: Rlp<'a>) -> TransactionView<'a> {
TransactionView {
rlp: rlp
}
}
/// Return reference to underlaying rlp.
pub fn rlp(&self) -> &Rlp<'a> {
&self.rlp
}
/// Get the nonce field of the transaction.
pub fn nonce(&self) -> U256 { self.rlp.val_at(0) }
/// Get the gas_price field of the transaction.
pub fn gas_price(&self) -> U256 { self.rlp.val_at(1) }
/// Get the gas field of the transaction.
pub fn gas(&self) -> U256 { self.rlp.val_at(2) }
/// Get the value field of the transaction.
pub fn value(&self) -> U256 { self.rlp.val_at(4) }
/// Get the data field of the transaction.
pub fn data(&self) -> Bytes { self.rlp.val_at(5) }
/// Get the v field of the transaction.
pub fn v(&self) -> u8 { let r: u16 = self.rlp.val_at(6); r as u8 }
/// Get the r field of the transaction.
pub fn r(&self) -> U256 { self.rlp.val_at(7) }
/// Get the s field of the transaction.
pub fn s(&self) -> U256 { self.rlp.val_at(8) }
}
impl<'a> Hashable for TransactionView<'a> {
fn sha3(&self) -> H256 {
self.rlp.as_raw().sha3()
}
}
#[cfg(test)]
mod tests {
use std::str::FromStr;
use rustc_serialize::hex::FromHex;
use util::U256;
use super::TransactionView;
#[test]
fn test_transaction_view() {
let rlp = "f87c80018261a894095e7baea6a6c7c4c2dfeb977efac326af552d870a9d00000000000000000000000000000000000000000000000000000000001ba048b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353a0efffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804".from_hex().unwrap();
let view = TransactionView::new(&rlp);
assert_eq!(view.nonce(), U256::from(0));
assert_eq!(view.gas_price(), U256::from(1));
assert_eq!(view.gas(), U256::from(0x61a8));
assert_eq!(view.value(), U256::from(0xa));
assert_eq!(view.data(), "0000000000000000000000000000000000000000000000000000000000".from_hex().unwrap());
assert_eq!(view.r(), U256::from_str("48b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353").unwrap());
assert_eq!(view.s(), U256::from_str("efffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804").unwrap());
assert_eq!(view.v(), 0x1b);
}
}
| new | identifier_name |
luhn_test.rs | // Implements http://rosettacode.org/wiki/Luhn_test_of_credit_card_numbers
struct | {
m: u64
}
impl Iterator for Digits {
type Item = u64;
fn next(&mut self) -> Option<u64> {
match self.m {
0 => None,
n => {
let ret = n % 10;
self.m = n / 10;
Some(ret)
}
}
}
}
#[derive(Copy, Clone)]
enum LuhnState { Even, Odd, }
fn digits(n: u64) -> Digits {
Digits{m: n}
}
fn luhn_test(n: u64) -> bool {
let odd_even = [LuhnState::Odd, LuhnState::Even];
let numbers = digits(n).zip(odd_even.iter().cycle().map(|&s| s));
let sum =
numbers.fold(0u64, |s, n| {
s +
match n {
(n, LuhnState::Odd) => n,
(n, LuhnState::Even) =>
digits(n * 2).fold(0, |s, n| s + n),
} });
sum % 10 == 0
}
#[cfg(not(test))]
fn main() {
let nos = [49927398716, 49927398717, 1234567812345678, 1234567812345670];
for n in &nos {
if luhn_test(*n) {
println!("{} passes.", n);
} else { println!("{} fails.", n); }
}
}
#[test]
fn test_inputs() {
assert!(luhn_test(49927398716));
assert!(!luhn_test(49927398717));
assert!(!luhn_test(1234567812345678));
assert!(luhn_test(1234567812345670));
}
| Digits | identifier_name |
luhn_test.rs | // Implements http://rosettacode.org/wiki/Luhn_test_of_credit_card_numbers
struct Digits {
m: u64
}
impl Iterator for Digits {
type Item = u64;
fn next(&mut self) -> Option<u64> {
match self.m {
0 => None,
n => {
let ret = n % 10;
self.m = n / 10;
Some(ret)
}
}
}
}
#[derive(Copy, Clone)]
enum LuhnState { Even, Odd, }
fn digits(n: u64) -> Digits {
Digits{m: n}
}
fn luhn_test(n: u64) -> bool {
let odd_even = [LuhnState::Odd, LuhnState::Even];
let numbers = digits(n).zip(odd_even.iter().cycle().map(|&s| s));
let sum =
numbers.fold(0u64, |s, n| {
s +
match n {
(n, LuhnState::Odd) => n,
(n, LuhnState::Even) =>
digits(n * 2).fold(0, |s, n| s + n),
} });
sum % 10 == 0
}
#[cfg(not(test))]
fn main() {
let nos = [49927398716, 49927398717, 1234567812345678, 1234567812345670];
for n in &nos {
if luhn_test(*n) {
println!("{} passes.", n);
} else { println!("{} fails.", n); }
}
}
#[test]
fn test_inputs() | {
assert!(luhn_test(49927398716));
assert!(!luhn_test(49927398717));
assert!(!luhn_test(1234567812345678));
assert!(luhn_test(1234567812345670));
} | identifier_body |
|
luhn_test.rs | // Implements http://rosettacode.org/wiki/Luhn_test_of_credit_card_numbers
struct Digits {
m: u64
}
impl Iterator for Digits {
type Item = u64;
fn next(&mut self) -> Option<u64> {
match self.m {
0 => None,
n => {
let ret = n % 10;
self.m = n / 10;
Some(ret)
}
}
}
}
#[derive(Copy, Clone)]
enum LuhnState { Even, Odd, }
fn digits(n: u64) -> Digits {
Digits{m: n}
}
fn luhn_test(n: u64) -> bool {
let odd_even = [LuhnState::Odd, LuhnState::Even];
let numbers = digits(n).zip(odd_even.iter().cycle().map(|&s| s));
let sum =
numbers.fold(0u64, |s, n| {
s +
match n {
(n, LuhnState::Odd) => n,
(n, LuhnState::Even) =>
digits(n * 2).fold(0, |s, n| s + n),
} });
sum % 10 == 0
}
#[cfg(not(test))]
fn main() {
let nos = [49927398716, 49927398717, 1234567812345678, 1234567812345670];
for n in &nos {
if luhn_test(*n) {
println!("{} passes.", n);
} else { println!("{} fails.", n); }
}
}
#[test] | assert!(!luhn_test(49927398717));
assert!(!luhn_test(1234567812345678));
assert!(luhn_test(1234567812345670));
} | fn test_inputs() {
assert!(luhn_test(49927398716)); | random_line_split |
mod.rs | //! Collectors will receive events from the contextual shard, check if the
//! filter lets them pass, and collects if the receive, collect, or time limits
//! are not reached yet.
use std::sync::Arc;
mod error;
pub use error::Error as CollectorError;
#[cfg(feature = "unstable_discord_api")]
pub mod component_interaction_collector;
pub mod event_collector;
pub mod message_collector;
pub mod reaction_collector;
#[cfg(feature = "unstable_discord_api")]
pub use component_interaction_collector::*;
pub use event_collector::*;
pub use message_collector::*;
pub use reaction_collector::*;
/// Wraps a &T and clones the value into an Arc<T> lazily. Used with collectors to allow inspecting | pub(crate) struct LazyArc<'a, T> {
value: &'a T,
arc: Option<Arc<T>>,
}
impl<'a, T: Clone> LazyArc<'a, T> {
pub fn new(value: &'a T) -> Self {
LazyArc {
value,
arc: None,
}
}
pub fn as_arc(&mut self) -> Arc<T> {
let value = self.value;
self.arc.get_or_insert_with(|| Arc::new(value.clone())).clone()
}
}
impl<'a, T> std::ops::Deref for LazyArc<'a, T> {
type Target = T;
fn deref(&self) -> &Self::Target {
self.value
}
} | /// the value in filters while only cloning values that actually match.
#[derive(Debug)] | random_line_split |
mod.rs | //! Collectors will receive events from the contextual shard, check if the
//! filter lets them pass, and collects if the receive, collect, or time limits
//! are not reached yet.
use std::sync::Arc;
mod error;
pub use error::Error as CollectorError;
#[cfg(feature = "unstable_discord_api")]
pub mod component_interaction_collector;
pub mod event_collector;
pub mod message_collector;
pub mod reaction_collector;
#[cfg(feature = "unstable_discord_api")]
pub use component_interaction_collector::*;
pub use event_collector::*;
pub use message_collector::*;
pub use reaction_collector::*;
/// Wraps a &T and clones the value into an Arc<T> lazily. Used with collectors to allow inspecting
/// the value in filters while only cloning values that actually match.
#[derive(Debug)]
pub(crate) struct LazyArc<'a, T> {
value: &'a T,
arc: Option<Arc<T>>,
}
impl<'a, T: Clone> LazyArc<'a, T> {
pub fn new(value: &'a T) -> Self {
LazyArc {
value,
arc: None,
}
}
pub fn as_arc(&mut self) -> Arc<T> {
let value = self.value;
self.arc.get_or_insert_with(|| Arc::new(value.clone())).clone()
}
}
impl<'a, T> std::ops::Deref for LazyArc<'a, T> {
type Target = T;
fn deref(&self) -> &Self::Target |
}
| {
self.value
} | identifier_body |
mod.rs | //! Collectors will receive events from the contextual shard, check if the
//! filter lets them pass, and collects if the receive, collect, or time limits
//! are not reached yet.
use std::sync::Arc;
mod error;
pub use error::Error as CollectorError;
#[cfg(feature = "unstable_discord_api")]
pub mod component_interaction_collector;
pub mod event_collector;
pub mod message_collector;
pub mod reaction_collector;
#[cfg(feature = "unstable_discord_api")]
pub use component_interaction_collector::*;
pub use event_collector::*;
pub use message_collector::*;
pub use reaction_collector::*;
/// Wraps a &T and clones the value into an Arc<T> lazily. Used with collectors to allow inspecting
/// the value in filters while only cloning values that actually match.
#[derive(Debug)]
pub(crate) struct LazyArc<'a, T> {
value: &'a T,
arc: Option<Arc<T>>,
}
impl<'a, T: Clone> LazyArc<'a, T> {
pub fn new(value: &'a T) -> Self {
LazyArc {
value,
arc: None,
}
}
pub fn | (&mut self) -> Arc<T> {
let value = self.value;
self.arc.get_or_insert_with(|| Arc::new(value.clone())).clone()
}
}
impl<'a, T> std::ops::Deref for LazyArc<'a, T> {
type Target = T;
fn deref(&self) -> &Self::Target {
self.value
}
}
| as_arc | identifier_name |
window_event.rs | #![allow(missing_docs)]
#[derive(Copy, Clone, PartialEq, PartialOrd, Debug, Serialize, Deserialize)]
pub enum WindowEvent {
Pos(i32, i32),
Size(u32, u32),
Close,
Refresh,
Focus(bool),
Iconify(bool),
FramebufferSize(u32, u32),
MouseButton(MouseButton, Action, Modifiers),
CursorPos(f64, f64, Modifiers),
CursorEnter(bool),
Scroll(f64, f64, Modifiers),
Key(Key, Action, Modifiers),
Char(char),
CharModifiers(char, Modifiers),
Touch(u64, f64, f64, TouchAction, Modifiers),
}
use WindowEvent::*;
impl WindowEvent {
/// Tests if this event is related to the keyboard.
pub fn is_keyboard_event(&self) -> bool {
matches!(self, Key(..) | Char(..) | CharModifiers(..))
}
/// Tests if this event is related to the mouse.
pub fn | (&self) -> bool {
matches!(
self,
MouseButton(..) | CursorPos(..) | CursorEnter(..) | Scroll(..)
)
}
/// Tests if this event is related to the touch.
pub fn is_touch_event(&self) -> bool {
matches!(self, Touch(..))
}
}
// NOTE: list of keys inspired from glutin.
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug, Serialize, Deserialize)]
pub enum Key {
Key1,
Key2,
Key3,
Key4,
Key5,
Key6,
Key7,
Key8,
Key9,
Key0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z,
Escape,
F1,
F2,
F3,
F4,
F5,
F6,
F7,
F8,
F9,
F10,
F11,
F12,
F13,
F14,
F15,
F16,
F17,
F18,
F19,
F20,
F21,
F22,
F23,
F24,
Snapshot,
Scroll,
Pause,
Insert,
Home,
Delete,
End,
PageDown,
PageUp,
Left,
Up,
Right,
Down,
Back,
Return,
Space,
Compose,
Caret,
Numlock,
Numpad0,
Numpad1,
Numpad2,
Numpad3,
Numpad4,
Numpad5,
Numpad6,
Numpad7,
Numpad8,
Numpad9,
AbntC1,
AbntC2,
Add,
Apostrophe,
Apps,
At,
Ax,
Backslash,
Calculator,
Capital,
Colon,
Comma,
Convert,
Decimal,
Divide,
Equals,
Grave,
Kana,
Kanji,
LAlt,
LBracket,
LControl,
LShift,
LWin,
Mail,
MediaSelect,
MediaStop,
Minus,
Multiply,
Mute,
MyComputer,
NavigateForward,
NavigateBackward,
NextTrack,
NoConvert,
NumpadComma,
NumpadEnter,
NumpadEquals,
OEM102,
Period,
PlayPause,
Power,
PrevTrack,
RAlt,
RBracket,
RControl,
RShift,
RWin,
Semicolon,
Slash,
Sleep,
Stop,
Subtract,
Sysrq,
Tab,
Underline,
Unlabeled,
VolumeDown,
VolumeUp,
Wake,
WebBack,
WebFavorites,
WebForward,
WebHome,
WebRefresh,
WebSearch,
WebStop,
Yen,
Copy,
Paste,
Cut,
Unknown,
}
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug, Serialize, Deserialize)]
pub enum MouseButton {
Button1,
Button2,
Button3,
Button4,
Button5,
Button6,
Button7,
Button8,
}
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug, Serialize, Deserialize)]
pub enum Action {
Release,
Press,
}
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug, Serialize, Deserialize)]
pub enum TouchAction {
Start,
End,
Move,
Cancel,
}
bitflags! {
#[doc = "Key modifiers"]
#[derive(Serialize, Deserialize)]
pub struct Modifiers: i32 {
const Shift = 0b0001;
const Control = 0b0010;
const Alt = 0b0100;
const Super = 0b1000;
}
}
| is_mouse_event | identifier_name |
window_event.rs | #![allow(missing_docs)]
#[derive(Copy, Clone, PartialEq, PartialOrd, Debug, Serialize, Deserialize)]
pub enum WindowEvent {
Pos(i32, i32),
Size(u32, u32),
Close,
Refresh,
Focus(bool),
Iconify(bool),
FramebufferSize(u32, u32),
MouseButton(MouseButton, Action, Modifiers),
CursorPos(f64, f64, Modifiers),
CursorEnter(bool),
Scroll(f64, f64, Modifiers),
Key(Key, Action, Modifiers),
Char(char), | }
use WindowEvent::*;
impl WindowEvent {
/// Tests if this event is related to the keyboard.
pub fn is_keyboard_event(&self) -> bool {
matches!(self, Key(..) | Char(..) | CharModifiers(..))
}
/// Tests if this event is related to the mouse.
pub fn is_mouse_event(&self) -> bool {
matches!(
self,
MouseButton(..) | CursorPos(..) | CursorEnter(..) | Scroll(..)
)
}
/// Tests if this event is related to the touch.
pub fn is_touch_event(&self) -> bool {
matches!(self, Touch(..))
}
}
// NOTE: list of keys inspired from glutin.
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug, Serialize, Deserialize)]
pub enum Key {
Key1,
Key2,
Key3,
Key4,
Key5,
Key6,
Key7,
Key8,
Key9,
Key0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z,
Escape,
F1,
F2,
F3,
F4,
F5,
F6,
F7,
F8,
F9,
F10,
F11,
F12,
F13,
F14,
F15,
F16,
F17,
F18,
F19,
F20,
F21,
F22,
F23,
F24,
Snapshot,
Scroll,
Pause,
Insert,
Home,
Delete,
End,
PageDown,
PageUp,
Left,
Up,
Right,
Down,
Back,
Return,
Space,
Compose,
Caret,
Numlock,
Numpad0,
Numpad1,
Numpad2,
Numpad3,
Numpad4,
Numpad5,
Numpad6,
Numpad7,
Numpad8,
Numpad9,
AbntC1,
AbntC2,
Add,
Apostrophe,
Apps,
At,
Ax,
Backslash,
Calculator,
Capital,
Colon,
Comma,
Convert,
Decimal,
Divide,
Equals,
Grave,
Kana,
Kanji,
LAlt,
LBracket,
LControl,
LShift,
LWin,
Mail,
MediaSelect,
MediaStop,
Minus,
Multiply,
Mute,
MyComputer,
NavigateForward,
NavigateBackward,
NextTrack,
NoConvert,
NumpadComma,
NumpadEnter,
NumpadEquals,
OEM102,
Period,
PlayPause,
Power,
PrevTrack,
RAlt,
RBracket,
RControl,
RShift,
RWin,
Semicolon,
Slash,
Sleep,
Stop,
Subtract,
Sysrq,
Tab,
Underline,
Unlabeled,
VolumeDown,
VolumeUp,
Wake,
WebBack,
WebFavorites,
WebForward,
WebHome,
WebRefresh,
WebSearch,
WebStop,
Yen,
Copy,
Paste,
Cut,
Unknown,
}
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug, Serialize, Deserialize)]
pub enum MouseButton {
Button1,
Button2,
Button3,
Button4,
Button5,
Button6,
Button7,
Button8,
}
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug, Serialize, Deserialize)]
pub enum Action {
Release,
Press,
}
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug, Serialize, Deserialize)]
pub enum TouchAction {
Start,
End,
Move,
Cancel,
}
bitflags! {
#[doc = "Key modifiers"]
#[derive(Serialize, Deserialize)]
pub struct Modifiers: i32 {
const Shift = 0b0001;
const Control = 0b0010;
const Alt = 0b0100;
const Super = 0b1000;
}
} | CharModifiers(char, Modifiers),
Touch(u64, f64, f64, TouchAction, Modifiers), | random_line_split |
domparser.rs | /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use crate::document_loader::DocumentLoader;
use crate::dom::bindings::codegen::Bindings::DOMParserBinding;
use crate::dom::bindings::codegen::Bindings::DOMParserBinding::DOMParserMethods;
use crate::dom::bindings::codegen::Bindings::DOMParserBinding::SupportedType::Application_xhtml_xml;
use crate::dom::bindings::codegen::Bindings::DOMParserBinding::SupportedType::Application_xml;
use crate::dom::bindings::codegen::Bindings::DOMParserBinding::SupportedType::Text_html;
use crate::dom::bindings::codegen::Bindings::DOMParserBinding::SupportedType::Text_xml;
use crate::dom::bindings::codegen::Bindings::DocumentBinding::DocumentReadyState;
use crate::dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
use crate::dom::bindings::error::Fallible;
use crate::dom::bindings::reflector::{reflect_dom_object, Reflector};
use crate::dom::bindings::root::{Dom, DomRoot};
use crate::dom::bindings::str::DOMString;
use crate::dom::document::DocumentSource;
use crate::dom::document::{Document, HasBrowsingContext, IsHTMLDocument};
use crate::dom::servoparser::ServoParser;
use crate::dom::window::Window;
use dom_struct::dom_struct;
use script_traits::DocumentActivity;
#[dom_struct]
pub struct DOMParser {
reflector_: Reflector,
window: Dom<Window>, // XXXjdm Document instead?
}
impl DOMParser {
fn new_inherited(window: &Window) -> DOMParser {
DOMParser {
reflector_: Reflector::new(),
window: Dom::from_ref(window),
}
}
pub fn new(window: &Window) -> DomRoot<DOMParser> {
reflect_dom_object(
Box::new(DOMParser::new_inherited(window)),
window,
DOMParserBinding::Wrap,
)
}
pub fn Constructor(window: &Window) -> Fallible<DomRoot<DOMParser>> {
Ok(DOMParser::new(window))
}
}
impl DOMParserMethods for DOMParser {
// https://w3c.github.io/DOM-Parsing/#the-domparser-interface
fn ParseFromString(
&self,
s: DOMString,
ty: DOMParserBinding::SupportedType,
) -> Fallible<DomRoot<Document>> {
let url = self.window.get_url();
let content_type = ty
.as_str()
.parse()
.expect("Supported type is not a MIME type");
let doc = self.window.Document();
let loader = DocumentLoader::new(&*doc.loader());
match ty {
Text_html => {
let document = Document::new(
&self.window,
HasBrowsingContext::No,
Some(url.clone()),
doc.origin().clone(),
IsHTMLDocument::HTMLDocument,
Some(content_type),
None,
DocumentActivity::Inactive,
DocumentSource::FromParser,
loader,
None,
None,
Default::default(),
);
ServoParser::parse_html_document(&document, s, url);
document.set_ready_state(DocumentReadyState::Complete);
Ok(document)
},
Text_xml | Application_xml | Application_xhtml_xml => | ,
}
}
}
| {
let document = Document::new(
&self.window,
HasBrowsingContext::No,
Some(url.clone()),
doc.origin().clone(),
IsHTMLDocument::NonHTMLDocument,
Some(content_type),
None,
DocumentActivity::Inactive,
DocumentSource::FromParser,
loader,
None,
None,
Default::default(),
);
ServoParser::parse_xml_document(&document, s, url);
document.set_ready_state(DocumentReadyState::Complete);
Ok(document)
} | conditional_block |
domparser.rs | /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use crate::document_loader::DocumentLoader;
use crate::dom::bindings::codegen::Bindings::DOMParserBinding;
use crate::dom::bindings::codegen::Bindings::DOMParserBinding::DOMParserMethods;
use crate::dom::bindings::codegen::Bindings::DOMParserBinding::SupportedType::Application_xhtml_xml;
use crate::dom::bindings::codegen::Bindings::DOMParserBinding::SupportedType::Application_xml;
use crate::dom::bindings::codegen::Bindings::DOMParserBinding::SupportedType::Text_html;
use crate::dom::bindings::codegen::Bindings::DOMParserBinding::SupportedType::Text_xml;
use crate::dom::bindings::codegen::Bindings::DocumentBinding::DocumentReadyState;
use crate::dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
use crate::dom::bindings::error::Fallible;
use crate::dom::bindings::reflector::{reflect_dom_object, Reflector};
use crate::dom::bindings::root::{Dom, DomRoot};
use crate::dom::bindings::str::DOMString;
use crate::dom::document::DocumentSource;
use crate::dom::document::{Document, HasBrowsingContext, IsHTMLDocument};
use crate::dom::servoparser::ServoParser;
use crate::dom::window::Window;
use dom_struct::dom_struct;
use script_traits::DocumentActivity;
#[dom_struct]
pub struct DOMParser {
reflector_: Reflector,
window: Dom<Window>, // XXXjdm Document instead?
}
impl DOMParser {
fn new_inherited(window: &Window) -> DOMParser {
DOMParser {
reflector_: Reflector::new(),
window: Dom::from_ref(window),
}
}
pub fn new(window: &Window) -> DomRoot<DOMParser> {
reflect_dom_object(
Box::new(DOMParser::new_inherited(window)),
window,
DOMParserBinding::Wrap,
)
}
pub fn Constructor(window: &Window) -> Fallible<DomRoot<DOMParser>> {
Ok(DOMParser::new(window))
}
}
impl DOMParserMethods for DOMParser {
// https://w3c.github.io/DOM-Parsing/#the-domparser-interface
fn ParseFromString(
&self,
s: DOMString,
ty: DOMParserBinding::SupportedType,
) -> Fallible<DomRoot<Document>> {
let url = self.window.get_url();
let content_type = ty
.as_str()
.parse()
.expect("Supported type is not a MIME type");
let doc = self.window.Document();
let loader = DocumentLoader::new(&*doc.loader());
match ty {
Text_html => {
let document = Document::new(
&self.window,
HasBrowsingContext::No,
Some(url.clone()),
doc.origin().clone(),
IsHTMLDocument::HTMLDocument,
Some(content_type),
None,
DocumentActivity::Inactive,
DocumentSource::FromParser,
loader,
None,
None,
Default::default(),
);
ServoParser::parse_html_document(&document, s, url);
document.set_ready_state(DocumentReadyState::Complete);
Ok(document)
}, | &self.window,
HasBrowsingContext::No,
Some(url.clone()),
doc.origin().clone(),
IsHTMLDocument::NonHTMLDocument,
Some(content_type),
None,
DocumentActivity::Inactive,
DocumentSource::FromParser,
loader,
None,
None,
Default::default(),
);
ServoParser::parse_xml_document(&document, s, url);
document.set_ready_state(DocumentReadyState::Complete);
Ok(document)
},
}
}
} | Text_xml | Application_xml | Application_xhtml_xml => {
let document = Document::new( | random_line_split |
domparser.rs | /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use crate::document_loader::DocumentLoader;
use crate::dom::bindings::codegen::Bindings::DOMParserBinding;
use crate::dom::bindings::codegen::Bindings::DOMParserBinding::DOMParserMethods;
use crate::dom::bindings::codegen::Bindings::DOMParserBinding::SupportedType::Application_xhtml_xml;
use crate::dom::bindings::codegen::Bindings::DOMParserBinding::SupportedType::Application_xml;
use crate::dom::bindings::codegen::Bindings::DOMParserBinding::SupportedType::Text_html;
use crate::dom::bindings::codegen::Bindings::DOMParserBinding::SupportedType::Text_xml;
use crate::dom::bindings::codegen::Bindings::DocumentBinding::DocumentReadyState;
use crate::dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
use crate::dom::bindings::error::Fallible;
use crate::dom::bindings::reflector::{reflect_dom_object, Reflector};
use crate::dom::bindings::root::{Dom, DomRoot};
use crate::dom::bindings::str::DOMString;
use crate::dom::document::DocumentSource;
use crate::dom::document::{Document, HasBrowsingContext, IsHTMLDocument};
use crate::dom::servoparser::ServoParser;
use crate::dom::window::Window;
use dom_struct::dom_struct;
use script_traits::DocumentActivity;
#[dom_struct]
pub struct DOMParser {
reflector_: Reflector,
window: Dom<Window>, // XXXjdm Document instead?
}
impl DOMParser {
fn new_inherited(window: &Window) -> DOMParser {
DOMParser {
reflector_: Reflector::new(),
window: Dom::from_ref(window),
}
}
pub fn new(window: &Window) -> DomRoot<DOMParser> {
reflect_dom_object(
Box::new(DOMParser::new_inherited(window)),
window,
DOMParserBinding::Wrap,
)
}
pub fn Constructor(window: &Window) -> Fallible<DomRoot<DOMParser>> |
}
impl DOMParserMethods for DOMParser {
// https://w3c.github.io/DOM-Parsing/#the-domparser-interface
fn ParseFromString(
&self,
s: DOMString,
ty: DOMParserBinding::SupportedType,
) -> Fallible<DomRoot<Document>> {
let url = self.window.get_url();
let content_type = ty
.as_str()
.parse()
.expect("Supported type is not a MIME type");
let doc = self.window.Document();
let loader = DocumentLoader::new(&*doc.loader());
match ty {
Text_html => {
let document = Document::new(
&self.window,
HasBrowsingContext::No,
Some(url.clone()),
doc.origin().clone(),
IsHTMLDocument::HTMLDocument,
Some(content_type),
None,
DocumentActivity::Inactive,
DocumentSource::FromParser,
loader,
None,
None,
Default::default(),
);
ServoParser::parse_html_document(&document, s, url);
document.set_ready_state(DocumentReadyState::Complete);
Ok(document)
},
Text_xml | Application_xml | Application_xhtml_xml => {
let document = Document::new(
&self.window,
HasBrowsingContext::No,
Some(url.clone()),
doc.origin().clone(),
IsHTMLDocument::NonHTMLDocument,
Some(content_type),
None,
DocumentActivity::Inactive,
DocumentSource::FromParser,
loader,
None,
None,
Default::default(),
);
ServoParser::parse_xml_document(&document, s, url);
document.set_ready_state(DocumentReadyState::Complete);
Ok(document)
},
}
}
}
| {
Ok(DOMParser::new(window))
} | identifier_body |
domparser.rs | /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
use crate::document_loader::DocumentLoader;
use crate::dom::bindings::codegen::Bindings::DOMParserBinding;
use crate::dom::bindings::codegen::Bindings::DOMParserBinding::DOMParserMethods;
use crate::dom::bindings::codegen::Bindings::DOMParserBinding::SupportedType::Application_xhtml_xml;
use crate::dom::bindings::codegen::Bindings::DOMParserBinding::SupportedType::Application_xml;
use crate::dom::bindings::codegen::Bindings::DOMParserBinding::SupportedType::Text_html;
use crate::dom::bindings::codegen::Bindings::DOMParserBinding::SupportedType::Text_xml;
use crate::dom::bindings::codegen::Bindings::DocumentBinding::DocumentReadyState;
use crate::dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
use crate::dom::bindings::error::Fallible;
use crate::dom::bindings::reflector::{reflect_dom_object, Reflector};
use crate::dom::bindings::root::{Dom, DomRoot};
use crate::dom::bindings::str::DOMString;
use crate::dom::document::DocumentSource;
use crate::dom::document::{Document, HasBrowsingContext, IsHTMLDocument};
use crate::dom::servoparser::ServoParser;
use crate::dom::window::Window;
use dom_struct::dom_struct;
use script_traits::DocumentActivity;
#[dom_struct]
pub struct DOMParser {
reflector_: Reflector,
window: Dom<Window>, // XXXjdm Document instead?
}
impl DOMParser {
fn new_inherited(window: &Window) -> DOMParser {
DOMParser {
reflector_: Reflector::new(),
window: Dom::from_ref(window),
}
}
pub fn new(window: &Window) -> DomRoot<DOMParser> {
reflect_dom_object(
Box::new(DOMParser::new_inherited(window)),
window,
DOMParserBinding::Wrap,
)
}
pub fn | (window: &Window) -> Fallible<DomRoot<DOMParser>> {
Ok(DOMParser::new(window))
}
}
impl DOMParserMethods for DOMParser {
// https://w3c.github.io/DOM-Parsing/#the-domparser-interface
fn ParseFromString(
&self,
s: DOMString,
ty: DOMParserBinding::SupportedType,
) -> Fallible<DomRoot<Document>> {
let url = self.window.get_url();
let content_type = ty
.as_str()
.parse()
.expect("Supported type is not a MIME type");
let doc = self.window.Document();
let loader = DocumentLoader::new(&*doc.loader());
match ty {
Text_html => {
let document = Document::new(
&self.window,
HasBrowsingContext::No,
Some(url.clone()),
doc.origin().clone(),
IsHTMLDocument::HTMLDocument,
Some(content_type),
None,
DocumentActivity::Inactive,
DocumentSource::FromParser,
loader,
None,
None,
Default::default(),
);
ServoParser::parse_html_document(&document, s, url);
document.set_ready_state(DocumentReadyState::Complete);
Ok(document)
},
Text_xml | Application_xml | Application_xhtml_xml => {
let document = Document::new(
&self.window,
HasBrowsingContext::No,
Some(url.clone()),
doc.origin().clone(),
IsHTMLDocument::NonHTMLDocument,
Some(content_type),
None,
DocumentActivity::Inactive,
DocumentSource::FromParser,
loader,
None,
None,
Default::default(),
);
ServoParser::parse_xml_document(&document, s, url);
document.set_ready_state(DocumentReadyState::Complete);
Ok(document)
},
}
}
}
| Constructor | identifier_name |
builtins.rs | use crate::state::InterpState;
use enum_iterator::IntoEnumIterator;
/// Represents a builtin function
#[derive(Debug, Clone, PartialEq, IntoEnumIterator)]
pub enum Builtin {
Dot,
Plus,
Minus,
Star,
Slash,
Abs,
And,
Or,
Xor,
LShift,
RShift,
Equals,
NotEquals,
LessThan,
GreaterThan,
LessEqual,
GreaterEqual,
Emit,
Dup,
Swap,
Over,
Rot,
Tuck,
Drop,
Fetch,
Store,
Here,
Comma,
Depth,
Allot,
}
impl Builtin {
pub fn | (&self) -> &'static str {
match *self {
Builtin::Dot => ".",
Builtin::Plus => "+",
Builtin::Minus => "-",
Builtin::Star => "*",
Builtin::Slash => "/",
Builtin::Abs => "abs",
Builtin::And => "and",
Builtin::Or => "or",
Builtin::Xor => "xor",
Builtin::LShift => "lshift",
Builtin::RShift => "rshift",
Builtin::Equals => "=",
Builtin::NotEquals => "<>",
Builtin::LessThan => "<",
Builtin::GreaterThan => ">",
Builtin::LessEqual => "<=",
Builtin::GreaterEqual => ">=",
Builtin::Emit => "emit",
Builtin::Dup => "dup",
Builtin::Swap => "swap",
Builtin::Over => "over",
Builtin::Rot => "rot",
Builtin::Tuck => "tuck",
Builtin::Drop => "drop",
Builtin::Here => "here",
Builtin::Fetch => "@",
Builtin::Store => "!",
Builtin::Comma => ",",
Builtin::Depth => "depth",
Builtin::Allot => "allot",
}
}
pub fn call(&self, state: &mut InterpState) {
let stack = &mut state.stack;
/// Allows defining a builtin using closure-like syntax. Note that the
/// arguments are in reverse order, as that is how the stack is laid out.
macro_rules! stackexpr {
( | $($aname:ident : $atype:ty),+ | $($value:expr),+ ) => {
{
$(
let $aname: $atype = stack.pop();
)+
$(
stack.push($value);
)+
}
}
}
use self::Builtin::*;
match *self {
Dot => print!("{}", stack.pop::<i32>()),
Plus => stackexpr!(|n2: i32, n1: i32| n1 + n2),
Minus => stackexpr!(|n2: i32, n1: i32| n1 - n2),
Star => stackexpr!(|n2: i32, n1: i32| n1 * n2),
Slash => stackexpr!(|n2: i32, n1: i32| n1 / n2),
Abs => stackexpr!(|n: i32| n.abs()),
And => stackexpr!(|n2: i32, n1: i32| n1 & n2),
Or => stackexpr!(|n2: i32, n1: i32| n1 | n2),
Xor => stackexpr!(|n2: i32, n1: i32| n1 ^ n2),
LShift => stackexpr!(|u: i32, n: i32| n << u),
RShift => stackexpr!(|u: i32, n: i32| n >> u),
Equals => stackexpr!(|n2: i32, n1: i32| n1 == n2),
NotEquals => stackexpr!(|n2: i32, n1: i32| n1!= n2),
LessThan => stackexpr!(|n2: i32, n1: i32| n1 < n2),
GreaterThan => stackexpr!(|n2: i32, n1: i32| n1 > n2),
LessEqual => stackexpr!(|n2: i32, n1: i32| n1 <= n2),
GreaterEqual => stackexpr!(|n2: i32, n1: i32| n1 >= n2),
Emit => print!("{}", stack.pop::<char>()),
Dup => {
let n: i32 = stack.peak();
stack.push(n);
}
Swap => stackexpr!(|n2: i32, n1: i32| n2, n1),
Over => stackexpr!(|n2: i32, n1: i32| n1, n2, n1),
Rot => stackexpr!(|n3: i32, n2: i32, n1: i32| n2, n3, n1),
Tuck => stackexpr!(|n2: i32, n1: i32| n2, n1, n2),
Drop => {
stack.pop::<i32>();
}
Fetch => stackexpr!(|addr: i32| state.memory.get::<i32>(addr)),
Store => {
let addr: i32 = stack.pop();
let n: i32 = stack.pop();
state.memory.set(addr, n);
}
Here => stack.push(state.memory.here()),
Comma => {
state.memory.new(stack.pop::<i32>());
}
Depth => {
let len = stack.len();
stack.push(len);
}
Allot => {
let n = stack.pop();
if n < 0 {
// TODO Free memory
} else {
for _ in 0..n {
state.memory.new(0);
}
}
}
}
}
}
| word | identifier_name |
builtins.rs | use crate::state::InterpState;
use enum_iterator::IntoEnumIterator;
/// Represents a builtin function
#[derive(Debug, Clone, PartialEq, IntoEnumIterator)]
pub enum Builtin {
Dot,
Plus,
Minus,
Star,
Slash,
Abs,
And,
Or,
Xor,
LShift,
RShift,
Equals,
NotEquals,
LessThan,
GreaterThan,
LessEqual,
GreaterEqual,
Emit,
Dup,
Swap,
Over,
Rot,
Tuck,
Drop,
Fetch,
Store,
Here,
Comma,
Depth,
Allot,
}
impl Builtin {
pub fn word(&self) -> &'static str {
match *self {
Builtin::Dot => ".",
Builtin::Plus => "+",
Builtin::Minus => "-",
Builtin::Star => "*",
Builtin::Slash => "/",
Builtin::Abs => "abs",
Builtin::And => "and",
Builtin::Or => "or",
Builtin::Xor => "xor",
Builtin::LShift => "lshift",
Builtin::RShift => "rshift",
Builtin::Equals => "=",
Builtin::NotEquals => "<>",
Builtin::LessThan => "<",
Builtin::GreaterThan => ">",
Builtin::LessEqual => "<=",
Builtin::GreaterEqual => ">=",
Builtin::Emit => "emit",
Builtin::Dup => "dup",
Builtin::Swap => "swap",
Builtin::Over => "over",
Builtin::Rot => "rot",
Builtin::Tuck => "tuck",
Builtin::Drop => "drop",
Builtin::Here => "here",
Builtin::Fetch => "@",
Builtin::Store => "!",
Builtin::Comma => ",",
Builtin::Depth => "depth",
Builtin::Allot => "allot",
}
}
pub fn call(&self, state: &mut InterpState) {
let stack = &mut state.stack;
/// Allows defining a builtin using closure-like syntax. Note that the
/// arguments are in reverse order, as that is how the stack is laid out.
macro_rules! stackexpr {
( | $($aname:ident : $atype:ty),+ | $($value:expr),+ ) => {
{
$(
let $aname: $atype = stack.pop();
)+
$(
stack.push($value);
)+
}
}
}
use self::Builtin::*;
match *self {
Dot => print!("{}", stack.pop::<i32>()),
Plus => stackexpr!(|n2: i32, n1: i32| n1 + n2),
Minus => stackexpr!(|n2: i32, n1: i32| n1 - n2),
Star => stackexpr!(|n2: i32, n1: i32| n1 * n2),
Slash => stackexpr!(|n2: i32, n1: i32| n1 / n2),
Abs => stackexpr!(|n: i32| n.abs()),
And => stackexpr!(|n2: i32, n1: i32| n1 & n2),
Or => stackexpr!(|n2: i32, n1: i32| n1 | n2),
Xor => stackexpr!(|n2: i32, n1: i32| n1 ^ n2),
LShift => stackexpr!(|u: i32, n: i32| n << u), | LessEqual => stackexpr!(|n2: i32, n1: i32| n1 <= n2),
GreaterEqual => stackexpr!(|n2: i32, n1: i32| n1 >= n2),
Emit => print!("{}", stack.pop::<char>()),
Dup => {
let n: i32 = stack.peak();
stack.push(n);
}
Swap => stackexpr!(|n2: i32, n1: i32| n2, n1),
Over => stackexpr!(|n2: i32, n1: i32| n1, n2, n1),
Rot => stackexpr!(|n3: i32, n2: i32, n1: i32| n2, n3, n1),
Tuck => stackexpr!(|n2: i32, n1: i32| n2, n1, n2),
Drop => {
stack.pop::<i32>();
}
Fetch => stackexpr!(|addr: i32| state.memory.get::<i32>(addr)),
Store => {
let addr: i32 = stack.pop();
let n: i32 = stack.pop();
state.memory.set(addr, n);
}
Here => stack.push(state.memory.here()),
Comma => {
state.memory.new(stack.pop::<i32>());
}
Depth => {
let len = stack.len();
stack.push(len);
}
Allot => {
let n = stack.pop();
if n < 0 {
// TODO Free memory
} else {
for _ in 0..n {
state.memory.new(0);
}
}
}
}
}
} | RShift => stackexpr!(|u: i32, n: i32| n >> u),
Equals => stackexpr!(|n2: i32, n1: i32| n1 == n2),
NotEquals => stackexpr!(|n2: i32, n1: i32| n1 != n2),
LessThan => stackexpr!(|n2: i32, n1: i32| n1 < n2),
GreaterThan => stackexpr!(|n2: i32, n1: i32| n1 > n2), | random_line_split |
builtins.rs | use crate::state::InterpState;
use enum_iterator::IntoEnumIterator;
/// Represents a builtin function
#[derive(Debug, Clone, PartialEq, IntoEnumIterator)]
pub enum Builtin {
Dot,
Plus,
Minus,
Star,
Slash,
Abs,
And,
Or,
Xor,
LShift,
RShift,
Equals,
NotEquals,
LessThan,
GreaterThan,
LessEqual,
GreaterEqual,
Emit,
Dup,
Swap,
Over,
Rot,
Tuck,
Drop,
Fetch,
Store,
Here,
Comma,
Depth,
Allot,
}
impl Builtin {
pub fn word(&self) -> &'static str {
match *self {
Builtin::Dot => ".",
Builtin::Plus => "+",
Builtin::Minus => "-",
Builtin::Star => "*",
Builtin::Slash => "/",
Builtin::Abs => "abs",
Builtin::And => "and",
Builtin::Or => "or",
Builtin::Xor => "xor",
Builtin::LShift => "lshift",
Builtin::RShift => "rshift",
Builtin::Equals => "=",
Builtin::NotEquals => "<>",
Builtin::LessThan => "<",
Builtin::GreaterThan => ">",
Builtin::LessEqual => "<=",
Builtin::GreaterEqual => ">=",
Builtin::Emit => "emit",
Builtin::Dup => "dup",
Builtin::Swap => "swap",
Builtin::Over => "over",
Builtin::Rot => "rot",
Builtin::Tuck => "tuck",
Builtin::Drop => "drop",
Builtin::Here => "here",
Builtin::Fetch => "@",
Builtin::Store => "!",
Builtin::Comma => ",",
Builtin::Depth => "depth",
Builtin::Allot => "allot",
}
}
pub fn call(&self, state: &mut InterpState) | Dot => print!("{}", stack.pop::<i32>()),
Plus => stackexpr!(|n2: i32, n1: i32| n1 + n2),
Minus => stackexpr!(|n2: i32, n1: i32| n1 - n2),
Star => stackexpr!(|n2: i32, n1: i32| n1 * n2),
Slash => stackexpr!(|n2: i32, n1: i32| n1 / n2),
Abs => stackexpr!(|n: i32| n.abs()),
And => stackexpr!(|n2: i32, n1: i32| n1 & n2),
Or => stackexpr!(|n2: i32, n1: i32| n1 | n2),
Xor => stackexpr!(|n2: i32, n1: i32| n1 ^ n2),
LShift => stackexpr!(|u: i32, n: i32| n << u),
RShift => stackexpr!(|u: i32, n: i32| n >> u),
Equals => stackexpr!(|n2: i32, n1: i32| n1 == n2),
NotEquals => stackexpr!(|n2: i32, n1: i32| n1!= n2),
LessThan => stackexpr!(|n2: i32, n1: i32| n1 < n2),
GreaterThan => stackexpr!(|n2: i32, n1: i32| n1 > n2),
LessEqual => stackexpr!(|n2: i32, n1: i32| n1 <= n2),
GreaterEqual => stackexpr!(|n2: i32, n1: i32| n1 >= n2),
Emit => print!("{}", stack.pop::<char>()),
Dup => {
let n: i32 = stack.peak();
stack.push(n);
}
Swap => stackexpr!(|n2: i32, n1: i32| n2, n1),
Over => stackexpr!(|n2: i32, n1: i32| n1, n2, n1),
Rot => stackexpr!(|n3: i32, n2: i32, n1: i32| n2, n3, n1),
Tuck => stackexpr!(|n2: i32, n1: i32| n2, n1, n2),
Drop => {
stack.pop::<i32>();
}
Fetch => stackexpr!(|addr: i32| state.memory.get::<i32>(addr)),
Store => {
let addr: i32 = stack.pop();
let n: i32 = stack.pop();
state.memory.set(addr, n);
}
Here => stack.push(state.memory.here()),
Comma => {
state.memory.new(stack.pop::<i32>());
}
Depth => {
let len = stack.len();
stack.push(len);
}
Allot => {
let n = stack.pop();
if n < 0 {
// TODO Free memory
} else {
for _ in 0..n {
state.memory.new(0);
}
}
}
}
}
}
| {
let stack = &mut state.stack;
/// Allows defining a builtin using closure-like syntax. Note that the
/// arguments are in reverse order, as that is how the stack is laid out.
macro_rules! stackexpr {
( | $($aname:ident : $atype:ty),+ | $($value:expr),+ ) => {
{
$(
let $aname: $atype = stack.pop();
)+
$(
stack.push($value);
)+
}
}
}
use self::Builtin::*;
match *self { | identifier_body |
lib.rs | /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */
#![crate_name = "js"]
#![crate_type = "rlib"]
#![feature(core_intrinsics)]
#![feature(link_args)]
#![feature(str_utf16)]
#![feature(unsafe_no_drop_flag)]
#![allow(non_upper_case_globals, non_camel_case_types, non_snake_case, improper_ctypes, raw_pointer_derive)]
extern crate libc;
#[macro_use]
extern crate log; |
pub mod jsapi;
pub mod linkhack;
pub mod rust;
pub mod glue;
pub mod jsval;
use jsapi::{JSContext, JSProtoKey, Heap};
use jsval::JSVal;
use rust::GCMethods;
use libc::c_uint;
use heapsize::HeapSizeOf;
pub const default_heapsize: u32 = 32_u32 * 1024_u32 * 1024_u32;
pub const default_stacksize: usize = 8192;
pub const JSID_TYPE_STRING: i64 = 0;
pub const JSID_TYPE_INT: i64 = 1;
pub const JSID_TYPE_VOID: i64 = 2;
pub const JSID_TYPE_OBJECT: i64 = 4;
pub const JSID_TYPE_DEFAULT_XML_NAMESPACE: i64 = 6;
pub const JSID_TYPE_MASK: i64 = 7;
pub const JSFUN_CONSTRUCTOR: u32 = 0x400; /* native that can be called as a ctor */
pub const JSPROP_ENUMERATE: c_uint = 0x01;
pub const JSPROP_READONLY: c_uint = 0x02;
pub const JSPROP_PERMANENT: c_uint = 0x04;
pub const JSPROP_GETTER: c_uint = 0x10;
pub const JSPROP_SETTER: c_uint = 0x20;
pub const JSPROP_SHARED: c_uint = 0x40;
pub const JSPROP_NATIVE_ACCESSORS: c_uint = 0x08;
pub const JSCLASS_RESERVED_SLOTS_SHIFT: c_uint = 8;
pub const JSCLASS_RESERVED_SLOTS_WIDTH: c_uint = 8;
pub const JSCLASS_RESERVED_SLOTS_MASK: c_uint = ((1 << JSCLASS_RESERVED_SLOTS_WIDTH) - 1) as c_uint;
pub const JSCLASS_HIGH_FLAGS_SHIFT: c_uint =
JSCLASS_RESERVED_SLOTS_SHIFT + JSCLASS_RESERVED_SLOTS_WIDTH;
pub const JSCLASS_IS_GLOBAL: c_uint = 1 << (JSCLASS_HIGH_FLAGS_SHIFT + 1);
pub const JSCLASS_GLOBAL_APPLICATION_SLOTS: c_uint = 4;
pub const JSCLASS_GLOBAL_SLOT_COUNT: c_uint = JSCLASS_GLOBAL_APPLICATION_SLOTS + JSProtoKey::JSProto_LIMIT as u32 * 3 + 31;
pub const JSCLASS_IS_DOMJSCLASS: u32 = 1 << 4;
pub const JSCLASS_IMPLEMENTS_BARRIERS: u32 = 1 << 5;
pub const JSCLASS_USERBIT1: u32 = 1 << 7;
pub const JSCLASS_IS_PROXY: u32 = 1 << (JSCLASS_HIGH_FLAGS_SHIFT+4);
pub const JSSLOT_PROXY_PRIVATE: u32 = 1;
pub const JS_DEFAULT_ZEAL_FREQ: u32 = 100;
pub const JSTrue: u8 = 1;
pub const JSFalse: u8 = 0;
#[link(name = "jsglue")]
extern { }
#[cfg(target_os = "android")]
#[link(name = "stdc++")]
extern { }
#[cfg(target_os = "android")]
#[link(name = "gcc")]
extern { }
#[inline(always)]
pub unsafe fn JS_ARGV(_cx: *mut JSContext, vp: *mut JSVal) -> *mut JSVal {
vp.offset(2)
}
#[inline(always)]
pub unsafe fn JS_CALLEE(_cx: *mut JSContext, vp: *mut JSVal) -> JSVal {
*vp
}
// This is measured properly by the heap measurement implemented in SpiderMonkey.
impl<T: Copy + GCMethods<T>> HeapSizeOf for Heap<T> {
fn heap_size_of_children(&self) -> usize {
0
}
}
known_heap_size!(0, JSVal); | #[macro_use]
extern crate heapsize;
extern crate rustc_serialize as serialize; | random_line_split |
lib.rs | /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */
#![crate_name = "js"]
#![crate_type = "rlib"]
#![feature(core_intrinsics)]
#![feature(link_args)]
#![feature(str_utf16)]
#![feature(unsafe_no_drop_flag)]
#![allow(non_upper_case_globals, non_camel_case_types, non_snake_case, improper_ctypes, raw_pointer_derive)]
extern crate libc;
#[macro_use]
extern crate log;
#[macro_use]
extern crate heapsize;
extern crate rustc_serialize as serialize;
pub mod jsapi;
pub mod linkhack;
pub mod rust;
pub mod glue;
pub mod jsval;
use jsapi::{JSContext, JSProtoKey, Heap};
use jsval::JSVal;
use rust::GCMethods;
use libc::c_uint;
use heapsize::HeapSizeOf;
pub const default_heapsize: u32 = 32_u32 * 1024_u32 * 1024_u32;
pub const default_stacksize: usize = 8192;
pub const JSID_TYPE_STRING: i64 = 0;
pub const JSID_TYPE_INT: i64 = 1;
pub const JSID_TYPE_VOID: i64 = 2;
pub const JSID_TYPE_OBJECT: i64 = 4;
pub const JSID_TYPE_DEFAULT_XML_NAMESPACE: i64 = 6;
pub const JSID_TYPE_MASK: i64 = 7;
pub const JSFUN_CONSTRUCTOR: u32 = 0x400; /* native that can be called as a ctor */
pub const JSPROP_ENUMERATE: c_uint = 0x01;
pub const JSPROP_READONLY: c_uint = 0x02;
pub const JSPROP_PERMANENT: c_uint = 0x04;
pub const JSPROP_GETTER: c_uint = 0x10;
pub const JSPROP_SETTER: c_uint = 0x20;
pub const JSPROP_SHARED: c_uint = 0x40;
pub const JSPROP_NATIVE_ACCESSORS: c_uint = 0x08;
pub const JSCLASS_RESERVED_SLOTS_SHIFT: c_uint = 8;
pub const JSCLASS_RESERVED_SLOTS_WIDTH: c_uint = 8;
pub const JSCLASS_RESERVED_SLOTS_MASK: c_uint = ((1 << JSCLASS_RESERVED_SLOTS_WIDTH) - 1) as c_uint;
pub const JSCLASS_HIGH_FLAGS_SHIFT: c_uint =
JSCLASS_RESERVED_SLOTS_SHIFT + JSCLASS_RESERVED_SLOTS_WIDTH;
pub const JSCLASS_IS_GLOBAL: c_uint = 1 << (JSCLASS_HIGH_FLAGS_SHIFT + 1);
pub const JSCLASS_GLOBAL_APPLICATION_SLOTS: c_uint = 4;
pub const JSCLASS_GLOBAL_SLOT_COUNT: c_uint = JSCLASS_GLOBAL_APPLICATION_SLOTS + JSProtoKey::JSProto_LIMIT as u32 * 3 + 31;
pub const JSCLASS_IS_DOMJSCLASS: u32 = 1 << 4;
pub const JSCLASS_IMPLEMENTS_BARRIERS: u32 = 1 << 5;
pub const JSCLASS_USERBIT1: u32 = 1 << 7;
pub const JSCLASS_IS_PROXY: u32 = 1 << (JSCLASS_HIGH_FLAGS_SHIFT+4);
pub const JSSLOT_PROXY_PRIVATE: u32 = 1;
pub const JS_DEFAULT_ZEAL_FREQ: u32 = 100;
pub const JSTrue: u8 = 1;
pub const JSFalse: u8 = 0;
#[link(name = "jsglue")]
extern { }
#[cfg(target_os = "android")]
#[link(name = "stdc++")]
extern { }
#[cfg(target_os = "android")]
#[link(name = "gcc")]
extern { }
#[inline(always)]
pub unsafe fn JS_ARGV(_cx: *mut JSContext, vp: *mut JSVal) -> *mut JSVal {
vp.offset(2)
}
#[inline(always)]
pub unsafe fn JS_CALLEE(_cx: *mut JSContext, vp: *mut JSVal) -> JSVal |
// This is measured properly by the heap measurement implemented in SpiderMonkey.
impl<T: Copy + GCMethods<T>> HeapSizeOf for Heap<T> {
fn heap_size_of_children(&self) -> usize {
0
}
}
known_heap_size!(0, JSVal);
| {
*vp
} | identifier_body |
lib.rs | /* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */
#![crate_name = "js"]
#![crate_type = "rlib"]
#![feature(core_intrinsics)]
#![feature(link_args)]
#![feature(str_utf16)]
#![feature(unsafe_no_drop_flag)]
#![allow(non_upper_case_globals, non_camel_case_types, non_snake_case, improper_ctypes, raw_pointer_derive)]
extern crate libc;
#[macro_use]
extern crate log;
#[macro_use]
extern crate heapsize;
extern crate rustc_serialize as serialize;
pub mod jsapi;
pub mod linkhack;
pub mod rust;
pub mod glue;
pub mod jsval;
use jsapi::{JSContext, JSProtoKey, Heap};
use jsval::JSVal;
use rust::GCMethods;
use libc::c_uint;
use heapsize::HeapSizeOf;
pub const default_heapsize: u32 = 32_u32 * 1024_u32 * 1024_u32;
pub const default_stacksize: usize = 8192;
pub const JSID_TYPE_STRING: i64 = 0;
pub const JSID_TYPE_INT: i64 = 1;
pub const JSID_TYPE_VOID: i64 = 2;
pub const JSID_TYPE_OBJECT: i64 = 4;
pub const JSID_TYPE_DEFAULT_XML_NAMESPACE: i64 = 6;
pub const JSID_TYPE_MASK: i64 = 7;
pub const JSFUN_CONSTRUCTOR: u32 = 0x400; /* native that can be called as a ctor */
pub const JSPROP_ENUMERATE: c_uint = 0x01;
pub const JSPROP_READONLY: c_uint = 0x02;
pub const JSPROP_PERMANENT: c_uint = 0x04;
pub const JSPROP_GETTER: c_uint = 0x10;
pub const JSPROP_SETTER: c_uint = 0x20;
pub const JSPROP_SHARED: c_uint = 0x40;
pub const JSPROP_NATIVE_ACCESSORS: c_uint = 0x08;
pub const JSCLASS_RESERVED_SLOTS_SHIFT: c_uint = 8;
pub const JSCLASS_RESERVED_SLOTS_WIDTH: c_uint = 8;
pub const JSCLASS_RESERVED_SLOTS_MASK: c_uint = ((1 << JSCLASS_RESERVED_SLOTS_WIDTH) - 1) as c_uint;
pub const JSCLASS_HIGH_FLAGS_SHIFT: c_uint =
JSCLASS_RESERVED_SLOTS_SHIFT + JSCLASS_RESERVED_SLOTS_WIDTH;
pub const JSCLASS_IS_GLOBAL: c_uint = 1 << (JSCLASS_HIGH_FLAGS_SHIFT + 1);
pub const JSCLASS_GLOBAL_APPLICATION_SLOTS: c_uint = 4;
pub const JSCLASS_GLOBAL_SLOT_COUNT: c_uint = JSCLASS_GLOBAL_APPLICATION_SLOTS + JSProtoKey::JSProto_LIMIT as u32 * 3 + 31;
pub const JSCLASS_IS_DOMJSCLASS: u32 = 1 << 4;
pub const JSCLASS_IMPLEMENTS_BARRIERS: u32 = 1 << 5;
pub const JSCLASS_USERBIT1: u32 = 1 << 7;
pub const JSCLASS_IS_PROXY: u32 = 1 << (JSCLASS_HIGH_FLAGS_SHIFT+4);
pub const JSSLOT_PROXY_PRIVATE: u32 = 1;
pub const JS_DEFAULT_ZEAL_FREQ: u32 = 100;
pub const JSTrue: u8 = 1;
pub const JSFalse: u8 = 0;
#[link(name = "jsglue")]
extern { }
#[cfg(target_os = "android")]
#[link(name = "stdc++")]
extern { }
#[cfg(target_os = "android")]
#[link(name = "gcc")]
extern { }
#[inline(always)]
pub unsafe fn JS_ARGV(_cx: *mut JSContext, vp: *mut JSVal) -> *mut JSVal {
vp.offset(2)
}
#[inline(always)]
pub unsafe fn JS_CALLEE(_cx: *mut JSContext, vp: *mut JSVal) -> JSVal {
*vp
}
// This is measured properly by the heap measurement implemented in SpiderMonkey.
impl<T: Copy + GCMethods<T>> HeapSizeOf for Heap<T> {
fn | (&self) -> usize {
0
}
}
known_heap_size!(0, JSVal);
| heap_size_of_children | identifier_name |
window.rs | -> &mut glfw::Window {
&mut self.window
}
/// The window width.
#[inline]
pub fn width(&self) -> f32 {
let (w, _) = self.window.get_size();
w as f32
}
/// The window height.
#[inline]
pub fn height(&self) -> f32 {
let (_, h) = self.window.get_size();
h as f32
}
/// The size of the window.
#[inline]
pub fn size(&self) -> Vec2<f32> {
let (w, h) = self.window.get_size();
Vec2::new(w as f32, h as f32)
}
/// Sets the maximum number of frames per second. Cannot be 0. `None` means there is no limit.
#[inline]
pub fn set_framerate_limit(&mut self, fps: Option<u64>) {
self.max_ms_per_frame = fps.map(|f| { assert!(f!= 0); 1000 / f })
}
/// Set window title
pub fn set_title(&mut self, title: &str) {
self.window.set_title(title)
}
/// Closes the window.
#[inline]
pub fn close(&mut self) {
self.window.set_should_close(true)
}
/// Hides the window, without closing it. Use `show` to make it visible again.
#[inline]
pub fn hide(&mut self) {
self.window.hide()
}
/// Makes the window visible. Use `hide` to hide it.
#[inline]
pub fn show(&mut self) {
self.window.show()
}
/// Sets the background color.
#[inline]
pub fn set_background_color(&mut self, r: f32, g: GLfloat, b: f32) {
self.background.x = r;
self.background.y = g;
self.background.z = b;
}
// XXX: remove this (moved to the render_frame).
/// Adds a line to be drawn during the next frame.
#[inline]
pub fn draw_line(&mut self, a: &Pnt3<f32>, b: &Pnt3<f32>, color: &Pnt3<f32>) {
self.line_renderer.draw_line(a.clone(), b.clone(), color.clone());
}
// XXX: remove this (moved to the render_frame).
/// Adds a point to be drawn during the next frame.
#[inline]
pub fn draw_point(&mut self, pt: &Pnt3<f32>, color: &Pnt3<f32>) {
self.point_renderer.draw_point(pt.clone(), color.clone());
}
// XXX: remove this (moved to the render_frame).
/// Adds a string to be drawn during the next frame.
#[inline]
pub fn draw_text(&mut self, text: &str, pos: &Pnt2<f32>, font: &Rc<Font>, color: &Pnt3<f32>) {
self.text_renderer.draw_text(text, pos, font, color);
}
/// Removes an object from the scene.
pub fn remove(&mut self, sn: &mut SceneNode) {
sn.unlink()
}
/// Adds a group to the scene.
///
/// A group is a node not containing any object.
pub fn add_group(&mut self) -> SceneNode {
self.scene.add_group()
}
/// Adds an obj model to the scene.
///
/// # Arguments
/// * `path` - relative path to the obj file.
/// * `scale` - scale to apply to the model.
pub fn add_obj(&mut self, path: &Path, mtl_dir: &Path, scale: Vec3<f32>) -> SceneNode {
self.scene.add_obj(path, mtl_dir, scale)
}
/// Adds an unnamed mesh to the scene.
pub fn add_mesh(&mut self, mesh: Rc<RefCell<Mesh>>, scale: Vec3<f32>) -> SceneNode {
self.scene.add_mesh(mesh, scale)
}
/// Creates and adds a new object using the geometry generated by a given procedural generator.
/// Creates and adds a new object using a mesh descriptor.
pub fn add_trimesh(&mut self, descr: TriMesh3<f32>, scale: Vec3<f32>) -> SceneNode {
self.scene.add_trimesh(descr, scale)
}
/// Creates and adds a new object using the geometry registered as `geometry_name`.
pub fn add_geom_with_name(&mut self, geometry_name: &str, scale: Vec3<f32>) -> Option<SceneNode> {
self.scene.add_geom_with_name(geometry_name, scale)
}
/// Adds a cube to the scene. The cube is initially axis-aligned and centered at (0, 0, 0).
///
/// # Arguments
/// * `wx` - the cube extent along the z axis
/// * `wy` - the cube extent along the y axis
/// * `wz` - the cube extent along the z axis
pub fn add_cube(&mut self, wx: GLfloat, wy: GLfloat, wz: GLfloat) -> SceneNode {
self.scene.add_cube(wx, wy, wz)
}
/// Adds a sphere to the scene. The sphere is initially centered at (0, 0, 0).
///
/// # Arguments
/// * `r` - the sphere radius
pub fn add_sphere(&mut self, r: GLfloat) -> SceneNode {
self.scene.add_sphere(r)
}
/// Adds a cone to the scene. The cone is initially centered at (0, 0, 0) and points toward the
/// positive `y` axis.
///
/// # Arguments
/// * `h` - the cone height
/// * `r` - the cone base radius
pub fn add_cone(&mut self, r: GLfloat, h: GLfloat) -> SceneNode {
self.scene.add_cone(r, h)
}
/// Adds a cylinder to the scene. The cylinder is initially centered at (0, 0, 0) and has its
/// principal axis aligned with the `y` axis.
///
/// # Arguments
/// * `h` - the cylinder height
/// * `r` - the cylinder base radius
pub fn add_cylinder(&mut self, r: GLfloat, h: GLfloat) -> SceneNode {
self.scene.add_cylinder(r, h)
}
/// Adds a capsule to the scene. The capsule is initially centered at (0, 0, 0) and has its
/// principal axis aligned with the `y` axis.
///
/// # Arguments
/// * `h` - the capsule height
/// * `r` - the capsule caps radius
pub fn add_capsule(&mut self, r: GLfloat, h: GLfloat) -> SceneNode {
self.scene.add_capsule(r, h)
}
/// Adds a double-sided quad to the scene. The quad is initially centered at (0, 0, 0). The
/// quad itself is composed of a user-defined number of triangles regularly spaced on a grid.
/// This is the main way to draw height maps.
///
/// # Arguments
/// * `w` - the quad width.
/// * `h` - the quad height.
/// * `wsubdivs` - number of horizontal subdivisions. This correspond to the number of squares
/// which will be placed horizontally on each line. Must not be `0`.
/// * `hsubdivs` - number of vertical subdivisions. This correspond to the number of squares
/// which will be placed vertically on each line. Must not be `0`.
/// update.
pub fn add_quad(&mut self, w: f32, h: f32, usubdivs: usize, vsubdivs: usize) -> SceneNode {
self.scene.add_quad(w, h, usubdivs, vsubdivs)
}
/// Adds a double-sided quad with the specified vertices.
pub fn add_quad_with_vertices(&mut self,
vertices: &[Pnt3<f32>],
nhpoints: usize,
nvpoints: usize)
-> SceneNode {
self.scene.add_quad_with_vertices(vertices, nhpoints, nvpoints)
}
#[doc(hidden)]
pub fn add_texture(&mut self, path: &Path, name: &str) -> Rc<Texture> {
TextureManager::get_global_manager(|tm| tm.add(path, name))
}
/// Returns whether this window is closed or not.
pub fn is_closed(&self) -> bool {
false // FIXME
}
/// Sets the light mode. Only one light is supported.
pub fn set_light(&mut self, pos: Light) {
self.light_mode = pos;
}
/// Opens a window, hide it then calls a user-defined procedure.
///
/// # Arguments
/// * `title` - the window title
pub fn new_hidden(title: &str) -> Window {
Window::do_new(title, true, DEFAULT_WIDTH, DEFAULT_HEIGHT)
}
/// Opens a window then calls a user-defined procedure.
///
/// # Arguments
/// * `title` - the window title
pub fn new(title: &str) -> Window {
Window::do_new(title, false, DEFAULT_WIDTH, DEFAULT_HEIGHT)
}
/// Opens a window with a custom size then calls a user-defined procedure.
///
/// # Arguments
/// * `title` - the window title.
/// * `width` - the window width.
/// * `height` - the window height.
pub fn new_with_size(title: &str, width: u32, height: u32) -> Window {
Window::do_new(title, false, width, height)
}
// FIXME: make this pub?
fn do_new(title: &str, hide: bool, width: u32, height: u32) -> Window {
// FIXME: glfw::set_error_callback(~ErrorCallback);
let glfw = glfw::init(glfw::FAIL_ON_ERRORS).unwrap();
let (mut window, events) = glfw.create_window(width, height, title, WindowMode::Windowed).expect("Unable to open a glfw window.");
window.make_current();
verify!(gl::load_with(|name| window.get_proc_address(name) as *const _));
init_gl();
let mut usr_window = Window {
max_ms_per_frame: None,
glfw: glfw,
window: window,
events: Rc::new(events),
unhandled_events: Rc::new(RefCell::new(Vec::new())),
scene: SceneNode::new_empty(),
light_mode: Light::Absolute(Pnt3::new(0.0, 10.0, 0.0)),
background: Vec3::new(0.0, 0.0, 0.0),
line_renderer: LineRenderer::new(),
point_renderer: PointRenderer::new(),
text_renderer: TextRenderer::new(),
post_process_render_target: FramebufferManager::new_render_target(width as usize, height as usize),
framebuffer_manager: FramebufferManager::new(),
curr_time: time::precise_time_ns(),
camera: Rc::new(RefCell::new(ArcBall::new(Pnt3::new(0.0f32, 0.0, -1.0), na::orig())))
};
// setup callbacks
usr_window.window.set_framebuffer_size_polling(true);
usr_window.window.set_key_polling(true);
usr_window.window.set_mouse_button_polling(true);
usr_window.window.set_cursor_pos_polling(true);
usr_window.window.set_scroll_polling(true);
if hide {
usr_window.window.hide()
}
// usr_window.framebuffer_size_callback(DEFAULT_WIDTH, DEFAULT_HEIGHT);
let light = usr_window.light_mode.clone();
usr_window.set_light(light);
usr_window
}
/// Reference to the scene associated with this window.
#[inline]
pub fn scene<'a>(&'a self) -> &'a SceneNode {
&self.scene
}
/// Mutable reference to the scene associated with this window.
#[inline]
pub fn scene_mut<'a>(&'a mut self) -> &'a mut SceneNode {
&mut self.scene
}
// FIXME: give more options for the snap size and offset.
/// Read the pixels currently displayed to the screen.
///
/// # Arguments:
/// * `out` - the output buffer. It is automatically resized.
pub fn snap(&self, out: &mut Vec<u8>) {
let (width, height) = self.window.get_size();
self.snap_rect(out, 0, 0, width as usize, height as usize)
}
/// Read a section of pixels from the screen
///
/// # Arguments:
/// * `out` - the output buffer. It is automatically resized
/// * `x, y, width, height` - the rectangle to capture
pub fn snap_rect(&self, out: &mut Vec<u8>, x: usize, y: usize, width: usize, height: usize) {
let size = (width * height * 3) as usize;
if out.len() < size {
let diff = size - out.len();
out.extend(repeat(0).take(diff));
}
else {
out.truncate(size)
}
// FIXME: this is _not_ the fastest way of doing this.
unsafe {
gl::PixelStorei(gl::PACK_ALIGNMENT, 1);
gl::ReadPixels(x as i32, y as i32,
width as i32, height as i32,
gl::RGB,
gl::UNSIGNED_BYTE,
mem::transmute(&mut out[0]));
}
}
/// Get the current screen as an image
pub fn snap_image(&self) -> ImageBuffer<Rgb<u8>, Vec<u8>> {
let (width, height) = self.window.get_size();
let mut buf = Vec::new();
self.snap(&mut buf);
let img_opt = ImageBuffer::from_vec(width as u32, height as u32, buf);
let img = img_opt.expect("Buffer created from window was not big enough for image.");
imageops::flip_vertical(&img)
}
/// Gets the events manager that gives access to an event iterator.
pub fn events(&self) -> EventManager {
EventManager::new(self.events.clone(), self.unhandled_events.clone())
}
/// Poll events and pass them to a user-defined function. If the function returns `true`, the
/// default engine event handler (camera, framebuffer size, etc.) is executed, if it returns
/// `false`, the default engine event handler is not executed. Return `false` if you want to
/// override the default engine behaviour.
#[inline]
fn handle_events(&mut self, camera: &mut Option<&mut Camera>) {
let unhandled_events = self.unhandled_events.clone(); // FIXME: this is very ugly.
let events = self.events.clone(); // FIXME: this is very ugly
for event in unhandled_events.borrow().iter() {
self.handle_event(camera, event)
}
for event in glfw::flush_messages(&*events) {
self.handle_event(camera, &event.1)
}
unhandled_events.borrow_mut().clear();
self.glfw.poll_events();
}
fn handle_event(&mut self, camera: &mut Option<&mut Camera>, event: &WindowEvent) {
match *event {
WindowEvent::Key(Key::Escape, _, Action::Release, _) => {
self.close();
},
WindowEvent::FramebufferSize(w, h) => {
self.update_viewport(w as f32, h as f32);
},
_ => { }
}
match *camera {
Some(ref mut cam) => cam.handle_event(&self.window, event),
None => self.camera.borrow_mut().handle_event(&self.window, event)
}
}
/// Renders the scene using the default camera.
///
/// Returns `false` if the window should be closed.
pub fn render(&mut self) -> bool {
self.render_with(None, None)
}
/// Render using a specific post processing effect.
///
/// Returns `false` if the window should be closed.
pub fn render_with_effect(&mut self, effect: &mut PostProcessingEffect) -> bool {
self.render_with(None, Some(effect))
}
/// Render using a specific camera.
///
/// Returns `false` if the window should be closed.
pub fn render_with_camera(&mut self, camera: &mut Camera) -> bool {
self.render_with(Some(camera), None)
}
/// Render using a specific camera and post processing effect.
///
/// Returns `false` if the window should be closed.
pub fn render_with_camera_and_effect(&mut self, camera: &mut Camera, effect: &mut PostProcessingEffect) -> bool {
self.render_with(Some(camera), Some(effect))
}
/// Draws the scene with the given camera and post-processing effect.
///
/// Returns `false` if the window should be closed.
pub fn render_with(&mut self,
camera: Option<&mut Camera>,
post_processing: Option<&mut PostProcessingEffect>)
-> bool {
let mut camera = camera;
self.handle_events(&mut camera);
match camera {
Some(cam) => self.do_render_with(cam, post_processing),
None => {
let self_cam = self.camera.clone(); // FIXME: this is ugly.
let mut bself_cam = self_cam.borrow_mut();
self.do_render_with(&mut *bself_cam, post_processing)
}
}
}
fn do_render_with(&mut self,
camera: &mut Camera,
post_processing: Option<&mut PostProcessingEffect>)
-> bool {
// XXX: too bad we have to do this at each frame…
let w = self.width();
let h = self.height();
camera.handle_event(&self.window, &WindowEvent::FramebufferSize(w as i32, h as i32));
camera.update(&self.window);
match self.light_mode {
Light::StickToCamera => self.set_light(Light::StickToCamera),
_ => { }
}
let mut post_processing = post_processing;
if post_processing.is_some() {
// if we need post-processing, render to our own frame buffer
self.framebuffer_manager.select(&self.post_process_render_target);
}
else {
self.framebuffer_manager.select(&FramebufferManager::screen());
}
for pass in 0usize.. camera.num_passes() {
camera.start_pass(pass, &self.window);
self.render_scene(camera, pass);
}
camera.render_complete(&self.window);
let (znear, zfar) = camera.clip_planes();
// FIXME: remove this completely?
// swatch off the wireframe mode for post processing and text rendering.
// if self.wireframe_mode {
// verify!(gl::PolygonMode(gl::FRONT_AND_BACK, gl::FILL));
// }
match post_processing {
Some(ref mut p) => {
// switch back to the screen framebuffer …
self.framebuffer_manager.select(&FramebufferManager::screen());
// … and execute the post-process
// FIXME: use the real time value instead of 0.016!
p.update(0.016, w, h, znear, zfar);
p.draw(&self.post_process_render_target);
},
None => { }
}
self.text_renderer.render(w, h);
// We are done: swap buffers
self.window.swap_buffers();
// Limit the fps if needed.
match self.max_ms_per_frame {
None => { },
Some(ms) => {
let elapsed = (time::precise_time_ns() - self.curr_time) / 1000000;
if elapsed < ms {
thread::sleep(Duration::from_millis(ms - elapsed));
}
}
}
self.curr_time = time::precise_time_ns();
// self.transparent_objects.clear();
// self.opaque_objects.clear();
!self.should_close()
}
fn render_scene(&mut self, camera: &mut Camera, pass: usize) {
// Activate the default texture
verify!(gl::ActiveTexture(gl::TEXTURE0));
// Clear the screen to black
verify!(gl::ClearColor(self.background.x, self.background.y, self.background.z, 1.0));
verify!(gl::Clear(gl::COLOR_BUFFER_BIT));
verify!(gl::Clear(gl::DEPTH_BUFFER_BIT));
if self.line_renderer.needs_rendering() {
self.line_renderer.render(pass, camera);
}
if self.point_renderer.needs_rendering() {
self.point_renderer.render(pass, camera);
}
self.scene.data_mut().render(pass, camera, &self.light_mode);
}
fn update_viewport(&mut self, w: f32, h: f32) {
// Update the viewport
verify!(gl::Scissor(0, 0, w as i32, h as i32));
FramebufferManager::screen().resize(w, h);
self.post_process_render_target.resize(w, h);
}
}
fn init_gl() {
/*
* Misc configurations
*/ | verify!(gl::FrontFace(gl::CCW));
verify!(gl::Enable(gl::DEPTH_TEST)); | random_line_split |
|
window.rs |
/// This is the main interface with the 3d engine.
pub struct Window {
events: Rc<Receiver<(f64, WindowEvent)>>,
unhandled_events: Rc<RefCell<Vec<WindowEvent>>>,
glfw: glfw::Glfw,
window: glfw::Window,
max_ms_per_frame: Option<u64>,
scene: SceneNode,
light_mode: Light, // FIXME: move that to the scene graph
background: Vec3<GLfloat>,
line_renderer: LineRenderer,
point_renderer: PointRenderer,
text_renderer: TextRenderer,
framebuffer_manager: FramebufferManager,
post_process_render_target: RenderTarget,
curr_time: u64,
camera: Rc<RefCell<ArcBall>>
}
impl Window {
/// Indicates whether this window should be closed.
#[inline]
pub fn should_close(&self) -> bool {
self.window.should_close()
}
/// Access the glfw context.
#[inline]
pub fn context<'r>(&'r self) -> &'r glfw::Glfw {
&self.glfw
}
/// Access the glfw window.
#[inline]
pub fn glfw_window(&self) -> &glfw::Window {
&self.window
}
/// Mutably access the glfw window.
#[inline]
pub fn glfw_window_mut(&mut self) -> &mut glfw::Window {
&mut self.window
}
/// The window width.
#[inline]
pub fn width(&self) -> f32 {
let (w, _) = self.window.get_size();
w as f32
}
/// The window height.
#[inline]
pub fn height(&self) -> f32 {
let (_, h) = self.window.get_size();
h as f32
}
/// The size of the window.
#[inline]
pub fn size(&self) -> Vec2<f32> {
let (w, h) = self.window.get_size();
Vec2::new(w as f32, h as f32)
}
/// Sets the maximum number of frames per second. Cannot be 0. `None` means there is no limit.
#[inline]
pub fn set_framerate_limit(&mut self, fps: Option<u64>) {
self.max_ms_per_frame = fps.map(|f| { assert!(f!= 0); 1000 / f })
}
/// Set window title
pub fn set_title(&mut self, title: &str) {
self.window.set_title(title)
}
/// Closes the window.
#[inline]
pub fn close(&mut self) {
self.window.set_should_close(true)
}
/// Hides the window, without closing it. Use `show` to make it visible again.
#[inline]
pub fn hide(&mut self) {
self.window.hide()
}
/// Makes the window visible. Use `hide` to hide it.
#[inline]
pub fn show(&mut self) {
self.window.show()
}
/// Sets the background color.
#[inline]
pub fn set_background_color(&mut self, r: f32, g: GLfloat, b: f32) {
self.background.x = r;
self.background.y = g;
self.background.z = b;
}
// XXX: remove this (moved to the render_frame).
/// Adds a line to be drawn during the next frame.
#[inline]
pub fn draw_line(&mut self, a: &Pnt3<f32>, b: &Pnt3<f32>, color: &Pnt3<f32>) {
self.line_renderer.draw_line(a.clone(), b.clone(), color.clone());
}
// XXX: remove this (moved to the render_frame).
/// Adds a point to be drawn during the next frame.
#[inline]
pub fn draw_point(&mut self, pt: &Pnt3<f32>, color: &Pnt3<f32>) {
self.point_renderer.draw_point(pt.clone(), color.clone());
}
// XXX: remove this (moved to the render_frame).
/// Adds a string to be drawn during the next frame.
#[inline]
pub fn draw_text(&mut self, text: &str, pos: &Pnt2<f32>, font: &Rc<Font>, color: &Pnt3<f32>) {
self.text_renderer.draw_text(text, pos, font, color);
}
/// Removes an object from the scene.
pub fn remove(&mut self, sn: &mut SceneNode) {
sn.unlink()
}
/// Adds a group to the scene.
///
/// A group is a node not containing any object.
pub fn add_group(&mut self) -> SceneNode {
self.scene.add_group()
}
/// Adds an obj model to the scene.
///
/// # Arguments
/// * `path` - relative path to the obj file.
/// * `scale` - scale to apply to the model.
pub fn add_obj(&mut self, path: &Path, mtl_dir: &Path, scale: Vec3<f32>) -> SceneNode {
self.scene.add_obj(path, mtl_dir, scale)
}
/// Adds an unnamed mesh to the scene.
pub fn add_mesh(&mut self, mesh: Rc<RefCell<Mesh>>, scale: Vec3<f32>) -> SceneNode {
self.scene.add_mesh(mesh, scale)
}
/// Creates and adds a new object using the geometry generated by a given procedural generator.
/// Creates and adds a new object using a mesh descriptor.
pub fn add_trimesh(&mut self, descr: TriMesh3<f32>, scale: Vec3<f32>) -> SceneNode |
/// Creates and adds a new object using the geometry registered as `geometry_name`.
pub fn add_geom_with_name(&mut self, geometry_name: &str, scale: Vec3<f32>) -> Option<SceneNode> {
self.scene.add_geom_with_name(geometry_name, scale)
}
/// Adds a cube to the scene. The cube is initially axis-aligned and centered at (0, 0, 0).
///
/// # Arguments
/// * `wx` - the cube extent along the z axis
/// * `wy` - the cube extent along the y axis
/// * `wz` - the cube extent along the z axis
pub fn add_cube(&mut self, wx: GLfloat, wy: GLfloat, wz: GLfloat) -> SceneNode {
self.scene.add_cube(wx, wy, wz)
}
/// Adds a sphere to the scene. The sphere is initially centered at (0, 0, 0).
///
/// # Arguments
/// * `r` - the sphere radius
pub fn add_sphere(&mut self, r: GLfloat) -> SceneNode {
self.scene.add_sphere(r)
}
/// Adds a cone to the scene. The cone is initially centered at (0, 0, 0) and points toward the
/// positive `y` axis.
///
/// # Arguments
/// * `h` - the cone height
/// * `r` - the cone base radius
pub fn add_cone(&mut self, r: GLfloat, h: GLfloat) -> SceneNode {
self.scene.add_cone(r, h)
}
/// Adds a cylinder to the scene. The cylinder is initially centered at (0, 0, 0) and has its
/// principal axis aligned with the `y` axis.
///
/// # Arguments
/// * `h` - the cylinder height
/// * `r` - the cylinder base radius
pub fn add_cylinder(&mut self, r: GLfloat, h: GLfloat) -> SceneNode {
self.scene.add_cylinder(r, h)
}
/// Adds a capsule to the scene. The capsule is initially centered at (0, 0, 0) and has its
/// principal axis aligned with the `y` axis.
///
/// # Arguments
/// * `h` - the capsule height
/// * `r` - the capsule caps radius
pub fn add_capsule(&mut self, r: GLfloat, h: GLfloat) -> SceneNode {
self.scene.add_capsule(r, h)
}
/// Adds a double-sided quad to the scene. The quad is initially centered at (0, 0, 0). The
/// quad itself is composed of a user-defined number of triangles regularly spaced on a grid.
/// This is the main way to draw height maps.
///
/// # Arguments
/// * `w` - the quad width.
/// * `h` - the quad height.
/// * `wsubdivs` - number of horizontal subdivisions. This correspond to the number of squares
/// which will be placed horizontally on each line. Must not be `0`.
/// * `hsubdivs` - number of vertical subdivisions. This correspond to the number of squares
/// which will be placed vertically on each line. Must not be `0`.
/// update.
pub fn add_quad(&mut self, w: f32, h: f32, usubdivs: usize, vsubdivs: usize) -> SceneNode {
self.scene.add_quad(w, h, usubdivs, vsubdivs)
}
/// Adds a double-sided quad with the specified vertices.
pub fn add_quad_with_vertices(&mut self,
vertices: &[Pnt3<f32>],
nhpoints: usize,
nvpoints: usize)
-> SceneNode {
self.scene.add_quad_with_vertices(vertices, nhpoints, nvpoints)
}
#[doc(hidden)]
pub fn add_texture(&mut self, path: &Path, name: &str) -> Rc<Texture> {
TextureManager::get_global_manager(|tm| tm.add(path, name))
}
/// Returns whether this window is closed or not.
pub fn is_closed(&self) -> bool {
false // FIXME
}
/// Sets the light mode. Only one light is supported.
pub fn set_light(&mut self, pos: Light) {
self.light_mode = pos;
}
/// Opens a window, hide it then calls a user-defined procedure.
///
/// # Arguments
/// * `title` - the window title
pub fn new_hidden(title: &str) -> Window {
Window::do_new(title, true, DEFAULT_WIDTH, DEFAULT_HEIGHT)
}
/// Opens a window then calls a user-defined procedure.
///
/// # Arguments
/// * `title` - the window title
pub fn new(title: &str) -> Window {
Window::do_new(title, false, DEFAULT_WIDTH, DEFAULT_HEIGHT)
}
/// Opens a window with a custom size then calls a user-defined procedure.
///
/// # Arguments
/// * `title` - the window title.
/// * `width` - the window width.
/// * `height` - the window height.
pub fn new_with_size(title: &str, width: u32, height: u32) -> Window {
Window::do_new(title, false, width, height)
}
// FIXME: make this pub?
fn do_new(title: &str, hide: bool, width: u32, height: u32) -> Window {
// FIXME: glfw::set_error_callback(~ErrorCallback);
let glfw = glfw::init(glfw::FAIL_ON_ERRORS).unwrap();
let (mut window, events) = glfw.create_window(width, height, title, WindowMode::Windowed).expect("Unable to open a glfw window.");
window.make_current();
verify!(gl::load_with(|name| window.get_proc_address(name) as *const _));
init_gl();
let mut usr_window = Window {
max_ms_per_frame: None,
glfw: glfw,
window: window,
events: Rc::new(events),
unhandled_events: Rc::new(RefCell::new(Vec::new())),
scene: SceneNode::new_empty(),
light_mode: Light::Absolute(Pnt3::new(0.0, 10.0, 0.0)),
background: Vec3::new(0.0, 0.0, 0.0),
line_renderer: LineRenderer::new(),
point_renderer: PointRenderer::new(),
text_renderer: TextRenderer::new(),
post_process_render_target: FramebufferManager::new_render_target(width as usize, height as usize),
framebuffer_manager: FramebufferManager::new(),
curr_time: time::precise_time_ns(),
camera: Rc::new(RefCell::new(ArcBall::new(Pnt3::new(0.0f32, 0.0, -1.0), na::orig())))
};
// setup callbacks
usr_window.window.set_framebuffer_size_polling(true);
usr_window.window.set_key_polling(true);
usr_window.window.set_mouse_button_polling(true);
usr_window.window.set_cursor_pos_polling(true);
usr_window.window.set_scroll_polling(true);
if hide {
usr_window.window.hide()
}
// usr_window.framebuffer_size_callback(DEFAULT_WIDTH, DEFAULT_HEIGHT);
let light = usr_window.light_mode.clone();
usr_window.set_light(light);
usr_window
}
/// Reference to the scene associated with this window.
#[inline]
pub fn scene<'a>(&'a self) -> &'a SceneNode {
&self.scene
}
/// Mutable reference to the scene associated with this window.
#[inline]
pub fn scene_mut<'a>(&'a mut self) -> &'a mut SceneNode {
&mut self.scene
}
// FIXME: give more options for the snap size and offset.
/// Read the pixels currently displayed to the screen.
///
/// # Arguments:
/// * `out` - the output buffer. It is automatically resized.
pub fn snap(&self, out: &mut Vec<u8>) {
let (width, height) = self.window.get_size();
self.snap_rect(out, 0, 0, width as usize, height as usize)
}
/// Read a section of pixels from the screen
///
/// # Arguments:
/// * `out` - the output buffer. It is automatically resized
/// * `x, y, width, height` - the rectangle to capture
pub fn snap_rect(&self, out: &mut Vec<u8>, x: usize, y: usize, width: usize, height: usize) {
let size = (width * height * 3) as usize;
if out.len() < size {
let diff = size - out.len();
out.extend(repeat(0).take(diff));
}
else {
out.truncate(size)
}
// FIXME: this is _not_ the fastest way of doing this.
unsafe {
gl::PixelStorei(gl::PACK_ALIGNMENT, 1);
gl::ReadPixels(x as i32, y as i32,
width as i32, height as i32,
gl::RGB,
gl::UNSIGNED_BYTE,
mem::transmute(&mut out[0]));
}
}
/// Get the current screen as an image
pub fn snap_image(&self) -> ImageBuffer<Rgb<u8>, Vec<u8>> {
let (width, height) = self.window.get_size();
let mut buf = Vec::new();
self.snap(&mut buf);
let img_opt = ImageBuffer::from_vec(width as u32, height as u32, buf);
let img = img_opt.expect("Buffer created from window was not big enough for image.");
imageops::flip_vertical(&img)
}
/// Gets the events manager that gives access to an event iterator.
pub fn events(&self) -> EventManager {
EventManager::new(self.events.clone(), self.unhandled_events.clone())
}
/// Poll events and pass them to a user-defined function. If the function returns `true`, the
/// default engine event handler (camera, framebuffer size, etc.) is executed, if it returns
/// `false`, the default engine event handler is not executed. Return `false` if you want to
/// override the default engine behaviour.
#[inline]
fn handle_events(&mut self, camera: &mut Option<&mut Camera>) {
let unhandled_events = self.unhandled_events.clone(); // FIXME: this is very ugly.
let events = self.events.clone(); // FIXME: this is very ugly
for event in unhandled_events.borrow().iter() {
self.handle_event(camera, event)
}
for event in glfw::flush_messages(&*events) {
self.handle_event(camera, &event.1)
}
unhandled_events.borrow_mut().clear();
self.glfw.poll_events();
}
fn handle_event(&mut self, camera: &mut Option<&mut Camera>, event: &WindowEvent) {
match *event {
WindowEvent::Key(Key::Escape, _, Action::Release, _) => {
self.close();
},
WindowEvent::FramebufferSize(w, h) => {
self.update_viewport(w as f32, h as f32);
},
_ => { }
}
match *camera {
Some(ref mut cam) => cam.handle_event(&self.window, event),
None => self.camera.borrow_mut().handle_event(&self.window, event)
}
}
/// Renders the scene using the default camera.
///
/// Returns `false` if the window should be closed.
pub fn render(&mut self) -> bool {
self.render_with(None, None)
}
/// Render using a specific post processing effect.
///
/// Returns `false` if the window should be closed.
pub fn render_with_effect(&mut self, effect: &mut PostProcessingEffect) -> bool {
self.render_with(None, Some(effect))
}
/// Render using a specific camera.
///
/// Returns `false` if the window should be closed.
pub fn render_with_camera(&mut self, camera: &mut Camera) -> bool {
self.render_with(Some(camera), None)
}
/// Render using a specific camera and post processing effect.
///
/// Returns `false` if the window should be closed.
pub fn render_with_camera_and_effect(&mut self, camera: &mut Camera, effect: &mut PostProcessingEffect) -> bool {
self.render_with(Some(camera), Some(effect))
}
/// Draws the scene with the given camera and post-processing effect.
///
/// Returns `false` if the window should be closed.
pub fn render_with(&mut self,
camera: Option<&mut Camera>,
post_processing: Option<&mut PostProcessingEffect>)
-> bool {
let mut camera = camera;
self.handle_events(&mut camera);
match camera {
Some(cam) => self.do_render_with(cam, post_processing),
None => {
let self_cam = self.camera.clone(); // FIXME: this is ugly.
let mut bself_cam = self_cam.borrow_mut();
self.do_render_with(&mut *bself_cam, post_processing)
}
}
}
fn do_render_with(&mut self,
camera: &mut Camera,
post_processing: Option<&mut PostProcessingEffect>)
-> bool {
// XXX: too bad we have to do this at each frame…
let w = self.width();
let h = self.height();
camera.handle_event(&self.window, &WindowEvent::FramebufferSize(w as i32, h as i32));
camera.update(&self.window);
match self.light_mode {
Light::StickToCamera => self.set_light(Light::StickToCamera),
_ => { }
}
let mut post_processing = post_processing;
if post_processing.is_some() {
// if we need post-processing, render to our own frame buffer
self.framebuffer_manager.select(&self.post_process_render_target);
}
else {
self.framebuffer_manager.select(&FramebufferManager::screen());
}
for pass in 0usize.. camera.num_passes() {
camera.start_pass(pass, &self.window);
self.render_scene(camera, pass);
}
camera.render_complete(&self.window);
let (znear, zfar) = camera.clip_planes();
// FIXME: remove this completely?
// swatch off the wireframe mode for post processing and text rendering.
// if self.wireframe_mode {
// verify!(gl::PolygonMode(gl::FRONT_AND_BACK, gl::FILL));
// }
match post_processing {
Some(ref mut p) => {
// switch back to the screen framebuffer …
self.framebuffer_manager.select(&FramebufferManager::screen());
// … and execute the post-process
// FIXME: use the real time value instead of 0.016!
p.update(0.016, w, h, znear, zfar);
p.draw(&self.post_process_render_target);
},
None => { }
}
self.text_renderer.render(w, h);
// We are done: swap buffers
self.window.swap_buffers();
// Limit the fps if needed.
match self.max_ms_per_frame {
None => { },
Some(ms) => {
let elapsed = (time::precise_time_ns() - self.curr_time) / 1000000; | {
self.scene.add_trimesh(descr, scale)
} | identifier_body |
window.rs |
/// This is the main interface with the 3d engine.
pub struct Window {
events: Rc<Receiver<(f64, WindowEvent)>>,
unhandled_events: Rc<RefCell<Vec<WindowEvent>>>,
glfw: glfw::Glfw,
window: glfw::Window,
max_ms_per_frame: Option<u64>,
scene: SceneNode,
light_mode: Light, // FIXME: move that to the scene graph
background: Vec3<GLfloat>,
line_renderer: LineRenderer,
point_renderer: PointRenderer,
text_renderer: TextRenderer,
framebuffer_manager: FramebufferManager,
post_process_render_target: RenderTarget,
curr_time: u64,
camera: Rc<RefCell<ArcBall>>
}
impl Window {
/// Indicates whether this window should be closed.
#[inline]
pub fn should_close(&self) -> bool {
self.window.should_close()
}
/// Access the glfw context.
#[inline]
pub fn context<'r>(&'r self) -> &'r glfw::Glfw {
&self.glfw
}
/// Access the glfw window.
#[inline]
pub fn glfw_window(&self) -> &glfw::Window {
&self.window
}
/// Mutably access the glfw window.
#[inline]
pub fn glfw_window_mut(&mut self) -> &mut glfw::Window {
&mut self.window
}
/// The window width.
#[inline]
pub fn width(&self) -> f32 {
let (w, _) = self.window.get_size();
w as f32
}
/// The window height.
#[inline]
pub fn height(&self) -> f32 {
let (_, h) = self.window.get_size();
h as f32
}
/// The size of the window.
#[inline]
pub fn size(&self) -> Vec2<f32> {
let (w, h) = self.window.get_size();
Vec2::new(w as f32, h as f32)
}
/// Sets the maximum number of frames per second. Cannot be 0. `None` means there is no limit.
#[inline]
pub fn set_framerate_limit(&mut self, fps: Option<u64>) {
self.max_ms_per_frame = fps.map(|f| { assert!(f!= 0); 1000 / f })
}
/// Set window title
pub fn set_title(&mut self, title: &str) {
self.window.set_title(title)
}
/// Closes the window.
#[inline]
pub fn close(&mut self) {
self.window.set_should_close(true)
}
/// Hides the window, without closing it. Use `show` to make it visible again.
#[inline]
pub fn hide(&mut self) {
self.window.hide()
}
/// Makes the window visible. Use `hide` to hide it.
#[inline]
pub fn show(&mut self) {
self.window.show()
}
/// Sets the background color.
#[inline]
pub fn set_background_color(&mut self, r: f32, g: GLfloat, b: f32) {
self.background.x = r;
self.background.y = g;
self.background.z = b;
}
// XXX: remove this (moved to the render_frame).
/// Adds a line to be drawn during the next frame.
#[inline]
pub fn draw_line(&mut self, a: &Pnt3<f32>, b: &Pnt3<f32>, color: &Pnt3<f32>) {
self.line_renderer.draw_line(a.clone(), b.clone(), color.clone());
}
// XXX: remove this (moved to the render_frame).
/// Adds a point to be drawn during the next frame.
#[inline]
pub fn draw_point(&mut self, pt: &Pnt3<f32>, color: &Pnt3<f32>) {
self.point_renderer.draw_point(pt.clone(), color.clone());
}
// XXX: remove this (moved to the render_frame).
/// Adds a string to be drawn during the next frame.
#[inline]
pub fn draw_text(&mut self, text: &str, pos: &Pnt2<f32>, font: &Rc<Font>, color: &Pnt3<f32>) {
self.text_renderer.draw_text(text, pos, font, color);
}
/// Removes an object from the scene.
pub fn remove(&mut self, sn: &mut SceneNode) {
sn.unlink()
}
/// Adds a group to the scene.
///
/// A group is a node not containing any object.
pub fn add_group(&mut self) -> SceneNode {
self.scene.add_group()
}
/// Adds an obj model to the scene.
///
/// # Arguments
/// * `path` - relative path to the obj file.
/// * `scale` - scale to apply to the model.
pub fn add_obj(&mut self, path: &Path, mtl_dir: &Path, scale: Vec3<f32>) -> SceneNode {
self.scene.add_obj(path, mtl_dir, scale)
}
/// Adds an unnamed mesh to the scene.
pub fn add_mesh(&mut self, mesh: Rc<RefCell<Mesh>>, scale: Vec3<f32>) -> SceneNode {
self.scene.add_mesh(mesh, scale)
}
/// Creates and adds a new object using the geometry generated by a given procedural generator.
/// Creates and adds a new object using a mesh descriptor.
pub fn add_trimesh(&mut self, descr: TriMesh3<f32>, scale: Vec3<f32>) -> SceneNode {
self.scene.add_trimesh(descr, scale)
}
/// Creates and adds a new object using the geometry registered as `geometry_name`.
pub fn add_geom_with_name(&mut self, geometry_name: &str, scale: Vec3<f32>) -> Option<SceneNode> {
self.scene.add_geom_with_name(geometry_name, scale)
}
/// Adds a cube to the scene. The cube is initially axis-aligned and centered at (0, 0, 0).
///
/// # Arguments
/// * `wx` - the cube extent along the z axis
/// * `wy` - the cube extent along the y axis
/// * `wz` - the cube extent along the z axis
pub fn add_cube(&mut self, wx: GLfloat, wy: GLfloat, wz: GLfloat) -> SceneNode {
self.scene.add_cube(wx, wy, wz)
}
/// Adds a sphere to the scene. The sphere is initially centered at (0, 0, 0).
///
/// # Arguments
/// * `r` - the sphere radius
pub fn | (&mut self, r: GLfloat) -> SceneNode {
self.scene.add_sphere(r)
}
/// Adds a cone to the scene. The cone is initially centered at (0, 0, 0) and points toward the
/// positive `y` axis.
///
/// # Arguments
/// * `h` - the cone height
/// * `r` - the cone base radius
pub fn add_cone(&mut self, r: GLfloat, h: GLfloat) -> SceneNode {
self.scene.add_cone(r, h)
}
/// Adds a cylinder to the scene. The cylinder is initially centered at (0, 0, 0) and has its
/// principal axis aligned with the `y` axis.
///
/// # Arguments
/// * `h` - the cylinder height
/// * `r` - the cylinder base radius
pub fn add_cylinder(&mut self, r: GLfloat, h: GLfloat) -> SceneNode {
self.scene.add_cylinder(r, h)
}
/// Adds a capsule to the scene. The capsule is initially centered at (0, 0, 0) and has its
/// principal axis aligned with the `y` axis.
///
/// # Arguments
/// * `h` - the capsule height
/// * `r` - the capsule caps radius
pub fn add_capsule(&mut self, r: GLfloat, h: GLfloat) -> SceneNode {
self.scene.add_capsule(r, h)
}
/// Adds a double-sided quad to the scene. The quad is initially centered at (0, 0, 0). The
/// quad itself is composed of a user-defined number of triangles regularly spaced on a grid.
/// This is the main way to draw height maps.
///
/// # Arguments
/// * `w` - the quad width.
/// * `h` - the quad height.
/// * `wsubdivs` - number of horizontal subdivisions. This correspond to the number of squares
/// which will be placed horizontally on each line. Must not be `0`.
/// * `hsubdivs` - number of vertical subdivisions. This correspond to the number of squares
/// which will be placed vertically on each line. Must not be `0`.
/// update.
pub fn add_quad(&mut self, w: f32, h: f32, usubdivs: usize, vsubdivs: usize) -> SceneNode {
self.scene.add_quad(w, h, usubdivs, vsubdivs)
}
/// Adds a double-sided quad with the specified vertices.
pub fn add_quad_with_vertices(&mut self,
vertices: &[Pnt3<f32>],
nhpoints: usize,
nvpoints: usize)
-> SceneNode {
self.scene.add_quad_with_vertices(vertices, nhpoints, nvpoints)
}
#[doc(hidden)]
pub fn add_texture(&mut self, path: &Path, name: &str) -> Rc<Texture> {
TextureManager::get_global_manager(|tm| tm.add(path, name))
}
/// Returns whether this window is closed or not.
pub fn is_closed(&self) -> bool {
false // FIXME
}
/// Sets the light mode. Only one light is supported.
pub fn set_light(&mut self, pos: Light) {
self.light_mode = pos;
}
/// Opens a window, hide it then calls a user-defined procedure.
///
/// # Arguments
/// * `title` - the window title
pub fn new_hidden(title: &str) -> Window {
Window::do_new(title, true, DEFAULT_WIDTH, DEFAULT_HEIGHT)
}
/// Opens a window then calls a user-defined procedure.
///
/// # Arguments
/// * `title` - the window title
pub fn new(title: &str) -> Window {
Window::do_new(title, false, DEFAULT_WIDTH, DEFAULT_HEIGHT)
}
/// Opens a window with a custom size then calls a user-defined procedure.
///
/// # Arguments
/// * `title` - the window title.
/// * `width` - the window width.
/// * `height` - the window height.
pub fn new_with_size(title: &str, width: u32, height: u32) -> Window {
Window::do_new(title, false, width, height)
}
// FIXME: make this pub?
fn do_new(title: &str, hide: bool, width: u32, height: u32) -> Window {
// FIXME: glfw::set_error_callback(~ErrorCallback);
let glfw = glfw::init(glfw::FAIL_ON_ERRORS).unwrap();
let (mut window, events) = glfw.create_window(width, height, title, WindowMode::Windowed).expect("Unable to open a glfw window.");
window.make_current();
verify!(gl::load_with(|name| window.get_proc_address(name) as *const _));
init_gl();
let mut usr_window = Window {
max_ms_per_frame: None,
glfw: glfw,
window: window,
events: Rc::new(events),
unhandled_events: Rc::new(RefCell::new(Vec::new())),
scene: SceneNode::new_empty(),
light_mode: Light::Absolute(Pnt3::new(0.0, 10.0, 0.0)),
background: Vec3::new(0.0, 0.0, 0.0),
line_renderer: LineRenderer::new(),
point_renderer: PointRenderer::new(),
text_renderer: TextRenderer::new(),
post_process_render_target: FramebufferManager::new_render_target(width as usize, height as usize),
framebuffer_manager: FramebufferManager::new(),
curr_time: time::precise_time_ns(),
camera: Rc::new(RefCell::new(ArcBall::new(Pnt3::new(0.0f32, 0.0, -1.0), na::orig())))
};
// setup callbacks
usr_window.window.set_framebuffer_size_polling(true);
usr_window.window.set_key_polling(true);
usr_window.window.set_mouse_button_polling(true);
usr_window.window.set_cursor_pos_polling(true);
usr_window.window.set_scroll_polling(true);
if hide {
usr_window.window.hide()
}
// usr_window.framebuffer_size_callback(DEFAULT_WIDTH, DEFAULT_HEIGHT);
let light = usr_window.light_mode.clone();
usr_window.set_light(light);
usr_window
}
/// Reference to the scene associated with this window.
#[inline]
pub fn scene<'a>(&'a self) -> &'a SceneNode {
&self.scene
}
/// Mutable reference to the scene associated with this window.
#[inline]
pub fn scene_mut<'a>(&'a mut self) -> &'a mut SceneNode {
&mut self.scene
}
// FIXME: give more options for the snap size and offset.
/// Read the pixels currently displayed to the screen.
///
/// # Arguments:
/// * `out` - the output buffer. It is automatically resized.
pub fn snap(&self, out: &mut Vec<u8>) {
let (width, height) = self.window.get_size();
self.snap_rect(out, 0, 0, width as usize, height as usize)
}
/// Read a section of pixels from the screen
///
/// # Arguments:
/// * `out` - the output buffer. It is automatically resized
/// * `x, y, width, height` - the rectangle to capture
pub fn snap_rect(&self, out: &mut Vec<u8>, x: usize, y: usize, width: usize, height: usize) {
let size = (width * height * 3) as usize;
if out.len() < size {
let diff = size - out.len();
out.extend(repeat(0).take(diff));
}
else {
out.truncate(size)
}
// FIXME: this is _not_ the fastest way of doing this.
unsafe {
gl::PixelStorei(gl::PACK_ALIGNMENT, 1);
gl::ReadPixels(x as i32, y as i32,
width as i32, height as i32,
gl::RGB,
gl::UNSIGNED_BYTE,
mem::transmute(&mut out[0]));
}
}
/// Get the current screen as an image
pub fn snap_image(&self) -> ImageBuffer<Rgb<u8>, Vec<u8>> {
let (width, height) = self.window.get_size();
let mut buf = Vec::new();
self.snap(&mut buf);
let img_opt = ImageBuffer::from_vec(width as u32, height as u32, buf);
let img = img_opt.expect("Buffer created from window was not big enough for image.");
imageops::flip_vertical(&img)
}
/// Gets the events manager that gives access to an event iterator.
pub fn events(&self) -> EventManager {
EventManager::new(self.events.clone(), self.unhandled_events.clone())
}
/// Poll events and pass them to a user-defined function. If the function returns `true`, the
/// default engine event handler (camera, framebuffer size, etc.) is executed, if it returns
/// `false`, the default engine event handler is not executed. Return `false` if you want to
/// override the default engine behaviour.
#[inline]
fn handle_events(&mut self, camera: &mut Option<&mut Camera>) {
let unhandled_events = self.unhandled_events.clone(); // FIXME: this is very ugly.
let events = self.events.clone(); // FIXME: this is very ugly
for event in unhandled_events.borrow().iter() {
self.handle_event(camera, event)
}
for event in glfw::flush_messages(&*events) {
self.handle_event(camera, &event.1)
}
unhandled_events.borrow_mut().clear();
self.glfw.poll_events();
}
fn handle_event(&mut self, camera: &mut Option<&mut Camera>, event: &WindowEvent) {
match *event {
WindowEvent::Key(Key::Escape, _, Action::Release, _) => {
self.close();
},
WindowEvent::FramebufferSize(w, h) => {
self.update_viewport(w as f32, h as f32);
},
_ => { }
}
match *camera {
Some(ref mut cam) => cam.handle_event(&self.window, event),
None => self.camera.borrow_mut().handle_event(&self.window, event)
}
}
/// Renders the scene using the default camera.
///
/// Returns `false` if the window should be closed.
pub fn render(&mut self) -> bool {
self.render_with(None, None)
}
/// Render using a specific post processing effect.
///
/// Returns `false` if the window should be closed.
pub fn render_with_effect(&mut self, effect: &mut PostProcessingEffect) -> bool {
self.render_with(None, Some(effect))
}
/// Render using a specific camera.
///
/// Returns `false` if the window should be closed.
pub fn render_with_camera(&mut self, camera: &mut Camera) -> bool {
self.render_with(Some(camera), None)
}
/// Render using a specific camera and post processing effect.
///
/// Returns `false` if the window should be closed.
pub fn render_with_camera_and_effect(&mut self, camera: &mut Camera, effect: &mut PostProcessingEffect) -> bool {
self.render_with(Some(camera), Some(effect))
}
/// Draws the scene with the given camera and post-processing effect.
///
/// Returns `false` if the window should be closed.
pub fn render_with(&mut self,
camera: Option<&mut Camera>,
post_processing: Option<&mut PostProcessingEffect>)
-> bool {
let mut camera = camera;
self.handle_events(&mut camera);
match camera {
Some(cam) => self.do_render_with(cam, post_processing),
None => {
let self_cam = self.camera.clone(); // FIXME: this is ugly.
let mut bself_cam = self_cam.borrow_mut();
self.do_render_with(&mut *bself_cam, post_processing)
}
}
}
fn do_render_with(&mut self,
camera: &mut Camera,
post_processing: Option<&mut PostProcessingEffect>)
-> bool {
// XXX: too bad we have to do this at each frame…
let w = self.width();
let h = self.height();
camera.handle_event(&self.window, &WindowEvent::FramebufferSize(w as i32, h as i32));
camera.update(&self.window);
match self.light_mode {
Light::StickToCamera => self.set_light(Light::StickToCamera),
_ => { }
}
let mut post_processing = post_processing;
if post_processing.is_some() {
// if we need post-processing, render to our own frame buffer
self.framebuffer_manager.select(&self.post_process_render_target);
}
else {
self.framebuffer_manager.select(&FramebufferManager::screen());
}
for pass in 0usize.. camera.num_passes() {
camera.start_pass(pass, &self.window);
self.render_scene(camera, pass);
}
camera.render_complete(&self.window);
let (znear, zfar) = camera.clip_planes();
// FIXME: remove this completely?
// swatch off the wireframe mode for post processing and text rendering.
// if self.wireframe_mode {
// verify!(gl::PolygonMode(gl::FRONT_AND_BACK, gl::FILL));
// }
match post_processing {
Some(ref mut p) => {
// switch back to the screen framebuffer …
self.framebuffer_manager.select(&FramebufferManager::screen());
// … and execute the post-process
// FIXME: use the real time value instead of 0.016!
p.update(0.016, w, h, znear, zfar);
p.draw(&self.post_process_render_target);
},
None => { }
}
self.text_renderer.render(w, h);
// We are done: swap buffers
self.window.swap_buffers();
// Limit the fps if needed.
match self.max_ms_per_frame {
None => { },
Some(ms) => {
let elapsed = (time::precise_time_ns() - self.curr_time) / 1000000; | add_sphere | identifier_name |
unordered_input.rs | //! Create new `Streams` connected to external inputs.
use std::rc::Rc;
use std::cell::RefCell;
use std::default::Default;
use progress::frontier::Antichain;
use progress::{Operate, Timestamp};
use progress::nested::subgraph::Source;
use progress::count_map::CountMap;
use timely_communication::Allocate;
use Data;
use dataflow::channels::pushers::{Tee, Counter as PushCounter};
use dataflow::channels::pushers::buffer::{Buffer as PushBuffer, AutoflushSession};
use dataflow::operators::Capability;
use dataflow::operators::capability::mint as mint_capability;
use dataflow::{Stream, Scope};
/// Create a new `Stream` and `Handle` through which to supply input.
pub trait UnorderedInput<G: Scope> {
/// Create a new capability-based `Stream` and `Handle` through which to supply input. This
/// input supports multiple open epochs (timestamps) at the same time.
///
/// The `new_unordered_input` method returns `((Handle, Capability), Stream)` where the `Stream` can be used
/// immediately for timely dataflow construction, `Handle` and `Capability` are later used to introduce
/// data into the timely dataflow computation.
///
/// The `Capability` returned is for the default value of the timestamp type in use. The
/// capability can be dropped to inform the system that the input has advanced beyond the
/// capability's timestamp. To retain the ability to send, a new capability at a later timestamp
/// should be obtained first, via the `delayed` function for `Capability`.
///
/// To communicate the end-of-input drop all available capabilities.
///
/// #Examples
///
/// ```
/// use std::sync::{Arc, Mutex};
///
/// use timely::*;
/// use timely::dataflow::operators::*;
/// use timely::dataflow::operators::capture::Extract;
/// use timely::dataflow::{Stream, Scope};
/// use timely::progress::timestamp::RootTimestamp;
///
/// // get send and recv endpoints, wrap send to share
/// let (send, recv) = ::std::sync::mpsc::channel();
/// let send = Arc::new(Mutex::new(send));
///
/// timely::execute(Configuration::Thread, move |root| {
///
/// // this is only to validate the output.
/// let send = send.lock().unwrap().clone();
///
/// // create and capture the unordered input.
/// let (mut input, mut cap) = root.scoped(|scope| {
/// let (input, stream) = scope.new_unordered_input();
/// stream.capture_into(send);
/// input
/// });
///
/// // feed values 0..10 at times 0..10.
/// for round in 0..10 {
/// input.session(cap.clone()).give(round);
/// cap = cap.delayed(&RootTimestamp::new(round + 1));
/// root.step();
/// }
/// }).unwrap();
///
/// let extract = recv.extract();
/// for i in 0..10 {
/// assert_eq!(extract[i], (RootTimestamp::new(i), vec![i]));
/// }
/// ```
fn new_unordered_input<D:Data>(&mut self) -> ((UnorderedHandle<G::Timestamp, D>, Capability<G::Timestamp>), Stream<G, D>);
}
impl<G: Scope> UnorderedInput<G> for G {
fn new_unordered_input<D:Data>(&mut self) -> ((UnorderedHandle<G::Timestamp, D>, Capability<G::Timestamp>), Stream<G, D>) {
let (output, registrar) = Tee::<G::Timestamp, D>::new();
let internal = Rc::new(RefCell::new(CountMap::new()));
let produced = Rc::new(RefCell::new(CountMap::new()));
let cap = mint_capability(Default::default(), internal.clone());
let helper = UnorderedHandle::new(PushCounter::new(output, produced.clone()));
let peers = self.peers();
let index = self.add_operator(UnorderedOperator {
internal: internal.clone(),
produced: produced.clone(),
peers: peers,
});
return ((helper, cap), Stream::new(Source { index: index, port: 0 }, registrar, self.clone()));
}
}
struct UnorderedOperator<T:Timestamp> {
internal: Rc<RefCell<CountMap<T>>>,
produced: Rc<RefCell<CountMap<T>>>,
peers: usize,
}
impl<T:Timestamp> Operate<T> for UnorderedOperator<T> {
fn name(&self) -> String { "Input".to_owned() }
fn inputs(&self) -> usize { 0 }
fn outputs(&self) -> usize { 1 }
fn get_internal_summary(&mut self) -> (Vec<Vec<Antichain<<T as Timestamp>::Summary>>>,
Vec<CountMap<T>>) {
let mut internal = CountMap::new();
// augment the counts for each reserved capability.
for &(ref time, count) in self.internal.borrow().iter() {
internal.update(time, count * (self.peers as i64 - 1));
}
// drain the changes to empty out, and complete the counts for internal.
self.internal.borrow_mut().drain_into(&mut internal);
(Vec::new(), vec![internal])
}
fn pull_internal_progress(&mut self,_consumed: &mut [CountMap<T>],
internal: &mut [CountMap<T>],
produced: &mut [CountMap<T>]) -> bool
{
self.produced.borrow_mut().drain_into(&mut produced[0]);
self.internal.borrow_mut().drain_into(&mut internal[0]);
return false;
}
fn notify_me(&self) -> bool { false }
}
/// A handle to an input `Stream`, used to introduce data to a timely dataflow computation.
pub struct | <T: Timestamp, D: Data> {
buffer: PushBuffer<T, D, PushCounter<T, D, Tee<T, D>>>,
}
impl<T: Timestamp, D: Data> UnorderedHandle<T, D> {
fn new(pusher: PushCounter<T, D, Tee<T, D>>) -> UnorderedHandle<T, D> {
UnorderedHandle {
buffer: PushBuffer::new(pusher),
}
}
/// Allocates a new automatically flushing session based on the supplied capability.
pub fn session<'b>(&'b mut self, cap: Capability<T>) -> AutoflushSession<'b, T, D, PushCounter<T, D, Tee<T, D>>> {
self.buffer.autoflush_session(cap)
}
}
impl<T: Timestamp, D: Data> Drop for UnorderedHandle<T, D> {
fn drop(&mut self) {
// TODO: explode if not all capabilities were given up?
}
}
| UnorderedHandle | identifier_name |
unordered_input.rs | //! Create new `Streams` connected to external inputs.
use std::rc::Rc;
use std::cell::RefCell;
use std::default::Default;
use progress::frontier::Antichain;
use progress::{Operate, Timestamp};
use progress::nested::subgraph::Source;
use progress::count_map::CountMap;
use timely_communication::Allocate;
use Data;
use dataflow::channels::pushers::{Tee, Counter as PushCounter};
use dataflow::channels::pushers::buffer::{Buffer as PushBuffer, AutoflushSession};
use dataflow::operators::Capability;
use dataflow::operators::capability::mint as mint_capability;
use dataflow::{Stream, Scope};
/// Create a new `Stream` and `Handle` through which to supply input.
pub trait UnorderedInput<G: Scope> {
/// Create a new capability-based `Stream` and `Handle` through which to supply input. This
/// input supports multiple open epochs (timestamps) at the same time.
///
/// The `new_unordered_input` method returns `((Handle, Capability), Stream)` where the `Stream` can be used
/// immediately for timely dataflow construction, `Handle` and `Capability` are later used to introduce
/// data into the timely dataflow computation.
///
/// The `Capability` returned is for the default value of the timestamp type in use. The
/// capability can be dropped to inform the system that the input has advanced beyond the
/// capability's timestamp. To retain the ability to send, a new capability at a later timestamp
/// should be obtained first, via the `delayed` function for `Capability`.
///
/// To communicate the end-of-input drop all available capabilities.
///
/// #Examples
///
/// ```
/// use std::sync::{Arc, Mutex};
///
/// use timely::*;
/// use timely::dataflow::operators::*;
/// use timely::dataflow::operators::capture::Extract;
/// use timely::dataflow::{Stream, Scope};
/// use timely::progress::timestamp::RootTimestamp;
///
/// // get send and recv endpoints, wrap send to share
/// let (send, recv) = ::std::sync::mpsc::channel();
/// let send = Arc::new(Mutex::new(send));
///
/// timely::execute(Configuration::Thread, move |root| {
///
/// // this is only to validate the output.
/// let send = send.lock().unwrap().clone();
///
/// // create and capture the unordered input.
/// let (mut input, mut cap) = root.scoped(|scope| {
/// let (input, stream) = scope.new_unordered_input();
/// stream.capture_into(send);
/// input
/// });
///
/// // feed values 0..10 at times 0..10.
/// for round in 0..10 {
/// input.session(cap.clone()).give(round);
/// cap = cap.delayed(&RootTimestamp::new(round + 1));
/// root.step();
/// }
/// }).unwrap();
///
/// let extract = recv.extract();
/// for i in 0..10 {
/// assert_eq!(extract[i], (RootTimestamp::new(i), vec![i]));
/// }
/// ```
fn new_unordered_input<D:Data>(&mut self) -> ((UnorderedHandle<G::Timestamp, D>, Capability<G::Timestamp>), Stream<G, D>);
}
impl<G: Scope> UnorderedInput<G> for G {
fn new_unordered_input<D:Data>(&mut self) -> ((UnorderedHandle<G::Timestamp, D>, Capability<G::Timestamp>), Stream<G, D>) {
let (output, registrar) = Tee::<G::Timestamp, D>::new();
let internal = Rc::new(RefCell::new(CountMap::new()));
let produced = Rc::new(RefCell::new(CountMap::new()));
let cap = mint_capability(Default::default(), internal.clone());
let helper = UnorderedHandle::new(PushCounter::new(output, produced.clone()));
let peers = self.peers();
let index = self.add_operator(UnorderedOperator {
internal: internal.clone(),
produced: produced.clone(),
peers: peers,
});
return ((helper, cap), Stream::new(Source { index: index, port: 0 }, registrar, self.clone()));
}
}
struct UnorderedOperator<T:Timestamp> {
internal: Rc<RefCell<CountMap<T>>>,
produced: Rc<RefCell<CountMap<T>>>,
peers: usize,
}
impl<T:Timestamp> Operate<T> for UnorderedOperator<T> {
fn name(&self) -> String { "Input".to_owned() }
fn inputs(&self) -> usize { 0 }
fn outputs(&self) -> usize |
fn get_internal_summary(&mut self) -> (Vec<Vec<Antichain<<T as Timestamp>::Summary>>>,
Vec<CountMap<T>>) {
let mut internal = CountMap::new();
// augment the counts for each reserved capability.
for &(ref time, count) in self.internal.borrow().iter() {
internal.update(time, count * (self.peers as i64 - 1));
}
// drain the changes to empty out, and complete the counts for internal.
self.internal.borrow_mut().drain_into(&mut internal);
(Vec::new(), vec![internal])
}
fn pull_internal_progress(&mut self,_consumed: &mut [CountMap<T>],
internal: &mut [CountMap<T>],
produced: &mut [CountMap<T>]) -> bool
{
self.produced.borrow_mut().drain_into(&mut produced[0]);
self.internal.borrow_mut().drain_into(&mut internal[0]);
return false;
}
fn notify_me(&self) -> bool { false }
}
/// A handle to an input `Stream`, used to introduce data to a timely dataflow computation.
pub struct UnorderedHandle<T: Timestamp, D: Data> {
buffer: PushBuffer<T, D, PushCounter<T, D, Tee<T, D>>>,
}
impl<T: Timestamp, D: Data> UnorderedHandle<T, D> {
fn new(pusher: PushCounter<T, D, Tee<T, D>>) -> UnorderedHandle<T, D> {
UnorderedHandle {
buffer: PushBuffer::new(pusher),
}
}
/// Allocates a new automatically flushing session based on the supplied capability.
pub fn session<'b>(&'b mut self, cap: Capability<T>) -> AutoflushSession<'b, T, D, PushCounter<T, D, Tee<T, D>>> {
self.buffer.autoflush_session(cap)
}
}
impl<T: Timestamp, D: Data> Drop for UnorderedHandle<T, D> {
fn drop(&mut self) {
// TODO: explode if not all capabilities were given up?
}
}
| { 1 } | identifier_body |
unordered_input.rs | //! Create new `Streams` connected to external inputs.
use std::rc::Rc;
use std::cell::RefCell;
use std::default::Default;
use progress::frontier::Antichain;
use progress::{Operate, Timestamp};
use progress::nested::subgraph::Source;
use progress::count_map::CountMap;
use timely_communication::Allocate;
use Data;
use dataflow::channels::pushers::{Tee, Counter as PushCounter};
use dataflow::channels::pushers::buffer::{Buffer as PushBuffer, AutoflushSession};
use dataflow::operators::Capability;
use dataflow::operators::capability::mint as mint_capability;
use dataflow::{Stream, Scope};
/// Create a new `Stream` and `Handle` through which to supply input.
pub trait UnorderedInput<G: Scope> {
/// Create a new capability-based `Stream` and `Handle` through which to supply input. This
/// input supports multiple open epochs (timestamps) at the same time.
///
/// The `new_unordered_input` method returns `((Handle, Capability), Stream)` where the `Stream` can be used
/// immediately for timely dataflow construction, `Handle` and `Capability` are later used to introduce
/// data into the timely dataflow computation.
///
/// The `Capability` returned is for the default value of the timestamp type in use. The
/// capability can be dropped to inform the system that the input has advanced beyond the
/// capability's timestamp. To retain the ability to send, a new capability at a later timestamp
/// should be obtained first, via the `delayed` function for `Capability`.
///
/// To communicate the end-of-input drop all available capabilities.
///
/// #Examples
///
/// ```
/// use std::sync::{Arc, Mutex};
///
/// use timely::*;
/// use timely::dataflow::operators::*;
/// use timely::dataflow::operators::capture::Extract;
/// use timely::dataflow::{Stream, Scope};
/// use timely::progress::timestamp::RootTimestamp;
///
/// // get send and recv endpoints, wrap send to share
/// let (send, recv) = ::std::sync::mpsc::channel();
/// let send = Arc::new(Mutex::new(send));
///
/// timely::execute(Configuration::Thread, move |root| {
///
/// // this is only to validate the output.
/// let send = send.lock().unwrap().clone();
///
/// // create and capture the unordered input.
/// let (mut input, mut cap) = root.scoped(|scope| {
/// let (input, stream) = scope.new_unordered_input();
/// stream.capture_into(send);
/// input
/// });
///
/// // feed values 0..10 at times 0..10.
/// for round in 0..10 {
/// input.session(cap.clone()).give(round);
/// cap = cap.delayed(&RootTimestamp::new(round + 1));
/// root.step();
/// }
/// }).unwrap();
///
/// let extract = recv.extract();
/// for i in 0..10 {
/// assert_eq!(extract[i], (RootTimestamp::new(i), vec![i]));
/// }
/// ```
fn new_unordered_input<D:Data>(&mut self) -> ((UnorderedHandle<G::Timestamp, D>, Capability<G::Timestamp>), Stream<G, D>);
}
impl<G: Scope> UnorderedInput<G> for G {
fn new_unordered_input<D:Data>(&mut self) -> ((UnorderedHandle<G::Timestamp, D>, Capability<G::Timestamp>), Stream<G, D>) {
let (output, registrar) = Tee::<G::Timestamp, D>::new();
let internal = Rc::new(RefCell::new(CountMap::new()));
let produced = Rc::new(RefCell::new(CountMap::new()));
let cap = mint_capability(Default::default(), internal.clone());
let helper = UnorderedHandle::new(PushCounter::new(output, produced.clone()));
let peers = self.peers();
let index = self.add_operator(UnorderedOperator {
internal: internal.clone(),
produced: produced.clone(),
peers: peers,
});
return ((helper, cap), Stream::new(Source { index: index, port: 0 }, registrar, self.clone()));
}
}
struct UnorderedOperator<T:Timestamp> {
internal: Rc<RefCell<CountMap<T>>>,
produced: Rc<RefCell<CountMap<T>>>,
peers: usize,
}
impl<T:Timestamp> Operate<T> for UnorderedOperator<T> {
fn name(&self) -> String { "Input".to_owned() }
fn inputs(&self) -> usize { 0 }
fn outputs(&self) -> usize { 1 }
fn get_internal_summary(&mut self) -> (Vec<Vec<Antichain<<T as Timestamp>::Summary>>>,
Vec<CountMap<T>>) {
let mut internal = CountMap::new();
// augment the counts for each reserved capability.
for &(ref time, count) in self.internal.borrow().iter() {
internal.update(time, count * (self.peers as i64 - 1));
}
// drain the changes to empty out, and complete the counts for internal.
self.internal.borrow_mut().drain_into(&mut internal);
(Vec::new(), vec![internal])
}
fn pull_internal_progress(&mut self,_consumed: &mut [CountMap<T>],
internal: &mut [CountMap<T>],
produced: &mut [CountMap<T>]) -> bool
{
self.produced.borrow_mut().drain_into(&mut produced[0]);
self.internal.borrow_mut().drain_into(&mut internal[0]);
return false;
}
fn notify_me(&self) -> bool { false }
}
/// A handle to an input `Stream`, used to introduce data to a timely dataflow computation.
pub struct UnorderedHandle<T: Timestamp, D: Data> {
buffer: PushBuffer<T, D, PushCounter<T, D, Tee<T, D>>>,
}
impl<T: Timestamp, D: Data> UnorderedHandle<T, D> {
fn new(pusher: PushCounter<T, D, Tee<T, D>>) -> UnorderedHandle<T, D> {
UnorderedHandle {
buffer: PushBuffer::new(pusher),
}
}
| }
impl<T: Timestamp, D: Data> Drop for UnorderedHandle<T, D> {
fn drop(&mut self) {
// TODO: explode if not all capabilities were given up?
}
} | /// Allocates a new automatically flushing session based on the supplied capability.
pub fn session<'b>(&'b mut self, cap: Capability<T>) -> AutoflushSession<'b, T, D, PushCounter<T, D, Tee<T, D>>> {
self.buffer.autoflush_session(cap)
} | random_line_split |
package.rs | use std::cell::{Ref, RefCell};
use std::collections::HashMap;
use std::fmt;
use std::hash;
use std::path::{Path, PathBuf};
use semver::Version;
use core::{Dependency, Manifest, PackageId, SourceId, Target, TargetKind};
use core::{Summary, Metadata, SourceMap};
use ops;
use util::{CargoResult, Config, LazyCell, ChainError, internal, human, lev_distance};
use rustc_serialize::{Encoder,Encodable};
/// Information about a package that is available somewhere in the file system.
///
/// A package is a `Cargo.toml` file plus all the files that are part of it.
// TODO: Is manifest_path a relic?
#[derive(Clone, Debug)]
pub struct Package {
// The package's manifest
manifest: Manifest,
// The root of the package
manifest_path: PathBuf,
}
#[derive(RustcEncodable)]
struct SerializedPackage<'a> {
name: &'a str,
version: &'a str,
id: &'a PackageId,
source: &'a SourceId,
dependencies: &'a [Dependency],
targets: &'a [Target],
features: &'a HashMap<String, Vec<String>>,
manifest_path: &'a str,
}
impl Encodable for Package {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
let summary = self.manifest.summary();
let package_id = summary.package_id();
SerializedPackage {
name: &package_id.name(),
version: &package_id.version().to_string(),
id: package_id,
source: summary.source_id(),
dependencies: summary.dependencies(),
targets: &self.manifest.targets(),
features: summary.features(),
manifest_path: &self.manifest_path.display().to_string(),
}.encode(s)
}
}
impl Package {
pub fn new(manifest: Manifest,
manifest_path: &Path) -> Package {
Package {
manifest: manifest,
manifest_path: manifest_path.to_path_buf(),
}
}
pub fn for_path(manifest_path: &Path, config: &Config) -> CargoResult<Package> |
pub fn dependencies(&self) -> &[Dependency] { self.manifest.dependencies() }
pub fn manifest(&self) -> &Manifest { &self.manifest }
pub fn manifest_path(&self) -> &Path { &self.manifest_path }
pub fn name(&self) -> &str { self.package_id().name() }
pub fn package_id(&self) -> &PackageId { self.manifest.package_id() }
pub fn root(&self) -> &Path { self.manifest_path.parent().unwrap() }
pub fn summary(&self) -> &Summary { self.manifest.summary() }
pub fn targets(&self) -> &[Target] { self.manifest().targets() }
pub fn version(&self) -> &Version { self.package_id().version() }
pub fn authors(&self) -> &Vec<String> { &self.manifest.metadata().authors }
pub fn publish(&self) -> bool { self.manifest.publish() }
pub fn has_custom_build(&self) -> bool {
self.targets().iter().any(|t| t.is_custom_build())
}
pub fn generate_metadata(&self) -> Metadata {
self.package_id().generate_metadata()
}
pub fn find_closest_target(&self, target: &str, kind: TargetKind) -> Option<&Target> {
let targets = self.targets();
let matches = targets.iter().filter(|t| *t.kind() == kind)
.map(|t| (lev_distance(target, t.name()), t))
.filter(|&(d, _)| d < 4);
matches.min_by_key(|t| t.0).map(|t| t.1)
}
}
impl fmt::Display for Package {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.summary().package_id())
}
}
impl PartialEq for Package {
fn eq(&self, other: &Package) -> bool {
self.package_id() == other.package_id()
}
}
impl Eq for Package {}
impl hash::Hash for Package {
fn hash<H: hash::Hasher>(&self, into: &mut H) {
self.package_id().hash(into)
}
}
pub struct PackageSet<'cfg> {
packages: Vec<(PackageId, LazyCell<Package>)>,
sources: RefCell<SourceMap<'cfg>>,
}
impl<'cfg> PackageSet<'cfg> {
pub fn new(package_ids: &[PackageId],
sources: SourceMap<'cfg>) -> PackageSet<'cfg> {
PackageSet {
packages: package_ids.iter().map(|id| {
(id.clone(), LazyCell::new(None))
}).collect(),
sources: RefCell::new(sources),
}
}
pub fn package_ids<'a>(&'a self) -> Box<Iterator<Item=&'a PackageId> + 'a> {
Box::new(self.packages.iter().map(|&(ref p, _)| p))
}
pub fn get(&self, id: &PackageId) -> CargoResult<&Package> {
let slot = try!(self.packages.iter().find(|p| p.0 == *id).chain_error(|| {
internal(format!("couldn't find `{}` in package set", id))
}));
let slot = &slot.1;
if let Some(pkg) = slot.borrow() {
return Ok(pkg)
}
let mut sources = self.sources.borrow_mut();
let source = try!(sources.get_mut(id.source_id()).chain_error(|| {
internal(format!("couldn't find source for `{}`", id))
}));
let pkg = try!(source.download(id).chain_error(|| {
human("unable to get packages from source")
}));
assert!(slot.fill(pkg).is_ok());
Ok(slot.borrow().unwrap())
}
pub fn sources(&self) -> Ref<SourceMap<'cfg>> {
self.sources.borrow()
}
}
| {
let path = manifest_path.parent().unwrap();
let source_id = try!(SourceId::for_path(path));
let (pkg, _) = try!(ops::read_package(&manifest_path, &source_id,
config));
Ok(pkg)
} | identifier_body |
package.rs | use std::cell::{Ref, RefCell};
use std::collections::HashMap;
use std::fmt;
use std::hash;
use std::path::{Path, PathBuf};
use semver::Version;
use core::{Dependency, Manifest, PackageId, SourceId, Target, TargetKind};
use core::{Summary, Metadata, SourceMap};
use ops;
use util::{CargoResult, Config, LazyCell, ChainError, internal, human, lev_distance};
use rustc_serialize::{Encoder,Encodable};
/// Information about a package that is available somewhere in the file system.
///
/// A package is a `Cargo.toml` file plus all the files that are part of it.
// TODO: Is manifest_path a relic?
#[derive(Clone, Debug)]
pub struct Package {
// The package's manifest
manifest: Manifest,
// The root of the package
manifest_path: PathBuf,
}
#[derive(RustcEncodable)]
struct SerializedPackage<'a> {
name: &'a str,
version: &'a str,
id: &'a PackageId,
source: &'a SourceId,
dependencies: &'a [Dependency],
targets: &'a [Target],
features: &'a HashMap<String, Vec<String>>,
manifest_path: &'a str,
}
impl Encodable for Package {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
let summary = self.manifest.summary();
let package_id = summary.package_id();
SerializedPackage {
name: &package_id.name(),
version: &package_id.version().to_string(),
id: package_id,
source: summary.source_id(),
dependencies: summary.dependencies(),
targets: &self.manifest.targets(),
features: summary.features(),
manifest_path: &self.manifest_path.display().to_string(),
}.encode(s)
}
}
impl Package {
pub fn new(manifest: Manifest,
manifest_path: &Path) -> Package {
Package {
manifest: manifest,
manifest_path: manifest_path.to_path_buf(),
}
}
pub fn for_path(manifest_path: &Path, config: &Config) -> CargoResult<Package> {
let path = manifest_path.parent().unwrap();
let source_id = try!(SourceId::for_path(path));
let (pkg, _) = try!(ops::read_package(&manifest_path, &source_id,
config));
Ok(pkg)
}
pub fn dependencies(&self) -> &[Dependency] { self.manifest.dependencies() }
pub fn manifest(&self) -> &Manifest { &self.manifest }
pub fn manifest_path(&self) -> &Path { &self.manifest_path }
pub fn name(&self) -> &str { self.package_id().name() }
pub fn package_id(&self) -> &PackageId { self.manifest.package_id() }
pub fn root(&self) -> &Path { self.manifest_path.parent().unwrap() }
pub fn summary(&self) -> &Summary { self.manifest.summary() }
pub fn targets(&self) -> &[Target] { self.manifest().targets() }
pub fn version(&self) -> &Version { self.package_id().version() }
pub fn authors(&self) -> &Vec<String> { &self.manifest.metadata().authors }
pub fn publish(&self) -> bool { self.manifest.publish() }
pub fn has_custom_build(&self) -> bool {
self.targets().iter().any(|t| t.is_custom_build())
}
pub fn generate_metadata(&self) -> Metadata {
self.package_id().generate_metadata()
}
pub fn find_closest_target(&self, target: &str, kind: TargetKind) -> Option<&Target> {
let targets = self.targets();
let matches = targets.iter().filter(|t| *t.kind() == kind)
.map(|t| (lev_distance(target, t.name()), t))
.filter(|&(d, _)| d < 4);
matches.min_by_key(|t| t.0).map(|t| t.1)
}
}
impl fmt::Display for Package {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.summary().package_id())
}
}
impl PartialEq for Package {
fn eq(&self, other: &Package) -> bool {
self.package_id() == other.package_id()
}
}
impl Eq for Package {}
impl hash::Hash for Package {
fn hash<H: hash::Hasher>(&self, into: &mut H) {
self.package_id().hash(into)
}
}
pub struct PackageSet<'cfg> {
packages: Vec<(PackageId, LazyCell<Package>)>, | }
impl<'cfg> PackageSet<'cfg> {
pub fn new(package_ids: &[PackageId],
sources: SourceMap<'cfg>) -> PackageSet<'cfg> {
PackageSet {
packages: package_ids.iter().map(|id| {
(id.clone(), LazyCell::new(None))
}).collect(),
sources: RefCell::new(sources),
}
}
pub fn package_ids<'a>(&'a self) -> Box<Iterator<Item=&'a PackageId> + 'a> {
Box::new(self.packages.iter().map(|&(ref p, _)| p))
}
pub fn get(&self, id: &PackageId) -> CargoResult<&Package> {
let slot = try!(self.packages.iter().find(|p| p.0 == *id).chain_error(|| {
internal(format!("couldn't find `{}` in package set", id))
}));
let slot = &slot.1;
if let Some(pkg) = slot.borrow() {
return Ok(pkg)
}
let mut sources = self.sources.borrow_mut();
let source = try!(sources.get_mut(id.source_id()).chain_error(|| {
internal(format!("couldn't find source for `{}`", id))
}));
let pkg = try!(source.download(id).chain_error(|| {
human("unable to get packages from source")
}));
assert!(slot.fill(pkg).is_ok());
Ok(slot.borrow().unwrap())
}
pub fn sources(&self) -> Ref<SourceMap<'cfg>> {
self.sources.borrow()
}
} | sources: RefCell<SourceMap<'cfg>>, | random_line_split |
package.rs | use std::cell::{Ref, RefCell};
use std::collections::HashMap;
use std::fmt;
use std::hash;
use std::path::{Path, PathBuf};
use semver::Version;
use core::{Dependency, Manifest, PackageId, SourceId, Target, TargetKind};
use core::{Summary, Metadata, SourceMap};
use ops;
use util::{CargoResult, Config, LazyCell, ChainError, internal, human, lev_distance};
use rustc_serialize::{Encoder,Encodable};
/// Information about a package that is available somewhere in the file system.
///
/// A package is a `Cargo.toml` file plus all the files that are part of it.
// TODO: Is manifest_path a relic?
#[derive(Clone, Debug)]
pub struct | {
// The package's manifest
manifest: Manifest,
// The root of the package
manifest_path: PathBuf,
}
#[derive(RustcEncodable)]
struct SerializedPackage<'a> {
name: &'a str,
version: &'a str,
id: &'a PackageId,
source: &'a SourceId,
dependencies: &'a [Dependency],
targets: &'a [Target],
features: &'a HashMap<String, Vec<String>>,
manifest_path: &'a str,
}
impl Encodable for Package {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
let summary = self.manifest.summary();
let package_id = summary.package_id();
SerializedPackage {
name: &package_id.name(),
version: &package_id.version().to_string(),
id: package_id,
source: summary.source_id(),
dependencies: summary.dependencies(),
targets: &self.manifest.targets(),
features: summary.features(),
manifest_path: &self.manifest_path.display().to_string(),
}.encode(s)
}
}
impl Package {
pub fn new(manifest: Manifest,
manifest_path: &Path) -> Package {
Package {
manifest: manifest,
manifest_path: manifest_path.to_path_buf(),
}
}
pub fn for_path(manifest_path: &Path, config: &Config) -> CargoResult<Package> {
let path = manifest_path.parent().unwrap();
let source_id = try!(SourceId::for_path(path));
let (pkg, _) = try!(ops::read_package(&manifest_path, &source_id,
config));
Ok(pkg)
}
pub fn dependencies(&self) -> &[Dependency] { self.manifest.dependencies() }
pub fn manifest(&self) -> &Manifest { &self.manifest }
pub fn manifest_path(&self) -> &Path { &self.manifest_path }
pub fn name(&self) -> &str { self.package_id().name() }
pub fn package_id(&self) -> &PackageId { self.manifest.package_id() }
pub fn root(&self) -> &Path { self.manifest_path.parent().unwrap() }
pub fn summary(&self) -> &Summary { self.manifest.summary() }
pub fn targets(&self) -> &[Target] { self.manifest().targets() }
pub fn version(&self) -> &Version { self.package_id().version() }
pub fn authors(&self) -> &Vec<String> { &self.manifest.metadata().authors }
pub fn publish(&self) -> bool { self.manifest.publish() }
pub fn has_custom_build(&self) -> bool {
self.targets().iter().any(|t| t.is_custom_build())
}
pub fn generate_metadata(&self) -> Metadata {
self.package_id().generate_metadata()
}
pub fn find_closest_target(&self, target: &str, kind: TargetKind) -> Option<&Target> {
let targets = self.targets();
let matches = targets.iter().filter(|t| *t.kind() == kind)
.map(|t| (lev_distance(target, t.name()), t))
.filter(|&(d, _)| d < 4);
matches.min_by_key(|t| t.0).map(|t| t.1)
}
}
impl fmt::Display for Package {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.summary().package_id())
}
}
impl PartialEq for Package {
fn eq(&self, other: &Package) -> bool {
self.package_id() == other.package_id()
}
}
impl Eq for Package {}
impl hash::Hash for Package {
fn hash<H: hash::Hasher>(&self, into: &mut H) {
self.package_id().hash(into)
}
}
pub struct PackageSet<'cfg> {
packages: Vec<(PackageId, LazyCell<Package>)>,
sources: RefCell<SourceMap<'cfg>>,
}
impl<'cfg> PackageSet<'cfg> {
pub fn new(package_ids: &[PackageId],
sources: SourceMap<'cfg>) -> PackageSet<'cfg> {
PackageSet {
packages: package_ids.iter().map(|id| {
(id.clone(), LazyCell::new(None))
}).collect(),
sources: RefCell::new(sources),
}
}
pub fn package_ids<'a>(&'a self) -> Box<Iterator<Item=&'a PackageId> + 'a> {
Box::new(self.packages.iter().map(|&(ref p, _)| p))
}
pub fn get(&self, id: &PackageId) -> CargoResult<&Package> {
let slot = try!(self.packages.iter().find(|p| p.0 == *id).chain_error(|| {
internal(format!("couldn't find `{}` in package set", id))
}));
let slot = &slot.1;
if let Some(pkg) = slot.borrow() {
return Ok(pkg)
}
let mut sources = self.sources.borrow_mut();
let source = try!(sources.get_mut(id.source_id()).chain_error(|| {
internal(format!("couldn't find source for `{}`", id))
}));
let pkg = try!(source.download(id).chain_error(|| {
human("unable to get packages from source")
}));
assert!(slot.fill(pkg).is_ok());
Ok(slot.borrow().unwrap())
}
pub fn sources(&self) -> Ref<SourceMap<'cfg>> {
self.sources.borrow()
}
}
| Package | identifier_name |
package.rs | use std::cell::{Ref, RefCell};
use std::collections::HashMap;
use std::fmt;
use std::hash;
use std::path::{Path, PathBuf};
use semver::Version;
use core::{Dependency, Manifest, PackageId, SourceId, Target, TargetKind};
use core::{Summary, Metadata, SourceMap};
use ops;
use util::{CargoResult, Config, LazyCell, ChainError, internal, human, lev_distance};
use rustc_serialize::{Encoder,Encodable};
/// Information about a package that is available somewhere in the file system.
///
/// A package is a `Cargo.toml` file plus all the files that are part of it.
// TODO: Is manifest_path a relic?
#[derive(Clone, Debug)]
pub struct Package {
// The package's manifest
manifest: Manifest,
// The root of the package
manifest_path: PathBuf,
}
#[derive(RustcEncodable)]
struct SerializedPackage<'a> {
name: &'a str,
version: &'a str,
id: &'a PackageId,
source: &'a SourceId,
dependencies: &'a [Dependency],
targets: &'a [Target],
features: &'a HashMap<String, Vec<String>>,
manifest_path: &'a str,
}
impl Encodable for Package {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
let summary = self.manifest.summary();
let package_id = summary.package_id();
SerializedPackage {
name: &package_id.name(),
version: &package_id.version().to_string(),
id: package_id,
source: summary.source_id(),
dependencies: summary.dependencies(),
targets: &self.manifest.targets(),
features: summary.features(),
manifest_path: &self.manifest_path.display().to_string(),
}.encode(s)
}
}
impl Package {
pub fn new(manifest: Manifest,
manifest_path: &Path) -> Package {
Package {
manifest: manifest,
manifest_path: manifest_path.to_path_buf(),
}
}
pub fn for_path(manifest_path: &Path, config: &Config) -> CargoResult<Package> {
let path = manifest_path.parent().unwrap();
let source_id = try!(SourceId::for_path(path));
let (pkg, _) = try!(ops::read_package(&manifest_path, &source_id,
config));
Ok(pkg)
}
pub fn dependencies(&self) -> &[Dependency] { self.manifest.dependencies() }
pub fn manifest(&self) -> &Manifest { &self.manifest }
pub fn manifest_path(&self) -> &Path { &self.manifest_path }
pub fn name(&self) -> &str { self.package_id().name() }
pub fn package_id(&self) -> &PackageId { self.manifest.package_id() }
pub fn root(&self) -> &Path { self.manifest_path.parent().unwrap() }
pub fn summary(&self) -> &Summary { self.manifest.summary() }
pub fn targets(&self) -> &[Target] { self.manifest().targets() }
pub fn version(&self) -> &Version { self.package_id().version() }
pub fn authors(&self) -> &Vec<String> { &self.manifest.metadata().authors }
pub fn publish(&self) -> bool { self.manifest.publish() }
pub fn has_custom_build(&self) -> bool {
self.targets().iter().any(|t| t.is_custom_build())
}
pub fn generate_metadata(&self) -> Metadata {
self.package_id().generate_metadata()
}
pub fn find_closest_target(&self, target: &str, kind: TargetKind) -> Option<&Target> {
let targets = self.targets();
let matches = targets.iter().filter(|t| *t.kind() == kind)
.map(|t| (lev_distance(target, t.name()), t))
.filter(|&(d, _)| d < 4);
matches.min_by_key(|t| t.0).map(|t| t.1)
}
}
impl fmt::Display for Package {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.summary().package_id())
}
}
impl PartialEq for Package {
fn eq(&self, other: &Package) -> bool {
self.package_id() == other.package_id()
}
}
impl Eq for Package {}
impl hash::Hash for Package {
fn hash<H: hash::Hasher>(&self, into: &mut H) {
self.package_id().hash(into)
}
}
pub struct PackageSet<'cfg> {
packages: Vec<(PackageId, LazyCell<Package>)>,
sources: RefCell<SourceMap<'cfg>>,
}
impl<'cfg> PackageSet<'cfg> {
pub fn new(package_ids: &[PackageId],
sources: SourceMap<'cfg>) -> PackageSet<'cfg> {
PackageSet {
packages: package_ids.iter().map(|id| {
(id.clone(), LazyCell::new(None))
}).collect(),
sources: RefCell::new(sources),
}
}
pub fn package_ids<'a>(&'a self) -> Box<Iterator<Item=&'a PackageId> + 'a> {
Box::new(self.packages.iter().map(|&(ref p, _)| p))
}
pub fn get(&self, id: &PackageId) -> CargoResult<&Package> {
let slot = try!(self.packages.iter().find(|p| p.0 == *id).chain_error(|| {
internal(format!("couldn't find `{}` in package set", id))
}));
let slot = &slot.1;
if let Some(pkg) = slot.borrow() |
let mut sources = self.sources.borrow_mut();
let source = try!(sources.get_mut(id.source_id()).chain_error(|| {
internal(format!("couldn't find source for `{}`", id))
}));
let pkg = try!(source.download(id).chain_error(|| {
human("unable to get packages from source")
}));
assert!(slot.fill(pkg).is_ok());
Ok(slot.borrow().unwrap())
}
pub fn sources(&self) -> Ref<SourceMap<'cfg>> {
self.sources.borrow()
}
}
| {
return Ok(pkg)
} | conditional_block |
zsys.rs | //! Module: czmq-zsys
use {czmq_sys, RawInterface, Result};
use error::{Error, ErrorKind};
use std::{error, fmt, ptr};
use std::os::raw::c_void;
use std::sync::{Once, ONCE_INIT};
use zsock::ZSock;
static INIT_ZSYS: Once = ONCE_INIT;
pub struct ZSys;
impl ZSys {
// Each new ZSock calls zsys_init(), which is a non-threadsafe
// fn. To mitigate the race condition, wrap it in a Once struct.
pub fn init() {
INIT_ZSYS.call_once(|| {
unsafe { czmq_sys::zsys_init() };
});
}
/// Create a pipe, which consists of two PAIR sockets connected
/// over inproc.
pub fn create_pipe() -> Result<(ZSock, ZSock)> {
let mut backend_raw: *mut czmq_sys::zsock_t = ptr::null_mut();
let frontend_raw = unsafe { czmq_sys::zsys_create_pipe(&mut backend_raw) };
if frontend_raw == ptr::null_mut() {
Err(Error::new(ErrorKind::NullPtr, ZSysError::CreatePipe))
} else {
Ok(unsafe { (ZSock::from_raw(frontend_raw as *mut c_void, true), ZSock::from_raw(backend_raw as *mut c_void, true)) })
}
}
pub fn is_interrupted() -> bool {
unsafe { czmq_sys::zsys_interrupted == 1 }
}
}
#[derive(Debug)]
pub enum ZSysError {
CreatePipe,
}
impl fmt::Display for ZSysError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ZSysError::CreatePipe => write!(f, "Could not create pipe"),
}
}
}
impl error::Error for ZSysError {
fn description(&self) -> &str {
match *self {
ZSysError::CreatePipe => "Could not create pipe",
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_create_pipe() {
ZSys::init();
let (frontend, backend) = ZSys::create_pipe().unwrap();
frontend.send_str("I changed my iPod’s name to Titanic...now it’s syncing.").unwrap();
assert_eq!(backend.recv_str().unwrap().unwrap(), "I changed my iPod’s name to Titanic...now it’s syncing.");
backend.send_str("My family laughed when I told them I was going to be a comedian. Well...they aren't laughing now!").unwrap();
assert_eq!(frontend.recv_str().unwrap().unwrap(), "My family laughed when I told them I was going to be a comedian. Well...they aren't laughing now!");
}
#[test]
fn test_is_ | // This test is half hearted as we can't test the interrupt
// case.
assert!(!ZSys::is_interrupted());
}
}
| interrupted() {
| identifier_name |
zsys.rs | //! Module: czmq-zsys
use {czmq_sys, RawInterface, Result};
use error::{Error, ErrorKind};
use std::{error, fmt, ptr};
use std::os::raw::c_void;
use std::sync::{Once, ONCE_INIT};
use zsock::ZSock;
static INIT_ZSYS: Once = ONCE_INIT;
pub struct ZSys;
impl ZSys {
// Each new ZSock calls zsys_init(), which is a non-threadsafe
// fn. To mitigate the race condition, wrap it in a Once struct.
pub fn init() {
INIT_ZSYS.call_once(|| {
unsafe { czmq_sys::zsys_init() };
});
}
/// Create a pipe, which consists of two PAIR sockets connected
/// over inproc.
pub fn create_pipe() -> Result<(ZSock, ZSock)> {
let mut backend_raw: *mut czmq_sys::zsock_t = ptr::null_mut();
let frontend_raw = unsafe { czmq_sys::zsys_create_pipe(&mut backend_raw) };
if frontend_raw == ptr::null_mut() {
Err(Error::new(ErrorKind::NullPtr, ZSysError::CreatePipe))
} else {
Ok(unsafe { (ZSock::from_raw(frontend_raw as *mut c_void, true), ZSock::from_raw(backend_raw as *mut c_void, true)) })
}
}
pub fn is_interrupted() -> bool { | #[derive(Debug)]
pub enum ZSysError {
CreatePipe,
}
impl fmt::Display for ZSysError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ZSysError::CreatePipe => write!(f, "Could not create pipe"),
}
}
}
impl error::Error for ZSysError {
fn description(&self) -> &str {
match *self {
ZSysError::CreatePipe => "Could not create pipe",
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_create_pipe() {
ZSys::init();
let (frontend, backend) = ZSys::create_pipe().unwrap();
frontend.send_str("I changed my iPod’s name to Titanic...now it’s syncing.").unwrap();
assert_eq!(backend.recv_str().unwrap().unwrap(), "I changed my iPod’s name to Titanic...now it’s syncing.");
backend.send_str("My family laughed when I told them I was going to be a comedian. Well...they aren't laughing now!").unwrap();
assert_eq!(frontend.recv_str().unwrap().unwrap(), "My family laughed when I told them I was going to be a comedian. Well...they aren't laughing now!");
}
#[test]
fn test_is_interrupted() {
// This test is half hearted as we can't test the interrupt
// case.
assert!(!ZSys::is_interrupted());
}
} | unsafe { czmq_sys::zsys_interrupted == 1 }
}
}
| random_line_split |
zsys.rs | //! Module: czmq-zsys
use {czmq_sys, RawInterface, Result};
use error::{Error, ErrorKind};
use std::{error, fmt, ptr};
use std::os::raw::c_void;
use std::sync::{Once, ONCE_INIT};
use zsock::ZSock;
static INIT_ZSYS: Once = ONCE_INIT;
pub struct ZSys;
impl ZSys {
// Each new ZSock calls zsys_init(), which is a non-threadsafe
// fn. To mitigate the race condition, wrap it in a Once struct.
pub fn init() {
INIT_ZSYS.call_once(|| {
unsafe { czmq_sys::zsys_init() };
});
}
/// Create a pipe, which consists of two PAIR sockets connected
/// over inproc.
pub fn create_pipe() -> Result<(ZSock, ZSock)> {
let mut backend_raw: *mut czmq_sys::zsock_t = ptr::null_mut();
let frontend_raw = unsafe { czmq_sys::zsys_create_pipe(&mut backend_raw) };
if frontend_raw == ptr::null_mut() {
Err(Error::new(ErrorKind::NullPtr, ZSysError::CreatePipe))
} else {
Ok(unsafe { (ZSock::from_raw(frontend_raw as *mut c_void, true), ZSock::from_raw(backend_raw as *mut c_void, true)) })
}
}
pub fn is_interrupted() -> bool |
}
#[derive(Debug)]
pub enum ZSysError {
CreatePipe,
}
impl fmt::Display for ZSysError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ZSysError::CreatePipe => write!(f, "Could not create pipe"),
}
}
}
impl error::Error for ZSysError {
fn description(&self) -> &str {
match *self {
ZSysError::CreatePipe => "Could not create pipe",
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_create_pipe() {
ZSys::init();
let (frontend, backend) = ZSys::create_pipe().unwrap();
frontend.send_str("I changed my iPod’s name to Titanic...now it’s syncing.").unwrap();
assert_eq!(backend.recv_str().unwrap().unwrap(), "I changed my iPod’s name to Titanic...now it’s syncing.");
backend.send_str("My family laughed when I told them I was going to be a comedian. Well...they aren't laughing now!").unwrap();
assert_eq!(frontend.recv_str().unwrap().unwrap(), "My family laughed when I told them I was going to be a comedian. Well...they aren't laughing now!");
}
#[test]
fn test_is_interrupted() {
// This test is half hearted as we can't test the interrupt
// case.
assert!(!ZSys::is_interrupted());
}
}
| {
unsafe { czmq_sys::zsys_interrupted == 1 }
} | identifier_body |
sha256sum_filebuffer.rs | // Filebuffer -- Fast and simple file reading
// Copyright 2016 Ruud van Asseldonk
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// A copy of the License has been included in the root of the repository.
// This example implements the `sha256sum` program in Rust using the Filebuffer library. Compare
// with `sha256sum_naive` which uses the IO primitives in the standard library.
use std::env;
use crypto::digest::Digest;
use crypto::sha2::Sha256;
use filebuffer::FileBuffer;
extern crate crypto;
extern crate filebuffer;
fn main() | {
for fname in env::args().skip(1) {
let fbuffer = FileBuffer::open(&fname).expect("failed to open file");
let mut hasher = Sha256::new();
hasher.input(&fbuffer);
// Match the output format of `sha256sum`, which has two spaces between the hash and name.
println!("{} {}", hasher.result_str(), fname);
}
} | identifier_body |
|
sha256sum_filebuffer.rs | // Filebuffer -- Fast and simple file reading
// Copyright 2016 Ruud van Asseldonk
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// A copy of the License has been included in the root of the repository.
// This example implements the `sha256sum` program in Rust using the Filebuffer library. Compare
// with `sha256sum_naive` which uses the IO primitives in the standard library.
use std::env;
use crypto::digest::Digest;
use crypto::sha2::Sha256;
use filebuffer::FileBuffer;
extern crate crypto;
extern crate filebuffer;
fn | () {
for fname in env::args().skip(1) {
let fbuffer = FileBuffer::open(&fname).expect("failed to open file");
let mut hasher = Sha256::new();
hasher.input(&fbuffer);
// Match the output format of `sha256sum`, which has two spaces between the hash and name.
println!("{} {}", hasher.result_str(), fname);
}
}
| main | identifier_name |
sha256sum_filebuffer.rs | // Filebuffer -- Fast and simple file reading
// Copyright 2016 Ruud van Asseldonk
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// A copy of the License has been included in the root of the repository.
|
use std::env;
use crypto::digest::Digest;
use crypto::sha2::Sha256;
use filebuffer::FileBuffer;
extern crate crypto;
extern crate filebuffer;
fn main() {
for fname in env::args().skip(1) {
let fbuffer = FileBuffer::open(&fname).expect("failed to open file");
let mut hasher = Sha256::new();
hasher.input(&fbuffer);
// Match the output format of `sha256sum`, which has two spaces between the hash and name.
println!("{} {}", hasher.result_str(), fname);
}
} | // This example implements the `sha256sum` program in Rust using the Filebuffer library. Compare
// with `sha256sum_naive` which uses the IO primitives in the standard library. | random_line_split |
primitive.rs | // Copyright 2012-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};
use ast;
use codemap::Span;
use ext::base::ExtCtxt;
use ext::build::AstBuilder;
use ext::deriving::generic::*;
use ext::deriving::generic::ty::*;
use parse::token::InternedString;
pub fn expand_deriving_from_primitive(cx: &mut ExtCtxt,
span: Span,
mitem: @MetaItem,
item: @Item,
push: |@Item|) | // #[inline] liable to cause code-bloat
attributes: attrs.clone(),
const_nonmatching: false,
combine_substructure: combine_substructure(|c, s, sub| {
cs_from("i64", c, s, sub)
}),
},
MethodDef {
name: "from_u64",
generics: LifetimeBounds::empty(),
explicit_self: None,
args: vec!(
Literal(Path::new(vec!("u64")))),
ret_ty: Literal(Path::new_(vec!("std", "option", "Option"),
None,
vec!(box Self),
true)),
// #[inline] liable to cause code-bloat
attributes: attrs,
const_nonmatching: false,
combine_substructure: combine_substructure(|c, s, sub| {
cs_from("u64", c, s, sub)
}),
})
};
trait_def.expand(cx, mitem, item, push)
}
fn cs_from(name: &str, cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) -> @Expr {
let n = match substr.nonself_args {
[n] => n,
_ => cx.span_bug(trait_span, "incorrect number of arguments in `deriving(FromPrimitive)`")
};
match *substr.fields {
StaticStruct(..) => {
cx.span_err(trait_span, "`FromPrimitive` cannot be derived for structs");
return cx.expr_fail(trait_span, InternedString::new(""));
}
StaticEnum(enum_def, _) => {
if enum_def.variants.is_empty() {
cx.span_err(trait_span,
"`FromPrimitive` cannot be derived for enums with no variants");
return cx.expr_fail(trait_span, InternedString::new(""));
}
let mut arms = Vec::new();
for variant in enum_def.variants.iter() {
match variant.node.kind {
ast::TupleVariantKind(ref args) => {
if!args.is_empty() {
cx.span_err(trait_span,
"`FromPrimitive` cannot be derived for \
enum variants with arguments");
return cx.expr_fail(trait_span,
InternedString::new(""));
}
let span = variant.span;
// expr for `$n == $variant as $name`
let variant = cx.expr_ident(span, variant.node.name);
let ty = cx.ty_ident(span, cx.ident_of(name));
let cast = cx.expr_cast(span, variant, ty);
let guard = cx.expr_binary(span, ast::BiEq, n, cast);
// expr for `Some($variant)`
let body = cx.expr_some(span, variant);
// arm for `_ if $guard => $body`
let arm = ast::Arm {
attrs: vec!(),
pats: vec!(cx.pat_wild(span)),
guard: Some(guard),
body: body,
};
arms.push(arm);
}
ast::StructVariantKind(_) => {
cx.span_err(trait_span,
"`FromPrimitive` cannot be derived for enums \
with struct variants");
return cx.expr_fail(trait_span,
InternedString::new(""));
}
}
}
// arm for `_ => None`
let arm = ast::Arm {
attrs: vec!(),
pats: vec!(cx.pat_wild(trait_span)),
guard: None,
body: cx.expr_none(trait_span),
};
arms.push(arm);
cx.expr_match(trait_span, n, arms)
}
_ => cx.span_bug(trait_span, "expected StaticEnum in deriving(FromPrimitive)")
}
}
| {
let inline = cx.meta_word(span, InternedString::new("inline"));
let attrs = vec!(cx.attribute(span, inline));
let trait_def = TraitDef {
span: span,
attributes: Vec::new(),
path: Path::new(vec!("std", "num", "FromPrimitive")),
additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
methods: vec!(
MethodDef {
name: "from_i64",
generics: LifetimeBounds::empty(),
explicit_self: None,
args: vec!(
Literal(Path::new(vec!("i64")))),
ret_ty: Literal(Path::new_(vec!("std", "option", "Option"),
None,
vec!(box Self),
true)), | identifier_body |
primitive.rs | // Copyright 2012-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};
use ast;
use codemap::Span;
use ext::base::ExtCtxt;
use ext::build::AstBuilder;
use ext::deriving::generic::*;
use ext::deriving::generic::ty::*;
use parse::token::InternedString;
pub fn | (cx: &mut ExtCtxt,
span: Span,
mitem: @MetaItem,
item: @Item,
push: |@Item|) {
let inline = cx.meta_word(span, InternedString::new("inline"));
let attrs = vec!(cx.attribute(span, inline));
let trait_def = TraitDef {
span: span,
attributes: Vec::new(),
path: Path::new(vec!("std", "num", "FromPrimitive")),
additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(),
methods: vec!(
MethodDef {
name: "from_i64",
generics: LifetimeBounds::empty(),
explicit_self: None,
args: vec!(
Literal(Path::new(vec!("i64")))),
ret_ty: Literal(Path::new_(vec!("std", "option", "Option"),
None,
vec!(box Self),
true)),
// #[inline] liable to cause code-bloat
attributes: attrs.clone(),
const_nonmatching: false,
combine_substructure: combine_substructure(|c, s, sub| {
cs_from("i64", c, s, sub)
}),
},
MethodDef {
name: "from_u64",
generics: LifetimeBounds::empty(),
explicit_self: None,
args: vec!(
Literal(Path::new(vec!("u64")))),
ret_ty: Literal(Path::new_(vec!("std", "option", "Option"),
None,
vec!(box Self),
true)),
// #[inline] liable to cause code-bloat
attributes: attrs,
const_nonmatching: false,
combine_substructure: combine_substructure(|c, s, sub| {
cs_from("u64", c, s, sub)
}),
})
};
trait_def.expand(cx, mitem, item, push)
}
fn cs_from(name: &str, cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) -> @Expr {
let n = match substr.nonself_args {
[n] => n,
_ => cx.span_bug(trait_span, "incorrect number of arguments in `deriving(FromPrimitive)`")
};
match *substr.fields {
StaticStruct(..) => {
cx.span_err(trait_span, "`FromPrimitive` cannot be derived for structs");
return cx.expr_fail(trait_span, InternedString::new(""));
}
StaticEnum(enum_def, _) => {
if enum_def.variants.is_empty() {
cx.span_err(trait_span,
"`FromPrimitive` cannot be derived for enums with no variants");
return cx.expr_fail(trait_span, InternedString::new(""));
}
let mut arms = Vec::new();
for variant in enum_def.variants.iter() {
match variant.node.kind {
ast::TupleVariantKind(ref args) => {
if!args.is_empty() {
cx.span_err(trait_span,
"`FromPrimitive` cannot be derived for \
enum variants with arguments");
return cx.expr_fail(trait_span,
InternedString::new(""));
}
let span = variant.span;
// expr for `$n == $variant as $name`
let variant = cx.expr_ident(span, variant.node.name);
let ty = cx.ty_ident(span, cx.ident_of(name));
let cast = cx.expr_cast(span, variant, ty);
let guard = cx.expr_binary(span, ast::BiEq, n, cast);
// expr for `Some($variant)`
let body = cx.expr_some(span, variant);
// arm for `_ if $guard => $body`
let arm = ast::Arm {
attrs: vec!(),
pats: vec!(cx.pat_wild(span)),
guard: Some(guard),
body: body,
};
arms.push(arm);
}
ast::StructVariantKind(_) => {
cx.span_err(trait_span,
"`FromPrimitive` cannot be derived for enums \
with struct variants");
return cx.expr_fail(trait_span,
InternedString::new(""));
}
}
}
// arm for `_ => None`
let arm = ast::Arm {
attrs: vec!(),
pats: vec!(cx.pat_wild(trait_span)),
guard: None,
body: cx.expr_none(trait_span),
};
arms.push(arm);
cx.expr_match(trait_span, n, arms)
}
_ => cx.span_bug(trait_span, "expected StaticEnum in deriving(FromPrimitive)")
}
}
| expand_deriving_from_primitive | identifier_name |
primitive.rs | // Copyright 2012-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};
use ast;
use codemap::Span;
use ext::base::ExtCtxt;
use ext::build::AstBuilder;
use ext::deriving::generic::*;
use ext::deriving::generic::ty::*;
use parse::token::InternedString;
pub fn expand_deriving_from_primitive(cx: &mut ExtCtxt,
span: Span,
mitem: @MetaItem,
item: @Item,
push: |@Item|) {
let inline = cx.meta_word(span, InternedString::new("inline"));
let attrs = vec!(cx.attribute(span, inline));
let trait_def = TraitDef {
span: span,
attributes: Vec::new(),
path: Path::new(vec!("std", "num", "FromPrimitive")),
additional_bounds: Vec::new(),
generics: LifetimeBounds::empty(), | MethodDef {
name: "from_i64",
generics: LifetimeBounds::empty(),
explicit_self: None,
args: vec!(
Literal(Path::new(vec!("i64")))),
ret_ty: Literal(Path::new_(vec!("std", "option", "Option"),
None,
vec!(box Self),
true)),
// #[inline] liable to cause code-bloat
attributes: attrs.clone(),
const_nonmatching: false,
combine_substructure: combine_substructure(|c, s, sub| {
cs_from("i64", c, s, sub)
}),
},
MethodDef {
name: "from_u64",
generics: LifetimeBounds::empty(),
explicit_self: None,
args: vec!(
Literal(Path::new(vec!("u64")))),
ret_ty: Literal(Path::new_(vec!("std", "option", "Option"),
None,
vec!(box Self),
true)),
// #[inline] liable to cause code-bloat
attributes: attrs,
const_nonmatching: false,
combine_substructure: combine_substructure(|c, s, sub| {
cs_from("u64", c, s, sub)
}),
})
};
trait_def.expand(cx, mitem, item, push)
}
fn cs_from(name: &str, cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) -> @Expr {
let n = match substr.nonself_args {
[n] => n,
_ => cx.span_bug(trait_span, "incorrect number of arguments in `deriving(FromPrimitive)`")
};
match *substr.fields {
StaticStruct(..) => {
cx.span_err(trait_span, "`FromPrimitive` cannot be derived for structs");
return cx.expr_fail(trait_span, InternedString::new(""));
}
StaticEnum(enum_def, _) => {
if enum_def.variants.is_empty() {
cx.span_err(trait_span,
"`FromPrimitive` cannot be derived for enums with no variants");
return cx.expr_fail(trait_span, InternedString::new(""));
}
let mut arms = Vec::new();
for variant in enum_def.variants.iter() {
match variant.node.kind {
ast::TupleVariantKind(ref args) => {
if!args.is_empty() {
cx.span_err(trait_span,
"`FromPrimitive` cannot be derived for \
enum variants with arguments");
return cx.expr_fail(trait_span,
InternedString::new(""));
}
let span = variant.span;
// expr for `$n == $variant as $name`
let variant = cx.expr_ident(span, variant.node.name);
let ty = cx.ty_ident(span, cx.ident_of(name));
let cast = cx.expr_cast(span, variant, ty);
let guard = cx.expr_binary(span, ast::BiEq, n, cast);
// expr for `Some($variant)`
let body = cx.expr_some(span, variant);
// arm for `_ if $guard => $body`
let arm = ast::Arm {
attrs: vec!(),
pats: vec!(cx.pat_wild(span)),
guard: Some(guard),
body: body,
};
arms.push(arm);
}
ast::StructVariantKind(_) => {
cx.span_err(trait_span,
"`FromPrimitive` cannot be derived for enums \
with struct variants");
return cx.expr_fail(trait_span,
InternedString::new(""));
}
}
}
// arm for `_ => None`
let arm = ast::Arm {
attrs: vec!(),
pats: vec!(cx.pat_wild(trait_span)),
guard: None,
body: cx.expr_none(trait_span),
};
arms.push(arm);
cx.expr_match(trait_span, n, arms)
}
_ => cx.span_bug(trait_span, "expected StaticEnum in deriving(FromPrimitive)")
}
} | methods: vec!( | random_line_split |
sync.rs | // Copyright 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.
/// Synchronous channels/ports
///
/// This channel implementation differs significantly from the asynchronous
/// implementations found next to it (oneshot/stream/share). This is an
/// implementation of a synchronous, bounded buffer channel.
///
/// Each channel is created with some amount of backing buffer, and sends will
/// *block* until buffer space becomes available. A buffer size of 0 is valid,
/// which means that every successful send is paired with a successful recv.
///
/// This flavor of channels defines a new `send_opt` method for channels which
/// is the method by which a message is sent but the task does not panic if it
/// cannot be delivered.
///
/// Another major difference is that send() will *always* return back the data
/// if it couldn't be sent. This is because it is deterministically known when
/// the data is received and when it is not received.
///
/// Implementation-wise, it can all be summed up with "use a mutex plus some
/// logic". The mutex used here is an OS native mutex, meaning that no user code
/// is run inside of the mutex (to prevent context switching). This
/// implementation shares almost all code for the buffered and unbuffered cases
/// of a synchronous channel. There are a few branches for the unbuffered case,
/// but they're mostly just relevant to blocking senders.
use core::prelude::*;
pub use self::Failure::*;
use self::Blocker::*;
use vec::Vec;
use core::mem;
use core::ptr;
use sync::atomic::{Ordering, AtomicUsize};
use sync::mpsc::blocking::{self, WaitToken, SignalToken};
use sync::mpsc::select::StartResult::{self, Installed, Abort};
use sync::{Mutex, MutexGuard};
pub struct Packet<T> {
/// Only field outside of the mutex. Just done for kicks, but mainly because
/// the other shared channel already had the code implemented
channels: AtomicUsize,
lock: Mutex<State<T>>,
}
unsafe impl<T:Send> Send for Packet<T> { }
unsafe impl<T:Send> Sync for Packet<T> { }
struct State<T> {
disconnected: bool, // Is the channel disconnected yet?
queue: Queue, // queue of senders waiting to send data
blocker: Blocker, // currently blocked task on this channel
buf: Buffer<T>, // storage for buffered messages
cap: uint, // capacity of this channel
/// A curious flag used to indicate whether a sender failed or succeeded in
/// blocking. This is used to transmit information back to the task that it
/// must dequeue its message from the buffer because it was not received.
/// This is only relevant in the 0-buffer case. This obviously cannot be
/// safely constructed, but it's guaranteed to always have a valid pointer
/// value.
canceled: Option<&'static mut bool>,
}
unsafe impl<T: Send> Send for State<T> {}
/// Possible flavors of threads who can be blocked on this channel.
enum Blocker {
BlockedSender(SignalToken),
BlockedReceiver(SignalToken),
NoneBlocked
}
/// Simple queue for threading tasks together. Nodes are stack-allocated, so
/// this structure is not safe at all
struct Queue {
head: *mut Node,
tail: *mut Node,
}
struct Node {
token: Option<SignalToken>,
next: *mut Node,
}
unsafe impl Send for Node {}
/// A simple ring-buffer
struct Buffer<T> {
buf: Vec<Option<T>>,
start: uint,
size: uint,
}
#[derive(Show)]
pub enum Failure {
Empty,
Disconnected,
}
/// Atomically blocks the current thread, placing it into `slot`, unlocking `lock`
/// in the meantime. This re-locks the mutex upon returning.
fn wait<'a, 'b, T: Send>(lock: &'a Mutex<State<T>>,
mut guard: MutexGuard<'b, State<T>>,
f: fn(SignalToken) -> Blocker)
-> MutexGuard<'a, State<T>>
{
let (wait_token, signal_token) = blocking::tokens();
match mem::replace(&mut guard.blocker, f(signal_token)) {
NoneBlocked => {}
_ => unreachable!(),
}
drop(guard); // unlock
wait_token.wait(); // block
lock.lock().unwrap() // relock
}
/// Wakes up a thread, dropping the lock at the correct time
fn wakeup<T>(token: SignalToken, guard: MutexGuard<State<T>>) {
// We need to be careful to wake up the waiting task *outside* of the mutex
// in case it incurs a context switch.
drop(guard);
token.signal();
}
impl<T: Send> Packet<T> {
pub fn new(cap: uint) -> Packet<T> {
Packet {
channels: AtomicUsize::new(1),
lock: Mutex::new(State {
disconnected: false,
blocker: NoneBlocked,
cap: cap,
canceled: None,
queue: Queue {
head: ptr::null_mut(),
tail: ptr::null_mut(),
},
buf: Buffer {
buf: range(0, cap + if cap == 0 {1} else {0}).map(|_| None).collect(),
start: 0,
size: 0,
},
}),
}
}
// wait until a send slot is available, returning locked access to
// the channel state.
fn acquire_send_slot(&self) -> MutexGuard<State<T>> {
let mut node = Node { token: None, next: ptr::null_mut() };
loop {
let mut guard = self.lock.lock().unwrap();
// are we ready to go?
if guard.disconnected || guard.buf.size() < guard.buf.cap() {
return guard;
}
// no room; actually block
let wait_token = guard.queue.enqueue(&mut node);
drop(guard);
wait_token.wait();
}
}
pub fn send(&self, t: T) -> Result<(), T> {
let mut guard = self.acquire_send_slot();
if guard.disconnected { return Err(t) }
guard.buf.enqueue(t);
match mem::replace(&mut guard.blocker, NoneBlocked) {
// if our capacity is 0, then we need to wait for a receiver to be
// available to take our data. After waiting, we check again to make
// sure the port didn't go away in the meantime. If it did, we need
// to hand back our data.
NoneBlocked if guard.cap == 0 => {
let mut canceled = false;
assert!(guard.canceled.is_none());
guard.canceled = Some(unsafe { mem::transmute(&mut canceled) });
let mut guard = wait(&self.lock, guard, BlockedSender);
if canceled {Err(guard.buf.dequeue())} else {Ok(())}
}
// success, we buffered some data
NoneBlocked => Ok(()),
// success, someone's about to receive our buffered data.
BlockedReceiver(token) => { wakeup(token, guard); Ok(()) }
BlockedSender(..) => panic!("lolwut"),
}
}
pub fn try_send(&self, t: T) -> Result<(), super::TrySendError<T>> {
let mut guard = self.lock.lock().unwrap();
if guard.disconnected {
Err(super::TrySendError::Disconnected(t))
} else if guard.buf.size() == guard.buf.cap() {
Err(super::TrySendError::Full(t))
} else if guard.cap == 0 {
// With capacity 0, even though we have buffer space we can't
// transfer the data unless there's a receiver waiting.
match mem::replace(&mut guard.blocker, NoneBlocked) {
NoneBlocked => Err(super::TrySendError::Full(t)),
BlockedSender(..) => unreachable!(),
BlockedReceiver(token) => {
guard.buf.enqueue(t);
wakeup(token, guard);
Ok(())
}
}
} else {
// If the buffer has some space and the capacity isn't 0, then we
// just enqueue the data for later retrieval, ensuring to wake up
// any blocked receiver if there is one.
assert!(guard.buf.size() < guard.buf.cap());
guard.buf.enqueue(t);
match mem::replace(&mut guard.blocker, NoneBlocked) {
BlockedReceiver(token) => wakeup(token, guard),
NoneBlocked => {}
BlockedSender(..) => unreachable!(),
}
Ok(())
}
}
// Receives a message from this channel
//
// When reading this, remember that there can only ever be one receiver at
// time.
pub fn recv(&self) -> Result<T, ()> {
let mut guard = self.lock.lock().unwrap();
// Wait for the buffer to have something in it. No need for a while loop
// because we're the only receiver.
let mut waited = false;
if!guard.disconnected && guard.buf.size() == 0 {
guard = wait(&self.lock, guard, BlockedReceiver);
waited = true;
}
if guard.disconnected && guard.buf.size() == 0 { return Err(()) }
// Pick up the data, wake up our neighbors, and carry on
assert!(guard.buf.size() > 0);
let ret = guard.buf.dequeue();
self.wakeup_senders(waited, guard);
return Ok(ret);
}
pub fn try_recv(&self) -> Result<T, Failure> {
let mut guard = self.lock.lock().unwrap();
// Easy cases first
if guard.disconnected { return Err(Disconnected) }
if guard.buf.size() == 0 { return Err(Empty) }
// Be sure to wake up neighbors
let ret = Ok(guard.buf.dequeue());
self.wakeup_senders(false, guard);
return ret;
}
// Wake up pending senders after some data has been received
//
// * `waited` - flag if the receiver blocked to receive some data, or if it
// just picked up some data on the way out
// * `guard` - the lock guard that is held over this channel's lock
fn wakeup_senders(&self, waited: bool, mut guard: MutexGuard<State<T>>) {
let pending_sender1: Option<SignalToken> = guard.queue.dequeue();
// If this is a no-buffer channel (cap == 0), then if we didn't wait we
// need to ACK the sender. If we waited, then the sender waking us up
// was already the ACK.
let pending_sender2 = if guard.cap == 0 &&!waited {
match mem::replace(&mut guard.blocker, NoneBlocked) {
NoneBlocked => None,
BlockedReceiver(..) => unreachable!(),
BlockedSender(token) => {
guard.canceled.take();
Some(token)
}
}
} else {
None
};
mem::drop(guard);
// only outside of the lock do we wake up the pending tasks
pending_sender1.map(|t| t.signal());
pending_sender2.map(|t| t.signal());
}
// Prepares this shared packet for a channel clone, essentially just bumping
// a refcount.
pub fn clone_chan(&self) {
self.channels.fetch_add(1, Ordering::SeqCst);
}
pub fn drop_chan(&self) {
// Only flag the channel as disconnected if we're the last channel
match self.channels.fetch_sub(1, Ordering::SeqCst) {
1 => {}
_ => return
}
// Not much to do other than wake up a receiver if one's there
let mut guard = self.lock.lock().unwrap();
if guard.disconnected { return }
guard.disconnected = true;
match mem::replace(&mut guard.blocker, NoneBlocked) {
NoneBlocked => {}
BlockedSender(..) => unreachable!(),
BlockedReceiver(token) => wakeup(token, guard),
}
}
pub fn drop_port(&self) {
let mut guard = self.lock.lock().unwrap();
if guard.disconnected { return }
guard.disconnected = true;
// If the capacity is 0, then the sender may want its data back after
// we're disconnected. Otherwise it's now our responsibility to destroy
// the buffered data. As with many other portions of this code, this
// needs to be careful to destroy the data *outside* of the lock to
// prevent deadlock.
let _data = if guard.cap!= 0 {
mem::replace(&mut guard.buf.buf, Vec::new())
} else {
Vec::new()
};
let mut queue = mem::replace(&mut guard.queue, Queue {
head: ptr::null_mut(),
tail: ptr::null_mut(),
});
let waiter = match mem::replace(&mut guard.blocker, NoneBlocked) {
NoneBlocked => None,
BlockedSender(token) => {
*guard.canceled.take().unwrap() = true;
Some(token)
}
BlockedReceiver(..) => unreachable!(),
};
mem::drop(guard);
loop {
match queue.dequeue() {
Some(token) => { token.signal(); }
None => break,
}
}
waiter.map(|t| t.signal());
}
////////////////////////////////////////////////////////////////////////////
// select implementation
////////////////////////////////////////////////////////////////////////////
// If Ok, the value is whether this port has data, if Err, then the upgraded
// port needs to be checked instead of this one.
pub fn can_recv(&self) -> bool {
let guard = self.lock.lock().unwrap();
guard.disconnected || guard.buf.size() > 0
}
// Attempts to start selection on this port. This can either succeed or fail
// because there is data waiting.
pub fn start_selection(&self, token: SignalToken) -> StartResult {
let mut guard = self.lock.lock().unwrap();
if guard.disconnected || guard.buf.size() > 0 {
Abort
} else {
match mem::replace(&mut guard.blocker, BlockedReceiver(token)) {
NoneBlocked => {}
BlockedSender(..) => unreachable!(),
BlockedReceiver(..) => unreachable!(),
}
Installed
}
}
// Remove a previous selecting task from this port. This ensures that the
// blocked task will no longer be visible to any other threads.
//
// The return value indicates whether there's data on this port.
pub fn abort_selection(&self) -> bool {
let mut guard = self.lock.lock().unwrap();
match mem::replace(&mut guard.blocker, NoneBlocked) {
NoneBlocked => true,
BlockedSender(token) => {
guard.blocker = BlockedSender(token);
true
}
BlockedReceiver(token) => { drop(token); false }
}
}
}
#[unsafe_destructor]
impl<T: Send> Drop for Packet<T> {
fn drop(&mut self) {
assert_eq!(self.channels.load(Ordering::SeqCst), 0);
let mut guard = self.lock.lock().unwrap();
assert!(guard.queue.dequeue().is_none());
assert!(guard.canceled.is_none());
}
}
////////////////////////////////////////////////////////////////////////////////
// Buffer, a simple ring buffer backed by Vec<T>
////////////////////////////////////////////////////////////////////////////////
impl<T> Buffer<T> {
fn enqueue(&mut self, t: T) {
let pos = (self.start + self.size) % self.buf.len();
self.size += 1;
let prev = mem::replace(&mut self.buf[pos], Some(t));
assert!(prev.is_none());
}
fn dequeue(&mut self) -> T {
let start = self.start;
self.size -= 1;
self.start = (self.start + 1) % self.buf.len();
let result = &mut self.buf[start];
result.take().unwrap()
}
fn size(&self) -> uint { self.size }
fn cap(&self) -> uint { self.buf.len() }
}
////////////////////////////////////////////////////////////////////////////////
// Queue, a simple queue to enqueue tasks with (stack-allocated nodes)
////////////////////////////////////////////////////////////////////////////////
impl Queue {
fn enqueue(&mut self, node: &mut Node) -> WaitToken {
let (wait_token, signal_token) = blocking::tokens();
node.token = Some(signal_token);
node.next = ptr::null_mut();
if self.tail.is_null() {
self.head = node as *mut Node;
self.tail = node as *mut Node;
} else {
unsafe {
(*self.tail).next = node as *mut Node;
self.tail = node as *mut Node;
}
}
wait_token
}
fn dequeue(&mut self) -> Option<SignalToken> |
}
| {
if self.head.is_null() {
return None
}
let node = self.head;
self.head = unsafe { (*node).next };
if self.head.is_null() {
self.tail = ptr::null_mut();
}
unsafe {
(*node).next = ptr::null_mut();
Some((*node).token.take().unwrap())
}
} | identifier_body |
sync.rs | // Copyright 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.
/// Synchronous channels/ports
///
/// This channel implementation differs significantly from the asynchronous
/// implementations found next to it (oneshot/stream/share). This is an
/// implementation of a synchronous, bounded buffer channel.
///
/// Each channel is created with some amount of backing buffer, and sends will
/// *block* until buffer space becomes available. A buffer size of 0 is valid,
/// which means that every successful send is paired with a successful recv.
///
/// This flavor of channels defines a new `send_opt` method for channels which
/// is the method by which a message is sent but the task does not panic if it
/// cannot be delivered.
///
/// Another major difference is that send() will *always* return back the data
/// if it couldn't be sent. This is because it is deterministically known when
/// the data is received and when it is not received.
///
/// Implementation-wise, it can all be summed up with "use a mutex plus some
/// logic". The mutex used here is an OS native mutex, meaning that no user code
/// is run inside of the mutex (to prevent context switching). This
/// implementation shares almost all code for the buffered and unbuffered cases
/// of a synchronous channel. There are a few branches for the unbuffered case,
/// but they're mostly just relevant to blocking senders.
use core::prelude::*;
pub use self::Failure::*;
use self::Blocker::*;
use vec::Vec;
use core::mem;
use core::ptr;
use sync::atomic::{Ordering, AtomicUsize};
use sync::mpsc::blocking::{self, WaitToken, SignalToken};
use sync::mpsc::select::StartResult::{self, Installed, Abort};
use sync::{Mutex, MutexGuard};
pub struct Packet<T> {
/// Only field outside of the mutex. Just done for kicks, but mainly because
/// the other shared channel already had the code implemented
channels: AtomicUsize,
lock: Mutex<State<T>>,
}
unsafe impl<T:Send> Send for Packet<T> { }
unsafe impl<T:Send> Sync for Packet<T> { }
struct State<T> {
disconnected: bool, // Is the channel disconnected yet?
queue: Queue, // queue of senders waiting to send data
blocker: Blocker, // currently blocked task on this channel
buf: Buffer<T>, // storage for buffered messages
cap: uint, // capacity of this channel
/// A curious flag used to indicate whether a sender failed or succeeded in
/// blocking. This is used to transmit information back to the task that it
/// must dequeue its message from the buffer because it was not received.
/// This is only relevant in the 0-buffer case. This obviously cannot be
/// safely constructed, but it's guaranteed to always have a valid pointer
/// value.
canceled: Option<&'static mut bool>,
}
unsafe impl<T: Send> Send for State<T> {}
/// Possible flavors of threads who can be blocked on this channel.
enum Blocker {
BlockedSender(SignalToken),
BlockedReceiver(SignalToken),
NoneBlocked
}
/// Simple queue for threading tasks together. Nodes are stack-allocated, so
/// this structure is not safe at all
struct Queue {
head: *mut Node,
tail: *mut Node,
}
struct Node {
token: Option<SignalToken>,
next: *mut Node,
}
unsafe impl Send for Node {}
/// A simple ring-buffer
struct Buffer<T> {
buf: Vec<Option<T>>,
start: uint,
size: uint,
}
#[derive(Show)]
pub enum Failure {
Empty,
Disconnected,
}
/// Atomically blocks the current thread, placing it into `slot`, unlocking `lock`
/// in the meantime. This re-locks the mutex upon returning.
fn wait<'a, 'b, T: Send>(lock: &'a Mutex<State<T>>,
mut guard: MutexGuard<'b, State<T>>,
f: fn(SignalToken) -> Blocker)
-> MutexGuard<'a, State<T>>
{
let (wait_token, signal_token) = blocking::tokens();
match mem::replace(&mut guard.blocker, f(signal_token)) {
NoneBlocked => {}
_ => unreachable!(),
}
drop(guard); // unlock
wait_token.wait(); // block
lock.lock().unwrap() // relock
}
/// Wakes up a thread, dropping the lock at the correct time
fn wakeup<T>(token: SignalToken, guard: MutexGuard<State<T>>) {
// We need to be careful to wake up the waiting task *outside* of the mutex
// in case it incurs a context switch.
drop(guard);
token.signal();
}
impl<T: Send> Packet<T> {
pub fn new(cap: uint) -> Packet<T> {
Packet {
channels: AtomicUsize::new(1),
lock: Mutex::new(State {
disconnected: false,
blocker: NoneBlocked,
cap: cap,
canceled: None,
queue: Queue {
head: ptr::null_mut(),
tail: ptr::null_mut(),
},
buf: Buffer {
buf: range(0, cap + if cap == 0 {1} else {0}).map(|_| None).collect(),
start: 0,
size: 0,
},
}),
}
}
// wait until a send slot is available, returning locked access to
// the channel state.
fn acquire_send_slot(&self) -> MutexGuard<State<T>> {
let mut node = Node { token: None, next: ptr::null_mut() };
loop {
let mut guard = self.lock.lock().unwrap();
// are we ready to go?
if guard.disconnected || guard.buf.size() < guard.buf.cap() {
return guard;
}
// no room; actually block
let wait_token = guard.queue.enqueue(&mut node);
drop(guard);
wait_token.wait();
}
}
pub fn send(&self, t: T) -> Result<(), T> {
let mut guard = self.acquire_send_slot();
if guard.disconnected { return Err(t) }
guard.buf.enqueue(t);
match mem::replace(&mut guard.blocker, NoneBlocked) {
// if our capacity is 0, then we need to wait for a receiver to be
// available to take our data. After waiting, we check again to make
// sure the port didn't go away in the meantime. If it did, we need
// to hand back our data.
NoneBlocked if guard.cap == 0 => {
let mut canceled = false;
assert!(guard.canceled.is_none());
guard.canceled = Some(unsafe { mem::transmute(&mut canceled) });
let mut guard = wait(&self.lock, guard, BlockedSender);
if canceled {Err(guard.buf.dequeue())} else {Ok(())}
}
// success, we buffered some data
NoneBlocked => Ok(()),
// success, someone's about to receive our buffered data.
BlockedReceiver(token) => { wakeup(token, guard); Ok(()) }
BlockedSender(..) => panic!("lolwut"),
}
}
pub fn try_send(&self, t: T) -> Result<(), super::TrySendError<T>> {
let mut guard = self.lock.lock().unwrap();
if guard.disconnected {
Err(super::TrySendError::Disconnected(t))
} else if guard.buf.size() == guard.buf.cap() {
Err(super::TrySendError::Full(t))
} else if guard.cap == 0 {
// With capacity 0, even though we have buffer space we can't
// transfer the data unless there's a receiver waiting.
match mem::replace(&mut guard.blocker, NoneBlocked) {
NoneBlocked => Err(super::TrySendError::Full(t)),
BlockedSender(..) => unreachable!(),
BlockedReceiver(token) => {
guard.buf.enqueue(t);
wakeup(token, guard);
Ok(())
}
}
} else {
// If the buffer has some space and the capacity isn't 0, then we
// just enqueue the data for later retrieval, ensuring to wake up
// any blocked receiver if there is one.
assert!(guard.buf.size() < guard.buf.cap());
guard.buf.enqueue(t);
match mem::replace(&mut guard.blocker, NoneBlocked) {
BlockedReceiver(token) => wakeup(token, guard),
NoneBlocked => {}
BlockedSender(..) => unreachable!(),
}
Ok(())
}
}
// Receives a message from this channel
//
// When reading this, remember that there can only ever be one receiver at
// time.
pub fn recv(&self) -> Result<T, ()> {
let mut guard = self.lock.lock().unwrap();
// Wait for the buffer to have something in it. No need for a while loop
// because we're the only receiver.
let mut waited = false;
if!guard.disconnected && guard.buf.size() == 0 {
guard = wait(&self.lock, guard, BlockedReceiver);
waited = true;
}
if guard.disconnected && guard.buf.size() == 0 { return Err(()) }
// Pick up the data, wake up our neighbors, and carry on
assert!(guard.buf.size() > 0);
let ret = guard.buf.dequeue();
self.wakeup_senders(waited, guard);
return Ok(ret);
}
pub fn try_recv(&self) -> Result<T, Failure> {
let mut guard = self.lock.lock().unwrap();
// Easy cases first
if guard.disconnected { return Err(Disconnected) }
if guard.buf.size() == 0 { return Err(Empty) }
// Be sure to wake up neighbors
let ret = Ok(guard.buf.dequeue());
self.wakeup_senders(false, guard);
return ret;
}
// Wake up pending senders after some data has been received
//
// * `waited` - flag if the receiver blocked to receive some data, or if it
// just picked up some data on the way out
// * `guard` - the lock guard that is held over this channel's lock
fn wakeup_senders(&self, waited: bool, mut guard: MutexGuard<State<T>>) {
let pending_sender1: Option<SignalToken> = guard.queue.dequeue();
// If this is a no-buffer channel (cap == 0), then if we didn't wait we
// need to ACK the sender. If we waited, then the sender waking us up
// was already the ACK.
let pending_sender2 = if guard.cap == 0 &&!waited {
match mem::replace(&mut guard.blocker, NoneBlocked) {
NoneBlocked => None,
BlockedReceiver(..) => unreachable!(),
BlockedSender(token) => {
guard.canceled.take();
Some(token)
}
}
} else {
None
};
mem::drop(guard);
// only outside of the lock do we wake up the pending tasks
pending_sender1.map(|t| t.signal());
pending_sender2.map(|t| t.signal());
}
// Prepares this shared packet for a channel clone, essentially just bumping
// a refcount.
pub fn clone_chan(&self) {
self.channels.fetch_add(1, Ordering::SeqCst);
}
pub fn drop_chan(&self) {
// Only flag the channel as disconnected if we're the last channel
match self.channels.fetch_sub(1, Ordering::SeqCst) {
1 => {}
_ => return
}
// Not much to do other than wake up a receiver if one's there
let mut guard = self.lock.lock().unwrap();
if guard.disconnected { return }
guard.disconnected = true;
match mem::replace(&mut guard.blocker, NoneBlocked) {
NoneBlocked => {}
BlockedSender(..) => unreachable!(),
BlockedReceiver(token) => wakeup(token, guard),
}
}
pub fn drop_port(&self) {
let mut guard = self.lock.lock().unwrap();
if guard.disconnected { return }
guard.disconnected = true;
// If the capacity is 0, then the sender may want its data back after
// we're disconnected. Otherwise it's now our responsibility to destroy
// the buffered data. As with many other portions of this code, this
// needs to be careful to destroy the data *outside* of the lock to
// prevent deadlock.
let _data = if guard.cap!= 0 {
mem::replace(&mut guard.buf.buf, Vec::new())
} else {
Vec::new()
};
let mut queue = mem::replace(&mut guard.queue, Queue {
head: ptr::null_mut(),
tail: ptr::null_mut(),
});
let waiter = match mem::replace(&mut guard.blocker, NoneBlocked) {
NoneBlocked => None,
BlockedSender(token) => {
*guard.canceled.take().unwrap() = true;
Some(token)
}
BlockedReceiver(..) => unreachable!(),
};
mem::drop(guard);
loop {
match queue.dequeue() {
Some(token) => { token.signal(); }
None => break,
}
}
waiter.map(|t| t.signal());
}
////////////////////////////////////////////////////////////////////////////
// select implementation
////////////////////////////////////////////////////////////////////////////
// If Ok, the value is whether this port has data, if Err, then the upgraded
// port needs to be checked instead of this one.
pub fn can_recv(&self) -> bool {
let guard = self.lock.lock().unwrap();
guard.disconnected || guard.buf.size() > 0
}
// Attempts to start selection on this port. This can either succeed or fail
// because there is data waiting.
pub fn start_selection(&self, token: SignalToken) -> StartResult {
let mut guard = self.lock.lock().unwrap();
if guard.disconnected || guard.buf.size() > 0 {
Abort
} else { | BlockedReceiver(..) => unreachable!(),
}
Installed
}
}
// Remove a previous selecting task from this port. This ensures that the
// blocked task will no longer be visible to any other threads.
//
// The return value indicates whether there's data on this port.
pub fn abort_selection(&self) -> bool {
let mut guard = self.lock.lock().unwrap();
match mem::replace(&mut guard.blocker, NoneBlocked) {
NoneBlocked => true,
BlockedSender(token) => {
guard.blocker = BlockedSender(token);
true
}
BlockedReceiver(token) => { drop(token); false }
}
}
}
#[unsafe_destructor]
impl<T: Send> Drop for Packet<T> {
fn drop(&mut self) {
assert_eq!(self.channels.load(Ordering::SeqCst), 0);
let mut guard = self.lock.lock().unwrap();
assert!(guard.queue.dequeue().is_none());
assert!(guard.canceled.is_none());
}
}
////////////////////////////////////////////////////////////////////////////////
// Buffer, a simple ring buffer backed by Vec<T>
////////////////////////////////////////////////////////////////////////////////
impl<T> Buffer<T> {
fn enqueue(&mut self, t: T) {
let pos = (self.start + self.size) % self.buf.len();
self.size += 1;
let prev = mem::replace(&mut self.buf[pos], Some(t));
assert!(prev.is_none());
}
fn dequeue(&mut self) -> T {
let start = self.start;
self.size -= 1;
self.start = (self.start + 1) % self.buf.len();
let result = &mut self.buf[start];
result.take().unwrap()
}
fn size(&self) -> uint { self.size }
fn cap(&self) -> uint { self.buf.len() }
}
////////////////////////////////////////////////////////////////////////////////
// Queue, a simple queue to enqueue tasks with (stack-allocated nodes)
////////////////////////////////////////////////////////////////////////////////
impl Queue {
fn enqueue(&mut self, node: &mut Node) -> WaitToken {
let (wait_token, signal_token) = blocking::tokens();
node.token = Some(signal_token);
node.next = ptr::null_mut();
if self.tail.is_null() {
self.head = node as *mut Node;
self.tail = node as *mut Node;
} else {
unsafe {
(*self.tail).next = node as *mut Node;
self.tail = node as *mut Node;
}
}
wait_token
}
fn dequeue(&mut self) -> Option<SignalToken> {
if self.head.is_null() {
return None
}
let node = self.head;
self.head = unsafe { (*node).next };
if self.head.is_null() {
self.tail = ptr::null_mut();
}
unsafe {
(*node).next = ptr::null_mut();
Some((*node).token.take().unwrap())
}
}
} | match mem::replace(&mut guard.blocker, BlockedReceiver(token)) {
NoneBlocked => {}
BlockedSender(..) => unreachable!(), | random_line_split |
sync.rs | // Copyright 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.
/// Synchronous channels/ports
///
/// This channel implementation differs significantly from the asynchronous
/// implementations found next to it (oneshot/stream/share). This is an
/// implementation of a synchronous, bounded buffer channel.
///
/// Each channel is created with some amount of backing buffer, and sends will
/// *block* until buffer space becomes available. A buffer size of 0 is valid,
/// which means that every successful send is paired with a successful recv.
///
/// This flavor of channels defines a new `send_opt` method for channels which
/// is the method by which a message is sent but the task does not panic if it
/// cannot be delivered.
///
/// Another major difference is that send() will *always* return back the data
/// if it couldn't be sent. This is because it is deterministically known when
/// the data is received and when it is not received.
///
/// Implementation-wise, it can all be summed up with "use a mutex plus some
/// logic". The mutex used here is an OS native mutex, meaning that no user code
/// is run inside of the mutex (to prevent context switching). This
/// implementation shares almost all code for the buffered and unbuffered cases
/// of a synchronous channel. There are a few branches for the unbuffered case,
/// but they're mostly just relevant to blocking senders.
use core::prelude::*;
pub use self::Failure::*;
use self::Blocker::*;
use vec::Vec;
use core::mem;
use core::ptr;
use sync::atomic::{Ordering, AtomicUsize};
use sync::mpsc::blocking::{self, WaitToken, SignalToken};
use sync::mpsc::select::StartResult::{self, Installed, Abort};
use sync::{Mutex, MutexGuard};
pub struct Packet<T> {
/// Only field outside of the mutex. Just done for kicks, but mainly because
/// the other shared channel already had the code implemented
channels: AtomicUsize,
lock: Mutex<State<T>>,
}
unsafe impl<T:Send> Send for Packet<T> { }
unsafe impl<T:Send> Sync for Packet<T> { }
struct State<T> {
disconnected: bool, // Is the channel disconnected yet?
queue: Queue, // queue of senders waiting to send data
blocker: Blocker, // currently blocked task on this channel
buf: Buffer<T>, // storage for buffered messages
cap: uint, // capacity of this channel
/// A curious flag used to indicate whether a sender failed or succeeded in
/// blocking. This is used to transmit information back to the task that it
/// must dequeue its message from the buffer because it was not received.
/// This is only relevant in the 0-buffer case. This obviously cannot be
/// safely constructed, but it's guaranteed to always have a valid pointer
/// value.
canceled: Option<&'static mut bool>,
}
unsafe impl<T: Send> Send for State<T> {}
/// Possible flavors of threads who can be blocked on this channel.
enum Blocker {
BlockedSender(SignalToken),
BlockedReceiver(SignalToken),
NoneBlocked
}
/// Simple queue for threading tasks together. Nodes are stack-allocated, so
/// this structure is not safe at all
struct Queue {
head: *mut Node,
tail: *mut Node,
}
struct Node {
token: Option<SignalToken>,
next: *mut Node,
}
unsafe impl Send for Node {}
/// A simple ring-buffer
struct Buffer<T> {
buf: Vec<Option<T>>,
start: uint,
size: uint,
}
#[derive(Show)]
pub enum Failure {
Empty,
Disconnected,
}
/// Atomically blocks the current thread, placing it into `slot`, unlocking `lock`
/// in the meantime. This re-locks the mutex upon returning.
fn wait<'a, 'b, T: Send>(lock: &'a Mutex<State<T>>,
mut guard: MutexGuard<'b, State<T>>,
f: fn(SignalToken) -> Blocker)
-> MutexGuard<'a, State<T>>
{
let (wait_token, signal_token) = blocking::tokens();
match mem::replace(&mut guard.blocker, f(signal_token)) {
NoneBlocked => {}
_ => unreachable!(),
}
drop(guard); // unlock
wait_token.wait(); // block
lock.lock().unwrap() // relock
}
/// Wakes up a thread, dropping the lock at the correct time
fn wakeup<T>(token: SignalToken, guard: MutexGuard<State<T>>) {
// We need to be careful to wake up the waiting task *outside* of the mutex
// in case it incurs a context switch.
drop(guard);
token.signal();
}
impl<T: Send> Packet<T> {
pub fn new(cap: uint) -> Packet<T> {
Packet {
channels: AtomicUsize::new(1),
lock: Mutex::new(State {
disconnected: false,
blocker: NoneBlocked,
cap: cap,
canceled: None,
queue: Queue {
head: ptr::null_mut(),
tail: ptr::null_mut(),
},
buf: Buffer {
buf: range(0, cap + if cap == 0 {1} else {0}).map(|_| None).collect(),
start: 0,
size: 0,
},
}),
}
}
// wait until a send slot is available, returning locked access to
// the channel state.
fn acquire_send_slot(&self) -> MutexGuard<State<T>> {
let mut node = Node { token: None, next: ptr::null_mut() };
loop {
let mut guard = self.lock.lock().unwrap();
// are we ready to go?
if guard.disconnected || guard.buf.size() < guard.buf.cap() {
return guard;
}
// no room; actually block
let wait_token = guard.queue.enqueue(&mut node);
drop(guard);
wait_token.wait();
}
}
pub fn send(&self, t: T) -> Result<(), T> {
let mut guard = self.acquire_send_slot();
if guard.disconnected { return Err(t) }
guard.buf.enqueue(t);
match mem::replace(&mut guard.blocker, NoneBlocked) {
// if our capacity is 0, then we need to wait for a receiver to be
// available to take our data. After waiting, we check again to make
// sure the port didn't go away in the meantime. If it did, we need
// to hand back our data.
NoneBlocked if guard.cap == 0 => {
let mut canceled = false;
assert!(guard.canceled.is_none());
guard.canceled = Some(unsafe { mem::transmute(&mut canceled) });
let mut guard = wait(&self.lock, guard, BlockedSender);
if canceled {Err(guard.buf.dequeue())} else {Ok(())}
}
// success, we buffered some data
NoneBlocked => Ok(()),
// success, someone's about to receive our buffered data.
BlockedReceiver(token) => { wakeup(token, guard); Ok(()) }
BlockedSender(..) => panic!("lolwut"),
}
}
pub fn try_send(&self, t: T) -> Result<(), super::TrySendError<T>> {
let mut guard = self.lock.lock().unwrap();
if guard.disconnected {
Err(super::TrySendError::Disconnected(t))
} else if guard.buf.size() == guard.buf.cap() {
Err(super::TrySendError::Full(t))
} else if guard.cap == 0 {
// With capacity 0, even though we have buffer space we can't
// transfer the data unless there's a receiver waiting.
match mem::replace(&mut guard.blocker, NoneBlocked) {
NoneBlocked => Err(super::TrySendError::Full(t)),
BlockedSender(..) => unreachable!(),
BlockedReceiver(token) => {
guard.buf.enqueue(t);
wakeup(token, guard);
Ok(())
}
}
} else {
// If the buffer has some space and the capacity isn't 0, then we
// just enqueue the data for later retrieval, ensuring to wake up
// any blocked receiver if there is one.
assert!(guard.buf.size() < guard.buf.cap());
guard.buf.enqueue(t);
match mem::replace(&mut guard.blocker, NoneBlocked) {
BlockedReceiver(token) => wakeup(token, guard),
NoneBlocked => {}
BlockedSender(..) => unreachable!(),
}
Ok(())
}
}
// Receives a message from this channel
//
// When reading this, remember that there can only ever be one receiver at
// time.
pub fn recv(&self) -> Result<T, ()> {
let mut guard = self.lock.lock().unwrap();
// Wait for the buffer to have something in it. No need for a while loop
// because we're the only receiver.
let mut waited = false;
if!guard.disconnected && guard.buf.size() == 0 {
guard = wait(&self.lock, guard, BlockedReceiver);
waited = true;
}
if guard.disconnected && guard.buf.size() == 0 { return Err(()) }
// Pick up the data, wake up our neighbors, and carry on
assert!(guard.buf.size() > 0);
let ret = guard.buf.dequeue();
self.wakeup_senders(waited, guard);
return Ok(ret);
}
pub fn try_recv(&self) -> Result<T, Failure> {
let mut guard = self.lock.lock().unwrap();
// Easy cases first
if guard.disconnected { return Err(Disconnected) }
if guard.buf.size() == 0 { return Err(Empty) }
// Be sure to wake up neighbors
let ret = Ok(guard.buf.dequeue());
self.wakeup_senders(false, guard);
return ret;
}
// Wake up pending senders after some data has been received
//
// * `waited` - flag if the receiver blocked to receive some data, or if it
// just picked up some data on the way out
// * `guard` - the lock guard that is held over this channel's lock
fn wakeup_senders(&self, waited: bool, mut guard: MutexGuard<State<T>>) {
let pending_sender1: Option<SignalToken> = guard.queue.dequeue();
// If this is a no-buffer channel (cap == 0), then if we didn't wait we
// need to ACK the sender. If we waited, then the sender waking us up
// was already the ACK.
let pending_sender2 = if guard.cap == 0 &&!waited {
match mem::replace(&mut guard.blocker, NoneBlocked) {
NoneBlocked => None,
BlockedReceiver(..) => unreachable!(),
BlockedSender(token) => {
guard.canceled.take();
Some(token)
}
}
} else {
None
};
mem::drop(guard);
// only outside of the lock do we wake up the pending tasks
pending_sender1.map(|t| t.signal());
pending_sender2.map(|t| t.signal());
}
// Prepares this shared packet for a channel clone, essentially just bumping
// a refcount.
pub fn clone_chan(&self) {
self.channels.fetch_add(1, Ordering::SeqCst);
}
pub fn drop_chan(&self) {
// Only flag the channel as disconnected if we're the last channel
match self.channels.fetch_sub(1, Ordering::SeqCst) {
1 => {}
_ => return
}
// Not much to do other than wake up a receiver if one's there
let mut guard = self.lock.lock().unwrap();
if guard.disconnected { return }
guard.disconnected = true;
match mem::replace(&mut guard.blocker, NoneBlocked) {
NoneBlocked => {}
BlockedSender(..) => unreachable!(),
BlockedReceiver(token) => wakeup(token, guard),
}
}
pub fn drop_port(&self) {
let mut guard = self.lock.lock().unwrap();
if guard.disconnected { return }
guard.disconnected = true;
// If the capacity is 0, then the sender may want its data back after
// we're disconnected. Otherwise it's now our responsibility to destroy
// the buffered data. As with many other portions of this code, this
// needs to be careful to destroy the data *outside* of the lock to
// prevent deadlock.
let _data = if guard.cap!= 0 {
mem::replace(&mut guard.buf.buf, Vec::new())
} else | ;
let mut queue = mem::replace(&mut guard.queue, Queue {
head: ptr::null_mut(),
tail: ptr::null_mut(),
});
let waiter = match mem::replace(&mut guard.blocker, NoneBlocked) {
NoneBlocked => None,
BlockedSender(token) => {
*guard.canceled.take().unwrap() = true;
Some(token)
}
BlockedReceiver(..) => unreachable!(),
};
mem::drop(guard);
loop {
match queue.dequeue() {
Some(token) => { token.signal(); }
None => break,
}
}
waiter.map(|t| t.signal());
}
////////////////////////////////////////////////////////////////////////////
// select implementation
////////////////////////////////////////////////////////////////////////////
// If Ok, the value is whether this port has data, if Err, then the upgraded
// port needs to be checked instead of this one.
pub fn can_recv(&self) -> bool {
let guard = self.lock.lock().unwrap();
guard.disconnected || guard.buf.size() > 0
}
// Attempts to start selection on this port. This can either succeed or fail
// because there is data waiting.
pub fn start_selection(&self, token: SignalToken) -> StartResult {
let mut guard = self.lock.lock().unwrap();
if guard.disconnected || guard.buf.size() > 0 {
Abort
} else {
match mem::replace(&mut guard.blocker, BlockedReceiver(token)) {
NoneBlocked => {}
BlockedSender(..) => unreachable!(),
BlockedReceiver(..) => unreachable!(),
}
Installed
}
}
// Remove a previous selecting task from this port. This ensures that the
// blocked task will no longer be visible to any other threads.
//
// The return value indicates whether there's data on this port.
pub fn abort_selection(&self) -> bool {
let mut guard = self.lock.lock().unwrap();
match mem::replace(&mut guard.blocker, NoneBlocked) {
NoneBlocked => true,
BlockedSender(token) => {
guard.blocker = BlockedSender(token);
true
}
BlockedReceiver(token) => { drop(token); false }
}
}
}
#[unsafe_destructor]
impl<T: Send> Drop for Packet<T> {
fn drop(&mut self) {
assert_eq!(self.channels.load(Ordering::SeqCst), 0);
let mut guard = self.lock.lock().unwrap();
assert!(guard.queue.dequeue().is_none());
assert!(guard.canceled.is_none());
}
}
////////////////////////////////////////////////////////////////////////////////
// Buffer, a simple ring buffer backed by Vec<T>
////////////////////////////////////////////////////////////////////////////////
impl<T> Buffer<T> {
fn enqueue(&mut self, t: T) {
let pos = (self.start + self.size) % self.buf.len();
self.size += 1;
let prev = mem::replace(&mut self.buf[pos], Some(t));
assert!(prev.is_none());
}
fn dequeue(&mut self) -> T {
let start = self.start;
self.size -= 1;
self.start = (self.start + 1) % self.buf.len();
let result = &mut self.buf[start];
result.take().unwrap()
}
fn size(&self) -> uint { self.size }
fn cap(&self) -> uint { self.buf.len() }
}
////////////////////////////////////////////////////////////////////////////////
// Queue, a simple queue to enqueue tasks with (stack-allocated nodes)
////////////////////////////////////////////////////////////////////////////////
impl Queue {
fn enqueue(&mut self, node: &mut Node) -> WaitToken {
let (wait_token, signal_token) = blocking::tokens();
node.token = Some(signal_token);
node.next = ptr::null_mut();
if self.tail.is_null() {
self.head = node as *mut Node;
self.tail = node as *mut Node;
} else {
unsafe {
(*self.tail).next = node as *mut Node;
self.tail = node as *mut Node;
}
}
wait_token
}
fn dequeue(&mut self) -> Option<SignalToken> {
if self.head.is_null() {
return None
}
let node = self.head;
self.head = unsafe { (*node).next };
if self.head.is_null() {
self.tail = ptr::null_mut();
}
unsafe {
(*node).next = ptr::null_mut();
Some((*node).token.take().unwrap())
}
}
}
| {
Vec::new()
} | conditional_block |
sync.rs | // Copyright 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.
/// Synchronous channels/ports
///
/// This channel implementation differs significantly from the asynchronous
/// implementations found next to it (oneshot/stream/share). This is an
/// implementation of a synchronous, bounded buffer channel.
///
/// Each channel is created with some amount of backing buffer, and sends will
/// *block* until buffer space becomes available. A buffer size of 0 is valid,
/// which means that every successful send is paired with a successful recv.
///
/// This flavor of channels defines a new `send_opt` method for channels which
/// is the method by which a message is sent but the task does not panic if it
/// cannot be delivered.
///
/// Another major difference is that send() will *always* return back the data
/// if it couldn't be sent. This is because it is deterministically known when
/// the data is received and when it is not received.
///
/// Implementation-wise, it can all be summed up with "use a mutex plus some
/// logic". The mutex used here is an OS native mutex, meaning that no user code
/// is run inside of the mutex (to prevent context switching). This
/// implementation shares almost all code for the buffered and unbuffered cases
/// of a synchronous channel. There are a few branches for the unbuffered case,
/// but they're mostly just relevant to blocking senders.
use core::prelude::*;
pub use self::Failure::*;
use self::Blocker::*;
use vec::Vec;
use core::mem;
use core::ptr;
use sync::atomic::{Ordering, AtomicUsize};
use sync::mpsc::blocking::{self, WaitToken, SignalToken};
use sync::mpsc::select::StartResult::{self, Installed, Abort};
use sync::{Mutex, MutexGuard};
pub struct Packet<T> {
/// Only field outside of the mutex. Just done for kicks, but mainly because
/// the other shared channel already had the code implemented
channels: AtomicUsize,
lock: Mutex<State<T>>,
}
unsafe impl<T:Send> Send for Packet<T> { }
unsafe impl<T:Send> Sync for Packet<T> { }
struct State<T> {
disconnected: bool, // Is the channel disconnected yet?
queue: Queue, // queue of senders waiting to send data
blocker: Blocker, // currently blocked task on this channel
buf: Buffer<T>, // storage for buffered messages
cap: uint, // capacity of this channel
/// A curious flag used to indicate whether a sender failed or succeeded in
/// blocking. This is used to transmit information back to the task that it
/// must dequeue its message from the buffer because it was not received.
/// This is only relevant in the 0-buffer case. This obviously cannot be
/// safely constructed, but it's guaranteed to always have a valid pointer
/// value.
canceled: Option<&'static mut bool>,
}
unsafe impl<T: Send> Send for State<T> {}
/// Possible flavors of threads who can be blocked on this channel.
enum Blocker {
BlockedSender(SignalToken),
BlockedReceiver(SignalToken),
NoneBlocked
}
/// Simple queue for threading tasks together. Nodes are stack-allocated, so
/// this structure is not safe at all
struct Queue {
head: *mut Node,
tail: *mut Node,
}
struct Node {
token: Option<SignalToken>,
next: *mut Node,
}
unsafe impl Send for Node {}
/// A simple ring-buffer
struct Buffer<T> {
buf: Vec<Option<T>>,
start: uint,
size: uint,
}
#[derive(Show)]
pub enum Failure {
Empty,
Disconnected,
}
/// Atomically blocks the current thread, placing it into `slot`, unlocking `lock`
/// in the meantime. This re-locks the mutex upon returning.
fn wait<'a, 'b, T: Send>(lock: &'a Mutex<State<T>>,
mut guard: MutexGuard<'b, State<T>>,
f: fn(SignalToken) -> Blocker)
-> MutexGuard<'a, State<T>>
{
let (wait_token, signal_token) = blocking::tokens();
match mem::replace(&mut guard.blocker, f(signal_token)) {
NoneBlocked => {}
_ => unreachable!(),
}
drop(guard); // unlock
wait_token.wait(); // block
lock.lock().unwrap() // relock
}
/// Wakes up a thread, dropping the lock at the correct time
fn wakeup<T>(token: SignalToken, guard: MutexGuard<State<T>>) {
// We need to be careful to wake up the waiting task *outside* of the mutex
// in case it incurs a context switch.
drop(guard);
token.signal();
}
impl<T: Send> Packet<T> {
pub fn new(cap: uint) -> Packet<T> {
Packet {
channels: AtomicUsize::new(1),
lock: Mutex::new(State {
disconnected: false,
blocker: NoneBlocked,
cap: cap,
canceled: None,
queue: Queue {
head: ptr::null_mut(),
tail: ptr::null_mut(),
},
buf: Buffer {
buf: range(0, cap + if cap == 0 {1} else {0}).map(|_| None).collect(),
start: 0,
size: 0,
},
}),
}
}
// wait until a send slot is available, returning locked access to
// the channel state.
fn acquire_send_slot(&self) -> MutexGuard<State<T>> {
let mut node = Node { token: None, next: ptr::null_mut() };
loop {
let mut guard = self.lock.lock().unwrap();
// are we ready to go?
if guard.disconnected || guard.buf.size() < guard.buf.cap() {
return guard;
}
// no room; actually block
let wait_token = guard.queue.enqueue(&mut node);
drop(guard);
wait_token.wait();
}
}
pub fn send(&self, t: T) -> Result<(), T> {
let mut guard = self.acquire_send_slot();
if guard.disconnected { return Err(t) }
guard.buf.enqueue(t);
match mem::replace(&mut guard.blocker, NoneBlocked) {
// if our capacity is 0, then we need to wait for a receiver to be
// available to take our data. After waiting, we check again to make
// sure the port didn't go away in the meantime. If it did, we need
// to hand back our data.
NoneBlocked if guard.cap == 0 => {
let mut canceled = false;
assert!(guard.canceled.is_none());
guard.canceled = Some(unsafe { mem::transmute(&mut canceled) });
let mut guard = wait(&self.lock, guard, BlockedSender);
if canceled {Err(guard.buf.dequeue())} else {Ok(())}
}
// success, we buffered some data
NoneBlocked => Ok(()),
// success, someone's about to receive our buffered data.
BlockedReceiver(token) => { wakeup(token, guard); Ok(()) }
BlockedSender(..) => panic!("lolwut"),
}
}
pub fn try_send(&self, t: T) -> Result<(), super::TrySendError<T>> {
let mut guard = self.lock.lock().unwrap();
if guard.disconnected {
Err(super::TrySendError::Disconnected(t))
} else if guard.buf.size() == guard.buf.cap() {
Err(super::TrySendError::Full(t))
} else if guard.cap == 0 {
// With capacity 0, even though we have buffer space we can't
// transfer the data unless there's a receiver waiting.
match mem::replace(&mut guard.blocker, NoneBlocked) {
NoneBlocked => Err(super::TrySendError::Full(t)),
BlockedSender(..) => unreachable!(),
BlockedReceiver(token) => {
guard.buf.enqueue(t);
wakeup(token, guard);
Ok(())
}
}
} else {
// If the buffer has some space and the capacity isn't 0, then we
// just enqueue the data for later retrieval, ensuring to wake up
// any blocked receiver if there is one.
assert!(guard.buf.size() < guard.buf.cap());
guard.buf.enqueue(t);
match mem::replace(&mut guard.blocker, NoneBlocked) {
BlockedReceiver(token) => wakeup(token, guard),
NoneBlocked => {}
BlockedSender(..) => unreachable!(),
}
Ok(())
}
}
// Receives a message from this channel
//
// When reading this, remember that there can only ever be one receiver at
// time.
pub fn recv(&self) -> Result<T, ()> {
let mut guard = self.lock.lock().unwrap();
// Wait for the buffer to have something in it. No need for a while loop
// because we're the only receiver.
let mut waited = false;
if!guard.disconnected && guard.buf.size() == 0 {
guard = wait(&self.lock, guard, BlockedReceiver);
waited = true;
}
if guard.disconnected && guard.buf.size() == 0 { return Err(()) }
// Pick up the data, wake up our neighbors, and carry on
assert!(guard.buf.size() > 0);
let ret = guard.buf.dequeue();
self.wakeup_senders(waited, guard);
return Ok(ret);
}
pub fn try_recv(&self) -> Result<T, Failure> {
let mut guard = self.lock.lock().unwrap();
// Easy cases first
if guard.disconnected { return Err(Disconnected) }
if guard.buf.size() == 0 { return Err(Empty) }
// Be sure to wake up neighbors
let ret = Ok(guard.buf.dequeue());
self.wakeup_senders(false, guard);
return ret;
}
// Wake up pending senders after some data has been received
//
// * `waited` - flag if the receiver blocked to receive some data, or if it
// just picked up some data on the way out
// * `guard` - the lock guard that is held over this channel's lock
fn wakeup_senders(&self, waited: bool, mut guard: MutexGuard<State<T>>) {
let pending_sender1: Option<SignalToken> = guard.queue.dequeue();
// If this is a no-buffer channel (cap == 0), then if we didn't wait we
// need to ACK the sender. If we waited, then the sender waking us up
// was already the ACK.
let pending_sender2 = if guard.cap == 0 &&!waited {
match mem::replace(&mut guard.blocker, NoneBlocked) {
NoneBlocked => None,
BlockedReceiver(..) => unreachable!(),
BlockedSender(token) => {
guard.canceled.take();
Some(token)
}
}
} else {
None
};
mem::drop(guard);
// only outside of the lock do we wake up the pending tasks
pending_sender1.map(|t| t.signal());
pending_sender2.map(|t| t.signal());
}
// Prepares this shared packet for a channel clone, essentially just bumping
// a refcount.
pub fn clone_chan(&self) {
self.channels.fetch_add(1, Ordering::SeqCst);
}
pub fn drop_chan(&self) {
// Only flag the channel as disconnected if we're the last channel
match self.channels.fetch_sub(1, Ordering::SeqCst) {
1 => {}
_ => return
}
// Not much to do other than wake up a receiver if one's there
let mut guard = self.lock.lock().unwrap();
if guard.disconnected { return }
guard.disconnected = true;
match mem::replace(&mut guard.blocker, NoneBlocked) {
NoneBlocked => {}
BlockedSender(..) => unreachable!(),
BlockedReceiver(token) => wakeup(token, guard),
}
}
pub fn | (&self) {
let mut guard = self.lock.lock().unwrap();
if guard.disconnected { return }
guard.disconnected = true;
// If the capacity is 0, then the sender may want its data back after
// we're disconnected. Otherwise it's now our responsibility to destroy
// the buffered data. As with many other portions of this code, this
// needs to be careful to destroy the data *outside* of the lock to
// prevent deadlock.
let _data = if guard.cap!= 0 {
mem::replace(&mut guard.buf.buf, Vec::new())
} else {
Vec::new()
};
let mut queue = mem::replace(&mut guard.queue, Queue {
head: ptr::null_mut(),
tail: ptr::null_mut(),
});
let waiter = match mem::replace(&mut guard.blocker, NoneBlocked) {
NoneBlocked => None,
BlockedSender(token) => {
*guard.canceled.take().unwrap() = true;
Some(token)
}
BlockedReceiver(..) => unreachable!(),
};
mem::drop(guard);
loop {
match queue.dequeue() {
Some(token) => { token.signal(); }
None => break,
}
}
waiter.map(|t| t.signal());
}
////////////////////////////////////////////////////////////////////////////
// select implementation
////////////////////////////////////////////////////////////////////////////
// If Ok, the value is whether this port has data, if Err, then the upgraded
// port needs to be checked instead of this one.
pub fn can_recv(&self) -> bool {
let guard = self.lock.lock().unwrap();
guard.disconnected || guard.buf.size() > 0
}
// Attempts to start selection on this port. This can either succeed or fail
// because there is data waiting.
pub fn start_selection(&self, token: SignalToken) -> StartResult {
let mut guard = self.lock.lock().unwrap();
if guard.disconnected || guard.buf.size() > 0 {
Abort
} else {
match mem::replace(&mut guard.blocker, BlockedReceiver(token)) {
NoneBlocked => {}
BlockedSender(..) => unreachable!(),
BlockedReceiver(..) => unreachable!(),
}
Installed
}
}
// Remove a previous selecting task from this port. This ensures that the
// blocked task will no longer be visible to any other threads.
//
// The return value indicates whether there's data on this port.
pub fn abort_selection(&self) -> bool {
let mut guard = self.lock.lock().unwrap();
match mem::replace(&mut guard.blocker, NoneBlocked) {
NoneBlocked => true,
BlockedSender(token) => {
guard.blocker = BlockedSender(token);
true
}
BlockedReceiver(token) => { drop(token); false }
}
}
}
#[unsafe_destructor]
impl<T: Send> Drop for Packet<T> {
fn drop(&mut self) {
assert_eq!(self.channels.load(Ordering::SeqCst), 0);
let mut guard = self.lock.lock().unwrap();
assert!(guard.queue.dequeue().is_none());
assert!(guard.canceled.is_none());
}
}
////////////////////////////////////////////////////////////////////////////////
// Buffer, a simple ring buffer backed by Vec<T>
////////////////////////////////////////////////////////////////////////////////
impl<T> Buffer<T> {
fn enqueue(&mut self, t: T) {
let pos = (self.start + self.size) % self.buf.len();
self.size += 1;
let prev = mem::replace(&mut self.buf[pos], Some(t));
assert!(prev.is_none());
}
fn dequeue(&mut self) -> T {
let start = self.start;
self.size -= 1;
self.start = (self.start + 1) % self.buf.len();
let result = &mut self.buf[start];
result.take().unwrap()
}
fn size(&self) -> uint { self.size }
fn cap(&self) -> uint { self.buf.len() }
}
////////////////////////////////////////////////////////////////////////////////
// Queue, a simple queue to enqueue tasks with (stack-allocated nodes)
////////////////////////////////////////////////////////////////////////////////
impl Queue {
fn enqueue(&mut self, node: &mut Node) -> WaitToken {
let (wait_token, signal_token) = blocking::tokens();
node.token = Some(signal_token);
node.next = ptr::null_mut();
if self.tail.is_null() {
self.head = node as *mut Node;
self.tail = node as *mut Node;
} else {
unsafe {
(*self.tail).next = node as *mut Node;
self.tail = node as *mut Node;
}
}
wait_token
}
fn dequeue(&mut self) -> Option<SignalToken> {
if self.head.is_null() {
return None
}
let node = self.head;
self.head = unsafe { (*node).next };
if self.head.is_null() {
self.tail = ptr::null_mut();
}
unsafe {
(*node).next = ptr::null_mut();
Some((*node).token.take().unwrap())
}
}
}
| drop_port | identifier_name |
shootout-nbody.rs | // The Computer Language Benchmarks Game
// http://benchmarksgame.alioth.debian.org/
//
// contributed by the Rust Project Developers
// Copyright (c) 2011-2014 The Rust Project Developers
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// - Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// - Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in
// the documentation and/or other materials provided with the
// distribution.
//
// - Neither the name of "The Computer Language Benchmarks Game" nor
// the name of "The Computer Language Shootout Benchmarks" nor the
// names of its contributors may be used to endorse or promote
// products derived from this software without specific prior
// written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
// OF THE POSSIBILITY OF SUCH DAMAGE.
use std::num::Float;
const PI: f64 = 3.141592653589793;
const SOLAR_MASS: f64 = 4.0 * PI * PI;
const YEAR: f64 = 365.24;
const N_BODIES: uint = 5;
static BODIES: [Planet;N_BODIES] = [
// Sun
Planet {
x: 0.0, y: 0.0, z: 0.0,
vx: 0.0, vy: 0.0, vz: 0.0,
mass: SOLAR_MASS,
},
// Jupiter
Planet {
x: 4.84143144246472090e+00,
y: -1.16032004402742839e+00,
z: -1.03622044471123109e-01,
vx: 1.66007664274403694e-03 * YEAR,
vy: 7.69901118419740425e-03 * YEAR,
vz: -6.90460016972063023e-05 * YEAR,
mass: 9.54791938424326609e-04 * SOLAR_MASS,
},
// Saturn
Planet {
x: 8.34336671824457987e+00,
y: 4.12479856412430479e+00,
z: -4.03523417114321381e-01,
vx: -2.76742510726862411e-03 * YEAR,
vy: 4.99852801234917238e-03 * YEAR,
vz: 2.30417297573763929e-05 * YEAR,
mass: 2.85885980666130812e-04 * SOLAR_MASS,
},
// Uranus
Planet {
x: 1.28943695621391310e+01,
y: -1.51111514016986312e+01,
z: -2.23307578892655734e-01,
vx: 2.96460137564761618e-03 * YEAR,
vy: 2.37847173959480950e-03 * YEAR,
vz: -2.96589568540237556e-05 * YEAR,
mass: 4.36624404335156298e-05 * SOLAR_MASS,
},
// Neptune
Planet {
x: 1.53796971148509165e+01,
y: -2.59193146099879641e+01,
z: 1.79258772950371181e-01,
vx: 2.68067772490389322e-03 * YEAR,
vy: 1.62824170038242295e-03 * YEAR,
vz: -9.51592254519715870e-05 * YEAR,
mass: 5.15138902046611451e-05 * SOLAR_MASS,
},
];
struct Planet {
x: f64, y: f64, z: f64,
vx: f64, vy: f64, vz: f64,
mass: f64,
}
impl Copy for Planet {}
fn advance(bodies: &mut [Planet;N_BODIES], dt: f64, steps: int) {
for _ in range(0, steps) {
let mut b_slice = bodies.as_mut_slice();
loop {
let bi = match shift_mut_ref(&mut b_slice) {
Some(bi) => bi,
None => break
};
for bj in b_slice.iter_mut() {
let dx = bi.x - bj.x;
let dy = bi.y - bj.y;
let dz = bi.z - bj.z;
let d2 = dx * dx + dy * dy + dz * dz;
let mag = dt / (d2 * d2.sqrt());
let massj_mag = bj.mass * mag;
bi.vx -= dx * massj_mag;
bi.vy -= dy * massj_mag;
bi.vz -= dz * massj_mag;
let massi_mag = bi.mass * mag;
bj.vx += dx * massi_mag;
bj.vy += dy * massi_mag;
bj.vz += dz * massi_mag;
}
bi.x += dt * bi.vx;
bi.y += dt * bi.vy;
bi.z += dt * bi.vz;
}
}
}
fn energy(bodies: &[Planet;N_BODIES]) -> f64 {
let mut e = 0.0;
let mut bodies = bodies.iter();
loop {
let bi = match bodies.next() {
Some(bi) => bi,
None => break
};
e += (bi.vx * bi.vx + bi.vy * bi.vy + bi.vz * bi.vz) * bi.mass / 2.0;
for bj in bodies.clone() {
let dx = bi.x - bj.x;
let dy = bi.y - bj.y;
let dz = bi.z - bj.z;
let dist = (dx * dx + dy * dy + dz * dz).sqrt();
e -= bi.mass * bj.mass / dist;
}
}
e
}
fn offset_momentum(bodies: &mut [Planet;N_BODIES]) {
let mut px = 0.0;
let mut py = 0.0;
let mut pz = 0.0;
for bi in bodies.iter() {
px += bi.vx * bi.mass;
py += bi.vy * bi.mass;
pz += bi.vz * bi.mass;
}
let sun = &mut bodies[0];
sun.vx = - px / SOLAR_MASS;
sun.vy = - py / SOLAR_MASS;
sun.vz = - pz / SOLAR_MASS;
}
fn main() {
let n = if std::os::getenv("RUST_BENCH").is_some() {
5000000
} else {
std::os::args().as_slice().get(1)
.and_then(|arg| arg.parse())
.unwrap_or(1000)
};
let mut bodies = BODIES;
offset_momentum(&mut bodies);
println!("{:.9}", energy(&bodies));
advance(&mut bodies, 0.01, n);
println!("{:.9}", energy(&bodies));
}
/// Pop a mutable reference off the head of a slice, mutating the slice to no
/// longer contain the mutable reference. This is a safe operation because the
/// two mutable borrows are entirely disjoint.
fn | <'a, T>(r: &mut &'a mut [T]) -> Option<&'a mut T> {
use std::mem;
use std::raw::Repr;
if r.len() == 0 { return None }
unsafe {
let mut raw = r.repr();
let ret = raw.data as *mut T;
raw.data = raw.data.offset(1);
raw.len -= 1;
*r = mem::transmute(raw);
Some(unsafe { &mut *ret })
}
}
| shift_mut_ref | identifier_name |
shootout-nbody.rs | // The Computer Language Benchmarks Game
// http://benchmarksgame.alioth.debian.org/
//
// contributed by the Rust Project Developers
// Copyright (c) 2011-2014 The Rust Project Developers
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// - Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// - Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in
// the documentation and/or other materials provided with the
// distribution.
//
// - Neither the name of "The Computer Language Benchmarks Game" nor
// the name of "The Computer Language Shootout Benchmarks" nor the
// names of its contributors may be used to endorse or promote
// products derived from this software without specific prior
// written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
// OF THE POSSIBILITY OF SUCH DAMAGE.
use std::num::Float;
const PI: f64 = 3.141592653589793;
const SOLAR_MASS: f64 = 4.0 * PI * PI;
const YEAR: f64 = 365.24;
const N_BODIES: uint = 5;
static BODIES: [Planet;N_BODIES] = [
// Sun
Planet {
x: 0.0, y: 0.0, z: 0.0,
vx: 0.0, vy: 0.0, vz: 0.0,
mass: SOLAR_MASS,
},
// Jupiter
Planet {
x: 4.84143144246472090e+00,
y: -1.16032004402742839e+00,
z: -1.03622044471123109e-01,
vx: 1.66007664274403694e-03 * YEAR,
vy: 7.69901118419740425e-03 * YEAR,
vz: -6.90460016972063023e-05 * YEAR,
mass: 9.54791938424326609e-04 * SOLAR_MASS,
},
// Saturn
Planet {
x: 8.34336671824457987e+00,
y: 4.12479856412430479e+00,
z: -4.03523417114321381e-01,
vx: -2.76742510726862411e-03 * YEAR,
vy: 4.99852801234917238e-03 * YEAR,
vz: 2.30417297573763929e-05 * YEAR,
mass: 2.85885980666130812e-04 * SOLAR_MASS,
},
// Uranus
Planet {
x: 1.28943695621391310e+01,
y: -1.51111514016986312e+01,
z: -2.23307578892655734e-01,
vx: 2.96460137564761618e-03 * YEAR,
vy: 2.37847173959480950e-03 * YEAR,
vz: -2.96589568540237556e-05 * YEAR,
mass: 4.36624404335156298e-05 * SOLAR_MASS,
},
// Neptune
Planet {
x: 1.53796971148509165e+01,
y: -2.59193146099879641e+01,
z: 1.79258772950371181e-01,
vx: 2.68067772490389322e-03 * YEAR,
vy: 1.62824170038242295e-03 * YEAR,
vz: -9.51592254519715870e-05 * YEAR,
mass: 5.15138902046611451e-05 * SOLAR_MASS,
},
];
struct Planet {
x: f64, y: f64, z: f64,
vx: f64, vy: f64, vz: f64,
mass: f64,
}
impl Copy for Planet {}
fn advance(bodies: &mut [Planet;N_BODIES], dt: f64, steps: int) |
let massi_mag = bi.mass * mag;
bj.vx += dx * massi_mag;
bj.vy += dy * massi_mag;
bj.vz += dz * massi_mag;
}
bi.x += dt * bi.vx;
bi.y += dt * bi.vy;
bi.z += dt * bi.vz;
}
}
}
fn energy(bodies: &[Planet;N_BODIES]) -> f64 {
let mut e = 0.0;
let mut bodies = bodies.iter();
loop {
let bi = match bodies.next() {
Some(bi) => bi,
None => break
};
e += (bi.vx * bi.vx + bi.vy * bi.vy + bi.vz * bi.vz) * bi.mass / 2.0;
for bj in bodies.clone() {
let dx = bi.x - bj.x;
let dy = bi.y - bj.y;
let dz = bi.z - bj.z;
let dist = (dx * dx + dy * dy + dz * dz).sqrt();
e -= bi.mass * bj.mass / dist;
}
}
e
}
fn offset_momentum(bodies: &mut [Planet;N_BODIES]) {
let mut px = 0.0;
let mut py = 0.0;
let mut pz = 0.0;
for bi in bodies.iter() {
px += bi.vx * bi.mass;
py += bi.vy * bi.mass;
pz += bi.vz * bi.mass;
}
let sun = &mut bodies[0];
sun.vx = - px / SOLAR_MASS;
sun.vy = - py / SOLAR_MASS;
sun.vz = - pz / SOLAR_MASS;
}
fn main() {
let n = if std::os::getenv("RUST_BENCH").is_some() {
5000000
} else {
std::os::args().as_slice().get(1)
.and_then(|arg| arg.parse())
.unwrap_or(1000)
};
let mut bodies = BODIES;
offset_momentum(&mut bodies);
println!("{:.9}", energy(&bodies));
advance(&mut bodies, 0.01, n);
println!("{:.9}", energy(&bodies));
}
/// Pop a mutable reference off the head of a slice, mutating the slice to no
/// longer contain the mutable reference. This is a safe operation because the
/// two mutable borrows are entirely disjoint.
fn shift_mut_ref<'a, T>(r: &mut &'a mut [T]) -> Option<&'a mut T> {
use std::mem;
use std::raw::Repr;
if r.len() == 0 { return None }
unsafe {
let mut raw = r.repr();
let ret = raw.data as *mut T;
raw.data = raw.data.offset(1);
raw.len -= 1;
*r = mem::transmute(raw);
Some(unsafe { &mut *ret })
}
}
| {
for _ in range(0, steps) {
let mut b_slice = bodies.as_mut_slice();
loop {
let bi = match shift_mut_ref(&mut b_slice) {
Some(bi) => bi,
None => break
};
for bj in b_slice.iter_mut() {
let dx = bi.x - bj.x;
let dy = bi.y - bj.y;
let dz = bi.z - bj.z;
let d2 = dx * dx + dy * dy + dz * dz;
let mag = dt / (d2 * d2.sqrt());
let massj_mag = bj.mass * mag;
bi.vx -= dx * massj_mag;
bi.vy -= dy * massj_mag;
bi.vz -= dz * massj_mag; | identifier_body |
shootout-nbody.rs | // The Computer Language Benchmarks Game
// http://benchmarksgame.alioth.debian.org/
//
// contributed by the Rust Project Developers
// Copyright (c) 2011-2014 The Rust Project Developers
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// - Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// - Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in
// the documentation and/or other materials provided with the
// distribution.
//
// - Neither the name of "The Computer Language Benchmarks Game" nor
// the name of "The Computer Language Shootout Benchmarks" nor the
// names of its contributors may be used to endorse or promote
// products derived from this software without specific prior
// written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
// OF THE POSSIBILITY OF SUCH DAMAGE.
use std::num::Float;
const PI: f64 = 3.141592653589793;
const SOLAR_MASS: f64 = 4.0 * PI * PI;
const YEAR: f64 = 365.24;
const N_BODIES: uint = 5;
static BODIES: [Planet;N_BODIES] = [
// Sun
Planet {
x: 0.0, y: 0.0, z: 0.0,
vx: 0.0, vy: 0.0, vz: 0.0,
mass: SOLAR_MASS,
},
// Jupiter
Planet {
x: 4.84143144246472090e+00,
y: -1.16032004402742839e+00,
z: -1.03622044471123109e-01,
vx: 1.66007664274403694e-03 * YEAR,
vy: 7.69901118419740425e-03 * YEAR,
vz: -6.90460016972063023e-05 * YEAR,
mass: 9.54791938424326609e-04 * SOLAR_MASS,
},
// Saturn
Planet {
x: 8.34336671824457987e+00,
y: 4.12479856412430479e+00,
z: -4.03523417114321381e-01,
vx: -2.76742510726862411e-03 * YEAR,
vy: 4.99852801234917238e-03 * YEAR,
vz: 2.30417297573763929e-05 * YEAR,
mass: 2.85885980666130812e-04 * SOLAR_MASS,
},
// Uranus
Planet {
x: 1.28943695621391310e+01,
y: -1.51111514016986312e+01,
z: -2.23307578892655734e-01,
vx: 2.96460137564761618e-03 * YEAR,
vy: 2.37847173959480950e-03 * YEAR,
vz: -2.96589568540237556e-05 * YEAR,
mass: 4.36624404335156298e-05 * SOLAR_MASS,
},
// Neptune | vy: 1.62824170038242295e-03 * YEAR,
vz: -9.51592254519715870e-05 * YEAR,
mass: 5.15138902046611451e-05 * SOLAR_MASS,
},
];
struct Planet {
x: f64, y: f64, z: f64,
vx: f64, vy: f64, vz: f64,
mass: f64,
}
impl Copy for Planet {}
fn advance(bodies: &mut [Planet;N_BODIES], dt: f64, steps: int) {
for _ in range(0, steps) {
let mut b_slice = bodies.as_mut_slice();
loop {
let bi = match shift_mut_ref(&mut b_slice) {
Some(bi) => bi,
None => break
};
for bj in b_slice.iter_mut() {
let dx = bi.x - bj.x;
let dy = bi.y - bj.y;
let dz = bi.z - bj.z;
let d2 = dx * dx + dy * dy + dz * dz;
let mag = dt / (d2 * d2.sqrt());
let massj_mag = bj.mass * mag;
bi.vx -= dx * massj_mag;
bi.vy -= dy * massj_mag;
bi.vz -= dz * massj_mag;
let massi_mag = bi.mass * mag;
bj.vx += dx * massi_mag;
bj.vy += dy * massi_mag;
bj.vz += dz * massi_mag;
}
bi.x += dt * bi.vx;
bi.y += dt * bi.vy;
bi.z += dt * bi.vz;
}
}
}
fn energy(bodies: &[Planet;N_BODIES]) -> f64 {
let mut e = 0.0;
let mut bodies = bodies.iter();
loop {
let bi = match bodies.next() {
Some(bi) => bi,
None => break
};
e += (bi.vx * bi.vx + bi.vy * bi.vy + bi.vz * bi.vz) * bi.mass / 2.0;
for bj in bodies.clone() {
let dx = bi.x - bj.x;
let dy = bi.y - bj.y;
let dz = bi.z - bj.z;
let dist = (dx * dx + dy * dy + dz * dz).sqrt();
e -= bi.mass * bj.mass / dist;
}
}
e
}
fn offset_momentum(bodies: &mut [Planet;N_BODIES]) {
let mut px = 0.0;
let mut py = 0.0;
let mut pz = 0.0;
for bi in bodies.iter() {
px += bi.vx * bi.mass;
py += bi.vy * bi.mass;
pz += bi.vz * bi.mass;
}
let sun = &mut bodies[0];
sun.vx = - px / SOLAR_MASS;
sun.vy = - py / SOLAR_MASS;
sun.vz = - pz / SOLAR_MASS;
}
fn main() {
let n = if std::os::getenv("RUST_BENCH").is_some() {
5000000
} else {
std::os::args().as_slice().get(1)
.and_then(|arg| arg.parse())
.unwrap_or(1000)
};
let mut bodies = BODIES;
offset_momentum(&mut bodies);
println!("{:.9}", energy(&bodies));
advance(&mut bodies, 0.01, n);
println!("{:.9}", energy(&bodies));
}
/// Pop a mutable reference off the head of a slice, mutating the slice to no
/// longer contain the mutable reference. This is a safe operation because the
/// two mutable borrows are entirely disjoint.
fn shift_mut_ref<'a, T>(r: &mut &'a mut [T]) -> Option<&'a mut T> {
use std::mem;
use std::raw::Repr;
if r.len() == 0 { return None }
unsafe {
let mut raw = r.repr();
let ret = raw.data as *mut T;
raw.data = raw.data.offset(1);
raw.len -= 1;
*r = mem::transmute(raw);
Some(unsafe { &mut *ret })
}
} | Planet {
x: 1.53796971148509165e+01,
y: -2.59193146099879641e+01,
z: 1.79258772950371181e-01,
vx: 2.68067772490389322e-03 * YEAR, | random_line_split |
shootout-nbody.rs | // The Computer Language Benchmarks Game
// http://benchmarksgame.alioth.debian.org/
//
// contributed by the Rust Project Developers
// Copyright (c) 2011-2014 The Rust Project Developers
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// - Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// - Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in
// the documentation and/or other materials provided with the
// distribution.
//
// - Neither the name of "The Computer Language Benchmarks Game" nor
// the name of "The Computer Language Shootout Benchmarks" nor the
// names of its contributors may be used to endorse or promote
// products derived from this software without specific prior
// written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
// OF THE POSSIBILITY OF SUCH DAMAGE.
use std::num::Float;
const PI: f64 = 3.141592653589793;
const SOLAR_MASS: f64 = 4.0 * PI * PI;
const YEAR: f64 = 365.24;
const N_BODIES: uint = 5;
static BODIES: [Planet;N_BODIES] = [
// Sun
Planet {
x: 0.0, y: 0.0, z: 0.0,
vx: 0.0, vy: 0.0, vz: 0.0,
mass: SOLAR_MASS,
},
// Jupiter
Planet {
x: 4.84143144246472090e+00,
y: -1.16032004402742839e+00,
z: -1.03622044471123109e-01,
vx: 1.66007664274403694e-03 * YEAR,
vy: 7.69901118419740425e-03 * YEAR,
vz: -6.90460016972063023e-05 * YEAR,
mass: 9.54791938424326609e-04 * SOLAR_MASS,
},
// Saturn
Planet {
x: 8.34336671824457987e+00,
y: 4.12479856412430479e+00,
z: -4.03523417114321381e-01,
vx: -2.76742510726862411e-03 * YEAR,
vy: 4.99852801234917238e-03 * YEAR,
vz: 2.30417297573763929e-05 * YEAR,
mass: 2.85885980666130812e-04 * SOLAR_MASS,
},
// Uranus
Planet {
x: 1.28943695621391310e+01,
y: -1.51111514016986312e+01,
z: -2.23307578892655734e-01,
vx: 2.96460137564761618e-03 * YEAR,
vy: 2.37847173959480950e-03 * YEAR,
vz: -2.96589568540237556e-05 * YEAR,
mass: 4.36624404335156298e-05 * SOLAR_MASS,
},
// Neptune
Planet {
x: 1.53796971148509165e+01,
y: -2.59193146099879641e+01,
z: 1.79258772950371181e-01,
vx: 2.68067772490389322e-03 * YEAR,
vy: 1.62824170038242295e-03 * YEAR,
vz: -9.51592254519715870e-05 * YEAR,
mass: 5.15138902046611451e-05 * SOLAR_MASS,
},
];
struct Planet {
x: f64, y: f64, z: f64,
vx: f64, vy: f64, vz: f64,
mass: f64,
}
impl Copy for Planet {}
fn advance(bodies: &mut [Planet;N_BODIES], dt: f64, steps: int) {
for _ in range(0, steps) {
let mut b_slice = bodies.as_mut_slice();
loop {
let bi = match shift_mut_ref(&mut b_slice) {
Some(bi) => bi,
None => break
};
for bj in b_slice.iter_mut() {
let dx = bi.x - bj.x;
let dy = bi.y - bj.y;
let dz = bi.z - bj.z;
let d2 = dx * dx + dy * dy + dz * dz;
let mag = dt / (d2 * d2.sqrt());
let massj_mag = bj.mass * mag;
bi.vx -= dx * massj_mag;
bi.vy -= dy * massj_mag;
bi.vz -= dz * massj_mag;
let massi_mag = bi.mass * mag;
bj.vx += dx * massi_mag;
bj.vy += dy * massi_mag;
bj.vz += dz * massi_mag;
}
bi.x += dt * bi.vx;
bi.y += dt * bi.vy;
bi.z += dt * bi.vz;
}
}
}
fn energy(bodies: &[Planet;N_BODIES]) -> f64 {
let mut e = 0.0;
let mut bodies = bodies.iter();
loop {
let bi = match bodies.next() {
Some(bi) => bi,
None => break
};
e += (bi.vx * bi.vx + bi.vy * bi.vy + bi.vz * bi.vz) * bi.mass / 2.0;
for bj in bodies.clone() {
let dx = bi.x - bj.x;
let dy = bi.y - bj.y;
let dz = bi.z - bj.z;
let dist = (dx * dx + dy * dy + dz * dz).sqrt();
e -= bi.mass * bj.mass / dist;
}
}
e
}
fn offset_momentum(bodies: &mut [Planet;N_BODIES]) {
let mut px = 0.0;
let mut py = 0.0;
let mut pz = 0.0;
for bi in bodies.iter() {
px += bi.vx * bi.mass;
py += bi.vy * bi.mass;
pz += bi.vz * bi.mass;
}
let sun = &mut bodies[0];
sun.vx = - px / SOLAR_MASS;
sun.vy = - py / SOLAR_MASS;
sun.vz = - pz / SOLAR_MASS;
}
fn main() {
let n = if std::os::getenv("RUST_BENCH").is_some() {
5000000
} else {
std::os::args().as_slice().get(1)
.and_then(|arg| arg.parse())
.unwrap_or(1000)
};
let mut bodies = BODIES;
offset_momentum(&mut bodies);
println!("{:.9}", energy(&bodies));
advance(&mut bodies, 0.01, n);
println!("{:.9}", energy(&bodies));
}
/// Pop a mutable reference off the head of a slice, mutating the slice to no
/// longer contain the mutable reference. This is a safe operation because the
/// two mutable borrows are entirely disjoint.
fn shift_mut_ref<'a, T>(r: &mut &'a mut [T]) -> Option<&'a mut T> {
use std::mem;
use std::raw::Repr;
if r.len() == 0 |
unsafe {
let mut raw = r.repr();
let ret = raw.data as *mut T;
raw.data = raw.data.offset(1);
raw.len -= 1;
*r = mem::transmute(raw);
Some(unsafe { &mut *ret })
}
}
| { return None } | conditional_block |
weblog.rs | use std::fmt;
// Define a weblog struct
#[derive(Debug)]
pub struct Weblog {
pub ip: String,
pub date: String,
pub req: String,
pub code: i32,
pub size: i32,
pub referer: String,
pub agent: String,
}
impl Weblog {
pub fn new(ip: String, date: String, req: String, code: i32, size: i32, referer: String, agent: String) -> Weblog {
Weblog { ip: ip, date: date, req: req, code: code, size: size, referer: referer, agent: agent }
}
}
impl Eq for Weblog {}
impl PartialEq for Weblog {
fn eq(&self, other: &Self) -> bool {
self.ip == other.ip && self.date == other.date
}
}
impl fmt::Display for Weblog {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result |
}
| {
write!(f, "({}, {}, {}, {}, {}, {}, {})",
self.ip, self.date, self.req, self.code,
self.size, self.referer, self.agent)
} | identifier_body |
weblog.rs | use std::fmt;
// Define a weblog struct
#[derive(Debug)]
pub struct Weblog {
pub ip: String,
pub date: String,
pub req: String,
pub code: i32,
pub size: i32,
pub referer: String,
pub agent: String,
}
impl Weblog {
pub fn | (ip: String, date: String, req: String, code: i32, size: i32, referer: String, agent: String) -> Weblog {
Weblog { ip: ip, date: date, req: req, code: code, size: size, referer: referer, agent: agent }
}
}
impl Eq for Weblog {}
impl PartialEq for Weblog {
fn eq(&self, other: &Self) -> bool {
self.ip == other.ip && self.date == other.date
}
}
impl fmt::Display for Weblog {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "({}, {}, {}, {}, {}, {}, {})",
self.ip, self.date, self.req, self.code,
self.size, self.referer, self.agent)
}
}
| new | identifier_name |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.