RWLock for regulating read and write access to data objects for multitasking.

We should standardize a way to regulate acces to data from multible threads of processing (Like interrupts, multitasking and PC SDK/RobServices).

I propose the following interface, shown here with an untested implementation.

If we agree that this implementation is sound, we should test and push it to master.

This specific implementation allows multiple parallel reads, but limits access when a thread is writing to the data.

```

MODULE RNL_B_RWLock

!RWlock (Read Write Lock) is a lock designed to lock data

!Dependencies:
! - None
! -

ALIAS bool lock_state;

RECORD RWLock
lock_state writeLock;
num readQueue;
ENDRECORD

VAR errnum ERR_RWLOCK_LOCKED:=-1;

CONST lock_state LOCKED:=TRUE;
CONST lock_state UNLOCKED:=FALSE;

!Constructor
FUNC RWLock RWLock_NEW()
VAR RWLock lock;
RETURN lock;
ENDFUNC

!Reading lock state

FUNC bool RWLock_canWrite(RWLock lock)
RETURN lock.writeLock=UNLOCKED AND lock.readQueue=0;
ENDFUNC

FUNC bool RWLock_canRead(RWLock lock)
RETURN lock.writeLock=UNLOCKED;
ENDFUNC

!Manipulating lock

PROC RWLock_beginWrite(INOUT RWLock lock)
IF NOT RWLock_canWrite(lock) THEN
IF ERR_RWLOCK_LOCKED=-1 BookErrNo ERR_RWLOCK_LOCKED;
RAISE ERR_RWLOCK_LOCKED;
ENDIF

lock.writeLock:=LOCKED;

ERROR
RAISE ;
ENDPROC

PROC RWLock_endWrite(INOUT RWLock lock)
lock.writeLock:=UNLOCKED;
ENDPROC

PROC RWLock_beginRead(INOUT RWLock lock)
IF NOT RWLock_canRead(lock) THEN
IF ERR_RWLOCK_LOCKED=-1 BookErrNo ERR_RWLOCK_LOCKED;
RAISE ERR_RWLOCK_LOCKED;
ENDIF

incr lock.readQueue;

ERROR
RAISE ;
ENDPROC

PROC RWLock_endRead(INOUT RWLock lock)
Decr lock.readQueue;
IF lock.readQueue < 0 THEN
!ERROR
lock.readQueue := 0;
ENDIF
ENDPROC

!Wait functions

PROC RWLock_WaitAndBeginWrite(INOUT RWLock lock)
WaitUntil RWLock_canWrite(lock);
RWLock_beginWrite lock;
ENDPROC

PROC RWLock_WaitAndBeginRead(INOUT RWLock lock)
WaitUntil RWLock_canRead(lock);
RWLock_beginRead lock;
ENDPROC

ENDMODULE

```