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; }