friend class Condition;
public:
+
Mutex()
{
- mutex_ = SDL_CreateMutex();
+ mMutex = SDL_CreateMutex();
}
~Mutex()
{
- SDL_DestroyMutex(mutex_);
+ SDL_DestroyMutex(mMutex);
}
bool acquireLock()
{
- return (SDL_LockMutex(mutex_) == 0);
+ return (SDL_LockMutex(mMutex) == 0);
}
bool releaseLock()
{
- return (SDL_UnlockMutex(mutex_) == 0);
+ return (SDL_UnlockMutex(mMutex) == 0);
}
class Lock
friend class Condition;
public:
+
Lock(Mutex& mutex)
{
- mutex_ = &mutex;
- isLocked_ = false;
+ mMutex = &mutex;
+ mIsLocked = false;
}
~Lock()
{
- if (isLocked_) release();
+ if (mIsLocked) release();
}
bool acquire()
{
- return (isLocked_ = mutex_->acquireLock());
+ return (mIsLocked = mMutex->acquireLock());
}
bool release()
{
- return mutex_->releaseLock();
- isLocked_ = false;
+ return mMutex->releaseLock();
+ mIsLocked = false;
}
bool isLocked() const
{
- return isLocked_;
+ return mIsLocked;
}
protected:
- Mutex* mutex_;
- bool isLocked_;
+
+ Mutex* mMutex;
+ bool mIsLocked;
};
class ScopedLock : public Lock
{
public:
+
ScopedLock(Mutex& mutex) :
Lock(mutex)
{
};
private:
- SDL_mutex* mutex_;
+
+ SDL_mutex* mMutex;
};
class Condition
{
public:
+
Condition()
{
condition_ = SDL_CreateCond();
bool wait(Mutex::Lock& lock)
{
- return (SDL_CondWait(condition_, lock.mutex_->mutex_) == 0);
+ return (SDL_CondWait(condition_, lock.mMutex->mMutex) == 0);
}
bool wait(Mutex::Lock& lock, unsigned ms)
{
// TODO for consistency, this function should take seconds
- return (SDL_CondWaitTimeout(condition_, lock.mutex_->mutex_, ms) == 0);
+ return (SDL_CondWaitTimeout(condition_, lock.mMutex->mMutex, ms) == 0);
}
bool notify()
}
private:
+
SDL_cond* condition_;
};
class Semaphore
{
public:
+
Semaphore(unsigned int value)
{
semaphore_ = SDL_CreateSemaphore(value);
class Lock
{
public:
+
Lock(Semaphore& semaphore)
{
semaphore_ = &semaphore;
- isLocked_ = false;
+ mIsLocked = false;
}
~Lock()
{
- if (isLocked_) release();
+ if (mIsLocked) release();
}
bool acquire()
{
- return (isLocked_ = semaphore_->acquireLock());
+ return (mIsLocked = semaphore_->acquireLock());
}
bool release()
{
- return semaphore_->releaseLock(); isLocked_ = false;
+ return semaphore_->releaseLock(); mIsLocked = false;
}
bool isLocked() const
{
- return isLocked_;
+ return mIsLocked;
}
protected:
+
Semaphore* semaphore_;
- bool isLocked_;
+ bool mIsLocked;
};
class ScopedLock : public Lock
{
public:
+
ScopedLock(Semaphore& semaphore) :
Lock(semaphore)
{
};
private:
+
SDL_sem* semaphore_;
};