debian-packages/vibe-core
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Remove all trailing whitespace

Browse source 
sed 's/[ \t]*$//' -i **/*.d
This commit is contained in:
Sebastian Wilzbach 2017-07-02 23:54:30 +02:00
parent 3faa5f3bdc
commit 8f89733a86
16 changed files with 114 additions and 114 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
source/vibe/core/concurrency.d
View file

@ -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)();
}

2
source/vibe/core/connectionpool.d
View file

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

4
source/vibe/core/core.d
View file

@ -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); }

2
source/vibe/core/file.d
View file

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

2
source/vibe/core/log.d
View file

@ -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;

14
source/vibe/core/net.d
View file

@ -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);

2
source/vibe/core/path.d
View file

@ -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.
*/

172
source/vibe/core/sync.d
View file

@ -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",
OP.leftJustify(10,' '),
INTENT == LockingIntent.READ_ONLY ? "RO" : "RW",
m_activeReadLocks, m_activeWriteLocks,
writefln("RWMutex: %s (%s), active: RO: %d, RW: %d; waiting: RO: %d, RW: %d",
OP.leftJustify(10,' '),
INTENT == LockingIntent.READ_ONLY ? "RO" : "RW",
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
* will instantly fail if the underlying mutex is locked (i.e. during another
* `tryLock()` or `unlock()` operation), in order to guarantee the fastest
* 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
* `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
* $(D INTENT) template argument, which determines if a mutex is
* The intent for the according mutex is specified through the
* $(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
* $(D INTENT) template argument, which determines if a mutex is
* The intent for the according mutex is specified through the
* $(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; }
}

6
source/vibe/core/task.d
View file

@ -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()
{

4
source/vibe/core/taskpool.d
View file

@ -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();

2
source/vibe/internal/async.d
View file

@ -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

2
source/vibe/internal/interfaceproxy.d
View file

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

2
source/vibe/internal/traits.d
View file

@ -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])))

4
tests/dirwatcher.d
View file

@ -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);

6
tests/vibe.core.concurrency.1408.d
View file

@ -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);
}

2
tests/vibe.core.net.1726.d
View file

@ -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.");