LadybirdBrowser/ladybird
1
1
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-10-26 14:57:54 +03:00
Code Issues Packages Projects Releases Wiki Activity

AK: Share code between NonnullOwnPtrVector and NonnullRefPtrVector.

Browse Source 
These can just inherit from a shared base template. Thanks to Robin for the
sweet idea :^)
This commit is contained in:
Andreas Kling 2019-07-25 11:00:26 +02:00
parent 7c3b2e0728
commit 10d120dc85
Notes: sideshowbarker 2024-07-19 13:04:08 +09:00 
Author: https://github.com/awesomekling
Commit: https://github.com/SerenityOS/serenity/commit/10d120dc852
3 changed files with 57 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
AK/NonnullOwnPtrVector.h
View File

@ -1,52 +1,13 @@
#pragma once
#include <AK/NonnullPtrVector.h>
#include <AK/NonnullOwnPtr.h>
#include <AK/Vector.h>
namespace AK {
template<typename T, int inline_capacity = 0>
class NonnullOwnPtrVector : public Vector<NonnullOwnPtr<T>, inline_capacity> {
typedef Vector<NonnullOwnPtr<T>, inline_capacity> Base;
public:
NonnullOwnPtrVector()
{
}
NonnullOwnPtrVector(Vector<NonnullOwnPtr<T>>&& other)
: Base(static_cast<Base&&>(other))
{
}
NonnullOwnPtrVector(const Vector<NonnullOwnPtr<T>>& other)
: Base(static_cast<const Base&>(other))
{
}
using Base::size;
using Iterator = VectorIterator<NonnullOwnPtrVector, T>;
Iterator begin() { return Iterator(*this, 0); }
Iterator end() { return Iterator(*this, size()); }
using ConstIterator = VectorIterator<const NonnullOwnPtrVector, const T>;
ConstIterator begin() const { return ConstIterator(*this, 0); }
ConstIterator end() const { return ConstIterator(*this, size()); }
T& at(int index) { return *Base::at(index); }
const T& at(int index) const { return *Base::at(index); }
T& operator[](int index) { return at(index); }
const T& operator[](int index) const { return at(index); }
T& first() { return at(0); }
const T& first() const { return at(0); }
T& last() { return at(size() - 1); }
const T& last() const { return at(size() - 1); }
private:
// NOTE: You can't use resize() on a NonnullOwnPtrVector since making the vector
// bigger would require being able to default-construct NonnullOwnPtrs.
// Instead, use shrink(new_size).
void resize(int) = delete;
class NonnullOwnPtrVector : public NonnullPtrVector<NonnullOwnPtr<T>, T, inline_capacity>
{
};
}

51
AK/NonnullPtrVector.h Normal file
View File

@ -0,0 +1,51 @@
#pragma once
#include <AK/Vector.h>
namespace AK {
template<typename PtrType, typename T, int inline_capacity = 0>
class NonnullPtrVector : public Vector<PtrType, inline_capacity> {
typedef Vector<PtrType, inline_capacity> Base;
public:
NonnullPtrVector()
{
}
NonnullPtrVector(Vector<PtrType>&& other)
: Base(static_cast<Base&&>(other))
{
}
NonnullPtrVector(const Vector<PtrType>& other)
: Base(static_cast<const Base&>(other))
{
}
using Base::size;
using Iterator = VectorIterator<NonnullPtrVector, T>;
Iterator begin() { return Iterator(*this, 0); }
Iterator end() { return Iterator(*this, size()); }
using ConstIterator = VectorIterator<const NonnullPtrVector, const T>;
ConstIterator begin() const { return ConstIterator(*this, 0); }
ConstIterator end() const { return ConstIterator(*this, size()); }
T& at(int index) { return *Base::at(index); }
const T& at(int index) const { return *Base::at(index); }
T& operator[](int index) { return at(index); }
const T& operator[](int index) const { return at(index); }
T& first() { return at(0); }
const T& first() const { return at(0); }
T& last() { return at(size() - 1); }
const T& last() const { return at(size() - 1); }
private:
// NOTE: You can't use resize() on a NonnullFooPtrVector since making the vector
// bigger would require being able to default-construct NonnullFooPtrs.
// Instead, use shrink(new_size).
void resize(int) = delete;
};
}

45
AK/NonnullRefPtrVector.h
View File

@ -1,52 +1,13 @@
#pragma once
#include <AK/NonnullPtrVector.h>
#include <AK/NonnullRefPtr.h>
#include <AK/Vector.h>
namespace AK {
template<typename T, int inline_capacity = 0>
class NonnullRefPtrVector : public Vector<NonnullRefPtr<T>, inline_capacity> {
typedef Vector<NonnullRefPtr<T>, inline_capacity> Base;
public:
NonnullRefPtrVector()
{
}
NonnullRefPtrVector(Vector<NonnullRefPtr<T>>&& other)
: Base(static_cast<Base&&>(other))
{
}
NonnullRefPtrVector(const Vector<NonnullRefPtr<T>>& other)
: Base(static_cast<const Base&>(other))
{
}
using Base::size;
using Iterator = VectorIterator<NonnullRefPtrVector, T>;
Iterator begin() { return Iterator(*this, 0); }
Iterator end() { return Iterator(*this, size()); }
using ConstIterator = VectorIterator<const NonnullRefPtrVector, const T>;
ConstIterator begin() const { return ConstIterator(*this, 0); }
ConstIterator end() const { return ConstIterator(*this, size()); }
T& at(int index) { return *Base::at(index); }
const T& at(int index) const { return *Base::at(index); }
T& operator[](int index) { return at(index); }
const T& operator[](int index) const { return at(index); }
T& first() { return at(0); }
const T& first() const { return at(0); }
T& last() { return at(size() - 1); }
const T& last() const { return at(size() - 1); }
private:
// NOTE: You can't use resize() on a NonnullRefPtrVector since making the vector
// bigger would require being able to default-construct NonnullRefPtrs.
// Instead, use shrink(new_size).
void resize(int) = delete;
class NonnullRefPtrVector : public NonnullPtrVector<NonnullRefPtr<T>, T, inline_capacity>
{
};
}