flightsimulatorplatfrom/pilotclient
1
0
Fork 0
mirror of https://github.com/swift-project/pilotclient.git synced 2026-03-31 12:55:33 +08:00
Code Issues Packages Projects Releases Wiki Activity

refs #124 using override keyword in containers' pimpls

Browse Source
This commit is contained in:
Mathew Sutcliffe
2014-02-08 14:20:04 +00:00
parent 06a7b0b32f
commit e52a4da826
3 changed files with 74 additions and 74 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
src/blackmisc/collection.h
View File

@@ -234,24 +234,24 @@ namespace BlackMisc
public:
static_assert(std::is_same<T, typename C::value_type>::value, "CCollection must be initialized from a container with the same value_type.");
Pimpl(C &&c) : m_impl(std::move(c)) {}
PimplBase *clone() const { return new Pimpl(*this); }
PimplBase *cloneEmpty() const { return new Pimpl(C()); }
iterator begin() { return iterator::fromImpl(m_impl.begin()); }
const_iterator begin() const { return const_iterator::fromImpl(m_impl.cbegin()); }
const_iterator cbegin() const { return const_iterator::fromImpl(m_impl.cbegin()); }
iterator end() { return iterator::fromImpl(m_impl.end()); }
const_iterator end() const { return const_iterator::fromImpl(m_impl.cend()); }
const_iterator cend() const { return const_iterator::fromImpl(m_impl.cend()); }
size_type size() const { return m_impl.size(); }
bool empty() const { return m_impl.empty(); }
void clear() { m_impl.clear(); }
iterator insert(const T &value) { return iterator::fromImpl(insertHelper(m_impl.insert(value))); }
iterator erase(iterator pos) { return iterator::fromImpl(m_impl.erase(*static_cast<const typename C::iterator *>(pos.getImpl()))); }
//iterator erase(iterator it1, iterator it2) { return iterator::fromImpl(m_impl.erase(*static_cast<const typename C::iterator *>(it1.getImpl()), *static_cast<const typename C::iterator*>(it2.getImpl()))); }
iterator erase(iterator it1, iterator it2) { while (it1 != it2) { it1 = iterator::fromImpl(m_impl.erase(*static_cast<const typename C::iterator *>(it1.getImpl()))); } return it1; }
iterator find(const T &value) { return iterator::fromImpl(m_impl.find(value)); }
const_iterator find(const T &value) const { return const_iterator::fromImpl(m_impl.find(value)); }
bool operator ==(const PimplBase &other) const { Pimpl copy = C(); for (auto i = other.cbegin(); i != other.cend(); ++i) copy.insert(*i); return m_impl == copy.m_impl; }
PimplBase *clone() const override { return new Pimpl(*this); }
PimplBase *cloneEmpty() const override { return new Pimpl(C()); }
iterator begin() override { return iterator::fromImpl(m_impl.begin()); }
const_iterator begin() const override { return const_iterator::fromImpl(m_impl.cbegin()); }
const_iterator cbegin() const override { return const_iterator::fromImpl(m_impl.cbegin()); }
iterator end() override { return iterator::fromImpl(m_impl.end()); }
const_iterator end() const override { return const_iterator::fromImpl(m_impl.cend()); }
const_iterator cend() const override { return const_iterator::fromImpl(m_impl.cend()); }
size_type size() const override { return m_impl.size(); }
bool empty() const override { return m_impl.empty(); }
void clear() override { m_impl.clear(); }
iterator insert(const T &value) override { return iterator::fromImpl(insertHelper(m_impl.insert(value))); }
iterator erase(iterator pos) override { return iterator::fromImpl(m_impl.erase(*static_cast<const typename C::iterator *>(pos.getImpl()))); }
//iterator erase(iterator it1, iterator it2) override { return iterator::fromImpl(m_impl.erase(*static_cast<const typename C::iterator *>(it1.getImpl()), *static_cast<const typename C::iterator*>(it2.getImpl()))); }
iterator erase(iterator it1, iterator it2) override { while (it1 != it2) { it1 = iterator::fromImpl(m_impl.erase(*static_cast<const typename C::iterator *>(it1.getImpl()))); } return it1; }
iterator find(const T &value) override { return iterator::fromImpl(m_impl.find(value)); }
const_iterator find(const T &value) const override { return const_iterator::fromImpl(m_impl.find(value)); }
bool operator ==(const PimplBase &other) const override { Pimpl copy = C(); for (auto i = other.cbegin(); i != other.cend(); ++i) copy.insert(*i); return m_impl == copy.m_impl; }
private:
C m_impl;
// insertHelper: QSet::insert returns an iterator, but std::set::insert returns a std::pair<interator, bool>

66
src/blackmisc/iterator.h
View File

@@ -149,12 +149,12 @@ namespace BlackMisc
static_assert(std::is_same<T, typename std::iterator_traits<I>::value_type>::value,
"ConstForwardIterator must be initialized from an iterator with the same value_type.");
Pimpl(I &&i) : m_impl(std::move(i)) {}
virtual PimplBase *clone() const { return new Pimpl(*this); }
virtual const_reference operator *() const { return *m_impl; }
virtual void operator ++() { ++m_impl; }
virtual void operator +=(difference_type n) { std::advance(m_impl, n); }
virtual bool operator ==(const PimplBase &other) const { return m_impl == static_cast<const Pimpl&>(other).m_impl; }
virtual void *impl() { return &m_impl; }
virtual PimplBase *clone() const override { return new Pimpl(*this); }
virtual const_reference operator *() const override { return *m_impl; }
virtual void operator ++() override { ++m_impl; }
virtual void operator +=(difference_type n) override { std::advance(m_impl, n); }
virtual bool operator ==(const PimplBase &other) const override { return m_impl == static_cast<const Pimpl&>(other).m_impl; }
virtual void *impl() override { return &m_impl; }
private:
I m_impl;
};
@@ -349,19 +349,19 @@ namespace BlackMisc
static_assert(std::is_same<T, typename std::iterator_traits<I>::value_type>::value,
"ConstBidirectionalIterator must be initialized from an iterator with the same value_type.");
Pimpl(I &&i) : m_impl(std::move(i)) {}
virtual PimplBase *clone() const { return new Pimpl(*this); }
virtual const_reference operator *() const { return *m_impl; }
virtual void operator ++() { ++m_impl; }
virtual void operator --() { --m_impl; }
virtual void operator +=(difference_type n) { m_impl += n; }
virtual void operator -=(difference_type n) { m_impl -= n; }
virtual difference_type operator -(const PimplBase &other) const { return m_impl - static_cast<const Pimpl&>(other).m_impl; }
virtual bool operator ==(const PimplBase &other) const { return m_impl == static_cast<const Pimpl&>(other).m_impl; }
virtual bool operator <(const PimplBase &other) const { return m_impl < static_cast<const Pimpl&>(other).m_impl; }
virtual bool operator >(const PimplBase &other) const { return m_impl > static_cast<const Pimpl&>(other).m_impl; }
virtual bool operator <=(const PimplBase &other) const { return m_impl <= static_cast<const Pimpl&>(other).m_impl; }
virtual bool operator >=(const PimplBase &other) const { return m_impl >= static_cast<const Pimpl&>(other).m_impl; }
virtual void *impl() { return &m_impl; }
virtual PimplBase *clone() const override { return new Pimpl(*this); }
virtual const_reference operator *() const override { return *m_impl; }
virtual void operator ++() override { ++m_impl; }
virtual void operator --() override { --m_impl; }
virtual void operator +=(difference_type n) override { m_impl += n; }
virtual void operator -=(difference_type n) override { m_impl -= n; }
virtual difference_type operator -(const PimplBase &other) const override { return m_impl - static_cast<const Pimpl&>(other).m_impl; }
virtual bool operator ==(const PimplBase &other) const override { return m_impl == static_cast<const Pimpl&>(other).m_impl; }
virtual bool operator <(const PimplBase &other) const override { return m_impl < static_cast<const Pimpl&>(other).m_impl; }
virtual bool operator >(const PimplBase &other) const override { return m_impl > static_cast<const Pimpl&>(other).m_impl; }
virtual bool operator <=(const PimplBase &other) const override { return m_impl <= static_cast<const Pimpl&>(other).m_impl; }
virtual bool operator >=(const PimplBase &other) const override { return m_impl >= static_cast<const Pimpl&>(other).m_impl; }
virtual void *impl() override { return &m_impl; }
private:
I m_impl;
};
@@ -569,20 +569,20 @@ namespace BlackMisc
static_assert(std::is_same<T, typename std::iterator_traits<I>::value_type>::value,
"BidirectionalIterator must be initialized from an iterator with the same value_type.");
Pimpl(I &&i) : m_impl(std::move(i)) {}
virtual PimplBase *clone() const { return new Pimpl(*this); }
virtual const_reference operator *() const { return *m_impl; }
virtual reference operator *() { return *m_impl; }
virtual void operator ++() { ++m_impl; }
virtual void operator --() { --m_impl; }
virtual void operator +=(difference_type n) { m_impl += n; }
virtual void operator -=(difference_type n) { m_impl -= n; }
virtual difference_type operator -(const PimplBase &other) const { return m_impl - static_cast<const Pimpl&>(other).m_impl; }
virtual bool operator ==(const PimplBase &other) const { return m_impl == static_cast<const Pimpl&>(other).m_impl; }
virtual bool operator <(const PimplBase &other) const { return m_impl < static_cast<const Pimpl&>(other).m_impl; }
virtual bool operator >(const PimplBase &other) const { return m_impl > static_cast<const Pimpl&>(other).m_impl; }
virtual bool operator <=(const PimplBase &other) const { return m_impl <= static_cast<const Pimpl&>(other).m_impl; }
virtual bool operator >=(const PimplBase &other) const { return m_impl >= static_cast<const Pimpl&>(other).m_impl; }
virtual void *impl() { return &m_impl; }
virtual PimplBase *clone() const override { return new Pimpl(*this); }
virtual const_reference operator *() const override { return *m_impl; }
virtual reference operator *() override { return *m_impl; }
virtual void operator ++() override { ++m_impl; }
virtual void operator --() override { --m_impl; }
virtual void operator +=(difference_type n) override { m_impl += n; }
virtual void operator -=(difference_type n) override { m_impl -= n; }
virtual difference_type operator -(const PimplBase &other) const override { return m_impl - static_cast<const Pimpl&>(other).m_impl; }
virtual bool operator ==(const PimplBase &other) const override { return m_impl == static_cast<const Pimpl&>(other).m_impl; }
virtual bool operator <(const PimplBase &other) const override { return m_impl < static_cast<const Pimpl&>(other).m_impl; }
virtual bool operator >(const PimplBase &other) const override { return m_impl > static_cast<const Pimpl&>(other).m_impl; }
virtual bool operator <=(const PimplBase &other) const override { return m_impl <= static_cast<const Pimpl&>(other).m_impl; }
virtual bool operator >=(const PimplBase &other) const override { return m_impl >= static_cast<const Pimpl&>(other).m_impl; }
virtual void *impl() override { return &m_impl; }
private:
I m_impl;
};

46
src/blackmisc/sequence.h
View File

@@ -461,29 +461,29 @@ namespace BlackMisc
public:
static_assert(std::is_same<T, typename C::value_type>::value, "CSequence must be initialized from a container with the same value_type.");
Pimpl(C &&c) : m_impl(std::move(c)) {}
PimplBase *clone() const { return new Pimpl(*this); }
PimplBase *cloneEmpty() const { return new Pimpl(C()); }
iterator begin() { return iterator::fromImpl(m_impl.begin()); }
const_iterator begin() const { return const_iterator::fromImpl(m_impl.cbegin()); }
const_iterator cbegin() const { return const_iterator::fromImpl(m_impl.cbegin()); }
iterator end() { return iterator::fromImpl(m_impl.end()); }
const_iterator end() const { return const_iterator::fromImpl(m_impl.cend()); }
const_iterator cend() const { return const_iterator::fromImpl(m_impl.cend()); }
reference operator [](size_type index) { return m_impl[index]; }
const_reference operator [](size_type index) const { return m_impl[index]; }
reference front() { return m_impl.front(); }
const_reference front() const { return m_impl.front(); }
reference back() { return m_impl.back(); }
const_reference back() const { return m_impl.back(); }
size_type size() const { return m_impl.size(); }
bool empty() const { return m_impl.empty(); }
void clear() { m_impl.clear(); }
iterator insert(iterator pos, const T &value) { return iterator::fromImpl(m_impl.insert(*static_cast<const typename C::iterator*>(pos.getImpl()), value)); }
void push_back(const T &value) { m_impl.push_back(value); }
void pop_back() { m_impl.pop_back(); }
iterator erase(iterator pos) { return iterator::fromImpl(m_impl.erase(*static_cast<const typename C::iterator*>(pos.getImpl()))); }
iterator erase(iterator it1, iterator it2) { return iterator::fromImpl(m_impl.erase(*static_cast<const typename C::iterator*>(it1.getImpl()), *static_cast<const typename C::iterator*>(it2.getImpl()))); }
bool operator ==(const PimplBase &other) const { Pimpl copy = C(); for (auto i = other.cbegin(); i != other.cend(); ++i) copy.push_back(*i); return m_impl == copy.m_impl; }
PimplBase *clone() const override { return new Pimpl(*this); }
PimplBase *cloneEmpty() const override { return new Pimpl(C()); }
iterator begin() override { return iterator::fromImpl(m_impl.begin()); }
const_iterator begin() const override { return const_iterator::fromImpl(m_impl.cbegin()); }
const_iterator cbegin() const override { return const_iterator::fromImpl(m_impl.cbegin()); }
iterator end() override { return iterator::fromImpl(m_impl.end()); }
const_iterator end() const override { return const_iterator::fromImpl(m_impl.cend()); }
const_iterator cend() const override { return const_iterator::fromImpl(m_impl.cend()); }
reference operator [](size_type index) override { return m_impl[index]; }
const_reference operator [](size_type index) const override { return m_impl[index]; }
reference front() override { return m_impl.front(); }
const_reference front() const override { return m_impl.front(); }
reference back() override { return m_impl.back(); }
const_reference back() const override { return m_impl.back(); }
size_type size() const override { return m_impl.size(); }
bool empty() const override { return m_impl.empty(); }
void clear() override { m_impl.clear(); }
iterator insert(iterator pos, const T &value) override { return iterator::fromImpl(m_impl.insert(*static_cast<const typename C::iterator*>(pos.getImpl()), value)); }
void push_back(const T &value) override { m_impl.push_back(value); }
void pop_back() override { m_impl.pop_back(); }
iterator erase(iterator pos) override { return iterator::fromImpl(m_impl.erase(*static_cast<const typename C::iterator*>(pos.getImpl()))); }
iterator erase(iterator it1, iterator it2) override { return iterator::fromImpl(m_impl.erase(*static_cast<const typename C::iterator*>(it1.getImpl()), *static_cast<const typename C::iterator*>(it2.getImpl()))); }
bool operator ==(const PimplBase &other) const override { Pimpl copy = C(); for (auto i = other.cbegin(); i != other.cend(); ++i) copy.push_back(*i); return m_impl == copy.m_impl; }
private:
C m_impl;
};