sid
/
NazaraEngine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'merging' 

Former-commit-id: df8fe7c6c673848922ffa2f6ebd3b1549bd1429b
This commit is contained in:
Alexandre Janniaux 2013-01-04 19:52:38 +01:00
parent 58e0071626 9ea7817502
commit eab132e187
18 changed files with 1051 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
src/Nazara/Core/Posix/ClockImpl.cpp Normal file
View File

@ -0,0 +1,30 @@
// Copyright (C) 2012 Jérôme Leclercq
// This file is part of the "Nazara Engine - Core module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Core/Posix/ClockImpl.hpp>
#include <Nazara/Core/Error.hpp>
#include <ctime>
#include <sys/time.h>
#include <Nazara/Core/Debug.hpp>
bool NzClockImplInitializeHighPrecision()
{
// No initialization needed
}
nzUInt64 NzClockImplGetMicroseconds()
{
timeval clock;
gettimeofday(&clock, nullptr);
return static_cast<nzUInt64>(clock.tv_sec*1000000 + (clock.tv_nsec/1000));
}
nzUInt64 NzClockImplGetMilliseconds()
{
timeval clock;
gettimeofday(&clock, nullptr);
return static_cast<nzUInt64>(clock.tv_sec*1000 + (clock.tv_nsec/1000000));
}

16
src/Nazara/Core/Posix/ClockImpl.hpp Normal file
View File

@ -0,0 +1,16 @@
// Copyright (C) 2012 Jérôme Leclercq
// This file is part of the "Nazara Engine - Core module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#pragma once
#ifndef NAZARA_CLOCKIMPL_POSIX_HPP
#define NAZARA_CLOCKIMPL_POSIX_HPP
#include <Nazara/Prerequesites.hpp>
bool NzClockImplInitializeHighPrecision();
nzUInt64 NzClockImplGetMicroseconds();
nzUInt64 NzClockImplGetMilliseconds();
#endif // NAZARA_CLOCKIMPL_POSIX_HPP

52
src/Nazara/Core/Posix/ConditionVariableImpl.cpp Normal file
View File

@ -0,0 +1,52 @@
// Copyright (C) 2012 Jérôme Leclercq
// This file is part of the "Nazara Engine - Core module"
// For conditions of distribution and use, see copyright notice in Config.hpp
// Source: http://www.cs.wustl.edu/~schmidt/win32-cv-1.html
#include <Nazara/Core/Posix/ConditionVariableImpl.hpp>
#include <Nazara/Core/Posix/MutexImpl.hpp>
#include <Nazara/Core/Debug.hpp>
NzConditionVariableImpl::NzConditionVariableImpl()
{
pthread_cond_init(&m_cv, nullptr);
}
NzConditionVariableImpl::~NzConditionVariableImpl()
{
pthread_cond_destroy(&m_cv);
}
void NzConditionVariableImpl::Signal()
{
pthread_cond_signal(&m_cv);
}
void NzConditionVariableImpl::SignalAll()
{
pthread_cond_broadcast(&m_cv);
}
void NzConditionVariableImpl::Wait(NzMutexImpl* mutex)
{
pthread_cond_wait(&m_cv, mutex);
}
bool NzConditionVariableImpl::Wait(NzMutexImpl* mutex, nzUInt32 timeout)
{
// get the current time
timeval tv;
gettimeofday(&tv, NULL);
// construct the time limit (current time + time to wait)
timespec ti;
ti.tv_nsec = (tv.tv_usec + (timeout % 1000)) * 1000000;
ti.tv_sec = tv.tv_sec + (timeout / 1000) + (ti.tv_nsec / 1000000000);
ti.tv_nsec %= 1000000000;
pthread_cond_timedwait(&m_cv,mutex, &tv);
}

37
src/Nazara/Core/Posix/ConditionVariableImpl.hpp Normal file
View File

@ -0,0 +1,37 @@
// Copyright (C) 2012 Jérôme Leclercq
// This file is part of the "Nazara Engine - Core module"
// For conditions of distribution and use, see copyright notice in Config.hpp
// http://www.cs.wustl.edu/~schmidt/win32-cv-1.html
#pragma once
#ifndef NAZARA_CONDITIONVARIABLEIMPL_HPP
#define NAZARA_CONDITIONVARIABLEIMPL_HPP
#include <Nazara/Prerequesites.hpp>
#include <pthread.h>
#include <unistd.h>
#include <sys/time.h>
class NzMutexImpl;
class NzConditionVariableImpl
{
public:
NzConditionVariableImpl();
~NzConditionVariableImpl();
void Signal();
void SignalAll();
void Wait(NzMutexImpl* mutex);
bool Wait(NzMutexImpl* mutex, nzUInt32 timeout);
private:
pthread_cond_t m_cv;
};
#endif // NAZARA_CONDITIONVARIABLEIMPL_HPP

101
src/Nazara/Core/Posix/DirectoryImpl.cpp Normal file
View File

@ -0,0 +1,101 @@
// Copyright (C) 2012 Jérôme Leclercq
// This file is part of the "Nazara Engine - Core module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Core/Posix/DirectoryImpl.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/Debug.hpp>
NzDirectoryImpl::NzDirectoryImpl(const NzDirectory* parent)
{
NazaraUnused(parent);
}
void NzDirectoryImpl::Close()
{
closedir(m_handle);
}
NzString NzDirectoryImpl::GetResultName() const
{
return NzString::Unicode(m_result.d_name);
}
nzUInt64 NzDirectoryImpl::GetResultSize() const
{
struct stat64 resulststat;
stat64(m_result.d_name, &resulststat);
return static_cast<nzUInt64>(resulststat.st_size);
}
bool NzDirectoryImpl::IsResultDirectory() const
{
return S_ISDIR(m_result.d_name);
}
bool NzDirectoryImpl::NextResult()
{
if (m_result = readdir64(m_handle))
return true;
else
{
if (errno != ENOENT)
NazaraError("Unable to get next result: " + NzGetLastSystemError());
return false;
}
}
bool NzDirectoryImpl::Open(const NzString& dirPath)
{
m_handle = opendir(dirPath.GetConstBuffer());
if (m_handle == NULL)
{
NazaraError("Unable to open directory: " + NzGetLastSystemError());
return false;
}
return true;
}
bool NzDirectoryImpl::Create(const NzString& dirPath)
{
mode_t permissions; // TODO: check permissions
bool success = mkdir(dirPath.GetConstBuffer(), permissions) != -1;
return success;
}
bool NzDirectoryImpl::Exists(const NzString& dirPath)
{
if (S_ISDIR(dirPath.GetConstBuffer()))
return true;
return false;
}
NzString NzDirectoryImpl::GetCurrent()
{
NzString currentPath;
char* path = new char[_PC_PATH_MAX];
if (getcwd(path, _PC_PATH_MAX))
currentPath = NzString::Unicode(path);
else
NazaraError("Unable to get current directory: " + NzGetLastSystemError());
delete[] path;
return currentPath;
}
bool NzDirectoryImpl::Remove(const NzString& dirPath)
{
bool success = rmdir(dirPath.GetConstBuffer()) != -1;
return success;
}

48
src/Nazara/Core/Posix/DirectoryImpl.hpp Normal file
View File

@ -0,0 +1,48 @@
// Copyright (C) 2012 Jérôme Leclercq
// This file is part of the "Nazara Engine - Core module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#pragma once
#ifndef NAZARA_DIRECTORYIMPL_HPP
#define NAZARA_DIRECTORYIMPL_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Core/NonCopyable.hpp>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <dirent.h>
class NzDirectory;
class NzString;
class NzDirectoryImpl : NzNonCopyable
{
public:
NzDirectoryImpl(const NzDirectory* parent);
~NzDirectoryImpl() = default;
void Close();
NzString GetResultName() const;
nzUInt64 GetResultSize() const;
bool IsResultDirectory() const;
bool NextResult();
bool Open(const NzString& dirPath);
static bool Create(const NzString& dirPath);
static bool Exists(const NzString& dirPath);
static NzString GetCurrent();
static bool Remove(const NzString& dirPath);
private:
DIR* m_handle;
dirent64* m_result;
bool m_firstCall;
};
#endif // NAZARA_DIRECTORYIMPL_HPP

45
src/Nazara/Core/Posix/DynLibImpl.cpp Normal file
View File

@ -0,0 +1,45 @@
// Copyright (C) 2012 Jérôme Leclercq
// This file is part of the "Nazara Engine - Core module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Core/Posix/DynLibImpl.hpp>
#include <Nazara/Core/DynLib.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/String.hpp>
#include <Nazara/Core/Debug.hpp>
NzDynLibImpl::NzDynLibImpl(NzDynLib* parent) :
m_parent(parent)
{
}
NzDynLibFunc NzDynLibImpl::GetSymbol(const NzString& symbol) const
{
NzDynLibFunc sym = reinterpret_cast<NzDynLibFunc>(dlsym(m_handle, symbol.GetConstBuffer()));
if (!sym)
m_parent->SetLastError(NzGetLastSystemError()); // dlerror() ?
return sym;
}
bool NzDynLibImpl::Load(const NzString& libraryPath)
{
NzString path = libraryPath;
if (!path.EndsWith(".so"))
path += ".so";
m_handle = dlopen(path.GetConstBuffer(),);
if (m_handle)
return true;
else
{
m_parent->SetLastError(NzGetLastSystemError());
return false;
}
}
void NzDynLibImpl::Unload()
{
dlclose(m_handle);
}

31
src/Nazara/Core/Posix/DynLibImpl.hpp Normal file
View File

@ -0,0 +1,31 @@
// Copyright (C) 2012 Jérôme Leclercq
// This file is part of the "Nazara Engine - Core module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#pragma once
#ifndef NAZARA_DYNLIBIMPL_HPP
#define NAZARA_DYNLIBIMPL_HPP
#include <Nazara/Core/DynLib.hpp>
#include <Nazara/Core/NonCopyable.hpp>
#include <dlfcn.h>
class NzString;
class NzDynLibImpl : NzNonCopyable
{
public:
NzDynLibImpl(NzDynLib* m_parent);
~NzDynLibImpl() = default;
NzDynLibFunc GetSymbol(const NzString& symbol) const;
bool Load(const NzString& libraryPath);
void Unload();
private:
void* m_handle;
NzDynLib* m_parent;
};
#endif // NAZARA_DYNLIBIMPL_HPP

253
src/Nazara/Core/Posix/FileImpl.cpp Normal file
View File

@ -0,0 +1,253 @@
// Copyright (C) 2012 Jérôme Leclercq
// This file is part of the "Nazara Engine - Core module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Core/Posix/FileImpl.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/Posix/Time.hpp>
#include <Nazara/Core/Debug.hpp>
#include <stdio.h>
#include <unistd.h>
#include <time.h>
NzFileImpl::NzFileImpl(const NzFile* parent) :
m_endOfFile(false),
m_endOfFileUpdated(true)
{
NazaraUnused(parent);
}
void NzFileImpl::Close()
{
close(m_fileDescriptor);
}
bool NzFileImpl::EndOfFile() const
{
if (!m_endOfFileUpdated)
{
stat64 fileSize;
if (fstat64(m_handle, &fileSize) == -1)
fileSize.st_size = 0;
m_endOfFile = (GetCursorPos() >= static_cast<nzUInt64>(fileSize.st_size));
m_endOfFileUpdated = true;
}
return m_endOfFile;
}
void NzFileImpl::Flush()
{
if (fsync(m_fileDescriptor) == -1)
NazaraError("Unable to flush file: " + NzGetLastSystemError());
}
nzUInt64 NzFileImpl::GetCursorPos() const
{
off64_t position = lseek64(m_fileDescriptor, 0, SEEK_CUR);
return static_cast<nzUInt64>(position);
}
bool NzFileImpl::Open(const NzString& filePath, unsigned int mode)
{
int flags;
mode_t permissions = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
if (mode & NzFile::ReadOnly)
flags = O_RDONLY;
else if (mode & NzFile::ReadWrite)
{
flags = O_CREAT | O_RDWR;
if (mode & NzFile::Append)
flags |= O_APPEND;
if (mode & NzFile::Truncate)
flags |= O_TRUNC;
}
else if (mode & NzFile::WriteOnly)
{
flags = O_CREAT | O_WRONLY;
if (mode & NzFile::Append)
flags |= O_APPEND;
if (mode & NzFile::Truncate)
flags |= O_TRUNC;
}
else
return false;
// TODO: lock
// if ((mode & NzFile::Lock) == 0)
// shareMode |= FILE_SHARE_WRITE;
const char* path = filePath.GetConstBuffer();
m_fileDescriptor = open64(path, flags, permissions);
return m_fileDescriptor != -1;
}
std::size_t NzFileImpl::Read(void* buffer, std::size_t size)
{
ssize_t bytes;
if ((bytes = read(m_fileDescriptor, buffer, size)) != -1)
{
m_endOfFile = (static_cast<std::size_t>(bytes) != size);
m_endOfFileUpdated = true;
return static_cast<std::size_t>(bytes);
}
else
return 0;
}
bool NzFileImpl::SetCursorPos(NzFile::CursorPosition pos, nzInt64 offset)
{
int moveMethod;
switch (pos)
{
case NzFile::AtBegin:
moveMethod = SEEK_SET;
break;
case NzFile::AtCurrent:
moveMethod = SEEK_CUR;
break;
case NzFile::AtEnd:
moveMethod = SEEK_END;
break;
default:
NazaraInternalError("Cursor position not handled (0x" + NzString::Number(pos, 16) + ')');
return false;
}
m_endOfFileUpdated = false;
return lseek64(m_fileDescriptor, offset, moveMethod) != -1;
}
std::size_t NzFileImpl::Write(const void* buffer, std::size_t size)
{
lockf64(m_fileDescriptor, F_LOCK, size);
ssize_t written = write(m_fileDescriptor, buffer, size);
lockf64(m_fileDescriptor, F_ULOCK, size);
m_endOfFileUpdated = false;
return written;
}
bool NzFileImpl::Copy(const NzString& sourcePath, const NzString& targetPath)
{
int fd1 = open64(sourcePath.GetConstBuffer(), O_RDONLY);
if (fd1 == -1)
{
NazaraError("Fail to open input file (" + sourcePath + "): " + NzGetLastSystemError());
return false;
}
mode_t permissions; // TODO : get permission from first file
int fd2 = open64(sourcePath.GetConstBuffer(), O_WRONLY | O_TRUNC, permissions);
if (fd2 == -1)
{
NazaraError("Fail to open output file (" + targetPath + "): " + NzGetLastSystemError()); // TODO: more info ?
close(fd1);
return false;
}
char buffer[512];
ssize_t bytes;
do
{
bytes = read(fd1,buffer,512);
if (bytes == -1)
{
close(fd1);
close(fd2);
NazaraError("An error occured from copy : " + NzGetLastSystemError());
return false;
}
write(fd2,buffer,bytes);
} while (bytes == 512);
close(fd1);
close(fd2);
}
bool NzFileImpl::Delete(const NzString& filePath)
{
const char* path = filePath.GetConstBuffer();
bool success = unlink(path) != -1;
if (success)
return true;
else
{
NazaraError("Failed to delete file (" + filePath + "): " + NzGetLastSystemError());
return false;
}
}
bool NzFileImpl::Exists(const NzString& filePath)
{
char* path = filePath.GetConstBuffer();
if (access(path, F_OK) != -1)
return true;
return false;
}
time_t NzFileImpl::GetCreationTime(const NzString& filePath)
{
struct stat64 stats;
stat64(filePath.GetConstBuffer(), &stats);
return NzFileTimeToTime(std::ctime(&stats.st_ctim)); // not sure ?
}
time_t NzFileImpl::GetLastAccessTime(const NzString& filePath)
{
struct stat64 stats;
stat64(filePath.GetConstBuffer(), &stats);
return NzFileTimeToTime(std::ctime(&stats.st_atim));
}
time_t NzFileImpl::GetLastWriteTime(const NzString& filePath)
{
struct stat64 stats;
stat64(filePath.GetConstBuffer(), &stats);
return NzFileTimeToTime(std::ctime(&stats.st_mtim));
}
nzUInt64 NzFileImpl::GetSize(const NzString& filePath)
{
struct stat64 stats;
stat64(filePath.GetConstBuffer(), &stats);
return static_cast<nzUInt64>(stats.st_size);
}
bool NzFileImpl::Rename(const NzString& sourcePath, const NzString& targetPath)
{
const char* path = sourcePath.GetConstBuffer();
const char* newPath = targetPath.GetConstBuffer();
bool success = std::rename(path, newPath) != -1;
if (success)
return true;
else
{
NazaraError("Unable to rename file: " + NzGetLastSystemError());
return false;
}
}

62
src/Nazara/Core/Posix/FileImpl.hpp Normal file
View File

@ -0,0 +1,62 @@
// Copyright (C) 2012 Jérôme Leclercq
// This file is part of the "Nazara Engine - Core module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#pragma once
#ifndef NAZARA_FILEIMPL_HPP
#define NAZARA_FILEIMPL_HPP
#ifndef _LARGEFILE64_SOURCE
#define _LARGEFILE64_SOURCE
#endif
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Core/File.hpp>
#include <Nazara/Core/NonCopyable.hpp>
#include <ctime>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
/*
04/01/2012 : alexandre.janniaux@gmail.com
Add posix file implementation.
*/
class NzFile;
class NzString;
class NzFileImpl : NzNonCopyable
{
public:
NzFileImpl(const NzFile* parent);
~NzFileImpl() = default;
void Close();
bool EndOfFile() const;
void Flush();
nzUInt64 GetCursorPos() const;
bool Open(const NzString& filePath, unsigned int mode);
std::size_t Read(void* buffer, std::size_t size);
bool SetCursorPos(NzFile::CursorPosition pos, nzInt64 offset);
std::size_t Write(const void* buffer, std::size_t size);
static bool Copy(const NzString& sourcePath, const NzString& targetPath);
static bool Delete(const NzString& filePath);
static bool Exists(const NzString& filePath);
static time_t GetCreationTime(const NzString& filePath);
static time_t GetLastAccessTime(const NzString& filePath);
static time_t GetLastWriteTime(const NzString& filePath);
static nzUInt64 GetSize(const NzString& filePath);
static bool Rename(const NzString& sourcePath, const NzString& targetPath);
private:
int m_fileDescriptor;
FILE* m_handle;
mutable bool m_endOfFile;
mutable bool m_endOfFileUpdated;
};
#endif // NAZARA_FILEIMPL_HPP

81
src/Nazara/Core/Posix/HardwareInfoImpl.cpp Normal file
View File

@ -0,0 +1,81 @@
// Copyright (C) 2012 Jérôme Leclercq
// This file is part of the "Nazara Engine - Core module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Core/Posix/HardwareInfoImpl.hpp>
#include <Nazara/Core/Error.hpp>
#ifdef NAZARA_COMPILER_MSVC
#include <intrin.h>
#endif
#include <Nazara/Core/Debug.hpp>
void NzHardwareInfoImpl::Cpuid(nzUInt32 code, nzUInt32 result[4])
{
#if defined(NAZARA_COMPILER_MSVC)
__cpuid(reinterpret_cast<int*>(result), static_cast<int>(code)); // Visual propose une fonction intrinsèque pour le cpuid
#elif defined(NAZARA_COMPILER_CLANG) || defined(NAZARA_COMPILER_GCC) || defined(NAZARA_COMPILER_INTEL)
// Source: http://stackoverflow.com/questions/1666093/cpuid-implementations-in-c
asm volatile ("cpuid" // Besoin d'être volatile ?
: "=a" (result[0]), "=b" (result[1]), "=c" (result[2]), "=d" (result[3]) // output
: "a" (code), "c" (0)); // input
#else
NazaraInternalError("Cpuid has been called although it is not supported");
#endif
}
unsigned int NzHardwareInfoImpl::GetProcessorCount()
{
// Plus simple (et plus portable) que de passer par le CPUID
return sysconf(_SC_NPROCESSORS_CONF);
}
bool NzHardwareInfoImpl::IsCpuidSupported()
{
#ifdef NAZARA_PLATFORM_x64
return true; // Toujours supporté sur un processeur 64 bits
#else
#if defined(NAZARA_COMPILER_MSVC)
int supported;
__asm
{
pushfd
pop eax
mov ecx, eax
xor eax, 0x200000
push eax
popfd
pushfd
pop eax
xor eax, ecx
mov supported, eax
push ecx
popfd
};
return supported != 0;
#elif defined(NAZARA_COMPILER_CLANG) || defined(NAZARA_COMPILER_GCC) || defined(NAZARA_COMPILER_INTEL)
int supported;
asm volatile (" pushfl\n"
" pop %%eax\n"
" mov %%eax, %%ecx\n"
" xor $0x200000, %%eax\n"
" push %%eax\n"
" popfl\n"
" pushfl\n"
" pop %%eax\n"
" xor %%ecx, %%eax\n"
" mov %%eax, %0\n"
" push %%ecx\n"
" popfl"
: "=m" (supported) // output
: // input
: "eax", "ecx", "memory"); // clobbered register
return supported != 0;
#else
return false;
#endif
#endif
}

21
src/Nazara/Core/Posix/HardwareInfoImpl.hpp Normal file
View File

@ -0,0 +1,21 @@
// Copyright (C) 2012 Jérôme Leclercq
// This file is part of the "Nazara Engine - Core module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#pragma once
#ifndef NAZARA_HARDWAREINFOIMPL_POSIX_HPP
#define NAZARA_HARDWAREINFOIMPL_POSIX_HPP
#include <Nazara/Prerequesites.hpp>
#include <unistd.h>
class NzHardwareInfoImpl
{
public:
static void Cpuid(nzUInt32 code, nzUInt32 result[4]);
static unsigned int GetProcessorCount();
static bool IsCpuidSupported();
};
#endif // NAZARA_HARDWAREINFOIMPL_POSIX_HPP

31
src/Nazara/Core/Posix/MutexImpl.cpp Normal file
View File

@ -0,0 +1,31 @@
// Copyright (C) 2012 Jérôme Leclercq
// This file is part of the "Nazara Engine - Core module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Core/Posix/MutexImpl.hpp>
#include <Nazara/Core/Debug.hpp>
NzMutexImpl::NzMutexImpl()
{
pthread_mutex_init(&m_handle, NULL);
}
NzMutexImpl::~NzMutexImpl()
{
pthread_mutex_destroy(&m_handle);
}
void NzMutexImpl::Lock()
{
pthread_mutex_lock(&m_handle);
}
bool NzMutexImpl::TryLock()
{
pthread_mutex_trylock(&m_handle) == 0;
}
void NzMutexImpl::Unlock()
{
pthread_mutex_unlock(&m_handle);
}

33
src/Nazara/Core/Posix/MutexImpl.hpp Normal file
View File

@ -0,0 +1,33 @@
// Copyright (C) 2012 Jérôme Leclercq
// This file is part of the "Nazara Engine - Core module"
// For conditions of distribution and use, see copyright notice in Config.hpp
/*
04/01/2012 : alexandre.janniaux@gmail.com
Add pthread mutex implementation.
*/
#pragma once
#ifndef NAZARA_MUTEXIMPL_HPP
#define NAZARA_MUTEXIMPL_HPP
#include <pthread.h>
class NzMutexImpl
{
friend class NzConditionVariableImpl;
public:
NzMutexImpl();
~NzMutexImpl();
void Lock();
bool TryLock();
void Unlock();
private:
pthread_mutex_t m_handle;
};
#endif // NAZARA_MUTEXIMPL_HPP

68
src/Nazara/Core/Posix/SemaphoreImpl.cpp Normal file
View File

@ -0,0 +1,68 @@
// Copyright (C) 2012 Jérôme Leclercq
// This file is part of the "Nazara Engine - Core module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Core/Posix/SemaphoreImpl.hpp>
#include <Nazara/Core/Config.hpp>
#include <Nazara/Core/Error.hpp>
#include <limits>
#include <Nazara/Core/Debug.hpp>
NzSemaphoreImpl::NzSemaphoreImpl(unsigned int count)
{
m_semaphore = sem_init(&m_semaphore, 0, count);
if (!m_semaphore)
NazaraError("Failed to create semaphore: " + NzGetLastSystemError());
}
NzSemaphoreImpl::~NzSemaphoreImpl()
{
sem_destroy(&m_semaphore);
}
unsigned int NzSemaphoreImpl::GetCount() const
{
int count;
sem_getvalue(&m_semaphore, &count);
return static_cast<unsigned int>(count);
}
void NzSemaphoreImpl::Post()
{
#if NAZARA_CORE_SAFE
if (sem_post(&m_semaphore)==-1)
NazaraError("Failed to release semaphore: " + NzGetLastSystemError());
#else
sem_post(&m_semaphore);
#endif
}
void NzSemaphoreImpl::Wait()
{
#if NAZARA_CORE_SAFE
if (sem_wait(&m_semaphore) == -1 )
NazaraError("Failed to wait for semaphore: " + NzGetLastSystemError());
#else
sem_wait(&m_semaphore);
#endif
}
bool NzSemaphoreImpl::Wait(nzUInt32 timeout)
{
timespec ti;
ti.tv_nsec = (tv.tv_usec + (timeout % 1000)) * 1000000;
ti.tv_sec = tv.tv_sec + (timeout / 1000) + (ti.tv_nsec / 1000000000);
ti.tv_nsec %= 1000000000;
#if NAZARA_CORE_SAFE
if (sem_timedwait(m_semaphore, timeout) == -1)
{
NazaraError("Failed to wait for semaphore: " + NzGetLastSystemError());
return false;
}
return true;
#else
return sem_timedwait(&m_semaphore, ti) != -1;
#endif
}

28
src/Nazara/Core/Posix/SemaphoreImpl.hpp Normal file
View File

@ -0,0 +1,28 @@
// Copyright (C) 2012 Jérôme Leclercq
// This file is part of the "Nazara Engine - Core module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#pragma once
#ifndef NAZARA_SEMAPHOREIMPL_HPP
#define NAZARA_SEMAPHOREIMPL_HPP
#include <Nazara/Prerequesites.hpp>
#include <semaphore.h>
class NzSemaphoreImpl
{
public:
NzSemaphoreImpl(unsigned int count);
~NzSemaphoreImpl();
unsigned int GetCount() const;
void Post();
void Wait();
bool Wait(nzUInt32 timeout);
private:
sem_t m_semaphore;
};
#endif // NAZARA_SEMAPHOREIMPL_HPP

79
src/Nazara/Core/Posix/ThreadImpl.cpp Normal file
View File

@ -0,0 +1,79 @@
// Copyright (C) 2012 Jérôme Leclercq
// This file is part of the "Nazara Engine - Core module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Core/Posix/ThreadImpl.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/Functor.hpp>
#include <process.h>
#include <Nazara/Core/Debug.hpp>
NzThreadImpl::NzThreadImpl(NzFunctor* functor)
{
int error = pthread_create(&m_handle, nullptr, &NzThreadImpl::ThreadProc, functor);
if (error != 0)
NazaraInternalError("Failed to create thread: " + NzGetLastSystemError());
}
void NzThreadImpl::Detach()
{
// http://stackoverflow.com/questions/418742/is-it-reasonable-to-call-closehandle-on-a-thread-before-it-terminates
pthread_detach(&m_handle);
}
void NzThreadImpl::Join()
{
pthread_join(&m_handle, nullptr);
}
unsigned int __stdcall NzThreadImpl::ThreadProc(void* userdata)
{
NzFunctor* func = static_cast<NzFunctor*>(userdata);
func->Run();
delete func;
/*
En C++, il vaut mieux retourner depuis la fonction que de quitter le thread explicitement
Source : http://msdn.microsoft.com/en-us/library/windows/desktop/ms682659(v=vs.85).aspx
*/
return 0;
}
void NzThreadImpl::Sleep(nzUInt32 time)
{
// code from SFML2 Unix SleepImpl.cpp source https://github.com/LaurentGomila/SFML/blob/master/src/SFML/System/Unix/SleepImpl.cpp
// usleep is not reliable enough (it might block the
// whole process instead of just the current thread)
// so we must use pthread_cond_timedwait instead
// this implementation is inspired from Qt
nzUint64 usecs = time.asMicroseconds();
// get the current time
timeval tv;
gettimeofday(&tv, NULL);
// construct the time limit (current time + time to wait)
timespec ti;
ti.tv_nsec = (tv.tv_usec + (usecs % 1000000)) * 1000;
ti.tv_sec = tv.tv_sec + (usecs / 1000000) + (ti.tv_nsec / 1000000000);
ti.tv_nsec %= 1000000000;
// create a mutex and thread condition
pthread_mutex_t mutex;
pthread_mutex_init(&mutex, 0);
pthread_cond_t condition;
pthread_cond_init(&condition, 0);
// wait...
pthread_mutex_lock(&mutex);
pthread_cond_timedwait(&condition, &mutex, &ti);
pthread_mutex_unlock(&mutex);
// destroy the mutex and condition
pthread_cond_destroy(&condition);
pthread_mutex_destroy(&mutex);
}

35
src/Nazara/Core/Posix/ThreadImpl.hpp Normal file
View File

@ -0,0 +1,35 @@
// Copyright (C) 2012 Jérôme Leclercq
// This file is part of the "Nazara Engine - Core module"
// For conditions of distribution and use, see copyright notice in Config.hpp
// Inspiré du code de la SFML par Laurent Gomila
#pragma once
#ifndef NAZARA_THREADIMPL_HPP
#define NAZARA_THREADIMPL_HPP
#include <Nazara/Prerequesites.hpp>
#include <pthread.h>
#include <unistd.h>
#include <sys/time.h>
struct NzFunctor;
class NzThreadImpl
{
public:
NzThreadImpl(NzFunctor* threadFunc);
void Detach();
void Join();
static void Sleep(nzUInt32 time);
private:
static unsigned int ThreadProc(void* userdata);
pthread_t m_handle;
};
#endif // NAZARA_THREADIMPL_HPP