sdl: mutex.go: Change Mutex, Sem, Cond to have methods instead of functions

Signed-off-by: Lilis Iskandar <[email protected]>

Author: veeableful

sdl/mutex.go

@@ -53,27 +53,39 @@ func CreateMutex() (*Mutex, error) {
 	return (*Mutex)(unsafe.Pointer(mutex)), nil
 }
 
-// LockMutex locks a mutex created with CreateMutex().
+// Lock locks a mutex created with CreateMutex().
 // (https://wiki.libsdl.org/SDL_LockMutex)
-func LockMutex(mutex *Mutex) int {
-	return int(C.SDL_LockMutex(mutex.cptr()))
+func (mutex *Mutex) Lock() error {
+	ret := int(C.SDL_LockMutex(mutex.cptr()))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
 }
 
-// TryLockMutex tries to lock a mutex without blocking.
+// TryLock tries to lock a mutex without blocking.
 // (https://wiki.libsdl.org/SDL_TryLockMutex)
-func TryLockMutex(mutex *Mutex) int {
-	return int(C.SDL_TryLockMutex(mutex.cptr()))
+func (mutex *Mutex) TryLock() error {
+	ret := int(C.SDL_TryLockMutex(mutex.cptr()))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
 }
 
-// UnlockMutex unlocks a mutex created with CreateMutex().
+// Unlock unlocks a mutex created with CreateMutex().
 // (https://wiki.libsdl.org/SDL_UnlockMutex)
-func UnlockMutex(mutex *Mutex) int {
-	return int(C.SDL_UnlockMutex(mutex.cptr()))
+func (mutex *Mutex) Unlock() error {
+	ret := int(C.SDL_UnlockMutex(mutex.cptr()))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
 }
 
-// DestroyMutex destroys a mutex created with CreateMutex().
+// Destroy destroys a mutex created with CreateMutex().
 // (https://wiki.libsdl.org/SDL_DestroyMutex)
-func DestroyMutex(mutex *Mutex) {
+func (mutex *Mutex) Destroy() {
 	C.SDL_DestroyMutex(mutex.cptr())
 }
 
@@ -87,39 +99,55 @@ func CreateSemaphore(initialValue uint32) (*Sem, error) {
 	return (*Sem)(unsafe.Pointer(sem)), nil
 }
 
-// DestroySemaphore destroys a semaphore.
+// Destroy destroys a semaphore.
 // (https://wiki.libsdl.org/SDL_DestroySemaphore)
-func DestroySemaphore(sem *Sem) {
+func (sem *Sem) Destroy() {
 	C.SDL_DestroySemaphore(sem.cptr())
 }
 
-// SemWait waits until a semaphore has a positive value and then decrements it.
+// Wait waits until a semaphore has a positive value and then decrements it.
 // (https://wiki.libsdl.org/SDL_SemWait)
-func SemWait(sem *Sem) int {
-	return int(C.SDL_SemWait(sem.cptr()))
+func (sem *Sem) Wait() error {
+	ret := int(C.SDL_SemWait(sem.cptr()))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
 }
 
-// SemTryWait sees if a semaphore has a positive value and decrement it if it does.
+// TryWait sees if a semaphore has a positive value and decrement it if it does.
 // (https://wiki.libsdl.org/SDL_SemTryWait)
-func SemTryWait(sem *Sem) int {
-	return int(C.SDL_SemTryWait(sem.cptr()))
+func (sem *Sem) TryWait() error {
+	ret := int(C.SDL_SemTryWait(sem.cptr()))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
 }
 
-// SemWaitTimeout waits until a semaphore has a positive value and then decrements it.
+// WaitTimeout waits until a semaphore has a positive value and then decrements it.
 // (https://wiki.libsdl.org/SDL_SemWaitTimeout)
-func SemWaitTimeout(sem *Sem, ms uint32) int {
-	return int(C.SDL_SemWaitTimeout(sem.cptr(), C.Uint32(ms)))
+func (sem *Sem) WaitTimeout(ms uint32) error {
+	ret := int(C.SDL_SemWaitTimeout(sem.cptr(), C.Uint32(ms)))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
 }
 
-// SemPost atomically increments a semaphore's value and wake waiting threads.
+// Post atomically increments a semaphore's value and wake waiting threads.
 // (https://wiki.libsdl.org/SDL_SemPost)
-func SemPost(sem *Sem) int {
-	return int(C.SDL_SemPost(sem.cptr()))
+func (sem *Sem) Post() error {
+	ret := int(C.SDL_SemPost(sem.cptr()))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
 }
 
-// SemValue returns the current value of a semaphore.
+// Value returns the current value of a semaphore.
 // (https://wiki.libsdl.org/SDL_SemValue)
-func SemValue(sem *Sem) uint32 {
+func (sem *Sem) Value() uint32 {
 	return uint32(C.SDL_SemValue(sem.cptr()))
 }
 
@@ -128,32 +156,48 @@ func CreateCond() *Cond {
 	return (*Cond)(unsafe.Pointer(C.SDL_CreateCond()))
 }
 
-// DestroyCond creates a condition variable.
+// Destroy creates a condition variable.
 // (https://wiki.libsdl.org/SDL_DestroyCond)
-func DestroyCond(cond *Cond) {
+func (cond *Cond) Destroy() {
 	C.SDL_DestroyCond(cond.cptr())
 }
 
-// CondSignal restarts one of the threads that are waiting on the condition variable.
+// Signal restarts one of the threads that are waiting on the condition variable.
 // (https://wiki.libsdl.org/SDL_CondSignal)
-func CondSignal(cond *Cond) int {
-	return int(C.SDL_CondSignal(cond.cptr()))
+func (cond *Cond) Signal() error {
+	ret := int(C.SDL_CondSignal(cond.cptr()))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
 }
 
-// CondBroadcast restarts all threads that are waiting on the condition variable.
+// Broadcast restarts all threads that are waiting on the condition variable.
 // (https://wiki.libsdl.org/SDL_CondBroadcast)
-func CondBroadcast(cond *Cond) int {
-	return int(C.SDL_CondBroadcast(cond.cptr()))
+func (cond *Cond) Broadcast() error {
+	ret := int(C.SDL_CondBroadcast(cond.cptr()))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
 }
 
-// CondWait waits until a condition variable is signaled.
+// Wait waits until a condition variable is signaled.
 // (https://wiki.libsdl.org/SDL_CondWait)
-func CondWait(cond *Cond, mutex *Mutex) int {
-	return int(C.SDL_CondWait(cond.cptr(), mutex.cptr()))
+func (cond *Cond) Wait(mutex *Mutex) error {
+	ret := int(C.SDL_CondWait(cond.cptr(), mutex.cptr()))
+	if ret != 0 {
+		return GetError()
+	}
+	return nil
 }
 
-// CondWaitTimeout waits until a condition variable is signaled or a specified amount of time has passed.
+// WaitTimeout waits until a condition variable is signaled or a specified amount of time has passed.
 // (https://wiki.libsdl.org/SDL_CondWaitTimeout)
-func CondWaitTimeout(cond *Cond, mutex *Mutex, ms uint32) int {
-	return int(C.SDL_CondWaitTimeout(cond.cptr(), mutex.cptr(), C.Uint32(ms)))
+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
 }