ArrayData *VectorArray::add(int64 k, CVarRef v, bool copy) {
assert(!exists(k));
if (k == m_size) return VectorArray::append(v, copy);
ZendArray *a = escalateToZendArray();
a->add(k, v, false);
return a;
}
ArrayData *VectorArray::lval(int64 k, Variant *&ret, bool copy,
bool checkExist /* = false */) {
ret = inRange(k, m_size) ? &tvAsVariant(&m_elems[k]) : nullptr;
if (ret == nullptr && k != m_size) {
ZendArray *a = escalateToZendArray();
a->addLvalImpl(k, &ret, false);
return a;
}
if (LIKELY(!copy)) {
if (ret) return nullptr;
assert(m_size == k);
checkSize();
Variant& v = tvAsUninitializedVariant(&m_elems[k]);
v.setUninitNull();
ret = &v;
checkInsertIterator((ssize_t)k);
m_size++;
return nullptr;
}
if (checkExist && ret && (ret->isReferenced() || ret->isObject())) {
return nullptr;
}
VectorArray *a = NEW(VectorArray)(this);
if (ret) {
Variant& v = tvAsVariant(&a->m_elems[k]);
ret = &v;
assert(ret);
return a;
}
assert(m_size == k);
a->VectorArray::lvalNew(ret, false);
return a;
}
ArrayData *VectorArray::lval(litstr k, Variant *&ret, bool copy,
bool checkExist /* = false */) {
ZendArray *a = escalateToZendArray();
StringData sd(k, AttachLiteral);
a->addLvalImpl(&sd, sd.hash(), &ret);
return a;
}
ArrayData *VectorArray::addLval(CVarRef k, Variant *&ret, bool copy) {
ASSERT(!exists(k));
Variant::TypedValueAccessor tva = k.getTypedAccessor();
if (isIntKey(tva)) return VectorArray::addLval(getIntKey(tva), ret, copy);
ASSERT(k.isString());
ZendArray *a = escalateToZendArray();
a->addLval(StrNR(getStringKey(tva)), ret, false);
return a;
}
ArrayData *VectorArray::setRef(CVarRef k, CVarRef v, bool copy) {
Variant::TypedValueAccessor tva = k.getTypedAccessor();
if (isIntKey(tva)) {
return VectorArray::setRef(getIntKey(tva), v, copy);
}
ASSERT(k.isString());
ZendArray *a = escalateToZendArray();
a->updateRef(getStringKey(tva), v);
return a;
}
HOT_FUNC_HPHP
ArrayData *VectorArray::set(CVarRef k, CVarRef v, bool copy) {
Variant::TypedValueAccessor tva = k.getTypedAccessor();
if (isIntKey(tva)) {
return VectorArray::set(getIntKey(tva), v, copy);
}
ASSERT(k.isString());
ZendArray *a = escalateToZendArray();
a->add(StrNR(getStringKey(tva)), v, false);
return a;
}
ArrayData *VectorArray::lval(CVarRef k, Variant *&ret, bool copy,
bool checkExist /* = false */) {
Variant::TypedValueAccessor tva = k.getTypedAccessor();
if (isIntKey(tva)) {
return VectorArray::lval(getIntKey(tva), ret, copy, checkExist);
}
ASSERT(k.isString());
ZendArray *a = escalateToZendArray();
StringData *sd = getStringKey(tva);
a->addLvalImpl(sd, sd->hash(), &ret);
return a;
}
HOT_FUNC_HPHP
ArrayData *VectorArray::set(int64 k, CVarRef v, bool copy) {
if (inRange(k, m_size)) {
if (copy) {
VectorArray *a = NEW(VectorArray)(this);
tvAsVariant(&a->m_elems[k]).assignVal(v);
return a;
}
tvAsVariant(&m_elems[k]).assignVal(v);
return nullptr;
}
if (k == m_size) return VectorArray::append(v, copy);
ZendArray *a = escalateToZendArray();
a->add(k, v, false);
return a;
}
ArrayData *VectorArray::addLval(int64 k, Variant *&ret, bool copy) {
assert(!exists(k));
if (k != m_size) {
ZendArray *a = escalateToZendArray();
a->addLval(k, ret, false);
return a;
}
uint index = m_size;
if (UNLIKELY(copy)) {
VectorArray *a = NEW(VectorArray)(this);
a->VectorArray::addLval(k, ret, false);
return a;
}
checkSize();
Variant& v = tvAsUninitializedVariant(&m_elems[index]);
v.setUninitNull();
ret = &v;
checkInsertIterator((ssize_t)index);
m_size++;
return nullptr;
}
HOT_FUNC_HPHP
ArrayData *VectorArray::append(const ArrayData *elems, ArrayOp op, bool copy) {
if (UNLIKELY(!elems->isVectorArray())) {
ZendArray *a = escalateToZendArray();
a->append(elems, op, false);
return a;
}
if (UNLIKELY(copy)) {
VectorArray *a = NEW(VectorArray)(this);
a->VectorArray::append(elems, op, false);
return a;
}
assert(dynamic_cast<const VectorArray *>(elems));
const VectorArray *velems = static_cast<const VectorArray *>(elems);
if (op == Plus) {
if (velems->m_size > m_size) {
checkSize(velems->m_size - m_size);
for (uint i = m_size; i < velems->m_size; i++) {
Variant& to = tvAsUninitializedVariant(&m_elems[i]);
CVarRef fm = tvAsCVarRef(&velems->m_elems[i]);
to.constructWithRefHelper(fm, 0);
}
checkInsertIterator((ssize_t)m_size);
m_size = velems->m_size;
}
} else {
assert(op == Merge);
if (velems->m_size > 0) {
checkSize(velems->m_size);
for (uint i = m_size; i < m_size + velems->m_size; i++) {
Variant& to = tvAsUninitializedVariant(&m_elems[i]);
CVarRef fm = tvAsCVarRef(&velems->m_elems[i - m_size]);
to.constructWithRefHelper(fm, 0);
}
checkInsertIterator((ssize_t)m_size);
m_size += velems->m_size;
}
}
return nullptr;
}
ArrayData *VectorArray::setRef(int64 k, CVarRef v, bool copy) {
if (UNLIKELY(copy)) {
if (inRange(k, m_size) || k == m_size) {
VectorArray *a = NEW(VectorArray)(this);
a->VectorArray::setRef(k, v, false);
return a;
}
} else {
if (inRange(k, m_size)) {
tvAsVariant(&m_elems[k]).assignRef(v);
return nullptr;
} else if (k == m_size) {
checkSize();
tvAsUninitializedVariant(&m_elems[k]).constructRefHelper(v);
checkInsertIterator((ssize_t)k);
m_size++;
return nullptr;
}
}
ZendArray *a = escalateToZendArray();
a->updateRef(k, v);
return a;
}
ArrayData* VectorArray::escalateForSort() {
return escalateToZendArray();
}
ArrayData *VectorArray::escalate(bool mutableIteration /* = false */) const {
if (mutableIteration) {
return escalateToZendArray();
}
return const_cast<VectorArray *>(this);
}
ArrayData *VectorArray::addLval(StringData* k, Variant *&ret, bool copy) {
ZendArray *a = escalateToZendArray();
a->addLval(k, ret, false);
return a;
}
ArrayData *VectorArray::add(StringData* k, CVarRef v, bool copy) {
ZendArray *a = escalateToZendArray();
a->add(k, v, false);
return a;
}
HOT_FUNC_HPHP
ArrayData *VectorArray::set(CStrRef k, CVarRef v, bool copy) {
ZendArray *a = escalateToZendArray();
a->add(k, v, false);
return a;
}
ArrayData *VectorArray::setRef(StringData* k, CVarRef v, bool copy) {
ZendArray *a = escalateToZendArray();
a->updateRef(k, v);
return a;
}
ArrayData *VectorArray::setRef(CStrRef k, CVarRef v, bool copy) {
ZendArray *a = escalateToZendArray();
a->updateRef(k.get(), v);
return a;
}
ArrayData *VectorArray::lvalPtr(int64 k, Variant *&ret, bool copy,
bool create) {
ZendArray *a = escalateToZendArray();
a->lvalPtr(k, ret, false, create);
return a;
}
ArrayData *VectorArray::lval(StringData* k, Variant *&ret, bool copy,
bool checkExist /* = false */) {
ZendArray *a = escalateToZendArray();
a->addLvalImpl(k, k->hash(), &ret);
return a;
}
