Remove all trailing whitespace

sed 's/[ \t]*$//' -i **/*.d

source/vibe/core/concurrency.d

@@ -1237,7 +1237,7 @@ package class VibedScheduler : Scheduler {
 
 		final switch (st_concurrencyPrimitive) with (ConcurrencyPrimitive) {
 			case task: runTask(op); break;
-			case workerTask: 
+			case workerTask:
 				static void wrapper(shared(void delegate()) op) {
 					(cast(void delegate())op)();
 				}

source/vibe/core/connectionpool.d

@@ -133,7 +133,7 @@ unittest {
 
 struct LockedConnection(Connection) {
 	import vibe.core.task : Task;
-	
+
 	private {
 		ConnectionPool!Connection m_pool;
 		Task m_task;

source/vibe/core/core.d

@@ -661,7 +661,7 @@ void yield()
 	to call `switchToTask` will result in task starvation and resource leakage.
 
 	Params:
-		on_interrupt = If specified, is required to 
+		on_interrupt = If specified, is required to
 
 	See_Also: `switchToTask`
 */
@@ -1042,7 +1042,7 @@ struct Timer {
 
 	/** Resets the timer to the specified timeout
 	*/
-	void rearm(Duration dur, bool periodic = false) nothrow 
+	void rearm(Duration dur, bool periodic = false) nothrow
 		in { assert(dur > 0.seconds, "Negative timer duration specified."); }
 		body { m_driver.set(m_id, dur, periodic ? dur : 0.seconds); }
 

source/vibe/core/file.d

@@ -410,7 +410,7 @@ struct FileStream {
 		if (m_fd != FileFD.invalid)
 			eventDriver.files.addRef(m_fd);
 	}
-	
+
 	~this()
 	{
 		if (m_fd != FileFD.invalid)

source/vibe/core/log.d

@@ -252,7 +252,7 @@ final class FileLogger : Logger {
 	Format infoFormat = Format.thread;
 
 	/** Use escape sequences to color log output.
-		
+
 		Note that the terminal must support 256-bit color codes.
 	*/
 	bool useColors = false;

source/vibe/core/net.d

@@ -192,9 +192,9 @@ TCPConnection connectTCP(NetworkAddress addr, NetworkAddress bind_address = anyA
 	return () @trusted { // scope
 		scope uaddr = new RefAddress(addr.sockAddr, addr.sockAddrLen);
 		scope baddr = new RefAddress(bind_address.sockAddr, bind_address.sockAddrLen);
-		
+
 		// FIXME: make this interruptible
-		auto result = asyncAwaitUninterruptible!(ConnectCallback, 
+		auto result = asyncAwaitUninterruptible!(ConnectCallback,
 			cb => eventDriver.sockets.connectStream(uaddr, baddr, cb)
 			//cb => eventDriver.sockets.cancelConnect(cb)
 		);
@@ -511,7 +511,7 @@ struct TCPConnection {
 	@property bool empty() { return leastSize == 0; }
 	@property ulong leastSize() { waitForData(); return m_context && m_context.readBuffer.length; }
 	@property bool dataAvailableForRead() { return waitForData(0.seconds); }
-	
+
 	void close()
 	nothrow {
 		//logInfo("close %s", cast(int)m_fd);
@@ -522,7 +522,7 @@ struct TCPConnection {
 			m_context = null;
 		}
 	}
-	
+
 	bool waitForData(Duration timeout = Duration.max)
 	{
 mixin(tracer);
@@ -602,7 +602,7 @@ mixin(tracer);
 		auto res = asyncAwait!(IOCallback,
 			cb => eventDriver.sockets.write(m_socket, bytes, mode, cb),
 			cb => eventDriver.sockets.cancelWrite(m_socket));
-		
+
 		switch (res[1]) {
 			default:
 				throw new Exception("Error writing data to socket.");
@@ -667,7 +667,7 @@ private void loopWithTimeout(alias LoopBody, ExceptionType = Exception)(Duration
 	do {
 		if (LoopBody(timeout))
 			return;
-		
+
 		if (timeout != Duration.max) {
 			auto prev = now;
 			now = Clock.currTime(UTC());
@@ -722,7 +722,7 @@ struct UDPConnection {
 		Context* m_context;
 	}
 
-	private this(ref NetworkAddress bind_address) 
+	private this(ref NetworkAddress bind_address)
 	{
 		scope baddr = new RefAddress(bind_address.sockAddr, bind_address.sockAddrLen);
 		m_socket = eventDriver.sockets.createDatagramSocket(baddr, null);

source/vibe/core/path.d

@@ -391,7 +391,7 @@ struct GenericPath(F) {
 
 	/** Constructs a path from an input range of `Segment`s.
 
-		Throws: 
+		Throws:
 			Since path segments are pre-validated, this constructor does not
 			throw an exception.
 	*/

source/vibe/core/sync.d

@@ -158,8 +158,8 @@ class LocalTaskSemaphore
 		LocalManualEvent m_signal;
 	}
 
-	this(uint max_locks) 
+	this(uint max_locks)
-	{ 
+	{
 		m_maxLocks = max_locks;
 		m_signal = createManualEvent();
 	}
@@ -182,10 +182,10 @@ class LocalTaskSemaphore
 			than one.
 	*/
 	bool tryLock()
-	{		
+	{
-		if (available > 0) 
+		if (available > 0)
 		{
-			m_locks++; 
+			m_locks++;
 			return true;
 		}
 		return false;
@@ -202,13 +202,13 @@ class LocalTaskSemaphore
 
 		if (tryLock())
 			return;
-		
+
 		ThreadWaiter w;
 		w.priority = priority;
 		w.seq = min(0, m_seq - w.priority);
 		if (++m_seq == uint.max)
 			rewindSeq();
-		
+
 		() @trusted { m_waiters.insert(w); } ();
 
 		while (true) {
@@ -222,7 +222,7 @@ class LocalTaskSemaphore
 
 	/** Gives up an existing lock.
 	*/
-	void unlock() 
+	void unlock()
 	{
 		assert(m_locks >= 1);
 		m_locks--;
@@ -232,7 +232,7 @@ class LocalTaskSemaphore
 
 	// if true, a goes after b. ie. b comes out front()
 	/// private
-	static bool asc(ref ThreadWaiter a, ref ThreadWaiter b) 
+	static bool asc(ref ThreadWaiter a, ref ThreadWaiter b)
 	{
 		if (a.priority != b.priority)
 			return a.priority < b.priority;
@@ -735,7 +735,7 @@ struct LocalManualEvent {
 	int wait(int emit_count) { return doWait!true(Duration.max, emit_count); }
 	/// ditto
 	int wait(Duration timeout, int emit_count) { return doWait!true(timeout, emit_count); }
-	
+
 	/** Same as $(D wait), but defers throwing any $(D InterruptException).
 
 		This method is annotated $(D nothrow) at the expense that it cannot be
@@ -905,7 +905,7 @@ struct ManualEvent {
 	int wait(int emit_count) shared { return doWaitShared!true(Duration.max, emit_count); }
 	/// ditto
 	int wait(Duration timeout, int emit_count) shared { return doWaitShared!true(timeout, emit_count); }
-	
+
 	/** Same as $(D wait), but defers throwing any $(D InterruptException).
 
 		This method is annotated $(D nothrow) at the expense that it cannot be
@@ -1183,7 +1183,7 @@ private struct ThreadLocalWaiter {
 		} else {
 			asyncAwaitAny!interruptible(timeout, waitable);
 		}
-		
+
 		if (waitable.cancelled) {
 			removeWaiter();
 			return false;
@@ -1481,7 +1481,7 @@ private struct TaskConditionImpl(bool INTERRUPTIBLE, LOCKABLE) {
  *  the actual functionality of their method calls.
  *
  *  The method implementations are based on two static parameters
- *  ($(D INTERRUPTIBLE) and $(D INTENT)), which are configured through 
+ *  ($(D INTERRUPTIBLE) and $(D INTENT)), which are configured through
  *  template arguments:
  *
  *  - $(D INTERRUPTIBLE) determines whether the mutex implementation
@@ -1498,12 +1498,12 @@ private struct ReadWriteMutexState(bool INTERRUPTIBLE)
 {
     /** The policy with which the mutex should operate.
      *
-     *  The policy determines how the acquisition of the locks is 
+     *  The policy determines how the acquisition of the locks is
      *  performed and can be used to tune the mutex according to the
      *  underlying algorithm in which it is used.
      *
      *  According to the provided policy, the mutex will either favor
-     *  reading or writing tasks and could potentially starve the 
+     *  reading or writing tasks and could potentially starve the
      *  respective opposite.
      *
      *  cf. $(D core.sync.rwmutex.ReadWriteMutex.Policy)
@@ -1515,7 +1515,7 @@ private struct ReadWriteMutexState(bool INTERRUPTIBLE)
         /** Writers are prioritized, readers may be starved as a result. */
         PREFER_WRITERS
     }
-    
+
     /** The intent with which a locking operation is performed.
      *
      *  Since both locks share the same underlying algorithms, the actual
@@ -1531,23 +1531,23 @@ private struct ReadWriteMutexState(bool INTERRUPTIBLE)
          *  hold a lock at any given time. */
         READ_WRITE = 1
     }
-    
+
     private {
         //Queue counters
         /** The number of reading tasks waiting for the lock to become available. */
         shared(uint)  m_waitingForReadLock = 0;
         /** The number of writing tasks waiting for the lock to become available. */
         shared(uint)  m_waitingForWriteLock = 0;
-        
+
         //Lock counters
         /** The number of reading tasks that currently hold the lock. */
         uint  m_activeReadLocks = 0;
         /** The number of writing tasks that currently hold the lock (binary). */
         ubyte m_activeWriteLocks = 0;
-        
+
         /** The policy determining the lock's behavior. */
         Policy m_policy;
-        
+
         //Queue Events
         /** The event used to wake reading tasks waiting for the lock while it is blocked. */
         shared(ManualEvent) m_readyForReadLock;
@@ -1557,7 +1557,7 @@ private struct ReadWriteMutexState(bool INTERRUPTIBLE)
         /** The underlying mutex that gates the access to the shared state. */
         Mutex m_counterMutex;
     }
-    
+
     this(Policy policy)
     {
         m_policy = policy;
@@ -1567,10 +1567,10 @@ private struct ReadWriteMutexState(bool INTERRUPTIBLE)
     }
 
     @disable this(this);
-    
+
     /** The policy with which the lock has been created. */
     @property policy() const { return m_policy; }
-    
+
     version(RWMutexPrint)
     {
         /** Print out debug information during lock operations. */
@@ -1580,17 +1580,17 @@ private struct ReadWriteMutexState(bool INTERRUPTIBLE)
             try
             {
                 import std.stdio;
-                writefln("RWMutex: %s (%s), active: RO: %d, RW: %d; waiting: RO: %d, RW: %d", 
+                writefln("RWMutex: %s (%s), active: RO: %d, RW: %d; waiting: RO: %d, RW: %d",
-                    OP.leftJustify(10,' '), 
+                    OP.leftJustify(10,' '),
-                    INTENT == LockingIntent.READ_ONLY ? "RO" : "RW", 
+                    INTENT == LockingIntent.READ_ONLY ? "RO" : "RW",
-                    m_activeReadLocks,    m_activeWriteLocks, 
+                    m_activeReadLocks,    m_activeWriteLocks,
                     m_waitingForReadLock, m_waitingForWriteLock
                     );
             }
             catch (Throwable t){}
         }
     }
-    
+
     /** An internal shortcut method to determine the queue event for a given intent. */
     @property ref auto queueEvent(LockingIntent INTENT)()
     {
@@ -1599,7 +1599,7 @@ private struct ReadWriteMutexState(bool INTERRUPTIBLE)
         else
             return m_readyForWriteLock;
     }
-    
+
     /** An internal shortcut method to determine the queue counter for a given intent. */
     @property ref auto queueCounter(LockingIntent INTENT)()
     {
@@ -1608,13 +1608,13 @@ private struct ReadWriteMutexState(bool INTERRUPTIBLE)
         else
             return m_waitingForWriteLock;
     }
-    
+
     /** An internal shortcut method to determine the current emitCount of the queue counter for a given intent. */
     int emitCount(LockingIntent INTENT)()
     {
         return queueEvent!INTENT.emitCount();
     }
-    
+
     /** An internal shortcut method to determine the active counter for a given intent. */
     @property ref auto activeCounter(LockingIntent INTENT)()
     {
@@ -1623,8 +1623,8 @@ private struct ReadWriteMutexState(bool INTERRUPTIBLE)
         else
             return m_activeWriteLocks;
     }
-    
+
-    /** An internal shortcut method to wait for the queue event for a given intent. 
+    /** An internal shortcut method to wait for the queue event for a given intent.
      *
      *  This method is used during the `lock()` operation, after a
      *  `tryLock()` operation has been unsuccessfully finished.
@@ -1638,8 +1638,8 @@ private struct ReadWriteMutexState(bool INTERRUPTIBLE)
         else
             return queueEvent!INTENT.waitUninterruptible(count);
     }
-    
+
-    /** An internal shortcut method to notify tasks waiting for the lock to become available again. 
+    /** An internal shortcut method to notify tasks waiting for the lock to become available again.
      *
      *  This method is called whenever the number of owners of the mutex hits
      *  zero; this is basically the counterpart to `wait()`.
@@ -1656,12 +1656,12 @@ private struct ReadWriteMutexState(bool INTERRUPTIBLE)
         { //If a writer unlocks the mutex, notify both readers and writers
             if (atomicLoad(m_waitingForReadLock) > 0)
                 m_readyForReadLock.emit();
-            
+
             if (atomicLoad(m_waitingForWriteLock) > 0)
                 m_readyForWriteLock.emit();
         }
     }
-    
+
     /** An internal method that performs the acquisition attempt in different variations.
      *
      *  Since both locks rely on a common TaskMutex object which gates the access
@@ -1669,15 +1669,15 @@ private struct ReadWriteMutexState(bool INTERRUPTIBLE)
      *  than for simple mutex variants. This method will thus be performing the
      *  `tryLock()` operation in two variations, depending on the callee:
      *
-     *  If called from the outside ($(D WAIT_FOR_BLOCKING_MUTEX) = false), the method 
+     *  If called from the outside ($(D WAIT_FOR_BLOCKING_MUTEX) = false), the method
-     *  will instantly fail if the underlying mutex is locked (i.e. during another 
+     *  will instantly fail if the underlying mutex is locked (i.e. during another
-     *  `tryLock()` or `unlock()` operation), in order to guarantee the fastest 
+     *  `tryLock()` or `unlock()` operation), in order to guarantee the fastest
      *  possible locking attempt.
      *
-     *  If used internally by the `lock()` method ($(D WAIT_FOR_BLOCKING_MUTEX) = true), 
+     *  If used internally by the `lock()` method ($(D WAIT_FOR_BLOCKING_MUTEX) = true),
      *  the operation will wait for the mutex to be available before deciding if
      *  the lock can be acquired, since the attempt would anyway be repeated until
-     *  it succeeds. This will prevent frequent retries under heavy loads and thus 
+     *  it succeeds. This will prevent frequent retries under heavy loads and thus
      *  should ensure better performance.
      */
     @trusted bool tryLock(LockingIntent INTENT, bool WAIT_FOR_BLOCKING_MUTEX)()
@@ -1685,7 +1685,7 @@ private struct ReadWriteMutexState(bool INTERRUPTIBLE)
         //Log a debug statement for the attempt
         version(RWMutexPrint)
             printInfo!("tryLock",INTENT)();
-        
+
         //Try to acquire the lock
         static if (!WAIT_FOR_BLOCKING_MUTEX)
         {
@@ -1694,43 +1694,43 @@ private struct ReadWriteMutexState(bool INTERRUPTIBLE)
         }
         else
             m_counterMutex.lock();
-        
+
         scope(exit)
             m_counterMutex.unlock();
-        
+
         //Log a debug statement for the attempt
         version(RWMutexPrint)
             printInfo!("checkCtrs",INTENT)();
-        
+
         //Check if there's already an active writer
         if (m_activeWriteLocks > 0)
             return false;
-        
+
         //If writers are preferred over readers, check whether there
         //currently is a writer in the waiting queue and abort if
         //that's the case.
         static if (INTENT == LockingIntent.READ_ONLY)
             if (m_policy.PREFER_WRITERS && m_waitingForWriteLock > 0)
                 return false;
-        
+
         //If we are locking the mutex for writing, make sure that
         //there's no reader active.
         static if (INTENT == LockingIntent.READ_WRITE)
             if (m_activeReadLocks > 0)
                 return false;
-        
+
         //We can successfully acquire the lock!
         //Log a debug statement for the success.
         version(RWMutexPrint)
             printInfo!("lock",INTENT)();
-        
+
-        //Increase the according counter 
+        //Increase the according counter
         //(number of active readers/writers)
         //and return a success code.
         activeCounter!INTENT += 1;
         return true;
     }
-    
+
     /** Attempt to acquire the lock for a given intent.
      *
      *  Returns:
@@ -1743,7 +1743,7 @@ private struct ReadWriteMutexState(bool INTERRUPTIBLE)
         //TaskMutex - fail if it is already blocked.
         return tryLock!(INTENT,false)();
     }
-    
+
     /** Acquire the lock for the given intent; yield and suspend until the lock has been acquired. */
     @trusted void lock(LockingIntent INTENT)()
     {
@@ -1755,29 +1755,29 @@ private struct ReadWriteMutexState(bool INTERRUPTIBLE)
         atomicOp!"+="(queueCounter!INTENT,1);
         scope(exit)
             atomicOp!"-="(queueCounter!INTENT,1);
-        
+
         //Try to lock the mutex
         auto locked = tryLock!(INTENT,true)();
         if (locked)
             return;
-        
+
         //Retry until we successfully acquired the lock
         while(!locked)
         {
             version(RWMutexPrint)
                 printInfo!("wait",INTENT)();
-            
+
             count  = wait!INTENT(count);
             locked = tryLock!(INTENT,true)();
         }
     }
-    
+
     /** Unlock the mutex after a successful acquisition. */
     @trusted void unlock(LockingIntent INTENT)()
     {
         version(RWMutexPrint)
             printInfo!("unlock",INTENT)();
-        
+
         debug assert(activeCounter!INTENT > 0);
 
         synchronized(m_counterMutex)
@@ -1789,7 +1789,7 @@ private struct ReadWriteMutexState(bool INTERRUPTIBLE)
             {
                 version(RWMutexPrint)
                     printInfo!("notify",INTENT)();
-                
+
                 notify!INTENT();
             }
         }
@@ -1800,20 +1800,20 @@ private struct ReadWriteMutexState(bool INTERRUPTIBLE)
  *
  *  This mutex can be used in exchange for a $(D core.sync.mutex.ReadWriteMutex),
  *  but does not block the event loop in contention situations. The `reader` and `writer`
- *  members are used for locking. Locking the `reader` mutex allows access to multiple 
+ *  members are used for locking. Locking the `reader` mutex allows access to multiple
  *  readers at once, while the `writer` mutex only allows a single writer to lock it at
- *  any given time. Locks on `reader` and `writer` are mutually exclusive (i.e. whenever a 
+ *  any given time. Locks on `reader` and `writer` are mutually exclusive (i.e. whenever a
  *  writer is active, no readers can be active at the same time, and vice versa).
- * 
+ *
  *  Notice:
  *      Mutexes implemented by this class cannot be interrupted
  *      using $(D vibe.core.task.Task.interrupt()). The corresponding
  *      InterruptException will be deferred until the next blocking
  *      operation yields the event loop.
- * 
+ *
  *      Use $(D InterruptibleTaskReadWriteMutex) as an alternative that can be
  *      interrupted.
- * 
+ *
  *  cf. $(D core.sync.mutex.ReadWriteMutex)
  */
 class TaskReadWriteMutex
@@ -1823,29 +1823,29 @@ class TaskReadWriteMutex
         alias LockingIntent = State.LockingIntent;
         alias READ_ONLY  = LockingIntent.READ_ONLY;
         alias READ_WRITE = LockingIntent.READ_WRITE;
-        
+
         /** The shared state used by the reader and writer mutexes. */
         State m_state;
     }
-    
+
     /** The policy with which the mutex should operate.
      *
-     *  The policy determines how the acquisition of the locks is 
+     *  The policy determines how the acquisition of the locks is
      *  performed and can be used to tune the mutex according to the
      *  underlying algorithm in which it is used.
      *
      *  According to the provided policy, the mutex will either favor
-     *  reading or writing tasks and could potentially starve the 
+     *  reading or writing tasks and could potentially starve the
      *  respective opposite.
      *
      *  cf. $(D core.sync.rwmutex.ReadWriteMutex.Policy)
      */
     alias Policy = State.Policy;
-    
+
     /** A common baseclass for both of the provided mutexes.
      *
-     *  The intent for the according mutex is specified through the 
+     *  The intent for the according mutex is specified through the
-     *  $(D INTENT) template argument, which determines if a mutex is 
+     *  $(D INTENT) template argument, which determines if a mutex is
      *  used for read or write locking.
      */
     final class Mutex(LockingIntent INTENT): core.sync.mutex.Mutex, Lockable
@@ -1859,17 +1859,17 @@ class TaskReadWriteMutex
     }
     alias Reader = Mutex!READ_ONLY;
     alias Writer = Mutex!READ_WRITE;
-    
+
     Reader reader;
     Writer writer;
-    
+
     this(Policy policy = Policy.PREFER_WRITERS)
     {
         m_state = State(policy);
         reader = new Reader();
         writer = new Writer();
     }
-    
+
     /** The policy with which the lock has been created. */
     @property Policy policy() const { return m_state.policy; }
 }
@@ -1878,7 +1878,7 @@ class TaskReadWriteMutex
  *
  *  This class supports the use of $(D vibe.core.task.Task.interrupt()) while
  *  waiting in the `lock()` method.
- * 
+ *
  *  cf. $(D core.sync.mutex.ReadWriteMutex)
  */
 class InterruptibleTaskReadWriteMutex
@@ -1890,31 +1890,31 @@ class InterruptibleTaskReadWriteMutex
         alias LockingIntent = State.LockingIntent;
         alias READ_ONLY  = LockingIntent.READ_ONLY;
         alias READ_WRITE = LockingIntent.READ_WRITE;
-        
+
         /** The shared state used by the reader and writer mutexes. */
         State m_state;
     }
-    
+
     /** The policy with which the mutex should operate.
      *
-     *  The policy determines how the acquisition of the locks is 
+     *  The policy determines how the acquisition of the locks is
      *  performed and can be used to tune the mutex according to the
      *  underlying algorithm in which it is used.
      *
      *  According to the provided policy, the mutex will either favor
-     *  reading or writing tasks and could potentially starve the 
+     *  reading or writing tasks and could potentially starve the
      *  respective opposite.
      *
      *  cf. $(D core.sync.rwmutex.ReadWriteMutex.Policy)
      */
     alias Policy = State.Policy;
-    
+
     /** A common baseclass for both of the provided mutexes.
      *
-     *  The intent for the according mutex is specified through the 
+     *  The intent for the according mutex is specified through the
-     *  $(D INTENT) template argument, which determines if a mutex is 
+     *  $(D INTENT) template argument, which determines if a mutex is
      *  used for read or write locking.
-     * 
+     *
      */
     final class Mutex(LockingIntent INTENT): core.sync.mutex.Mutex, Lockable
     {
@@ -1927,17 +1927,17 @@ class InterruptibleTaskReadWriteMutex
     }
     alias Reader = Mutex!READ_ONLY;
     alias Writer = Mutex!READ_WRITE;
-    
+
     Reader reader;
     Writer writer;
-    
+
     this(Policy policy = Policy.PREFER_WRITERS)
     {
         m_state = State(policy);
         reader = new Reader();
         writer = new Writer();
     }
-    
+
     /** The policy with which the lock has been created. */
     @property Policy policy() const { return m_state.policy; }
 }

source/vibe/core/task.d

@@ -77,7 +77,7 @@ struct Task {
 		}
 
 		package @property ref ThreadInfo tidInfo() @system { return m_fiber ? taskFiber.tidInfo : s_tidInfo; } // FIXME: this is not thread safe!
-		
+
 		@property Tid tid() @trusted { return tidInfo.ident; }
 	}
 
@@ -341,7 +341,7 @@ final package class TaskFiber : Fiber {
 		import std.concurrency : Tid, thisTid;
 		import std.encoding : sanitize;
 		import vibe.core.core : isEventLoopRunning, recycleFiber, taskScheduler, yield;
-		
+
 		version (VibeDebugCatchAll) alias UncaughtException = Throwable;
 		else alias UncaughtException = Exception;
 		try {
@@ -725,7 +725,7 @@ package struct TaskScheduler {
 
 	/** Holds execution until the task gets explicitly resumed.
 
-		
+
 	*/
 	void hibernate()
 	{

source/vibe/core/taskpool.d

@@ -47,7 +47,7 @@ shared class TaskPool {
 			threads.length = thread_count;
 			foreach (i; 0 .. thread_count) {
 				WorkerThread thr;
-				() @trusted { 
+				() @trusted {
 					thr = new WorkerThread(this);
 					thr.name = format("vibe-%s", i);
 					thr.start();
@@ -338,7 +338,7 @@ nothrow @safe:
 	bool consume(ref TaskFuncInfo tfi)
 	{
 		import std.algorithm.mutation : swap;
-		
+
 		if (m_queue.empty) return false;
 		swap(tfi, m_queue.front);
 		m_queue.popFront();

source/vibe/internal/async.d

@@ -61,7 +61,7 @@ struct Waitable(CB, alias wait, alias cancel, on_result...)
 
 	bool cancelled;
 	auto waitCallback(Callback cb) nothrow { return wait(cb); }
-	
+
 	static if (is(ReturnType!waitCallback == void))
 		void cancelCallback(Callback cb) nothrow { cancel(cb); }
 	else

source/vibe/internal/interfaceproxy.d

@@ -163,7 +163,7 @@ struct InterfaceProxy(I) if (is(I == interface)) {
 			}
 			return ret;
 		}
-		
+
 		mixin(impl());
 	}
 

source/vibe/internal/traits.d

@@ -440,7 +440,7 @@ template checkInterfaceConformance(T, I) {
 		}
 		alias checkMemberConformance = impl!0;
 	}
-	
+
 	template impl(size_t i) {
 		static if (i < Members.length) {
 			static if (__traits(compiles, __traits(getMember, I, Members[i])))

tests/dirwatcher.d

@@ -70,13 +70,13 @@ void runTest()
 	remove(bar);
 	watcher = Path(dir).watchDirectory(Yes.recursive);
 	write(foo, null);
-	sleep(1.seconds); 
+	sleep(1.seconds);
 	write(foo, [0, 1]);
 	sleep(100.msecs);
 	remove(foo);
 
 	write(bar, null);
-	sleep(1.seconds); 
+	sleep(1.seconds);
 	write(bar, [0, 1]);
 	sleep(100.msecs);
 	remove(bar);

tests/vibe.core.concurrency.1408.d

@@ -20,7 +20,7 @@ void test()
 		assert(gotit);
 		sleep(10.msecs);
 	});
-	
+
 	t.tid.send(10);
 	t.tid.send(11); // never received
 	t.join();
@@ -43,9 +43,9 @@ void test()
 
 	t3.tid.send(13);
 	sleep(10.msecs);
-	
+
 	logInfo("Success.");
-	
+
 	exitEventLoop(true);
 }
 

tests/vibe.core.net.1726.d

@@ -29,7 +29,7 @@ void main()
 			} // expected
 		}, conn);
 		auto wt = runTask!TCPConnection((conn) {
-			sleep(1.msecs); // give the connection time to establish 
+			sleep(1.msecs); // give the connection time to establish
 			try {
 				conn.write(buf);
 				assert(false, "Expected read() to throw an exception.");