JSONValue JSONValue::CreateChild(JSONValueType valueType)
{
    assert(IsArray());
    if (!IsArray())
        return JSONValue::EMPTY;

    Value value(ToRapidJsonType(valueType));
    value_->PushBack(value, file_->GetDocument()->GetAllocator());

    return GetChild(GetSize() - 1, valueType);
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
int AggregateCopyPropagation::ExtractCopySetInfo(CallInstr* instr, Operand*& destOp) {
    DebugValidator::IsNotNull(instr);

    // Check if we have a call to 'copyMemory' or
    // 'setMemory' that targets records or arrays.
    if(auto intrinsic = instr->GetIntrinsic()) {
        bool valid = false;
        bool isCopy;
        destOp = WithoutPointerCasts(CopyMemoryIntr::GetDestination(instr));

        if(intrinsic->Is<CopyMemoryIntr>()) {
            // The copy is valid only if the whole object
            // is copied using a constant size argument.
            auto destType = destOp->GetType()->As<PointerType>()->PointeeType();
            
            if(destType->IsRecord() || destType->IsArray()) {
                if(auto intConst = CopyMemoryIntr::GetLength(instr)->As<IntConstant>()) {
                    int size = TI::GetSize(destType, GetTarget());
                    valid = intConst->Value() == size;
                }
            }

            isCopy = true;
        }
        else if(intrinsic->Is<SetMemoryIntr>()) {
            // The copy is valid only if the whole object
            // is set using a constant size argument and a constant value.
            auto destType = destOp->GetType()->As<PointerType>()->PointeeType();

            if(destType->IsRecord() || destType->IsArray()) {
                if(auto intConst = SetMemoryIntr::GetLength(instr)->As<IntConstant>()) {
                    int size = TI::GetSize(destType, GetTarget());

                    // Check that the value that is set is a constant.
                    valid = (intConst->Value() == size) &&
                            (SetMemoryIntr::GetSource(instr)->IsIntConstant());
                }
            }

            isCopy = false;
        }

        if(valid) {
            return AddInfo(instr, isCopy);
        }
    }

    return -1;
}

		TITANIUM_FUNCTION(ListView, replaceSectionAt)
		{
			const auto js_context = this_object.get_context();
			if (arguments.size() >= 2) {
				JSObject animation = js_context.CreateObject();
				std::vector<std::shared_ptr<ListSection>> sections;

				const auto _0 = arguments.at(0);
				TITANIUM_ASSERT(_0.IsNumber());
				const auto sectionIndex = static_cast<uint32_t>(_0);

				const auto _1 = arguments.at(1);
				TITANIUM_ASSERT(_1.IsObject());
				const auto js_sections = static_cast<JSObject>(_1);

				if (js_sections.IsArray()) {
					sections = static_cast<JSArray>(js_sections).GetPrivateItems<ListSection>();
				} else {
					sections.push_back(js_sections.GetPrivate<ListSection>());
				}

				if (arguments.size() >= 3) {
					const auto _2 = arguments.at(2);
					if (_2.IsObject()) {
						animation = listviewAnimationProperties_ctor__.CallAsConstructor({_2});
					}
				}

				replaceSectionAt(sectionIndex, sections, animation.GetPrivate<ListViewAnimationProperties>());
			}
			return this_object.get_context().CreateUndefined();
		}

Qt::ItemFlags JSON_Model::flags(QModelIndex const& index) const
{
//    std::lock_guard<std::recursive_mutex> sm(mTreeMutex);


    if (!index.isValid())
    {
        return 0;
    }

    uint32_t default_flags = Qt::ItemIsEnabled | Qt::ItemIsSelectable;

    auto* ti = (Tree_Item*)index.internalPointer();
    if (!ti || !ti->m_json)
    {
        return Qt::ItemFlags(default_flags);
    }

    auto json = ti->m_json;
    if (json->IsObject() || json->IsArray())
    {
        return Qt::ItemFlags(default_flags);
    }

    return Qt::ItemFlags((index.column() == 0) ? default_flags : default_flags | Qt::ItemIsEditable);
}

	const Array &Node::AsArray() const
	{
		if (IsArray())
			return static_cast<const Array&>(*this);
		else
			throw TypeException();
	}

int WindDataParser::GetStrItemIndexOfSafeArray(const VARIANT& safeArray, const wstring& itemNameStr)
{
	if(!IsArray(safeArray))
	{
		return -1;
	}

	int length = GetCountOfSafeArray(safeArray);

	HRESULT hr ;
	BSTR *pbItems;

	hr = SafeArrayAccessData(safeArray.parray, (void HUGEP**)&pbItems);
	if (FAILED(hr))
	{
		return -1;
	}
	int nRetIndex = -1;
	for(int index = 0; index < length; index++)
	{
		if (0 == itemNameStr.compare(pbItems[index]))
		{
			nRetIndex = index;
			break;
		}
	}
	SafeArrayUnaccessData(safeArray.parray);

	return nRetIndex;
}

wstring WindDataParser::GetStrItemByIndex(const VARIANT& safeArray, int index)
{
	if(!IsArray(safeArray))
	{
		return L"";
	}

	if (VT_BSTR != (safeArray.vt & VT_BSTR_BLOB))
	{
		return L"";
	}

	HRESULT hr ;
	BSTR *pbItems;

	if (index >= GetCountOfSafeArray(safeArray))
	{
		return L"";
	}

	hr = SafeArrayAccessData(safeArray.parray, (void HUGEP**)&pbItems);
	if (FAILED(hr))
	{
		return L"";
	}

	wstring itemStr = pbItems[index];
	
	SafeArrayUnaccessData(safeArray.parray);

	return itemStr;
}

int WindDataParser::GetDoubleItemIndexOfSafeArray(const VARIANT& safeArray, DOUBLE dbl)
{
	if(!IsArray(safeArray))
	{
		return -1;
	}

	int length = GetCountOfSafeArray(safeArray);

	HRESULT hr;
	DOUBLE *pbItems;

	hr = SafeArrayAccessData(safeArray.parray, (void HUGEP**)&pbItems);
	if (FAILED(hr))
	{
		return -1;
	}
	int nRetIndex = -1;
	for(int index = 0; index < length; index++)
	{
		if (dbl == pbItems[index])
		{
			nRetIndex = index;
			break;
		}
	}
	SafeArrayUnaccessData(safeArray.parray);

	return nRetIndex;
}

 template<typename VALUE_T>uint32_t
 Document_t<VALUE_T>::Locate(uint32_t pos, const char *path) const
 {
     char *cur, *next, *_path = strdup(path);
     for (cur = _path; cur != NULL; cur = next) {
         if ((next = strchr(cur, '.')) != NULL) *next++ = 0;
         if (strlen(cur) == strspn(cur, "0123456789")) {
             if (!IsArray(pos)) {
                 pos = UINT32_MAX; goto quit0;
             }
             uint32_t idx = atol(cur);
             if (idx >= GetArraySpace(pos)) {
                 pos = UINT32_MAX; goto quit0;
             }
             pos = GetArray(pos, idx);
         } else {
             if (!IsObject(pos)) {
                 pos = UINT32_MAX; goto quit0;
             }
             if ((pos = ObjectSearch(pos, cur)) == UINT32_MAX) {
                 pos = UINT32_MAX; goto quit0;
             }
         }
     }
 quit0:
     free(_path);
     return pos;
 }

// fix arrays -- i.e. replace a tuple containing ALL unnamed elements
// with the corresponding array
// ( gdb evaluator array data is returned as tuple with {} instead []=
void MIValue::FixArrays(void)
{
	
	bool named = false;
	if(IsTuple())
	{
		for(int iVal = 0; iVal < tuple.GetCount(); iVal++)
			if(tuple.GetKey(iVal) != "<UNNAMED>")
			{
				named = true;
				break;
			}
		if(!named)
		{
			array.Clear();
			for(int iVal = 0; iVal < tuple.GetCount(); iVal++)
				array.Add() = pick(tuple[iVal]);
			tuple.Clear();
			type = MIArray;
		}
	}
	if(IsTuple() || IsArray())
		for(int i = 0; i < GetCount(); i++)
			Get(i).FixArrays();
}

Type GetType(JSValueRef value)
{
    if (JSValueIsNull(g_ctx, value))
        return VTYPE_NULL;
    if (JSValueIsBoolean(g_ctx, value))
        return VTYPE_BOOL;
    if (JSValueIsNumber(g_ctx, value))
        return VTYPE_DOUBLE;
    if (JSValueIsString(g_ctx, value))
        return VTYPE_STRING;

    if (JSValueIsObject(g_ctx, value))
    {
        JSObjectRef obj = JSValueToObject(g_ctx, value, NULL);

        if (JSObjectIsFunction(g_ctx, obj))
            return VTYPE_FUNCTION;
        if (IsArray(obj))
            return VTYPE_LIST;

        return VTYPE_DICTIONARY;
    }

    return VTYPE_INVALID;
}

void CVisProp::SetObjFromPv(const void *pvObj,
		const CVisDimIndex& refdimindex)
{
	assert(IsArray());
	PropTypeInfo().AssignObjToObj(pvObj,
			PRefCntArray()->PvObj(refdimindex));
}

void CVisProp::SetObjReferenceFromPv(void *pvObj, bool fShared)
{
	if (IsValid() && IsArray())
		ReleaseObj();

	assert(!IsValid() || !FPointerToObject() || PvRefCntObj() != 0);

	if ((IsValid()) && (IsShared() == fShared) && (IsObjReference()))
	{
		((CVisRefCntObj<void *> *) PvRefCntObj())->Obj() = pvObj;
	}
	else
	{
		ReleaseObj();
		SetFShared(fShared);
		SetFPointerToObject(fShared);

		if (fShared)
		{
			SetPvRefCntObj(new CVisRefCntObj<void *>(pvObj));
		}
		else
		{
			*((void * *) (void *) &m_llData) = pvObj;
		}

		SetFObjReference(true);
		SetFInitialized(true);
	}
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void VariableAnalysis::MarkAddressTaken(Instruction* instr) {
	if(auto loadInstr = instr->As<LoadInstr>()) {
		// Volatile loads should not be eliminated.
		if(loadInstr->IsVolatile()) {
			if(auto variableRef = loadInstr->SourceOp()->As<VariableReference>()) {
				auto localVar = variableRef->GetVariable();
				
                if(localVar == nullptr) {
                    return;
                }
                
                localVar->SetIsAddresTaken(true);
			}
		}

		return; // We're done with this instruction.
	}
	else if(auto storeInstr = instr->As<StoreInstr>()) {
		// Volatile stores should not be eliminated.
		if(storeInstr->IsVolatile()) {
			if(auto variableRef = storeInstr->DestinationOp()->As<VariableReference>()) {
				auto localVar = variableRef->GetVariable();
				
                if(localVar == nullptr) {
                    return;
                }

				localVar->SetIsAddresTaken(true);
			}
		}

		// If the stored operand is a local variable we can't eliminate it.
		if(storeInstr->SourceOp()->IsLocalVariableRef()) {
			auto variableRef = storeInstr->SourceOp()->As<VariableReference>();
            variableRef->GetVariable()->SetIsAddresTaken(true);
		}

		return; // We're done with this instruction.
	}

	// Any other instruction that has a variable reference as it's operand
	// is considered to take it's address.
	for(int i = 0; i < instr->SourceOpCount(); i++) {
		if(auto variableRef = instr->GetSourceOp(i)->As<VariableReference>()) {
			auto localVar = variableRef->GetVariable();

			if(localVar == nullptr) {
                continue;
            }

			// We don't set the flag for pointers, arrays and records because
			// we have a separate step that takes care of this.
			if((localVar->IsPointer() || 
                localVar->IsRecord()  ||
				localVar->IsArray()) == false) {
                localVar->SetIsAddresTaken(true);
			}
		}
	}
}

		TITANIUM_FUNCTION(MusicPlayer, setQueue)
		{
			ENSURE_OBJECT_AT_INDEX(js_queue, 0);

			std::vector<std::shared_ptr<Item>> queues;

			const auto queue = js_queue.GetPrivate<Item>();

			if (queue != nullptr) {
				queues.push_back(queue);
			} else if (js_queue.IsArray()) {
				const auto js_array = static_cast<std::vector<JSValue>>(static_cast<JSArray>(js_queue));
				for (const auto v : js_array) {
					queues.push_back(static_cast<JSObject>(v).GetPrivate<Item>());
				}
			} else if (js_queue.HasProperty("items")) {
				// PlayerQueue
				const auto js_playerQueue = static_cast<JSObject>(js_queue.GetProperty("items"));
				if (js_playerQueue.IsArray()) {
					const auto js_array = static_cast<std::vector<JSValue>>(static_cast<JSArray>(js_playerQueue));
					for (const auto v : js_array) {
						queues.push_back(static_cast<JSObject>(v).GetPrivate<Item>());
					}
				}
			}

			setQueue(queues);

			return get_context().CreateUndefined();
		}

size_t Json::size() const {
    if (IsNull()) return 0;
    if (IsObject()) return object().size();
    if (IsArray()) return array().size();
    if (IsString()) return string().size();
    return 1;
}

unsigned JSONValue::GetSize() const
{
    if (IsArray())
        return (unsigned)value_->Size();
    else
        return 0;
}

void _Check(const String& name, CIMConstProperty& p, T* tag)
{
    if (p.getName() == name)
    {
        if (IsArray(tag) != p.isArray() || GetType(tag) != p.getType())
            throw CIMException(CIM_ERR_TYPE_MISMATCH, name);
    }
}

CFX_Matrix CPDF_Array::GetMatrix() {
  CFX_Matrix matrix;
  if (!IsArray() || m_Objects.size() != 6)
    return matrix;

  matrix.Set(GetNumberAt(0), GetNumberAt(1), GetNumberAt(2), GetNumberAt(3),
             GetNumberAt(4), GetNumberAt(5));
  return matrix;
}

//------------------------------------------------------------------------------
void ReflectedPropertyStruct::ResizeArrayOfStruct( void * object, size_t newSize ) const
{
    // sanity checks
    ASSERT( IsArray() );
    ASSERT( GetType() == PT_STRUCT );

    const ReflectionInfo * structRI = m_StructReflectionInfo;
    void * arrayBase = (void *)( (size_t)object + m_Offset );
    structRI->SetArraySize( arrayBase, newSize );
}