Update socket documentationv0.10.0

17 files changed, 173 insertions, 132 deletions

diff --git a/source/tanya/algorithm/comparison.d b/source/tanya/algorithm/comparison.d
index 61dbcf6..029ddfa 100644
--- a/source/tanya/algorithm/comparison.d
+++ b/source/tanya/algorithm/comparison.d
@@ -278,10 +278,10 @@ if (isForwardRange!Range && isOrderingComparable!(ElementType!Range))
  * If the ranges have different lengths, they aren't equal.
  *
  * Params:
- *  R1     = First range type.
- *  R2     = Second range type.
- *  range1 = First range.
- *  range2 = Second range.
+ *  R1 = First range type.
+ *  R2 = Second range type.
+ *  r1 = First range.
+ *  r2 = Second range.
  *
  * Returns: $(D_KEYWORD true) if both ranges are equal, $(D_KEYWORD false)
  *          otherwise.
diff --git a/source/tanya/async/loop.d b/source/tanya/async/loop.d
index b56118f..f5c7dae 100644
--- a/source/tanya/async/loop.d
+++ b/source/tanya/async/loop.d
@@ -13,50 +13,52 @@
  *

  * class EchoProtocol : TransmissionControlProtocol

  * {

- *  private DuplexTransport transport;

+ *     private DuplexTransport transport;

  *

- *  void received(in ubyte[] data) @nogc

- *  {

- *      transport.write(data);

- *  }

+ *     void received(in ubyte[] data) @nogc

+ *     {

+ *         ubyte[512] buffer;

+ *         buffer[0 .. data.length] = data;

+ *         transport.write(buffer[]);

+ *     }

  *

- *  void connected(DuplexTransport transport) @nogc

- *  {

- *      this.transport = transport;

- *  }

+ *     void connected(DuplexTransport transport) @nogc

+ *     {

+ *         this.transport = transport;

+ *     }

  *

- *  void disconnected(SocketException e) @nogc

- *  {

- *  }

+ *     void disconnected(SocketException e) @nogc

+ *     {

+ *     }

  * }

  *

  * void main()

  * {

- *  auto address = defaultAllocator.make!InternetAddress("127.0.0.1", cast(ushort) 8192);

+ *     auto address = defaultAllocator.make!InternetAddress("127.0.0.1", cast(ushort) 8192);

  *

- *  version (Windows)

- *  {

- *      auto sock = defaultAllocator.make!OverlappedStreamSocket(AddressFamily.inet);

- *  }

- *  else

- *  {

- *      auto sock = defaultAllocator.make!StreamSocket(AddressFamily.inet);

- *      sock.blocking = false;

- *  }

+ *     version (Windows)

+ *     {

+ *         auto sock = defaultAllocator.make!OverlappedStreamSocket(AddressFamily.inet);

+ *     }

+ *     else

+ *     {

+ *         auto sock = defaultAllocator.make!StreamSocket(AddressFamily.inet);

+ *         sock.blocking = false;

+ *     }

  *

- *  sock.bind(address);

- *  sock.listen(5);

+ *     sock.bind(address);

+ *     sock.listen(5);

  *

- *  auto io = defaultAllocator.make!ConnectionWatcher(sock);

- *  io.setProtocol!EchoProtocol;

+ *     auto io = defaultAllocator.make!ConnectionWatcher(sock);

+ *     io.setProtocol!EchoProtocol;

  *

- *  defaultLoop.start(io);

- *  defaultLoop.run();

+ *     defaultLoop.start(io);

+ *     defaultLoop.run();

  *

- *  sock.shutdown();

- *  defaultAllocator.dispose(io);

- *  defaultAllocator.dispose(sock);

- *  defaultAllocator.dispose(address);

+ *     sock.shutdown();

+ *     defaultAllocator.dispose(io);

+ *     defaultAllocator.dispose(sock);

+ *     defaultAllocator.dispose(address);

  * }

  * ---

  *

diff --git a/source/tanya/container/buffer.d b/source/tanya/container/buffer.d
index a4ffebc..4866ca7 100644
--- a/source/tanya/container/buffer.d
+++ b/source/tanya/container/buffer.d
@@ -51,7 +51,7 @@ version (unittest)
  *  T = Buffer type.

  */

 struct ReadBuffer(T = ubyte)

-    if (isScalarType!T)

+if (isScalarType!T)

 {

     /// Internal buffer.

     private T[] buffer_;

@@ -66,16 +66,16 @@ struct ReadBuffer(T = ubyte)
     private size_t ring;

 

     /// Available space.

-    private immutable size_t minAvailable = 1024;

+    private size_t minAvailable = 1024;

 

     /// Size by which the buffer will grow.

-    private immutable size_t blockSize = 8192;

+    private size_t blockSize = 8192;

 

     invariant

     {

-        assert(length_ <= buffer_.length);

-        assert(blockSize > 0);

-        assert(minAvailable > 0);

+        assert(this.length_ <= this.buffer_.length);

+        assert(this.blockSize > 0);

+        assert(this.minAvailable > 0);

     }

 

     /**

@@ -89,14 +89,14 @@ struct ReadBuffer(T = ubyte)
      *                 $(D_PSYMBOL free) < $(D_PARAM minAvailable)).

      *  allocator    = Allocator.

      */

-    this(in size_t size,

-         in size_t minAvailable = 1024,

+    this(size_t size,

+         size_t minAvailable = 1024,

          shared Allocator allocator = defaultAllocator) @trusted

     {

         this(allocator);

         this.minAvailable = minAvailable;

         this.blockSize = size;

-        buffer_ = cast(T[]) allocator_.allocate(size * T.sizeof);

+        this.buffer_ = cast(T[]) allocator_.allocate(size * T.sizeof);

     }

 

     /// ditto

@@ -115,7 +115,7 @@ struct ReadBuffer(T = ubyte)
      */

     ~this() @trusted

     {

-        allocator.deallocate(buffer_);

+        allocator.deallocate(this.buffer_);

     }

 

     ///

@@ -131,7 +131,7 @@ struct ReadBuffer(T = ubyte)
      */

     @property size_t capacity() const

     {

-        return buffer_.length;

+        return this.buffer_.length;

     }

 

     /**

@@ -139,7 +139,7 @@ struct ReadBuffer(T = ubyte)
      */

     @property size_t length() const

     {

-        return length_ - start;

+        return this.length_ - start;

     }

 

     /// ditto

@@ -152,7 +152,7 @@ struct ReadBuffer(T = ubyte)
      */

     void clear()

     {

-        start = length_ = ring;

+        start = this.length_ = ring;

     }

 

     /**

@@ -187,10 +187,10 @@ struct ReadBuffer(T = ubyte)
      *

      * Returns: $(D_KEYWORD this).

      */

-    ref ReadBuffer opOpAssign(string op)(in size_t length)

+    ref ReadBuffer opOpAssign(string op)(size_t length)

         if (op == "+")

     {

-        length_ += length;

+        this.length_ += length;

         ring = start;

         return this;

     }

@@ -234,9 +234,9 @@ struct ReadBuffer(T = ubyte)
      *

      * Returns: Array between $(D_PARAM start) and $(D_PARAM end).

      */

-    T[] opSlice(in size_t start, in size_t end)

+    T[] opSlice(size_t start, size_t end)

     {

-        return buffer_[this.start + start .. this.start + end];

+        return this.buffer_[this.start + start .. this.start + end];

     }

 

     /**

@@ -250,23 +250,24 @@ struct ReadBuffer(T = ubyte)
     {

         if (start > 0)

         {

-            auto ret = buffer_[0 .. start];

+            auto ret = this.buffer_[0 .. start];

             ring = 0;

             return ret;

         }

         else

         {

-            if (capacity - length < minAvailable)

+            if (capacity - length < this.minAvailable)

             {

-                void[] buf = buffer_;

-                immutable cap = capacity;

+                void[] buf = this.buffer_;

+                const cap = capacity;

                 () @trusted {

-                    allocator.reallocate(buf, (cap + blockSize) * T.sizeof);

-                    buffer_ = cast(T[]) buf;

+                    allocator.reallocate(buf,

+                                         (cap + this.blockSize) * T.sizeof);

+                    this.buffer_ = cast(T[]) buf;

                 }();

             }

-            ring = length_;

-            return buffer_[length_ .. $];

+            ring = this.length_;

+            return this.buffer_[this.length_ .. $];

         }

     }

 

@@ -310,7 +311,7 @@ struct ReadBuffer(T = ubyte)
  *  T = Buffer type.

  */

 struct WriteBuffer(T = ubyte)

-    if (isScalarType!T)

+if (isScalarType!T)

 {

     /// Internal buffer.

     private T[] buffer_;

@@ -322,16 +323,16 @@ struct WriteBuffer(T = ubyte)
     private size_t ring;

 

     /// Size by which the buffer will grow.

-    private immutable size_t blockSize;

+    private const size_t blockSize;

 

     /// The position of the free area in the buffer.

     private size_t position;

 

     invariant

     {

-        assert(blockSize > 0);

+        assert(this.blockSize > 0);

         // Position can refer to an element outside the buffer if the buffer is full.

-        assert(position <= buffer_.length);

+        assert(this.position <= this.buffer_.length);

     }

 

     /**

@@ -342,7 +343,7 @@ struct WriteBuffer(T = ubyte)
      *

      * Precondition: $(D_INLINECODE size > 0 && allocator !is null)

      */

-    this(in size_t size, shared Allocator allocator = defaultAllocator) @trusted

+    this(size_t size, shared Allocator allocator = defaultAllocator) @trusted

     in

     {

         assert(size > 0);

@@ -350,10 +351,10 @@ struct WriteBuffer(T = ubyte)
     }

     do

     {

-        blockSize = size;

+        this.blockSize = size;

         ring = size - 1;

         allocator_ = allocator;

-        buffer_ = cast(T[]) allocator_.allocate(size * T.sizeof);

+        this.buffer_ = cast(T[]) allocator_.allocate(size * T.sizeof);

     }

 

     @disable this();

@@ -363,7 +364,7 @@ struct WriteBuffer(T = ubyte)
      */

     ~this()

     {

-        allocator.deallocate(buffer_);

+        allocator.deallocate(this.buffer_);

     }

 

     /**

@@ -371,7 +372,7 @@ struct WriteBuffer(T = ubyte)
      */

     @property size_t capacity() const

     {

-        return buffer_.length;

+        return this.buffer_.length;

     }

 

     /**

@@ -384,13 +385,13 @@ struct WriteBuffer(T = ubyte)
      */

     @property size_t length() const

     {

-        if (position > ring || position < start) // Buffer overflowed

+        if (this.position > ring || this.position < start) // Buffer overflowed

         {

             return ring - start + 1;

         }

         else

         {

-            return position - start;

+            return this.position - start;

         }

     }

 

@@ -433,61 +434,62 @@ struct WriteBuffer(T = ubyte)
      * Params:

      *  buffer = Buffer chunk got with $(D_PSYMBOL opIndex).

      */

-    ref WriteBuffer opOpAssign(string op)(in T[] buffer)

+    ref WriteBuffer opOpAssign(string op)(const T[] buffer)

         if (op == "~")

     {

         size_t end, start;

 

-        if (position >= this.start && position <= ring)

+        if (this.position >= this.start && this.position <= ring)

         {

             auto afterRing = ring + 1;

 

-            end = position + buffer.length;

+            end = this.position + buffer.length;

             if (end > afterRing)

             {

                 end = afterRing;

             }

-            start = end - position;

-            buffer_[position .. end] = buffer[0 .. start];

+            start = end - this.position;

+            this.buffer_[this.position .. end] = buffer[0 .. start];

             if (end == afterRing)

             {

-                position = this.start == 0 ? afterRing : 0;

+                this.position = this.start == 0 ? afterRing : 0;

             }

             else

             {

-                position = end;

+                this.position = end;

             }

         }

 

         // Check if we have some free space at the beginning

-        if (start < buffer.length && position < this.start)

+        if (start < buffer.length && this.position < this.start)

         {

-            end = position + buffer.length - start;

+            end = this.position + buffer.length - start;

             if (end > this.start)

             {

                 end = this.start;

             }

-            auto areaEnd = end - position + start;

-            buffer_[position .. end] = buffer[start .. areaEnd];

-            position = end == this.start ? ring + 1 : end - position;

+            auto areaEnd = end - this.position + start;

+            this.buffer_[this.position .. end] = buffer[start .. areaEnd];

+            this.position = end == this.start ? ring + 1 : end - this.position;

             start = areaEnd;

         }

 

         // And if we still haven't found any place, save the rest in the overflow area

         if (start < buffer.length)

         {

-            end = position + buffer.length - start;

+            end = this.position + buffer.length - start;

             if (end > capacity)

             {

-                auto newSize = (end / blockSize * blockSize + blockSize) * T.sizeof;

+                const newSize = end / this.blockSize * this.blockSize

+                              + this.blockSize;

                 () @trusted {

-                    void[] buf = buffer_;

-                    allocator.reallocate(buf, newSize);

-                    buffer_ = cast(T[]) buf;

+                    void[] buf = this.buffer_;

+                    allocator.reallocate(buf, newSize * T.sizeof);

+                    this.buffer_ = cast(T[]) buf;

                 }();

             }

-            buffer_[position .. end] = buffer[start .. $];

-            position = end;

+            this.buffer_[this.position .. end] = buffer[start .. $];

+            this.position = end;

             if (this.start == 0)

             {

                 ring = capacity - 1;

@@ -506,7 +508,7 @@ struct WriteBuffer(T = ubyte)
      *

      * Returns: $(D_KEYWORD this).

      */

-    ref WriteBuffer opOpAssign(string op)(in size_t length)

+    ref WriteBuffer opOpAssign(string op)(size_t length)

         if (op == "+")

     in

     {

@@ -521,42 +523,42 @@ struct WriteBuffer(T = ubyte)
         {

             return this;

         }

-        else if (position <= afterRing)

+        else if (this.position <= afterRing)

         {

             start += length;

-            if (start > 0 && position == afterRing)

+            if (start > 0 && this.position == afterRing)

             {

-                position = oldStart;

+                this.position = oldStart;

             }

         }

         else

         {

-            auto overflow = position - afterRing;

+            auto overflow = this.position - afterRing;

 

             if (overflow > length)

             {

-                immutable afterLength = afterRing + length;

-                buffer_[start .. start + length] = buffer_[afterRing .. afterLength];

-                buffer_[afterRing .. afterLength] = buffer_[afterLength .. position];

-                position -= length;

+                const afterLength = afterRing + length;

+                this.buffer_[start .. start + length] = this.buffer_[afterRing .. afterLength];

+                this.buffer_[afterRing .. afterLength] = this.buffer_[afterLength .. this.position];

+                this.position -= length;

             }

             else if (overflow == length)

             {

-                buffer_[start .. start + overflow] = buffer_[afterRing .. position];

-                position -= overflow;

+                this.buffer_[start .. start + overflow] = this.buffer_[afterRing .. this.position];

+                this.position -= overflow;

             }

             else

             {

-                buffer_[start .. start + overflow] = buffer_[afterRing .. position];

-                position = overflow;

+                this.buffer_[start .. start + overflow] = this.buffer_[afterRing .. this.position];

+                this.position = overflow;

             }

             start += length;

 

-            if (start == position)

+            if (start == this.position)

             {

-                if (position != afterRing)

+                if (this.position != afterRing)

                 {

-                    position = 0;

+                    this.position = 0;

                 }

                 start = 0;

                 ring = capacity - 1;

@@ -596,15 +598,15 @@ struct WriteBuffer(T = ubyte)
      *

      * Returns: A chunk of data buffer.

      */

-    T[] opSlice(in size_t start, in size_t end)

+    T[] opSlice(size_t start, size_t end)

     {

-        if (position > ring || position < start) // Buffer overflowed

+        if (this.position > ring || this.position < start) // Buffer overflowed

         {

-            return buffer_[this.start .. ring + 1 - length + end];

+            return this.buffer_[this.start .. ring + 1 - length + end];

         }

         else

         {

-            return buffer_[this.start .. this.start + end];

+            return this.buffer_[this.start .. this.start + end];

         }

     }

 

diff --git a/source/tanya/conv.d b/source/tanya/conv.d
index 70e97fa..61935f6 100644
--- a/source/tanya/conv.d
+++ b/source/tanya/conv.d
@@ -5,7 +5,7 @@
 /**
  * This module provides functions for converting between different types.
  *
- * Copyright: Eugene Wissner 2017.
+ * Copyright: Eugene Wissner 2017-2018.
  * 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)
diff --git a/source/tanya/exception.d b/source/tanya/exception.d
index c329999..936e4a7 100644
--- a/source/tanya/exception.d
+++ b/source/tanya/exception.d
@@ -5,7 +5,7 @@
 /**
  * Common exceptions and errors.
  *
- * Copyright: Eugene Wissner 2017.
+ * Copyright: Eugene Wissner 2017-2018.
  * 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)
diff --git a/source/tanya/format.d b/source/tanya/format.d
index c1b087e..4bd0983 100644
--- a/source/tanya/format.d
+++ b/source/tanya/format.d
@@ -3,9 +3,10 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
- * This package contains formatting and conversion functions.
+ * This package doesn't yet contain public symbols. Refer to
+ * $(D_PSYMBOL tanya.conv) for basic formatting and conversion functionality.
  *
- * Copyright: Eugene Wissner 2017.
+ * Copyright: Eugene Wissner 2017-2018.
  * 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)
diff --git a/source/tanya/math/package.d b/source/tanya/math/package.d
index 58c7ad9..0aad01d 100644
--- a/source/tanya/math/package.d
+++ b/source/tanya/math/package.d
@@ -38,7 +38,7 @@ enum IEEEPrecision : ubyte
 /**
  * Tests the precision of floating-point type $(D_PARAM F).
  *
- * For $(D_KEYWORD float), $(D_PSYMBOL ieeePrecision) always evaluates to
+ * For $(D_KEYWORD float) $(D_PSYMBOL ieeePrecision) always evaluates to
  * $(D_INLINECODE IEEEPrecision.single); for $(D_KEYWORD double) - to
  * $(D_INLINECODE IEEEPrecision.double). It returns different values only
  * for $(D_KEYWORD real), since $(D_KEYWORD real) is a platform-dependent type.
@@ -396,7 +396,7 @@ if (isFloatingPoint!F)
 
 /**
  * Determines whether $(D_PARAM x) is a denormilized number or not.
-
+ *
  * Denormalized number is a number between `0` and `1` that cannot be
  * represented as
  *
@@ -459,7 +459,7 @@ if (isFloatingPoint!F)
 
 /**
  * Determines whether $(D_PARAM x) is a normilized number or not.
-
+ *
  * Normalized number is a number that can be represented as
  *
  * <pre>
diff --git a/source/tanya/network/package.d b/source/tanya/network/package.d
index 6cae18c..185d27c 100644
--- a/source/tanya/network/package.d
+++ b/source/tanya/network/package.d
@@ -5,7 +5,7 @@
 /**
  * Network programming.
  *
- * Copyright: Eugene Wissner 2016-2017.
+ * Copyright: Eugene Wissner 2016-2018.
  * 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)
diff --git a/source/tanya/network/socket.d b/source/tanya/network/socket.d
index a7d304a..b50d3f0 100644
--- a/source/tanya/network/socket.d
+++ b/source/tanya/network/socket.d
@@ -5,7 +5,43 @@
 /**
  * Low-level socket programming.
  *
- * Copyright: Eugene Wissner 2016-2017.
+ * Current API supports only server-side TCP communication.
+ *
+ * Here is an example of a cross-platform blocking server:
+ *
+ * ---
+ * import std.stdio;
+ * import tanya.memory;
+ * import tanya.network;
+ *
+ * void main()
+ * {
+ *     auto socket = defaultAllocator.make!StreamSocket(AddressFamily.inet);
+ *     auto address = defaultAllocator.make!InternetAddress("127.0.0.1",
+ *                                                          cast(ushort) 8192);
+ *
+ *     socket.setOption(SocketOptionLevel.SOCKET, SocketOption.REUSEADDR, true);
+ *     socket.blocking = true;
+ *     socket.bind(address);
+ *     socket.listen(5);
+ *
+ *     auto client = socket.accept();
+ *     client.send(cast(const(ubyte)[]) "Test\n");
+ *
+ *     ubyte[100] buf;
+ *     auto response = client.receive(buf[]);
+ *
+ *     writeln(cast(const(char)[]) buf[0 .. response]);
+ *
+ *     defaultAllocator.dispose(client);
+ *     defaultAllocator.dispose(socket);
+ * }
+ * ---
+ *
+ * For an example of an asynchronous server refer to the documentation of the
+ * $(D_PSYMBOL tanya.async.loop) module.
+ *
+ * Copyright: Eugene Wissner 2016-2018.
  * 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)
diff --git a/source/tanya/os/package.d b/source/tanya/os/package.d
index 3cb621c..5292a8a 100644
--- a/source/tanya/os/package.d
+++ b/source/tanya/os/package.d
@@ -6,7 +6,7 @@
  * This package provides platform-independent interfaces to operating system
  * functionality.
  *
- * Copyright: Eugene Wissner 2017.
+ * Copyright: Eugene Wissner 2017-2018.
  * 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)
diff --git a/source/tanya/sys/windows/def.d b/source/tanya/sys/windows/def.d
index f4e5d04..6fe920e 100644
--- a/source/tanya/sys/windows/def.d
+++ b/source/tanya/sys/windows/def.d
@@ -16,7 +16,7 @@
  * defined here.
  * Also aliases for specific types like $(D_PSYMBOL SOCKET) are defined here.
  *
- * Copyright: Eugene Wissner 2017.
+ * Copyright: Eugene Wissner 2017-2018.
  * 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)
@@ -58,4 +58,4 @@ align(1) struct GUID
     ushort Data2;
     ushort Data3;
     char[8] Data4;
-}
\ No newline at end of file
+}
diff --git a/source/tanya/sys/windows/error.d b/source/tanya/sys/windows/error.d
index 3f6e71c..9ce6bf8 100644
--- a/source/tanya/sys/windows/error.d
+++ b/source/tanya/sys/windows/error.d
@@ -3,7 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
- * Copyright: Eugene Wissner 2017.
+ * Copyright: Eugene Wissner 2017-2018.
  * 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)
diff --git a/source/tanya/sys/windows/package.d b/source/tanya/sys/windows/package.d
index 07b17d7..8ecb96b 100644
--- a/source/tanya/sys/windows/package.d
+++ b/source/tanya/sys/windows/package.d
@@ -3,7 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /**
- * Copyright: Eugene Wissner 2017.
+ * Copyright: Eugene Wissner 2017-2018.
  * 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)
@@ -17,4 +17,4 @@ version (Windows):
 public import tanya.sys.windows.def;
 public import tanya.sys.windows.error;
 public import tanya.sys.windows.winbase;
-public import tanya.sys.windows.winsock2;
\ No newline at end of file
+public import tanya.sys.windows.winsock2;
diff --git a/source/tanya/sys/windows/winbase.d b/source/tanya/sys/windows/winbase.d
index bbcc712..02978a3 100644
--- a/source/tanya/sys/windows/winbase.d
+++ b/source/tanya/sys/windows/winbase.d
@@ -5,7 +5,7 @@
 /**
  * Definitions from winbase.h.
  *
- * Copyright: Eugene Wissner 2017.
+ * Copyright: Eugene Wissner 2017-2018.
  * 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)
@@ -52,4 +52,4 @@ extern(Windows)
 BOOL GetOverlappedResult(HANDLE hFile,
                          OVERLAPPED* lpOverlapped,
                          DWORD* lpNumberOfBytesTransferred,
-                         BOOL bWait) nothrow @system @nogc;
\ No newline at end of file
+                         BOOL bWait) nothrow @system @nogc;
diff --git a/source/tanya/sys/windows/winsock2.d b/source/tanya/sys/windows/winsock2.d
index c9bae7f..8a00ed9 100644
--- a/source/tanya/sys/windows/winsock2.d
+++ b/source/tanya/sys/windows/winsock2.d
@@ -5,7 +5,7 @@
 /**
  * Definitions from winsock2.h, ws2def.h and MSWSock.h.
  *
- * Copyright: Eugene Wissner 2017.
+ * Copyright: Eugene Wissner 2017-2018.
  * 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)
@@ -216,4 +216,4 @@ enum
     SO_UPDATE_ACCEPT_CONTEXT = 0x700B,
     SO_CONNECT_TIME = 0x700C,
     SO_UPDATE_CONNECT_CONTEXT = 0x7010,
-}
\ No newline at end of file
+}
diff --git a/source/tanya/test/assertion.d b/source/tanya/test/assertion.d
index 4a82102..10105d7 100644
--- a/source/tanya/test/assertion.d
+++ b/source/tanya/test/assertion.d
@@ -13,7 +13,7 @@
  * The functions can cause segmentation fault if the module is compiled
  * in production mode and the condition fails.
  *
- * Copyright: Eugene Wissner 2017.
+ * Copyright: Eugene Wissner 2017-2018.
  * 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)
diff --git a/source/tanya/test/package.d b/source/tanya/test/package.d
index a1e339f..2e34702 100644
--- a/source/tanya/test/package.d
+++ b/source/tanya/test/package.d
@@ -5,7 +5,7 @@
 /**
  * Test suite for $(D_KEYWORD unittest)-blocks.
  *
- * Copyright: Eugene Wissner 2017.
+ * Copyright: Eugene Wissner 2017-2018.
  * 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)