user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Camel case various core constructors

Browse source
This commit is contained in:
Brian Anderson 2012-08-27 14:22:25 -07:00
parent 4ba9fdd362
commit 161a82e433
113 changed files with 530 additions and 545 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/libstd/deque.rs
View file

@ -1,7 +1,7 @@
//! A deque. Untested as of yet. Likely buggy
import option::{Some, None};
import dvec::{DVec, dvec};
import dvec::DVec;
trait t<T> {
fn size() -> uint;

60
src/libstd/net_tcp.rs
View file

@ -121,19 +121,19 @@ enum tcp_connect_err_data {
fn connect(-input_ip: ip::ip_addr, port: uint,
iotask: iotask)
-> result::Result<tcp_socket, tcp_connect_err_data> unsafe {
let result_po = core::comm::port::<conn_attempt>();
let closed_signal_po = core::comm::port::<()>();
let result_po = core::comm::Port::<conn_attempt>();
let closed_signal_po = core::comm::Port::<()>();
let conn_data = {
result_ch: core::comm::chan(result_po),
closed_signal_ch: core::comm::chan(closed_signal_po)
result_ch: core::comm::Chan(result_po),
closed_signal_ch: core::comm::Chan(closed_signal_po)
};
let conn_data_ptr = ptr::addr_of(conn_data);
let reader_po = core::comm::port::<result::Result<~[u8], tcp_err_data>>();
let reader_po = core::comm::Port::<result::Result<~[u8], tcp_err_data>>();
let stream_handle_ptr = malloc_uv_tcp_t();
*(stream_handle_ptr as *mut uv::ll::uv_tcp_t) = uv::ll::tcp_t();
let socket_data = @{
reader_po: reader_po,
reader_ch: core::comm::chan(reader_po),
reader_ch: core::comm::Chan(reader_po),
stream_handle_ptr: stream_handle_ptr,
connect_req: uv::ll::connect_t(),
write_req: uv::ll::write_t(),
@ -468,13 +468,13 @@ fn accept(new_conn: tcp_new_connection)
new_tcp_conn(server_handle_ptr) => {
let server_data_ptr = uv::ll::get_data_for_uv_handle(
server_handle_ptr) as *tcp_listen_fc_data;
let reader_po = core::comm::port();
let reader_po = core::comm::Port();
let iotask = (*server_data_ptr).iotask;
let stream_handle_ptr = malloc_uv_tcp_t();
*(stream_handle_ptr as *mut uv::ll::uv_tcp_t) = uv::ll::tcp_t();
let client_socket_data = @{
reader_po: reader_po,
reader_ch: core::comm::chan(reader_po),
reader_ch: core::comm::Chan(reader_po),
stream_handle_ptr : stream_handle_ptr,
connect_req : uv::ll::connect_t(),
write_req : uv::ll::write_t(),
@ -484,8 +484,8 @@ fn accept(new_conn: tcp_new_connection)
let client_stream_handle_ptr =
(*client_socket_data_ptr).stream_handle_ptr;
let result_po = core::comm::port::<Option<tcp_err_data>>();
let result_ch = core::comm::chan(result_po);
let result_po = core::comm::Port::<Option<tcp_err_data>>();
let result_ch = core::comm::Chan(result_po);
// UNSAFE LIBUV INTERACTION BEGIN
// .. normally this happens within the context of
@ -581,14 +581,14 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
on_establish_cb: fn~(comm::Chan<Option<tcp_err_data>>),
-on_connect_cb: fn~(*uv::ll::uv_tcp_t))
-> result::Result<(), tcp_listen_err_data> unsafe {
let stream_closed_po = core::comm::port::<()>();
let kill_po = core::comm::port::<Option<tcp_err_data>>();
let kill_ch = core::comm::chan(kill_po);
let stream_closed_po = core::comm::Port::<()>();
let kill_po = core::comm::Port::<Option<tcp_err_data>>();
let kill_ch = core::comm::Chan(kill_po);
let server_stream = uv::ll::tcp_t();
let server_stream_ptr = ptr::addr_of(server_stream);
let server_data = {
server_stream_ptr: server_stream_ptr,
stream_closed_ch: core::comm::chan(stream_closed_po),
stream_closed_ch: core::comm::Chan(stream_closed_po),
kill_ch: kill_ch,
on_connect_cb: on_connect_cb,
iotask: iotask,
@ -833,8 +833,8 @@ impl tcp_socket_buf: io::Writer {
// INTERNAL API
fn tear_down_socket_data(socket_data: @tcp_socket_data) unsafe {
let closed_po = core::comm::port::<()>();
let closed_ch = core::comm::chan(closed_po);
let closed_po = core::comm::Port::<()>();
let closed_ch = core::comm::Chan(closed_po);
let close_data = {
closed_ch: closed_ch
};
@ -896,8 +896,8 @@ fn read_common_impl(socket_data: *tcp_socket_data, timeout_msecs: uint)
fn read_stop_common_impl(socket_data: *tcp_socket_data) ->
result::Result<(), tcp_err_data> unsafe {
let stream_handle_ptr = (*socket_data).stream_handle_ptr;
let stop_po = core::comm::port::<Option<tcp_err_data>>();
let stop_ch = core::comm::chan(stop_po);
let stop_po = core::comm::Port::<Option<tcp_err_data>>();
let stop_ch = core::comm::Chan(stop_po);
do iotask::interact((*socket_data).iotask) |loop_ptr| unsafe {
log(debug, ~"in interact cb for tcp::read_stop");
match uv::ll::read_stop(stream_handle_ptr as *uv::ll::uv_stream_t) {
@ -923,8 +923,8 @@ fn read_start_common_impl(socket_data: *tcp_socket_data)
-> result::Result<comm::Port<
result::Result<~[u8], tcp_err_data>>, tcp_err_data> unsafe {
let stream_handle_ptr = (*socket_data).stream_handle_ptr;
let start_po = core::comm::port::<Option<uv::ll::uv_err_data>>();
let start_ch = core::comm::chan(start_po);
let start_po = core::comm::Port::<Option<uv::ll::uv_err_data>>();
let start_ch = core::comm::Chan(start_po);
log(debug, ~"in tcp::read_start before interact loop");
do iotask::interact((*socket_data).iotask) |loop_ptr| unsafe {
log(debug, fmt!("in tcp::read_start interact cb %?", loop_ptr));
@ -961,9 +961,9 @@ fn write_common_impl(socket_data_ptr: *tcp_socket_data,
vec::unsafe::to_ptr(raw_write_data),
vec::len(raw_write_data)) ];
let write_buf_vec_ptr = ptr::addr_of(write_buf_vec);
let result_po = core::comm::port::<tcp_write_result>();
let result_po = core::comm::Port::<tcp_write_result>();
let write_data = {
result_ch: core::comm::chan(result_po)
result_ch: core::comm::Chan(result_po)
};
let write_data_ptr = ptr::addr_of(write_data);
do iotask::interact((*socket_data_ptr).iotask) |loop_ptr| unsafe {
@ -1278,11 +1278,11 @@ mod test {
let expected_req = ~"ping";
let expected_resp = ~"pong";
let server_result_po = core::comm::port::<~str>();
let server_result_ch = core::comm::chan(server_result_po);
let server_result_po = core::comm::Port::<~str>();
let server_result_ch = core::comm::Chan(server_result_po);
let cont_po = core::comm::port::<()>();
let cont_ch = core::comm::chan(cont_po);
let cont_po = core::comm::Port::<()>();
let cont_ch = core::comm::Chan(cont_po);
// server
do task::spawn_sched(task::ManualThreads(1u)) {
let actual_req = do comm::listen |server_ch| {
@ -1344,11 +1344,11 @@ mod test {
let expected_req = ~"ping";
let expected_resp = ~"pong";
let server_result_po = core::comm::port::<~str>();
let server_result_ch = core::comm::chan(server_result_po);
let server_result_po = core::comm::Port::<~str>();
let server_result_ch = core::comm::Chan(server_result_po);
let cont_po = core::comm::port::<()>();
let cont_ch = core::comm::chan(cont_po);
let cont_po = core::comm::Port::<()>();
let cont_ch = core::comm::Chan(cont_po);
// server
do task::spawn_sched(task::ManualThreads(1u)) {
let actual_req = do comm::listen |server_ch| {

10
src/libstd/net_url.rs
View file

@ -3,7 +3,7 @@
import map;
import map::{hashmap, str_hash};
import io::{Reader, ReaderUtil};
import dvec::{DVec, dvec};
import dvec::DVec;
export url, userinfo, query;
export from_str, to_str;
@ -217,7 +217,7 @@ fn decode_form_urlencoded(s: ~[u8]) ->
let values = match m.find(key) {
Some(values) => values,
None => {
let values = @dvec();
let values = @DVec();
m.insert(key, values);
values
}
@ -252,7 +252,7 @@ fn decode_form_urlencoded(s: ~[u8]) ->
let values = match m.find(key) {
Some(values) => values,
None => {
let values = @dvec();
let values = @DVec();
m.insert(key, values);
values
}
@ -1010,8 +1010,8 @@ mod tests {
let m = str_hash();
assert encode_form_urlencoded(m) == ~"";
m.insert(~"", @dvec());
m.insert(~"foo", @dvec());
m.insert(~"", @DVec());
m.insert(~"foo", @DVec());
assert encode_form_urlencoded(m) == ~"";
let m = str_hash();

4
src/libstd/smallintmap.rs
View file

@ -4,7 +4,7 @@
*/
import core::option;
import core::option::{Some, None};
import dvec::{DVec, dvec};
import dvec::DVec;
import map::map;
// FIXME (#2347): Should not be @; there's a bug somewhere in rustc that
@ -17,7 +17,7 @@ enum smallintmap<T:copy> {
/// Create a smallintmap
fn mk<T: copy>() -> smallintmap<T> {
let v = dvec();
let v = DVec();
return smallintmap_(@{v: v});
}

2
src/libstd/tempfile.rs
View file

@ -5,7 +5,7 @@ import option::{None, Some};
import rand;
fn mkdtemp(tmpdir: &Path, suffix: &str) -> Option<Path> {
let r = rand::rng();
let r = rand::Rng();
let mut i = 0u;
while (i < 1000u) {
let p = tmpdir.push(r.gen_str(16u) +

20
src/libstd/test.rs
View file

@ -286,8 +286,8 @@ fn run_tests(opts: test_opts, tests: ~[test_desc],
let mut wait_idx = 0u;
let mut done_idx = 0u;
let p = core::comm::port();
let ch = core::comm::chan(p);
let p = core::comm::Port();
let ch = core::comm::Chan(p);
while done_idx < total {
while wait_idx < concurrency && run_idx < total {
@ -420,8 +420,8 @@ mod tests {
ignore: true,
should_fail: false
};
let p = core::comm::port();
let ch = core::comm::chan(p);
let p = core::comm::Port();
let ch = core::comm::Chan(p);
run_test(desc, ch);
let (_, res) = core::comm::recv(p);
assert res != tr_ok;
@ -436,8 +436,8 @@ mod tests {
ignore: true,
should_fail: false
};
let p = core::comm::port();
let ch = core::comm::chan(p);
let p = core::comm::Port();
let ch = core::comm::Chan(p);
run_test(desc, ch);
let (_, res) = core::comm::recv(p);
assert res == tr_ignored;
@ -453,8 +453,8 @@ mod tests {
ignore: false,
should_fail: true
};
let p = core::comm::port();
let ch = core::comm::chan(p);
let p = core::comm::Port();
let ch = core::comm::Chan(p);
run_test(desc, ch);
let (_, res) = core::comm::recv(p);
assert res == tr_ok;
@ -469,8 +469,8 @@ mod tests {
ignore: false,
should_fail: true
};
let p = core::comm::port();
let ch = core::comm::chan(p);
let p = core::comm::Port();
let ch = core::comm::Chan(p);
run_test(desc, ch);
let (_, res) = core::comm::recv(p);
assert res == tr_failed;

24
src/libstd/timer.rs
View file

@ -29,8 +29,8 @@ export delayed_send, sleep, recv_timeout;
fn delayed_send<T: copy send>(iotask: iotask,
msecs: uint, ch: comm::Chan<T>, +val: T) {
unsafe {
let timer_done_po = core::comm::port::<()>();
let timer_done_ch = core::comm::chan(timer_done_po);
let timer_done_po = core::comm::Port::<()>();
let timer_done_ch = core::comm::Chan(timer_done_po);
let timer_done_ch_ptr = ptr::addr_of(timer_done_ch);
let timer = uv::ll::timer_t();
let timer_ptr = ptr::addr_of(timer);
@ -76,8 +76,8 @@ fn delayed_send<T: copy send>(iotask: iotask,
* * msecs - an amount of time, in milliseconds, for the current task to block
*/
fn sleep(iotask: iotask, msecs: uint) {
let exit_po = core::comm::port::<()>();
let exit_ch = core::comm::chan(exit_po);
let exit_po = core::comm::Port::<()>();
let exit_ch = core::comm::Chan(exit_po);
delayed_send(iotask, msecs, exit_ch, ());
core::comm::recv(exit_po);
}
@ -105,8 +105,8 @@ fn sleep(iotask: iotask, msecs: uint) {
fn recv_timeout<T: copy send>(iotask: iotask,
msecs: uint,
wait_po: comm::Port<T>) -> Option<T> {
let timeout_po = comm::port::<()>();
let timeout_ch = comm::chan(timeout_po);
let timeout_po = comm::Port::<()>();
let timeout_ch = comm::Chan(timeout_po);
delayed_send(iotask, msecs, timeout_ch, ());
// FIXME: This could be written clearer (#2618)
either::either(
@ -163,8 +163,8 @@ mod test {
#[test]
fn test_gl_timer_sleep_stress2() {
let po = core::comm::port();
let ch = core::comm::chan(po);
let po = core::comm::Port();
let ch = core::comm::Chan(po);
let hl_loop = uv::global_loop::get();
let repeat = 20u;
@ -182,7 +182,7 @@ mod test {
let (times, maxms) = spec;
do task::spawn {
import rand::*;
let rng = rng();
let rng = Rng();
for iter::repeat(times) {
sleep(hl_loop, rng.next() as uint % maxms);
}
@ -240,9 +240,9 @@ mod test {
let hl_loop = uv::global_loop::get();
for iter::repeat(times as uint) {
let expected = rand::rng().gen_str(16u);
let test_po = core::comm::port::<~str>();
let test_ch = core::comm::chan(test_po);
let expected = rand::Rng().gen_str(16u);
let test_po = core::comm::Port::<~str>();
let test_ch = core::comm::Chan(test_po);
do task::spawn() {
delayed_send(hl_loop, 50u, test_ch, expected);

14
src/libstd/uv_global_loop.rs
View file

@ -8,7 +8,7 @@ import get_gl = get;
import iotask::{iotask, spawn_iotask};
import priv::{chan_from_global_ptr, weaken_task};
import comm = core::comm;
import comm::{Port, Chan, port, chan, select2, listen};
import comm::{Port, Chan, select2, listen};
import task::TaskBuilder;
import either::{Left, Right};
@ -132,8 +132,8 @@ mod test {
}
fn impl_uv_hl_simple_timer(iotask: iotask) unsafe {
let exit_po = core::comm::port::<bool>();
let exit_ch = core::comm::chan(exit_po);
let exit_po = core::comm::Port::<bool>();
let exit_ch = core::comm::Chan(exit_po);
let exit_ch_ptr = ptr::addr_of(exit_ch);
log(debug, fmt!("EXIT_CH_PTR newly created exit_ch_ptr: %?",
exit_ch_ptr));
@ -165,8 +165,8 @@ mod test {
#[test]
fn test_gl_uv_global_loop_high_level_global_timer() unsafe {
let hl_loop = get_gl();
let exit_po = comm::port::<()>();
let exit_ch = comm::chan(exit_po);
let exit_po = comm::Port::<()>();
let exit_ch = comm::Chan(exit_po);
task::spawn_sched(task::ManualThreads(1u), || {
impl_uv_hl_simple_timer(hl_loop);
core::comm::send(exit_ch, ());
@ -181,8 +181,8 @@ mod test {
#[ignore]
fn test_stress_gl_uv_global_loop_high_level_global_timer() unsafe {
let hl_loop = get_gl();
let exit_po = core::comm::port::<()>();
let exit_ch = core::comm::chan(exit_po);
let exit_po = core::comm::Port::<()>();
let exit_ch = core::comm::Chan(exit_po);
let cycles = 5000u;
for iter::repeat(cycles) {
task::spawn_sched(task::ManualThreads(1u), || {

20
src/libstd/uv_iotask.rs
View file

@ -13,7 +13,7 @@ export exit;
import libc::c_void;
import ptr::addr_of;
import comm = core::comm;
import comm::{Port, port, Chan, chan, listen};
import comm::{Port, Chan, listen};
import task::TaskBuilder;
import ll = uv_ll;
@ -102,7 +102,7 @@ fn run_loop(iotask_ch: Chan<iotask>) unsafe {
// initialize our loop data and store it in the loop
let data: iotask_loop_data = {
async_handle: async_handle,
msg_po: port()
msg_po: Port()
};
ll::set_data_for_uv_handle(async_handle, addr_of(data));
@ -186,8 +186,8 @@ mod test {
fn impl_uv_iotask_async(iotask: iotask) unsafe {
let async_handle = ll::async_t();
let ah_ptr = ptr::addr_of(async_handle);
let exit_po = core::comm::port::<()>();
let exit_ch = core::comm::chan(exit_po);
let exit_po = core::comm::Port::<()>();
let exit_ch = core::comm::Chan(exit_po);
let ah_data = {
iotask: iotask,
exit_ch: exit_ch
@ -204,8 +204,8 @@ mod test {
// this fn documents the bear minimum neccesary to roll your own
// high_level_loop
unsafe fn spawn_test_loop(exit_ch: comm::Chan<()>) -> iotask {
let iotask_port = comm::port::<iotask>();
let iotask_ch = comm::chan(iotask_port);
let iotask_port = comm::Port::<iotask>();
let iotask_ch = comm::Chan(iotask_port);
do task::spawn_sched(task::ManualThreads(1u)) {
run_loop(iotask_ch);
exit_ch.send(());
@ -225,8 +225,8 @@ mod test {
#[test]
fn test_uv_iotask_async() unsafe {
let exit_po = core::comm::port::<()>();
let exit_ch = core::comm::chan(exit_po);
let exit_po = core::comm::Port::<()>();
let exit_ch = core::comm::Chan(exit_po);
let iotask = spawn_test_loop(exit_ch);
// using this handle to manage the lifetime of the high_level_loop,
@ -235,8 +235,8 @@ mod test {
// under race-condition type situations.. this ensures that the loop
// lives until, at least, all of the impl_uv_hl_async() runs have been
// called, at least.
let work_exit_po = core::comm::port::<()>();
let work_exit_ch = core::comm::chan(work_exit_po);
let work_exit_po = core::comm::Port::<()>();
let work_exit_ch = core::comm::Chan(work_exit_po);
for iter::repeat(7u) {
do task::spawn_sched(task::ManualThreads(1u)) {
impl_uv_iotask_async(iotask);

12
src/libstd/uv_ll.rs
View file

@ -1461,13 +1461,13 @@ mod test {
let port = 8887;
let kill_server_msg = ~"does a dog have buddha nature?";
let server_resp_msg = ~"mu!";
let client_port = core::comm::port::<~str>();
let client_chan = core::comm::chan::<~str>(client_port);
let server_port = core::comm::port::<~str>();
let server_chan = core::comm::chan::<~str>(server_port);
let client_port = core::comm::Port::<~str>();
let client_chan = core::comm::Chan::<~str>(client_port);
let server_port = core::comm::Port::<~str>();
let server_chan = core::comm::Chan::<~str>(server_port);
let continue_port = core::comm::port::<bool>();
let continue_chan = core::comm::chan::<bool>(continue_port);
let continue_port = core::comm::Port::<bool>();
let continue_chan = core::comm::Chan::<bool>(continue_port);
let continue_chan_ptr = ptr::addr_of(continue_chan);
do task::spawn_sched(task::ManualThreads(1u)) {