Open-Harbor/osrm-backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

replacing c-style size_t with the one from std namespace

Browse Source
This commit is contained in:
DennisOSRM 2013-02-12 15:46:40 +01:00
parent 7e39c43896
commit 0f03beb2b5
1 changed files with 30 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

61
DataStructures/DeallocatingVector.h
View File

@ -22,7 +22,6 @@ or see http://www.gnu.org/licenses/agpl.txt.
#define DEALLOCATINGVECTOR_H_ #define DEALLOCATINGVECTOR_H_
#include <cassert> #include <cassert>
#include <cstdlib>
#include <vector> #include <vector>
#if __cplusplus > 199711L #if __cplusplus > 199711L
@ -32,7 +31,7 @@ or see http://www.gnu.org/licenses/agpl.txt.
#endif #endif
template<typename ElementT, size_t bucketSizeC = 8388608/sizeof(ElementT), bool DeallocateC = false> template<typename ElementT, std::size_t bucketSizeC = 8388608/sizeof(ElementT), bool DeallocateC = false>
class DeallocatingVectorIterator : public std::iterator<std::random_access_iterator_tag, ElementT> { class DeallocatingVectorIterator : public std::iterator<std::random_access_iterator_tag, ElementT> {
protected: protected:
@ -42,12 +41,12 @@ protected:
DeallocatingVectorIteratorState(); DeallocatingVectorIteratorState();
public: public:
explicit DeallocatingVectorIteratorState(const DeallocatingVectorIteratorState &r) : mData(r.mData), mIndex(r.mIndex), mBucketList(r.mBucketList) {} explicit DeallocatingVectorIteratorState(const DeallocatingVectorIteratorState &r) : mData(r.mData), mIndex(r.mIndex), mBucketList(r.mBucketList) {}
//explicit DeallocatingVectorIteratorState(const ElementT * ptr, const size_t idx, const std::vector<ElementT *> & input_list) : mData(ptr), mIndex(idx), mBucketList(input_list) {} //explicit DeallocatingVectorIteratorState(const ElementT * ptr, const std::size_t idx, const std::vector<ElementT *> & input_list) : mData(ptr), mIndex(idx), mBucketList(input_list) {}
explicit DeallocatingVectorIteratorState(const size_t idx, std::vector<ElementT *> & input_list) : mData(DEALLOCATION_VECTOR_NULL_PTR), mIndex(idx), mBucketList(input_list) { explicit DeallocatingVectorIteratorState(const std::size_t idx, std::vector<ElementT *> & input_list) : mData(DEALLOCATION_VECTOR_NULL_PTR), mIndex(idx), mBucketList(input_list) {
setPointerForIndex(); setPointerForIndex();
} }
ElementT * mData; ElementT * mData;
size_t mIndex; std::size_t mIndex;
std::vector<ElementT *> & mBucketList; std::vector<ElementT *> & mBucketList;
inline void setPointerForIndex() { inline void setPointerForIndex() {
@ -55,8 +54,8 @@ protected:
mData = DEALLOCATION_VECTOR_NULL_PTR; mData = DEALLOCATION_VECTOR_NULL_PTR;
return; return;
} }
size_t _bucket = mIndex/bucketSizeC; std::size_t _bucket = mIndex/bucketSizeC;
size_t _index = mIndex%bucketSizeC; std::size_t _index = mIndex%bucketSizeC;
mData = &(mBucketList[_bucket][_index]); mData = &(mBucketList[_bucket][_index]);
if(DeallocateC) { if(DeallocateC) {
@ -104,8 +103,8 @@ public:
template<typename T2> template<typename T2>
DeallocatingVectorIterator(const DeallocatingVectorIterator<T2> & r) : mState(r.mState) {} DeallocatingVectorIterator(const DeallocatingVectorIterator<T2> & r) : mState(r.mState) {}
DeallocatingVectorIterator(size_t idx, std::vector<ElementT *> & input_list) : mState(idx, input_list) {} DeallocatingVectorIterator(std::size_t idx, std::vector<ElementT *> & input_list) : mState(idx, input_list) {}
//DeallocatingVectorIterator(size_t idx, const std::vector<ElementT *> & input_list) : mState(idx, input_list) {} //DeallocatingVectorIterator(std::size_t idx, const std::vector<ElementT *> & input_list) : mState(idx, input_list) {}
DeallocatingVectorIterator(const DeallocatingVectorIteratorState & r) : mState(r) {} DeallocatingVectorIterator(const DeallocatingVectorIteratorState & r) : mState(r) {}
template<typename T2> template<typename T2>
@ -185,10 +184,10 @@ public:
} }
}; };
template<typename ElementT, size_t bucketSizeC = 8388608/sizeof(ElementT) > template<typename ElementT, std::size_t bucketSizeC = 8388608/sizeof(ElementT) >
class DeallocatingVector { class DeallocatingVector {
private: private:
size_t mCurrentSize; std::size_t mCurrentSize;
std::vector<ElementT *> mBucketList; std::vector<ElementT *> mBucketList;
public: public:
@ -227,21 +226,21 @@ public:
} }
inline void push_back(const ElementT & element) { inline void push_back(const ElementT & element) {
size_t _capacity = capacity(); std::size_t _capacity = capacity();
if(mCurrentSize == _capacity) { if(mCurrentSize == _capacity) {
mBucketList.push_back(new ElementT[bucketSizeC]); mBucketList.push_back(new ElementT[bucketSizeC]);
} }
size_t _index = size()%bucketSizeC; std::size_t _index = size()%bucketSizeC;
mBucketList.back()[_index] = element; mBucketList.back()[_index] = element;
++mCurrentSize; ++mCurrentSize;
} }
inline void reserve(const size_t) const { inline void reserve(const std::size_t) const {
//don't do anything //don't do anything
} }
inline void resize(const size_t new_size) { inline void resize(const std::size_t new_size) {
if(new_size > mCurrentSize) { if(new_size > mCurrentSize) {
while(capacity() < new_size) { while(capacity() < new_size) {
mBucketList.push_back(new ElementT[bucketSizeC]); mBucketList.push_back(new ElementT[bucketSizeC]);
@ -249,7 +248,7 @@ public:
mCurrentSize = new_size; mCurrentSize = new_size;
} }
if(new_size < mCurrentSize) { if(new_size < mCurrentSize) {
size_t number_of_necessary_buckets = 1+(new_size / bucketSizeC); std::size_t number_of_necessary_buckets = 1+(new_size / bucketSizeC);
for(unsigned i = number_of_necessary_buckets; i < mBucketList.size(); ++i) { for(unsigned i = number_of_necessary_buckets; i < mBucketList.size(); ++i) {
delete[] mBucketList[i]; delete[] mBucketList[i];
@ -259,16 +258,16 @@ public:
} }
} }
inline size_t size() const { inline std::size_t size() const {
return mCurrentSize; return mCurrentSize;
} }
inline size_t capacity() const { inline std::size_t capacity() const {
return mBucketList.size() * bucketSizeC; return mBucketList.size() * bucketSizeC;
} }
inline iterator begin() { inline iterator begin() {
return iterator(static_cast<size_t>(0), mBucketList); return iterator(static_cast<std::size_t>(0), mBucketList);
} }
inline iterator end() { inline iterator end() {
@ -276,7 +275,7 @@ public:
} }
inline deallocation_iterator dbegin() { inline deallocation_iterator dbegin() {
return deallocation_iterator(static_cast<size_t>(0), mBucketList); return deallocation_iterator(static_cast<std::size_t>(0), mBucketList);
} }
inline deallocation_iterator dend() { inline deallocation_iterator dend() {
@ -284,34 +283,34 @@ public:
} }
inline const_iterator begin() const { inline const_iterator begin() const {
return const_iterator(static_cast<size_t>(0), mBucketList); return const_iterator(static_cast<std::size_t>(0), mBucketList);
} }
inline const_iterator end() const { inline const_iterator end() const {
return const_iterator(size(), mBucketList); return const_iterator(size(), mBucketList);
} }
inline ElementT & operator[](const size_t index) { inline ElementT & operator[](const std::size_t index) {
size_t _bucket = index / bucketSizeC; std::size_t _bucket = index / bucketSizeC;
size_t _index = index % bucketSizeC; std::size_t _index = index % bucketSizeC;
return (mBucketList[_bucket][_index]); return (mBucketList[_bucket][_index]);
} }
const inline ElementT & operator[](const size_t index) const { const inline ElementT & operator[](const std::size_t index) const {
size_t _bucket = index / bucketSizeC; std::size_t _bucket = index / bucketSizeC;
size_t _index = index % bucketSizeC; std::size_t _index = index % bucketSizeC;
return (mBucketList[_bucket][_index]); return (mBucketList[_bucket][_index]);
} }
inline ElementT & back() { inline ElementT & back() {
size_t _bucket = mCurrentSize / bucketSizeC; std::size_t _bucket = mCurrentSize / bucketSizeC;
size_t _index = mCurrentSize % bucketSizeC; std::size_t _index = mCurrentSize % bucketSizeC;
return (mBucketList[_bucket][_index]); return (mBucketList[_bucket][_index]);
} }
const inline ElementT & back() const { const inline ElementT & back() const {
size_t _bucket = mCurrentSize / bucketSizeC; std::size_t _bucket = mCurrentSize / bucketSizeC;
size_t _index = mCurrentSize % bucketSizeC; std::size_t _index = mCurrentSize % bucketSizeC;
return (mBucketList[_bucket][_index]); return (mBucketList[_bucket][_index]);
} }
}; };