ArrayData *SharedMap::lvalNew(Variant *&ret, bool copy) {
ArrayData *escalated = SharedMap::escalate();
return releaseIfCopied(escalated, escalated->lvalNew(ret, false));
}
bool Globals::setFullPos(const FullPos &pos) {
ArrayData *arr = Array::get();
return arr->setFullPos(pos);
}
ArrayData *SharedMap::LvalStr(ArrayData* ad, StringData* k, Variant *&ret,
bool copy) {
ArrayData *escalated = Escalate(ad);
return releaseIfCopied(escalated, escalated->lval(k, ret, false));
}
ArrayData*
APCLocalArray::RemoveStr(ArrayData* ad, const StringData* k, bool copy) {
ArrayData *escalated = Escalate(ad);
return releaseIfCopied(escalated, escalated->remove(k, false));
}
ArrayData *APCLocalArray::Prepend(ArrayData* ad, const Variant& v, bool copy) {
ArrayData *escalated = Escalate(ad);
return releaseIfCopied(escalated, escalated->prepend(v, false));
}
ArrayData *APCLocalArray::LvalInt(ArrayData* ad, int64_t k, Variant *&ret,
bool copy) {
ArrayData *escalated = Escalate(ad);
return releaseIfCopied(escalated, escalated->lval(k, ret, false));
}
ArrayData*
APCLocalArray::SetRefStr(ArrayData* ad, StringData* k, const Variant& v, bool copy) {
ArrayData *escalated = Escalate(ad);
return releaseIfCopied(escalated, escalated->setRef(k, v, false));
}
ArrayData *SharedMap::escalate() const {
ArrayData *ret = loadElems();
assert(!ret->isStatic());
return ret;
}
ArrayData* SharedMap::escalateForSort() {
ArrayData *ret = loadElems(true /* mapInit */);
assert(!ret->isStatic());
return ret;
}
ArrayData *SharedMap::merge(const ArrayData *elems, bool copy) {
ArrayData *escalated = SharedMap::escalate();
return releaseIfCopied(escalated, escalated->merge(elems, false));
}
ArrayData *SharedMap::prepend(CVarRef v, bool copy) {
ArrayData *escalated = SharedMap::escalate();
return releaseIfCopied(escalated, escalated->prepend(v, false));
}
ArrayData *SharedMap::appendWithRef(CVarRef v, bool copy) {
ArrayData *escalated = SharedMap::escalate();
return releaseIfCopied(escalated, escalated->appendWithRef(v, false));
}
ArrayData *SharedMap::remove(const StringData* k, bool copy) {
ArrayData *escalated = SharedMap::escalate();
return releaseIfCopied(escalated, escalated->remove(k, false));
}
ArrayData *SharedMap::setRef(StringData* k, CVarRef v, bool copy) {
ArrayData *escalated = SharedMap::escalate();
return releaseIfCopied(escalated, escalated->setRef(k, v, false));
}
ALWAYS_INLINE static
int64_t extract_impl(VRefParam vref_array,
int extract_type /* = EXTR_OVERWRITE */,
const String& prefix /* = "" */) {
auto arrByRef = false;
auto arr_tv = vref_array.wrapped().asTypedValue();
if (arr_tv->m_type == KindOfRef) {
arr_tv = arr_tv->m_data.pref->tv();
arrByRef = true;
}
if (!isArrayType(arr_tv->m_type)) {
raise_warning("extract() expects parameter 1 to be array");
return 0;
}
bool reference = extract_type & EXTR_REFS;
extract_type &= ~EXTR_REFS;
VMRegAnchor _;
auto const varEnv = g_context->getOrCreateVarEnv();
if (!varEnv) return 0;
auto& carr = tvAsCVarRef(arr_tv).asCArrRef();
if (UNLIKELY(reference)) {
auto extr_refs = [&](Array& arr) {
if (arr.size() > 0) {
// force arr to escalate (if necessary) by getting an lvalue to the
// first element.
ArrayData* ad = arr.get();
auto const& first_key = ad->getKey(ad->iter_begin());
arr.lvalAt(first_key);
}
int count = 0;
for (ArrayIter iter(arr); iter; ++iter) {
auto name = iter.first().toString();
if (!modify_extract_name(varEnv, name, extract_type, prefix)) continue;
// The const_cast is safe because we escalated the array. We can't use
// arr.lvalAt(name), because arr may have been modified as a side
// effect of an earlier iteration.
auto& ref = const_cast<Variant&>(iter.secondRef());
g_context->bindVar(name.get(), ref.asTypedValue());
++count;
}
return count;
};
if (arrByRef) {
return extr_refs(tvAsVariant(vref_array.getRefData()->tv()).asArrRef());
}
Array tmp = carr;
return extr_refs(tmp);
}
int count = 0;
for (ArrayIter iter(carr); iter; ++iter) {
auto name = iter.first().toString();
if (!modify_extract_name(varEnv, name, extract_type, prefix)) continue;
g_context->setVar(name.get(), iter.secondRef().asTypedValue());
++count;
}
return count;
}
void tvCastToArrayInPlace(TypedValue* tv) {
assert(tvIsPlausible(*tv));
tvUnboxIfNeeded(tv);
ArrayData* a;
do {
switch (tv->m_type) {
case KindOfUninit:
case KindOfNull:
a = ArrayData::Create();
continue;
case KindOfBoolean:
case KindOfInt64:
case KindOfDouble:
case KindOfPersistentString:
a = ArrayData::Create(tvAsVariant(tv));
continue;
case KindOfString:
a = ArrayData::Create(tvAsVariant(tv));
tvDecRefStr(tv);
continue;
case KindOfPersistentVec: {
auto* adIn = tv->m_data.parr;
assert(adIn->isVecArray());
a = PackedArray::ToPHPArrayVec(adIn, true);
assert(a != adIn);
continue;
}
case KindOfVec: {
auto* adIn = tv->m_data.parr;
assert(adIn->isVecArray());
a = PackedArray::ToPHPArrayVec(adIn, adIn->cowCheck());
if (a != adIn) tvDecRefArr(tv);
continue;
}
case KindOfPersistentDict: {
auto* adIn = tv->m_data.parr;
assert(adIn->isDict());
a = MixedArray::ToPHPArrayDict(adIn, true);
assert(a != adIn);
continue;
}
case KindOfDict: {
auto* adIn = tv->m_data.parr;
assert(adIn->isDict());
a = MixedArray::ToPHPArrayDict(adIn, adIn->cowCheck());
if (a != adIn) tvDecRefArr(tv);
continue;
}
case KindOfPersistentKeyset: {
auto* adIn = tv->m_data.parr;
assert(adIn->isKeyset());
a = MixedArray::ToPHPArrayKeyset(adIn, true);
assert(a != adIn);
continue;
}
case KindOfKeyset: {
auto* adIn = tv->m_data.parr;
assert(adIn->isKeyset());
a = MixedArray::ToPHPArrayKeyset(adIn, adIn->cowCheck());
if (a != adIn) tvDecRefArr(tv);
continue;
}
case KindOfPersistentArray:
case KindOfArray:
assert(tv->m_data.parr->isPHPArray());
return;
case KindOfObject:
// For objects, we fall back on the Variant machinery
tvAsVariant(tv) = tv->m_data.pobj->toArray();
return;
case KindOfResource:
a = ArrayData::Create(tvAsVariant(tv));
tvDecRefRes(tv);
continue;
case KindOfRef:
case KindOfClass:
break;
}
not_reached();
} while (0);
assert(!a->isRefCounted() || a->hasExactlyOneRef());
tv->m_data.parr = a;
tv->m_type = KindOfArray;
assert(cellIsPlausible(*tv));
}
ArrayData *SharedMap::escalate(bool mutableIteration /* = false */) const {
ArrayData *ret = NULL;
m_arr->loadElems(ret, *this, mutableIteration);
ASSERT(!ret->isStatic());
return ret;
}
void tvCastToKeysetInPlace(TypedValue* tv) {
assert(tvIsPlausible(*tv));
tvUnboxIfNeeded(tv);
ArrayData* a;
do {
switch (tv->m_type) {
case KindOfUninit:
case KindOfNull:
raise_warning("Null to keyset conversion");
a = staticEmptyKeysetArray();
continue;
case KindOfBoolean:
raise_warning("Bool to keyset conversion");
a = staticEmptyKeysetArray();
continue;
case KindOfInt64:
raise_warning("Int to keyset conversion");
a = staticEmptyKeysetArray();
continue;
case KindOfDouble:
raise_warning("Double to keyset conversion");
a = staticEmptyKeysetArray();
continue;
case KindOfPersistentString:
case KindOfString:
raise_warning("String to keyset conversion");
a = staticEmptyKeysetArray();
decRefStr(tv->m_data.pstr);
continue;
case KindOfResource:
raise_warning("Resource to keyset conversion");
a = staticEmptyKeysetArray();
decRefRes(tv->m_data.pres);
continue;
case KindOfPersistentVec:
case KindOfVec: {
auto* adIn = tv->m_data.parr;
assert(adIn->isVecArray());
a = PackedArray::ToKeysetVec(adIn, adIn->cowCheck());
assert(a != adIn);
decRefArr(adIn);
continue;
}
case KindOfPersistentDict:
case KindOfDict: {
auto* adIn = tv->m_data.parr;
assert(adIn->isDict());
a = MixedArray::ToKeysetDict(adIn, adIn->cowCheck());
if (a != adIn) decRefArr(adIn);
continue;
}
case KindOfPersistentArray:
case KindOfArray: {
auto* adIn = tv->m_data.parr;
assert(adIn->isPHPArray());
a = adIn->toKeyset(adIn->cowCheck());
if (a != adIn) decRefArr(adIn);
continue;
}
case KindOfPersistentKeyset:
case KindOfKeyset:
assert(tv->m_data.parr->isKeyset());
return;
case KindOfObject: {
auto* obj = tv->m_data.pobj;
if (!obj->isCollection()) {
raise_warning("Non-collection object conversion to keyset");
a = staticEmptyKeysetArray();
} else {
auto keyset = collections::toArray(obj).toKeyset();
decRefObj(obj);
a = keyset.detach();
}
continue;
}
case KindOfRef:
case KindOfClass:
break;
}
not_reached();
} while (0);
assert(!a->isRefCounted() || a->hasExactlyOneRef());
tv->m_data.parr = a;
tv->m_type = KindOfKeyset;
assert(cellIsPlausible(*tv));
}
ArrayData*
APCLocalArray::SetInt(ArrayData* ad, int64_t k, const Variant& v, bool copy) {
ArrayData *escalated = Escalate(ad);
return releaseIfCopied(escalated, escalated->set(k, v, false));
}
void ArrayDataTest::testproperty_Properties()
{
string id = "file_id";
ArrayData array;
array.ArraySetFileIdentifier() = id;
CPPUNIT_ASSERT(array.ArraySetFileIdentifier() == id);
array.DataTypeIdentifier() = "affymetrix-calvin-arraysetfile";
CPPUNIT_ASSERT(array.DataTypeIdentifier() == "affymetrix-calvin-arraysetfile");
array.CreatedStep() = ArrayRegistrationStep;
CPPUNIT_ASSERT(array.CreatedStep() == ArrayRegistrationStep);
array.InitialProject() = L"none";
CPPUNIT_ASSERT(array.InitialProject() == L"none");
array.CreationDateTime() = L"now";
CPPUNIT_ASSERT(array.CreationDateTime() == L"now");
array.CreatedBy() = L"me";
CPPUNIT_ASSERT(array.CreatedBy() == L"me");
}
ArrayData *APCLocalArray::RemoveInt(ArrayData* ad, int64_t k, bool copy) {
ArrayData *escalated = Escalate(ad);
return releaseIfCopied(escalated, escalated->remove(k, false));
}
void ArrayDataTest::testmethod_Clear()
{
string id = "file_id";
ArrayData array;
array.ArraySetFileIdentifier() = id;
array.PhysicalArraysAttributes().resize(2);
array.UserAttributes().resize(4);
array.DataTypeIdentifier() = "affymetrix-calvin-arraysetfile";
array.CreatedStep() = ArrayRegistrationStep;
array.InitialProject() = L"none";
array.CreationDateTime() = L"now";
array.CreatedBy() = L"me";
array.Clear();
CPPUNIT_ASSERT(array.ArraySetFileIdentifier() == "");
CPPUNIT_ASSERT(array.PhysicalArraysAttributes().size() == 0);
CPPUNIT_ASSERT(array.UserAttributes().size() == 0);
CPPUNIT_ASSERT(array.DataTypeIdentifier() == "");
CPPUNIT_ASSERT(array.CreatedStep() == NoStep);
CPPUNIT_ASSERT(array.InitialProject() == L"");
CPPUNIT_ASSERT(array.CreationDateTime() == L"");
CPPUNIT_ASSERT(array.CreatedBy() == L"");
}
ArrayData*
APCLocalArray::AppendWithRef(ArrayData* ad, const Variant& v, bool copy) {
ArrayData *escalated = Escalate(ad);
return releaseIfCopied(escalated, escalated->appendWithRef(v, false));
}
bool ObjectQueryHandler::HandleRequest(const ApiUser::Ptr& user, HttpRequest& request, HttpResponse& response, const Dictionary::Ptr& params)
{
if (request.RequestUrl->GetPath().size() < 3 || request.RequestUrl->GetPath().size() > 4)
return false;
if (request.RequestMethod != "GET")
return false;
Type::Ptr type = FilterUtility::TypeFromPluralName(request.RequestUrl->GetPath()[2]);
if (!type) {
HttpUtility::SendJsonError(response, params, 400, "Invalid type specified.");
return true;
}
QueryDescription qd;
qd.Types.insert(type->GetName());
qd.Permission = "objects/query/" + type->GetName();
Array::Ptr uattrs, ujoins, umetas;
try {
uattrs = params->Get("attrs");
} catch (const std::exception&) {
HttpUtility::SendJsonError(response, params, 400,
"Invalid type for 'attrs' attribute specified. Array type is required.");
return true;
}
try {
ujoins = params->Get("joins");
} catch (const std::exception&) {
HttpUtility::SendJsonError(response, params, 400,
"Invalid type for 'joins' attribute specified. Array type is required.");
return true;
}
try {
umetas = params->Get("meta");
} catch (const std::exception&) {
HttpUtility::SendJsonError(response, params, 400,
"Invalid type for 'meta' attribute specified. Array type is required.");
return true;
}
bool allJoins = HttpUtility::GetLastParameter(params, "all_joins");
params->Set("type", type->GetName());
if (request.RequestUrl->GetPath().size() >= 4) {
String attr = type->GetName();
boost::algorithm::to_lower(attr);
params->Set(attr, request.RequestUrl->GetPath()[3]);
}
std::vector<Value> objs;
try {
objs = FilterUtility::GetFilterTargets(qd, params, user);
} catch (const std::exception& ex) {
HttpUtility::SendJsonError(response, params, 404,
"No objects found.",
DiagnosticInformation(ex));
return true;
}
ArrayData results;
results.reserve(objs.size());
std::set<String> joinAttrs;
std::set<String> userJoinAttrs;
if (ujoins) {
ObjectLock olock(ujoins);
for (const String& ujoin : ujoins) {
userJoinAttrs.insert(ujoin.SubStr(0, ujoin.FindFirstOf(".")));
}
}
for (int fid = 0; fid < type->GetFieldCount(); fid++) {
Field field = type->GetFieldInfo(fid);
if (!(field.Attributes & FANavigation))
continue;
if (!allJoins && userJoinAttrs.find(field.NavigationName) == userJoinAttrs.end())
continue;
joinAttrs.insert(field.Name);
}
for (const ConfigObject::Ptr& obj : objs) {
DictionaryData result1{
{ "name", obj->GetName() },
{ "type", obj->GetReflectionType()->GetName() }
};
DictionaryData metaAttrs;
if (umetas) {
ObjectLock olock(umetas);
for (const String& meta : umetas) {
if (meta == "used_by") {
Array::Ptr used_by = new Array();
metaAttrs.emplace_back("used_by", used_by);
for (const Object::Ptr& pobj : DependencyGraph::GetParents((obj)))
{
ConfigObject::Ptr configObj = dynamic_pointer_cast<ConfigObject>(pobj);
if (!configObj)
continue;
used_by->Add(new Dictionary({
{ "type", configObj->GetReflectionType()->GetName() },
{ "name", configObj->GetName() }
}));
}
} else if (meta == "location") {
metaAttrs.emplace_back("location", obj->GetSourceLocation());
} else {
HttpUtility::SendJsonError(response, params, 400, "Invalid field specified for meta: " + meta);
return true;
}
}
}
result1.emplace_back("meta", new Dictionary(std::move(metaAttrs)));
try {
result1.emplace_back("attrs", SerializeObjectAttrs(obj, String(), uattrs, false, false));
} catch (const ScriptError& ex) {
HttpUtility::SendJsonError(response, params, 400, ex.what());
return true;
}
DictionaryData joins;
for (const String& joinAttr : joinAttrs) {
Object::Ptr joinedObj;
int fid = type->GetFieldId(joinAttr);
if (fid < 0) {
HttpUtility::SendJsonError(response, params, 400, "Invalid field specified for join: " + joinAttr);
return true;
}
Field field = type->GetFieldInfo(fid);
if (!(field.Attributes & FANavigation)) {
HttpUtility::SendJsonError(response, params, 400, "Not a joinable field: " + joinAttr);
return true;
}
joinedObj = obj->NavigateField(fid);
if (!joinedObj)
continue;
String prefix = field.NavigationName;
try {
joins.emplace_back(prefix, SerializeObjectAttrs(joinedObj, prefix, ujoins, true, allJoins));
} catch (const ScriptError& ex) {
HttpUtility::SendJsonError(response, params, 400, ex.what());
return true;
}
}
result1.emplace_back("joins", new Dictionary(std::move(joins)));
results.push_back(new Dictionary(std::move(result1)));
}
Dictionary::Ptr result = new Dictionary({
{ "results", new Array(std::move(results)) }
});
response.SetStatus(200, "OK");
HttpUtility::SendJsonBody(response, params, result);
return true;
}
void Globals::getFullPos(FullPos &pos) {
ArrayData *arr = Array::get();
arr->getFullPos(pos);
}
SharedVariant::SharedVariant(CVarRef source, bool serialized,
bool inner /* = false */,
bool unserializeObj /* = false */)
: m_count (1), m_shouldCache(false), m_flags(0){
ASSERT(!serialized || source.isString());
m_type = source.getType();
switch (m_type) {
case KindOfBoolean:
{
m_data.num = source.toBoolean();
break;
}
case KindOfByte:
case KindOfInt16:
case KindOfInt32:
case KindOfInt64:
{
m_type = KindOfInt64;
m_data.num = source.toInt64();
break;
}
case KindOfDouble:
{
m_data.dbl = source.toDouble();
break;
}
case KindOfStaticString:
case KindOfString:
{
String s = source.toString();
if (serialized) {
m_type = KindOfObject;
// It is priming, and there might not be the right class definitions
// for unserialization.
s = apc_reserialize(s);
}
m_data.str = s->copy(true);
break;
}
case KindOfArray:
{
ArrayData *arr = source.getArrayData();
if (!inner) {
// only need to call hasInternalReference() on the toplevel array
PointerSet seen;
if (arr->hasInternalReference(seen)) {
setSerializedArray();
m_shouldCache = true;
String s = apc_serialize(source);
m_data.str = new StringData(s.data(), s.size(), CopyString);
break;
}
}
size_t size = arr->size();
if (arr->isVectorData()) {
setIsVector();
m_data.vec = new VectorData(size);
uint i = 0;
for (ArrayIter it(arr); !it.end(); it.next(), i++) {
SharedVariant* val = Create(it.secondRef(), false, true,
unserializeObj);
if (val->m_shouldCache) m_shouldCache = true;
m_data.vec->vals[i] = val;
}
} else {
m_data.map = new ImmutableMap(size);
for (ArrayIter it(arr); !it.end(); it.next()) {
SharedVariant* key = Create(it.first(), false, true,
unserializeObj);
SharedVariant* val = Create(it.secondRef(), false, true,
unserializeObj);
if (val->m_shouldCache) m_shouldCache = true;
m_data.map->add(key, val);
}
}
break;
}
case KindOfNull:
{
m_data.num = 0;
break;
}
default:
{
ASSERT(source.isObject());
m_shouldCache = true;
if (unserializeObj) {
// This assumes hasInternalReference(seen, true) is false
ImmutableObj* obj = new ImmutableObj(source.getObjectData());
m_data.obj = obj;
setIsObj();
} else {
String s = apc_serialize(source);
m_data.str = new StringData(s.data(), s.size(), CopyString);
}
break;
}
}
}
void c_MutableArrayIterator::t___construct(VRefParam array) {
INSTANCE_METHOD_INJECTION_BUILTIN(MutableArrayIterator, MutableArrayIterator::__construct);
if (m_valid) {
MIterCtx& mi = marr();
mi.~MIterCtx();
m_valid = false;
}
Variant var(strongBind(array));
TypedValue* tv = (TypedValue*)(&var);
ASSERT(tv->m_type == KindOfRef);
if (tv->m_data.ptv->m_type == KindOfArray) {
ArrayData* ad = tv->m_data.ptv->m_data.parr;
if (ad->getCount() > 1) {
ArrayData* copy = ad->copy();
copy->incRefCount();
ad->decRefCount(); // count > 1 to begin with; don't need release
ad = tv->m_data.ptv->m_data.parr = copy;
}
MIterCtx& mi = marr();
(void) new (&mi) MIterCtx(tv->m_data.pref);
m_valid = mi.m_mArray->advance();
if (!m_valid) mi.~MIterCtx();
} else if (tv->m_data.ptv->m_type == KindOfObject) {
CStrRef ctxStr = hhvm
? g_vmContext->getContextClassName(true)
: FrameInjection::GetClassName(true);
bool isIterator;
Object obj = tv->m_data.ptv->m_data.pobj->iterableObject(isIterator);
if (isIterator) {
raise_error("An iterator cannot be used with foreach by reference");
}
Array iterArray = obj->o_toIterArray(ctxStr, true);
ArrayData* ad = iterArray.getArrayData();
if (ad->getCount() > 1) {
ArrayData* copy = ad->copy();
copy->incRefCount();
ad->decRefCount(); // count > 1 to begin with; don't need release
ad = copy;
}
MIterCtx& mi = marr();
(void) new (&mi) MIterCtx(ad);
m_valid = mi.m_mArray->advance();
if (!m_valid) mi.~MIterCtx();
} else {
raise_warning("Invalid argument supplied for foreach()");
}
}
MsgStatus CMessage2Parser::_ParserParam( CMessage* pMsg, const CBufferMessage& pBuf )
{
uint8* pData = pBuf.GetBuffer();
int nParserIndex = MSG_HEAD_LEN;
std::string strParam;
int ArrSize = 0;
std::vector<std::string> vecStrParam;
std::vector<uint8> vecUint8Param;
std::vector<uint16> vecUint16Param;
std::vector<uint32> vecUint32Param;
ArrayData* pArrData = NULL;
uint8 NumByte[4] = {0};
for (auto It = pMsg->PortBegin(); It != pMsg->PortEnd(); It++)
{
pArrData = new ArrayData;
switch (It->second.first)
{
case MsgDataMType_Data:
switch (It->second.second)
{
case MsgDataType_String:
for (int index = 0; index < sizeof(uint32); index++)
{
NumByte[index] = pData[nParserIndex];
nParserIndex++;
}
for (int index = 0; index < _ByteToInt(NumByte); index++)
{
if ((_ByteToInt(NumByte) == 1) && (pData[nParserIndex] == 0))
{
nParserIndex++;
break;
}
strParam.push_back(pData[nParserIndex]);
nParserIndex++;
}
pMsg->Write(It->first, new StringData(strParam));
strParam.clear();
memset(NumByte, 0, 4);
break;
case MsgDataType_Uint8:
pMsg->Write(It->first, new NumData<uint8>(pData[nParserIndex]));
nParserIndex++;
break;
case MsgDataType_Uint16:
for (int index = 0; index < sizeof(uint16); index++)
{
NumByte[index] = pData[nParserIndex];
nParserIndex++;
}
pMsg->Write(It->first, new NumData<uint16>(_ByteToInt(NumByte)));
memset(NumByte, 0, 4);
break;
case MsgDataType_Uint32:
for (int index = 0; index < sizeof(uint32); index++)
{
NumByte[index] = pData[nParserIndex];
nParserIndex++;
}
pMsg->Write(It->first, new NumData<uint32>(_ByteToInt(NumByte)));
memset(NumByte, 0, 4);
break;
}
break;
case MsgDataMType_List:
for (int index = 0; index < sizeof(uint32); index++)
{
NumByte[index] = pData[nParserIndex];
nParserIndex++;
}
ArrSize = _ByteToInt(NumByte);
memset(NumByte, 0, 4);
for (int index = 0; index < ArrSize; index++)
{
if (It->second.second == MsgDataType_String)
{
for (int index = 0; index < sizeof(uint32); index++)
{
NumByte[index] = pData[nParserIndex];
nParserIndex++;
}
for (int index = 0; index < _ByteToInt(NumByte); index++)
{
if ((_ByteToInt(NumByte) == 1) && (pData[nParserIndex] == 0))
{
nParserIndex++;
break;
}
strParam.push_back(pData[nParserIndex]);
nParserIndex++;
}
vecStrParam.push_back(strParam);
strParam.clear();
memset(NumByte, 0, 4);
}
else if (It->second.second == MsgDataType_Uint8)
{
vecUint8Param.push_back(pData[nParserIndex]);
nParserIndex++;
}
else if (It->second.second == MsgDataType_Uint16)
{
for (int index = 0; index < sizeof(uint16); index++)
{
NumByte[index] = pData[nParserIndex];
nParserIndex++;
}
vecUint16Param.push_back(_ByteToInt(NumByte));
memset(NumByte, 0, 4);
}
else if (It->second.second == MsgDataType_Uint32)
{
for (int index = 0; index < sizeof(uint32); index++)
{
NumByte[index] = pData[nParserIndex];
nParserIndex++;
}
vecUint32Param.push_back(_ByteToInt(NumByte));
memset(NumByte, 0, 4);
}
}
if (!vecStrParam.empty())
{
pArrData->Push(vecStrParam);
vecStrParam.clear();
}
if (!vecUint8Param.empty())
{
pArrData->Push(vecUint8Param);
vecUint8Param.clear();
}
if (!vecUint16Param.empty())
{
pArrData->Push(vecUint16Param);
vecUint16Param.clear();
}
if (!vecUint32Param.empty())
{
pArrData->Push(vecUint32Param);
vecUint32Param.clear();
}
pMsg->WriteArr(It->first, pArrData);
break;
default:
return MsgStatus_Err;
}
}
return MsgStatus_Ok;
}
ArrayData *SharedMap::LvalNew(ArrayData* ad, Variant *&ret, bool copy) {
ArrayData *escalated = Escalate(ad);
return releaseIfCopied(escalated, escalated->lvalNew(ret, false));
}
ArrayData *SharedMap::lval(StringData* k, Variant *&ret, bool copy,
bool checkExist /* = false */) {
ArrayData *escalated = SharedMap::escalate();
return releaseIfCopied(escalated, escalated->lval(k, ret, false));
}
