mirror of
https://github.com/flutter/flutter.git
synced 2026-02-20 02:29:02 +08:00
e0fd75b5ab
This caused us to lose our gn check certification. :( Turns out gn check was just ignoring all the header paths it didn't understand and so gn check passing for sky wasn't meaning much. I tried to straighten out some of the mess in this CL, but its going to take several more rounds of massaging before gn check passes again. On the bright side (almost) all of our headers are absolute now. Turns out my script (attached to the bug) didn't notice ../ includes but I'll fix that in the next patch. R=abarth@chromium.org BUG=435361 Review URL: https://codereview.chromium.org/746023002
99 lines
3.0 KiB
C++
99 lines
3.0 KiB
C++
// Copyright 2014 The Chromium Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
#ifndef TerminatedArray_h
|
|
#define TerminatedArray_h
|
|
|
|
#include "sky/engine/wtf/FastAllocBase.h"
|
|
#include "sky/engine/wtf/OwnPtr.h"
|
|
|
|
namespace WTF {
|
|
|
|
// TerminatedArray<T> represents a sequence of elements of type T in which each
|
|
// element knows whether it is the last element in the sequence or not. For this
|
|
// check type T must provide isLastInArray method.
|
|
// TerminatedArray<T> can only be constructed by TerminatedArrayBuilder<T>.
|
|
template<typename T>
|
|
class TerminatedArray {
|
|
WTF_MAKE_NONCOPYABLE(TerminatedArray);
|
|
public:
|
|
T& at(size_t index) { return reinterpret_cast<T*>(this)[index]; }
|
|
const T& at(size_t index) const { return reinterpret_cast<const T*>(this)[index]; }
|
|
|
|
template<typename U>
|
|
class iterator_base {
|
|
public:
|
|
iterator_base& operator++()
|
|
{
|
|
if (m_val->isLastInArray()) {
|
|
m_val = 0;
|
|
} else {
|
|
++m_val;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
U& operator*() const { return *m_val; }
|
|
|
|
bool operator==(const iterator_base& other) const { return m_val == other.m_val; }
|
|
bool operator!=(const iterator_base& other) const { return !(*this == other); }
|
|
|
|
private:
|
|
iterator_base(U* val) : m_val(val) { }
|
|
|
|
U* m_val;
|
|
|
|
friend class TerminatedArray;
|
|
};
|
|
|
|
typedef iterator_base<T> iterator;
|
|
typedef iterator_base<const T> const_iterator;
|
|
|
|
iterator begin() { return iterator(reinterpret_cast<T*>(this)); }
|
|
const_iterator begin() const { return const_iterator(reinterpret_cast<const T*>(this)); }
|
|
|
|
iterator end() { return iterator(0); }
|
|
const_iterator end() const { return const_iterator(0); }
|
|
|
|
size_t size() const
|
|
{
|
|
size_t count = 0;
|
|
for (const_iterator it = begin(); it != end(); ++it)
|
|
count++;
|
|
return count;
|
|
}
|
|
|
|
// Match Allocator semantics to be able to use OwnPtr<TerminatedArray>.
|
|
void operator delete(void* p) { ::WTF::fastFree(p); }
|
|
|
|
private:
|
|
// Allocator describes how TerminatedArrayBuilder should create new instances
|
|
// of TerminateArray and manage their lifetimes.
|
|
struct Allocator {
|
|
typedef PassOwnPtr<TerminatedArray> PassPtr;
|
|
typedef OwnPtr<TerminatedArray> Ptr;
|
|
|
|
static PassPtr create(size_t capacity)
|
|
{
|
|
return adoptPtr(static_cast<TerminatedArray*>(fastMalloc(capacity * sizeof(T))));
|
|
}
|
|
|
|
static PassPtr resize(PassPtr ptr, size_t capacity)
|
|
{
|
|
return adoptPtr(static_cast<TerminatedArray*>(fastRealloc(ptr.leakPtr(), capacity * sizeof(T))));
|
|
}
|
|
};
|
|
|
|
// Prohibit construction. Allocator makes TerminatedArray instances for
|
|
// TerminatedArrayBuilder by pointer casting.
|
|
TerminatedArray();
|
|
|
|
template<typename, template <typename> class> friend class TerminatedArrayBuilder;
|
|
};
|
|
|
|
} // namespace WTF
|
|
|
|
using WTF::TerminatedArray;
|
|
|
|
#endif // TerminatedArray_h
|