C++ (Cpp) reseatable Examples

Example #1

File: proxy-array.cpp Project: duxet/hhvm

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

Example #2

File: proxy-array.cpp Project: LouisRenWeiWei/hhvm

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

Example #3

File: proxy-array.cpp Project: LouisRenWeiWei/hhvm

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

Example #4

File: proxy-array.cpp Project: LouisRenWeiWei/hhvm

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

Example #5

File: proxy-array.cpp Project: nurulimamnotes/hhvm

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

Example #6

File: proxy-array.cpp Project: nurulimamnotes/hhvm

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

Example #7

File: proxy-array.cpp Project: MatmaRex/hhvm

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

Example #8

File: proxy-array.cpp Project: MatmaRex/hhvm

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

Example #9

File: proxy-array.cpp Project: nurulimamnotes/hhvm

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

Example #10

File: proxy-array.cpp Project: KOgames/hhvm

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

Example #11

File: proxy-array.cpp Project: MatmaRex/hhvm

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

Example #12

File: proxy-array.cpp Project: nurulimamnotes/hhvm

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

Example #13

File: proxy-array.cpp Project: MatmaRex/hhvm

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

Example #14

File: proxy-array.cpp Project: nurulimamnotes/hhvm

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

Example #15

File: proxy-array.cpp Project: MatmaRex/hhvm

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

Example #16

File: proxy-array.cpp Project: MatmaRex/hhvm

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

Example #17

File: proxy-array.cpp Project: BwRy/hhvm

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

Example #18

File: proxy-array.cpp Project: MatmaRex/hhvm

ArrayData* ProxyArray::ZAppend(ArrayData* ad, RefData* v, int64_t* key_ptr) {
  auto r = innerArr(ad)->zAppend(v, key_ptr);
  reseatable(ad, r);
  return ad;
}

Example #19

File: proxy-array.cpp Project: MatmaRex/hhvm

ArrayData* ProxyArray::ToKeyset(ArrayData* ad, bool copy) {
  auto const r = innerArr(ad)->toKeyset(innerArr(ad)->cowCheck());
  reseatable(ad, r);
  return const_cast<ArrayData*>(ad);
}

Example #20

File: proxy-array.cpp Project: MatmaRex/hhvm

ArrayData* ProxyArray::ZSetInt(ArrayData* ad, int64_t k, RefData* v) {
  auto const r = innerArr(ad)->zSet(k, v);
  reseatable(ad, r);
  return ad;
}

Example #21

File: proxy-array.cpp Project: MatmaRex/hhvm

ArrayData* ProxyArray::ZSetStr(ArrayData* ad, StringData* k, RefData* v) {
  auto r = innerArr(ad)->zSet(k, v);
  reseatable(ad, r);
  return ad;
}

Example #22

File: proxy-array.cpp Project: MatmaRex/hhvm

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

Example #23

File: proxy-array.cpp Project: MatmaRex/hhvm

bool ProxyArray::Uasort(ArrayData* ad, const Variant& cmp_function) {
  reseatable(ad, innerArr(ad)->escalateForSort(SORTFUNC_UASORT));
  return innerArr(ad)->uasort(cmp_function);
}

Example #24

File: proxy-array.cpp Project: MatmaRex/hhvm

ArrayData* ProxyArray::EscalateForSort(ArrayData* ad, SortFunction sf) {
  auto const r = innerArr(ad)->escalateForSort(sf);
  reseatable(ad, r);
  return ad;
}

Example #25

File: proxy-array.cpp Project: BwRy/hhvm

bool ProxyArray::Usort(ArrayData* ad, const Variant& cmp_function) {
  ad = reseatable(ad, innerArr(ad)->escalateForSort());
  return innerArr(ad)->usort(cmp_function);
}

Example #26

File: proxy-array.cpp Project: MatmaRex/hhvm

ArrayData* ProxyArray::Pop(ArrayData* ad, Variant &value) {
  auto const r = innerArr(ad)->pop(value);
  reseatable(ad, r);
  return ad;
}

Example #27

File: proxy-array.cpp Project: MatmaRex/hhvm

ArrayData* ProxyArray::ToVec(ArrayData* ad, bool copy) {
  auto const r = innerArr(ad)->toVec(innerArr(ad)->cowCheck());
  reseatable(ad, r);
  return ad;
}

Example #28

File: proxy-array.cpp Project: MatmaRex/hhvm

ArrayData* ProxyArray::Dequeue(ArrayData* ad, Variant &value) {
  auto const r = innerArr(ad)->dequeue(value);
  reseatable(ad, r);
  return ad;
}

Example #29

File: proxy-array.cpp Project: MatmaRex/hhvm

ArrayData*
ProxyArray::Merge(ArrayData* ad, const ArrayData* elems) {
  auto const r = innerArr(ad)->merge(elems);
  reseatable(ad, r);
  return ad;
}

Example #30

File: proxy-array.cpp Project: MatmaRex/hhvm

ArrayData* ProxyArray::Escalate(const ArrayData* ad) {
  auto const r = innerArr(ad)->escalate();
  reseatable(ad, r);
  return const_cast<ArrayData*>(ad);
}