Array HashCollection::toValuesArray() {
PackedArrayInit ai(m_size);
auto* eLimit = elmLimit();
for (auto* e = firstElm(); e != eLimit; e = nextElm(e, eLimit)) {
ai.append(tvAsCVarRef(&e->data));
}
return ai.toArray();
}
Variant BaseMap::firstKey() {
if (!m_size) return null_variant;
auto* e = firstElm();
assert(e != elmLimit());
if (e->hasIntKey()) {
return e->ikey;
} else {
assert(e->hasStrKey());
return Variant{e->skey};
}
}
Array HashCollection::toKeysArray() {
PackedArrayInit ai(m_size);
auto* eLimit = elmLimit();
for (auto* e = firstElm(); e != eLimit; e = nextElm(e, eLimit)) {
if (e->hasIntKey()) {
ai.append(int64_t{e->ikey});
} else {
assert(e->hasStrKey());
ai.append(VarNR(e->skey).tv());
}
}
return ai.toArray();
}
bool BaseSet::Equals(const ObjectData* obj1, const ObjectData* obj2) {
auto st1 = static_cast<const BaseSet*>(obj1);
auto st2 = static_cast<const BaseSet*>(obj2);
if (st1->m_size != st2->m_size) return false;
auto eLimit = st1->elmLimit();
for (auto e = st1->firstElm(); e != eLimit; e = nextElm(e, eLimit)) {
if (e->hasIntKey()) {
if (!st2->contains(e->data.m_data.num)) return false;
} else {
assert(e->hasStrKey());
if (!st2->contains(e->data.m_data.pstr)) return false;
}
}
return true;
}
NEVER_INLINE
void HashCollection::warnOnStrIntDup() const {
req::hash_set<int64_t> seenVals;
auto* eLimit = elmLimit();
for (auto* e = firstElm(); e != eLimit; e = nextElm(e, eLimit)) {
int64_t newVal = 0;
if (e->hasIntKey()) {
newVal = e->ikey;
} else {
assert(e->hasStrKey());
// isStriclyInteger() puts the int value in newVal as a side effect.
if (!e->skey->isStrictlyInteger(newVal)) continue;
}
if (seenVals.find(newVal) != seenVals.end()) {
auto cls = getVMClass()->name()->toCppString();
auto pos = cls.rfind('\\');
if (pos != std::string::npos) {
cls = cls.substr(pos + 1);
}
raise_warning(
"%s::toArray() for a %s containing both int(%" PRId64 ") "
"and string('%" PRId64 "')",
cls.c_str(),
toLower(cls).c_str(),
newVal,
newVal
);
return;
}
seenVals.insert(newVal);
}
// Do nothing if no 'duplicates' were found.
}
ALWAYS_INLINE
typename std::enable_if<
std::is_base_of<BaseMap, TMap>::value, Object>::type
BaseMap::php_differenceByKey(const Variant& it) {
if (!it.isObject()) {
SystemLib::throwInvalidArgumentExceptionObject(
"Parameter it must be an instance of Iterable");
}
ObjectData* obj = it.getObjectData();
TMap* target = BaseMap::Clone<TMap>(this);
auto ret = Object::attach(target);
if (obj->isCollection()) {
if (isMapCollection(obj->collectionType())) {
auto map = static_cast<BaseMap*>(obj);
auto* eLimit = map->elmLimit();
for (auto* e = map->firstElm(); e != eLimit; e = nextElm(e, eLimit)) {
if (e->hasIntKey()) {
target->remove((int64_t)e->ikey);
} else {
assert(e->hasStrKey());
target->remove(e->skey);
}
}
return ret;
}
}
for (ArrayIter iter(obj); iter; ++iter) {
Variant k = iter.first();
if (k.isInteger()) {
target->remove(k.toInt64());
} else {
assert(k.isString());
target->remove(k.getStringData());
}
}
return ret;
}
Variant BaseSet::firstValue() {
if (!m_size) return init_null();
auto e = firstElm();
assert(e != elmLimit());
return tvAsCVarRef(&e->data);
}
Variant BaseMap::firstValue() {
if (!m_size) return null_variant;
auto* e = firstElm();
assert(e != elmLimit());
return tvAsCVarRef(&e->data);
}
