dart::BaseGrowableArray< T, B, Allocator > Class Template Reference

#include <growable_array.h>

Inheritance diagram for dart::BaseGrowableArray< T, B, Allocator >:

Public Member Functions
	BaseGrowableArray (Allocator *allocator)
	BaseGrowableArray (intptr_t initial_capacity, Allocator *allocator)
	BaseGrowableArray (BaseGrowableArray &&other)
	~BaseGrowableArray ()
BaseGrowableArray &	operator= (BaseGrowableArray &&other)
intptr_t	length () const
T *	data () const
bool	is_empty () const
void	TruncateTo (intptr_t length)
bool	Contains (const T &other, bool isEqual(const T &, const T &)=nullptr) const
void	Add (const T &value)
T &	RemoveLast ()
T &	operator[] (intptr_t index) const
void	FillWith (const T &value, intptr_t start, intptr_t length)
void	EnsureLength (intptr_t new_length, const T &default_value)
const T &	At (intptr_t index) const
T &	Last () const
void	AddArray (const BaseGrowableArray< T, B, Allocator > &src)
void	Clear ()
void	InsertAt (intptr_t idx, const T &value)
void	Reverse ()
void	Swap (intptr_t i, intptr_t j)
void	RemoveAt (intptr_t i)
void	EraseAt (intptr_t idx)
void	SetLength (intptr_t new_length)
void	Resize (intptr_t new_length)
void	Sort (int compare(const T *, const T *))
void	StealBuffer (T **buffer, intptr_t *length)
T *	begin ()
const T *	begin () const
T *	end ()
const T *	end () const
Public Member Functions inherited from B
	B ()
void	setValues (int v) override
bool	checkValues (int v) override
Public Member Functions inherited from A
	A ()
virtual	~A ()
void *	operator new (size_t size)
void	operator delete (void *p)

Additional Inherited Members
Static Public Member Functions inherited from A
static A *	Create (SkRandom *r)
static void	SetAllocator (size_t preallocSize, size_t minAllocSize)
static void	ResetAllocator ()
static void	ValidatePool ()

Detailed Description

template<typename T, typename B, typename Allocator>
class dart::BaseGrowableArray< T, B, Allocator >

Definition at line 19 of file growable_array.h.

Constructor & Destructor Documentation

BaseGrowableArray() [1/3]

template<typename T , typename B , typename Allocator >

dart::BaseGrowableArray< T, B, Allocator >::BaseGrowableArray ( Allocator *  allocator )

inlineexplicit

Definition at line 21 of file growable_array.h.

      : length_(0), capacity_(0), data_(nullptr), allocator_(allocator) {}

BaseGrowableArray() [2/3]

template<typename T , typename B , typename Allocator >

dart::BaseGrowableArray< T, B, Allocator >::BaseGrowableArray ( intptr_t  initial_capacity, Allocator *  allocator  )

inline

Definition at line 24 of file growable_array.h.

      : length_(0), capacity_(0), data_(nullptr), allocator_(allocator) {
    if (initial_capacity > 0) {
      capacity_ = Utils::RoundUpToPowerOfTwo(initial_capacity);
      data_ = allocator_->template Alloc<T>(capacity_);
    }
  }

BaseGrowableArray() [3/3]

template<typename T , typename B , typename Allocator >

dart::BaseGrowableArray< T, B, Allocator >::BaseGrowableArray ( BaseGrowableArray< T, B, Allocator > &&  other )

inline

Definition at line 32 of file growable_array.h.

      : length_(other.length_),
        capacity_(other.capacity_),
        data_(other.data_),
        allocator_(other.allocator_) {
    other.length_ = 0;
    other.capacity_ = 0;
    other.data_ = nullptr;
  }

~BaseGrowableArray()

template<typename T , typename B , typename Allocator >

dart::BaseGrowableArray< T, B, Allocator >::~BaseGrowableArray ( )

inline

Definition at line 42 of file growable_array.h.

{ allocator_->template Free<T>(data_, capacity_); }

Member Function Documentation

Add()

template<typename T , typename B , typename Allocator >

void dart::BaseGrowableArray< T, B, Allocator >::Add ( const T &  value )

inline

Definition at line 84 of file growable_array.h.

                           {
    Resize(length() + 1);
    Last() = value;
  }

AddArray()

template<typename T , typename B , typename Allocator >

void dart::BaseGrowableArray< T, B, Allocator >::AddArray ( const BaseGrowableArray< T, B, Allocator > &  src )

inline

Definition at line 131 of file growable_array.h.

                                                               {
    for (intptr_t i = 0; i < src.length(); i++) {
      Add(src[i]);
    }
  }

At()

template<typename T , typename B , typename Allocator >

const T & dart::BaseGrowableArray< T, B, Allocator >::At ( intptr_t  index ) const

inline

Definition at line 124 of file growable_array.h.

{ return operator[](index); }

begin() [1/2]

template<typename T , typename B , typename Allocator >

T * dart::BaseGrowableArray< T, B, Allocator >::begin ( )

inline

Definition at line 206 of file growable_array.h.

{ return &data_[0]; }

begin() [2/2]

template<typename T , typename B , typename Allocator >

const T * dart::BaseGrowableArray< T, B, Allocator >::begin ( ) const

inline

Definition at line 207 of file growable_array.h.

{ return &data_[0]; }

Clear()

template<typename T , typename B , typename Allocator >

void dart::BaseGrowableArray< T, B, Allocator >::Clear ( )

inline

Definition at line 137 of file growable_array.h.

{ length_ = 0; }

Contains()

template<typename T , typename B , typename Allocator >

bool dart::BaseGrowableArray< T, B, Allocator >::Contains ( const T &  other, bool   isEqualconst T &, const T & = nullptr  ) const

inline

Definition at line 69 of file growable_array.h.

                                                                         {
    for (const auto& value : *this) {
      if (value == other) {
        // Value identity should imply isEqual.
        ASSERT(isEqual == nullptr || isEqual(value, other));
        return true;
      }
      if (isEqual != nullptr && isEqual(value, other)) {
        return true;
      }
    }
    return false;
  }

data()

template<typename T , typename B , typename Allocator >

T * dart::BaseGrowableArray< T, B, Allocator >::data ( ) const

inline

Definition at line 61 of file growable_array.h.

{ return data_; }

end() [1/2]

template<typename T , typename B , typename Allocator >

T * dart::BaseGrowableArray< T, B, Allocator >::end ( )

inline

Definition at line 209 of file growable_array.h.

{ return &data_[length_]; }

end() [2/2]

template<typename T , typename B , typename Allocator >

const T * dart::BaseGrowableArray< T, B, Allocator >::end ( ) const

inline

Definition at line 210 of file growable_array.h.

{ return &data_[length_]; }

EnsureLength()

template<typename T , typename B , typename Allocator >

void dart::BaseGrowableArray< T, B, Allocator >::EnsureLength ( intptr_t  new_length, const T &  default_value  )

inline

Definition at line 114 of file growable_array.h.

                                                                 {
    const intptr_t old_length = length_;
    if (old_length < new_length) {
      Resize(new_length);
      for (intptr_t i = old_length; i < new_length; ++i) {
        (*this)[i] = default_value;
      }
    }
  }

EraseAt()

template<typename T , typename B , typename Allocator >

void dart::BaseGrowableArray< T, B, Allocator >::EraseAt ( intptr_t  idx )

inline

Definition at line 179 of file growable_array.h.

                             {
    ASSERT(idx >= 0);
    ASSERT(idx < length_);
    for (intptr_t i = idx; i < length_ - 1; i++) {
      data_[i] = data_[i + 1];
    }
    RemoveLast();
  }

FillWith()

template<typename T , typename B , typename Allocator >

void dart::BaseGrowableArray< T, B, Allocator >::FillWith ( const T &  value, intptr_t  start, intptr_t  length  )

inline

Definition at line 103 of file growable_array.h.

                                                                 {
    ASSERT(start >= 0);
    ASSERT(length >= 0);
    ASSERT(start <= length_);
 
    Resize(start + length);
    for (intptr_t i = 0; i < length; ++i) {
      data_[start + i] = value;
    }
  }

InsertAt()

template<typename T , typename B , typename Allocator >

void dart::BaseGrowableArray< T, B, Allocator >::InsertAt ( intptr_t  idx, const T &  value  )

inline

Definition at line 139 of file growable_array.h.

                                              {
    Resize(length() + 1);
    for (intptr_t i = length_ - 2; i >= idx; i--) {
      data_[i + 1] = data_[i];
    }
    data_[idx] = value;
  }

is_empty()

template<typename T , typename B , typename Allocator >

bool dart::BaseGrowableArray< T, B, Allocator >::is_empty ( ) const

inline

Definition at line 62 of file growable_array.h.

{ return length_ == 0; }

Last()

template<typename T , typename B , typename Allocator >

T & dart::BaseGrowableArray< T, B, Allocator >::Last ( ) const

inline

Definition at line 126 of file growable_array.h.

                  {
    ASSERT(length_ > 0);
    return operator[](length_ - 1);
  }

length()

template<typename T , typename B , typename Allocator >

intptr_t dart::BaseGrowableArray< T, B, Allocator >::length ( ) const

inline

Definition at line 60 of file growable_array.h.

{ return length_; }

operator=()

template<typename T , typename B , typename Allocator >

BaseGrowableArray & dart::BaseGrowableArray< T, B, Allocator >::operator= ( BaseGrowableArray< T, B, Allocator > &&  other )

inline

Definition at line 44 of file growable_array.h.

                                                          {
    intptr_t temp = other.length_;
    other.length_ = length_;
    length_ = temp;
    temp = other.capacity_;
    other.capacity_ = capacity_;
    capacity_ = temp;
    T* temp_data = other.data_;
    other.data_ = data_;
    data_ = temp_data;
    Allocator* temp_allocator = other.allocator_;
    other.allocator_ = allocator_;
    allocator_ = temp_allocator;
    return *this;
  }

operator[]()

template<typename T , typename B , typename Allocator >

T & dart::BaseGrowableArray< T, B, Allocator >::operator[] ( intptr_t  index ) const

inline

Definition at line 96 of file growable_array.h.

                                      {
    ASSERT(0 <= index);
    ASSERT(index < length_);
    ASSERT(length_ <= capacity_);
    return data_[index];
  }

RemoveAt()

template<typename T , typename B , typename Allocator >

void dart::BaseGrowableArray< T, B, Allocator >::RemoveAt ( intptr_t  i )

inline

Definition at line 168 of file growable_array.h.

                            {
    ASSERT(i >= 0);
    ASSERT(i < length_);
    intptr_t last = length_ - 1;
    if (i < last) {
      Swap(i, last);
    }
    RemoveLast();
  }

RemoveLast()

template<typename T , typename B , typename Allocator >

T & dart::BaseGrowableArray< T, B, Allocator >::RemoveLast ( )

inline

Definition at line 89 of file growable_array.h.

                  {
    ASSERT(length_ > 0);
    T& result = operator[](length_ - 1);
    length_--;
    return result;
  }

Resize()

template<typename T , typename B , typename Allocator >

void dart::BaseGrowableArray< T, B, Allocator >::Resize

(

intptr_t

new_length

)

Definition at line 232 of file growable_array.h.

                                                                   {
  if (new_length > capacity_) {
    intptr_t new_capacity = Utils::RoundUpToPowerOfTwo(new_length);
    T* new_data =
        allocator_->template Realloc<T>(data_, capacity_, new_capacity);
    ASSERT(new_data != nullptr);
    data_ = new_data;
    capacity_ = new_capacity;
  }
  length_ = new_length;
}

Reverse()

template<typename T , typename B , typename Allocator >

void dart::BaseGrowableArray< T, B, Allocator >::Reverse ( )

inline

Definition at line 147 of file growable_array.h.

                 {
    for (intptr_t i = 0; i < length_ / 2; i++) {
      const intptr_t j = length_ - 1 - i;
      T temp = data_[i];
      data_[i] = data_[j];
      data_[j] = temp;
    }
  }

SetLength()

template<typename T , typename B , typename Allocator >

void dart::BaseGrowableArray< T, B, Allocator >::SetLength

(

intptr_t

new_length

)

Definition at line 245 of file growable_array.h.

                                                                      {
  if (new_length > capacity_) {
    T* new_data = allocator_->template Alloc<T>(new_length);
    ASSERT(new_data != nullptr);
    data_ = new_data;
    capacity_ = new_length;
  }
  length_ = new_length;
}

Sort()

template<typename T , typename B , typename Allocator >

void dart::BaseGrowableArray< T, B, Allocator >::Sort ( int   compareconst T *, const T * )

inline

Definition at line 222 of file growable_array.h.

                                                                            {
  // Avoid calling qsort with a null array.
  if (length_ == 0) return;
 
  typedef int (*CompareFunction)(const void*, const void*);
  qsort(data_, length_, sizeof(T), reinterpret_cast<CompareFunction>(compare));
}

StealBuffer()

template<typename T , typename B , typename Allocator >

void dart::BaseGrowableArray< T, B, Allocator >::StealBuffer ( T **  buffer, intptr_t *  length  )

inline

Definition at line 198 of file growable_array.h.

                                                 {
    *buffer = data_;
    *length = length_;
    data_ = nullptr;
    length_ = 0;
    capacity_ = 0;
  }

Swap()

template<typename T , typename B , typename Allocator >

void dart::BaseGrowableArray< T, B, Allocator >::Swap ( intptr_t  i, intptr_t  j  )

inline

Definition at line 157 of file growable_array.h.

                                    {
    ASSERT(i >= 0);
    ASSERT(j >= 0);
    ASSERT(i < length_);
    ASSERT(j < length_);
    T temp = data_[i];
    data_[i] = data_[j];
    data_[j] = temp;
  }

TruncateTo()

template<typename T , typename B , typename Allocator >

void dart::BaseGrowableArray< T, B, Allocator >::TruncateTo ( intptr_t  length )

inline

Definition at line 64 of file growable_array.h.

                                   {
    ASSERT(length_ >= length);
    length_ = length;
  }

---

The documentation for this class was generated from the following file:

• third_party/dart-lang/sdk/runtime/platform/growable_array.h