encounter/dawn-cmake
1
0
Fork 0
mirror of https://github.com/encounter/dawn-cmake.git synced 2025-12-16 00:17:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

Member rename: src/{common/utils/wire}

Browse Source
This commit is contained in:
Corentin Wallez
2017-11-23 10:49:58 -08:00
committed by Corentin Wallez
parent 8d75e5b4ae
commit ad6470466c
11 changed files with 214 additions and 214 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
src/common/DynamicLib.cpp
View File

@@ -29,65 +29,65 @@ DynamicLib::~DynamicLib() {
}
DynamicLib::DynamicLib(DynamicLib&& other) {
std::swap(this->handle, other.handle);
std::swap(mHandle, other.mHandle);
}
DynamicLib& DynamicLib::operator=(DynamicLib&& other) {
std::swap(this->handle, other.handle);
std::swap(mHandle, other.mHandle);
return *this;
}
bool DynamicLib::Valid() const {
return handle != nullptr;
return mHandle != nullptr;
}
bool DynamicLib::Open(const std::string& filename, std::string* error) {
#if NXT_PLATFORM_WINDOWS
handle = LoadLibraryA(filename.c_str());
mHandle = LoadLibraryA(filename.c_str());
if (handle == nullptr && error != nullptr) {
if (mHandle == nullptr && error != nullptr) {
*error = "Windows Error: " + std::to_string(GetLastError());
}
#elif NXT_PLATFORM_POSIX
handle = dlopen(filename.c_str(), RTLD_NOW);
mHandle = dlopen(filename.c_str(), RTLD_NOW);
if (handle == nullptr && error != nullptr) {
if (mHandle == nullptr && error != nullptr) {
*error = dlerror();
}
#else
#error "Unsupported platform for DynamicLib"
#endif
return handle != nullptr;
return mHandle != nullptr;
}
void DynamicLib::Close() {
if (handle == nullptr) {
if (mHandle == nullptr) {
return;
}
#if NXT_PLATFORM_WINDOWS
FreeLibrary(static_cast<HMODULE>(handle));
FreeLibrary(static_cast<HMODULE>(mHandle));
#elif NXT_PLATFORM_POSIX
dlclose(handle);
dlclose(mHandle);
#else
#error "Unsupported platform for DynamicLib"
#endif
handle = nullptr;
mHandle = nullptr;
}
void* DynamicLib::GetProc(const std::string& procName, std::string* error) const {
void* proc = nullptr;
#if NXT_PLATFORM_WINDOWS
proc = reinterpret_cast<void*>(GetProcAddress(static_cast<HMODULE>(handle), procName.c_str()));
proc = reinterpret_cast<void*>(GetProcAddress(static_cast<HMODULE>(mHandle), procName.c_str()));
if (proc == nullptr && error != nullptr) {
*error = "Windows Error: " + std::to_string(GetLastError());
}
#elif NXT_PLATFORM_POSIX
proc = reinterpret_cast<void*>(dlsym(handle, procName.c_str()));
proc = reinterpret_cast<void*>(dlsym(mHandle, procName.c_str()));
if (proc == nullptr && error != nullptr) {
*error = dlerror();

2
src/common/DynamicLib.h
View File

@@ -48,7 +48,7 @@ class DynamicLib {
}
private:
void* handle = nullptr;
void* mHandle = nullptr;
};
#endif // COMMON_DYNAMICLIB_H_

132
src/common/SerialQueue.h
View File

@@ -40,11 +40,11 @@ class SerialQueue {
T& operator*() const;
private:
StorageIterator storageIterator;
// Special case the serialIterator when it should be equal to storageIterator.begin()
// otherwise we could ask storageIterator.begin() when storageIterator is storage.end()
// which is invalid. storageIterator.begin() is tagged with a nullptr.
T* serialIterator;
StorageIterator mStorageIterator;
// Special case the mSerialIterator when it should be equal to mStorageIterator.begin()
// otherwise we could ask mStorageIterator.begin() when mStorageIterator is mStorage.end()
// which is invalid. mStorageIterator.begin() is tagged with a nullptr.
T* mSerialIterator;
};
class ConstIterator {
@@ -57,8 +57,8 @@ class SerialQueue {
const T& operator*() const;
private:
ConstStorageIterator storageIterator;
const T* serialIterator;
ConstStorageIterator mStorageIterator;
const T* mSerialIterator;
};
class BeginEnd {
@@ -69,8 +69,8 @@ class SerialQueue {
Iterator end() const;
private:
StorageIterator startIt;
StorageIterator endIt;
StorageIterator mStartIt;
StorageIterator mEndIt;
};
class ConstBeginEnd {
@@ -81,8 +81,8 @@ class SerialQueue {
ConstIterator end() const;
private:
ConstStorageIterator startIt;
ConstStorageIterator endIt;
ConstStorageIterator mStartIt;
ConstStorageIterator mEndIt;
};
// The serial must be given in (not strictly) increasing order.
@@ -110,90 +110,90 @@ class SerialQueue {
// Returns the first StorageIterator that a serial bigger than serial.
ConstStorageIterator FindUpTo(Serial serial) const;
StorageIterator FindUpTo(Serial serial);
Storage storage;
Storage mStorage;
};
// SerialQueue
template<typename T>
void SerialQueue<T>::Enqueue(const T& value, Serial serial) {
NXT_ASSERT(Empty() || storage.back().first <= serial);
NXT_ASSERT(Empty() || mStorage.back().first <= serial);
if (Empty() || storage.back().first < serial) {
storage.emplace_back(SerialPair(serial, {}));
if (Empty() || mStorage.back().first < serial) {
mStorage.emplace_back(SerialPair(serial, {}));
}
storage.back().second.emplace_back(value);
mStorage.back().second.emplace_back(value);
}
template<typename T>
void SerialQueue<T>::Enqueue(T&& value, Serial serial) {
NXT_ASSERT(Empty() || storage.back().first <= serial);
NXT_ASSERT(Empty() || mStorage.back().first <= serial);
if (Empty() || storage.back().first < serial) {
storage.emplace_back(SerialPair(serial, {}));
if (Empty() || mStorage.back().first < serial) {
mStorage.emplace_back(SerialPair(serial, {}));
}
storage.back().second.emplace_back(value);
mStorage.back().second.emplace_back(value);
}
template<typename T>
void SerialQueue<T>::Enqueue(const std::vector<T>& values, Serial serial) {
NXT_ASSERT(values.size() > 0);
NXT_ASSERT(Empty() || storage.back().first <= serial);
storage.emplace_back(SerialPair(serial, {values}));
NXT_ASSERT(Empty() || mStorage.back().first <= serial);
mStorage.emplace_back(SerialPair(serial, {values}));
}
template<typename T>
void SerialQueue<T>::Enqueue(std::vector<T>&& values, Serial serial) {
NXT_ASSERT(values.size() > 0);
NXT_ASSERT(Empty() || storage.back().first <= serial);
storage.emplace_back(SerialPair(serial, {values}));
NXT_ASSERT(Empty() || mStorage.back().first <= serial);
mStorage.emplace_back(SerialPair(serial, {values}));
}
template<typename T>
bool SerialQueue<T>::Empty() const {
return storage.empty();
return mStorage.empty();
}
template<typename T>
typename SerialQueue<T>::ConstBeginEnd SerialQueue<T>::IterateAll() const {
return {storage.begin(), storage.end()};
return {mStorage.begin(), mStorage.end()};
}
template<typename T>
typename SerialQueue<T>::ConstBeginEnd SerialQueue<T>::IterateUpTo(Serial serial) const {
return {storage.begin(), FindUpTo(serial)};
return {mStorage.begin(), FindUpTo(serial)};
}
template<typename T>
typename SerialQueue<T>::BeginEnd SerialQueue<T>::IterateAll() {
return {storage.begin(), storage.end()};
return {mStorage.begin(), mStorage.end()};
}
template<typename T>
typename SerialQueue<T>::BeginEnd SerialQueue<T>::IterateUpTo(Serial serial) {
return {storage.begin(), FindUpTo(serial)};
return {mStorage.begin(), FindUpTo(serial)};
}
template<typename T>
void SerialQueue<T>::Clear() {
storage.clear();
mStorage.clear();
}
template<typename T>
void SerialQueue<T>::ClearUpTo(Serial serial) {
storage.erase(storage.begin(), FindUpTo(serial));
mStorage.erase(mStorage.begin(), FindUpTo(serial));
}
template<typename T>
Serial SerialQueue<T>::FirstSerial() const {
NXT_ASSERT(!Empty());
return storage.front().first;
return mStorage.front().first;
}
template<typename T>
typename SerialQueue<T>::ConstStorageIterator SerialQueue<T>::FindUpTo(Serial serial) const {
auto it = storage.begin();
while (it != storage.end() && it->first <= serial) {
auto it = mStorage.begin();
while (it != mStorage.end() && it->first <= serial) {
it ++;
}
return it;
@@ -201,8 +201,8 @@ typename SerialQueue<T>::ConstStorageIterator SerialQueue<T>::FindUpTo(Serial se
template<typename T>
typename SerialQueue<T>::StorageIterator SerialQueue<T>::FindUpTo(Serial serial) {
auto it = storage.begin();
while (it != storage.end() && it->first <= serial) {
auto it = mStorage.begin();
while (it != mStorage.end() && it->first <= serial) {
it ++;
}
return it;
@@ -212,39 +212,39 @@ typename SerialQueue<T>::StorageIterator SerialQueue<T>::FindUpTo(Serial serial)
template<typename T>
SerialQueue<T>::BeginEnd::BeginEnd(typename SerialQueue<T>::StorageIterator start, typename SerialQueue<T>::StorageIterator end)
: startIt(start), endIt(end) {
: mStartIt(start), mEndIt(end) {
}
template<typename T>
typename SerialQueue<T>::Iterator SerialQueue<T>::BeginEnd::begin() const {
return {startIt};
return {mStartIt};
}
template<typename T>
typename SerialQueue<T>::Iterator SerialQueue<T>::BeginEnd::end() const {
return {endIt};
return {mEndIt};
}
// SerialQueue::Iterator
template<typename T>
SerialQueue<T>::Iterator::Iterator(typename SerialQueue<T>::StorageIterator start)
: storageIterator(start), serialIterator(nullptr) {
: mStorageIterator(start), mSerialIterator(nullptr) {
}
template<typename T>
typename SerialQueue<T>::Iterator& SerialQueue<T>::Iterator::operator++() {
T* vectorData = storageIterator->second.data();
T* vectorData = mStorageIterator->second.data();
if (serialIterator == nullptr) {
serialIterator = vectorData + 1;
if (mSerialIterator == nullptr) {
mSerialIterator = vectorData + 1;
} else {
serialIterator ++;
mSerialIterator ++;
}
if (serialIterator >= vectorData + storageIterator->second.size()) {
serialIterator = nullptr;
storageIterator ++;
if (mSerialIterator >= vectorData + mStorageIterator->second.size()) {
mSerialIterator = nullptr;
mStorageIterator ++;
}
return *this;
@@ -252,7 +252,7 @@ typename SerialQueue<T>::Iterator& SerialQueue<T>::Iterator::operator++() {
template<typename T>
bool SerialQueue<T>::Iterator::operator==(const typename SerialQueue<T>::Iterator& other) const {
return other.storageIterator == storageIterator && other.serialIterator == serialIterator;
return other.mStorageIterator == mStorageIterator && other.mSerialIterator == mSerialIterator;
}
template<typename T>
@@ -262,49 +262,49 @@ bool SerialQueue<T>::Iterator::operator!=(const typename SerialQueue<T>::Iterato
template<typename T>
T& SerialQueue<T>::Iterator::operator*() const {
if (serialIterator == nullptr) {
return *storageIterator->second.begin();
if (mSerialIterator == nullptr) {
return *mStorageIterator->second.begin();
}
return *serialIterator;
return *mSerialIterator;
}
// SerialQueue::ConstBeginEnd
template<typename T>
SerialQueue<T>::ConstBeginEnd::ConstBeginEnd(typename SerialQueue<T>::ConstStorageIterator start, typename SerialQueue<T>::ConstStorageIterator end)
: startIt(start), endIt(end) {
: mStartIt(start), mEndIt(end) {
}
template<typename T>
typename SerialQueue<T>::ConstIterator SerialQueue<T>::ConstBeginEnd::begin() const {
return {startIt};
return {mStartIt};
}
template<typename T>
typename SerialQueue<T>::ConstIterator SerialQueue<T>::ConstBeginEnd::end() const {
return {endIt};
return {mEndIt};
}
// SerialQueue::ConstIterator
template<typename T>
SerialQueue<T>::ConstIterator::ConstIterator(typename SerialQueue<T>::ConstStorageIterator start)
: storageIterator(start), serialIterator(nullptr) {
: mStorageIterator(start), mSerialIterator(nullptr) {
}
template<typename T>
typename SerialQueue<T>::ConstIterator& SerialQueue<T>::ConstIterator::operator++() {
const T* vectorData = storageIterator->second.data();
const T* vectorData = mStorageIterator->second.data();
if (serialIterator == nullptr) {
serialIterator = vectorData + 1;
if (mSerialIterator == nullptr) {
mSerialIterator = vectorData + 1;
} else {
serialIterator ++;
mSerialIterator ++;
}
if (serialIterator >= vectorData + storageIterator->second.size()) {
serialIterator = nullptr;
storageIterator ++;
if (mSerialIterator >= vectorData + mStorageIterator->second.size()) {
mSerialIterator = nullptr;
mStorageIterator ++;
}
return *this;
@@ -312,7 +312,7 @@ typename SerialQueue<T>::ConstIterator& SerialQueue<T>::ConstIterator::operator+
template<typename T>
bool SerialQueue<T>::ConstIterator::operator==(const typename SerialQueue<T>::ConstIterator& other) const {
return other.storageIterator == storageIterator && other.serialIterator == serialIterator;
return other.mStorageIterator == mStorageIterator && other.mSerialIterator == mSerialIterator;
}
template<typename T>
@@ -322,10 +322,10 @@ bool SerialQueue<T>::ConstIterator::operator!=(const typename SerialQueue<T>::Co
template<typename T>
const T& SerialQueue<T>::ConstIterator::operator*() const {
if (serialIterator == nullptr) {
return *storageIterator->second.begin();
if (mSerialIterator == nullptr) {
return *mStorageIterator->second.begin();
}
return *serialIterator;
return *mSerialIterator;
}
#endif // COMMON_SERIALQUEUE_H_