lauchmelder/SFML
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Removed dependencies to OS-specific headers in sfml-system

Browse source 
git-svn-id: https://sfml.svn.sourceforge.net/svnroot/sfml/branches/sfml2@1023 4e206d99-4929-0410-ac5d-dfc041789085
This commit is contained in:
laurentgom 2009-02-27 15:03:20 +00:00
parent 2228419caf
commit 9a7fcc04be
21 changed files with 531 additions and 306 deletions
Download patch file Download diff file Expand all files Collapse all files

52
include/SFML/System/Mutex.hpp
View file

@ -29,17 +29,59 @@
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Config.hpp>
#include <SFML/System/NonCopyable.hpp>
#ifdef SFML_SYSTEM_WINDOWS
namespace sf
{
namespace priv
{
class MutexImpl;
}
#include <SFML/System/Win32/Mutex.hpp>
////////////////////////////////////////////////////////////
/// Mutex defines a mutex (MUTual EXclusion) object,
/// that allows a thread to lock critical instructions
/// to avoid simultaneous access with other threads.
/// See Lock for an efficient way of using it.
////////////////////////////////////////////////////////////
class SFML_API Mutex : NonCopyable
{
public :
#else
////////////////////////////////////////////////////////////
/// Default constructor
///
////////////////////////////////////////////////////////////
Mutex();
#include <SFML/System/Unix/Mutex.hpp>
////////////////////////////////////////////////////////////
/// Destructor
///
////////////////////////////////////////////////////////////
~Mutex();
#endif
////////////////////////////////////////////////////////////
/// Lock the mutex
///
////////////////////////////////////////////////////////////
void Lock();
////////////////////////////////////////////////////////////
/// Unlock the mutex
///
////////////////////////////////////////////////////////////
void Unlock();
private :
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
priv::MutexImpl* myMutexImpl; ///< OS-specific implementation
};
} // namespace sf
#endif // SFML_MUTEX_HPP

7
include/SFML/System/Randomizer.hpp
View file

@ -79,13 +79,6 @@ public :
///
////////////////////////////////////////////////////////////
static int Random(int Begin, int End);
private :
////////////////////////////////////////////////////////////
// Static member variables
////////////////////////////////////////////////////////////
static unsigned int ourSeed;
};
} // namespace sf

14
include/SFML/System/Sleep.hpp
View file

@ -33,13 +33,13 @@
namespace sf
{
////////////////////////////////////////////////////////////
/// Make the current thread sleep for a given time
///
/// \param Duration : Time to sleep, in seconds (must be >= 0)
///
////////////////////////////////////////////////////////////
void SFML_API Sleep(float Duration);
////////////////////////////////////////////////////////////
/// Make the current thread sleep for a given time
///
/// \param Duration : Time to sleep, in seconds (must be >= 0)
///
////////////////////////////////////////////////////////////
void SFML_API Sleep(float Duration);
} // namespace sf

86
include/SFML/System/Thread.hpp
View file

@ -29,17 +29,93 @@
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Config.hpp>
#include <SFML/System/NonCopyable.hpp>
#include <cstdlib>
#ifdef SFML_SYSTEM_WINDOWS
namespace sf
{
namespace priv
{
class ThreadImpl;
}
#include <SFML/System/Win32/Thread.hpp>
////////////////////////////////////////////////////////////
/// Thread defines an easy way to manipulate a thread.
/// There are two ways to use Thread :
/// - Inherit from it and override the Run() virtual function
/// - Construct a Thread instance and pass it a function
/// pointer to call
////////////////////////////////////////////////////////////
class SFML_API Thread : NonCopyable
{
public :
#else
typedef void (*FuncType)(void*);
#include <SFML/System/Unix/Thread.hpp>
////////////////////////////////////////////////////////////
/// Construct the thread from a function pointer
///
/// \param Function : Entry point of the thread
/// \param UserData : Data to pass to the thread function (NULL by default)
///
////////////////////////////////////////////////////////////
Thread(FuncType Function, void* UserData = NULL);
#endif
////////////////////////////////////////////////////////////
/// Virtual destructor
///
////////////////////////////////////////////////////////////
virtual ~Thread();
////////////////////////////////////////////////////////////
/// Create and run the thread
///
////////////////////////////////////////////////////////////
void Launch();
////////////////////////////////////////////////////////////
/// Wait until the thread finishes
///
////////////////////////////////////////////////////////////
void Wait();
////////////////////////////////////////////////////////////
/// Terminate the thread
/// Terminating a thread with this function is not safe,
/// you should rather try to make the thread function
/// terminate by itself
///
////////////////////////////////////////////////////////////
void Terminate();
protected :
////////////////////////////////////////////////////////////
/// Default constructor
///
////////////////////////////////////////////////////////////
Thread();
private :
friend class priv::ThreadImpl;
////////////////////////////////////////////////////////////
/// Function called as the thread entry point
///
////////////////////////////////////////////////////////////
virtual void Run();
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
priv::ThreadImpl* myThreadImpl; ///< OS-specific implementation of the thread
FuncType myFunction; ///< Function to call as the thread entry point
void* myUserData; ///< Data to pass to the thread function
};
} // namespace sf
#endif // SFML_THREAD_HPP

82
include/SFML/System/Unix/Mutex.hpp
View file

@ -1,82 +0,0 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented;
// you must not claim that you wrote the original software.
// If you use this software in a product, an acknowledgment
// in the product documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such,
// and must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
////////////////////////////////////////////////////////////
#ifndef SFML_MUTEXUNIX_HPP
#define SFML_MUTEXUNIX_HPP
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/System/NonCopyable.hpp>
#include <pthread.h>
namespace sf
{
////////////////////////////////////////////////////////////
/// Mutex defines a mutex (MUTual EXclusion) object,
/// that allows a thread to lock critical instructions
/// to avoid simultaneous access with other threads.
/// See Lock for an efficient way of using it.
////////////////////////////////////////////////////////////
class SFML_API Mutex : NonCopyable
{
public :
////////////////////////////////////////////////////////////
/// Default constructor
///
////////////////////////////////////////////////////////////
Mutex();
////////////////////////////////////////////////////////////
/// Destructor
///
////////////////////////////////////////////////////////////
~Mutex();
////////////////////////////////////////////////////////////
/// Lock the mutex
///
////////////////////////////////////////////////////////////
void Lock();
////////////////////////////////////////////////////////////
/// Unlock the mutex
///
////////////////////////////////////////////////////////////
void Unlock();
private :
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
pthread_mutex_t myMutex; ///< pthread instance of the mutex
};
} // namespace sf
#endif // SFML_MUTEXUNIX_HPP

124
include/SFML/System/Unix/Thread.hpp
View file

@ -1,124 +0,0 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented;
// you must not claim that you wrote the original software.
// If you use this software in a product, an acknowledgment
// in the product documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such,
// and must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
////////////////////////////////////////////////////////////
#ifndef SFML_THREADUNIX_HPP
#define SFML_THREADUNIX_HPP
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/System/NonCopyable.hpp>
#include <pthread.h>
namespace sf
{
////////////////////////////////////////////////////////////
/// Thread defines a thread.
/// There is two ways to use Thread :
/// - Inherit from it and override the Run() virtual function
/// - Construct a sfThread instance and pass it a function
/// pointer to call
////////////////////////////////////////////////////////////
class SFML_API Thread : NonCopyable
{
public :
typedef void (*FuncType)(void*);
////////////////////////////////////////////////////////////
/// Construct the thread from a function pointer
///
/// \param Function : Entry point of the thread
/// \param UserData : Data to pass to the thread function (NULL by default)
///
////////////////////////////////////////////////////////////
Thread(FuncType Function, void* UserData = NULL);
////////////////////////////////////////////////////////////
/// Virtual destructor
///
////////////////////////////////////////////////////////////
virtual ~Thread();
////////////////////////////////////////////////////////////
/// Create and run the thread
///
////////////////////////////////////////////////////////////
void Launch();
////////////////////////////////////////////////////////////
/// Wait until the thread finishes
///
////////////////////////////////////////////////////////////
void Wait();
////////////////////////////////////////////////////////////
/// Terminate the thread
/// Terminating a thread with this function is not safe,
/// you should rather try to make the thread function
/// terminate by itself
///
////////////////////////////////////////////////////////////
void Terminate();
protected :
////////////////////////////////////////////////////////////
/// Default constructor
///
////////////////////////////////////////////////////////////
Thread();
private :
////////////////////////////////////////////////////////////
/// Function called as the thread entry point
///
////////////////////////////////////////////////////////////
virtual void Run();
////////////////////////////////////////////////////////////
/// Actual thread entry point, dispatches to instances
///
/// \param UserData : Data to pass to the thread function
///
/// \return Error code
///
////////////////////////////////////////////////////////////
static void* ThreadFunc(void* UserData);
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
pthread_t myThread; ///< Unix thread instance
bool myIsActive; ///< Thread state (active or inactive)
FuncType myFunction; ///< Function to call as the thread entry point
void* myUserData; ///< Data to pass to the thread function
};
} // namespace sf
#endif // SFML_THREADUNIX_HPP

84
include/SFML/System/Win32/Mutex.hpp
View file

@ -1,84 +0,0 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented;
// you must not claim that you wrote the original software.
// If you use this software in a product, an acknowledgment
// in the product documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such,
// and must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
////////////////////////////////////////////////////////////
#ifndef SFML_MUTEXWIN32_HPP
#define SFML_MUTEXWIN32_HPP
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/System/NonCopyable.hpp>
#include <windows.h>
namespace sf
{
////////////////////////////////////////////////////////////
/// Mutex defines a mutex (MUTual EXclusion) object,
/// that allows a thread to lock critical instructions
/// to avoid simultaneous access with other threads.
/// The Win32 version uses critical sections, as it is
/// faster than mutexes.<br/>
/// See Lock for an efficient way of using it.
////////////////////////////////////////////////////////////
class SFML_API Mutex : NonCopyable
{
public :
////////////////////////////////////////////////////////////
/// Default constructor
///
////////////////////////////////////////////////////////////
Mutex();
////////////////////////////////////////////////////////////
/// Destructor
///
////////////////////////////////////////////////////////////
~Mutex();
////////////////////////////////////////////////////////////
/// Lock the mutex
///
////////////////////////////////////////////////////////////
void Lock();
////////////////////////////////////////////////////////////
/// Unlock the mutex
///
////////////////////////////////////////////////////////////
void Unlock();
private :
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
CRITICAL_SECTION myHandle; ///< Win32 handle of the mutex
};
} // namespace sf
#endif // SFML_MUTEXWIN32_HPP

123
include/SFML/System/Win32/Thread.hpp
View file

@ -1,123 +0,0 @@
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2009 Laurent Gomila (laurent.gom@gmail.com)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented;
// you must not claim that you wrote the original software.
// If you use this software in a product, an acknowledgment
// in the product documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such,
// and must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
////////////////////////////////////////////////////////////
#ifndef SFML_THREADWIN32_HPP
#define SFML_THREADWIN32_HPP
////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/System/NonCopyable.hpp>
#include <windows.h>
namespace sf
{
////////////////////////////////////////////////////////////
/// Thread defines an easy way to manipulate a thread.
/// There are two ways to use Thread :
/// - Inherit from it and override the Run() virtual function
/// - Construct a Thread instance and pass it a function
/// pointer to call
////////////////////////////////////////////////////////////
class SFML_API Thread : NonCopyable
{
public :
typedef void (*FuncType)(void*);
////////////////////////////////////////////////////////////
/// Construct the thread from a function pointer
///
/// \param Function : Entry point of the thread
/// \param UserData : Data to pass to the thread function (NULL by default)
///
////////////////////////////////////////////////////////////
Thread(FuncType Function, void* UserData = NULL);
////////////////////////////////////////////////////////////
/// Virtual destructor
///
////////////////////////////////////////////////////////////
virtual ~Thread();
////////////////////////////////////////////////////////////
/// Create and run the thread
///
////////////////////////////////////////////////////////////
void Launch();
////////////////////////////////////////////////////////////
/// Wait until the thread finishes
///
////////////////////////////////////////////////////////////
void Wait();
////////////////////////////////////////////////////////////
/// Terminate the thread
/// Terminating a thread with this function is not safe,
/// you should rather try to make the thread function
/// terminate by itself
///
////////////////////////////////////////////////////////////
void Terminate();
protected :
////////////////////////////////////////////////////////////
/// Default constructor
///
////////////////////////////////////////////////////////////
Thread();
private :
////////////////////////////////////////////////////////////
/// Function called as the thread entry point
///
////////////////////////////////////////////////////////////
virtual void Run();
////////////////////////////////////////////////////////////
/// Actual thread entry point, dispatches to instances
///
/// \param UserData : Data to pass to the thread function
///
/// \return Error code
///
////////////////////////////////////////////////////////////
static unsigned int __stdcall ThreadFunc(void* UserData);
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
HANDLE myHandle; ///< Win32 thread handle
FuncType myFunction; ///< Function to call as the thread entry point
void* myUserData; ///< Data to pass to the thread function
};
} // namespace sf
#endif // SFML_THREADWIN32_HPP