mrq/reactphysics3d
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Working on Map

Browse Source
This commit is contained in:
Daniel Chappuis 2018-01-19 17:50:30 +01:00
parent b1ecfb0fed
commit 3a0cc1feac
1 changed files with 24 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
src/containers/Map.h
View File

@ -257,17 +257,14 @@ class Map {
private: private:
/// Array of buckets
const int* mBuckets;
/// Array of entries /// Array of entries
const Entry* mEntries; const Entry* mEntries;
/// Capacity of the map /// Capacity of the map
int mCapacity; int mCapacity;
/// Index of the current bucket /// Number of used entries in the map
int mCurrentBucket; int mNbUsedEntries;
/// Index of the current entry /// Index of the current entry
int mCurrentEntry; int mCurrentEntry;
@ -276,32 +273,20 @@ class Map {
void advance() { void advance() {
// If we are trying to move past the end // If we are trying to move past the end
assert(mCurrentBucket < mCapacity); assert(mCurrentEntry < mNbUsedEntries);
// If we are at the last entry for the current bucket for (mCurrentEntry += 1; mCurrentEntry < mNbUsedEntries; mCurrentEntry++) {
if (mEntries[mCurrentEntry].next == -1) {
// Find the next occupied bucket // If the entry is not empty
for (int b = mCurrentBucket + 1; mBuckets[b] > 0 || b == mCapacity; b++) { if (mEntries[mCurrentEntry].keyValue != nullptr) {
mCurrentBucket = b; // We have found the next non empty entry
return;
// If we have reached the end of the map
if (mCurrentBucket == mCapacity) {
mCurrentEntry = mCapacity;
return;
}
mCurrentEntry = mBuckets[mCurrentBucket];
assert(mCurrentEntry != -1);
} }
} }
else {
// Move to the next entry in the current bucket // We have not find a non empty entry, we return an iterator to the end
mCurrentEntry = mEntries[mCurrentEntry].next; mCurrentEntry = mCapacity;
assert(mEntries[mCurrentEntry].keyValue != nullptr);
}
} }
public: public:
@ -317,29 +302,27 @@ class Map {
Iterator() = default; Iterator() = default;
/// Constructor /// Constructor
Iterator(const int* buckets, const Entry* entries, int capacity, int currentBucket, int currentEntry) Iterator(const Entry* entries, int capacity, int nbUsedEntries, int currentEntry)
:mBuckets(buckets), mEntries(entries), mCapacity(capacity), mCurrentBucket(currentBucket), mCurrentEntry(currentEntry) { :mEntries(entries), mCapacity(capacity), mNbUsedEntries(nbUsedEntries), mCurrentEntry(currentEntry) {
} }
/// Copy constructor /// Copy constructor
Iterator(const Iterator& it) Iterator(const Iterator& it)
:mBuckets(it.mBuckets), mEntries(it.mEntries), mCapacity(it.mCapacity), mCurrentBucket(it.mCurrentBucket), mCurrentEntry(it.mCurrentEntry) { :mEntries(it.mEntries), mCapacity(it.mCapacity), mNbUsedEntries(it.mNbUsedEntries), mCurrentEntry(it.mCurrentEntry) {
} }
/// Deferencable /// Deferencable
reference operator*() const { reference operator*() const {
assert(mCurrentBucket >= 0 && mCurrentBucket < mCapacity); assert(mCurrentEntry >= 0 && mCurrentEntry < mNbUsedEntries);
assert (mCurrentEntry != -1);
assert(mEntries[mCurrentEntry].keyValue != nullptr); assert(mEntries[mCurrentEntry].keyValue != nullptr);
return mEntries[mCurrentEntry].keyValue; return mEntries[mCurrentEntry].keyValue;
} }
/// Deferencable /// Deferencable
pointer operator->() const { pointer operator->() const {
assert(mCurrentBucket >= 0 && mCurrentBucket < mCapacity); assert(mCurrentEntry >= 0 && mCurrentEntry < mNbUsedEntries);
assert (mCurrentEntry != -1);
assert(mEntries[mCurrentEntry].keyValue != nullptr); assert(mEntries[mCurrentEntry].keyValue != nullptr);
return mEntries[mCurrentEntry].keyValue; return mEntries[mCurrentEntry].keyValue;
} }
@ -359,10 +342,7 @@ class Map {
/// Equality operator (it == end()) /// Equality operator (it == end())
bool operator==(const Iterator& iterator) const { bool operator==(const Iterator& iterator) const {
return mBuckets == iterator.mBuckets && return mCurrentEntry == iterator.mCurrentEntry && mEntries == iterator.mEntries;
mEntries == iterator.mEntries &&
mCurrentBucket == iterator.mCurrentBucket &&
mCurrentEntry == iterator.mCurrentEntry;
} }
/// Inequality operator (it != end()) /// Inequality operator (it != end())
@ -591,7 +571,7 @@ class Map {
assert(mEntries[entry].keyValue != nullptr); assert(mEntries[entry].keyValue != nullptr);
return Iterator(mBuckets, mEntries, mCapacity, bucket, entry); return Iterator(mEntries, mCapacity, mNbUsedEntries, entry);
} }
/// Overloaded index operator /// Overloaded index operator
@ -709,24 +689,20 @@ class Map {
return end(); return end();
} }
int bucket = -1; // Find the first used entry
int entry;
// Find the first used bucket for (entry=0; entry < mNbUsedEntries; entry++) {
for (int i=0; i<mCapacity; i++) { if (mEntries[entry].keyValue != nullptr) {
if (mBuckets[i] >= 0) { return Iterator(mEntries, mCapacity, mNbUsedEntries, entry);
bucket = i;
break;
} }
} }
assert(bucket >= 0); assert(false);
return Iterator(mBuckets, mEntries, mCapacity, bucket, mBuckets[bucket]);
} }
/// Return a end iterator /// Return a end iterator
Iterator end() const { Iterator end() const {
return Iterator(mBuckets, mEntries, mCapacity, mCapacity, mCapacity); return Iterator(mEntries, mCapacity, mNbUsedEntries, mCapacity);
} }
}; };