Fix parameter count for docs in container.string

Implement DList.insertBack
Rename Vector to Array
2017-05-19 20:01:04 +02:00 · 2017-05-16 13:16:18 +02:00 · 2017-05-16 12:12:57 +02:00 · 2017-05-15 20:09:32 +02:00 · 2017-05-15 19:57:36 +02:00 · 2017-05-15 19:50:20 +02:00
23 changed files with 6741 additions and 3711 deletions
--- a/.editorconfig
+++ b/.editorconfig
@ -0,0 +1,9 @@
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+charset = utf-8
+indent_style = space
+indent_size = 4
+trim_trailing_whitespace = true
--- a/.travis.yml
+++ b/.travis.yml
@ -17,4 +17,7 @@ env:
  - ARCH=x86_64

 script:
- - dub test --arch=$ARCH
+ - dub test -b unittest-cov --arch=$ARCH
+
+after_success:
+ - bash <(curl -s https://codecov.io/bash)
--- a/README.md
+++ b/README.md
@ -1,6 +1,8 @@
 # Tanya

-[![Build Status](https://travis-ci.org/caraus-ecms/tanya.svg?branch=master)](https://travis-ci.org/caraus-ecms/tanya)
+[![Build status](https://travis-ci.org/caraus-ecms/tanya.svg?branch=master)](https://travis-ci.org/caraus-ecms/tanya)
+[![Build status](https://ci.appveyor.com/api/projects/status/djkmverdfsylc7ti/branch/master?svg=true)](https://ci.appveyor.com/project/belka-ew/tanya/branch/master)
+[![codecov](https://codecov.io/gh/caraus-ecms/tanya/branch/master/graph/badge.svg)](https://codecov.io/gh/caraus-ecms/tanya)
 [![Dub version](https://img.shields.io/dub/v/tanya.svg)](https://code.dlang.org/packages/tanya)
 [![Dub downloads](https://img.shields.io/dub/dt/tanya.svg)](https://code.dlang.org/packages/tanya)
 [![License](https://img.shields.io/badge/license-MPL_2.0-blue.svg)](https://raw.githubusercontent.com/caraus-ecms/tanya/master/LICENSE)
@ -21,11 +23,12 @@ data structures and utilities that depend on the Garbage Collector in Phobos.
 Tanya consists of the following packages:

 * `async`: Event loop (epoll, kqueue and IOCP).
-* `container`: Queue, Vector, Singly linked list, buffers.
+* `container`: Queue, Array, Singly and doubly linked lists, Buffers, UTF-8
+string.
 * `math`: Arbitrary precision integer and a set of functions.
 * `memory`: Tools for manual memory management (allocator, reference counting,
 helper functions).
-* `network`: URL-Parsing, sockets.
+* `network`: URL-Parsing, sockets, utilities.

 ### Supported compilers

@ -38,20 +41,14 @@ helper functions).

 ### Current status

-The library is currently under development, but the API is becoming gradually
-stable.
+Following modules are under development:

-Following modules are coming soon:
-
-| Feature      | Build status                                                                                                            |
-|--------------|:-----------------------------------------------------------------------------------------------------------------------:|
-| UTF-8 string | [![utf8string](https://travis-ci.org/caraus-ecms/tanya.svg?branch=utf8string)](https://travis-ci.org/caraus-ecms/tanya) |
-| BitVector    | [![bitvector](https://travis-ci.org/caraus-ecms/tanya.svg?branch=bitvector)](https://travis-ci.org/caraus-ecms/tanya)   |
-| Hash table   | N/A                                                                                                                     |
-
-`math` package contains an arbitrary precision integer implementation that
-needs more test cases, better performance and some additional features
-(constructing from a string and an ubyte array, and converting it back).
+| Feature      | Branch       | Build status                                                                                                                                                                                                                                                                                                 |
+|--------------|:------------:|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| BitVector    | bitvector    | [![bitvector](https://travis-ci.org/caraus-ecms/tanya.svg?branch=bitvector)](https://travis-ci.org/caraus-ecms/tanya) [![bitvector](https://ci.appveyor.com/api/projects/status/djkmverdfsylc7ti/branch/bitvector?svg=true)](https://ci.appveyor.com/project/belka-ew/tanya/branch/bitvector)                |
+| TLS          | crypto       | [![crypto](https://travis-ci.org/caraus-ecms/tanya.svg?branch=crypto)](https://travis-ci.org/caraus-ecms/tanya) [![crypto](https://ci.appveyor.com/api/projects/status/djkmverdfsylc7ti/branch/crypto?svg=true)](https://ci.appveyor.com/project/belka-ew/tanya/branch/crypto)                               |
+| File IO      | io           | [![io](https://travis-ci.org/caraus-ecms/tanya.svg?branch=io)](https://travis-ci.org/caraus-ecms/tanya) [![io](https://ci.appveyor.com/api/projects/status/djkmverdfsylc7ti/branch/io?svg=true)](https://ci.appveyor.com/project/belka-ew/tanya/branch/io)                                                   |
+| Hash table   | horton-table | [![horton-table](https://travis-ci.org/caraus-ecms/tanya.svg?branch=horton-table)](https://travis-ci.org/caraus-ecms/tanya) [![horton-table](https://ci.appveyor.com/api/projects/status/djkmverdfsylc7ti/branch/horton-table?svg=true)](https://ci.appveyor.com/project/belka-ew/tanya/branch/horton-table) |

 ### Further characteristics

@ -62,10 +59,14 @@ is being tested on Windows and FreeBSD as well.

 * The library isn't thread-safe. Thread-safity should be added later.

+## Release management
+
+3-week release cycle.
+
 ## Contributing

 Since I'm mostly busy writing new code and implementing new features I would
 appreciate, if anyone uses the library. It would help me to improve the
 codebase and fix issues.

-Feel free to contact me if you have any questions.
+Feel free to contact me if you have any questions: info@caraus.de.
--- a/appveyor.yml
+++ b/appveyor.yml
@ -0,0 +1,52 @@
+platform: x64
+os: Visual Studio 2017
+
+environment:
+ matrix:
+  - DC: dmd
+    DVersion: 2.074.0
+    arch: x86
+  - DC: dmd
+    DVersion: 2.073.2
+    arch: x86
+  - DC: dmd
+    DVersion: 2.072.2
+    arch: x86
+  - DC: dmd
+    DVersion: 2.071.2
+    arch: x86
+
+skip_tags: true
+
+install:
+  - ps: function SetUpDCompiler
+        {
+            $env:toolchain = "msvc";
+            $version = $env:DVersion;
+            Invoke-WebRequest "http://downloads.dlang.org/releases/2.x/$($version)/dmd.$($version).windows.7z" -OutFile "c:\dmd.7z";
+            echo "finished.";
+            pushd c:\\;
+            7z x dmd.7z > $null;
+            popd;
+        }
+  - ps: SetUpDCompiler
+
+  - ps: if($env:DVersion -eq "2.071.2"){
+            Invoke-WebRequest "http://code.dlang.org/files/dub-1.2.1-windows-x86.zip" -OutFile "dub.zip";
+            7z x dub.zip -odub > $null;
+            Move-Item "dub/dub.exe" "C:\dmd2\windows\bin"
+          }
+
+before_build:
+  - ps: $env:PATH += ";C:\dmd2\windows\bin;";
+  - call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\Common7\Tools\VsDevCmd.bat" -arch=%arch%
+
+build_script:
+ - echo dummy build script - dont remove me
+
+test_script:
+ - echo %DC%
+ - echo %PATH%
+ - 'dub --version'
+ - '%DC% --version'
+ - dub test --arch=x86 --compiler=%DC%
--- a/source/tanya/async/event/epoll.d
+++ b/source/tanya/async/event/epoll.d
@ -18,7 +18,7 @@ import tanya.async.event.selector;
 import tanya.async.loop;
 import tanya.async.transport;
 import tanya.async.watcher;
-import tanya.container.vector;
+import tanya.container.array;
 import tanya.memory;
 import tanya.memory.mmappool;
 import tanya.network.socket;
@ -29,153 +29,153 @@ import std.algorithm.comparison;

 extern (C) nothrow @nogc
 {
-	int epoll_create1(int flags);
-	int epoll_ctl (int epfd, int op, int fd, epoll_event *event);
-	int epoll_wait (int epfd, epoll_event *events, int maxevents, int timeout);
+    int epoll_create1(int flags);
+    int epoll_ctl (int epfd, int op, int fd, epoll_event *event);
+    int epoll_wait (int epfd, epoll_event *events, int maxevents, int timeout);
 }

 final class EpollLoop : SelectorLoop
 {
-	protected int fd;
-	private Vector!epoll_event events;
+    protected int fd;
+    private Array!epoll_event events;

-	/**
-	 * Initializes the loop.
-	 */
-	this() @nogc
-	{
-		if ((fd = epoll_create1(EPOLL_CLOEXEC)) < 0)
-		{
-			throw defaultAllocator.make!BadLoopException("epoll initialization failed");
-		}
-		super();
-		events = Vector!epoll_event(maxEvents, MmapPool.instance);
-	}
+    /**
+     * Initializes the loop.
+     */
+    this() @nogc
+    {
+        if ((fd = epoll_create1(EPOLL_CLOEXEC)) < 0)
+        {
+            throw defaultAllocator.make!BadLoopException("epoll initialization failed");
+        }
+        super();
+        events = Array!epoll_event(maxEvents, MmapPool.instance);
+    }

-	/**
-	 * Frees loop internals.
-	 */
-	~this() @nogc
-	{
-		close(fd);
-	}
+    /**
+     * Frees loop internals.
+     */
+    ~this() @nogc
+    {
+        close(fd);
+    }

-	/**
-	 * Should be called if the backend configuration changes.
-	 *
-	 * Params:
-	 * 	watcher   = Watcher.
-	 * 	oldEvents = The events were already set.
-	 * 	events    = The events should be set.
-	 *
-	 * Returns: $(D_KEYWORD true) if the operation was successful.
-	 */
-	protected override bool reify(SocketWatcher watcher,
-	                              EventMask oldEvents,
-	                              EventMask events) @nogc
-	{
-		int op = EPOLL_CTL_DEL;
-		epoll_event ev;
+    /**
+     * Should be called if the backend configuration changes.
+     *
+     * Params:
+     *  watcher   = Watcher.
+     *  oldEvents = The events were already set.
+     *  events    = The events should be set.
+     *
+     * Returns: $(D_KEYWORD true) if the operation was successful.
+     */
+    protected override bool reify(SocketWatcher watcher,
+                                  EventMask oldEvents,
+                                  EventMask events) @nogc
+    {
+        int op = EPOLL_CTL_DEL;
+        epoll_event ev;

-		if (events == oldEvents)
-		{
-			return true;
-		}
-		if (events && oldEvents)
-		{
-			op = EPOLL_CTL_MOD;
-		}
-		else if (events && !oldEvents)
-		{
-			op = EPOLL_CTL_ADD;
-		}
+        if (events == oldEvents)
+        {
+            return true;
+        }
+        if (events && oldEvents)
+        {
+            op = EPOLL_CTL_MOD;
+        }
+        else if (events && !oldEvents)
+        {
+            op = EPOLL_CTL_ADD;
+        }

-		ev.data.fd = watcher.socket.handle;
-		ev.events = (events & (Event.read | Event.accept) ? EPOLLIN | EPOLLPRI : 0)
-		          | (events & Event.write ? EPOLLOUT : 0)
-		          | EPOLLET;
+        ev.data.fd = watcher.socket.handle;
+        ev.events = (events & (Event.read | Event.accept) ? EPOLLIN | EPOLLPRI : 0)
+                  | (events & Event.write ? EPOLLOUT : 0)
+                  | EPOLLET;

-		return epoll_ctl(fd, op, watcher.socket.handle, &ev) == 0;
-	}
+        return epoll_ctl(fd, op, watcher.socket.handle, &ev) == 0;
+    }

-	/**
-	 * Does the actual polling.
-	 */
-	protected override void poll() @nogc
-	{
-		// Don't block
-		immutable timeout = cast(immutable int) blockTime.total!"msecs";
-		auto eventCount = epoll_wait(fd, events.get().ptr, maxEvents, timeout);
+    /**
+     * Does the actual polling.
+     */
+    protected override void poll() @nogc
+    {
+        // Don't block
+        immutable timeout = cast(immutable int) blockTime.total!"msecs";
+        auto eventCount = epoll_wait(fd, events.get().ptr, maxEvents, timeout);

-		if (eventCount < 0)
-		{
-			if (errno != EINTR)
-			{
-				throw defaultAllocator.make!BadLoopException();
-			}
-			return;
-		}
+        if (eventCount < 0)
+        {
+            if (errno != EINTR)
+            {
+                throw defaultAllocator.make!BadLoopException();
+            }
+            return;
+        }

-		for (auto i = 0; i < eventCount; ++i)
-		{
-			auto transport = cast(StreamTransport) connections[events[i].data.fd];
+        for (auto i = 0; i < eventCount; ++i)
+        {
+            auto transport = cast(StreamTransport) connections[events[i].data.fd];

-			if (transport is null)
-			{
-				auto connection = cast(ConnectionWatcher) connections[events[i].data.fd];
-				assert(connection !is null);
+            if (transport is null)
+            {
+                auto connection = cast(ConnectionWatcher) connections[events[i].data.fd];
+                assert(connection !is null);

-				acceptConnections(connection);
-			}
-			else if (events[i].events & EPOLLERR)
-			{
-				kill(transport);
-				continue;
-			}
-			else if (events[i].events & (EPOLLIN | EPOLLPRI | EPOLLHUP))
-			{
-				SocketException exception;
-				try
-				{
-					ptrdiff_t received;
-					do
-					{
-						received = transport.socket.receive(transport.output[]);
-						transport.output += received;
-					}
-					while (received);
-				}
-				catch (SocketException e)
-				{
-					exception = e;
-				}
-				if (transport.socket.disconnected)
-				{
-					kill(transport, exception);
-					continue;
-				}
-				else if (transport.output.length)
-				{
-					pendings.enqueue(transport);
-				}
-			}
-			if (events[i].events & EPOLLOUT)
-			{
-				transport.writeReady = true;
-				if (transport.input.length)
-				{
-					feed(transport);
-				}
-			}
-		}
-	}
+                acceptConnections(connection);
+            }
+            else if (events[i].events & EPOLLERR)
+            {
+                kill(transport);
+                continue;
+            }
+            else if (events[i].events & (EPOLLIN | EPOLLPRI | EPOLLHUP))
+            {
+                SocketException exception;
+                try
+                {
+                    ptrdiff_t received;
+                    do
+                    {
+                        received = transport.socket.receive(transport.output[]);
+                        transport.output += received;
+                    }
+                    while (received);
+                }
+                catch (SocketException e)
+                {
+                    exception = e;
+                }
+                if (transport.socket.disconnected)
+                {
+                    kill(transport, exception);
+                    continue;
+                }
+                else if (transport.output.length)
+                {
+                    pendings.enqueue(transport);
+                }
+            }
+            if (events[i].events & EPOLLOUT)
+            {
+                transport.writeReady = true;
+                if (transport.input.length)
+                {
+                    feed(transport);
+                }
+            }
+        }
+    }

-	/**
-	 * Returns: The blocking time.
-	 */
-	override protected @property inout(Duration) blockTime()
-	inout @safe pure nothrow
-	{
-		return min(super.blockTime, 1.dur!"seconds");
-	}
+    /**
+     * Returns: The blocking time.
+     */
+    override protected @property inout(Duration) blockTime()
+    inout @safe pure nothrow
+    {
+        return min(super.blockTime, 1.dur!"seconds");
+    }
 }
--- a/source/tanya/async/event/iocp.d
+++ b/source/tanya/async/event/iocp.d
@ -31,354 +31,354 @@ import core.sys.windows.winsock2;
 */
 final class StreamTransport : SocketWatcher, DuplexTransport, SocketTransport
 {
-	private SocketException exception;
+    private SocketException exception;

-	private ReadBuffer!ubyte output;
+    private ReadBuffer!ubyte output;

-	private WriteBuffer!ubyte input;
+    private WriteBuffer!ubyte input;

-	private Protocol protocol_;
+    private Protocol protocol_;

-	private bool closing;
+    private bool closing;

-	/**
-	 * Creates new completion port transport.
-	 *
-	 * Params:
-	 * 	socket = Socket.
-	 *
-	 * Precondition: $(D_INLINECODE socket !is null)
-	 */
-	this(OverlappedConnectedSocket socket) @nogc
-	{
-		super(socket);
-		output = ReadBuffer!ubyte(8192, 1024, MmapPool.instance);
-		input = WriteBuffer!ubyte(8192, MmapPool.instance);
-		active = true;
-	}
+    /**
+     * Creates new completion port transport.
+     *
+     * Params:
+     *  socket = Socket.
+     *
+     * Precondition: $(D_INLINECODE socket !is null)
+     */
+    this(OverlappedConnectedSocket socket) @nogc
+    {
+        super(socket);
+        output = ReadBuffer!ubyte(8192, 1024, MmapPool.instance);
+        input = WriteBuffer!ubyte(8192, MmapPool.instance);
+        active = true;
+    }

-	/**
-	 * Returns: Socket.
-	 *
-	 * Postcondition: $(D_INLINECODE socket !is null)
-	 */
-	override @property OverlappedConnectedSocket socket() pure nothrow @safe @nogc
-	out (socket)
-	{
-		assert(socket !is null);
-	}
-	body
-	{
-		return cast(OverlappedConnectedSocket) socket_;
-	}
+    /**
+     * Returns: Socket.
+     *
+     * Postcondition: $(D_INLINECODE socket !is null)
+     */
+    override @property OverlappedConnectedSocket socket() pure nothrow @safe @nogc
+    out (socket)
+    {
+        assert(socket !is null);
+    }
+    body
+    {
+        return cast(OverlappedConnectedSocket) socket_;
+    }

-	/**
-	 * Returns $(D_PARAM true) if the transport is closing or closed.
-	 */
-	bool isClosing() const pure nothrow @safe @nogc
-	{
-		return closing;
-	}
+    /**
+     * Returns $(D_PARAM true) if the transport is closing or closed.
+     */
+    bool isClosing() const pure nothrow @safe @nogc
+    {
+        return closing;
+    }

-	/**
-	 * Close the transport.
-	 *
-	 * Buffered data will be flushed.  No more data will be received.
-	 */
-	void close() pure nothrow @safe @nogc
-	{
-		closing = true;
-	}
+    /**
+     * Close the transport.
+     *
+     * Buffered data will be flushed.  No more data will be received.
+     */
+    void close() pure nothrow @safe @nogc
+    {
+        closing = true;
+    }

-	/**
-	 * Write some data to the transport.
-	 *
-	 * Params:
-	 * 	data = Data to send.
-	 */
-	void write(ubyte[] data) @nogc
-	{
-		input ~= data;
-	}
+    /**
+     * Write some data to the transport.
+     *
+     * Params:
+     *  data = Data to send.
+     */
+    void write(ubyte[] data) @nogc
+    {
+        input ~= data;
+    }

-	/**
-	 * Returns: Application protocol.
-	 */
-	@property Protocol protocol() pure nothrow @safe @nogc
-	{
-		return protocol_;
-	}
+    /**
+     * Returns: Application protocol.
+     */
+    @property Protocol protocol() pure nothrow @safe @nogc
+    {
+        return protocol_;
+    }

-	/**
-	 * Switches the protocol.
-	 *
-	 * The protocol is deallocated by the event loop, it should currently be
-	 * allocated with $(D_PSYMBOL MmapPool).
-	 *
-	 * Params:
-	 * 	protocol = Application protocol.
-	 *
-	 * Precondition: $(D_INLINECODE protocol !is null)
-	 */
-	@property void protocol(Protocol protocol) pure nothrow @safe @nogc
-	in
-	{
-		assert(protocol !is null);
-	}
-	body
-	{
-		protocol_ = protocol;
-	}
+    /**
+     * Switches the protocol.
+     *
+     * The protocol is deallocated by the event loop, it should currently be
+     * allocated with $(D_PSYMBOL MmapPool).
+     *
+     * Params:
+     *  protocol = Application protocol.
+     *
+     * Precondition: $(D_INLINECODE protocol !is null)
+     */
+    @property void protocol(Protocol protocol) pure nothrow @safe @nogc
+    in
+    {
+        assert(protocol !is null);
+    }
+    body
+    {
+        protocol_ = protocol;
+    }

-	/**
-	 * Invokes the watcher callback.
-	 */
-	override void invoke() @nogc
-	{
-		if (output.length)
-		{
-			immutable empty = input.length == 0;
-			protocol.received(output[0 .. $]);
-			output.clear();
-			if (empty)
-			{
-				SocketState overlapped;
-				try
-				{
-					overlapped = MmapPool.instance.make!SocketState;
-					socket.beginSend(input[], overlapped);
-				}
-				catch (SocketException e)
-				{
-					MmapPool.instance.dispose(overlapped);
-					MmapPool.instance.dispose(e);
-				}
-			}
-		}
-		else
-		{
-			protocol.disconnected(exception);
-			MmapPool.instance.dispose(protocol_);
-			defaultAllocator.dispose(exception);
-			active = false;
-		}
-	}
+    /**
+     * Invokes the watcher callback.
+     */
+    override void invoke() @nogc
+    {
+        if (output.length)
+        {
+            immutable empty = input.length == 0;
+            protocol.received(output[0 .. $]);
+            output.clear();
+            if (empty)
+            {
+                SocketState overlapped;
+                try
+                {
+                    overlapped = MmapPool.instance.make!SocketState;
+                    socket.beginSend(input[], overlapped);
+                }
+                catch (SocketException e)
+                {
+                    MmapPool.instance.dispose(overlapped);
+                    MmapPool.instance.dispose(e);
+                }
+            }
+        }
+        else
+        {
+            protocol.disconnected(exception);
+            MmapPool.instance.dispose(protocol_);
+            defaultAllocator.dispose(exception);
+            active = false;
+        }
+    }
 }

 final class IOCPLoop : Loop
 {
-	protected HANDLE completionPort;
+    protected HANDLE completionPort;

-	protected OVERLAPPED overlap;
+    protected OVERLAPPED overlap;

-	/**
-	 * Initializes the loop.
-	 */
-	this() @nogc
-	{
-		super();
+    /**
+     * Initializes the loop.
+     */
+    this() @nogc
+    {
+        super();

-		completionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
-		if (!completionPort)
-		{
-			throw make!BadLoopException(defaultAllocator,
-			                            "Creating completion port failed");
-		}
-	}
+        completionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
+        if (!completionPort)
+        {
+            throw make!BadLoopException(defaultAllocator,
+                                        "Creating completion port failed");
+        }
+    }

-	/**
-	 * Should be called if the backend configuration changes.
-	 *
-	 * Params:
-	 * 	watcher   = Watcher.
-	 * 	oldEvents = The events were already set.
-	 * 	events    = The events should be set.
-	 *
-	 * Returns: $(D_KEYWORD true) if the operation was successful.
-	 */
-	override protected bool reify(SocketWatcher watcher,
-								  EventMask oldEvents,
-								  EventMask events) @nogc
-	{
-		SocketState overlapped;
-		if (!(oldEvents & Event.accept) && (events & Event.accept))
-		{
-			auto socket = cast(OverlappedStreamSocket) watcher.socket;
-			assert(socket !is null);
+    /**
+     * Should be called if the backend configuration changes.
+     *
+     * Params:
+     *  watcher   = Watcher.
+     *  oldEvents = The events were already set.
+     *  events    = The events should be set.
+     *
+     * Returns: $(D_KEYWORD true) if the operation was successful.
+     */
+    override protected bool reify(SocketWatcher watcher,
+                                  EventMask oldEvents,
+                                  EventMask events) @nogc
+    {
+        SocketState overlapped;
+        if (!(oldEvents & Event.accept) && (events & Event.accept))
+        {
+            auto socket = cast(OverlappedStreamSocket) watcher.socket;
+            assert(socket !is null);

-			if (CreateIoCompletionPort(cast(HANDLE) socket.handle,
-									   completionPort,
-									   cast(ULONG_PTR) (cast(void*) watcher),
-									   0) !is completionPort)
-			{
-				return false;
-			}
+            if (CreateIoCompletionPort(cast(HANDLE) socket.handle,
+                                       completionPort,
+                                       cast(ULONG_PTR) (cast(void*) watcher),
+                                       0) !is completionPort)
+            {
+                return false;
+            }

-			try
-			{
-				overlapped = MmapPool.instance.make!SocketState;
-				socket.beginAccept(overlapped);
-			}
-			catch (SocketException e)
-			{
-				MmapPool.instance.dispose(overlapped);
-				defaultAllocator.dispose(e);
-				return false;
-			}
-		}
-		if (!(oldEvents & Event.read) && (events & Event.read)
-			|| !(oldEvents & Event.write) && (events & Event.write))
-		{
-			auto transport = cast(StreamTransport) watcher;
-			assert(transport !is null);
+            try
+            {
+                overlapped = MmapPool.instance.make!SocketState;
+                socket.beginAccept(overlapped);
+            }
+            catch (SocketException e)
+            {
+                MmapPool.instance.dispose(overlapped);
+                defaultAllocator.dispose(e);
+                return false;
+            }
+        }
+        if (!(oldEvents & Event.read) && (events & Event.read)
+            || !(oldEvents & Event.write) && (events & Event.write))
+        {
+            auto transport = cast(StreamTransport) watcher;
+            assert(transport !is null);

-			if (CreateIoCompletionPort(cast(HANDLE) transport.socket.handle,
-									   completionPort,
-									   cast(ULONG_PTR) (cast(void*) watcher),
-									   0) !is completionPort)
-			{
-				return false;
-			}
+            if (CreateIoCompletionPort(cast(HANDLE) transport.socket.handle,
+                                       completionPort,
+                                       cast(ULONG_PTR) (cast(void*) watcher),
+                                       0) !is completionPort)
+            {
+                return false;
+            }

-			// Begin to read
-			if (!(oldEvents & Event.read) && (events & Event.read))
-			{
-				try
-				{
-					overlapped = MmapPool.instance.make!SocketState;
-					transport.socket.beginReceive(transport.output[], overlapped);
-				}
-				catch (SocketException e)
-				{
-					MmapPool.instance.dispose(overlapped);
-					defaultAllocator.dispose(e);
-					return false;
-				}
-			}
-		}
-		return true;
-	}
+            // Begin to read
+            if (!(oldEvents & Event.read) && (events & Event.read))
+            {
+                try
+                {
+                    overlapped = MmapPool.instance.make!SocketState;
+                    transport.socket.beginReceive(transport.output[], overlapped);
+                }
+                catch (SocketException e)
+                {
+                    MmapPool.instance.dispose(overlapped);
+                    defaultAllocator.dispose(e);
+                    return false;
+                }
+            }
+        }
+        return true;
+    }

-	private void kill(StreamTransport transport,
-	                  SocketException exception = null) @nogc
-	in
-	{
-		assert(transport !is null);
-	}
-	body
-	{
-		transport.socket.shutdown();
-		defaultAllocator.dispose(transport.socket);
-		transport.exception = exception;
-		pendings.enqueue(transport);
-	}
+    private void kill(StreamTransport transport,
+                      SocketException exception = null) @nogc
+    in
+    {
+        assert(transport !is null);
+    }
+    body
+    {
+        transport.socket.shutdown();
+        defaultAllocator.dispose(transport.socket);
+        transport.exception = exception;
+        pendings.enqueue(transport);
+    }

-	/**
-	 * Does the actual polling.
-	 */
-	override protected void poll() @nogc
-	{
-		DWORD lpNumberOfBytes;
-		ULONG_PTR key;
-		LPOVERLAPPED overlap;
-		immutable timeout = cast(immutable int) blockTime.total!"msecs";
+    /**
+     * Does the actual polling.
+     */
+    override protected void poll() @nogc
+    {
+        DWORD lpNumberOfBytes;
+        ULONG_PTR key;
+        LPOVERLAPPED overlap;
+        immutable timeout = cast(immutable int) blockTime.total!"msecs";

-		auto result = GetQueuedCompletionStatus(completionPort,
-												&lpNumberOfBytes,
-												&key,
-												&overlap,
-												timeout);
-		if (result == FALSE && overlap == NULL)
-		{
-			return; // Timeout
-		}
+        auto result = GetQueuedCompletionStatus(completionPort,
+                                                &lpNumberOfBytes,
+                                                &key,
+                                                &overlap,
+                                                timeout);
+        if (result == FALSE && overlap == NULL)
+        {
+            return; // Timeout
+        }

-		auto overlapped = (cast(SocketState) ((cast(void*) overlap) - 8));
-		assert(overlapped !is null);
-		scope (failure)
-		{
-			MmapPool.instance.dispose(overlapped);
-		}
+        auto overlapped = (cast(SocketState) ((cast(void*) overlap) - 8));
+        assert(overlapped !is null);
+        scope (failure)
+        {
+            MmapPool.instance.dispose(overlapped);
+        }

-		switch (overlapped.event)
-		{
-			case OverlappedSocketEvent.accept:
-				auto connection = cast(ConnectionWatcher) (cast(void*) key);
-				assert(connection !is null);
+        switch (overlapped.event)
+        {
+            case OverlappedSocketEvent.accept:
+                auto connection = cast(ConnectionWatcher) (cast(void*) key);
+                assert(connection !is null);

-				auto listener = cast(OverlappedStreamSocket) connection.socket;
-				assert(listener !is null);
+                auto listener = cast(OverlappedStreamSocket) connection.socket;
+                assert(listener !is null);

-				auto socket = listener.endAccept(overlapped);
-				auto transport = MmapPool.instance.make!StreamTransport(socket);
+                auto socket = listener.endAccept(overlapped);
+                auto transport = MmapPool.instance.make!StreamTransport(socket);

-				connection.incoming.enqueue(transport);
+                connection.incoming.enqueue(transport);

-				reify(transport, EventMask(Event.none), EventMask(Event.read, Event.write));
+                reify(transport, EventMask(Event.none), EventMask(Event.read, Event.write));

-				pendings.enqueue(connection);
-				listener.beginAccept(overlapped);
-				break;
-			case OverlappedSocketEvent.read:
-				auto transport = cast(StreamTransport) (cast(void*) key);
-				assert(transport !is null);
+                pendings.enqueue(connection);
+                listener.beginAccept(overlapped);
+                break;
+            case OverlappedSocketEvent.read:
+                auto transport = cast(StreamTransport) (cast(void*) key);
+                assert(transport !is null);

-				if (!transport.active)
-				{
-					MmapPool.instance.dispose(transport);
-					MmapPool.instance.dispose(overlapped);
-					return;
-				}
+                if (!transport.active)
+                {
+                    MmapPool.instance.dispose(transport);
+                    MmapPool.instance.dispose(overlapped);
+                    return;
+                }

-				int received;
-				SocketException exception;
-				try
-				{
-					received = transport.socket.endReceive(overlapped);
-				}
-				catch (SocketException e)
-				{
-					exception = e;
-				}
-				if (transport.socket.disconnected)
-				{
-					// We want to get one last notification to destroy the watcher.
-					transport.socket.beginReceive(transport.output[], overlapped);
-					kill(transport, exception);
-				}
-				else if (received > 0)
-				{
-					immutable full = transport.output.free == received;
+                int received;
+                SocketException exception;
+                try
+                {
+                    received = transport.socket.endReceive(overlapped);
+                }
+                catch (SocketException e)
+                {
+                    exception = e;
+                }
+                if (transport.socket.disconnected)
+                {
+                    // We want to get one last notification to destroy the watcher.
+                    transport.socket.beginReceive(transport.output[], overlapped);
+                    kill(transport, exception);
+                }
+                else if (received > 0)
+                {
+                    immutable full = transport.output.free == received;

-					transport.output += received;
-					// Receive was interrupted because the buffer is full. We have to continue.
-					if (full)
-					{
-						transport.socket.beginReceive(transport.output[], overlapped);
-					}
-					pendings.enqueue(transport);
-				}
-				break;
-			case OverlappedSocketEvent.write:
-				auto transport = cast(StreamTransport) (cast(void*) key);
-				assert(transport !is null);
+                    transport.output += received;
+                    // Receive was interrupted because the buffer is full. We have to continue.
+                    if (full)
+                    {
+                        transport.socket.beginReceive(transport.output[], overlapped);
+                    }
+                    pendings.enqueue(transport);
+                }
+                break;
+            case OverlappedSocketEvent.write:
+                auto transport = cast(StreamTransport) (cast(void*) key);
+                assert(transport !is null);

-				transport.input += transport.socket.endSend(overlapped);
-				if (transport.input.length > 0)
-				{
-					transport.socket.beginSend(transport.input[], overlapped);
-				}
-				else
-				{
-					transport.socket.beginReceive(transport.output[], overlapped);
-					if (transport.isClosing())
-					{
-						kill(transport);
-					}
-				}
-				break;
-			default:
-				assert(false, "Unknown event");
-		}
-	}
-}
+                transport.input += transport.socket.endSend(overlapped);
+                if (transport.input.length > 0)
+                {
+                    transport.socket.beginSend(transport.input[], overlapped);
+                }
+                else
+                {
+                    transport.socket.beginReceive(transport.output[], overlapped);
+                    if (transport.isClosing())
+                    {
+                        kill(transport);
+                    }
+                }
+                break;
+            default:
+                assert(false, "Unknown event");
+        }
+    }
+}
--- a/source/tanya/async/event/kqueue.d
+++ b/source/tanya/async/event/kqueue.d
@ -12,31 +12,31 @@ module tanya.async.event.kqueue;

 version (OSX)
 {
-	version = MacBSD;
+    version = MacBSD;
 }
 else version (iOS)
 {
-	version = MacBSD;
+    version = MacBSD;
 }
 else version (TVOS)
 {
-	version = MacBSD;
+    version = MacBSD;
 }
 else version (WatchOS)
 {
-	version = MacBSD;
+    version = MacBSD;
 }
 else version (FreeBSD)
 {
-	version = MacBSD;
+    version = MacBSD;
 }
 else version (OpenBSD)
 {
-	version = MacBSD;
+    version = MacBSD;
 }
 else version (DragonFlyBSD)
 {
-	version = MacBSD;
+    version = MacBSD;
 }

 version (MacBSD):
@ -50,62 +50,62 @@ import tanya.async.event.selector;
 import tanya.async.loop;
 import tanya.async.transport;
 import tanya.async.watcher;
-import tanya.container.vector;
+import tanya.container.array;
 import tanya.memory;
 import tanya.memory.mmappool;
 import tanya.network.socket;

 void EV_SET(kevent_t* kevp, typeof(kevent_t.tupleof) args) pure nothrow @nogc
 {
-	*kevp = kevent_t(args);
+    *kevp = kevent_t(args);
 }

 enum : short
 {
-	EVFILT_READ     =  -1,
-	EVFILT_WRITE    =  -2,
-	EVFILT_AIO      =  -3, /* attached to aio requests */
-	EVFILT_VNODE    =  -4, /* attached to vnodes */
-	EVFILT_PROC     =  -5, /* attached to struct proc */
-	EVFILT_SIGNAL   =  -6, /* attached to struct proc */
-	EVFILT_TIMER    =  -7, /* timers */
-	EVFILT_MACHPORT =  -8, /* Mach portsets */
-	EVFILT_FS       =  -9, /* filesystem events */
-	EVFILT_USER     = -10, /* User events */
-	EVFILT_VM       = -12, /* virtual memory events */
-	EVFILT_SYSCOUNT =  11
+    EVFILT_READ     =  -1,
+    EVFILT_WRITE    =  -2,
+    EVFILT_AIO      =  -3, /* attached to aio requests */
+    EVFILT_VNODE    =  -4, /* attached to vnodes */
+    EVFILT_PROC     =  -5, /* attached to struct proc */
+    EVFILT_SIGNAL   =  -6, /* attached to struct proc */
+    EVFILT_TIMER    =  -7, /* timers */
+    EVFILT_MACHPORT =  -8, /* Mach portsets */
+    EVFILT_FS       =  -9, /* filesystem events */
+    EVFILT_USER     = -10, /* User events */
+    EVFILT_VM       = -12, /* virtual memory events */
+    EVFILT_SYSCOUNT =  11
 }

 struct kevent_t
 {
-	uintptr_t    ident; /* identifier for this event */
-	short       filter; /* filter for event */
-	ushort       flags;
-	uint        fflags;
-	intptr_t      data;
-	void        *udata; /* opaque user data identifier */
+    uintptr_t    ident; /* identifier for this event */
+    short       filter; /* filter for event */
+    ushort       flags;
+    uint        fflags;
+    intptr_t      data;
+    void        *udata; /* opaque user data identifier */
 }

 enum
 {
-	/* actions */
-	EV_ADD      = 0x0001, /* add event to kq (implies enable) */
-	EV_DELETE   = 0x0002, /* delete event from kq */
-	EV_ENABLE   = 0x0004, /* enable event */
-	EV_DISABLE  = 0x0008, /* disable event (not reported) */
+    /* actions */
+    EV_ADD      = 0x0001, /* add event to kq (implies enable) */
+    EV_DELETE   = 0x0002, /* delete event from kq */
+    EV_ENABLE   = 0x0004, /* enable event */
+    EV_DISABLE  = 0x0008, /* disable event (not reported) */

-	/* flags */
-	EV_ONESHOT  = 0x0010, /* only report one occurrence */
-	EV_CLEAR    = 0x0020, /* clear event state after reporting */
-	EV_RECEIPT  = 0x0040, /* force EV_ERROR on success, data=0 */
-	EV_DISPATCH = 0x0080, /* disable event after reporting */
+    /* flags */
+    EV_ONESHOT  = 0x0010, /* only report one occurrence */
+    EV_CLEAR    = 0x0020, /* clear event state after reporting */
+    EV_RECEIPT  = 0x0040, /* force EV_ERROR on success, data=0 */
+    EV_DISPATCH = 0x0080, /* disable event after reporting */

-	EV_SYSFLAGS = 0xF000, /* reserved by system */
-	EV_FLAG1    = 0x2000, /* filter-specific flag */
+    EV_SYSFLAGS = 0xF000, /* reserved by system */
+    EV_FLAG1    = 0x2000, /* filter-specific flag */

-	/* returned values */
-	EV_EOF      = 0x8000, /* EOF detected */
-	EV_ERROR    = 0x4000, /* error, data contains errno */
+    /* returned values */
+    EV_EOF      = 0x8000, /* EOF detected */
+    EV_ERROR    = 0x4000, /* error, data contains errno */
 }

 extern(C) int kqueue() nothrow @nogc;
@ -115,211 +115,211 @@ extern(C) int kevent(int kq, const kevent_t *changelist, int nchanges,

 final class KqueueLoop : SelectorLoop
 {
-	protected int fd;
-	private Vector!kevent_t events;
-	private Vector!kevent_t changes;
-	private size_t changeCount;
+    protected int fd;
+    private Array!kevent_t events;
+    private Array!kevent_t changes;
+    private size_t changeCount;

-	/**
-	 * Returns: Maximal event count can be got at a time
-	 *          (should be supported by the backend).
-	 */
-	override protected @property uint maxEvents()
-	const pure nothrow @safe @nogc
-	{
-		return cast(uint) events.length;
-	}
+    /**
+     * Returns: Maximal event count can be got at a time
+     *          (should be supported by the backend).
+     */
+    override protected @property uint maxEvents()
+    const pure nothrow @safe @nogc
+    {
+        return cast(uint) events.length;
+    }

-	this() @nogc
-	{
-		super();
+    this() @nogc
+    {
+        super();

-		if ((fd = kqueue()) == -1)
-		{
-			throw make!BadLoopException(defaultAllocator,
-			                            "kqueue initialization failed");
-		}
-		events = Vector!kevent_t(64, MmapPool.instance);
-		changes = Vector!kevent_t(64, MmapPool.instance);
-	}
+        if ((fd = kqueue()) == -1)
+        {
+            throw make!BadLoopException(defaultAllocator,
+                                        "kqueue initialization failed");
+        }
+        events = Array!kevent_t(64, MmapPool.instance);
+        changes = Array!kevent_t(64, MmapPool.instance);
+    }

-	/**
-	 * Frees loop internals.
-	 */
-	~this() @nogc
-	{
-		close(fd);
-	}
+    /**
+     * Frees loop internals.
+     */
+    ~this() @nogc
+    {
+        close(fd);
+    }

-	private void set(socket_t socket, short filter, ushort flags) @nogc
-	{
-		if (changes.length <= changeCount)
-		{
-			changes.length = changeCount + maxEvents;
-		}
-		EV_SET(&changes[changeCount],
-		       cast(ulong) socket,
-		       filter,
-		       flags,
-		       0U,
-		       0L,
-		       null);
-		++changeCount;
-	}
+    private void set(socket_t socket, short filter, ushort flags) @nogc
+    {
+        if (changes.length <= changeCount)
+        {
+            changes.length = changeCount + maxEvents;
+        }
+        EV_SET(&changes[changeCount],
+               cast(ulong) socket,
+               filter,
+               flags,
+               0U,
+               0L,
+               null);
+        ++changeCount;
+    }

-	/**
-	 * Should be called if the backend configuration changes.
-	 *
-	 * Params:
-	 * 	watcher   = Watcher.
-	 * 	oldEvents = The events were already set.
-	 * 	events    = The events should be set.
-	 *
-	 * Returns: $(D_KEYWORD true) if the operation was successful.
-	 */
-	override protected bool reify(SocketWatcher watcher,
-	                              EventMask oldEvents,
-	                              EventMask events) @nogc
-	{
-		if (events != oldEvents)
-		{
-			if (oldEvents & Event.read || oldEvents & Event.accept)
-			{
-				set(watcher.socket.handle, EVFILT_READ, EV_DELETE);
-			}
-			if (oldEvents & Event.write)
-			{
-				set(watcher.socket.handle, EVFILT_WRITE, EV_DELETE);
-			}
-		}
-		if (events & (Event.read | events & Event.accept))
-		{
-			set(watcher.socket.handle, EVFILT_READ, EV_ADD | EV_ENABLE);
-		}
-		if (events & Event.write)
-		{
-			set(watcher.socket.handle, EVFILT_WRITE, EV_ADD | EV_DISPATCH);
-		}
-		return true;
-	}
+    /**
+     * Should be called if the backend configuration changes.
+     *
+     * Params:
+     * 	watcher   = Watcher.
+     * 	oldEvents = The events were already set.
+     * 	events    = The events should be set.
+     *
+     * Returns: $(D_KEYWORD true) if the operation was successful.
+     */
+    override protected bool reify(SocketWatcher watcher,
+                                  EventMask oldEvents,
+                                  EventMask events) @nogc
+    {
+        if (events != oldEvents)
+        {
+            if (oldEvents & Event.read || oldEvents & Event.accept)
+            {
+                set(watcher.socket.handle, EVFILT_READ, EV_DELETE);
+            }
+            if (oldEvents & Event.write)
+            {
+                set(watcher.socket.handle, EVFILT_WRITE, EV_DELETE);
+            }
+        }
+        if (events & (Event.read | events & Event.accept))
+        {
+            set(watcher.socket.handle, EVFILT_READ, EV_ADD | EV_ENABLE);
+        }
+        if (events & Event.write)
+        {
+            set(watcher.socket.handle, EVFILT_WRITE, EV_ADD | EV_DISPATCH);
+        }
+        return true;
+    }

-	/**
-	 * Does the actual polling.
-	 */
-	protected override void poll() @nogc
-	{
-		timespec ts;
-		blockTime.split!("seconds", "nsecs")(ts.tv_sec, ts.tv_nsec);
+    /**
+     * Does the actual polling.
+     */
+    protected override void poll() @nogc
+    {
+        timespec ts;
+        blockTime.split!("seconds", "nsecs")(ts.tv_sec, ts.tv_nsec);

-		if (changeCount > maxEvents) 
-		{
-			events.length = changes.length;
-		}
+        if (changeCount > maxEvents) 
+        {
+            events.length = changes.length;
+        }

-		auto eventCount = kevent(fd,
-		                         changes.get().ptr,
-		                         cast(int) changeCount,
-		                         events.get().ptr,
-		                         maxEvents,
-		                         &ts);
-		changeCount = 0;
+        auto eventCount = kevent(fd,
+                                 changes.get().ptr,
+                                 cast(int) changeCount,
+                                 events.get().ptr,
+                                 maxEvents,
+                                 &ts);
+        changeCount = 0;

-		if (eventCount < 0)
-		{
-			if (errno != EINTR)
-			{
-				throw defaultAllocator.make!BadLoopException();
-			}
-			return;
-		}
+        if (eventCount < 0)
+        {
+            if (errno != EINTR)
+            {
+                throw defaultAllocator.make!BadLoopException();
+            }
+            return;
+        }

-		for (int i; i < eventCount; ++i)
-		{
-			assert(connections.length > events[i].ident);
+        for (int i; i < eventCount; ++i)
+        {
+            assert(connections.length > events[i].ident);

-			auto transport = cast(StreamTransport) connections[events[i].ident];
-			// If it is a ConnectionWatcher. Accept connections.
-			if (transport is null)
-			{
-				auto connection = cast(ConnectionWatcher) connections[events[i].ident];
-				assert(connection !is null);
+            auto transport = cast(StreamTransport) connections[events[i].ident];
+            // If it is a ConnectionWatcher. Accept connections.
+            if (transport is null)
+            {
+                auto connection = cast(ConnectionWatcher) connections[events[i].ident];
+                assert(connection !is null);

-				acceptConnections(connection);
-			}
-			else if (events[i].flags & EV_ERROR)
-			{
-				kill(transport);
-			}
-			else if (events[i].filter == EVFILT_READ)
-			{
-				SocketException exception;
-				try
-				{
-					ptrdiff_t received;
-					do
-					{
-						received = transport.socket.receive(transport.output[]);
-						transport.output += received;
-					}
-					while (received);
-				}
-				catch (SocketException e)
-				{
-					exception = e;
-				}
-				if (transport.socket.disconnected)
-				{
-					kill(transport, exception);
-				}
-				else if (transport.output.length)
-				{
-					pendings.enqueue(transport);
-				}
-			}
-			else if (events[i].filter == EVFILT_WRITE)
-			{
-				transport.writeReady = true;
-				if (transport.input.length)
-				{
-					feed(transport);
-				}
-			}
-		}
-	}
+                acceptConnections(connection);
+            }
+            else if (events[i].flags & EV_ERROR)
+            {
+                kill(transport);
+            }
+            else if (events[i].filter == EVFILT_READ)
+            {
+                SocketException exception;
+                try
+                {
+                    ptrdiff_t received;
+                    do
+                    {
+                        received = transport.socket.receive(transport.output[]);
+                        transport.output += received;
+                    }
+                    while (received);
+                }
+                catch (SocketException e)
+                {
+                    exception = e;
+                }
+                if (transport.socket.disconnected)
+                {
+                    kill(transport, exception);
+                }
+                else if (transport.output.length)
+                {
+                    pendings.enqueue(transport);
+                }
+            }
+            else if (events[i].filter == EVFILT_WRITE)
+            {
+                transport.writeReady = true;
+                if (transport.input.length)
+                {
+                    feed(transport);
+                }
+            }
+        }
+    }

-	/**
-	 * Returns: The blocking time.
-	 */
-	override protected @property inout(Duration) blockTime()
-	inout @nogc @safe pure nothrow
-	{
-		return min(super.blockTime, 1.dur!"seconds");
-	}
+    /**
+     * Returns: The blocking time.
+     */
+    override protected @property inout(Duration) blockTime()
+    inout @nogc @safe pure nothrow
+    {
+        return min(super.blockTime, 1.dur!"seconds");
+    }

-	/**
-	 * If the transport couldn't send the data, the further sending should
-	 * be handled by the event loop.
-	 *
-	 * Params:
-	 * 	transport = Transport.
-	 * 	exception = Exception thrown on sending.
-	 *
-	 * Returns: $(D_KEYWORD true) if the operation could be successfully
-	 *          completed or scheduled, $(D_KEYWORD false) otherwise (the
-	 *          transport will be destroyed then).
-	 */
-	protected override bool feed(StreamTransport transport,
-	                             SocketException exception = null) @nogc
-	{
-		if (!super.feed(transport, exception))
-		{
-			return false;
-		}
-		if (!transport.writeReady)
-		{
-			set(transport.socket.handle, EVFILT_WRITE, EV_DISPATCH);
-			return true;
-		}
-		return false;
-	}
+    /**
+     * If the transport couldn't send the data, the further sending should
+     * be handled by the event loop.
+     *
+     * Params:
+     * 	transport = Transport.
+     * 	exception = Exception thrown on sending.
+     *
+     * Returns: $(D_KEYWORD true) if the operation could be successfully
+     *          completed or scheduled, $(D_KEYWORD false) otherwise (the
+     *          transport will be destroyed then).
+     */
+    protected override bool feed(StreamTransport transport,
+                                 SocketException exception = null) @nogc
+    {
+        if (!super.feed(transport, exception))
+        {
+            return false;
+        }
+        if (!transport.writeReady)
+        {
+            set(transport.socket.handle, EVFILT_WRITE, EV_DISPATCH);
+            return true;
+        }
+        return false;
+    }
 }
--- a/source/tanya/async/event/selector.d
+++ b/source/tanya/async/event/selector.d
@ -17,7 +17,7 @@ import tanya.async.protocol;
 import tanya.async.transport;
 import tanya.async.watcher;
 import tanya.container.buffer;
-import tanya.container.vector;
+import tanya.container.array;
 import tanya.memory;
 import tanya.memory.mmappool;
 import tanya.network.socket;
@ -27,371 +27,374 @@ import tanya.network.socket;
 */
 package class StreamTransport : SocketWatcher, DuplexTransport, SocketTransport
 {
-	private SelectorLoop loop;
+    private SelectorLoop loop;

-	private SocketException exception;
+    private SocketException exception;

-	package ReadBuffer!ubyte output;
+    package ReadBuffer!ubyte output;

-	package WriteBuffer!ubyte input;
+    package WriteBuffer!ubyte input;

-	private Protocol protocol_;
+    private Protocol protocol_;

-	private bool closing;
+    private bool closing;

-	/// Received notification that the underlying socket is write-ready.
-	package bool writeReady;
+    /// Received notification that the underlying socket is write-ready.
+    package bool writeReady;

-	/**
-	 * Params:
-	 * 	loop   = Event loop.
-	 * 	socket = Socket.
-	 *
-	 * Precondition: $(D_INLINECODE loop !is null && socket !is null)
-	 */
-	this(SelectorLoop loop, ConnectedSocket socket) @nogc
-	in 
-	{
-		assert(loop !is null);
-	}
-	body
-	{
-		super(socket);
-		this.loop = loop;
-		output = ReadBuffer!ubyte(8192, 1024, MmapPool.instance);
-		input = WriteBuffer!ubyte(8192, MmapPool.instance);
-		active = true;
-	}
+    /**
+     * Params:
+     *  loop   = Event loop.
+     *  socket = Socket.
+     *
+     * Precondition: $(D_INLINECODE loop !is null && socket !is null)
+     */
+    this(SelectorLoop loop, ConnectedSocket socket) @nogc
+    in 
+    {
+        assert(loop !is null);
+    }
+    body
+    {
+        super(socket);
+        this.loop = loop;
+        output = ReadBuffer!ubyte(8192, 1024, MmapPool.instance);
+        input = WriteBuffer!ubyte(8192, MmapPool.instance);
+        active = true;
+    }

-	/**
-	 * Returns: Socket.
-	 *
-	 * Postcondition: $(D_INLINECODE socket !is null)
-	 */
-	override @property ConnectedSocket socket() pure nothrow @safe @nogc
-	out (socket)
-	{
-		assert(socket !is null);
-	}
-	body
-	{
-		return cast(ConnectedSocket) socket_;
-	}
+    /**
+     * Returns: Socket.
+     *
+     * Postcondition: $(D_INLINECODE socket !is null)
+     */
+    override @property ConnectedSocket socket() pure nothrow @safe @nogc
+    out (socket)
+    {
+        assert(socket !is null);
+    }
+    body
+    {
+        return cast(ConnectedSocket) socket_;
+    }

-	private @property void socket(ConnectedSocket socket) pure nothrow @safe @nogc
-	in
-	{
-		assert(socket !is null);
-	}
-	body
-	{
-		socket_ = socket;
-	}
+    private @property void socket(ConnectedSocket socket)
+    pure nothrow @safe @nogc
+    in
+    {
+        assert(socket !is null);
+    }
+    body
+    {
+        socket_ = socket;
+    }

-	/**
-	 * Returns: Application protocol.
-	 */
-	@property Protocol protocol() pure nothrow @safe @nogc
-	{
-		return protocol_;
-	}
+    /**
+     * Returns: Application protocol.
+     */
+    @property Protocol protocol() pure nothrow @safe @nogc
+    {
+        return protocol_;
+    }

-	/**
-	 * Switches the protocol.
-	 *
-	 * The protocol is deallocated by the event loop, it should currently be
-	 * allocated with $(D_PSYMBOL MmapPool).
-	 *
-	 * Params:
-	 * 	protocol = Application protocol.
-	 *
-	 * Precondition: $(D_INLINECODE protocol !is null)
-	 */
-	@property void protocol(Protocol protocol) pure nothrow @safe @nogc
-	in
-	{
-		assert(protocol !is null);
-	}
-	body
-	{
-		protocol_ = protocol;
-	}
+    /**
+     * Switches the protocol.
+     *
+     * The protocol is deallocated by the event loop, it should currently be
+     * allocated with $(D_PSYMBOL MmapPool).
+     *
+     * Params:
+     *  protocol = Application protocol.
+     *
+     * Precondition: $(D_INLINECODE protocol !is null)
+     */
+    @property void protocol(Protocol protocol) pure nothrow @safe @nogc
+    in
+    {
+        assert(protocol !is null);
+    }
+    body
+    {
+        protocol_ = protocol;
+    }

-	/**
-	 * Returns $(D_PARAM true) if the transport is closing or closed.
-	 */
-	bool isClosing() const pure nothrow @safe @nogc
-	{
-		return closing;
-	}
+    /**
+     * Returns $(D_PARAM true) if the transport is closing or closed.
+     */
+    bool isClosing() const pure nothrow @safe @nogc
+    {
+        return closing;
+    }

-	/**
-	 * Close the transport.
-	 *
-	 * Buffered data will be flushed.  No more data will be received.
-	 */
-	void close() @nogc
-	{
-		closing = true;
-		loop.reify(this, EventMask(Event.read, Event.write), EventMask(Event.write));
-	}
+    /**
+     * Close the transport.
+     *
+     * Buffered data will be flushed.  No more data will be received.
+     */
+    void close() @nogc
+    {
+        closing = true;
+        loop.reify(this,
+                   EventMask(Event.read, Event.write),
+                   EventMask(Event.write));
+    }

-	/**
-	 * Invokes the watcher callback.
-	 */
-	override void invoke() @nogc
-	{
-		if (output.length)
-		{
-			protocol.received(output[0 .. $]);
-			output.clear();
-			if (isClosing() && input.length == 0)
-			{
-				loop.kill(this);
-			}
-		}
-		else
-		{
-			protocol.disconnected(exception);
-			MmapPool.instance.dispose(protocol_);
-			defaultAllocator.dispose(exception);
-			active = false;
-		}
-	}
+    /**
+     * Invokes the watcher callback.
+     */
+    override void invoke() @nogc
+    {
+        if (output.length)
+        {
+            protocol.received(output[0 .. $]);
+            output.clear();
+            if (isClosing() && input.length == 0)
+            {
+                loop.kill(this);
+            }
+        }
+        else
+        {
+            protocol.disconnected(exception);
+            MmapPool.instance.dispose(protocol_);
+            defaultAllocator.dispose(exception);
+            active = false;
+        }
+    }

-	/**
-	 * Write some data to the transport.
-	 *
-	 * Params:
-	 * 	data = Data to send.
-	 */
-	void write(ubyte[] data) @nogc
-	{
-		if (!data.length)
-		{
-			return;
-		}
-		// Try to write if the socket is write ready.
-		if (writeReady)
-		{
-			ptrdiff_t sent;
-			SocketException exception;
-			try
-			{
-				sent = socket.send(data);
-				if (sent == 0)
-				{
-					writeReady = false;
-				}
-			}
-			catch (SocketException e)
-			{
-				writeReady = false;
-				exception = e;
-			}
-			if (sent < data.length)
-			{
-				input ~= data[sent..$];
-				loop.feed(this, exception);
-			}
-		}
-		else
-		{
-			input ~= data;
-		}
-	}
+    /**
+     * Write some data to the transport.
+     *
+     * Params:
+     *  data = Data to send.
+     */
+    void write(ubyte[] data) @nogc
+    {
+        if (!data.length)
+        {
+            return;
+        }
+        // Try to write if the socket is write ready.
+        if (writeReady)
+        {
+            ptrdiff_t sent;
+            SocketException exception;
+            try
+            {
+                sent = socket.send(data);
+                if (sent == 0)
+                {
+                    writeReady = false;
+                }
+            }
+            catch (SocketException e)
+            {
+                writeReady = false;
+                exception = e;
+            }
+            if (sent < data.length)
+            {
+                input ~= data[sent..$];
+                loop.feed(this, exception);
+            }
+        }
+        else
+        {
+            input ~= data;
+        }
+    }
 }

 abstract class SelectorLoop : Loop
 {
-	/// Pending connections.
-	protected Vector!SocketWatcher connections;
+    /// Pending connections.
+    protected Array!SocketWatcher connections;

-	this() @nogc
-	{
-		super();
-		connections = Vector!SocketWatcher(maxEvents, MmapPool.instance);
-	}
+    this() @nogc
+    {
+        super();
+        connections = Array!SocketWatcher(maxEvents, MmapPool.instance);
+    }

-	~this() @nogc
-	{
-		foreach (ref connection; connections)
-		{
-			// We want to free only the transports. ConnectionWatcher are created by the
-			// user and should be freed by himself.
-			if (cast(StreamTransport) connection !is null)
-			{
-				MmapPool.instance.dispose(connection);
-			}
-		}
-	}
+    ~this() @nogc
+    {
+        foreach (ref connection; connections)
+        {
+            // We want to free only the transports. ConnectionWatcher are
+            // created by the user and should be freed by himself.
+            if (cast(StreamTransport) connection !is null)
+            {
+                MmapPool.instance.dispose(connection);
+            }
+        }
+    }

-	/**
-	 * Should be called if the backend configuration changes.
-	 *
-	 * Params:
-	 * 	watcher   = Watcher.
-	 * 	oldEvents = The events were already set.
-	 * 	events    = The events should be set.
-	 *
-	 * Returns: $(D_KEYWORD true) if the operation was successful.
-	 */
-	override abstract protected bool reify(SocketWatcher watcher,
-	                                       EventMask oldEvents,
-	                                       EventMask events) @nogc;
+    /**
+     * Should be called if the backend configuration changes.
+     *
+     * Params:
+     *  watcher   = Watcher.
+     *  oldEvents = The events were already set.
+     *  events    = The events should be set.
+     *
+     * Returns: $(D_KEYWORD true) if the operation was successful.
+     */
+    override abstract protected bool reify(SocketWatcher watcher,
+                                           EventMask oldEvents,
+                                           EventMask events) @nogc;

-	/**
-	 * Kills the watcher and closes the connection.
-	 *
-	 * Params:
-	 * 	transport = Transport.
-	 * 	exception = Occurred exception.
-	 */
-	protected void kill(StreamTransport transport,
-	                    SocketException exception = null) @nogc
-	in
-	{
-		assert(transport !is null);
-	}
-	body
-	{
-		transport.socket.shutdown();
-		defaultAllocator.dispose(transport.socket);
-		transport.exception = exception;
-		pendings.enqueue(transport);
-	}
+    /**
+     * Kills the watcher and closes the connection.
+     *
+     * Params:
+     *  transport = Transport.
+     *  exception = Occurred exception.
+     */
+    protected void kill(StreamTransport transport,
+                        SocketException exception = null) @nogc
+    in
+    {
+        assert(transport !is null);
+    }
+    body
+    {
+        transport.socket.shutdown();
+        defaultAllocator.dispose(transport.socket);
+        transport.exception = exception;
+        pendings.enqueue(transport);
+    }

-	/**
-	 * If the transport couldn't send the data, the further sending should
-	 * be handled by the event loop.
-	 *
-	 * Params:
-	 * 	transport = Transport.
-	 * 	exception = Exception thrown on sending.
-	 *
-	 * Returns: $(D_KEYWORD true) if the operation could be successfully
-	 *          completed or scheduled, $(D_KEYWORD false) otherwise (the
-	 *          transport will be destroyed then).
-	 */
-	protected bool feed(StreamTransport transport,
-	                    SocketException exception = null) @nogc
-	in
-	{
-		assert(transport !is null);
-	}
-	body
-	{
-		while (transport.input.length && transport.writeReady)
-		{
-			try
-			{
-				ptrdiff_t sent = transport.socket.send(transport.input[]);
-				if (sent == 0)
-				{
-					transport.writeReady = false;
-				}
-				else
-				{
-					transport.input += sent;
-				}
-			}
-			catch (SocketException e)
-			{
-				exception = e;
-				transport.writeReady = false;
-			}
-		}
-		if (exception !is null)
-		{
-			kill(transport, exception);
-			return false;
-		}
-		if (transport.input.length == 0 && transport.isClosing())
-		{
-			kill(transport);
-		}
-		return true;
-	}
+    /**
+     * If the transport couldn't send the data, the further sending should
+     * be handled by the event loop.
+     *
+     * Params:
+     *  transport = Transport.
+     *  exception = Exception thrown on sending.
+     *
+     * Returns: $(D_KEYWORD true) if the operation could be successfully
+     *          completed or scheduled, $(D_KEYWORD false) otherwise (the
+     *          transport will be destroyed then).
+     */
+    protected bool feed(StreamTransport transport,
+                        SocketException exception = null) @nogc
+    in
+    {
+        assert(transport !is null);
+    }
+    body
+    {
+        while (transport.input.length && transport.writeReady)
+        {
+            try
+            {
+                ptrdiff_t sent = transport.socket.send(transport.input[]);
+                if (sent == 0)
+                {
+                    transport.writeReady = false;
+                }
+                else
+                {
+                    transport.input += sent;
+                }
+            }
+            catch (SocketException e)
+            {
+                exception = e;
+                transport.writeReady = false;
+            }
+        }
+        if (exception !is null)
+        {
+            kill(transport, exception);
+            return false;
+        }
+        if (transport.input.length == 0 && transport.isClosing())
+        {
+            kill(transport);
+        }
+        return true;
+    }

-	/**
-	 * Start watching.
-	 *
-	 * Params:
-	 * 	watcher = Watcher.
-	 */
-	override void start(ConnectionWatcher watcher) @nogc
-	{
-		if (watcher.active)
-		{
-			return;
-		}
+    /**
+     * Start watching.
+     *
+     * Params:
+     *  watcher = Watcher.
+     */
+    override void start(ConnectionWatcher watcher) @nogc
+    {
+        if (watcher.active)
+        {
+            return;
+        }

-		if (connections.length <= watcher.socket)
-		{
-			connections.length = watcher.socket.handle + maxEvents / 2;
-		}
-		connections[watcher.socket.handle] = watcher;
+        if (connections.length <= watcher.socket)
+        {
+            connections.length = watcher.socket.handle + maxEvents / 2;
+        }
+        connections[watcher.socket.handle] = watcher;

-		super.start(watcher);
-	}
+        super.start(watcher);
+    }

-	/**
-	 * Accept incoming connections.
-	 *
-	 * Params:
-	 * 	connection = Connection watcher ready to accept.
-	 */
-	package void acceptConnections(ConnectionWatcher connection) @nogc
-	in
-	{
-		assert(connection !is null);
-	}
-	body
-	{
-		while (true)
-		{
-			ConnectedSocket client;
-			try
-			{
-				client = (cast(StreamSocket) connection.socket).accept();
-			}
-			catch (SocketException e)
-			{
-				defaultAllocator.dispose(e);
-				break;
-			}
-			if (client is null)
-			{
-				break;
-			}
+    /**
+     * Accept incoming connections.
+     *
+     * Params:
+     *  connection = Connection watcher ready to accept.
+     */
+    package void acceptConnections(ConnectionWatcher connection) @nogc
+    in
+    {
+        assert(connection !is null);
+    }
+    body
+    {
+        while (true)
+        {
+            ConnectedSocket client;
+            try
+            {
+                client = (cast(StreamSocket) connection.socket).accept();
+            }
+            catch (SocketException e)
+            {
+                defaultAllocator.dispose(e);
+                break;
+            }
+            if (client is null)
+            {
+                break;
+            }

-			StreamTransport transport;
+            StreamTransport transport;

-			if (connections.length > client.handle)
-			{
-				transport = cast(StreamTransport) connections[client.handle];
-			}
-			else
-			{
-				connections.length = client.handle + maxEvents / 2;
-			}
-			if (transport is null)
-			{
-				transport = MmapPool.instance.make!StreamTransport(this, client);
-				connections[client.handle] = transport;
-			}
-			else
-			{
-				transport.socket = client;
-			}
+            if (connections.length > client.handle)
+            {
+                transport = cast(StreamTransport) connections[client.handle];
+            }
+            else
+            {
+                connections.length = client.handle + maxEvents / 2;
+            }
+            if (transport is null)
+            {
+                transport = MmapPool.instance.make!StreamTransport(this, client);
+                connections[client.handle] = transport;
+            }
+            else
+            {
+                transport.socket = client;
+            }

-			reify(transport, EventMask(Event.none), EventMask(Event.read, Event.write));
-			connection.incoming.enqueue(transport);
-		}
+            reify(transport, EventMask(Event.none), EventMask(Event.read, Event.write));
+            connection.incoming.enqueue(transport);
+        }

-		if (!connection.incoming.empty)
-		{
-			pendings.enqueue(connection);
-		}
-	}
+        if (!connection.incoming.empty)
+        {
+            pendings.enqueue(connection);
+        }
+    }
 }
--- a/source/tanya/async/iocp.d
+++ b/source/tanya/async/iocp.d
@ -21,12 +21,12 @@ import core.sys.windows.windef;
 */
 class State
 {
-	/// For internal use by Windows API.
-	align(1) OVERLAPPED overlapped;
+    /// For internal use by Windows API.
+    align(1) OVERLAPPED overlapped;

-	/// File/socket handle.
-	HANDLE handle;
+    /// File/socket handle.
+    HANDLE handle;

-	/// For keeping events or event masks.
-	int event;
+    /// For keeping events or event masks.
+    int event;
 }
--- a/source/tanya/async/loop.d
+++ b/source/tanya/async/loop.d
@ -15,50 +15,50 @@
 *
 * class EchoProtocol : TransmissionControlProtocol
 * {
- * 	private DuplexTransport transport;
+ *  private DuplexTransport transport;
 *
- * 	void received(in ubyte[] data) @nogc
- * 	{
- * 		transport.write(data);
- * 	}
+ *  void received(in ubyte[] data) @nogc
+ *  {
+ *      transport.write(data);
+ *  }
 *
- * 	void connected(DuplexTransport transport) @nogc
- * 	{
- * 		this.transport = transport;
- * 	}
+ *  void connected(DuplexTransport transport) @nogc
+ *  {
+ *      this.transport = transport;
+ *  }
 *
- * 	void disconnected(SocketException e) @nogc
- * 	{
- * 	}
+ *  void disconnected(SocketException e) @nogc
+ *  {
+ *  }
 * }
 *
 * void main()
 * {
- * 	auto address = defaultAllocator.make!InternetAddress("127.0.0.1", cast(ushort) 8192);
+ *  auto address = defaultAllocator.make!InternetAddress("127.0.0.1", cast(ushort) 8192);
 *
- * 	version (Windows)
- * 	{
- * 		auto sock = defaultAllocator.make!OverlappedStreamSocket(AddressFamily.INET);
- * 	}
- * 	else
- * 	{
- * 		auto sock = defaultAllocator.make!StreamSocket(AddressFamily.INET);
- * 		sock.blocking = false;
- * 	}
+ *  version (Windows)
+ *  {
+ *      auto sock = defaultAllocator.make!OverlappedStreamSocket(AddressFamily.INET);
+ *  }
+ *  else
+ *  {
+ *      auto sock = defaultAllocator.make!StreamSocket(AddressFamily.INET);
+ *      sock.blocking = false;
+ *  }
 *
- * 	sock.bind(address);
- * 	sock.listen(5);
+ *  sock.bind(address);
+ *  sock.listen(5);
 *
- * 	auto io = defaultAllocator.make!ConnectionWatcher(sock);
- * 	io.setProtocol!EchoProtocol;
+ *  auto io = defaultAllocator.make!ConnectionWatcher(sock);
+ *  io.setProtocol!EchoProtocol;
 *
- * 	defaultLoop.start(io);
- * 	defaultLoop.run();
+ *  defaultLoop.start(io);
+ *  defaultLoop.run();
 *
- * 	sock.shutdown();
- * 	defaultAllocator.dispose(io);
- * 	defaultAllocator.dispose(sock);
- * 	defaultAllocator.dispose(address);
+ *  sock.shutdown();
+ *  defaultAllocator.dispose(io);
+ *  defaultAllocator.dispose(sock);
+ *  defaultAllocator.dispose(address);
 * }
 * ---
 */
@ -81,33 +81,33 @@ version (DisableBackends)
 }
 else version (linux)
 {
-	import tanya.async.event.epoll;
-	version = Epoll;
+    import tanya.async.event.epoll;
+    version = Epoll;
 }
 else version (Windows)
 {
-	import tanya.async.event.iocp;
-	version = IOCP;
+    import tanya.async.event.iocp;
+    version = IOCP;
 }
 else version (OSX)
 {
-	version = Kqueue;
+    version = Kqueue;
 }
 else version (iOS)
 {
-	version = Kqueue;
+    version = Kqueue;
 }
 else version (FreeBSD)
 {
-	version = Kqueue;
+    version = Kqueue;
 }
 else version (OpenBSD)
 {
-	version = Kqueue;
+    version = Kqueue;
 }
 else version (DragonFlyBSD)
 {
-	version = Kqueue;
+    version = Kqueue;
 }

 /**
@ -115,11 +115,11 @@ else version (DragonFlyBSD)
 */
 enum Event : uint
 {
-	none   = 0x00,       /// No events.
-	read   = 0x01,       /// Non-blocking read call.
-	write  = 0x02,       /// Non-blocking write call.
-	accept = 0x04,       /// Connection made.
-	error  = 0x80000000, /// Sent when an error occurs.
+    none   = 0x00,       /// No events.
+    read   = 0x01,       /// Non-blocking read call.
+    write  = 0x02,       /// Non-blocking write call.
+    accept = 0x04,       /// Connection made.
+    error  = 0x80000000, /// Sent when an error occurs.
 }

 alias EventMask = BitFlags!Event;
@ -129,150 +129,150 @@ alias EventMask = BitFlags!Event;
 */
 abstract class Loop
 {
-	private bool done;
+    private bool done;

-	/// Pending watchers.
-	protected Queue!Watcher pendings;
+    /// Pending watchers.
+    protected Queue!Watcher pendings;

-	/**
-	 * Returns: Maximal event count can be got at a time
-	 *          (should be supported by the backend).
-	 */
-	protected @property uint maxEvents()
-	const pure nothrow @safe @nogc
-	{
-		return 128U;
-	}
+    /**
+     * Returns: Maximal event count can be got at a time
+     *          (should be supported by the backend).
+     */
+    protected @property uint maxEvents()
+    const pure nothrow @safe @nogc
+    {
+        return 128U;
+    }

-	/**
-	 * Initializes the loop.
-	 */
-	this() @nogc
-	{
-		pendings = Queue!Watcher(MmapPool.instance);
-	}
+    /**
+     * Initializes the loop.
+     */
+    this() @nogc
+    {
+        pendings = Queue!Watcher(MmapPool.instance);
+    }

-	/**
-	 * Frees loop internals.
-	 */
-	~this() @nogc
-	{
-		foreach (w; pendings)
-		{
-			MmapPool.instance.dispose(w);
-		}
-	}
+    /**
+     * Frees loop internals.
+     */
+    ~this() @nogc
+    {
+        foreach (w; pendings)
+        {
+            MmapPool.instance.dispose(w);
+        }
+    }

-	/**
-	 * Starts the loop.
-	 */
-	void run() @nogc
-	{
-		done = false;
-		do
-		{
-			poll();
+    /**
+     * Starts the loop.
+     */
+    void run() @nogc
+    {
+        done = false;
+        do
+        {
+            poll();

-			// Invoke pendings
-			foreach (ref w; pendings)
-			{
-				w.invoke();
-			}
-		}
-		while (!done);
-	}
+            // Invoke pendings
+            foreach (ref w; pendings)
+            {
+                w.invoke();
+            }
+        }
+        while (!done);
+    }

-	/**
-	 * Break out of the loop.
-	 */
-	void unloop() @safe pure nothrow @nogc
-	{
-		done = true;
-	}
+    /**
+     * Break out of the loop.
+     */
+    void unloop() @safe pure nothrow @nogc
+    {
+        done = true;
+    }

-	/**
-	 * Start watching.
-	 *
-	 * Params:
-	 * 	watcher = Watcher.
-	 */
-	void start(ConnectionWatcher watcher) @nogc
-	{
-		if (watcher.active)
-		{
-			return;
-		}
-		watcher.active = true;
+    /**
+     * Start watching.
+     *
+     * Params:
+     *  watcher = Watcher.
+     */
+    void start(ConnectionWatcher watcher) @nogc
+    {
+        if (watcher.active)
+        {
+            return;
+        }
+        watcher.active = true;

-		reify(watcher, EventMask(Event.none), EventMask(Event.accept));
-	}
+        reify(watcher, EventMask(Event.none), EventMask(Event.accept));
+    }

-	/**
-	 * Stop watching.
-	 *
-	 * Params:
-	 * 	watcher = Watcher.
-	 */
-	void stop(ConnectionWatcher watcher) @nogc
-	{
-		if (!watcher.active)
-		{
-			return;
-		}
-		watcher.active = false;
+    /**
+     * Stop watching.
+     *
+     * Params:
+     *  watcher = Watcher.
+     */
+    void stop(ConnectionWatcher watcher) @nogc
+    {
+        if (!watcher.active)
+        {
+            return;
+        }
+        watcher.active = false;

-		reify(watcher, EventMask(Event.accept), EventMask(Event.none));
-	}
+        reify(watcher, EventMask(Event.accept), EventMask(Event.none));
+    }

-	/**
-	 * Should be called if the backend configuration changes.
-	 *
-	 * Params:
-	 * 	watcher   = Watcher.
-	 * 	oldEvents = The events were already set.
-	 * 	events    = The events should be set.
-	 *
-	 * Returns: $(D_KEYWORD true) if the operation was successful.
-	 */
-	abstract protected bool reify(SocketWatcher watcher,
-	                              EventMask oldEvents,
-	                              EventMask events) @nogc;
+    /**
+     * Should be called if the backend configuration changes.
+     *
+     * Params:
+     *  watcher   = Watcher.
+     *  oldEvents = The events were already set.
+     *  events    = The events should be set.
+     *
+     * Returns: $(D_KEYWORD true) if the operation was successful.
+     */
+    abstract protected bool reify(SocketWatcher watcher,
+                                  EventMask oldEvents,
+                                  EventMask events) @nogc;

-	/**
-	 * Returns: The blocking time.
-	 */
-	protected @property inout(Duration) blockTime()
-	inout @safe pure nothrow @nogc
-	{
-		// Don't block if we have to do.
-		return pendings.empty ? blockTime_ : Duration.zero;
-	}
+    /**
+     * Returns: The blocking time.
+     */
+    protected @property inout(Duration) blockTime()
+    inout @safe pure nothrow @nogc
+    {
+        // Don't block if we have to do.
+        return pendings.empty ? blockTime_ : Duration.zero;
+    }

-	/**
-	 * Sets the blocking time for IO watchers.
-	 *
-	 * Params:
-	 * 	blockTime = The blocking time. Cannot be larger than
-	 * 	            $(D_PSYMBOL maxBlockTime).
-	 */
-	protected @property void blockTime(in Duration blockTime) @safe pure nothrow @nogc
-	in
-	{
-		assert(blockTime <= 1.dur!"hours", "Too long to wait.");
-		assert(!blockTime.isNegative);
-	}
-	body
-	{
-		blockTime_ = blockTime;
-	}
+    /**
+     * Sets the blocking time for IO watchers.
+     *
+     * Params:
+     *  blockTime = The blocking time. Cannot be larger than
+     *              $(D_PSYMBOL maxBlockTime).
+     */
+    protected @property void blockTime(in Duration blockTime) @safe pure nothrow @nogc
+    in
+    {
+        assert(blockTime <= 1.dur!"hours", "Too long to wait.");
+        assert(!blockTime.isNegative);
+    }
+    body
+    {
+        blockTime_ = blockTime;
+    }

-	/**
-	 * Does the actual polling.
-	 */
-	abstract protected void poll() @nogc;
+    /**
+     * Does the actual polling.
+     */
+    abstract protected void poll() @nogc;

-	/// Maximal block time.
-	protected Duration blockTime_ = 1.dur!"minutes";
+    /// Maximal block time.
+    protected Duration blockTime_ = 1.dur!"minutes";
 }

 /**
@ -280,17 +280,17 @@ abstract class Loop
 */
 class BadLoopException : Exception
 {
-	/**
-	 * Params:
-	 * 	file = The file where the exception occurred.
-	 * 	line = The line number where the exception occurred.
-	 * 	next = The previous exception in the chain of exceptions, if any.
-	 */
-	this(string file = __FILE__, size_t line = __LINE__, Throwable next = null)
-	pure nothrow const @safe @nogc
-	{
-		super("Event loop cannot be initialized.", file, line, next);
-	}
+    /**
+     * Params:
+     *  file = The file where the exception occurred.
+     *  line = The line number where the exception occurred.
+     *  next = The previous exception in the chain of exceptions, if any.
+     */
+    this(string file = __FILE__, size_t line = __LINE__, Throwable next = null)
+    pure nothrow const @safe @nogc
+    {
+        super("Event loop cannot be initialized.", file, line, next);
+    }
 }

 /**
@ -302,24 +302,24 @@ class BadLoopException : Exception
 */
@property Loop defaultLoop() @nogc
 {
-	if (defaultLoop_ !is null)
-	{
-		return defaultLoop_;
-	}
-	version (Epoll)
-	{
-		defaultLoop_ = MmapPool.instance.make!EpollLoop;
-	}
-	else version (IOCP)
-	{
-		defaultLoop_ = MmapPool.instance.make!IOCPLoop;
-	}
-	else version (Kqueue)
-	{
-		import tanya.async.event.kqueue;
-		defaultLoop_ = MmapPool.instance.make!KqueueLoop;
-	}
-	return defaultLoop_;
+    if (defaultLoop_ !is null)
+    {
+        return defaultLoop_;
+    }
+    version (Epoll)
+    {
+        defaultLoop_ = MmapPool.instance.make!EpollLoop;
+    }
+    else version (IOCP)
+    {
+        defaultLoop_ = MmapPool.instance.make!IOCPLoop;
+    }
+    else version (Kqueue)
+    {
+        import tanya.async.event.kqueue;
+        defaultLoop_ = MmapPool.instance.make!KqueueLoop;
+    }
+    return defaultLoop_;
 }

 /**
@ -331,16 +331,16 @@ class BadLoopException : Exception
 * your implementation to this property.
 *
 * Params:
- * 	loop = The event loop.
+ *  loop = The event loop.
 */
@property void defaultLoop(Loop loop) @nogc
 in
 {
-	assert(loop !is null);
+    assert(loop !is null);
 }
 body
 {
-	defaultLoop_ = loop;
+    defaultLoop_ = loop;
 }

 private Loop defaultLoop_;
--- a/source/tanya/async/protocol.d
+++ b/source/tanya/async/protocol.d
@ -18,28 +18,28 @@ import tanya.async.transport;
 */
 interface Protocol
 {
-	/**
-	 * Params:
-	 * 	data = Read data.
-	 */
-	void received(in ubyte[] data) @nogc;
+    /**
+     * Params:
+     *  data = Read data.
+     */
+    void received(in ubyte[] data) @nogc;

-	/**
-	 * Called when a connection is made.
-	 *
-	 * Params:
-	 * 	transport = Protocol transport.
-	 */
-	void connected(DuplexTransport transport) @nogc;
+    /**
+     * Called when a connection is made.
+     *
+     * Params:
+     *  transport = Protocol transport.
+     */
+    void connected(DuplexTransport transport) @nogc;

-	/**
-	 * Called when a connection is lost.
-	 *
-	 * Params:
-	 * 	exception = $(D_PSYMBOL Exception) if an error caused
-	 * 	            the disconnect, $(D_KEYWORD null) otherwise.
-	 */
-	void disconnected(SocketException exception) @nogc;
+    /**
+     * Called when a connection is lost.
+     *
+     * Params:
+     *  exception = $(D_PSYMBOL Exception) if an error caused
+     *              the disconnect, $(D_KEYWORD null) otherwise.
+     */
+    void disconnected(SocketException exception) @nogc;
 }

 /**
--- a/source/tanya/async/transport.d
+++ b/source/tanya/async/transport.d
@ -32,13 +32,13 @@ interface ReadTransport : Transport
 */
 interface WriteTransport : Transport
 {
-	/**
-	 * Write some data to the transport.
-	 *
-	 * Params:
-	 * 	data = Data to send.
-	 */
-	void write(ubyte[] data) @nogc;
+    /**
+     * Write some data to the transport.
+     *
+     * Params:
+     *  data = Data to send.
+     */
+    void write(ubyte[] data) @nogc;
 }

 /**
@ -46,46 +46,46 @@ interface WriteTransport : Transport
 */
 interface DuplexTransport : ReadTransport, WriteTransport
 {
-	/**
-	 * Returns: Application protocol.
-	 *
-	 * Postcondition: $(D_INLINECODE protocol !is null)
-	 */
-	@property Protocol protocol() pure nothrow @safe @nogc
-	out (protocol)
-	{
-		assert(protocol !is null);
-	}
+    /**
+     * Returns: Application protocol.
+     *
+     * Postcondition: $(D_INLINECODE protocol !is null)
+     */
+    @property Protocol protocol() pure nothrow @safe @nogc
+    out (protocol)
+    {
+        assert(protocol !is null);
+    }

-	/**
-	 * Switches the protocol.
-	 *
-	 * The protocol is deallocated by the event loop, it should currently be
-	 * allocated with $(D_PSYMBOL MmapPool).
-	 *
-	 * Params:
-	 * 	protocol = Application protocol.
-	 *
-	 * Precondition: $(D_INLINECODE protocol !is null)
-	 */
-	@property void protocol(Protocol protocol) pure nothrow @safe @nogc
-	in
-	{
-		assert(protocol !is null);
-	}
+    /**
+     * Switches the protocol.
+     *
+     * The protocol is deallocated by the event loop, it should currently be
+     * allocated with $(D_PSYMBOL MmapPool).
+     *
+     * Params:
+     *  protocol = Application protocol.
+     *
+     * Precondition: $(D_INLINECODE protocol !is null)
+     */
+    @property void protocol(Protocol protocol) pure nothrow @safe @nogc
+    in
+    {
+        assert(protocol !is null);
+    }


-	/**
-	 * Returns $(D_PARAM true) if the transport is closing or closed.
-	 */
-	bool isClosing() const pure nothrow @safe @nogc;
+    /**
+     * Returns $(D_PARAM true) if the transport is closing or closed.
+     */
+    bool isClosing() const pure nothrow @safe @nogc;

-	/**
-	 * Close the transport.
-	 *
-	 * Buffered data will be flushed.  No more data will be received.
-	 */
-	void close() @nogc;
+    /**
+     * Close the transport.
+     *
+     * Buffered data will be flushed.  No more data will be received.
+     */
+    void close() @nogc;
 }

 /**
@ -93,8 +93,8 @@ interface DuplexTransport : ReadTransport, WriteTransport
 */
 interface SocketTransport : Transport
 {
-	/**
-	 * Returns: Socket.
-	 */
-	@property Socket socket() pure nothrow @safe @nogc;
+    /**
+     * Returns: Socket.
+     */
+    @property Socket socket() pure nothrow @safe @nogc;
 }
--- a/source/tanya/async/watcher.d
+++ b/source/tanya/async/watcher.d
@ -27,13 +27,13 @@ import tanya.network.socket;
 */
 abstract class Watcher
 {
-	/// Whether the watcher is active.
-	bool active;
+    /// Whether the watcher is active.
+    bool active;

-	/**
-	 * Invoke some action on event.
-	 */
-	void invoke() @nogc;
+    /**
+     * Invoke some action on event.
+     */
+    void invoke() @nogc;
 }

 /**
@ -41,32 +41,32 @@ abstract class Watcher
 */
 abstract class SocketWatcher : Watcher
 {
-	/// Watched socket.
-	protected Socket socket_;
+    /// Watched socket.
+    protected Socket socket_;

-	/**
-	 * Params:
-	 * 	socket = Socket.
-	 *
-	 * Precondition: $(D_INLINECODE socket !is null)
-	 */
-	this(Socket socket) pure nothrow @safe @nogc
-	in
-	{
-		assert(socket !is null);
-	}
-	body
-	{
-		socket_ = socket;
-	}
+    /**
+     * Params:
+     *  socket = Socket.
+     *
+     * Precondition: $(D_INLINECODE socket !is null)
+     */
+    this(Socket socket) pure nothrow @safe @nogc
+    in
+    {
+        assert(socket !is null);
+    }
+    body
+    {
+        socket_ = socket;
+    }

-	/**
-	 * Returns: Socket.
-	 */
-	@property Socket socket() pure nothrow @safe @nogc
-	{
-		return socket_;
-	}
+    /**
+     * Returns: Socket.
+     */
+    @property Socket socket() pure nothrow @safe @nogc
+    {
+        return socket_;
+    }
 }

 /**
@ -74,44 +74,44 @@ abstract class SocketWatcher : Watcher
 */
 class ConnectionWatcher : SocketWatcher
 {
-	/// Incoming connection queue.
-	Queue!DuplexTransport incoming;
+    /// Incoming connection queue.
+    Queue!DuplexTransport incoming;

-	private Protocol delegate() @nogc protocolFactory;
+    private Protocol delegate() @nogc protocolFactory;

-	/**
-	 * Params:
-	 * 	socket = Socket.
-	 */
-	this(Socket socket) @nogc
-	{
-		super(socket);
-		incoming = Queue!DuplexTransport(MmapPool.instance);
-	}
+    /**
+     * Params:
+     *  socket = Socket.
+     */
+    this(Socket socket) @nogc
+    {
+        super(socket);
+        incoming = Queue!DuplexTransport(MmapPool.instance);
+    }

-	/**
-	 * Params:
-	 * 	P = Protocol should be used.
-	 */
-	void setProtocol(P : Protocol)() @nogc
-	{
-		this.protocolFactory = () @nogc => cast(Protocol) MmapPool.instance.make!P;
-	}
+    /**
+     * Params:
+     *  P = Protocol should be used.
+     */
+    void setProtocol(P : Protocol)() @nogc
+    {
+        this.protocolFactory = () @nogc => cast(Protocol) MmapPool.instance.make!P;
+    }

-	/**
-	 * Invokes new connection callback.
-	 */
-	override void invoke() @nogc
-	in
-	{
-		assert(protocolFactory !is null, "Protocol isn't set.");
-	}
-	body
-	{
-		foreach (transport; incoming)
-		{
-			transport.protocol = protocolFactory();
-			transport.protocol.connected(transport);
-		}
-	}
+    /**
+     * Invokes new connection callback.
+     */
+    override void invoke() @nogc
+    in
+    {
+        assert(protocolFactory !is null, "Protocol isn't set.");
+    }
+    body
+    {
+        foreach (transport; incoming)
+        {
+            transport.protocol = protocolFactory();
+            transport.protocol.connected(transport);
+        }
+    }
 }
--- a/source/tanya/container/array.d
+++ b/source/tanya/container/array.d
--- a/source/tanya/container/buffer.d
+++ b/source/tanya/container/buffer.d
@ -333,9 +333,9 @@ struct WriteBuffer(T = ubyte)

    /**
     * Params:
-     * 	size      = Initial buffer size and the size by which the buffer will
-     * 	            grow.
-     * 	allocator = Allocator.
+     *  size      = Initial buffer size and the size by which the buffer will
+     *              grow.
+     *  allocator = Allocator.
     *
     * Precondition: $(D_INLINECODE size > 0 && allocator !is null)
     */
@ -428,7 +428,7 @@ struct WriteBuffer(T = ubyte)
     * Appends data to the buffer.
     *
     * Params:
-     * 	buffer = Buffer chunk got with $(D_PSYMBOL opIndex).
+     *  buffer = Buffer chunk got with $(D_PSYMBOL opIndex).
     */
    ref WriteBuffer opOpAssign(string op)(in T[] buffer)
        if (op == "~")
@ -535,7 +535,7 @@ struct WriteBuffer(T = ubyte)
     * appropriately. Always call it after $(D_PSYMBOL opIndex).
     *
     * Params:
-     * 	length = Length of the written data.
+     *  length = Length of the written data.
     *
     * Returns: $(D_KEYWORD this).
     */
--- a/source/tanya/container/entry.d
+++ b/source/tanya/container/entry.d
@ -14,9 +14,18 @@ module tanya.container.entry;

 package struct SEntry(T)
 {
-    /// Item content.
+    // Item content.
    T content;

-    /// Next item.
+    // Next item.
    SEntry* next;
 }
+
+package struct DEntry(T)
+{
+    // Item content.
+    T content;
+
+    // Previous and next item.
+    DEntry* next, prev;
+}
--- a/source/tanya/container/list.d
+++ b/source/tanya/container/list.d
--- a/source/tanya/container/package.d
+++ b/source/tanya/container/package.d
@ -12,7 +12,8 @@
 */
 module tanya.container;

+public import tanya.container.array;
 public import tanya.container.buffer;
 public import tanya.container.list;
-public import tanya.container.vector;
+public import tanya.container.string;
 public import tanya.container.queue;
--- a/source/tanya/container/string.d
+++ b/source/tanya/container/string.d
--- a/source/tanya/container/vector.d
+++ b/source/tanya/container/vector.d
--- a/source/tanya/math/mp.d
+++ b/source/tanya/math/mp.d
@ -16,7 +16,7 @@ import std.algorithm;
 import std.ascii;
 import std.range;
 import std.traits;
-import tanya.container.vector;
+import tanya.container.array;
 import tanya.memory;

 /**
@ -160,6 +160,45 @@ struct Integer
        assert(integer == 7383520307673030126);
    }

+    /**
+     * Constructs the integer from a two's complement representation.
+     *
+     * Params:
+     *  R         = Range type.
+     *  value     = Range.
+     *  allocator = Allocator.
+     *
+     * Precondition: $(D_INLINECODE allocator !is null)
+     */
+    this(R)(R value,
+            shared Allocator allocator = defaultAllocator)
+        if (isBidirectionalRange!R && hasLength!R
+         && is(Unqual!(ElementType!R) == ubyte))
+    {
+        this(Sign.positive, value, allocator);
+
+        if (!value.empty && ((value.front & 0x80) != 0))
+        {
+            // Negative number.
+            opOpAssign!"-"(exp2(countBits()));
+        }
+    }
+
+    ///
+    nothrow @safe @nogc unittest
+    {
+        {
+            ubyte[8] range = [ 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xdd, 0xee ];
+            auto integer = Integer(range[]);
+            assert(integer == 7383520307673030126);
+        }
+        {
+            ubyte[8] range = [ 0xe6, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xdd, 0xee ];
+            auto integer = Integer(range[]);
+            assert(integer == -1839851729181745682);
+        }
+    }
+
    /**
     * Copies the integer.
     */
@ -178,12 +217,64 @@ struct Integer
        allocator.resize(this.rep, 0);
    }

+    static private const short[16] bitCounts = [
+        4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0
+    ];
+
+    // Counts the number of LSBs before the first non-zero bit.
+    private ptrdiff_t countLSBs() const pure nothrow @safe @nogc
+    {
+        if (this.size == 0)
+        {
+            return 0;
+        }
+
+        ptrdiff_t bits;
+        for (bits = 0; (bits < this.size) && (this.rep[bits] == 0); ++bits)
+        {
+        }
+        digit nonZero = this.rep[bits];
+        bits *= digitBitCount;
+
+        /* now scan this digit until a 1 is found */
+        if ((nonZero & 0x01) == 0)
+        {
+            digit bitCountsPos;
+            do
+            {
+                bitCountsPos = nonZero & 0x0f;
+                bits += bitCounts[bitCountsPos];
+                nonZero >>= 4;
+            }
+            while (bitCountsPos == 0);
+        }
+        return bits;
+    }
+
    /**
-     * Returns: Integer byte length.
+     * Returns: Number of bytes in the two's complement representation.
     */
    @property size_t length() const pure nothrow @safe @nogc
    {
-        return (countBits() + 7) / 8; // Round up.
+        if (this.sign)
+        {
+            const bc = countBits();
+            auto length = bc + (8 - (bc & 0x07));
+
+            if (((countLSBs() + 1) == bc) && ((bc & 0x07) == 0))
+            {
+                --length;
+            }
+            return length / 8;
+        }
+        else if (this.size == 0)
+        {
+            return 0;
+        }
+        else
+        {
+            return (countBits() / 8) + 1;
+        }
    }

    /**
@ -245,16 +336,10 @@ struct Integer
    ref Integer opAssign(T)(T value) nothrow @safe @nogc
        if (is(T == Integer))
    {
-        if (this.allocator is value.allocator)
-        {
-            swap(this.rep, value.rep);
-            swap(this.sign, value.sign);
-            swap(this.size, value.size);
-        }
-        else
-        {
-            this = value;
-        }
+        swap(this.rep, value.rep);
+        swap(this.sign, value.sign);
+        swap(this.size, value.size);
+        swap(this.allocator_, value.allocator_);
        return this;
    }

@ -1343,79 +1428,72 @@ struct Integer
        return result;
    }

-    Vector!ubyte toVector() const nothrow @safe @nogc
+    // Returns 2^^n.
+    private Integer exp2(size_t n) const nothrow @safe @nogc
    {
-        Vector!ubyte vector;
-        bool firstBit;
-        ubyte carry;
+        auto ret = Integer(allocator);
+        const bytes = n / digitBitCount;
+
+        ret.grow(bytes + 1);
+        ret.size = bytes + 1;
+        ret.rep[bytes] = (cast(digit) 1) << (n % digitBitCount);
+
+        return ret;
+    }
+
+    /**
+     * Returns: Two's complement representation of the integer.
+     */
+    Array!ubyte toArray() const nothrow @safe @nogc
+    out (array)
+    {
+        assert(array.length == length);
+    }
+    body
+    {
+        Array!ubyte array;

        if (this.size == 0)
        {
-            return vector;
+            return array;
        }
-        vector.reserve(this.size * digit.sizeof);
+        const bc = countBits();
+        const remainingBits = bc & 0x07;

-        // The first digit needs extra handling since it can have leading
-        // non significant zeros.
-        int digitCount = digitBitCount - 8;
-        const first = this.rep[this.size - 1];
-        const prevBitCount = ((this.size - 1) * digitBitCount);
-        const fullBytesBitCount = ((prevBitCount - 1) / 8 + 1) * 8;
-
-        // Find out the right alignment of the first byte.
-        if ((fullBytesBitCount - prevBitCount) == 0)
+        array.reserve(bc / 8);
+        if (remainingBits == 0)
        {
-            digitCount -= digit.sizeof * 8 - digitBitCount;
+            array.insertBack(ubyte.init);
+
        }
-        for (; digitCount >= 0; digitCount -= 8)
+
+        Integer tmp;
+        if (this.sign)
        {
-            if (firstBit || ((first >> digitCount) != 0))
+            auto length = bc + (8 - remainingBits);
+
+            if (((countLSBs() + 1) == bc) && (remainingBits == 0))
            {
-                firstBit = true;
-                vector.insertBack(cast(ubyte) (first >> digitCount));
+                length -= 8;
            }
-        }
-        if (digitCount >= -8)
-        {
-            carry = (first << -digitCount) & 0xff;
-            digitCount += digitBitCount;
+
+            tmp = exp2(length) + this;
        }
        else
        {
-            carry = 0;
-            digitCount = digitBitCount - 8;
+            tmp = this;
        }

-        foreach_reverse (d; this.rep[0 .. this.size - 1])
+        do
        {
-            if (carry != 0) // Check the carry from the previous digit.
-            {
-                vector.insertBack(cast(ubyte) (carry | (d >> digitCount)));
-                digitCount -= 8;
-            }
-            // Write the digit by bytes.
-            for (; digitCount >= 0; digitCount -= 8)
-            {
-                vector.insertBack(cast(ubyte) (d >> digitCount));
-            }
-            // Check for an incomplete byte.
-            if (digitCount >= -8)
-            {
-                carry = (d << -digitCount) & 0xff;
-                digitCount += digitBitCount;
-            }
-            else
-            {
-                carry = 0;
-                digitCount = digitBitCount - 8;
-            }
-        }
-        if (carry != 0)
-        {
-            vector.insertBack(cast(ubyte) (carry >> (digitBitCount - digitCount)));
+            array.insertBack(cast(ubyte) (tmp.rep[0] & 0xff));
+            tmp >>= 8;
        }
+        while (tmp != 0);

-        return vector;
+        array[].reverse();
+
+        return array;
    }

    ///
@ -1425,15 +1503,15 @@ struct Integer
            auto integer = Integer(0x66778899aabbddee);
            ubyte[8] expected = [ 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xdd, 0xee ];

-            auto vector = integer.toVector();
-            assert(equal(vector[], expected[]));
+            auto array = integer.toArray();
+            assert(equal(array[], expected[]));
        }
        {
            auto integer = Integer(0x03);
            ubyte[1] expected = [ 0x03 ];

-            auto vector = integer.toVector();
-            assert(equal(vector[], expected[]));
+            auto array = integer.toArray();
+            assert(equal(array[], expected[]));
        }
        {
            ubyte[63] expected = [
@ -1448,8 +1526,8 @@ struct Integer
            ];
            auto integer = Integer(Sign.positive, expected[]);

-            auto vector = integer.toVector();
-            assert(equal(vector[], expected[]));
+            auto array = integer.toArray();
+            assert(equal(array[], expected[]));
        }
        {
            ubyte[14] expected = [
@ -1458,8 +1536,8 @@ struct Integer
            ];
            auto integer = Integer(Sign.positive, expected[]);

-            auto vector = integer.toVector();
-            assert(equal(vector[], expected[]));
+            auto array = integer.toArray();
+            assert(equal(array[], expected[]));
        }
    }

--- a/source/tanya/memory/mmappool.d
+++ b/source/tanya/memory/mmappool.d
--- a/source/tanya/memory/types.d
+++ b/source/tanya/memory/types.d
@ -18,7 +18,19 @@ import std.range;
 import std.traits;
 import tanya.memory;

-package(tanya) final class RefCountedStore(T)
+private template Payload(T)
+{
+    static if (is(T == class) || is(T == interface) || isArray!T)
+    {
+        alias Payload = T;
+    }
+    else
+    {
+        alias Payload = T*;
+    }
+}
+
+final class RefCountedStore(T)
 {
    T payload;
    size_t counter = 1;
@ -34,7 +46,7 @@ package(tanya) final class RefCountedStore(T)
        mixin("return " ~ op ~ "counter;");
    }

-    int opCmp(size_t counter)
+    int opCmp(const size_t counter)
    {
        if (this.counter > counter)
        {
@ -50,7 +62,7 @@ package(tanya) final class RefCountedStore(T)
        }
    }

-    int opEquals(size_t counter)
+    int opEquals(const size_t counter)
    {
        return this.counter == counter;
    }
@ -81,15 +93,7 @@ private void unifiedDeleter(T)(RefCountedStore!T storage,
 */
 struct RefCounted(T)
 {
-    static if (is(T == class) || is(T == interface) || isArray!T)
-    {
-        private alias Payload = T;
-    }
-    else
-    {
-        private alias Payload = T*;
-    }
-    private alias Storage = RefCountedStore!Payload;
+    private alias Storage = RefCountedStore!(Payload!T);

    private Storage storage;
    private void function(Storage storage,
@ -112,13 +116,18 @@ struct RefCounted(T)
     *
     * Precondition: $(D_INLINECODE allocator !is null)
     */
-    this()(auto ref Payload value,
+    this()(auto ref Payload!T value,
           shared Allocator allocator = defaultAllocator)
    {
        this(allocator);
        this.storage = allocator.make!Storage();
-        this.deleter = &separateDeleter!Payload;
+        this.deleter = &separateDeleter!(Payload!T);
+
        move(value, this.storage.payload);
+        static if (__traits(isRef, value))
+        {
+            value = null;
+        }
    }

    /// Ditto.
@ -139,7 +148,7 @@ struct RefCounted(T)
    {
        if (count != 0)
        {
-            ++storage;
+            ++this.storage;
        }
    }

@ -152,7 +161,7 @@ struct RefCounted(T)
    {
        if (this.storage !is null && !(this.storage.counter && --this.storage))
        {
-            deleter(storage, allocator);
+            deleter(this.storage, allocator);
        }
    }

@ -163,34 +172,34 @@ struct RefCounted(T)
     * If it is the last reference of the previously owned object,
     * it will be destroyed.
     *
-     * To reset the $(D_PSYMBOL RefCounted) assign $(D_KEYWORD null).
+     * To reset $(D_PSYMBOL RefCounted) assign $(D_KEYWORD null).
     *
     * If the allocator wasn't set before, $(D_PSYMBOL defaultAllocator) will
     * be used. If you need a different allocator, create a new
     * $(D_PSYMBOL RefCounted) and assign it.
     *
     * Params:
-     *  rhs = $(D_KEYWORD this).
+     *  rhs = New object.
+     *
+     * Returns: $(D_KEYWORD this).
     */
-    ref typeof(this) opAssign()(auto ref Payload rhs)
+    ref typeof(this) opAssign()(auto ref Payload!T rhs)
    {
        if (this.storage is null)
        {
            this.storage = allocator.make!Storage();
-            this.deleter = &separateDeleter!Payload;
+            this.deleter = &separateDeleter!(Payload!T);
        }
        else if (this.storage > 1)
        {
            --this.storage;
            this.storage = allocator.make!Storage();
-            this.deleter = &separateDeleter!Payload;
+            this.deleter = &separateDeleter!(Payload!T);
        }
        else
        {
-            // Created with refCounted. Always destroyed togethter with the pointer.
-            assert(this.storage.counter != 0);
            finalize(this.storage.payload);
-            this.storage.payload = Payload.init;
+            this.storage.payload = Payload!T.init;
        }
        move(rhs, this.storage.payload);
        return this;
@ -206,15 +215,13 @@ struct RefCounted(T)
        else if (this.storage > 1)
        {
            --this.storage;
-            this.storage = null;
        }
        else
        {
-            // Created with refCounted. Always destroyed togethter with the pointer.
-            assert(this.storage.counter != 0);
-            finalize(this.storage.payload);
-            this.storage.payload = Payload.init;
+            deleter(this.storage, allocator);
        }
+        this.storage = null;
+
        return this;
    }

@ -229,8 +236,10 @@ struct RefCounted(T)

    /**
     * Returns: Reference to the owned object.
+     *
+     * Precondition: $(D_INLINECODE cound > 0).
     */
-    inout(Payload) get() inout pure nothrow @safe @nogc
+    Payload!T get() pure nothrow @safe @nogc
    in
    {
        assert(count > 0, "Attempted to access an uninitialized reference.");
@ -240,7 +249,7 @@ struct RefCounted(T)
        return storage.payload;
    }

-    static if (isPointer!Payload)
+    version (D_Ddoc)
    {
        /**
         * Params:
@ -251,6 +260,11 @@ struct RefCounted(T)
         *
         * Returns: Reference to the pointed value.
         */
+        ref T opUnary(string op)()
+            if (op == "*");
+    }
+    else static if (isPointer!(Payload!T))
+    {
        ref T opUnary(string op)()
            if (op == "*")
        {
@ -352,6 +366,44 @@ private unittest
    assert(rc.count == 1);
 }

+private unittest
+{
+    auto rc = defaultAllocator.refCounted!int(5);
+    assert(rc.count == 1);
+
+    void func(RefCounted!int rc)
+    {
+        assert(rc.count == 2);
+        rc = null;
+        assert(!rc.isInitialized);
+        assert(rc.count == 0);
+    }
+
+    assert(rc.count == 1);
+    func(rc);
+    assert(rc.count == 1);
+
+    rc = null;
+    assert(!rc.isInitialized);
+    assert(rc.count == 0);
+}
+
+private unittest
+{
+    auto rc = defaultAllocator.refCounted!int(5);
+    assert(*rc == 5);
+
+    void func(RefCounted!int rc)
+    {
+        assert(rc.count == 2);
+        rc = defaultAllocator.refCounted!int(4);
+        assert(*rc == 4);
+        assert(rc.count == 1);
+    }
+    func(rc);
+    assert(*rc == 5);
+}
+
 private unittest
 {
    static assert(is(typeof(RefCounted!int.storage.payload) == int*));
@ -414,13 +466,13 @@ body
        auto ptr = (() @trusted => (cast(T*) mem[storageSize .. $].ptr))();
        rc.storage.payload = emplace!T(ptr, args);
    }
-    rc.deleter = &unifiedDeleter!(RefCounted!T.Payload);
+    rc.deleter = &unifiedDeleter!(Payload!T);
    return rc;
 }

 /**
 * Constructs a new array with $(D_PARAM size) elements and wraps it in a
- * $(D_PSYMBOL RefCounted) using.
+ * $(D_PSYMBOL RefCounted).
 *
 * Params:
 *  T         = Array type.
@ -432,7 +484,8 @@ body
 * Precondition: $(D_INLINECODE allocator !is null
 *                           && size <= size_t.max / ElementType!T.sizeof)
 */
- RefCounted!T refCounted(T)(shared Allocator allocator, const size_t size)
+RefCounted!T refCounted(T)(shared Allocator allocator, const size_t size)
+@trusted
    if (isArray!T)
 in
 {
@ -441,8 +494,7 @@ in
 }
 body
 {
-    auto payload = cast(T) allocator.allocate(ElementType!T.sizeof * size);
-    initializeAll(payload);
+    auto payload = allocator.resize!(ElementType!T)(null, size);
    return RefCounted!T(payload, allocator);
 }

@ -495,3 +547,266 @@ private @nogc unittest
    auto rc = defaultAllocator.refCounted!(int[])(5);
    assert(rc.length == 5);
 }
+
+private @nogc unittest
+{
+    static bool destroyed = false;
+
+    struct F
+    {
+        ~this() @nogc
+        {
+            destroyed = true;
+        }
+    }
+    {
+        auto rc = defaultAllocator.refCounted!F();
+    }
+    assert(destroyed);
+}
+
+/**
+ * $(D_PSYMBOL Scoped) stores an object that gets destroyed at the end of its scope.
+ *
+ * Params:
+ *  T = Value type.
+ */
+struct Scoped(T)
+{
+    private Payload!T payload;
+
+    invariant
+    {
+        assert(payload is null || allocator_ !is null);
+    }
+
+    /**
+     * Takes ownership over $(D_PARAM value), setting the counter to 1.
+     * $(D_PARAM value) may be a pointer, an object or a dynamic array.
+     *
+     * Params:
+     *  value     = Value whose ownership is taken over.
+     *  allocator = Allocator used to destroy the $(D_PARAM value) and to
+     *              allocate/deallocate internal storage.
+     *
+     * Precondition: $(D_INLINECODE allocator !is null)
+     */
+    this()(auto ref Payload!T value,
+           shared Allocator allocator = defaultAllocator)
+    {
+        this(allocator);
+
+        move(value, this.payload);
+        static if (__traits(isRef, value))
+        {
+            value = null;
+        }
+    }
+
+    /// Ditto.
+    this(shared Allocator allocator)
+    in
+    {
+        assert(allocator !is null);
+    }
+    body
+    {
+        this.allocator_ = allocator;
+    }
+
+    /**
+     * $(D_PSYMBOL Scoped) is noncopyable.
+     */
+    @disable this(this);
+
+    /**
+     * Destroys the owned object.
+     */
+    ~this()
+    {
+        if (this.payload !is null)
+        {
+            allocator.dispose(this.payload);
+        }
+    }
+
+    /**
+     * Initialized this $(D_PARAM Scoped) and takes ownership over
+     * $(D_PARAM rhs).
+     *
+     * To reset $(D_PSYMBOL Scoped) assign $(D_KEYWORD null).
+     *
+     * If the allocator wasn't set before, $(D_PSYMBOL defaultAllocator) will
+     * be used. If you need a different allocator, create a new
+     * $(D_PSYMBOL Scoped) and assign it.
+     *
+     * Params:
+     *  rhs = New object.
+     *
+     * Returns: $(D_KEYWORD this).
+     */
+    ref typeof(this) opAssign()(auto ref Payload!T rhs)
+    {
+        allocator.dispose(this.payload);
+        move(rhs, this.payload);
+
+        return this;
+    }
+
+    /// Ditto.
+    ref typeof(this) opAssign(typeof(null))
+    {
+        allocator.dispose(this.payload);
+        return this;
+    }
+
+    /// Ditto.
+    ref typeof(this) opAssign(typeof(this) rhs)
+    {
+        swap(this.allocator_, rhs.allocator_);
+        swap(this.payload, rhs.payload);
+
+        return this;
+    }
+
+    /**
+     * Returns: Reference to the owned object.
+     */
+    Payload!T get() pure nothrow @safe @nogc
+    {
+        return payload;
+    }
+
+    version (D_Ddoc)
+    {
+        /**
+         * Params:
+         *  op = Operation. 
+         *
+         * Dereferences the pointer. It is defined only for pointers, not for
+         * reference types like classes, that can be accessed directly.
+         *
+         * Returns: Reference to the pointed value.
+         */
+        ref T opUnary(string op)()
+            if (op == "*");
+    }
+    else static if (isPointer!(Payload!T))
+    {
+        ref T opUnary(string op)()
+            if (op == "*")
+        {
+            return *payload;
+        }
+    }
+
+    mixin DefaultAllocator;
+    alias get this;
+}
+
+///
+@nogc unittest
+{
+    auto p = defaultAllocator.make!int(5);
+    auto s = Scoped!int(p, defaultAllocator);
+    assert(p is null);
+    assert(*s == 5);
+}
+
+///
+@nogc unittest
+{
+    static bool destroyed = false;
+
+    struct F
+    {
+        ~this() @nogc
+        {
+            destroyed = true;
+        }
+    }
+    {
+        auto s = Scoped!F(defaultAllocator.make!F(), defaultAllocator);
+    }
+    assert(destroyed);
+}
+
+/**
+ * Constructs a new object of type $(D_PARAM T) and wraps it in a
+ * $(D_PSYMBOL Scoped) using $(D_PARAM args) as the parameter list for
+ * the constructor of $(D_PARAM T).
+ *
+ * Params:
+ *  T         = Type of the constructed object.
+ *  A         = Types of the arguments to the constructor of $(D_PARAM T).
+ *  allocator = Allocator.
+ *  args      = Constructor arguments of $(D_PARAM T).
+ * 
+ * Returns: Newly created $(D_PSYMBOL Scoped!T).
+ *
+ * Precondition: $(D_INLINECODE allocator !is null)
+ */
+Scoped!T scoped(T, A...)(shared Allocator allocator, auto ref A args)
+    if (!is(T == interface) && !isAbstractClass!T
+     && !isAssociativeArray!T && !isArray!T)
+in
+{
+    assert(allocator !is null);
+}
+body
+{
+    auto payload = allocator.make!(T, shared Allocator, A)(args);
+    return Scoped!T(payload, allocator);
+}
+
+/**
+ * Constructs a new array with $(D_PARAM size) elements and wraps it in a
+ * $(D_PSYMBOL Scoped).
+ *
+ * Params:
+ *  T         = Array type.
+ *  size      = Array size.
+ *  allocator = Allocator.
+ *
+ * Returns: Newly created $(D_PSYMBOL Scoped!T).
+ *
+ * Precondition: $(D_INLINECODE allocator !is null
+ *                           && size <= size_t.max / ElementType!T.sizeof)
+ */
+Scoped!T scoped(T)(shared Allocator allocator, const size_t size)
+@trusted
+    if (isArray!T)
+in
+{
+    assert(allocator !is null);
+    assert(size <= size_t.max / ElementType!T.sizeof);
+}
+body
+{
+    auto payload = allocator.resize!(ElementType!T)(null, size);
+    return Scoped!T(payload, allocator);
+}
+
+private unittest
+{
+    static assert(is(typeof(defaultAllocator.scoped!B(5))));
+    static assert(is(typeof(defaultAllocator.scoped!(int[])(5))));
+}
+
+private unittest
+{
+    auto s = defaultAllocator.scoped!int(5);
+    assert(*s == 5);
+
+    s = null;
+    assert(s is null);
+}
+
+private unittest
+{
+    auto s = defaultAllocator.scoped!int(5);
+    assert(*s == 5);
+
+    s = defaultAllocator.scoped!int(4);
+    assert(*s == 4);
+}
Author	SHA1	Message	Date
Eugen Wissner	a648e2120a	Fix parameter count for docs in container.string	2017-05-19 20:01:04 +02:00
Eugen Wissner	bc61809050	Implement DList.insertBack	2017-05-16 13:16:18 +02:00
Eugen Wissner	8c42cbfd63	Rename Vector to Array For consistency with Phobos.	2017-05-16 12:12:57 +02:00
Eugen Wissner	58664570f9	Add new branch, add DList to package description	2017-05-15 20:09:32 +02:00
Eugen Wissner	decb82f437	Remove crypto.mac for now It wasn't released yet and needs some work.	2017-05-15 19:57:36 +02:00
Eugen Wissner	357c7e279d	Add doubly-linked list DList is an adjusted copy of SList. Missing: * insertBack * insertAfter * removeBack	2017-05-15 19:50:20 +02:00
Eugen Wissner	32e19c8b58	Rename String.get into toString. Add String.toStringz	2017-05-14 11:56:57 +02:00
Eugen Wissner	f5c6c5b483	Add Payload template for memory.types	2017-05-13 08:43:49 +02:00
Eugen Wissner	ba2d086fb8	Add memory.types.Scoped	2017-05-13 08:27:51 +02:00
Eugen Wissner	7a0241b484	Fix unittest text for strings	2017-05-12 22:42:43 +02:00
Eugen Wissner	36dad80e18	Use char ranges to avoid compilation errors on elder compilers	2017-05-12 21:46:48 +02:00
Eugen Wissner	29d883150e	Fix unittests on 2.072 and 2.071	2017-05-12 21:10:22 +02:00
Eugen Wissner	e2bed0cfcb	Replace tabs with spaces in mmappool and buffer	2017-05-12 21:02:24 +02:00
Eugen Wissner	38afeac071	Insert String.insertFront and String.insertBack	2017-05-12 20:55:42 +02:00
Eugen Wissner	001c7c3e33	Replace immutable with const in Vector	2017-05-12 20:35:16 +02:00
Eugen Wissner	d4ab339feb	Add String.remove	2017-05-12 20:23:16 +02:00
Eugen Wissner	8477312769	Add editorconfig	2017-05-11 13:57:24 +02:00
Eugen Wissner	67f90e137d	Add codecov badge	2017-05-11 13:15:04 +02:00
Eugen Wissner	f264fd5597	Generate unittest coverage information	2017-05-11 13:11:12 +02:00
Eugen Wissner	9e75620f1b	Fix appveyor branch badges	2017-05-11 07:05:13 +02:00
Eugene Wissner	45825946c0	Appveyor (#10 ) * Add appveyor.yml * Try major VC version * Switch to VC 2015 * Try new version * Try enterprise * Try another path * Change VC template * Set arch * Set LINKCMD64 * Fix quotes * Update LINKCMD64 * remove dir * Update arch * Fix syntax * Set arch to x64 * Remove extra dub downloading * Remove dub version * Download dub for 2.071.2 * Use DVersion * Fix nul in powershell * Put quotes to commands * Add badges	2017-05-11 06:26:59 +02:00
Eugen Wissner	8afb552d59	mp.Integer: add two's complement constructor	2017-05-10 19:27:25 +02:00
Eugen Wissner	e4091669f8	Add information about io branch	2017-05-10 13:18:58 +02:00
Eugen Wissner	1cb9349226	math.mp.Integer.toVector return two's complement	2017-05-09 06:27:30 +02:00
Eugen Wissner	06620dc5df	math.mp.Integer: Return two's complement length	2017-05-08 21:09:52 +02:00
Eugen Wissner	708d95db49	Remove utf8string branch	2017-05-06 11:55:20 +02:00
Eugen Wissner	85d9361bfb	Fix fill with char on older compilers	2017-05-05 07:03:16 +02:00
Eugen Wissner	a6a6f496eb	Implement string slice assignments	2017-05-04 23:17:50 +02:00
Eugen Wissner	db12f03264	Merge branch 'master' into utf8string	2017-05-03 19:15:13 +02:00
Eugen Wissner	231aedb8ad	Add HMAC	2017-05-03 19:05:23 +02:00
Eugen Wissner	c3b63ee40d	Merge branch 'master' into utf8string	2017-05-02 10:59:00 +02:00
Eugen Wissner	6f405c5e08	Make Vector's opSliceAssign accept only own ranges Vector.opSliceAssign and Vector.opIndexAssign should accept only vector ranges. For assigning other ranges, std.algorithm.mutation.copy and std.algorithm.mutation.fill should be used.	2017-05-02 10:56:32 +02:00
Eugen Wissner	16cf8478cf	Add ByCodePoint	2017-05-01 20:17:37 +02:00
Eugen Wissner	8915a0c7a7	Implement opCmp and opEquals for the String	2017-05-01 18:43:12 +02:00
Eugen Wissner	e5c7edb72c	Implement String opAssign	2017-05-01 12:58:37 +02:00
Eugen Wissner	64e0d666ed	Merge branch 'master' of github.com:caraus-ecms/tanya into utf8string	2017-05-01 09:59:29 +02:00
Eugen Wissner	f2aac680c5	Fix container ctors and opAssign ref parameters Container constructors and opAssign should accept any ref container and not only const, otherwise the source container will be copied because the constructor/opAssign without ref would be a better match.	2017-05-01 09:48:12 +02:00
Eugen Wissner	d629525a4b	Make String to be a char Slice alias	2017-04-21 14:03:20 +02:00
Eugen Wissner	33d321f0d7	Merge branch 'master' into utf8string	2017-04-20 17:32:59 +02:00
Eugen Wissner	3d64d59ba9	Merge branch 'master' of github.com:caraus-ecms/tanya	2017-04-20 17:32:29 +02:00
Eugen Wissner	4635835a99	Rename Vector range to Slice	2017-04-20 17:32:16 +02:00
Eugen Wissner	8725ec5f20	Make Integer representation little endian	2017-04-19 13:49:44 +02:00
Eugen Wissner	9a4c8cea06	Merge branch 'master' into utf8string	2017-04-16 20:52:40 +02:00
Eugen Wissner	eb360bda38	Add unittest to check RefCounted calles struct destructors	2017-04-16 20:52:24 +02:00
Eugen Wissner	4b1cd2cbfd	Merge branch 'master' into utf8string	2017-04-16 20:15:11 +02:00
Eugen Wissner	cd944a61b7	Merge remote-tracking branch 'origin/master' into utf8string	2017-04-13 16:03:00 +02:00
Eugen Wissner	47ef787353	Add missing constructors to the String	2017-04-10 08:10:08 +02:00
Eugen Wissner	6436ad49df	Add ByteRange to the String	2017-04-08 17:44:08 +02:00
Eugen Wissner	e1964e47a5	Merge branch 'master' into utf8string	2017-04-08 08:44:21 +02:00
Eugen Wissner	43319e4e3a	Initialization from a UTF-16 string	2017-02-27 11:27:24 +01:00
Eugen Wissner	33dbf042c2	Add dchar constructor	2017-02-26 22:40:27 +01:00
Eugen Wissner	885fca9b5e	Add String.reserve and shrink	2017-02-20 12:01:15 +01:00
Eugen Wissner	074d027629	Merge branch 'master' into utf8string	2017-02-20 08:02:01 +01:00
Eugen Wissner	f4b90d8b51	Add string skeleton	2017-02-10 19:22:46 +01:00