wellton/hhvm
1
0
Fork 0
Código Issues Pull Requests Ações Pacotes Projetos Versões Wiki Atividade

Remove bool key overloads from Array smart pointer

Ver Código-Fonte 
They were dead code.  Removed weakRemove() methods, also dead code.
More importantly, foo("something") binds to foo(bool) if there
is no foo(litstr), so this avoids accidentally calling the wrong
overload as I'm ripping out litstr overloads.
Esse commit está contido em:
smith
2013-04-18 13:57:48 -07:00
commit de Sara Golemon
pai 37e49ba6e4
commit 46f11e95d0
5 arquivos alterados com 0 adições e 159 exclusões
Baixar Arquivo de Patch Baixar Arquivo de Diff Expandir todos os arquivos Colapsar todos os arquivos
hphp/runtime/base/type_array.cpp
-10
Ver Arquivo
@@ -414,16 +414,6 @@ void Array::escalate() {
///////////////////////////////////////////////////////////////////////////////
// offset functions
Variant Array::rvalAt(bool key, ACCESSPARAMS_IMPL) const {
if (m_px) return m_px->get(key ? 1LL : 0LL, flags & AccessFlags::Error);
return null_variant;
}
CVarRef Array::rvalAtRef(bool key, ACCESSPARAMS_IMPL) const {
if (m_px) return m_px->get(key ? 1LL : 0LL, flags & AccessFlags::Error);
return null_variant;
}
Variant Array::rvalAt(int key, ACCESSPARAMS_IMPL) const {
if (m_px) return m_px->get((int64_t)key, flags & AccessFlags::Error);
return null_variant;
hphp/runtime/base/type_array.h
-37
Ver Arquivo
@@ -260,7 +260,6 @@ class Array : protected ArrayBase {
/**
* Offset
*/
Variant rvalAt(bool key, ACCESSPARAMS_DECL) const;
Variant rvalAt(int key, ACCESSPARAMS_DECL) const;
Variant rvalAt(int64_t key, ACCESSPARAMS_DECL) const;
Variant rvalAt(double key, ACCESSPARAMS_DECL) const;
@@ -271,7 +270,6 @@ class Array : protected ArrayBase {
/**
* To get offset for temporary usage
*/
CVarRef rvalAtRef(bool key, ACCESSPARAMS_DECL) const;
CVarRef rvalAtRef(int key, ACCESSPARAMS_DECL) const;
CVarRef rvalAtRef(int64_t key, ACCESSPARAMS_DECL) const;
CVarRef rvalAtRef(double key, ACCESSPARAMS_DECL) const;
@@ -279,7 +277,6 @@ class Array : protected ArrayBase {
CVarRef rvalAtRef(CVarRef key, ACCESSPARAMS_DECL) const;
CVarRef rvalAtRef(CStrRef key, ACCESSPARAMS_DECL) const;
const Variant operator[](bool key) const;
const Variant operator[](int key) const;
const Variant operator[](int64_t key) const;
const Variant operator[](double key) const;
@@ -309,9 +306,6 @@ class Array : protected ArrayBase {
Variant &lvalAt();
Variant &lvalAt(bool key, ACCESSPARAMS_DECL) {
return lvalAtImpl(key, flags);
}
Variant &lvalAt(int key, ACCESSPARAMS_DECL) {
return lvalAtImpl(key, flags);
}
@@ -331,9 +325,6 @@ class Array : protected ArrayBase {
template<typename T>
CVarRef setRefImpl(const T &key, CVarRef v);
CVarRef set(bool key, CVarRef v) {
return set(int64_t(key ? 1 : 0), v);
}
CVarRef set(int key, CVarRef v) {
return set((int64_t)key, v);
}
@@ -346,7 +337,6 @@ class Array : protected ArrayBase {
CVarRef set(CStrRef key, CVarRef v, bool isKey = false);
CVarRef set(CVarRef key, CVarRef v, bool isKey = false);
CVarRef set(bool key, RefResult v) { return setRef(key,variant(v)); }
CVarRef set(char key, RefResult v) { return setRef(key,variant(v)); }
CVarRef set(short key, RefResult v) { return setRef(key,variant(v)); }
CVarRef set(int key, RefResult v) { return setRef(key,variant(v)); }
@@ -363,9 +353,6 @@ class Array : protected ArrayBase {
return setRef(key,variant(v), isKey);
}
CVarRef setRef(bool key, CVarRef v) {
return setRef((int64_t)key, v);
}
CVarRef setRef(int key, CVarRef v) {
return setRef((int64_t)key, v);
}
@@ -382,9 +369,6 @@ class Array : protected ArrayBase {
template<typename T>
CVarRef addImpl(const T &key, CVarRef v);
CVarRef add(bool key, CVarRef v) {
return add((int64_t)key, v);
}
CVarRef add(int key, CVarRef v) {
return add((int64_t)key, v);
}
@@ -408,9 +392,6 @@ class Array : protected ArrayBase {
return *ret;
}
Variant &addLval(bool key) {
return addLvalImpl(key ? 1LL : 0LL);
}
Variant &addLval(int key) {
return addLvalImpl((int64_t)key);
}
@@ -433,9 +414,6 @@ class Array : protected ArrayBase {
if (m_px) return m_px->exists(key);
return false;
}
bool exists(bool key) const {
return existsImpl(key ? 1LL : 0LL);
}
bool exists(char key) const {
return existsImpl((int64_t)key);
}
@@ -462,9 +440,6 @@ class Array : protected ArrayBase {
if (escalated != m_px) ArrayBase::operator=(escalated);
}
}
void remove(bool key) {
removeImpl(key ? 1LL : 0LL);
}
void remove(char key) {
removeImpl((int64_t)key);
}
@@ -484,18 +459,6 @@ class Array : protected ArrayBase {
void remove(CStrRef key, bool isString = false);
void remove(CVarRef key);
void weakRemove(litstr key, bool isString = false) {
remove(key, isString);
}
void weakRemove(CStrRef key, bool isString = false) {
remove(key, isString);
}
template<typename T>
void weakRemove(const T &key) {
remove(key);
}
void removeAll();
void clear() { removeAll();}
hphp/runtime/base/type_variant.cpp
-50
Ver Arquivo
@@ -68,7 +68,6 @@ static StaticString s_PHP_Incomplete_Class_Name("__PHP_Incomplete_Class_Name");
///////////////////////////////////////////////////////////////////////////////
// local helpers
static int64_t ToKey(bool i) { return (int64_t)i; }
static int64_t ToKey(int64_t i) { return i; }
static VarNR ToKey(CStrRef s) { return s.toKey(); }
static VarNR ToKey(CVarRef v) { return v.toKey(); }
@@ -1883,9 +1882,6 @@ static void raise_bad_offset_notice() {
} \
return null_variant;
Variant Variant::rvalAt(bool offset, ACCESSPARAMS_IMPL) const {
IMPLEMENT_RVAL_INTEGRAL
}
Variant Variant::rvalAt(double offset, ACCESSPARAMS_IMPL) const {
IMPLEMENT_RVAL_INTEGRAL
}
@@ -2065,13 +2061,6 @@ CVarRef Variant::rvalRefHelper(T offset, CVarRef tmp, ACCESSPARAMS_IMPL) const {
template CVarRef
Variant::rvalRefHelper(int64_t offset, CVarRef tmp, ACCESSPARAMS_IMPL) const;
CVarRef Variant::rvalRef(bool offset, CVarRef tmp, ACCESSPARAMS_IMPL) const {
if (m_type == KindOfArray) {
return m_data.parr->get(ToKey(offset), flags & AccessFlags::Error);
}
return rvalRefHelper(offset, tmp, flags);
}
CVarRef Variant::rvalRef(double offset, CVarRef tmp, ACCESSPARAMS_IMPL) const {
if (m_type == KindOfArray) {
return m_data.parr->get(ToKey(offset), flags & AccessFlags::Error);
@@ -2254,9 +2243,6 @@ Variant& Variant::lvalAtImpl(T key, ACCESSPARAMS_IMPL) {
return Variant::LvalAtImpl0<T>(this, key, nullptr, true, flags);
}
Variant &Variant::lvalAt(bool key, ACCESSPARAMS_IMPL) {
return lvalAtImpl(key, flags);
}
Variant &Variant::lvalAt(int key, ACCESSPARAMS_IMPL) {
return lvalAt((int64_t)key, flags);
}
@@ -2277,9 +2263,6 @@ Variant &Variant::lvalAt(CVarRef k, ACCESSPARAMS_IMPL) {
return lvalAtImpl<CVarRef>(k, flags);
}
Variant &Variant::lvalRef(bool key, Variant& tmp, ACCESSPARAMS_IMPL) {
return LvalAtImpl0(this, key, &tmp, false, flags);
}
Variant &Variant::lvalRef(int key, Variant& tmp, ACCESSPARAMS_IMPL) {
return lvalRef((int64_t)key, tmp, flags);
}
@@ -2504,10 +2487,6 @@ inline ALWAYS_INLINE CVarRef Variant::SetImpl(Variant *self, T key,
return v;
}
CVarRef Variant::set(bool key, CVarRef v) {
return SetImpl(this, key, v, false);
}
CVarRef Variant::set(int64_t key, CVarRef v) {
return SetImpl(this, key, v, false);
}
@@ -2633,10 +2612,6 @@ inline ALWAYS_INLINE CVarRef Variant::SetRefImpl(Variant *self, T key,
return v;
}
CVarRef Variant::setRef(bool key, CVarRef v) {
return SetRefImpl(this, key, v, false);
}
CVarRef Variant::setRef(int64_t key, CVarRef v) {
return SetRefImpl(this, key, v, false);
}
@@ -2749,31 +2724,6 @@ void Variant::removeImpl(int64_t key) {
}
}
void Variant::removeImpl(bool key) {
switch (getType()) {
case KindOfUninit:
case KindOfNull:
break;
case KindOfArray:
{
ArrayData *arr = getArrayData();
if (arr) {
ArrayData *escalated = arr->remove(ToKey(key), (arr->getCount() > 1));
if (escalated != arr) {
set(escalated);
}
}
}
break;
case KindOfObject:
callOffsetUnset(key);
break;
default:
lvalInvalid();
break;
}
}
void Variant::removeImpl(CVarRef key, bool isString /* false */) {
switch (getType()) {
case KindOfUninit:
hphp/runtime/base/type_variant.h
-54
Ver Arquivo
@@ -794,7 +794,6 @@ class Variant : private VariantBase {
* Offset functions
*/
Variant rvalAtHelper(int64_t offset, ACCESSPARAMS_DECL) const;
Variant rvalAt(bool offset, ACCESSPARAMS_DECL) const;
Variant rvalAt(int offset, ACCESSPARAMS_DECL) const {
return rvalAt((int64_t)offset, flags);
}
@@ -821,7 +820,6 @@ class Variant : private VariantBase {
}
return rvalRefHelper(offset, tmp, flags);
}
CVarRef rvalRef(bool offset, CVarRef tmp, ACCESSPARAMS_DECL) const;
CVarRef rvalRef(double offset, CVarRef tmp, ACCESSPARAMS_DECL) const;
CVarRef rvalRef(litstr offset, CVarRef tmp, ACCESSPARAMS_DECL) const;
CVarRef rvalRef(CStrRef offset, CVarRef tmp, ACCESSPARAMS_DECL) const;
@@ -830,9 +828,6 @@ class Variant : private VariantBase {
// for when we know its an array or null
template <typename T>
CVarRef rvalAtRefHelper(T offset, ACCESSPARAMS_DECL) const;
CVarRef rvalAtRef(bool offset, ACCESSPARAMS_DECL) const {
return rvalAtRefHelper((int64_t)offset, flags);
}
CVarRef rvalAtRef(int offset, ACCESSPARAMS_DECL) const {
return rvalAtRefHelper((int64_t)offset, flags);
}
@@ -846,7 +841,6 @@ class Variant : private VariantBase {
CVarRef rvalAtRef(CVarRef offset, ACCESSPARAMS_DECL) const {
return rvalAtRefHelper<CVarRef>(offset, flags);
}
const Variant operator[](bool key) const { return rvalAt(key);}
const Variant operator[](int key) const { return rvalAt(key);}
const Variant operator[](int64_t key) const { return rvalAt(key);}
const Variant operator[](double key) const { return rvalAt(key);}
@@ -878,7 +872,6 @@ class Variant : private VariantBase {
static Variant &lvalInvalid();
static Variant &lvalBlackHole();
Variant &lvalAt(bool key, ACCESSPARAMS_DECL);
Variant &lvalAt(int key, ACCESSPARAMS_DECL);
Variant &lvalAt(int64_t key, ACCESSPARAMS_DECL);
Variant &lvalAt(double key, ACCESSPARAMS_DECL);
@@ -886,7 +879,6 @@ class Variant : private VariantBase {
Variant &lvalAt(CStrRef key, ACCESSPARAMS_DECL);
Variant &lvalAt(CVarRef key, ACCESSPARAMS_DECL);
Variant &lvalRef(bool key, Variant& tmp, ACCESSPARAMS_DECL);
Variant &lvalRef(int key, Variant& tmp, ACCESSPARAMS_DECL);
Variant &lvalRef(int64_t key, Variant& tmp, ACCESSPARAMS_DECL);
Variant &lvalRef(double key, Variant& tmp, ACCESSPARAMS_DECL);
@@ -914,7 +906,6 @@ class Variant : private VariantBase {
inline ALWAYS_INLINE static CVarRef SetRefImpl(
Variant *self, T key, CVarRef v, bool isKey);
CVarRef set(bool key, CVarRef v);
CVarRef set(int key, CVarRef v) { return set((int64_t)key, v); }
CVarRef set(int64_t key, CVarRef v);
CVarRef set(double key, CVarRef v);
@@ -926,7 +917,6 @@ class Variant : private VariantBase {
CVarRef append(CVarRef v);
CVarRef setRef(bool key, CVarRef v);
CVarRef setRef(int key, CVarRef v) { return setRef((int64_t)key, v); }
CVarRef setRef(int64_t key, CVarRef v);
CVarRef setRef(double key, CVarRef v);
@@ -936,7 +926,6 @@ class Variant : private VariantBase {
CVarRef setRef(CStrRef key, CVarRef v, bool isString = false);
CVarRef setRef(CVarRef key, CVarRef v);
CVarRef set(bool key, RefResult v) { return setRef(key, variant(v)); }
CVarRef set(int key, RefResult v) { return setRef(key, variant(v)); }
CVarRef set(int64_t key, RefResult v) { return setRef(key, variant(v)); }
CVarRef set(double key, RefResult v) { return setRef(key, variant(v)); }
@@ -951,7 +940,6 @@ class Variant : private VariantBase {
CVarRef appendRef(CVarRef v);
CVarRef append(RefResult v) { return appendRef(variant(v)); }
void remove(bool key) { removeImpl(key);}
void remove(int key) { removeImpl((int64_t)key);}
void remove(int64_t key) { removeImpl(key);}
void remove(double key) { removeImpl(key);}
@@ -963,43 +951,6 @@ class Variant : private VariantBase {
}
void remove(CVarRef key);
void weakRemove(litstr key, bool isStr = false) {
if (is(KindOfArray) ||
(is(KindOfObject) && getObjectData()->supportsUnsetElem())) {
remove(key, isStr);
return;
}
if (isString()) {
raise_error("Cannot unset string offsets");
return;
}
}
void weakRemove(CStrRef key, bool isStr = false) {
if (is(KindOfArray) ||
(is(KindOfObject) && getObjectData()->supportsUnsetElem())) {
remove(key, isStr);
return;
}
if (isString()) {
raise_error("Cannot unset string offsets");
return;
}
}
template<typename T>
void weakRemove(const T &key) {
if (is(KindOfArray) ||
(is(KindOfObject) && getObjectData()->supportsUnsetElem())) {
remove(key);
return;
}
if (isString()) {
raise_error("Cannot unset string offsets");
return;
}
}
/**
* More array operations.
*/
@@ -1173,7 +1124,6 @@ class Variant : private VariantBase {
void removeImpl(double key);
void removeImpl(int64_t key);
void removeImpl(bool key);
void removeImpl(CVarRef key, bool isString = false);
void removeImpl(CStrRef key, bool isString = false);
@@ -1534,10 +1484,6 @@ private:
///////////////////////////////////////////////////////////////////////////////
// breaking circular dependencies
inline const Variant Array::operator[](bool key) const {
return rvalAt(key);
}
inline const Variant Array::operator[](int key) const {
return rvalAt(key);
}
hphp/test/test_cpp_base.cpp
-8
Ver Arquivo
@@ -284,14 +284,6 @@ bool TestCppBase::TestArray() {
}
VERIFY(i == 2);
}
{
Variant arr = CREATE_MAP1("n1", "v1");
Variant k, v;
for (MutableArrayIter iter = arr.begin(&k, v); iter.advance();) {
arr.weakRemove(k);
}
VS(arr, Array::Create());
}
/* TODO: fix this
{
Variant arr = CREATE_MAP2("n1", "v1", "n2", "v2");