rust/src/libstd/util.rs, branch try

Move replace and swap to std::mem. Get rid of std::util

2014-02-10T21:21:35+00:00

Also move Void to std::any, move drop to std::mem and reexport in prelude.

std: Clean up the swap function a little

2014-02-10T00:23:39+00:00

std: Stop parameterizing some memcpy functions over RawPtr

2014-02-10T00:23:10+00:00

It unsafe assumptions that any impl of RawPtr is for actual pointers, that they can be copied by memcpy. Removing it is easy, so I don't think it's solving a real problem.

std: Add init and uninit to mem. Replace direct intrinsic usage

2014-02-09T08:17:40+00:00

Implement clone() for TCP/UDP/Unix sockets

2014-02-05T19:43:49+00:00

This is part of the overall strategy I would like to take when approaching issue #11165. The only two I/O objects that reasonably want to be "split" are the network stream objects. Everything else can be "split" by just creating another version. The initial idea I had was the literally split the object into a reader and a writer half, but that would just introduce lots of clutter with extra interfaces that were a little unnnecssary, or it would return a ~Reader and a ~Writer which means you couldn't access things like the remote peer name or local socket name. The solution I found to be nicer was to just clone the stream itself. The clone is just a clone of the handle, nothing fancy going on at the kernel level. Conceptually I found this very easy to wrap my head around (everything else supports clone()), and it solved the "split" problem at the same time. The cloning support is pretty specific per platform/lib combination: * native/win32 - uses some specific WSA apis to clone the SOCKET handle * native/unix - uses dup() to get another file descriptor * green/all - This is where things get interesting. When we support full clones of a handle, this implies that we're allowing simultaneous writes and reads to happen. It turns out that libuv doesn't support two simultaneous reads or writes of the same object. It does support *one* read and *one* write at the same time, however. Some extra infrastructure was added to just block concurrent writers/readers until the previous read/write operation was completed. I've added tests to the tcp/unix modules to make sure that this functionality is supported everywhere.

Replace NonCopyable usage with NoPod

2014-02-03T23:15:27+00:00

cc #10834

stdtest: Fix all leaked trait imports

2014-01-08T07:51:38+00:00

Remove std::either

2014-01-03T18:25:23+00:00

std: uniform modules titles for doc

2013-12-27T08:49:11+00:00

This commit uniforms the short title of modules provided by libstd, in order to make their roles more explicit when glancing at the index. Signed-off-by: Luca Bruno

Move std::util::ignore to std::prelude::drop

2013-12-04T04:40:38+00:00

It's a more fitting name for the most common use case of this function.