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
29 changed files with 9800 additions and 6200 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
@ -7,14 +7,17 @@ os:
 language: d
 d:
 - dmd-2.074.0
 - dmd-2.073.2
 - dmd-2.072.2
 - dmd-2.071.2
 - dmd-2.070.2
 env: 
 matrix:
  - 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,32 +23,32 @@ 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
-* dmd 2.073.2
+| dmd     |
-* dmd 2.072.2
+|:-------:|
-* dmd 2.071.2
+| 2.074.0 |
-* dmd 2.070.2
+| 2.073.2 |
 | 2.072.2 |
 | 2.071.2 |
 ### Current status
-The library is currently under development, but the API is becoming gradually
+Following modules are under development:
 stable.
-`container`s are being extended to support ranges. Also following modules are
+| Feature      | Branch       | Build status                                                                                                                                                                                                                                                                                                 |
-coming soon:
+|--------------|:------------:|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-* UTF-8 string.
+| 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)                |
-* Hash table.
+| 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)                                                   |
-`math` package contains an arbitrary precision integer implementation that
+| 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) |
 needs more test cases, better performance and some additional features
 (constructing from a string and an ubyte array, and converting it back).
 ### Further characteristics
@ -57,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_create1(int flags);
-	int epoll_ctl (int epfd, int op, int fd, epoll_event *event);
+    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_wait (int epfd, epoll_event *events, int maxevents, int timeout);
 }
 final class EpollLoop : SelectorLoop
 {
-	protected int fd;
+    protected int fd;
-	private Vector!epoll_event events;
+    private Array!epoll_event events;
-	/**
+    /**
-	 * Initializes the loop.
+     * Initializes the loop.
-	 */
+     */
-	this() @nogc
+    this() @nogc
-	{
+    {
-		if ((fd = epoll_create1(EPOLL_CLOEXEC)) < 0)
+        if ((fd = epoll_create1(EPOLL_CLOEXEC)) < 0)
-		{
+        {
-			throw defaultAllocator.make!BadLoopException("epoll initialization failed");
+            throw defaultAllocator.make!BadLoopException("epoll initialization failed");
-		}
+        }
-		super();
+        super();
-		events = Vector!epoll_event(maxEvents, MmapPool.instance);
+        events = Array!epoll_event(maxEvents, MmapPool.instance);
-	}
+    }
-	/**
+    /**
-	 * Frees loop internals.
+     * Frees loop internals.
-	 */
+     */
-	~this() @nogc
+    ~this() @nogc
-	{
+    {
-		close(fd);
+        close(fd);
-	}
+    }
-	/**
+    /**
-	 * Should be called if the backend configuration changes.
+     * Should be called if the backend configuration changes.
-	 *
+     *
-	 * Params:
+     * Params:
-	 * 	watcher   = Watcher.
+     *  watcher   = Watcher.
-	 * 	oldEvents = The events were already set.
+     *  oldEvents = The events were already set.
-	 * 	events    = The events should be set.
+     *  events    = The events should be set.
-	 *
+     *
-	 * Returns: $(D_KEYWORD true) if the operation was successful.
+     * Returns: $(D_KEYWORD true) if the operation was successful.
-	 */
+     */
-	protected override bool reify(SocketWatcher watcher,
+    protected override bool reify(SocketWatcher watcher,
-	                              EventMask oldEvents,
+                                  EventMask oldEvents,
-	                              EventMask events) @nogc
+                                  EventMask events) @nogc
-	{
+    {
-		int op = EPOLL_CTL_DEL;
+        int op = EPOLL_CTL_DEL;
-		epoll_event ev;
+        epoll_event ev;
-		if (events == oldEvents)
+        if (events == oldEvents)
-		{
+        {
-			return true;
+            return true;
-		}
+        }
-		if (events && oldEvents)
+        if (events && oldEvents)
-		{
+        {
-			op = EPOLL_CTL_MOD;
+            op = EPOLL_CTL_MOD;
-		}
+        }
-		else if (events && !oldEvents)
+        else if (events && !oldEvents)
-		{
+        {
-			op = EPOLL_CTL_ADD;
+            op = EPOLL_CTL_ADD;
-		}
+        }
-		ev.data.fd = watcher.socket.handle;
+        ev.data.fd = watcher.socket.handle;
-		ev.events = (events & (Event.read | Event.accept) ? EPOLLIN | EPOLLPRI : 0)
+        ev.events = (events & (Event.read | Event.accept) ? EPOLLIN | EPOLLPRI : 0)
-		          | (events & Event.write ? EPOLLOUT : 0)
+                  | (events & Event.write ? EPOLLOUT : 0)
-		          | EPOLLET;
+                  | 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.
+     * Does the actual polling.
-	 */
+     */
-	protected override void poll() @nogc
+    protected override void poll() @nogc
-	{
+    {
-		// Don't block
+        // Don't block
-		immutable timeout = cast(immutable int) blockTime.total!"msecs";
+        immutable timeout = cast(immutable int) blockTime.total!"msecs";
-		auto eventCount = epoll_wait(fd, events.get().ptr, maxEvents, timeout);
+        auto eventCount = epoll_wait(fd, events.get().ptr, maxEvents, timeout);
-		if (eventCount < 0)
+        if (eventCount < 0)
-		{
+        {
-			if (errno != EINTR)
+            if (errno != EINTR)
-			{
+            {
-				throw defaultAllocator.make!BadLoopException();
+                throw defaultAllocator.make!BadLoopException();
-			}
+            }
-			return;
+            return;
-		}
+        }
-		for (auto i = 0; i < eventCount; ++i)
+        for (auto i = 0; i < eventCount; ++i)
-		{
+        {
-			auto transport = cast(StreamTransport) connections[events[i].data.fd];
+            auto transport = cast(StreamTransport) connections[events[i].data.fd];
-			if (transport is null)
+            if (transport is null)
-			{
+            {
-				auto connection = cast(ConnectionWatcher) connections[events[i].data.fd];
+                auto connection = cast(ConnectionWatcher) connections[events[i].data.fd];
-				assert(connection !is null);
+                assert(connection !is null);
-				acceptConnections(connection);
+                acceptConnections(connection);
-			}
+            }
-			else if (events[i].events & EPOLLERR)
+            else if (events[i].events & EPOLLERR)
-			{
+            {
-				kill(transport);
+                kill(transport);
-				continue;
+                continue;
-			}
+            }
-			else if (events[i].events & (EPOLLIN | EPOLLPRI | EPOLLHUP))
+            else if (events[i].events & (EPOLLIN | EPOLLPRI | EPOLLHUP))
-			{
+            {
-				SocketException exception;
+                SocketException exception;
-				try
+                try
-				{
+                {
-					ptrdiff_t received;
+                    ptrdiff_t received;
-					do
+                    do
-					{
+                    {
-						received = transport.socket.receive(transport.output[]);
+                        received = transport.socket.receive(transport.output[]);
-						transport.output += received;
+                        transport.output += received;
-					}
+                    }
-					while (received);
+                    while (received);
-				}
+                }
-				catch (SocketException e)
+                catch (SocketException e)
-				{
+                {
-					exception = e;
+                    exception = e;
-				}
+                }
-				if (transport.socket.disconnected)
+                if (transport.socket.disconnected)
-				{
+                {
-					kill(transport, exception);
+                    kill(transport, exception);
-					continue;
+                    continue;
-				}
+                }
-				else if (transport.output.length)
+                else if (transport.output.length)
-				{
+                {
-					pendings.enqueue(transport);
+                    pendings.enqueue(transport);
-				}
+                }
-			}
+            }
-			if (events[i].events & EPOLLOUT)
+            if (events[i].events & EPOLLOUT)
-			{
+            {
-				transport.writeReady = true;
+                transport.writeReady = true;
-				if (transport.input.length)
+                if (transport.input.length)
-				{
+                {
-					feed(transport);
+                    feed(transport);
-				}
+                }
-			}
+            }
-		}
+        }
-	}
+    }
-	/**
+    /**
-	 * Returns: The blocking time.
+     * Returns: The blocking time.
-	 */
+     */
-	override protected @property inout(Duration) blockTime()
+    override protected @property inout(Duration) blockTime()
-	inout @safe pure nothrow
+    inout @safe pure nothrow
-	{
+    {
-		return min(super.blockTime, 1.dur!"seconds");
+        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.
+     * Creates new completion port transport.
-	 *
+     *
-	 * Params:
+     * Params:
-	 * 	socket = Socket.
+     *  socket = Socket.
-	 *
+     *
-	 * Precondition: $(D_INLINECODE socket !is null)
+     * Precondition: $(D_INLINECODE socket !is null)
-	 */
+     */
-	this(OverlappedConnectedSocket socket) @nogc
+    this(OverlappedConnectedSocket socket) @nogc
-	{
+    {
-		super(socket);
+        super(socket);
-		output = ReadBuffer!ubyte(8192, 1024, MmapPool.instance);
+        output = ReadBuffer!ubyte(8192, 1024, MmapPool.instance);
-		input = WriteBuffer!ubyte(8192, MmapPool.instance);
+        input = WriteBuffer!ubyte(8192, MmapPool.instance);
-		active = true;
+        active = true;
-	}
+    }
-	/**
+    /**
-	 * Returns: Socket.
+     * Returns: Socket.
-	 *
+     *
-	 * Postcondition: $(D_INLINECODE socket !is null)
+     * Postcondition: $(D_INLINECODE socket !is null)
-	 */
+     */
-	override @property OverlappedConnectedSocket socket() pure nothrow @safe @nogc
+    override @property OverlappedConnectedSocket socket() pure nothrow @safe @nogc
-	out (socket)
+    out (socket)
-	{
+    {
-		assert(socket !is null);
+        assert(socket !is null);
-	}
+    }
-	body
+    body
-	{
+    {
-		return cast(OverlappedConnectedSocket) socket_;
+        return cast(OverlappedConnectedSocket) socket_;
-	}
+    }
-	/**
+    /**
-	 * Returns $(D_PARAM true) if the transport is closing or closed.
+     * Returns $(D_PARAM true) if the transport is closing or closed.
-	 */
+     */
-	bool isClosing() const pure nothrow @safe @nogc
+    bool isClosing() const pure nothrow @safe @nogc
-	{
+    {
-		return closing;
+        return closing;
-	}
+    }
-	/**
+    /**
-	 * Close the transport.
+     * Close the transport.
-	 *
+     *
-	 * Buffered data will be flushed.  No more data will be received.
+     * Buffered data will be flushed.  No more data will be received.
-	 */
+     */
-	void close() pure nothrow @safe @nogc
+    void close() pure nothrow @safe @nogc
-	{
+    {
-		closing = true;
+        closing = true;
-	}
+    }
-	/**
+    /**
-	 * Write some data to the transport.
+     * Write some data to the transport.
-	 *
+     *
-	 * Params:
+     * Params:
-	 * 	data = Data to send.
+     *  data = Data to send.
-	 */
+     */
-	void write(ubyte[] data) @nogc
+    void write(ubyte[] data) @nogc
-	{
+    {
-		input ~= data;
+        input ~= data;
-	}
+    }
-	/**
+    /**
-	 * Returns: Application protocol.
+     * Returns: Application protocol.
-	 */
+     */
-	@property Protocol protocol() pure nothrow @safe @nogc
+    @property Protocol protocol() pure nothrow @safe @nogc
-	{
+    {
-		return protocol_;
+        return protocol_;
-	}
+    }
-	/**
+    /**
-	 * Switches the protocol.
+     * Switches the protocol.
-	 *
+     *
-	 * The protocol is deallocated by the event loop, it should currently be
+     * The protocol is deallocated by the event loop, it should currently be
-	 * allocated with $(D_PSYMBOL MmapPool).
+     * allocated with $(D_PSYMBOL MmapPool).
-	 *
+     *
-	 * Params:
+     * Params:
-	 * 	protocol = Application protocol.
+     *  protocol = Application protocol.
-	 *
+     *
-	 * Precondition: $(D_INLINECODE protocol !is null)
+     * Precondition: $(D_INLINECODE protocol !is null)
-	 */
+     */
-	@property void protocol(Protocol protocol) pure nothrow @safe @nogc
+    @property void protocol(Protocol protocol) pure nothrow @safe @nogc
-	in
+    in
-	{
+    {
-		assert(protocol !is null);
+        assert(protocol !is null);
-	}
+    }
-	body
+    body
-	{
+    {
-		protocol_ = protocol;
+        protocol_ = protocol;
-	}
+    }
-	/**
+    /**
-	 * Invokes the watcher callback.
+     * Invokes the watcher callback.
-	 */
+     */
-	override void invoke() @nogc
+    override void invoke() @nogc
-	{
+    {
-		if (output.length)
+        if (output.length)
-		{
+        {
-			immutable empty = input.length == 0;
+            immutable empty = input.length == 0;
-			protocol.received(output[0 .. $]);
+            protocol.received(output[0 .. $]);
-			output.clear();
+            output.clear();
-			if (empty)
+            if (empty)
-			{
+            {
-				SocketState overlapped;
+                SocketState overlapped;
-				try
+                try
-				{
+                {
-					overlapped = MmapPool.instance.make!SocketState;
+                    overlapped = MmapPool.instance.make!SocketState;
-					socket.beginSend(input[], overlapped);
+                    socket.beginSend(input[], overlapped);
-				}
+                }
-				catch (SocketException e)
+                catch (SocketException e)
-				{
+                {
-					MmapPool.instance.dispose(overlapped);
+                    MmapPool.instance.dispose(overlapped);
-					MmapPool.instance.dispose(e);
+                    MmapPool.instance.dispose(e);
-				}
+                }
-			}
+            }
-		}
+        }
-		else
+        else
-		{
+        {
-			protocol.disconnected(exception);
+            protocol.disconnected(exception);
-			MmapPool.instance.dispose(protocol_);
+            MmapPool.instance.dispose(protocol_);
-			defaultAllocator.dispose(exception);
+            defaultAllocator.dispose(exception);
-			active = false;
+            active = false;
-		}
+        }
-	}
+    }
 }
 final class IOCPLoop : Loop
 {
-	protected HANDLE completionPort;
+    protected HANDLE completionPort;
-	protected OVERLAPPED overlap;
+    protected OVERLAPPED overlap;
-	/**
+    /**
-	 * Initializes the loop.
+     * Initializes the loop.
-	 */
+     */
-	this() @nogc
+    this() @nogc
-	{
+    {
-		super();
+        super();
-		completionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
+        completionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
-		if (!completionPort)
+        if (!completionPort)
-		{
+        {
-			throw make!BadLoopException(defaultAllocator,
+            throw make!BadLoopException(defaultAllocator,
-			                            "Creating completion port failed");
+                                        "Creating completion port failed");
-		}
+        }
-	}
+    }
-	/**
+    /**
-	 * Should be called if the backend configuration changes.
+     * Should be called if the backend configuration changes.
-	 *
+     *
-	 * Params:
+     * Params:
-	 * 	watcher   = Watcher.
+     *  watcher   = Watcher.
-	 * 	oldEvents = The events were already set.
+     *  oldEvents = The events were already set.
-	 * 	events    = The events should be set.
+     *  events    = The events should be set.
-	 *
+     *
-	 * Returns: $(D_KEYWORD true) if the operation was successful.
+     * Returns: $(D_KEYWORD true) if the operation was successful.
-	 */
+     */
-	override protected bool reify(SocketWatcher watcher,
+    override protected bool reify(SocketWatcher watcher,
-								  EventMask oldEvents,
+                                  EventMask oldEvents,
-								  EventMask events) @nogc
+                                  EventMask events) @nogc
-	{
+    {
-		SocketState overlapped;
+        SocketState overlapped;
-		if (!(oldEvents & Event.accept) && (events & Event.accept))
+        if (!(oldEvents & Event.accept) && (events & Event.accept))
-		{
+        {
-			auto socket = cast(OverlappedStreamSocket) watcher.socket;
+            auto socket = cast(OverlappedStreamSocket) watcher.socket;
-			assert(socket !is null);
+            assert(socket !is null);
-			if (CreateIoCompletionPort(cast(HANDLE) socket.handle,
+            if (CreateIoCompletionPort(cast(HANDLE) socket.handle,
-									   completionPort,
+                                       completionPort,
-									   cast(ULONG_PTR) (cast(void*) watcher),
+                                       cast(ULONG_PTR) (cast(void*) watcher),
-									   0) !is completionPort)
+                                       0) !is completionPort)
-			{
+            {
-				return false;
+                return false;
-			}
+            }
-			try
+            try
-			{
+            {
-				overlapped = MmapPool.instance.make!SocketState;
+                overlapped = MmapPool.instance.make!SocketState;
-				socket.beginAccept(overlapped);
+                socket.beginAccept(overlapped);
-			}
+            }
-			catch (SocketException e)
+            catch (SocketException e)
-			{
+            {
-				MmapPool.instance.dispose(overlapped);
+                MmapPool.instance.dispose(overlapped);
-				defaultAllocator.dispose(e);
+                defaultAllocator.dispose(e);
-				return false;
+                return false;
-			}
+            }
-		}
+        }
-		if (!(oldEvents & Event.read) && (events & Event.read)
+        if (!(oldEvents & Event.read) && (events & Event.read)
-			|| !(oldEvents & Event.write) && (events & Event.write))
+            || !(oldEvents & Event.write) && (events & Event.write))
-		{
+        {
-			auto transport = cast(StreamTransport) watcher;
+            auto transport = cast(StreamTransport) watcher;
-			assert(transport !is null);
+            assert(transport !is null);
-			if (CreateIoCompletionPort(cast(HANDLE) transport.socket.handle,
+            if (CreateIoCompletionPort(cast(HANDLE) transport.socket.handle,
-									   completionPort,
+                                       completionPort,
-									   cast(ULONG_PTR) (cast(void*) watcher),
+                                       cast(ULONG_PTR) (cast(void*) watcher),
-									   0) !is completionPort)
+                                       0) !is completionPort)
-			{
+            {
-				return false;
+                return false;
-			}
+            }
-			// Begin to read
+            // Begin to read
-			if (!(oldEvents & Event.read) && (events & Event.read))
+            if (!(oldEvents & Event.read) && (events & Event.read))
-			{
+            {
-				try
+                try
-				{
+                {
-					overlapped = MmapPool.instance.make!SocketState;
+                    overlapped = MmapPool.instance.make!SocketState;
-					transport.socket.beginReceive(transport.output[], overlapped);
+                    transport.socket.beginReceive(transport.output[], overlapped);
-				}
+                }
-				catch (SocketException e)
+                catch (SocketException e)
-				{
+                {
-					MmapPool.instance.dispose(overlapped);
+                    MmapPool.instance.dispose(overlapped);
-					defaultAllocator.dispose(e);
+                    defaultAllocator.dispose(e);
-					return false;
+                    return false;
-				}
+                }
-			}
+            }
-		}
+        }
-		return true;
+        return true;
-	}
+    }
-	private void kill(StreamTransport transport,
+    private void kill(StreamTransport transport,
-	                  SocketException exception = null) @nogc
+                      SocketException exception = null) @nogc
-	in
+    in
-	{
+    {
-		assert(transport !is null);
+        assert(transport !is null);
-	}
+    }
-	body
+    body
-	{
+    {
-		transport.socket.shutdown();
+        transport.socket.shutdown();
-		defaultAllocator.dispose(transport.socket);
+        defaultAllocator.dispose(transport.socket);
-		transport.exception = exception;
+        transport.exception = exception;
-		pendings.enqueue(transport);
+        pendings.enqueue(transport);
-	}
+    }
-	/**
+    /**
-	 * Does the actual polling.
+     * Does the actual polling.
-	 */
+     */
-	override protected void poll() @nogc
+    override protected void poll() @nogc
-	{
+    {
-		DWORD lpNumberOfBytes;
+        DWORD lpNumberOfBytes;
-		ULONG_PTR key;
+        ULONG_PTR key;
-		LPOVERLAPPED overlap;
+        LPOVERLAPPED overlap;
-		immutable timeout = cast(immutable int) blockTime.total!"msecs";
+        immutable timeout = cast(immutable int) blockTime.total!"msecs";
-		auto result = GetQueuedCompletionStatus(completionPort,
+        auto result = GetQueuedCompletionStatus(completionPort,
-												&lpNumberOfBytes,
+                                                &lpNumberOfBytes,
-												&key,
+                                                &key,
-												&overlap,
+                                                &overlap,
-												timeout);
+                                                timeout);
-		if (result == FALSE && overlap == NULL)
+        if (result == FALSE && overlap == NULL)
-		{
+        {
-			return; // Timeout
+            return; // Timeout
-		}
+        }
-		auto overlapped = (cast(SocketState) ((cast(void*) overlap) - 8));
+        auto overlapped = (cast(SocketState) ((cast(void*) overlap) - 8));
-		assert(overlapped !is null);
+        assert(overlapped !is null);
-		scope (failure)
+        scope (failure)
-		{
+        {
-			MmapPool.instance.dispose(overlapped);
+            MmapPool.instance.dispose(overlapped);
-		}
+        }
-		switch (overlapped.event)
+        switch (overlapped.event)
-		{
+        {
-			case OverlappedSocketEvent.accept:
+            case OverlappedSocketEvent.accept:
-				auto connection = cast(ConnectionWatcher) (cast(void*) key);
+                auto connection = cast(ConnectionWatcher) (cast(void*) key);
-				assert(connection !is null);
+                assert(connection !is null);
-				auto listener = cast(OverlappedStreamSocket) connection.socket;
+                auto listener = cast(OverlappedStreamSocket) connection.socket;
-				assert(listener !is null);
+                assert(listener !is null);
-				auto socket = listener.endAccept(overlapped);
+                auto socket = listener.endAccept(overlapped);
-				auto transport = MmapPool.instance.make!StreamTransport(socket);
+                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);
+                pendings.enqueue(connection);
-				listener.beginAccept(overlapped);
+                listener.beginAccept(overlapped);
-				break;
+                break;
-			case OverlappedSocketEvent.read:
+            case OverlappedSocketEvent.read:
-				auto transport = cast(StreamTransport) (cast(void*) key);
+                auto transport = cast(StreamTransport) (cast(void*) key);
-				assert(transport !is null);
+                assert(transport !is null);
-				if (!transport.active)
+                if (!transport.active)
-				{
+                {
-					MmapPool.instance.dispose(transport);
+                    MmapPool.instance.dispose(transport);
-					MmapPool.instance.dispose(overlapped);
+                    MmapPool.instance.dispose(overlapped);
-					return;
+                    return;
-				}
+                }
-				int received;
+                int received;
-				SocketException exception;
+                SocketException exception;
-				try
+                try
-				{
+                {
-					received = transport.socket.endReceive(overlapped);
+                    received = transport.socket.endReceive(overlapped);
-				}
+                }
-				catch (SocketException e)
+                catch (SocketException e)
-				{
+                {
-					exception = e;
+                    exception = e;
-				}
+                }
-				if (transport.socket.disconnected)
+                if (transport.socket.disconnected)
-				{
+                {
-					// We want to get one last notification to destroy the watcher.
+                    // We want to get one last notification to destroy the watcher.
-					transport.socket.beginReceive(transport.output[], overlapped);
+                    transport.socket.beginReceive(transport.output[], overlapped);
-					kill(transport, exception);
+                    kill(transport, exception);
-				}
+                }
-				else if (received > 0)
+                else if (received > 0)
-				{
+                {
-					immutable full = transport.output.free == received;
+                    immutable full = transport.output.free == received;
-					transport.output += received;
+                    transport.output += received;
-					// Receive was interrupted because the buffer is full. We have to continue.
+                    // Receive was interrupted because the buffer is full. We have to continue.
-					if (full)
+                    if (full)
-					{
+                    {
-						transport.socket.beginReceive(transport.output[], overlapped);
+                        transport.socket.beginReceive(transport.output[], overlapped);
-					}
+                    }
-					pendings.enqueue(transport);
+                    pendings.enqueue(transport);
-				}
+                }
-				break;
+                break;
-			case OverlappedSocketEvent.write:
+            case OverlappedSocketEvent.write:
-				auto transport = cast(StreamTransport) (cast(void*) key);
+                auto transport = cast(StreamTransport) (cast(void*) key);
-				assert(transport !is null);
+                assert(transport !is null);
-				transport.input += transport.socket.endSend(overlapped);
+                transport.input += transport.socket.endSend(overlapped);
-				if (transport.input.length > 0)
+                if (transport.input.length > 0)
-				{
+                {
-					transport.socket.beginSend(transport.input[], overlapped);
+                    transport.socket.beginSend(transport.input[], overlapped);
-				}
+                }
-				else
+                else
-				{
+                {
-					transport.socket.beginReceive(transport.output[], overlapped);
+                    transport.socket.beginReceive(transport.output[], overlapped);
-					if (transport.isClosing())
+                    if (transport.isClosing())
-					{
+                    {
-						kill(transport);
+                        kill(transport);
-					}
+                    }
-				}
+                }
-				break;
+                break;
-			default:
+            default:
-				assert(false, "Unknown event");
+                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_READ     =  -1,
-	EVFILT_WRITE    =  -2,
+    EVFILT_WRITE    =  -2,
-	EVFILT_AIO      =  -3, /* attached to aio requests */
+    EVFILT_AIO      =  -3, /* attached to aio requests */
-	EVFILT_VNODE    =  -4, /* attached to vnodes */
+    EVFILT_VNODE    =  -4, /* attached to vnodes */
-	EVFILT_PROC     =  -5, /* attached to struct proc */
+    EVFILT_PROC     =  -5, /* attached to struct proc */
-	EVFILT_SIGNAL   =  -6, /* attached to struct proc */
+    EVFILT_SIGNAL   =  -6, /* attached to struct proc */
-	EVFILT_TIMER    =  -7, /* timers */
+    EVFILT_TIMER    =  -7, /* timers */
-	EVFILT_MACHPORT =  -8, /* Mach portsets */
+    EVFILT_MACHPORT =  -8, /* Mach portsets */
-	EVFILT_FS       =  -9, /* filesystem events */
+    EVFILT_FS       =  -9, /* filesystem events */
-	EVFILT_USER     = -10, /* User events */
+    EVFILT_USER     = -10, /* User events */
-	EVFILT_VM       = -12, /* virtual memory events */
+    EVFILT_VM       = -12, /* virtual memory events */
-	EVFILT_SYSCOUNT =  11
+    EVFILT_SYSCOUNT =  11
 }
 struct kevent_t
 {
-	uintptr_t    ident; /* identifier for this event */
+    uintptr_t    ident; /* identifier for this event */
-	short       filter; /* filter for event */
+    short       filter; /* filter for event */
-	ushort       flags;
+    ushort       flags;
-	uint        fflags;
+    uint        fflags;
-	intptr_t      data;
+    intptr_t      data;
-	void        *udata; /* opaque user data identifier */
+    void        *udata; /* opaque user data identifier */
 }
 enum
 {
-	/* actions */
+    /* actions */
-	EV_ADD      = 0x0001, /* add event to kq (implies enable) */
+    EV_ADD      = 0x0001, /* add event to kq (implies enable) */
-	EV_DELETE   = 0x0002, /* delete event from kq */
+    EV_DELETE   = 0x0002, /* delete event from kq */
-	EV_ENABLE   = 0x0004, /* enable event */
+    EV_ENABLE   = 0x0004, /* enable event */
-	EV_DISABLE  = 0x0008, /* disable event (not reported) */
+    EV_DISABLE  = 0x0008, /* disable event (not reported) */
-	/* flags */
+    /* flags */
-	EV_ONESHOT  = 0x0010, /* only report one occurrence */
+    EV_ONESHOT  = 0x0010, /* only report one occurrence */
-	EV_CLEAR    = 0x0020, /* clear event state after reporting */
+    EV_CLEAR    = 0x0020, /* clear event state after reporting */
-	EV_RECEIPT  = 0x0040, /* force EV_ERROR on success, data=0 */
+    EV_RECEIPT  = 0x0040, /* force EV_ERROR on success, data=0 */
-	EV_DISPATCH = 0x0080, /* disable event after reporting */
+    EV_DISPATCH = 0x0080, /* disable event after reporting */
-	EV_SYSFLAGS = 0xF000, /* reserved by system */
+    EV_SYSFLAGS = 0xF000, /* reserved by system */
-	EV_FLAG1    = 0x2000, /* filter-specific flag */
+    EV_FLAG1    = 0x2000, /* filter-specific flag */
-	/* returned values */
+    /* returned values */
-	EV_EOF      = 0x8000, /* EOF detected */
+    EV_EOF      = 0x8000, /* EOF detected */
-	EV_ERROR    = 0x4000, /* error, data contains errno */
+    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;
+    protected int fd;
-	private Vector!kevent_t events;
+    private Array!kevent_t events;
-	private Vector!kevent_t changes;
+    private Array!kevent_t changes;
-	private size_t changeCount;
+    private size_t changeCount;
-	/**
+    /**
-	 * Returns: Maximal event count can be got at a time
+     * Returns: Maximal event count can be got at a time
-	 *          (should be supported by the backend).
+     *          (should be supported by the backend).
-	 */
+     */
-	override protected @property uint maxEvents()
+    override protected @property uint maxEvents()
-	const pure nothrow @safe @nogc
+    const pure nothrow @safe @nogc
-	{
+    {
-		return cast(uint) events.length;
+        return cast(uint) events.length;
-	}
+    }
-	this() @nogc
+    this() @nogc
-	{
+    {
-		super();
+        super();
-		if ((fd = kqueue()) == -1)
+        if ((fd = kqueue()) == -1)
-		{
+        {
-			throw make!BadLoopException(defaultAllocator,
+            throw make!BadLoopException(defaultAllocator,
-			                            "kqueue initialization failed");
+                                        "kqueue initialization failed");
-		}
+        }
-		events = Vector!kevent_t(64, MmapPool.instance);
+        events = Array!kevent_t(64, MmapPool.instance);
-		changes = Vector!kevent_t(64, MmapPool.instance);
+        changes = Array!kevent_t(64, MmapPool.instance);
-	}
+    }
-	/**
+    /**
-	 * Frees loop internals.
+     * Frees loop internals.
-	 */
+     */
-	~this() @nogc
+    ~this() @nogc
-	{
+    {
-		close(fd);
+        close(fd);
-	}
+    }
-	private void set(socket_t socket, short filter, ushort flags) @nogc
+    private void set(socket_t socket, short filter, ushort flags) @nogc
-	{
+    {
-		if (changes.length <= changeCount)
+        if (changes.length <= changeCount)
-		{
+        {
-			changes.length = changeCount + maxEvents;
+            changes.length = changeCount + maxEvents;
-		}
+        }
-		EV_SET(&changes[changeCount],
+        EV_SET(&changes[changeCount],
-		       cast(ulong) socket,
+               cast(ulong) socket,
-		       filter,
+               filter,
-		       flags,
+               flags,
-		       0U,
+               0U,
-		       0L,
+               0L,
-		       null);
+               null);
-		++changeCount;
+        ++changeCount;
-	}
+    }
-	/**
+    /**
-	 * Should be called if the backend configuration changes.
+     * Should be called if the backend configuration changes.
-	 *
+     *
-	 * Params:
+     * Params:
-	 * 	watcher   = Watcher.
+     * 	watcher   = Watcher.
-	 * 	oldEvents = The events were already set.
+     * 	oldEvents = The events were already set.
-	 * 	events    = The events should be set.
+     * 	events    = The events should be set.
-	 *
+     *
-	 * Returns: $(D_KEYWORD true) if the operation was successful.
+     * Returns: $(D_KEYWORD true) if the operation was successful.
-	 */
+     */
-	override protected bool reify(SocketWatcher watcher,
+    override protected bool reify(SocketWatcher watcher,
-	                              EventMask oldEvents,
+                                  EventMask oldEvents,
-	                              EventMask events) @nogc
+                                  EventMask events) @nogc
-	{
+    {
-		if (events != oldEvents)
+        if (events != oldEvents)
-		{
+        {
-			if (oldEvents & Event.read || oldEvents & Event.accept)
+            if (oldEvents & Event.read || oldEvents & Event.accept)
-			{
+            {
-				set(watcher.socket.handle, EVFILT_READ, EV_DELETE);
+                set(watcher.socket.handle, EVFILT_READ, EV_DELETE);
-			}
+            }
-			if (oldEvents & Event.write)
+            if (oldEvents & Event.write)
-			{
+            {
-				set(watcher.socket.handle, EVFILT_WRITE, EV_DELETE);
+                set(watcher.socket.handle, EVFILT_WRITE, EV_DELETE);
-			}
+            }
-		}
+        }
-		if (events & (Event.read | events & Event.accept))
+        if (events & (Event.read | events & Event.accept))
-		{
+        {
-			set(watcher.socket.handle, EVFILT_READ, EV_ADD | EV_ENABLE);
+            set(watcher.socket.handle, EVFILT_READ, EV_ADD | EV_ENABLE);
-		}
+        }
-		if (events & Event.write)
+        if (events & Event.write)
-		{
+        {
-			set(watcher.socket.handle, EVFILT_WRITE, EV_ADD | EV_DISPATCH);
+            set(watcher.socket.handle, EVFILT_WRITE, EV_ADD | EV_DISPATCH);
-		}
+        }
-		return true;
+        return true;
-	}
+    }
-	/**
+    /**
-	 * Does the actual polling.
+     * Does the actual polling.
-	 */
+     */
-	protected override void poll() @nogc
+    protected override void poll() @nogc
-	{
+    {
-		timespec ts;
+        timespec ts;
-		blockTime.split!("seconds", "nsecs")(ts.tv_sec, ts.tv_nsec);
+        blockTime.split!("seconds", "nsecs")(ts.tv_sec, ts.tv_nsec);
-		if (changeCount > maxEvents) 
+        if (changeCount > maxEvents) 
-		{
+        {
-			events.length = changes.length;
+            events.length = changes.length;
-		}
+        }
-		auto eventCount = kevent(fd,
+        auto eventCount = kevent(fd,
-		                         changes.get().ptr,
+                                 changes.get().ptr,
-		                         cast(int) changeCount,
+                                 cast(int) changeCount,
-		                         events.get().ptr,
+                                 events.get().ptr,
-		                         maxEvents,
+                                 maxEvents,
-		                         &ts);
+                                 &ts);
-		changeCount = 0;
+        changeCount = 0;
-		if (eventCount < 0)
+        if (eventCount < 0)
-		{
+        {
-			if (errno != EINTR)
+            if (errno != EINTR)
-			{
+            {
-				throw defaultAllocator.make!BadLoopException();
+                throw defaultAllocator.make!BadLoopException();
-			}
+            }
-			return;
+            return;
-		}
+        }
-		for (int i; i < eventCount; ++i)
+        for (int i; i < eventCount; ++i)
-		{
+        {
-			assert(connections.length > events[i].ident);
+            assert(connections.length > events[i].ident);
-			auto transport = cast(StreamTransport) connections[events[i].ident];
+            auto transport = cast(StreamTransport) connections[events[i].ident];
-			// If it is a ConnectionWatcher. Accept connections.
+            // If it is a ConnectionWatcher. Accept connections.
-			if (transport is null)
+            if (transport is null)
-			{
+            {
-				auto connection = cast(ConnectionWatcher) connections[events[i].ident];
+                auto connection = cast(ConnectionWatcher) connections[events[i].ident];
-				assert(connection !is null);
+                assert(connection !is null);
-				acceptConnections(connection);
+                acceptConnections(connection);
-			}
+            }
-			else if (events[i].flags & EV_ERROR)
+            else if (events[i].flags & EV_ERROR)
-			{
+            {
-				kill(transport);
+                kill(transport);
-			}
+            }
-			else if (events[i].filter == EVFILT_READ)
+            else if (events[i].filter == EVFILT_READ)
-			{
+            {
-				SocketException exception;
+                SocketException exception;
-				try
+                try
-				{
+                {
-					ptrdiff_t received;
+                    ptrdiff_t received;
-					do
+                    do
-					{
+                    {
-						received = transport.socket.receive(transport.output[]);
+                        received = transport.socket.receive(transport.output[]);
-						transport.output += received;
+                        transport.output += received;
-					}
+                    }
-					while (received);
+                    while (received);
-				}
+                }
-				catch (SocketException e)
+                catch (SocketException e)
-				{
+                {
-					exception = e;
+                    exception = e;
-				}
+                }
-				if (transport.socket.disconnected)
+                if (transport.socket.disconnected)
-				{
+                {
-					kill(transport, exception);
+                    kill(transport, exception);
-				}
+                }
-				else if (transport.output.length)
+                else if (transport.output.length)
-				{
+                {
-					pendings.enqueue(transport);
+                    pendings.enqueue(transport);
-				}
+                }
-			}
+            }
-			else if (events[i].filter == EVFILT_WRITE)
+            else if (events[i].filter == EVFILT_WRITE)
-			{
+            {
-				transport.writeReady = true;
+                transport.writeReady = true;
-				if (transport.input.length)
+                if (transport.input.length)
-				{
+                {
-					feed(transport);
+                    feed(transport);
-				}
+                }
-			}
+            }
-		}
+        }
-	}
+    }
-	/**
+    /**
-	 * Returns: The blocking time.
+     * Returns: The blocking time.
-	 */
+     */
-	override protected @property inout(Duration) blockTime()
+    override protected @property inout(Duration) blockTime()
-	inout @nogc @safe pure nothrow
+    inout @nogc @safe pure nothrow
-	{
+    {
-		return min(super.blockTime, 1.dur!"seconds");
+        return min(super.blockTime, 1.dur!"seconds");
-	}
+    }
-	/**
+    /**
-	 * If the transport couldn't send the data, the further sending should
+     * If the transport couldn't send the data, the further sending should
-	 * be handled by the event loop.
+     * be handled by the event loop.
-	 *
+     *
-	 * Params:
+     * Params:
-	 * 	transport = Transport.
+     * 	transport = Transport.
-	 * 	exception = Exception thrown on sending.
+     * 	exception = Exception thrown on sending.
-	 *
+     *
-	 * Returns: $(D_KEYWORD true) if the operation could be successfully
+     * Returns: $(D_KEYWORD true) if the operation could be successfully
-	 *          completed or scheduled, $(D_KEYWORD false) otherwise (the
+     *          completed or scheduled, $(D_KEYWORD false) otherwise (the
-	 *          transport will be destroyed then).
+     *          transport will be destroyed then).
-	 */
+     */
-	protected override bool feed(StreamTransport transport,
+    protected override bool feed(StreamTransport transport,
-	                             SocketException exception = null) @nogc
+                                 SocketException exception = null) @nogc
-	{
+    {
-		if (!super.feed(transport, exception))
+        if (!super.feed(transport, exception))
-		{
+        {
-			return false;
+            return false;
-		}
+        }
-		if (!transport.writeReady)
+        if (!transport.writeReady)
-		{
+        {
-			set(transport.socket.handle, EVFILT_WRITE, EV_DISPATCH);
+            set(transport.socket.handle, EVFILT_WRITE, EV_DISPATCH);
-			return true;
+            return true;
-		}
+        }
-		return false;
+        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.
+    /// Received notification that the underlying socket is write-ready.
-	package bool writeReady;
+    package bool writeReady;
-	/**
+    /**
-	 * Params:
+     * Params:
-	 * 	loop   = Event loop.
+     *  loop   = Event loop.
-	 * 	socket = Socket.
+     *  socket = Socket.
-	 *
+     *
-	 * Precondition: $(D_INLINECODE loop !is null && socket !is null)
+     * Precondition: $(D_INLINECODE loop !is null && socket !is null)
-	 */
+     */
-	this(SelectorLoop loop, ConnectedSocket socket) @nogc
+    this(SelectorLoop loop, ConnectedSocket socket) @nogc
-	in 
+    in 
-	{
+    {
-		assert(loop !is null);
+        assert(loop !is null);
-	}
+    }
-	body
+    body
-	{
+    {
-		super(socket);
+        super(socket);
-		this.loop = loop;
+        this.loop = loop;
-		output = ReadBuffer!ubyte(8192, 1024, MmapPool.instance);
+        output = ReadBuffer!ubyte(8192, 1024, MmapPool.instance);
-		input = WriteBuffer!ubyte(8192, MmapPool.instance);
+        input = WriteBuffer!ubyte(8192, MmapPool.instance);
-		active = true;
+        active = true;
-	}
+    }
-	/**
+    /**
-	 * Returns: Socket.
+     * Returns: Socket.
-	 *
+     *
-	 * Postcondition: $(D_INLINECODE socket !is null)
+     * Postcondition: $(D_INLINECODE socket !is null)
-	 */
+     */
-	override @property ConnectedSocket socket() pure nothrow @safe @nogc
+    override @property ConnectedSocket socket() pure nothrow @safe @nogc
-	out (socket)
+    out (socket)
-	{
+    {
-		assert(socket !is null);
+        assert(socket !is null);
-	}
+    }
-	body
+    body
-	{
+    {
-		return cast(ConnectedSocket) socket_;
+        return cast(ConnectedSocket) socket_;
-	}
+    }
-	private @property void socket(ConnectedSocket socket) pure nothrow @safe @nogc
+    private @property void socket(ConnectedSocket socket)
-	in
+    pure nothrow @safe @nogc
-	{
+    in
-		assert(socket !is null);
+    {
-	}
+        assert(socket !is null);
-	body
+    }
-	{
+    body
-		socket_ = socket;
+    {
-	}
+        socket_ = socket;
    }
-	/**
+    /**
-	 * Returns: Application protocol.
+     * Returns: Application protocol.
-	 */
+     */
-	@property Protocol protocol() pure nothrow @safe @nogc
+    @property Protocol protocol() pure nothrow @safe @nogc
-	{
+    {
-		return protocol_;
+        return protocol_;
-	}
+    }
-	/**
+    /**
-	 * Switches the protocol.
+     * Switches the protocol.
-	 *
+     *
-	 * The protocol is deallocated by the event loop, it should currently be
+     * The protocol is deallocated by the event loop, it should currently be
-	 * allocated with $(D_PSYMBOL MmapPool).
+     * allocated with $(D_PSYMBOL MmapPool).
-	 *
+     *
-	 * Params:
+     * Params:
-	 * 	protocol = Application protocol.
+     *  protocol = Application protocol.
-	 *
+     *
-	 * Precondition: $(D_INLINECODE protocol !is null)
+     * Precondition: $(D_INLINECODE protocol !is null)
-	 */
+     */
-	@property void protocol(Protocol protocol) pure nothrow @safe @nogc
+    @property void protocol(Protocol protocol) pure nothrow @safe @nogc
-	in
+    in
-	{
+    {
-		assert(protocol !is null);
+        assert(protocol !is null);
-	}
+    }
-	body
+    body
-	{
+    {
-		protocol_ = protocol;
+        protocol_ = protocol;
-	}
+    }
-	/**
+    /**
-	 * Returns $(D_PARAM true) if the transport is closing or closed.
+     * Returns $(D_PARAM true) if the transport is closing or closed.
-	 */
+     */
-	bool isClosing() const pure nothrow @safe @nogc
+    bool isClosing() const pure nothrow @safe @nogc
-	{
+    {
-		return closing;
+        return closing;
-	}
+    }
-	/**
+    /**
-	 * Close the transport.
+     * Close the transport.
-	 *
+     *
-	 * Buffered data will be flushed.  No more data will be received.
+     * Buffered data will be flushed.  No more data will be received.
-	 */
+     */
-	void close() @nogc
+    void close() @nogc
-	{
+    {
-		closing = true;
+        closing = true;
-		loop.reify(this, EventMask(Event.read, Event.write), EventMask(Event.write));
+        loop.reify(this,
-	}
+                   EventMask(Event.read, Event.write),
                   EventMask(Event.write));
    }
-	/**
+    /**
-	 * Invokes the watcher callback.
+     * Invokes the watcher callback.
-	 */
+     */
-	override void invoke() @nogc
+    override void invoke() @nogc
-	{
+    {
-		if (output.length)
+        if (output.length)
-		{
+        {
-			protocol.received(output[0 .. $]);
+            protocol.received(output[0 .. $]);
-			output.clear();
+            output.clear();
-			if (isClosing() && input.length == 0)
+            if (isClosing() && input.length == 0)
-			{
+            {
-				loop.kill(this);
+                loop.kill(this);
-			}
+            }
-		}
+        }
-		else
+        else
-		{
+        {
-			protocol.disconnected(exception);
+            protocol.disconnected(exception);
-			MmapPool.instance.dispose(protocol_);
+            MmapPool.instance.dispose(protocol_);
-			defaultAllocator.dispose(exception);
+            defaultAllocator.dispose(exception);
-			active = false;
+            active = false;
-		}
+        }
-	}
+    }
-	/**
+    /**
-	 * Write some data to the transport.
+     * Write some data to the transport.
-	 *
+     *
-	 * Params:
+     * Params:
-	 * 	data = Data to send.
+     *  data = Data to send.
-	 */
+     */
-	void write(ubyte[] data) @nogc
+    void write(ubyte[] data) @nogc
-	{
+    {
-		if (!data.length)
+        if (!data.length)
-		{
+        {
-			return;
+            return;
-		}
+        }
-		// Try to write if the socket is write ready.
+        // Try to write if the socket is write ready.
-		if (writeReady)
+        if (writeReady)
-		{
+        {
-			ptrdiff_t sent;
+            ptrdiff_t sent;
-			SocketException exception;
+            SocketException exception;
-			try
+            try
-			{
+            {
-				sent = socket.send(data);
+                sent = socket.send(data);
-				if (sent == 0)
+                if (sent == 0)
-				{
+                {
-					writeReady = false;
+                    writeReady = false;
-				}
+                }
-			}
+            }
-			catch (SocketException e)
+            catch (SocketException e)
-			{
+            {
-				writeReady = false;
+                writeReady = false;
-				exception = e;
+                exception = e;
-			}
+            }
-			if (sent < data.length)
+            if (sent < data.length)
-			{
+            {
-				input ~= data[sent..$];
+                input ~= data[sent..$];
-				loop.feed(this, exception);
+                loop.feed(this, exception);
-			}
+            }
-		}
+        }
-		else
+        else
-		{
+        {
-			input ~= data;
+            input ~= data;
-		}
+        }
-	}
+    }
 }
 abstract class SelectorLoop : Loop
 {
-	/// Pending connections.
+    /// Pending connections.
-	protected Vector!SocketWatcher connections;
+    protected Array!SocketWatcher connections;
-	this() @nogc
+    this() @nogc
-	{
+    {
-		super();
+        super();
-		connections = Vector!SocketWatcher(maxEvents, MmapPool.instance);
+        connections = Array!SocketWatcher(maxEvents, MmapPool.instance);
-	}
+    }
-	~this() @nogc
+    ~this() @nogc
-	{
+    {
-		foreach (ref connection; connections)
+        foreach (ref connection; connections)
-		{
+        {
-			// We want to free only the transports. ConnectionWatcher are created by the
+            // We want to free only the transports. ConnectionWatcher are
-			// user and should be freed by himself.
+            // created by the user and should be freed by himself.
-			if (cast(StreamTransport) connection !is null)
+            if (cast(StreamTransport) connection !is null)
-			{
+            {
-				MmapPool.instance.dispose(connection);
+                MmapPool.instance.dispose(connection);
-			}
+            }
-		}
+        }
-	}
+    }
-	/**
+    /**
-	 * Should be called if the backend configuration changes.
+     * Should be called if the backend configuration changes.
-	 *
+     *
-	 * Params:
+     * Params:
-	 * 	watcher   = Watcher.
+     *  watcher   = Watcher.
-	 * 	oldEvents = The events were already set.
+     *  oldEvents = The events were already set.
-	 * 	events    = The events should be set.
+     *  events    = The events should be set.
-	 *
+     *
-	 * Returns: $(D_KEYWORD true) if the operation was successful.
+     * Returns: $(D_KEYWORD true) if the operation was successful.
-	 */
+     */
-	override abstract protected bool reify(SocketWatcher watcher,
+    override abstract protected bool reify(SocketWatcher watcher,
-	                                       EventMask oldEvents,
+                                           EventMask oldEvents,
-	                                       EventMask events) @nogc;
+                                           EventMask events) @nogc;
-	/**
+    /**
-	 * Kills the watcher and closes the connection.
+     * Kills the watcher and closes the connection.
-	 *
+     *
-	 * Params:
+     * Params:
-	 * 	transport = Transport.
+     *  transport = Transport.
-	 * 	exception = Occurred exception.
+     *  exception = Occurred exception.
-	 */
+     */
-	protected void kill(StreamTransport transport,
+    protected void kill(StreamTransport transport,
-	                    SocketException exception = null) @nogc
+                        SocketException exception = null) @nogc
-	in
+    in
-	{
+    {
-		assert(transport !is null);
+        assert(transport !is null);
-	}
+    }
-	body
+    body
-	{
+    {
-		transport.socket.shutdown();
+        transport.socket.shutdown();
-		defaultAllocator.dispose(transport.socket);
+        defaultAllocator.dispose(transport.socket);
-		transport.exception = exception;
+        transport.exception = exception;
-		pendings.enqueue(transport);
+        pendings.enqueue(transport);
-	}
+    }
-	/**
+    /**
-	 * If the transport couldn't send the data, the further sending should
+     * If the transport couldn't send the data, the further sending should
-	 * be handled by the event loop.
+     * be handled by the event loop.
-	 *
+     *
-	 * Params:
+     * Params:
-	 * 	transport = Transport.
+     *  transport = Transport.
-	 * 	exception = Exception thrown on sending.
+     *  exception = Exception thrown on sending.
-	 *
+     *
-	 * Returns: $(D_KEYWORD true) if the operation could be successfully
+     * Returns: $(D_KEYWORD true) if the operation could be successfully
-	 *          completed or scheduled, $(D_KEYWORD false) otherwise (the
+     *          completed or scheduled, $(D_KEYWORD false) otherwise (the
-	 *          transport will be destroyed then).
+     *          transport will be destroyed then).
-	 */
+     */
-	protected bool feed(StreamTransport transport,
+    protected bool feed(StreamTransport transport,
-	                    SocketException exception = null) @nogc
+                        SocketException exception = null) @nogc
-	in
+    in
-	{
+    {
-		assert(transport !is null);
+        assert(transport !is null);
-	}
+    }
-	body
+    body
-	{
+    {
-		while (transport.input.length && transport.writeReady)
+        while (transport.input.length && transport.writeReady)
-		{
+        {
-			try
+            try
-			{
+            {
-				ptrdiff_t sent = transport.socket.send(transport.input[]);
+                ptrdiff_t sent = transport.socket.send(transport.input[]);
-				if (sent == 0)
+                if (sent == 0)
-				{
+                {
-					transport.writeReady = false;
+                    transport.writeReady = false;
-				}
+                }
-				else
+                else
-				{
+                {
-					transport.input += sent;
+                    transport.input += sent;
-				}
+                }
-			}
+            }
-			catch (SocketException e)
+            catch (SocketException e)
-			{
+            {
-				exception = e;
+                exception = e;
-				transport.writeReady = false;
+                transport.writeReady = false;
-			}
+            }
-		}
+        }
-		if (exception !is null)
+        if (exception !is null)
-		{
+        {
-			kill(transport, exception);
+            kill(transport, exception);
-			return false;
+            return false;
-		}
+        }
-		if (transport.input.length == 0 && transport.isClosing())
+        if (transport.input.length == 0 && transport.isClosing())
-		{
+        {
-			kill(transport);
+            kill(transport);
-		}
+        }
-		return true;
+        return true;
-	}
+    }
-	/**
+    /**
-	 * Start watching.
+     * Start watching.
-	 *
+     *
-	 * Params:
+     * Params:
-	 * 	watcher = Watcher.
+     *  watcher = Watcher.
-	 */
+     */
-	override void start(ConnectionWatcher watcher) @nogc
+    override void start(ConnectionWatcher watcher) @nogc
-	{
+    {
-		if (watcher.active)
+        if (watcher.active)
-		{
+        {
-			return;
+            return;
-		}
+        }
-		if (connections.length <= watcher.socket)
+        if (connections.length <= watcher.socket)
-		{
+        {
-			connections.length = watcher.socket.handle + maxEvents / 2;
+            connections.length = watcher.socket.handle + maxEvents / 2;
-		}
+        }
-		connections[watcher.socket.handle] = watcher;
+        connections[watcher.socket.handle] = watcher;
-		super.start(watcher);
+        super.start(watcher);
-	}
+    }
-	/**
+    /**
-	 * Accept incoming connections.
+     * Accept incoming connections.
-	 *
+     *
-	 * Params:
+     * Params:
-	 * 	connection = Connection watcher ready to accept.
+     *  connection = Connection watcher ready to accept.
-	 */
+     */
-	package void acceptConnections(ConnectionWatcher connection) @nogc
+    package void acceptConnections(ConnectionWatcher connection) @nogc
-	in
+    in
-	{
+    {
-		assert(connection !is null);
+        assert(connection !is null);
-	}
+    }
-	body
+    body
-	{
+    {
-		while (true)
+        while (true)
-		{
+        {
-			ConnectedSocket client;
+            ConnectedSocket client;
-			try
+            try
-			{
+            {
-				client = (cast(StreamSocket) connection.socket).accept();
+                client = (cast(StreamSocket) connection.socket).accept();
-			}
+            }
-			catch (SocketException e)
+            catch (SocketException e)
-			{
+            {
-				defaultAllocator.dispose(e);
+                defaultAllocator.dispose(e);
-				break;
+                break;
-			}
+            }
-			if (client is null)
+            if (client is null)
-			{
+            {
-				break;
+                break;
-			}
+            }
-			StreamTransport transport;
+            StreamTransport transport;
-			if (connections.length > client.handle)
+            if (connections.length > client.handle)
-			{
+            {
-				transport = cast(StreamTransport) connections[client.handle];
+                transport = cast(StreamTransport) connections[client.handle];
-			}
+            }
-			else
+            else
-			{
+            {
-				connections.length = client.handle + maxEvents / 2;
+                connections.length = client.handle + maxEvents / 2;
-			}
+            }
-			if (transport is null)
+            if (transport is null)
-			{
+            {
-				transport = MmapPool.instance.make!StreamTransport(this, client);
+                transport = MmapPool.instance.make!StreamTransport(this, client);
-				connections[client.handle] = transport;
+                connections[client.handle] = transport;
-			}
+            }
-			else
+            else
-			{
+            {
-				transport.socket = client;
+                transport.socket = client;
-			}
+            }
-			reify(transport, EventMask(Event.none), EventMask(Event.read, Event.write));
+            reify(transport, EventMask(Event.none), EventMask(Event.read, Event.write));
-			connection.incoming.enqueue(transport);
+            connection.incoming.enqueue(transport);
-		}
+        }
-		if (!connection.incoming.empty)
+        if (!connection.incoming.empty)
-		{
+        {
-			pendings.enqueue(connection);
+            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.
+    /// For internal use by Windows API.
-	align(1) OVERLAPPED overlapped;
+    align(1) OVERLAPPED overlapped;
-	/// File/socket handle.
+    /// File/socket handle.
-	HANDLE handle;
+    HANDLE handle;
-	/// For keeping events or event masks.
+    /// For keeping events or event masks.
-	int event;
+    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
+ *  void received(in ubyte[] data) @nogc
- * 	{
+ *  {
- * 		transport.write(data);
+ *      transport.write(data);
- * 	}
+ *  }
 *
- * 	void connected(DuplexTransport transport) @nogc
+ *  void connected(DuplexTransport transport) @nogc
- * 	{
+ *  {
- * 		this.transport = transport;
+ *      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)
+ *  version (Windows)
- * 	{
+ *  {
- * 		auto sock = defaultAllocator.make!OverlappedStreamSocket(AddressFamily.INET);
+ *      auto sock = defaultAllocator.make!OverlappedStreamSocket(AddressFamily.INET);
- * 	}
+ *  }
- * 	else
+ *  else
- * 	{
+ *  {
- * 		auto sock = defaultAllocator.make!StreamSocket(AddressFamily.INET);
+ *      auto sock = defaultAllocator.make!StreamSocket(AddressFamily.INET);
- * 		sock.blocking = false;
+ *      sock.blocking = false;
- * 	}
+ *  }
 *
- * 	sock.bind(address);
+ *  sock.bind(address);
- * 	sock.listen(5);
+ *  sock.listen(5);
 *
- * 	auto io = defaultAllocator.make!ConnectionWatcher(sock);
+ *  auto io = defaultAllocator.make!ConnectionWatcher(sock);
- * 	io.setProtocol!EchoProtocol;
+ *  io.setProtocol!EchoProtocol;
 *
- * 	defaultLoop.start(io);
+ *  defaultLoop.start(io);
- * 	defaultLoop.run();
+ *  defaultLoop.run();
 *
- * 	sock.shutdown();
+ *  sock.shutdown();
- * 	defaultAllocator.dispose(io);
+ *  defaultAllocator.dispose(io);
- * 	defaultAllocator.dispose(sock);
+ *  defaultAllocator.dispose(sock);
- * 	defaultAllocator.dispose(address);
+ *  defaultAllocator.dispose(address);
 * }
 * ---
 */
@ -81,33 +81,33 @@ version (DisableBackends)
 }
 else version (linux)
 {
-	import tanya.async.event.epoll;
+    import tanya.async.event.epoll;
-	version = Epoll;
+    version = Epoll;
 }
 else version (Windows)
 {
-	import tanya.async.event.iocp;
+    import tanya.async.event.iocp;
-	version = 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.
+    none   = 0x00,       /// No events.
-	read   = 0x01,       /// Non-blocking read call.
+    read   = 0x01,       /// Non-blocking read call.
-	write  = 0x02,       /// Non-blocking write call.
+    write  = 0x02,       /// Non-blocking write call.
-	accept = 0x04,       /// Connection made.
+    accept = 0x04,       /// Connection made.
-	error  = 0x80000000, /// Sent when an error occurs.
+    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.
+    /// Pending watchers.
-	protected Queue!Watcher pendings;
+    protected Queue!Watcher pendings;
-	/**
+    /**
-	 * Returns: Maximal event count can be got at a time
+     * Returns: Maximal event count can be got at a time
-	 *          (should be supported by the backend).
+     *          (should be supported by the backend).
-	 */
+     */
-	protected @property uint maxEvents()
+    protected @property uint maxEvents()
-	const pure nothrow @safe @nogc
+    const pure nothrow @safe @nogc
-	{
+    {
-		return 128U;
+        return 128U;
-	}
+    }
-	/**
+    /**
-	 * Initializes the loop.
+     * Initializes the loop.
-	 */
+     */
-	this() @nogc
+    this() @nogc
-	{
+    {
-		pendings = Queue!Watcher(MmapPool.instance);
+        pendings = Queue!Watcher(MmapPool.instance);
-	}
+    }
-	/**
+    /**
-	 * Frees loop internals.
+     * Frees loop internals.
-	 */
+     */
-	~this() @nogc
+    ~this() @nogc
-	{
+    {
-		foreach (w; pendings)
+        foreach (w; pendings)
-		{
+        {
-			MmapPool.instance.dispose(w);
+            MmapPool.instance.dispose(w);
-		}
+        }
-	}
+    }
-	/**
+    /**
-	 * Starts the loop.
+     * Starts the loop.
-	 */
+     */
-	void run() @nogc
+    void run() @nogc
-	{
+    {
-		done = false;
+        done = false;
-		do
+        do
-		{
+        {
-			poll();
+            poll();
-			// Invoke pendings
+            // Invoke pendings
-			foreach (ref w; pendings)
+            foreach (ref w; pendings)
-			{
+            {
-				w.invoke();
+                w.invoke();
-			}
+            }
-		}
+        }
-		while (!done);
+        while (!done);
-	}
+    }
-	/**
+    /**
-	 * Break out of the loop.
+     * Break out of the loop.
-	 */
+     */
-	void unloop() @safe pure nothrow @nogc
+    void unloop() @safe pure nothrow @nogc
-	{
+    {
-		done = true;
+        done = true;
-	}
+    }
-	/**
+    /**
-	 * Start watching.
+     * Start watching.
-	 *
+     *
-	 * Params:
+     * Params:
-	 * 	watcher = Watcher.
+     *  watcher = Watcher.
-	 */
+     */
-	void start(ConnectionWatcher watcher) @nogc
+    void start(ConnectionWatcher watcher) @nogc
-	{
+    {
-		if (watcher.active)
+        if (watcher.active)
-		{
+        {
-			return;
+            return;
-		}
+        }
-		watcher.active = true;
+        watcher.active = true;
-		reify(watcher, EventMask(Event.none), EventMask(Event.accept));
+        reify(watcher, EventMask(Event.none), EventMask(Event.accept));
-	}
+    }
-	/**
+    /**
-	 * Stop watching.
+     * Stop watching.
-	 *
+     *
-	 * Params:
+     * Params:
-	 * 	watcher = Watcher.
+     *  watcher = Watcher.
-	 */
+     */
-	void stop(ConnectionWatcher watcher) @nogc
+    void stop(ConnectionWatcher watcher) @nogc
-	{
+    {
-		if (!watcher.active)
+        if (!watcher.active)
-		{
+        {
-			return;
+            return;
-		}
+        }
-		watcher.active = false;
+        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.
+     * Should be called if the backend configuration changes.
-	 *
+     *
-	 * Params:
+     * Params:
-	 * 	watcher   = Watcher.
+     *  watcher   = Watcher.
-	 * 	oldEvents = The events were already set.
+     *  oldEvents = The events were already set.
-	 * 	events    = The events should be set.
+     *  events    = The events should be set.
-	 *
+     *
-	 * Returns: $(D_KEYWORD true) if the operation was successful.
+     * Returns: $(D_KEYWORD true) if the operation was successful.
-	 */
+     */
-	abstract protected bool reify(SocketWatcher watcher,
+    abstract protected bool reify(SocketWatcher watcher,
-	                              EventMask oldEvents,
+                                  EventMask oldEvents,
-	                              EventMask events) @nogc;
+                                  EventMask events) @nogc;
-	/**
+    /**
-	 * Returns: The blocking time.
+     * Returns: The blocking time.
-	 */
+     */
-	protected @property inout(Duration) blockTime()
+    protected @property inout(Duration) blockTime()
-	inout @safe pure nothrow @nogc
+    inout @safe pure nothrow @nogc
-	{
+    {
-		// Don't block if we have to do.
+        // Don't block if we have to do.
-		return pendings.empty ? blockTime_ : Duration.zero;
+        return pendings.empty ? blockTime_ : Duration.zero;
-	}
+    }
-	/**
+    /**
-	 * Sets the blocking time for IO watchers.
+     * Sets the blocking time for IO watchers.
-	 *
+     *
-	 * Params:
+     * Params:
-	 * 	blockTime = The blocking time. Cannot be larger than
+     *  blockTime = The blocking time. Cannot be larger than
-	 * 	            $(D_PSYMBOL maxBlockTime).
+     *              $(D_PSYMBOL maxBlockTime).
-	 */
+     */
-	protected @property void blockTime(in Duration blockTime) @safe pure nothrow @nogc
+    protected @property void blockTime(in Duration blockTime) @safe pure nothrow @nogc
-	in
+    in
-	{
+    {
-		assert(blockTime <= 1.dur!"hours", "Too long to wait.");
+        assert(blockTime <= 1.dur!"hours", "Too long to wait.");
-		assert(!blockTime.isNegative);
+        assert(!blockTime.isNegative);
-	}
+    }
-	body
+    body
-	{
+    {
-		blockTime_ = blockTime;
+        blockTime_ = blockTime;
-	}
+    }
-	/**
+    /**
-	 * Does the actual polling.
+     * Does the actual polling.
-	 */
+     */
-	abstract protected void poll() @nogc;
+    abstract protected void poll() @nogc;
-	/// Maximal block time.
+    /// Maximal block time.
-	protected Duration blockTime_ = 1.dur!"minutes";
+    protected Duration blockTime_ = 1.dur!"minutes";
 }
 /**
@ -280,17 +280,17 @@ abstract class Loop
 */
 class BadLoopException : Exception
 {
-	/**
+    /**
-	 * Params:
+     * Params:
-	 * 	file = The file where the exception occurred.
+     *  file = The file where the exception occurred.
-	 * 	line = The line number where the exception occurred.
+     *  line = The line number where the exception occurred.
-	 * 	next = The previous exception in the chain of exceptions, if any.
+     *  next = The previous exception in the chain of exceptions, if any.
-	 */
+     */
-	this(string file = __FILE__, size_t line = __LINE__, Throwable next = null)
+    this(string file = __FILE__, size_t line = __LINE__, Throwable next = null)
-	pure nothrow const @safe @nogc
+    pure nothrow const @safe @nogc
-	{
+    {
-		super("Event loop cannot be initialized.", file, line, next);
+        super("Event loop cannot be initialized.", file, line, next);
-	}
+    }
 }
 /**
@ -302,24 +302,24 @@ class BadLoopException : Exception
 */
@property Loop defaultLoop() @nogc
 {
-	if (defaultLoop_ !is null)
+    if (defaultLoop_ !is null)
-	{
+    {
-		return defaultLoop_;
+        return defaultLoop_;
-	}
+    }
-	version (Epoll)
+    version (Epoll)
-	{
+    {
-		defaultLoop_ = MmapPool.instance.make!EpollLoop;
+        defaultLoop_ = MmapPool.instance.make!EpollLoop;
-	}
+    }
-	else version (IOCP)
+    else version (IOCP)
-	{
+    {
-		defaultLoop_ = MmapPool.instance.make!IOCPLoop;
+        defaultLoop_ = MmapPool.instance.make!IOCPLoop;
-	}
+    }
-	else version (Kqueue)
+    else version (Kqueue)
-	{
+    {
-		import tanya.async.event.kqueue;
+        import tanya.async.event.kqueue;
-		defaultLoop_ = MmapPool.instance.make!KqueueLoop;
+        defaultLoop_ = MmapPool.instance.make!KqueueLoop;
-	}
+    }
-	return defaultLoop_;
+    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:
+     * Params:
-	 * 	data = Read data.
+     *  data = Read data.
-	 */
+     */
-	void received(in ubyte[] data) @nogc;
+    void received(in ubyte[] data) @nogc;
-	/**
+    /**
-	 * Called when a connection is made.
+     * Called when a connection is made.
-	 *
+     *
-	 * Params:
+     * Params:
-	 * 	transport = Protocol transport.
+     *  transport = Protocol transport.
-	 */
+     */
-	void connected(DuplexTransport transport) @nogc;
+    void connected(DuplexTransport transport) @nogc;
-	/**
+    /**
-	 * Called when a connection is lost.
+     * Called when a connection is lost.
-	 *
+     *
-	 * Params:
+     * Params:
-	 * 	exception = $(D_PSYMBOL Exception) if an error caused
+     *  exception = $(D_PSYMBOL Exception) if an error caused
-	 * 	            the disconnect, $(D_KEYWORD null) otherwise.
+     *              the disconnect, $(D_KEYWORD null) otherwise.
-	 */
+     */
-	void disconnected(SocketException exception) @nogc;
+    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.
+     * Write some data to the transport.
-	 *
+     *
-	 * Params:
+     * Params:
-	 * 	data = Data to send.
+     *  data = Data to send.
-	 */
+     */
-	void write(ubyte[] data) @nogc;
+    void write(ubyte[] data) @nogc;
 }
 /**
@ -46,46 +46,46 @@ interface WriteTransport : Transport
 */
 interface DuplexTransport : ReadTransport, WriteTransport
 {
-	/**
+    /**
-	 * Returns: Application protocol.
+     * Returns: Application protocol.
-	 *
+     *
-	 * Postcondition: $(D_INLINECODE protocol !is null)
+     * Postcondition: $(D_INLINECODE protocol !is null)
-	 */
+     */
-	@property Protocol protocol() pure nothrow @safe @nogc
+    @property Protocol protocol() pure nothrow @safe @nogc
-	out (protocol)
+    out (protocol)
-	{
+    {
-		assert(protocol !is null);
+        assert(protocol !is null);
-	}
+    }
-	/**
+    /**
-	 * Switches the protocol.
+     * Switches the protocol.
-	 *
+     *
-	 * The protocol is deallocated by the event loop, it should currently be
+     * The protocol is deallocated by the event loop, it should currently be
-	 * allocated with $(D_PSYMBOL MmapPool).
+     * allocated with $(D_PSYMBOL MmapPool).
-	 *
+     *
-	 * Params:
+     * Params:
-	 * 	protocol = Application protocol.
+     *  protocol = Application protocol.
-	 *
+     *
-	 * Precondition: $(D_INLINECODE protocol !is null)
+     * Precondition: $(D_INLINECODE protocol !is null)
-	 */
+     */
-	@property void protocol(Protocol protocol) pure nothrow @safe @nogc
+    @property void protocol(Protocol protocol) pure nothrow @safe @nogc
-	in
+    in
-	{
+    {
-		assert(protocol !is null);
+        assert(protocol !is null);
-	}
+    }
-	/**
+    /**
-	 * Returns $(D_PARAM true) if the transport is closing or closed.
+     * Returns $(D_PARAM true) if the transport is closing or closed.
-	 */
+     */
-	bool isClosing() const pure nothrow @safe @nogc;
+    bool isClosing() const pure nothrow @safe @nogc;
-	/**
+    /**
-	 * Close the transport.
+     * Close the transport.
-	 *
+     *
-	 * Buffered data will be flushed.  No more data will be received.
+     * Buffered data will be flushed.  No more data will be received.
-	 */
+     */
-	void close() @nogc;
+    void close() @nogc;
 }
 /**
@ -93,8 +93,8 @@ interface DuplexTransport : ReadTransport, WriteTransport
 */
 interface SocketTransport : Transport
 {
-	/**
+    /**
-	 * Returns: Socket.
+     * Returns: Socket.
-	 */
+     */
-	@property Socket socket() pure nothrow @safe @nogc;
+    @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.
+    /// Whether the watcher is active.
-	bool active;
+    bool active;
-	/**
+    /**
-	 * Invoke some action on event.
+     * Invoke some action on event.
-	 */
+     */
-	void invoke() @nogc;
+    void invoke() @nogc;
 }
 /**
@ -41,32 +41,32 @@ abstract class Watcher
 */
 abstract class SocketWatcher : Watcher
 {
-	/// Watched socket.
+    /// Watched socket.
-	protected Socket socket_;
+    protected Socket socket_;
-	/**
+    /**
-	 * Params:
+     * Params:
-	 * 	socket = Socket.
+     *  socket = Socket.
-	 *
+     *
-	 * Precondition: $(D_INLINECODE socket !is null)
+     * Precondition: $(D_INLINECODE socket !is null)
-	 */
+     */
-	this(Socket socket) pure nothrow @safe @nogc
+    this(Socket socket) pure nothrow @safe @nogc
-	in
+    in
-	{
+    {
-		assert(socket !is null);
+        assert(socket !is null);
-	}
+    }
-	body
+    body
-	{
+    {
-		socket_ = socket;
+        socket_ = socket;
-	}
+    }
-	/**
+    /**
-	 * Returns: Socket.
+     * Returns: Socket.
-	 */
+     */
-	@property Socket socket() pure nothrow @safe @nogc
+    @property Socket socket() pure nothrow @safe @nogc
-	{
+    {
-		return socket_;
+        return socket_;
-	}
+    }
 }
 /**
@ -74,44 +74,44 @@ abstract class SocketWatcher : Watcher
 */
 class ConnectionWatcher : SocketWatcher
 {
-	/// Incoming connection queue.
+    /// Incoming connection queue.
-	Queue!DuplexTransport incoming;
+    Queue!DuplexTransport incoming;
-	private Protocol delegate() @nogc protocolFactory;
+    private Protocol delegate() @nogc protocolFactory;
-	/**
+    /**
-	 * Params:
+     * Params:
-	 * 	socket = Socket.
+     *  socket = Socket.
-	 */
+     */
-	this(Socket socket) @nogc
+    this(Socket socket) @nogc
-	{
+    {
-		super(socket);
+        super(socket);
-		incoming = Queue!DuplexTransport(MmapPool.instance);
+        incoming = Queue!DuplexTransport(MmapPool.instance);
-	}
+    }
-	/**
+    /**
-	 * Params:
+     * Params:
-	 * 	P = Protocol should be used.
+     *  P = Protocol should be used.
-	 */
+     */
-	void setProtocol(P : Protocol)() @nogc
+    void setProtocol(P : Protocol)() @nogc
-	{
+    {
-		this.protocolFactory = () @nogc => cast(Protocol) MmapPool.instance.make!P;
+        this.protocolFactory = () @nogc => cast(Protocol) MmapPool.instance.make!P;
-	}
+    }
-	/**
+    /**
-	 * Invokes new connection callback.
+     * Invokes new connection callback.
-	 */
+     */
-	override void invoke() @nogc
+    override void invoke() @nogc
-	in
+    in
-	{
+    {
-		assert(protocolFactory !is null, "Protocol isn't set.");
+        assert(protocolFactory !is null, "Protocol isn't set.");
-	}
+    }
-	body
+    body
-	{
+    {
-		foreach (transport; incoming)
+        foreach (transport; incoming)
-		{
+        {
-			transport.protocol = protocolFactory();
+            transport.protocol = protocolFactory();
-			transport.protocol.connected(transport);
+            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
+     *  size      = Initial buffer size and the size by which the buffer will
-     * 	            grow.
+     *              grow.
-     * 	allocator = Allocator.
+     *  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
--- a/source/tanya/math/package.d
+++ b/source/tanya/math/package.d
@ -87,22 +87,22 @@ in
 }
 body
 {
-    size_t i = y.length;
+    size_t i;
    auto tmp1 = Integer(x, x.allocator);
    auto result = Integer(x.allocator);
    bool firstBit;
-    if (x.length == 0 && i != 0)
+    if (x.size == 0 && y.size != 0)
    {
-        i = 0;
+        i = y.size;
    }
    else
    {
        result = 1;
    }
-    while (i)
+    while (i < y.size)
    {
-        --i;
+        for (uint mask = 0x01; mask != 0x10000000; mask <<= 1)
        for (ubyte mask = 0x01; mask; mask <<= 1)
        {
            if (y.rep[i] & mask)
            {
@ -113,6 +113,7 @@ body
            tmp1 *= tmp2;
            tmp1 %= z;
        }
        ++i;
    }
    return result;
 }
--- a/source/tanya/memory/mmappool.d
+++ b/source/tanya/memory/mmappool.d
--- a/source/tanya/memory/package.d
+++ b/source/tanya/memory/package.d
@ -11,6 +11,7 @@
 module tanya.memory;
 import core.exception;
 import std.algorithm.iteration;
 public import std.experimental.allocator : make;
 import std.traits;
 public import tanya.memory.allocator;
@ -87,8 +88,8 @@ shared Allocator allocator;
 shared static this() nothrow @trusted @nogc
 {
-    import tanya.memory.mallocator;
+    import tanya.memory.mmappool;
-    allocator = Mallocator.instance;
+    allocator = MmapPool.instance;
 }
@property ref shared(Allocator) defaultAllocator() nothrow @safe @nogc
@ -202,41 +203,33 @@ private unittest
    assert(p is null);
 }
-/**
+/*
- * Destroys and deallocates $(D_PARAM p) of type $(D_PARAM T).
+ * Destroys the object.
- * It is assumed the respective entities had been allocated with the same
+ * Returns the memory should be freed.
 * allocator.
 *
 * Params:
 *  T         = Type of $(D_PARAM p).
 *  allocator = Allocator the $(D_PARAM p) was allocated with.
 *  p         = Object or array to be destroyed.
 */
-void dispose(T)(shared Allocator allocator, auto ref T* p)
+package(tanya) void[] finalize(T)(ref T* p)
 {
    static if (hasElaborateDestructor!T)
    {
        destroy(*p);
    }
-    () @trusted { allocator.deallocate((cast(void*) p)[0 .. T.sizeof]); }();
+    return (cast(void*) p)[0 .. T.sizeof];
    p = null;
 }
-/// Ditto.
+package(tanya) void[] finalize(T)(ref T p)
 void dispose(T)(shared Allocator allocator, auto ref T p)
    if (is(T == class) || is(T == interface))
 {
    if (p is null)
    {
-        return;
+        return null;
    }
    static if (is(T == interface))
    {
        version(Windows)
        {
            import core.sys.windows.unknwn : IUnknown;
-            static assert(!is(T: IUnknown), "COM interfaces can't be destroyed in "
+            static assert(!is(T : IUnknown), "COM interfaces can't be destroyed in "
-                                         ~ __PRETTY_FUNCTION__);
+                                           ~ __PRETTY_FUNCTION__);
        }
        auto ob = cast(Object) p;
    }
@ -244,19 +237,13 @@ void dispose(T)(shared Allocator allocator, auto ref T p)
    {
        alias ob = p;
    }
-    auto ptr = cast(void *) ob;
+    auto ptr = cast(void*) ob;
    auto support = ptr[0 .. typeid(ob).initializer.length];
    scope (success)
    {
        () @trusted { allocator.deallocate(support); }();
        p = null;
    }
    auto ppv = cast(void**) ptr;
    if (!*ppv)
    {
-        return;
+        return null;
    }
    auto pc = cast(ClassInfo*) *ppv;
    scope (exit)
@ -280,21 +267,35 @@ void dispose(T)(shared Allocator allocator, auto ref T p)
    {
        _d_monitordelete(cast(Object) ptr, true);
    }
    return support;
 }
-/// Ditto.
+package(tanya) void[] finalize(T)(ref T[] p)
 void dispose(T)(shared Allocator allocator, auto ref T[] p)
 {
    static if (hasElaborateDestructor!(typeof(p[0])))
    {
-        import std.algorithm.iteration;
+        p.each!((ref e) => destroy(e));
        p.each!(e => destroy(e));
    }
-    () @trusted { allocator.deallocate(p); }();
+    return p;
 }
 /**
 * Destroys and deallocates $(D_PARAM p) of type $(D_PARAM T).
 * It is assumed the respective entities had been allocated with the same
 * allocator.
 *
 * Params:
 *  T         = Type of $(D_PARAM p).
 *  allocator = Allocator the $(D_PARAM p) was allocated with.
 *  p         = Object or array to be destroyed.
 */
 void dispose(T)(shared Allocator allocator, auto ref T p)
 {
    () @trusted { allocator.deallocate(finalize(p)); }();
    p = null;
 }
-unittest
+private unittest
 {
    struct S
    {
--- a/source/tanya/memory/types.d
+++ b/source/tanya/memory/types.d
@ -14,9 +14,75 @@ import core.exception;
 import std.algorithm.comparison;
 import std.algorithm.mutation;
 import std.conv;
 import std.range;
 import std.traits;
 import tanya.memory;
 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;
    size_t opUnary(string op)()
        if (op == "--" || op == "++")
    in
    {
        assert(counter > 0);
    }
    body
    {
        mixin("return " ~ op ~ "counter;");
    }
    int opCmp(const size_t counter)
    {
        if (this.counter > counter)
        {
            return 1;
        }
        else if (this.counter < counter)
        {
            return -1;
        }
        else
        {
            return 0;
        }
    }
    int opEquals(const size_t counter)
    {
        return this.counter == counter;
    }
 }
 private void separateDeleter(T)(RefCountedStore!T storage,
                                shared Allocator allocator)
 {
    allocator.dispose(storage.payload);
    allocator.dispose(storage);
 }
 private void unifiedDeleter(T)(RefCountedStore!T storage,
                               shared Allocator allocator)
 {
    auto ptr1 = finalize(storage);
    auto ptr2 = finalize(storage.payload);
    allocator.deallocate(ptr1.ptr[0 .. ptr1.length + ptr2.length]);
 }
 /**
 * Reference-counted object containing a $(D_PARAM T) value as payload.
 * $(D_PSYMBOL RefCounted) keeps track of all references of an object, and
@ -27,78 +93,16 @@ import tanya.memory;
 */
 struct RefCounted(T)
 {
-    static if (is(T == class) || is(T == interface))
+    private alias Storage = RefCountedStore!(Payload!T);
    {
        private alias Payload = T;
    }
    else
    {
        private alias Payload = T*;
    }
    private class Storage
    {
        private Payload payload;
        private size_t counter = 1;
        private final size_t opUnary(string op)() pure nothrow @safe @nogc
            if (op == "--" || op == "++")
        in
        {
            assert(counter > 0);
        }
        body
        {
            mixin("return " ~ op ~ "counter;");
        }
        private final int opCmp(size_t counter) const pure nothrow @safe @nogc
        {
            if (this.counter > counter)
            {
                return 1;
            }
            else if (this.counter < counter)
            {
                return -1;
            }
            else
            {
                return 0;
            }
        }
        private final int opEquals(size_t counter) const pure nothrow @safe @nogc
        {
            return this.counter == counter;
        }
    }
    private final class RefCountedStorage : Storage
    {
        private shared Allocator allocator;
        this(shared Allocator allocator) pure nothrow @safe @nogc
        in
        {
            assert(allocator !is null);
        }
        body
        {
            this.allocator = allocator;
        }
        ~this() nothrow @nogc
        {
            allocator.dispose(payload);
        }
    }
    private Storage storage;
    private void function(Storage storage,
                          shared Allocator allocator) @nogc deleter;
    invariant
    {
        assert(storage is null || allocator_ !is null);
        assert(storage is null || deleter !is null);
    }
    /**
@ -112,11 +116,18 @@ struct RefCounted(T)
     *
     * Precondition: $(D_INLINECODE allocator !is null)
     */
-    this(Payload value, shared Allocator allocator = defaultAllocator)
+    this()(auto ref Payload!T value,
           shared Allocator allocator = defaultAllocator)
    {
        this(allocator);
-        storage = allocator.make!RefCountedStorage(allocator);
+        this.storage = allocator.make!Storage();
-        move(value, storage.payload);
+        this.deleter = &separateDeleter!(Payload!T);
        move(value, this.storage.payload);
        static if (__traits(isRef, value))
        {
            value = null;
        }
    }
    /// Ditto.
@ -137,7 +148,7 @@ struct RefCounted(T)
    {
        if (count != 0)
        {
-            ++storage;
+            ++this.storage;
        }
    }
@ -148,9 +159,9 @@ struct RefCounted(T)
     */
    ~this()
    {
-        if (storage !is null && !(storage.counter && --storage))
+        if (this.storage !is null && !(this.storage.counter && --this.storage))
        {
-            allocator_.dispose(storage);
+            deleter(this.storage, allocator);
        }
    }
@ -161,79 +172,74 @@ 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(Payload rhs)
+    ref typeof(this) opAssign()(auto ref Payload!T rhs)
    {
-        if (storage is null)
+        if (this.storage is null)
        {
-            storage = allocator.make!RefCountedStorage(allocator);
+            this.storage = allocator.make!Storage();
            this.deleter = &separateDeleter!(Payload!T);
        }
-        else if (storage > 1)
+        else if (this.storage > 1)
        {
-            --storage;
+            --this.storage;
-            storage = allocator.make!RefCountedStorage(allocator);
+            this.storage = allocator.make!Storage();
-        }
+            this.deleter = &separateDeleter!(Payload!T);
        else if (cast(RefCountedStorage) storage is null)
        {
            // Created with refCounted. Always destroyed togethter with the pointer.
            assert(storage.counter != 0);
            allocator.dispose(storage);
            storage = allocator.make!RefCountedStorage(allocator);
        }
        else
        {
-            allocator.dispose(storage.payload);
+            finalize(this.storage.payload);
            this.storage.payload = Payload!T.init;
        }
-        move(rhs, storage.payload);
+        move(rhs, this.storage.payload);
        return this;
    }
    /// Ditto.
    ref typeof(this) opAssign(typeof(null))
    {
-        if (storage is null)
+        if (this.storage is null)
        {
            return this;
        }
-        else if (storage > 1)
+        else if (this.storage > 1)
        {
-            --storage;
+            --this.storage;
            storage = null;
        }
        else if (cast(RefCountedStorage) storage is null)
        {
            // Created with refCounted. Always destroyed togethter with the pointer.
            assert(storage.counter != 0);
            allocator.dispose(storage);
            return this;
        }
        else
        {
-            allocator.dispose(storage.payload);
+            deleter(this.storage, allocator);
        }
        this.storage = null;
        return this;
    }
    /// Ditto.
    ref typeof(this) opAssign(typeof(this) rhs)
    {
-        swap(allocator_, rhs.allocator_);
+        swap(this.allocator_, rhs.allocator_);
-        swap(storage, rhs.storage);
+        swap(this.storage, rhs.storage);
        swap(this.deleter, rhs.deleter);
        return this;
    }
    /**
     * 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.");
@ -243,7 +249,7 @@ struct RefCounted(T)
        return storage.payload;
    }
-    static if (isPointer!Payload)
+    version (D_Ddoc)
    {
        /**
         * Params:
@ -254,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 == "*")
        {
@ -355,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*));
@ -380,15 +429,22 @@ private unittest
 *  args      = Constructor arguments of $(D_PARAM T).
 * 
 * Returns: Newly created $(D_PSYMBOL RefCounted!T).
 *
 * Precondition: $(D_INLINECODE allocator !is null)
 */
 RefCounted!T refCounted(T, A...)(shared Allocator allocator, auto ref A args)
    if (!is(T == interface) && !isAbstractClass!T
-         && !isArray!T && !isAssociativeArray!T)
+     && !isAssociativeArray!T && !isArray!T)
 in
 {
    assert(allocator !is null);
 }
 body
 {
    auto rc = typeof(return)(allocator);
-    immutable storageSize = alignedSize(stateSize!(RefCounted!T.Storage));
+    const storageSize = alignedSize(stateSize!(RefCounted!T.Storage));
-    immutable size = alignedSize(stateSize!T + storageSize);
+    const size = alignedSize(stateSize!T + storageSize);
    auto mem = (() @trusted => allocator.allocate(size))();
    if (mem is null)
@ -399,7 +455,7 @@ RefCounted!T refCounted(T, A...)(shared Allocator allocator, auto ref A args)
    {
        () @trusted { allocator.deallocate(mem); }();
    }
-    rc.storage = emplace!(RefCounted!T.Storage)(mem[0 .. storageSize]);
+    rc.storage = emplace!((RefCounted!T.Storage))(mem[0 .. storageSize]);
    static if (is(T == class))
    {
@ -410,9 +466,38 @@ RefCounted!T refCounted(T, A...)(shared Allocator allocator, auto ref A args)
        auto ptr = (() @trusted => (cast(T*) mem[storageSize .. $].ptr))();
        rc.storage.payload = emplace!T(ptr, args);
    }
    rc.deleter = &unifiedDeleter!(Payload!T);
    return rc;
 }
 /**
 * Constructs a new array with $(D_PARAM size) elements and wraps it in a
 * $(D_PSYMBOL RefCounted).
 *
 * Params:
 *  T         = Array type.
 *  size      = Array size.
 *  allocator = Allocator.
 *
 * Returns: Newly created $(D_PSYMBOL RefCounted!T).
 *
 * Precondition: $(D_INLINECODE allocator !is null
 *                           && size <= size_t.max / ElementType!T.sizeof)
 */
 RefCounted!T refCounted(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 RefCounted!T(payload, allocator);
 }
 ///
 unittest
 {
@ -456,3 +541,272 @@ private @nogc unittest
        assert(rc.count);
    }
 }
 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);
 }
--- a/source/tanya/network/inet.d
+++ b/source/tanya/network/inet.d
@ -0,0 +1,356 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 /**
 * Internet utilities.
 *
 * Copyright: Eugene Wissner 2016-2017.
 * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
 *                  Mozilla Public License, v. 2.0).
 * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
 */
 module tanya.network.inet;
 import std.math;
 import std.range.primitives;
 import std.traits;
 version (unittest)
 {
    version (Windows)
    {
        import core.sys.windows.winsock2;
        version = PlattformUnittest;
    }
    else version (Posix)
    {
        import core.sys.posix.arpa.inet;
        version = PlattformUnittest;
    }
 }
 /**
 * Represents an unsigned integer as an $(D_KEYWORD ubyte) range.
 *
 * The range is bidirectional. The byte order is always big-endian.
 *
 * It can accept any unsigned integral type but the value should fit
 * in $(D_PARAM L) bytes.
 *
 * Params:
 *  L = Desired range length.
 */
 struct NetworkOrder(uint L)
    if (L > ubyte.sizeof && L <= ulong.sizeof)
 {
    static if (L > uint.sizeof)
    {
        private alias StorageType = ulong;
    }
    else static if (L > ushort.sizeof)
    {
        private alias StorageType = uint;
    }
    else static if (L > ubyte.sizeof)
    {
        private alias StorageType = ushort;
    }
    else
    {
        private alias StorageType = ubyte;
    }
    private StorageType value;
    private size_t size = L;
    const pure nothrow @safe @nogc invariant
    {
        assert(this.size <= L);
    }
    /**
     * Constructs a new range.
     *
     * $(D_PARAM T) can be any unsigned type but $(D_PARAM value) cannot be
     * larger than the maximum can be stored in $(D_PARAM L) bytes. Otherwise
     * an assertion failure will be caused.
     *
     * Params:
     *  T      = Value type.
     *  value  = The value should be represented by this range.
     *
     * Precondition: $(D_INLINECODE value <= 2 ^^ (length * 8) - 1).
     */
    this(T)(const T value)
        if (isUnsigned!T)
    in
    {
        assert(value <= pow(2, L * 8) - 1);
    }
    body
    {
        this.value = value & StorageType.max;
    }
    /**
     * Returns: LSB.
     *
     * Precondition: $(D_INLINECODE length > 0).
     */
    @property ubyte back() const
    in
    {
        assert(this.length > 0);
    }
    body
    {
        return this.value & 0xff;
    }
    /**
     * Returns: MSB.
     *
     * Precondition: $(D_INLINECODE length > 0).
     */
    @property ubyte front() const
    in
    {
        assert(this.length > 0);
    }
    body
    {
        return (this.value >> ((this.length - 1) * 8)) & 0xff;
    }
    /**
     * Eliminates the LSB.
     *
     * Precondition: $(D_INLINECODE length > 0).
     */
    void popBack()
    in
    {
        assert(this.length > 0);
    }
    body
    {
        this.value >>= 8;
        --this.size;
    }
    /**
     * Eliminates the MSB.
     *
     * Precondition: $(D_INLINECODE length > 0).
     */
    void popFront()
    in
    {
        assert(this.length > 0);
    }
    body
    {
        this.value &= StorageType.max >> ((StorageType.sizeof - this.length) * 8);
        --this.size;
    }
    /**
     * Returns: Copy of this range.
     */
    typeof(this) save() const
    {
        return this;
    }
    /**
     * Returns: Whether the range is empty.
     */
    @property bool empty() const
    {
        return this.length == 0;
    }
    /**
     * Returns: Byte length.
     */
    @property size_t length() const
    {
        return this.size;
    }
 }
 ///
 pure nothrow @safe @nogc unittest
 {
    auto networkOrder = NetworkOrder!3(0xae34e2u);
    assert(!networkOrder.empty);
    assert(networkOrder.front == 0xae);
    networkOrder.popFront();
    assert(networkOrder.length == 2);
    assert(networkOrder.front == 0x34);
    assert(networkOrder.back == 0xe2);
    networkOrder.popBack();
    assert(networkOrder.length == 1);
    assert(networkOrder.front == 0x34);
    assert(networkOrder.front == 0x34);
    networkOrder.popFront();
    assert(networkOrder.empty);
 }
 // Static.
 private unittest
 {
    static assert(isBidirectionalRange!(NetworkOrder!4));
    static assert(isBidirectionalRange!(NetworkOrder!8));
    static assert(!is(NetworkOrder!9));
    static assert(!is(NetworkOrder!1));
 }
 // Tests against the system's htonl, htons.
 version (PlattformUnittest)
 {
    private unittest
    {
        for (uint counter; counter <= 8 * uint.sizeof; ++counter)
        {
            const value = pow(2, counter) - 1;
            const inNetworkOrder = htonl(value);
            const p = cast(ubyte*) &inNetworkOrder;
            auto networkOrder = NetworkOrder!4(value);
            assert(networkOrder.length == 4);
            assert(!networkOrder.empty);
            assert(networkOrder.front == *p);
            assert(networkOrder.back == *(p + 3));
            networkOrder.popBack();
            assert(networkOrder.length == 3);
            assert(networkOrder.front == *p);
            assert(networkOrder.back == *(p + 2));
            networkOrder.popFront();
            assert(networkOrder.length == 2);
            assert(networkOrder.front == *(p + 1));
            assert(networkOrder.back == *(p + 2));
            networkOrder.popFront();
            assert(networkOrder.length == 1);
            assert(networkOrder.front == *(p + 2));
            assert(networkOrder.back == *(p + 2));
            networkOrder.popBack();
            assert(networkOrder.length == 0);
            assert(networkOrder.empty);
        }
        for (ushort counter; counter <= 8 * ushort.sizeof; ++counter)
        {
            const value = cast(ushort) (pow(2, counter) - 1);
            const inNetworkOrder = htons(value);
            const p = cast(ubyte*) &inNetworkOrder;
            auto networkOrder = NetworkOrder!2(value);
            assert(networkOrder.length == 2);
            assert(!networkOrder.empty);
            assert(networkOrder.front == *p);
            assert(networkOrder.back == *(p + 1));
            networkOrder.popBack();
            assert(networkOrder.length == 1);
            assert(networkOrder.front == *p);
            assert(networkOrder.back == *p);
            networkOrder.popBack();
            assert(networkOrder.length == 0);
            assert(networkOrder.empty);
            networkOrder = NetworkOrder!2(value);
            networkOrder.popFront();
            assert(networkOrder.length == 1);
            assert(networkOrder.front == *(p + 1));
            assert(networkOrder.back == *(p + 1));
            networkOrder.popFront();
            assert(networkOrder.length == 0);
            assert(networkOrder.empty);
        }
    }
 }
 /**
 * Converts the $(D_KEYWORD ubyte) input range $(D_PARAM range) to
 * $(D_PARAM T).
 *
 * The byte order of $(D_PARAM r) is assumed to be big-endian. The length
 * cannot be larger than $(D_INLINECODE T.sizeof). Otherwise an assertion
 * failure will be caused.
 *
 * Params:
 *  T     = Desired return type.
 *  R     = Range type.
 *  range = Input range.
 *
 * Returns: Integral representation of $(D_PARAM range) with the host byte
 *          order.
 */
 T toHostOrder(T = size_t, R)(R range)
    if (isInputRange!R
     && !isInfinite!R
     && is(Unqual!(ElementType!R) == ubyte)
     && isUnsigned!T)
 {
    T ret;
    ushort pos = T.sizeof * 8;
    for (; !range.empty && range.front == 0; pos -= 8, range.popFront())
    {
    }
    for (; !range.empty; range.popFront())
    {
        assert(pos != 0);
        pos -= 8;
        ret |= (cast(T) range.front) << pos;
    }
    return ret >> pos;
 }
 ///
 pure nothrow @safe @nogc unittest
 {
    const value = 0xae34e2u;
    auto networkOrder = NetworkOrder!4(value);
    assert(networkOrder.toHostOrder() == value);
 }
 // Tests against the system's htonl, htons.
 version (PlattformUnittest)
 {
    private unittest
    {
        for (uint counter; counter <= 8 * uint.sizeof; ++counter)
        {
            const value = pow(2, counter) - 1;
            const inNetworkOrder = htonl(value);
            const p = cast(ubyte*) &inNetworkOrder;
            auto networkOrder = NetworkOrder!4(value);
            assert(p[0 .. uint.sizeof].toHostOrder() == value);
        }
        for (ushort counter; counter <= 8 * ushort.sizeof; ++counter)
        {
            const value = cast(ushort) (pow(2, counter) - 1);
            const inNetworkOrder = htons(value);
            const p = cast(ubyte*) &inNetworkOrder;
            auto networkOrder = NetworkOrder!2(value);
            assert(p[0 .. ushort.sizeof].toHostOrder() == value);
        }
    }
 }
--- a/source/tanya/network/package.d
+++ b/source/tanya/network/package.d
@ -0,0 +1,17 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 /**
 * Network programming.
 *
 * Copyright: Eugene Wissner 2016-2017.
 * License: $(LINK2 https://www.mozilla.org/en-US/MPL/2.0/,
 *                  Mozilla Public License, v. 2.0).
 * Authors: $(LINK2 mailto:info@caraus.de, Eugene Wissner)
 */
 module tanya.network;
 public import tanya.network.inet;
 public import tanya.network.socket;
 public import tanya.network.url;
--- a/source/tanya/network/socket.d
+++ b/source/tanya/network/socket.d
--- a/source/tanya/network/url.d
+++ b/source/tanya/network/url.d
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	65c3ca14ec	Integer storage optimization	2017-04-30 16:07:44 +02:00
Eugen Wissner	4fa47153ba	Make Integer representation little endian	2017-04-25 19:50:06 +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	628153e2e8	Make RefCounted work with dynamic arrays	2017-04-16 20:14:04 +02:00
Eugen Wissner	7aa9ac9f4a	Add internal finalize method for finalizing an object without deallocating	2017-04-16 20:13:20 +02:00
Eugen Wissner	cd944a61b7	Merge remote-tracking branch 'origin/master' into utf8string	2017-04-13 16:03:00 +02:00
Eugen Wissner	8156d0fe3a	Add support for dmd 2.074.0, remove 2.070.2	2017-04-13 16:02:18 +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	6e2ce5d686	Remove opApply from containers opApply requires additional overloads for the const containers (with a const delegate). If using a templated opApply foreach cannot infer the types for the variables. foreach with one argument still works (opIndex() is used), for more complex cases slicing should be used.	2017-04-07 16:00:50 +02:00
Eugen Wissner	ba6bf554fb	Make SList range public	2017-04-07 15:17:14 +02:00
Eugen Wissner	b1d2b9bd9e	Fix Vector.insertAfter/Before an empty range	2017-04-04 15:11:14 +02:00
Eugen Wissner	9b953198fa	Fix network.inet release build	2017-04-04 08:36:42 +02:00
Eugen Wissner	bc2a6d2703	Swap toHostOrder template parameters	2017-04-03 15:32:15 +02:00
Eugen Wissner	b458250ad7	Make NetworkOrder work with 8-byte integers	2017-04-02 20:55:22 +02:00
Eugen Wissner	b08d5e5d83	Add tanya.network.inet.toHostOrder The function reverts NetworkOrder.	2017-04-02 11:16:08 +02:00
Eugen Wissner	445b872e91	Add tanya.network.inet.NetworkOrder NetworkOrder converts an integral type into a bidirectional range with big-endian byte order.	2017-04-02 09:29:54 +02:00
Eugen Wissner	5e16fe98d6	Add tanya.network package file	2017-04-01 09:53:59 +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