King_DuckZ/clooneljump
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Refactoring in ObserversManager.

Browse source 
Pull out the storage part so the class is more tidy.
This commit is contained in:
King_DuckZ 2014-07-06 20:50:00 +02:00
parent 173d5d2f99
commit 103689a29a
2 changed files with 204 additions and 101 deletions
Download patch file Download diff file Expand all files Collapse all files

110
src/observersmanager.hpp
View file

@ -20,6 +20,7 @@
#ifndef idF5E41734950640CDA3C949E0D3A9A30D
#define idF5E41734950640CDA3C949E0D3A9A30D
#include "linearmap.hpp"
#include <cassert>
#include <vector>
#include <algorithm>
@ -27,101 +28,31 @@
#include <ciso646>
namespace cloonel {
namespace implem {
template <typename T>
class Iterator {
public:
Iterator ( const std::vector<bool>& parOccupied, std::vector<T>& parItems, bool parEnd ) :
m_occupied(parOccupied),
m_items(parItems),
m_pos(parEnd ? m_occupied.size() : 0)
{
assert(m_occupied.size() == m_items.size());
}
Iterator ( const Iterator& parOther ) :
m_occupied(parOther.m_occupied),
m_items(parOther.m_items),
m_pos(parOther.m_pos)
{
}
~Iterator ( void ) noexcept = default;
T operator-> ( void ) {
assert(m_pos < m_occupied.size());
assert(m_occupied[m_pos]);
return m_items[m_pos];
}
T operator* ( void ) {
assert(m_pos < m_occupied.size());
assert(m_occupied[m_pos]);
return m_items[m_pos];
}
Iterator& operator++ ( void ) {
if (m_occupied.size() == m_pos)
return *this;
auto itNext = std::find(m_occupied.begin() + static_cast<std::vector<bool>::difference_type>(m_pos + 1), m_occupied.end(), true);
if (m_occupied.end() != itNext)
m_pos = static_cast<std::size_t>(itNext - m_occupied.begin());
else
m_pos = m_occupied.size();
return *this;
}
Iterator operator++ ( int ) {
Iterator prevState(*this);
++(*this);
return prevState;
}
bool operator== ( const Iterator& parOther ) const {
return m_pos == parOther.m_pos and &m_items == &parOther.m_items;
}
bool operator!= ( const Iterator& parOther ) const { return not this->operator==(parOther); }
private:
const std::vector<bool>& m_occupied;
std::vector<T>& m_items;
std::size_t m_pos;
};
} //namespace implem
template <typename T>
class ObserversManager {
public:
typedef size_t TicketType;
typedef implem::Iterator<T> iterator;
typedef typename LinearMap<T>::iterator iterator;
ObserversManager ( void );
ObserversManager ( void ) = default;
~ObserversManager ( void ) noexcept = default;
TicketType Add ( T parObserver );
void Remove ( TicketType parTicket ) noexcept;
void Update ( TicketType parTicket, T parObserver );
std::size_t size ( void ) const { return m_usedCount; }
iterator begin ( void ) { return iterator(m_occupied, m_list, false); }
iterator end ( void ) { return iterator(m_occupied, m_list, true); }
std::size_t size ( void ) const { return m_list.size(); }
iterator begin ( void ) { return m_list.begin(); }
iterator end ( void ) { return m_list.end(); }
private:
std::vector<T> m_list;
std::vector<bool> m_occupied;
std::size_t m_usedCount;
LinearMap<T> m_list;
};
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
template <typename T>
ObserversManager<T>::ObserversManager() :
m_usedCount(0)
{
}
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
template <typename T>
typename ObserversManager<T>::TicketType ObserversManager<T>::Add (T parObserver) {
m_list.push_back(parObserver);
m_occupied.push_back(true);
++m_usedCount;
return static_cast<TicketType>(m_list.size());
}
@ -129,37 +60,14 @@ namespace cloonel {
///--------------------------------------------------------------------------
template <typename T>
void ObserversManager<T>::Remove (TicketType parTicket) noexcept {
assert(static_cast<std::size_t>(parTicket) <= m_list.size());
assert(m_occupied[parTicket - 1]);
assert(m_usedCount > 0);
assert(m_list.size() == m_occupied.size());
m_occupied[parTicket - 1] = false;
--m_usedCount;
std::size_t deleCount = 0;
for (auto itOcc = m_occupied.rbegin(), itOccEND = m_occupied.rend(); itOcc != itOccEND and not *itOcc; ++itOcc) {
++deleCount;
}
if (deleCount) {
assert(deleCount <= m_occupied.size());
const std::size_t newSize = m_occupied.size() - deleCount;
m_occupied.resize(newSize);
m_list.resize(newSize);
}
m_list.erase_absolute(parTicket - 1);
}
///--------------------------------------------------------------------------
///--------------------------------------------------------------------------
template <typename T>
void ObserversManager<T>::Update (TicketType parTicket, T parObserver) {
assert(static_cast<std::size_t>(parTicket) <= m_list.size());
assert(m_occupied[parTicket - 1]);
assert(m_usedCount > 0);
assert(m_list.size() == m_occupied.size());
std::swap(m_list[parTicket - 1], parObserver);
std::swap(*m_list.at_absolute(parTicket - 1), parObserver);
}
} //namespace cloonel