hphp/runtime/base/array-data-defs.h

   1 /*
   2    +----------------------------------------------------------------------+
   3    | HipHop for PHP                                                       |
   4    +----------------------------------------------------------------------+
   5    | Copyright (c) 2010-present Facebook, Inc. (http://www.facebook.com)  |
   6    +----------------------------------------------------------------------+
   7    | This source file is subject to version 3.01 of the PHP license,      |
   8    | that is bundled with this package in the file LICENSE, and is        |
   9    | available through the world-wide-web at the following url:           |
  10    | http://www.php.net/license/3_01.txt                                  |
  11    | If you did not receive a copy of the PHP license and are unable to   |
  12    | obtain it through the world-wide-web, please send a note to          |
  13    | license@php.net so we can mail you a copy immediately.               |
  14    +----------------------------------------------------------------------+
  15 */
  16
  17 #ifndef incl_HPHP_ARRAY_DATA_DEFS_H_
  18 #define incl_HPHP_ARRAY_DATA_DEFS_H_
  19
  20 #include "hphp/runtime/base/array-data.h"
  21
  22 #include "hphp/runtime/base/tv-val.h"
  23 #include "hphp/runtime/base/string-data.h"
  24 #include "hphp/runtime/base/type-variant.h"
  25
  26 #include <algorithm>
  27
  28 namespace HPHP {
  29
  30 ///////////////////////////////////////////////////////////////////////////////
  31
  32 extern const StaticString s_InvalidKeysetOperationMsg;
  33 extern const StaticString s_VecUnsetMsg;
  34
  35 ///////////////////////////////////////////////////////////////////////////////
  36
  37 inline ArrayData* ArrayData::Create(const Variant& value) {
  38   return Create(*value.asTypedValue());
  39 }
  40
  41 inline ArrayData* ArrayData::Create(const Variant& name, TypedValue value) {
  42   return Create(*name.asTypedValue(), value);
  43 }
  44
  45 inline ArrayData* ArrayData::Create(const Variant& name, const Variant& value) {
  46   return Create(*name.asTypedValue(), *value.asTypedValue());
  47 }
  48
  49 ///////////////////////////////////////////////////////////////////////////////
  50 // ArrayFunction dispatch.
  51
  52 inline bool ArrayData::notCyclic(TypedValue v) const {
  53   return !tvIsArrayLike(v) || v.m_data.parr != this;
  54 }
  55
  56 inline ArrayData* ArrayData::copy() const {
  57   return g_array_funcs.copy[kind()](this);
  58 }
  59
  60 inline ArrayData* ArrayData::copyStatic() const {
  61   auto ret = g_array_funcs.copyStatic[kind()](this);
  62   assertx(ret != this && ret->isStatic());
  63   return ret;
  64 }
  65
  66 inline ArrayData* ArrayData::toPHPArray(bool copy) {
  67   return g_array_funcs.toPHPArray[kind()](this, copy);
  68 }
  69
  70 inline ArrayData* ArrayData::toPHPArrayIntishCast(bool copy) {
  71   return g_array_funcs.toPHPArrayIntishCast[kind()](this, copy);
  72 }
  73
  74 inline ArrayData* ArrayData::toDict(bool copy) {
  75   return g_array_funcs.toDict[kind()](this, copy);
  76 }
  77
  78 inline ArrayData* ArrayData::toVec(bool copy) {
  79   return g_array_funcs.toVec[kind()](this, copy);
  80 }
  81
  82 inline ArrayData* ArrayData::toKeyset(bool copy) {
  83   return g_array_funcs.toKeyset[kind()](this, copy);
  84 }
  85
  86 inline ArrayData* ArrayData::toVArray(bool copy) {
  87   return g_array_funcs.toVArray[kind()](this, copy);
  88 }
  89
  90 inline ArrayData* ArrayData::toDArray(bool copy) {
  91   return g_array_funcs.toDArray[kind()](this, copy);
  92 }
  93
  94 inline bool ArrayData::isVectorData() const {
  95   return g_array_funcs.isVectorData[kind()](this);
  96 }
  97
  98 inline void ArrayData::release() noexcept {
  99   assertx(!hasMultipleRefs());
 100   g_array_funcs.release[kind()](this);
 101   AARCH64_WALKABLE_FRAME();
 102 }
 103
 104 inline bool ArrayData::exists(int64_t k) const {
 105   return g_array_funcs.existsInt[kind()](this, k);
 106 }
 107
 108 inline bool ArrayData::exists(const StringData* k) const {
 109   return g_array_funcs.existsStr[kind()](this, k);
 110 }
 111
 112 inline arr_lval ArrayData::lval(int64_t k) {
 113   return g_array_funcs.lvalInt[kind()](this, k);
 114 }
 115
 116 inline arr_lval ArrayData::lval(StringData* k) {
 117   return g_array_funcs.lvalStr[kind()](this, k);
 118 }
 119
 120 inline ssize_t ArrayData::nvGetIntPos(int64_t k) const {
 121   return g_array_funcs.nvGetIntPos[kind()](this, k);
 122 }
 123
 124 inline ssize_t ArrayData::nvGetStrPos(const StringData* k) const {
 125   return g_array_funcs.nvGetStrPos[kind()](this, k);
 126 }
 127
 128 inline TypedValue ArrayData::nvGetKey(ssize_t pos) const {
 129   return g_array_funcs.getPosKey[kind()](this, pos);
 130 }
 131
 132 inline TypedValue ArrayData::nvGetVal(ssize_t pos) const {
 133   return g_array_funcs.getPosVal[kind()](this, pos);
 134 }
 135
 136 inline Variant ArrayData::getKey(ssize_t pos) const {
 137   return Variant::wrap(nvGetKey(pos));
 138 }
 139
 140 inline Variant ArrayData::getValue(ssize_t pos) const {
 141   return Variant::wrap(nvGetVal(pos));
 142 }
 143
 144 inline ArrayData* ArrayData::set(int64_t k, TypedValue v) {
 145   assertx(tvIsPlausible(v));
 146   assertx(cowCheck() || notCyclic(v));
 147   return g_array_funcs.setInt[kind()](this, k, v);
 148 }
 149
 150 inline ArrayData* ArrayData::setMove(int64_t k, TypedValue v) {
 151   assertx(tvIsPlausible(v));
 152   assertx(cowCheck() || notCyclic(v));
 153   return g_array_funcs.setIntMove[kind()](this, k, v);
 154 }
 155
 156 inline ArrayData* ArrayData::set(StringData* k, TypedValue v) {
 157   assertx(tvIsPlausible(v));
 158   assertx(cowCheck() || notCyclic(v));
 159   return g_array_funcs.setStr[kind()](this, k, v);
 160 }
 161
 162 inline ArrayData* ArrayData::setMove(StringData* k, TypedValue v) {
 163   assertx(tvIsPlausible(v));
 164   assertx(cowCheck() || notCyclic(v));
 165   return g_array_funcs.setStrMove[kind()](this, k, v);
 166 }
 167
 168 inline ArrayData* ArrayData::set(int64_t k, const Variant& v) {
 169   auto c = *v.asTypedValue();
 170   assertx(cowCheck() || notCyclic(c));
 171   return g_array_funcs.setInt[kind()](this, k, c);
 172 }
 173
 174 inline ArrayData* ArrayData::set(StringData* k, const Variant& v) {
 175   auto c = *v.asTypedValue();
 176   assertx(cowCheck() || notCyclic(c));
 177   return g_array_funcs.setStr[kind()](this, k, c);
 178 }
 179
 180 inline ArrayData* ArrayData::remove(int64_t k) {
 181   return g_array_funcs.removeInt[kind()](this, k);
 182 }
 183
 184 inline ArrayData* ArrayData::remove(const StringData* k) {
 185   return g_array_funcs.removeStr[kind()](this, k);
 186 }
 187
 188 inline ArrayData* ArrayData::append(TypedValue v) {
 189   assertx(v.m_type != KindOfUninit);
 190   assertx(cowCheck() || notCyclic(v));
 191   return g_array_funcs.append[kind()](this, v);
 192 }
 193
 194 inline ssize_t ArrayData::iter_begin() const {
 195   return g_array_funcs.iterBegin[kind()](this);
 196 }
 197
 198 inline ssize_t ArrayData::iter_last() const {
 199   return g_array_funcs.iterLast[kind()](this);
 200 }
 201
 202 inline ssize_t ArrayData::iter_end() const {
 203   return g_array_funcs.iterEnd[kind()](this);
 204 }
 205
 206 inline ssize_t ArrayData::iter_advance(ssize_t pos) const {
 207   return g_array_funcs.iterAdvance[kind()](this, pos);
 208 }
 209
 210 inline ssize_t ArrayData::iter_rewind(ssize_t pos) const {
 211   return g_array_funcs.iterRewind[kind()](this, pos);
 212 }
 213
 214 inline ArrayData* ArrayData::escalateForSort(SortFunction sf) {
 215   return g_array_funcs.escalateForSort[kind()](this, sf);
 216 }
 217
 218 inline void ArrayData::ksort(int sort_flags, bool ascending) {
 219   return g_array_funcs.ksort[kind()](this, sort_flags, ascending);
 220 }
 221
 222 inline void ArrayData::sort(int sort_flags, bool ascending) {
 223   return g_array_funcs.sort[kind()](this, sort_flags, ascending);
 224 }
 225
 226 inline void ArrayData::asort(int sort_flags, bool ascending) {
 227   return g_array_funcs.asort[kind()](this, sort_flags, ascending);
 228 }
 229
 230 inline bool ArrayData::uksort(const Variant& compare) {
 231   return g_array_funcs.uksort[kind()](this, compare);
 232 }
 233
 234 inline bool ArrayData::usort(const Variant& compare) {
 235   return g_array_funcs.usort[kind()](this, compare);
 236 }
 237
 238 inline bool ArrayData::uasort(const Variant& compare) {
 239   return g_array_funcs.uasort[kind()](this, compare);
 240 }
 241
 242 inline ArrayData* ArrayData::plusEq(const ArrayData* elms) {
 243   return g_array_funcs.plusEq[kind()](this, elms);
 244 }
 245
 246 inline ArrayData* ArrayData::merge(const ArrayData* elms) {
 247   auto ret = g_array_funcs.merge[kind()](this, elms);
 248   assertx(ret->isPHPArrayType());
 249   assertx(ret->isNotDVArray());
 250   return ret;
 251 }
 252
 253 inline ArrayData* ArrayData::pop(Variant& value) {
 254   return g_array_funcs.pop[kind()](this, value);
 255 }
 256
 257 inline ArrayData* ArrayData::dequeue(Variant& value) {
 258   return g_array_funcs.dequeue[kind()](this, value);
 259 }
 260
 261 inline ArrayData* ArrayData::prepend(TypedValue v) {
 262   assertx(v.m_type != KindOfUninit);
 263   return g_array_funcs.prepend[kind()](this, v);
 264 }
 265
 266 inline void ArrayData::onSetEvalScalar() {
 267   return g_array_funcs.onSetEvalScalar[kind()](this);
 268 }
 269
 270 inline ArrayData* ArrayData::renumber() {
 271   return g_array_funcs.renumber[kind()](this);
 272 }
 273
 274 ///////////////////////////////////////////////////////////////////////////////
 275
 276 namespace detail {
 277
 278 inline bool isIntKey(TypedValue cell) {
 279   assertx(isIntType(cell.m_type) || isStringType(cell.m_type));
 280   return isIntType(cell.m_type);
 281 }
 282
 283 inline int64_t getIntKey(TypedValue cell) {
 284   assertx(isIntType(cell.m_type));
 285   return cell.m_data.num;
 286 }
 287
 288 inline StringData* getStringKey(TypedValue cell) {
 289   assertx(isStringType(cell.m_type));
 290   return cell.m_data.pstr;
 291 }
 292
 293 }
 294
 295 ///////////////////////////////////////////////////////////////////////////////
 296 // Element manipulation.
 297
 298 inline bool ArrayData::exists(TypedValue k) const {
 299   assertx(IsValidKey(k));
 300   return detail::isIntKey(k) ? exists(detail::getIntKey(k))
 301                              : exists(detail::getStringKey(k));
 302 }
 303
 304 inline arr_lval ArrayData::lval(TypedValue k) {
 305   assertx(IsValidKey(k));
 306   return detail::isIntKey(k) ? lval(detail::getIntKey(k))
 307                              : lval(detail::getStringKey(k));
 308 }
 309
 310 inline TypedValue ArrayData::get(int64_t k, bool error) const {
 311   auto const result = g_array_funcs.nvGetInt[kind()](this, k);
 312   if (error && !result.is_init()) getNotFound(k);
 313   return result;
 314 }
 315
 316 inline TypedValue ArrayData::get(const StringData* k, bool error) const {
 317   auto const result = g_array_funcs.nvGetStr[kind()](this, k);
 318   if (error && !result.is_init()) getNotFound(k);
 319   return result;
 320 }
 321
 322 inline TypedValue ArrayData::get(TypedValue k, bool error) const {
 323   assertx(IsValidKey(k));
 324   return detail::isIntKey(k) ? get(detail::getIntKey(k), error)
 325                              : get(detail::getStringKey(k), error);
 326 }
 327
 328 inline TypedValue ArrayData::at(int64_t k) const {
 329   auto const result = get(k);
 330   assertx(result.is_init());
 331   return result;
 332 }
 333
 334 inline TypedValue ArrayData::at(const StringData* k) const {
 335   auto const result = get(k);
 336   assertx(result.is_init());
 337   return result;
 338 }
 339
 340 inline TypedValue ArrayData::at(TypedValue k) const {
 341   assertx(IsValidKey(k));
 342   return detail::isIntKey(k) ? at(detail::getIntKey(k))
 343                              : at(detail::getStringKey(k));
 344 }
 345
 346 inline ArrayData* ArrayData::set(TypedValue k, TypedValue v) {
 347   assertx(tvIsPlausible(k));
 348   assertx(tvIsPlausible(v));
 349   assertx(IsValidKey(k));
 350
 351   return detail::isIntKey(k) ? set(detail::getIntKey(k), v)
 352                              : set(detail::getStringKey(k), v);
 353 }
 354
 355 inline ArrayData* ArrayData::remove(TypedValue k) {
 356   assertx(IsValidKey(k));
 357   return detail::isIntKey(k) ? remove(detail::getIntKey(k))
 358                              : remove(detail::getStringKey(k));
 359 }
 360
 361 ///////////////////////////////////////////////////////////////////////////////
 362
 363 inline bool ArrayData::exists(const String& k) const {
 364   assertx(IsValidKey(k));
 365   return exists(k.get());
 366 }
 367
 368 inline bool ArrayData::exists(const Variant& k) const {
 369   return exists(*k.asTypedValue());
 370 }
 371
 372 inline arr_lval ArrayData::lval(const String& k) {
 373   assertx(IsValidKey(k));
 374   return lval(k.get());
 375 }
 376
 377 inline arr_lval ArrayData::lval(const Variant& k) {
 378   return lval(*k.asTypedValue());
 379 }
 380
 381 inline TypedValue ArrayData::get(const String& k, bool error) const {
 382   assertx(IsValidKey(k));
 383   return get(k.get(), error);
 384 }
 385
 386 inline TypedValue ArrayData::get(const Variant& k, bool error) const {
 387   return get(*k.asTypedValue(), error);
 388 }
 389
 390 inline ArrayData* ArrayData::set(const String& k, TypedValue v) {
 391   assertx(tvIsPlausible(v));
 392   assertx(IsValidKey(k));
 393   return set(k.get(), v);
 394 }
 395
 396 inline ArrayData* ArrayData::set(const String& k, const Variant& v) {
 397   return set(k, *v.asTypedValue());
 398 }
 399
 400 inline ArrayData* ArrayData::set(const Variant& k, const Variant& v) {
 401   return set(*k.asTypedValue(), *v.asTypedValue());
 402 }
 403
 404 inline ArrayData* ArrayData::remove(const String& k) {
 405   assertx(IsValidKey(k));
 406   return remove(k.get());
 407 }
 408
 409 inline ArrayData* ArrayData::remove(const Variant& k) {
 410   return remove(*k.asTypedValue());
 411 }
 412
 413 ///////////////////////////////////////////////////////////////////////////////
 414
 415 template <IntishCast IC>
 416 ALWAYS_INLINE bool ArrayData::convertKey(const StringData* key,
 417                                          int64_t& i) const {
 418   return IC == IntishCast::Cast &&
 419          key->isStrictlyInteger(i) &&
 420          useWeakKeys();
 421 }
 422
 423 template <IntishCast IC>
 424 ALWAYS_INLINE
 425 folly::Optional<int64_t> tryIntishCast(const StringData* key) {
 426   int64_t i;
 427   if (UNLIKELY(IC == IntishCast::Cast &&
 428                key->isStrictlyInteger(i))) {
 429     return i;
 430   }
 431   return {};
 432 }
 433
 434 ///////////////////////////////////////////////////////////////////////////////
 435
 436 }
 437
 438 #endif