mirror of
https://github.com/dart-lang/sdk
synced 2024-09-19 20:41:45 +00:00
b1c09ecd8f
Currently we have things called XPtr which are not what you get from ptr().
Old world:
handle->raw() returns RawObject* (tagged)
raw_obj->ptr() returns RawObject* (untagged)
After 6fe15f6df9
:
handle->raw() returns ObjectPtr
obj_ptr->ptr() returns ObjectLayout*
New world:
handle->ptr() returns ObjectPtr
obj_ptr->untag() returns UntaggedObject*
TEST=ci
Change-Id: I6c7f34014cf20737607caaf84979838300d12df2
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/149367
Commit-Queue: Ryan Macnak <rmacnak@google.com>
Reviewed-by: Martin Kustermann <kustermann@google.com>
Reviewed-by: Siva Annamalai <asiva@google.com>
Reviewed-by: Vyacheslav Egorov <vegorov@google.com>
99 lines
3.3 KiB
C++
99 lines
3.3 KiB
C++
// Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file
|
|
// for details. All rights reserved. Use of this source code is governed by a
|
|
// BSD-style license that can be found in the LICENSE file.
|
|
// Defines growable array classes, that differ where they are allocated:
|
|
// - GrowableArray: allocated on stack.
|
|
// - ZoneGrowableArray: allocated in the zone.
|
|
// - MallocGrowableArray: allocates using malloc/realloc; free is only called
|
|
// at destruction.
|
|
|
|
#ifndef RUNTIME_VM_GROWABLE_ARRAY_H_
|
|
#define RUNTIME_VM_GROWABLE_ARRAY_H_
|
|
|
|
#include "platform/growable_array.h"
|
|
#include "vm/thread_state.h"
|
|
#include "vm/zone.h"
|
|
|
|
namespace dart {
|
|
|
|
template <typename T>
|
|
class GrowableArray : public BaseGrowableArray<T, ValueObject, Zone> {
|
|
public:
|
|
GrowableArray(Zone* zone, intptr_t initial_capacity)
|
|
: BaseGrowableArray<T, ValueObject, Zone>(initial_capacity,
|
|
ASSERT_NOTNULL(zone)) {}
|
|
explicit GrowableArray(intptr_t initial_capacity)
|
|
: BaseGrowableArray<T, ValueObject, Zone>(
|
|
initial_capacity,
|
|
ASSERT_NOTNULL(ThreadState::Current()->zone())) {}
|
|
GrowableArray()
|
|
: BaseGrowableArray<T, ValueObject, Zone>(
|
|
ASSERT_NOTNULL(ThreadState::Current()->zone())) {}
|
|
};
|
|
|
|
template <typename T>
|
|
class ZoneGrowableArray : public BaseGrowableArray<T, ZoneAllocated, Zone> {
|
|
public:
|
|
ZoneGrowableArray(Zone* zone, intptr_t initial_capacity)
|
|
: BaseGrowableArray<T, ZoneAllocated, Zone>(initial_capacity,
|
|
ASSERT_NOTNULL(zone)) {}
|
|
explicit ZoneGrowableArray(intptr_t initial_capacity)
|
|
: BaseGrowableArray<T, ZoneAllocated, Zone>(
|
|
initial_capacity,
|
|
ASSERT_NOTNULL(ThreadState::Current()->zone())) {}
|
|
ZoneGrowableArray()
|
|
: BaseGrowableArray<T, ZoneAllocated, Zone>(
|
|
ASSERT_NOTNULL(ThreadState::Current()->zone())) {}
|
|
};
|
|
|
|
// T must be a Handle type.
|
|
template <typename T, typename B>
|
|
class BaseGrowableHandlePtrArray : public B {
|
|
public:
|
|
BaseGrowableHandlePtrArray(Zone* zone, intptr_t initial_capacity)
|
|
: zone_(zone), array_(zone, initial_capacity) {}
|
|
|
|
// Use unique zone handles to store objects.
|
|
void Add(const T& t) { array_.Add(&T::ZoneHandle(zone_, t.ptr())); }
|
|
|
|
T& operator[](intptr_t index) const { return *array_[index]; }
|
|
|
|
const T& At(intptr_t index) const { return operator[](index); }
|
|
|
|
void SetAt(intptr_t index, const T& t) {
|
|
array_[index] = &T::ZoneHandle(zone_, t.ptr());
|
|
}
|
|
|
|
intptr_t length() const { return array_.length(); }
|
|
|
|
void Clear() { array_.Clear(); }
|
|
|
|
const GrowableArray<T*>& growable_array() const { return array_; }
|
|
|
|
private:
|
|
Zone* zone_;
|
|
GrowableArray<T*> array_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(BaseGrowableHandlePtrArray);
|
|
};
|
|
|
|
template <typename T>
|
|
class GrowableHandlePtrArray
|
|
: public BaseGrowableHandlePtrArray<T, ValueObject> {
|
|
public:
|
|
GrowableHandlePtrArray(Zone* zone, intptr_t initial_capacity)
|
|
: BaseGrowableHandlePtrArray<T, ValueObject>(zone, initial_capacity) {}
|
|
};
|
|
|
|
template <typename T>
|
|
class ZoneGrowableHandlePtrArray
|
|
: public BaseGrowableHandlePtrArray<T, ZoneAllocated> {
|
|
public:
|
|
ZoneGrowableHandlePtrArray(Zone* zone, intptr_t initial_capacity)
|
|
: BaseGrowableHandlePtrArray<T, ZoneAllocated>(zone, initial_capacity) {}
|
|
};
|
|
|
|
} // namespace dart
|
|
|
|
#endif // RUNTIME_VM_GROWABLE_ARRAY_H_
|