ArrayData* ProxyArray::LvalInt(ArrayData* ad, int64_t k, Variant*& ret, bool copy) { if (copy) { return innerArr(ad)->lval(k, ret, true); } else { auto r = innerArr(ad)->lval(k, ret, innerArr(ad)->hasMultipleRefs()); reseatable(ad, r); return ad; } }
ArrayData* ProxyArray::RemoveInt(ArrayData* ad, int64_t k, bool copy) { if (copy) { return innerArr(ad)->remove(k, true); } else { auto r = innerArr(ad)->remove(k, innerArr(ad)->cowCheck()); reseatable(ad, r); return ad; } }
ArrayData* ProxyArray::AppendWithRef(ArrayData* ad, const Variant& v, bool copy) { if (copy) { return innerArr(ad)->appendWithRef(v, true); } else { auto r = innerArr(ad)->appendWithRef(v, innerArr(ad)->cowCheck()); reseatable(ad, r); return ad; } }
ArrayData* ProxyArray::LvalNew(ArrayData* ad, Variant*& ret, bool copy) { if (copy) { return innerArr(ad)->lvalNew(ret, true); } else { auto r = innerArr(ad)->lvalNew(ret, innerArr(ad)->cowCheck()); reseatable(ad, r); return ad; } }
void ProxyArray::proxyInit(uint32_t nSize, DtorFunc pDestructor, bool persistent) { if (persistent) { throw FatalErrorException("zend_hash_init: \"persistent\" is \ unimplemented"); } if (nSize) { reseatable(this, MixedArray::MakeReserve(nSize)); } m_destructor = pDestructor; }
ArrayData* ProxyArray::RemoveStr(ArrayData* ad, const StringData* k, bool copy) { if (copy) { return innerArr(ad)->remove(k, true); } else { auto r = innerArr(ad)->remove(k, innerArr(ad)->hasMultipleRefs()); reseatable(ad, r); return ad; } }
void ProxyArray::proxyInit(uint32_t nSize, DtorFunc pDestructor, bool persistent) { if (persistent) { raise_fatal_error("zend_hash_init: \"persistent\" is \ unimplemented"); } if (nSize) { reseatable(this, PackedArray::MakeReserve(nSize)); } m_destructor = pDestructor; }
ArrayData* ProxyArray::SetRefStr(ArrayData* ad, StringData* k, Variant& v, bool copy) { if (copy) { return innerArr(ad)->setRef(k, v, true); } auto const r = innerArr(ad)->setRef(k, v, innerArr(ad)->cowCheck()); reseatable(ad, r); return ad; }
ArrayData* ProxyArray::SetRefStr(ArrayData* ad, StringData* k, Variant& v, bool copy) { if (copy) { return innerArr(ad)->setRef(k, v, true); } else { auto r = innerArr(ad)->setRef(k, v, innerArr(ad)->hasMultipleRefs()); reseatable(ad, r); return ad; } }
ArrayData* ProxyArray::SetRefInt(ArrayData* ad, int64_t k, Variant& v, bool copy) { if (copy) { return innerArr(ad)->setRef(k, v, true); } else { auto r = innerArr(ad)->setRef(k, v, innerArr(ad)->cowCheck()); reseatable(ad, r); return ad; } }
void* ProxyArray::proxyGet(StringData * str) const { // elementToData() may need to modify the value. The zend_hash_find() // interface itself is theoretically non-const and callers may write directly // to the value. So lval() is appropriate here, to force escalation of // APCLocalArray to MixedArray. if (!innerArr(this)->exists(str)) { return nullptr; } auto r = innerArr(this)->lval(str, false); reseatable(this, r.array); return elementToData(r.val); }
ArrayData* ProxyArray::SetStr(ArrayData* ad, StringData* k, Cell v, bool copy) { if (copy) { return innerArr(ad)->set(k, tvAsCVarRef(&v), copy); } else { auto r = innerArr(ad)->set(k, tvAsCVarRef(&v), innerArr(ad)->hasMultipleRefs()); reseatable(ad, r); return ad; } }
ArrayData* ProxyArray::SetInt(ArrayData* ad, int64_t k, Cell v, bool copy) { if (copy) { return innerArr(ad)->set(k, tvAsCVarRef(&v), true); } auto const r = innerArr(ad)->set( k, tvAsCVarRef(&v), innerArr(ad)->cowCheck() ); reseatable(ad, r); return ad; }
ArrayData* ProxyArray::SetInt(ArrayData* ad, int64_t k, Cell v, bool copy) { if (copy) { return innerArr(ad)->set(k, tvAsCVarRef(&v), true); } else { auto r = innerArr(ad)->set(k, tvAsCVarRef(&v), innerArr(ad)->hasMultipleRefs()); reseatable(ad, r); return ad; } }
ArrayData* ProxyArray::SetStr(ArrayData* ad, StringData* k, Cell v, bool copy) { if (copy) { return innerArr(ad)->set(k, tvAsCVarRef(&v), copy); } auto const r = innerArr(ad)->set( k, tvAsCVarRef(&v), innerArr(ad)->cowCheck() ); reseatable(ad, r); return ad; }
void ProxyArray::proxyAppend(void* data, uint32_t data_size, void** dest) { ArrayData * r; if (hasZvalValues()) { assert(data_size == sizeof(void*)); int64_t k = 0; r = innerArr(this)->zAppend(*(RefData**)data, &k); if (dest) { *dest = (void*)(&r->nvGet(k)->m_data.pref); } } else { auto v = Variant(makeElementResource(data, data_size, dest)); r = innerArr(this)->append(*v.asTypedValue(), false); } reseatable(this, r); }
void ProxyArray::proxyAppend(void* data, uint32_t data_size, void** dest) { ArrayData * r; if (hasZvalValues()) { assert(data_size == sizeof(void*)); int64_t k = 0; r = m_ad->zAppend(*(RefData**)data, &k); if (dest) { *dest = (void*)(&m_ad->nvGet(k)->m_data.pref); } } else { ResourceData * elt = makeElementResource(data, data_size, dest); r = m_ad->append(elt, false); } reseatable(this, r); }
ArrayData* ProxyArray::ZAppend(ArrayData* ad, RefData* v, int64_t* key_ptr) { auto r = innerArr(ad)->zAppend(v, key_ptr); reseatable(ad, r); return ad; }
ArrayData* ProxyArray::ToKeyset(ArrayData* ad, bool copy) { auto const r = innerArr(ad)->toKeyset(innerArr(ad)->cowCheck()); reseatable(ad, r); return const_cast<ArrayData*>(ad); }
ArrayData* ProxyArray::ZSetInt(ArrayData* ad, int64_t k, RefData* v) { auto const r = innerArr(ad)->zSet(k, v); reseatable(ad, r); return ad; }
ArrayData* ProxyArray::ZSetStr(ArrayData* ad, StringData* k, RefData* v) { auto r = innerArr(ad)->zSet(k, v); reseatable(ad, r); return ad; }
void ProxyArray::Asort(ArrayData* ad, int sort_flags, bool ascending) { auto const sf = getSortFunction(SORTFUNC_ASORT, ascending); reseatable(ad, innerArr(ad)->escalateForSort(sf)); return innerArr(ad)->asort(sort_flags, ascending); }
bool ProxyArray::Uasort(ArrayData* ad, const Variant& cmp_function) { reseatable(ad, innerArr(ad)->escalateForSort(SORTFUNC_UASORT)); return innerArr(ad)->uasort(cmp_function); }
ArrayData* ProxyArray::EscalateForSort(ArrayData* ad, SortFunction sf) { auto const r = innerArr(ad)->escalateForSort(sf); reseatable(ad, r); return ad; }
bool ProxyArray::Usort(ArrayData* ad, const Variant& cmp_function) { ad = reseatable(ad, innerArr(ad)->escalateForSort()); return innerArr(ad)->usort(cmp_function); }
ArrayData* ProxyArray::Pop(ArrayData* ad, Variant &value) { auto const r = innerArr(ad)->pop(value); reseatable(ad, r); return ad; }
ArrayData* ProxyArray::ToVec(ArrayData* ad, bool copy) { auto const r = innerArr(ad)->toVec(innerArr(ad)->cowCheck()); reseatable(ad, r); return ad; }
ArrayData* ProxyArray::Dequeue(ArrayData* ad, Variant &value) { auto const r = innerArr(ad)->dequeue(value); reseatable(ad, r); return ad; }
ArrayData* ProxyArray::Merge(ArrayData* ad, const ArrayData* elems) { auto const r = innerArr(ad)->merge(elems); reseatable(ad, r); return ad; }
ArrayData* ProxyArray::Escalate(const ArrayData* ad) { auto const r = innerArr(ad)->escalate(); reseatable(ad, r); return const_cast<ArrayData*>(ad); }