Initial release: RadiantWave v1.0

vendor/github.com/veandco/go-sdl2/sdl/mutex.go

@@ -0,0 +1,203 @@
+package sdl
+
+// #include "sdl_wrapper.h"
+import "C"
+import "unsafe"
+
+// ThreadID is the thread identifier for a thread.
+type ThreadID uint64
+
+// Mutex is the SDL mutex structure.
+type Mutex struct {
+	Recursive int
+	Owner     ThreadID
+	Sem       *Sem
+}
+
+// Sem is the SDL semaphore structure.
+type Sem struct {
+	Count        uint32
+	WaitersCount uint32
+	CountLock    *Mutex
+	CountNonzero *Cond
+}
+
+// Cond is the SDL condition variable structure.
+type Cond struct {
+	Lock     *Mutex
+	Waiting  int
+	Signals  int
+	WaitSem  *Sem
+	WaitDone *Sem
+}
+
+func (m *Mutex) cptr() *C.SDL_mutex {
+	return (*C.SDL_mutex)(unsafe.Pointer(m))
+}
+
+func (s *Sem) cptr() *C.SDL_sem {
+	return (*C.SDL_sem)(unsafe.Pointer(s))
+}
+
+func (c *Cond) cptr() *C.SDL_cond {
+	return (*C.SDL_cond)(unsafe.Pointer(c))
+}
+
+// CreateMutex creates a new mutex.
+// (https://wiki.libsdl.org/SDL_CreateMutex)
+func CreateMutex() (*Mutex, error) {
+	mutex := C.SDL_CreateMutex()
+	if mutex == nil {
+		return nil, GetError()
+	}
+	return (*Mutex)(unsafe.Pointer(mutex)), nil
+}
+
+// Lock locks a mutex created with CreateMutex().
+// (https://wiki.libsdl.org/SDL_LockMutex)
+func (mutex *Mutex) Lock() error {
+	ret := int(C.SDL_LockMutex(mutex.cptr()))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// TryLock tries to lock a mutex without blocking.
+// (https://wiki.libsdl.org/SDL_TryLockMutex)
+func (mutex *Mutex) TryLock() error {
+	ret := int(C.SDL_TryLockMutex(mutex.cptr()))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// Unlock unlocks a mutex created with CreateMutex().
+// (https://wiki.libsdl.org/SDL_UnlockMutex)
+func (mutex *Mutex) Unlock() error {
+	ret := int(C.SDL_UnlockMutex(mutex.cptr()))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// Destroy destroys a mutex created with CreateMutex().
+// (https://wiki.libsdl.org/SDL_DestroyMutex)
+func (mutex *Mutex) Destroy() {
+	C.SDL_DestroyMutex(mutex.cptr())
+}
+
+// CreateSemaphore creates a semaphore.
+// (https://wiki.libsdl.org/SDL_CreateSemaphore)
+func CreateSemaphore(initialValue uint32) (*Sem, error) {
+	sem := C.SDL_CreateSemaphore(C.Uint32(initialValue))
+	if sem == nil {
+		return nil, GetError()
+	}
+	return (*Sem)(unsafe.Pointer(sem)), nil
+}
+
+// Destroy destroys a semaphore.
+// (https://wiki.libsdl.org/SDL_DestroySemaphore)
+func (sem *Sem) Destroy() {
+	C.SDL_DestroySemaphore(sem.cptr())
+}
+
+// Wait waits until a semaphore has a positive value and then decrements it.
+// (https://wiki.libsdl.org/SDL_SemWait)
+func (sem *Sem) Wait() error {
+	ret := int(C.SDL_SemWait(sem.cptr()))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// TryWait sees if a semaphore has a positive value and decrement it if it does.
+// (https://wiki.libsdl.org/SDL_SemTryWait)
+func (sem *Sem) TryWait() error {
+	ret := int(C.SDL_SemTryWait(sem.cptr()))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// WaitTimeout waits until a semaphore has a positive value and then decrements it.
+// (https://wiki.libsdl.org/SDL_SemWaitTimeout)
+func (sem *Sem) WaitTimeout(ms uint32) error {
+	ret := int(C.SDL_SemWaitTimeout(sem.cptr(), C.Uint32(ms)))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// Post atomically increments a semaphore's value and wake waiting threads.
+// (https://wiki.libsdl.org/SDL_SemPost)
+func (sem *Sem) Post() error {
+	ret := int(C.SDL_SemPost(sem.cptr()))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// Value returns the current value of a semaphore.
+// (https://wiki.libsdl.org/SDL_SemValue)
+func (sem *Sem) Value() uint32 {
+	return uint32(C.SDL_SemValue(sem.cptr()))
+}
+
+// CreateCond (https://wiki.libsdl.org/SDL_CreateCond)
+func CreateCond() *Cond {
+	return (*Cond)(unsafe.Pointer(C.SDL_CreateCond()))
+}
+
+// Destroy creates a condition variable.
+// (https://wiki.libsdl.org/SDL_DestroyCond)
+func (cond *Cond) Destroy() {
+	C.SDL_DestroyCond(cond.cptr())
+}
+
+// Signal restarts one of the threads that are waiting on the condition variable.
+// (https://wiki.libsdl.org/SDL_CondSignal)
+func (cond *Cond) Signal() error {
+	ret := int(C.SDL_CondSignal(cond.cptr()))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// Broadcast restarts all threads that are waiting on the condition variable.
+// (https://wiki.libsdl.org/SDL_CondBroadcast)
+func (cond *Cond) Broadcast() error {
+	ret := int(C.SDL_CondBroadcast(cond.cptr()))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// Wait waits until a condition variable is signaled.
+// (https://wiki.libsdl.org/SDL_CondWait)
+func (cond *Cond) Wait(mutex *Mutex) error {
+	ret := int(C.SDL_CondWait(cond.cptr(), mutex.cptr()))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
+}
+
+// WaitTimeout waits until a condition variable is signaled or a specified amount of time has passed.
+// (https://wiki.libsdl.org/SDL_CondWaitTimeout)
+func (cond *Cond) WaitTimeout(mutex *Mutex, ms uint32) error {
+	ret := int(C.SDL_CondWaitTimeout(cond.cptr(), mutex.cptr(), C.Uint32(ms)))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
+}