VarNR Variant::toKey() const {
if (m_type == KindOfString || m_type == KindOfStaticString) {
int64_t n;
if (m_data.pstr->isStrictlyInteger(n)) {
return VarNR(n);
} else {
return VarNR(m_data.pstr);
}
}
switch (m_type) {
case KindOfUninit:
case KindOfNull:
return VarNR(empty_string);
case KindOfBoolean:
case KindOfInt64:
return VarNR(m_data.num);
case KindOfDouble:
{
auto val = m_data.dbl > std::numeric_limits<uint64_t>::max()
? 0u
: uint64_t(m_data.dbl);
return VarNR(val);
}
case KindOfObject:
break;
case KindOfResource:
return VarNR(toInt64());
case KindOfRef:
return m_data.pref->var()->toKey();
default:
break;
}
throw_bad_type_exception("Invalid type used as key");
return null_varNR;
}
VarNR Variant::toKey() const {
if (m_type == KindOfString || m_type == KindOfStaticString) {
int64_t n;
if (m_data.pstr->isStrictlyInteger(n)) {
return VarNR(n);
} else {
return VarNR(m_data.pstr);
}
}
switch (m_type) {
case KindOfUninit:
case KindOfNull:
return VarNR(staticEmptyString());
case KindOfBoolean:
case KindOfInt64:
return VarNR(m_data.num);
case KindOfObject:
break;
case KindOfDouble:
case KindOfResource:
return VarNR(toInt64());
case KindOfRef:
return m_data.pref->var()->toKey();
default:
break;
}
throw_bad_type_exception("Invalid type used as key");
return null_varNR;
}
void throw_expected_array_or_collection_exception() {
const char* fn = "(unknown)";
ActRec *ar = g_context->getStackFrame();
if (ar) {
fn = ar->m_func->name()->data();
}
throw_bad_type_exception("%s expects array(s) or collection(s)", fn);
}
HOT_FUNC_HPHP
CVarRef Array::rvalAtRef(CVarRef key, ACCESSPARAMS_IMPL) const {
if (!m_px) return null_variant;
switch (key.m_type) {
case KindOfUninit:
case KindOfNull:
return m_px->get(empty_string, flags & AccessFlags::Error);
case KindOfBoolean:
case KindOfInt64:
return m_px->get(key.m_data.num, flags & AccessFlags::Error);
case KindOfDouble:
return m_px->get((int64)key.m_data.dbl, flags & AccessFlags::Error);
case KindOfStaticString:
case KindOfString: {
int64 n;
if (!(flags & AccessFlags::Key) &&
key.m_data.pstr->isStrictlyInteger(n)) {
return m_px->get(n, flags & AccessFlags::Error);
} else {
return m_px->get(key.asCStrRef(), flags & AccessFlags::Error);
}
}
case KindOfArray:
throw_bad_type_exception("Invalid type used as key");
break;
case KindOfObject:
if (key.isResource()) {
return m_px->get(key.toInt64(), flags & AccessFlags::Error);
}
throw_bad_type_exception("Invalid type used as key");
break;
case KindOfRef:
return rvalAtRef(*(key.m_data.pvar), flags);
default:
ASSERT(false);
break;
}
return null_variant;
}
String f_implode(CVarRef arg1, CVarRef arg2 /* = null_variant */) {
Array items;
String delim;
if (arg1.is(KindOfArray)) {
items = arg1.toArray();
delim = arg2.toString();
} else if (arg2.is(KindOfArray)) {
items = arg2.toArray();
delim = arg1.toString();
} else {
throw_bad_type_exception("arguments need at least one array");
return String();
}
return StringUtil::Implode(items, delim);
}
HOT_FUNC
bool f_array_key_exists(CVarRef key, CVarRef search) {
const ArrayData *ad;
auto const searchCell = search.asCell();
if (LIKELY(searchCell->m_type == KindOfArray)) {
ad = searchCell->m_data.parr;
} else if (searchCell->m_type == KindOfObject) {
ObjectData* obj = searchCell->m_data.pobj;
if (obj->isCollection()) {
return collectionOffsetContains(obj, key);
}
return f_array_key_exists(key, toArray(search));
} else {
throw_bad_type_exception("array_key_exists expects an array or an object; "
"false returned.");
return false;
}
auto const cell = key.asCell();
switch (cell->m_type) {
case KindOfString:
case KindOfStaticString: {
int64_t n = 0;
StringData *sd = cell->m_data.pstr;
if (sd->isStrictlyInteger(n)) {
return ad->exists(n);
}
return ad->exists(StrNR(sd));
}
case KindOfInt64:
return ad->exists(cell->m_data.num);
case KindOfUninit:
case KindOfNull:
return ad->exists(empty_string);
default:
break;
}
raise_warning("Array key should be either a string or an integer");
return false;
}
HOT_FUNC
bool f_array_key_exists(CVarRef key, CVarRef search) {
const ArrayData *ad;
Variant::TypedValueAccessor sacc = search.getTypedAccessor();
DataType saccType = Variant::GetAccessorType(sacc);
if (LIKELY(saccType == KindOfArray)) {
ad = Variant::GetArrayData(sacc);
} else if (saccType == KindOfObject) {
return f_array_key_exists(key, toArray(search));
} else {
throw_bad_type_exception("array_key_exists expects an array or an object; "
"false returned.");
return false;
}
Variant::TypedValueAccessor kacc = key.getTypedAccessor();
switch (Variant::GetAccessorType(kacc)) {
case KindOfString:
case KindOfStaticString: {
int64_t n = 0;
StringData *sd = Variant::GetStringData(kacc);
if (sd->isStrictlyInteger(n)) {
return ad->exists(n);
}
return ad->exists(StrNR(sd));
}
case KindOfInt64:
return ad->exists(Variant::GetInt64(kacc));
case KindOfUninit:
case KindOfNull:
return ad->exists(empty_string);
default:
break;
}
raise_warning("Array key should be either a string or an integer");
return false;
}
