1 // Copyright 2014 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 #ifndef TerminatedArray_h 5 #define TerminatedArray_h 6 7 #include "wtf/FastAllocBase.h" 8 #include "wtf/OwnPtr.h" 9 10 namespace WTF { 11 12 // TerminatedArray<T> represents a sequence of elements of type T in which each 13 // element knows whether it is the last element in the sequence or not. For this 14 // check type T must provide isLastInArray method. 15 // TerminatedArray<T> can only be constructed by TerminatedArrayBuilder<T>. 16 template<typename T> 17 class TerminatedArray { 18 WTF_MAKE_NONCOPYABLE(TerminatedArray); 19 public: at(size_t index)20 T& at(size_t index) { return reinterpret_cast<T*>(this)[index]; } at(size_t index)21 const T& at(size_t index) const { return reinterpret_cast<const T*>(this)[index]; } 22 23 template<typename U> 24 class iterator_base { 25 public: 26 iterator_base& operator++() 27 { 28 if (m_val->isLastInArray()) { 29 m_val = 0; 30 } else { 31 ++m_val; 32 } 33 return *this; 34 } 35 36 U& operator*() const { return *m_val; } 37 38 bool operator==(const iterator_base& other) const { return m_val == other.m_val; } 39 bool operator!=(const iterator_base& other) const { return !(*this == other); } 40 41 private: iterator_base(U * val)42 iterator_base(U* val) : m_val(val) { } 43 44 U* m_val; 45 46 friend class TerminatedArray; 47 }; 48 49 typedef iterator_base<T> iterator; 50 typedef iterator_base<const T> const_iterator; 51 begin()52 iterator begin() { return iterator(reinterpret_cast<T*>(this)); } begin()53 const_iterator begin() const { return const_iterator(reinterpret_cast<const T*>(this)); } 54 end()55 iterator end() { return iterator(0); } end()56 const_iterator end() const { return const_iterator(0); } 57 size()58 size_t size() const 59 { 60 size_t count = 0; 61 for (const_iterator it = begin(); it != end(); ++it) 62 count++; 63 return count; 64 } 65 66 // Match Allocator semantics to be able to use OwnPtr<TerminatedArray>. delete(void * p)67 void operator delete(void* p) { ::WTF::fastFree(p); } 68 69 private: 70 // Allocator describes how TerminatedArrayBuilder should create new instances 71 // of TerminateArray and manage their lifetimes. 72 struct Allocator { 73 typedef PassOwnPtr<TerminatedArray> PassPtr; 74 typedef OwnPtr<TerminatedArray> Ptr; 75 createAllocator76 static PassPtr create(size_t capacity) 77 { 78 return adoptPtr(static_cast<TerminatedArray*>(fastMalloc(capacity * sizeof(T)))); 79 } 80 resizeAllocator81 static PassPtr resize(PassPtr ptr, size_t capacity) 82 { 83 return adoptPtr(static_cast<TerminatedArray*>(fastRealloc(ptr.leakPtr(), capacity * sizeof(T)))); 84 } 85 }; 86 87 // Prohibit construction. Allocator makes TerminatedArray instances for 88 // TerminatedArrayBuilder by pointer casting. 89 TerminatedArray(); 90 91 template<typename, template <typename> class> friend class TerminatedArrayBuilder; 92 }; 93 94 } // namespace WTF 95 96 using WTF::TerminatedArray; 97 98 #endif // TerminatedArray_h 99