arangodb::traverser::EdgeCursor*
arangodb::traverser::TraverserOptions::nextCursorLocal(ManagedDocumentResult* mmdr,
VPackSlice vertex, size_t depth, std::vector<LookupInfo>& list) const {
TRI_ASSERT(mmdr != nullptr);
auto allCursor = std::make_unique<SingleServerEdgeCursor>(mmdr, _trx, list.size());
auto& opCursors = allCursor->getCursors();
VPackValueLength vidLength;
char const* vid = vertex.getString(vidLength);
for (auto& info : list) {
auto& node = info.indexCondition;
TRI_ASSERT(node->numMembers() > 0);
if (info.conditionNeedUpdate) {
// We have to inject _from/_to iff the condition needs it
auto dirCmp = node->getMemberUnchecked(info.conditionMemberToUpdate);
TRI_ASSERT(dirCmp->type == aql::NODE_TYPE_OPERATOR_BINARY_EQ);
TRI_ASSERT(dirCmp->numMembers() == 2);
auto idNode = dirCmp->getMemberUnchecked(1);
TRI_ASSERT(idNode->type == aql::NODE_TYPE_VALUE);
TRI_ASSERT(idNode->isValueType(aql::VALUE_TYPE_STRING));
idNode->setStringValue(vid, vidLength);
}
std::vector<OperationCursor*> csrs;
csrs.reserve(info.idxHandles.size());
for (auto const& it : info.idxHandles) {
csrs.emplace_back(_trx->indexScanForCondition(
it, node, _tmpVar, mmdr, UINT64_MAX, 1000, false));
}
opCursors.emplace_back(std::move(csrs));
}
return allCursor.release();
}
void ClassNode::buildAdditionalMethods()
{
int backup = yytokenno;
yytokenno = 0;
MethodNode* defaultConstructor = 0;
std::vector<MethodNode*> constructors;
std::vector<MemberNode*> memberNodes;
m_memberList->collectMemberNodes(memberNodes);
size_t memberCount = memberNodes.size();
for(size_t i = 0; i < memberCount; ++i)
{
MemberNode* memberNode = memberNodes[i];
if(snt_method == memberNode->m_nodeType)
{
MethodNode* methodNode = static_cast<MethodNode*>(memberNode);
if(memberNode->m_name->m_str == m_name->m_str)
{
if(isDefaultConstructor(this, methodNode))
{
assert(0 == defaultConstructor);
defaultConstructor = methodNode;
}
constructors.push_back(methodNode);
}
}
}
size_t count = constructors.size();
for(size_t i = 0; i < count; ++i)
{
MethodNode* constructor = constructors[i];
GenerateCreateInstanceMethod("New", constructor);
if(!isValueType())
{
GenerateCreateInstanceMethod("NewARC", constructor);
}
}
if(0 != defaultConstructor && isValueType())
{
GenerateCreateArrayMethod("NewArray", defaultConstructor);
}
yytokenno = backup;
}
bool arangodb::traverser::TraverserOptions::evaluateEdgeExpression(
arangodb::velocypack::Slice edge, arangodb::velocypack::Slice vertex,
size_t depth, size_t cursorId) const {
if (_isCoordinator) {
// The Coordinator never checks conditions. The DBServer is responsible!
return true;
}
arangodb::aql::Expression* expression = nullptr;
auto specific = _depthLookupInfo.find(depth);
if (specific != _depthLookupInfo.end()) {
TRI_ASSERT(!specific->second.empty());
TRI_ASSERT(specific->second.size() > cursorId);
expression = specific->second[cursorId].expression;
} else {
TRI_ASSERT(!_baseLookupInfos.empty());
TRI_ASSERT(_baseLookupInfos.size() > cursorId);
expression = _baseLookupInfos[cursorId].expression;
}
if (expression != nullptr) {
TRI_ASSERT(!expression->isV8());
expression->setVariable(_tmpVar, edge);
VPackValueLength vidLength;
char const* vid = vertex.getString(vidLength);
// inject _from/_to value
auto node = expression->nodeForModification();
TRI_ASSERT(node->numMembers() > 0);
auto dirCmp = node->getMemberUnchecked(node->numMembers() - 1);
TRI_ASSERT(dirCmp->type == aql::NODE_TYPE_OPERATOR_BINARY_EQ);
TRI_ASSERT(dirCmp->numMembers() == 2);
auto idNode = dirCmp->getMemberUnchecked(1);
TRI_ASSERT(idNode->type == aql::NODE_TYPE_VALUE);
TRI_ASSERT(idNode->isValueType(aql::VALUE_TYPE_STRING));
idNode->stealComputedValue();
idNode->setStringValue(vid, vidLength);
bool mustDestroy = false;
aql::AqlValue res = expression->execute(_trx, _ctx, mustDestroy);
expression->clearVariable(_tmpVar);
bool result = res.toBoolean();
if (mustDestroy) {
res.destroy();
}
return result;
}
return true;
}
int QDeclarativePropertyPrivate::propertyType() const
{
uint type = q->type();
if (isValueType()) {
return valueType.valueTypePropType;
} else if (type & QDeclarativeProperty::Property) {
if (core.propType == (int)QVariant::LastType)
return qMetaTypeId<QVariant>();
else
return core.propType;
} else {
return QVariant::Invalid;
}
}
void ClassNode::checkSemantic(TemplateArguments* templateArguments)
{
if (m_templateParametersNode)
{
if (0 == templateArguments)
{
return;
}
}
assert(m_typeNode && m_typeNode->m_enclosing);
std::vector<TypeNameNode*> baseTypeNameNodes;
m_baseList->collectTypeNameNodes(baseTypeNameNodes);
std::vector<TypeNode*> baseTypeNodes;
size_t baseCount = baseTypeNameNodes.size();
for (size_t i = 0; i < baseCount; ++i)
{
TypeNameNode* typeNameNode = baseTypeNameNodes[i];
TypeNode* typeNode = typeNameNode->getTypeNode(templateArguments);
if (0 != typeNode)
{
baseTypeNodes.push_back(typeNode);
g_compiler.useType(typeNode, tu_definition, typeNameNode);
}
}
checkBaseTypes(this, baseTypeNameNodes, baseTypeNodes, templateArguments);
if (0 == baseCount)
{
if (!isValueType())
{
std::string typeName;
m_typeNode->getFullName(typeName);
if (typeName != "::pafcore::Reference")
{
RaiseError_MissingReferenceBaseType(m_name);
}
}
}
std::vector<MemberNode*> memberNodes;
m_memberList->collectMemberNodes(memberNodes);
size_t memberCount = memberNodes.size();
for (size_t i = 0; i < memberCount; ++i)
{
MemberNode* memberNode = memberNodes[i];
memberNodes[i]->checkSemantic(templateArguments);
}
checkMemberNames(this, memberNodes, templateArguments);
}
bool QDeclarativePropertyPrivate::writeValueProperty(const QVariant &value, WriteFlags flags)
{
// Remove any existing bindings on this property
if (!(flags & DontRemoveBinding)) {
QDeclarativeAbstractBinding *binding = setBinding(*q, 0);
if (binding) binding->destroy();
}
bool rv = false;
if (isValueType()) {
QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(context);
QDeclarativeValueType *writeBack = 0;
if (ep) {
writeBack = ep->valueTypes[core.propType];
} else {
writeBack = QDeclarativeValueTypeFactory::valueType(core.propType);
}
writeBack->read(object, core.coreIndex);
QDeclarativePropertyCache::Data data = core;
data.flags = valueType.flags;
data.coreIndex = valueType.valueTypeCoreIdx;
data.propType = valueType.valueTypePropType;
rv = write(writeBack, data, value, context, flags);
writeBack->write(object, core.coreIndex, flags);
if (!ep) delete writeBack;
} else {
rv = write(object, core, value, context, flags);
}
return rv;
}
QVariant QDeclarativePropertyPrivate::readValueProperty()
{
if (isValueType()) {
QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(context);
QDeclarativeValueType *valueType = 0;
if (ep) valueType = ep->valueTypes[core.propType];
else valueType = QDeclarativeValueTypeFactory::valueType(core.propType);
Q_ASSERT(valueType);
valueType->read(object, core.coreIndex);
QVariant rv =
valueType->metaObject()->property(this->valueType.valueTypeCoreIdx).read(valueType);
if (!ep) delete valueType;
return rv;
} else if (core.flags & QDeclarativePropertyCache::Data::IsQList) {
QDeclarativeListProperty<QObject> prop;
void *args[] = { &prop, 0 };
QMetaObject::metacall(object, QMetaObject::ReadProperty, core.coreIndex, args);
return QVariant::fromValue(QDeclarativeListReferencePrivate::init(prop, core.propType, engine));
} else if (core.flags & QDeclarativePropertyCache::Data::IsQObjectDerived) {
QObject *rv = 0;
void *args[] = { &rv, 0 };
QMetaObject::metacall(object, QMetaObject::ReadProperty, core.coreIndex, args);
return QVariant::fromValue(rv);
} else {
return object->metaObject()->property(core.coreIndex).read(object.data());
}
}
QDeclarativeProperty::PropertyTypeCategory
QDeclarativePropertyPrivate::propertyTypeCategory() const
{
uint type = q->type();
if (isValueType()) {
return QDeclarativeProperty::Normal;
} else if (type & QDeclarativeProperty::Property) {
int type = propertyType();
if (type == QVariant::Invalid)
return QDeclarativeProperty::InvalidCategory;
else if (QDeclarativeValueTypeFactory::isValueType((uint)type))
return QDeclarativeProperty::Normal;
else if (core.flags & QDeclarativePropertyCache::Data::IsQObjectDerived)
return QDeclarativeProperty::Object;
else if (core.flags & QDeclarativePropertyCache::Data::IsQList)
return QDeclarativeProperty::List;
else
return QDeclarativeProperty::Normal;
} else {
return QDeclarativeProperty::InvalidCategory;
}
}
Type* BinaryOperation::type()
{
auto lt = left()->type();
auto rt = right()->type();
auto ltp = dynamic_cast<PrimitiveType*>(lt);
auto rtp = dynamic_cast<PrimitiveType*>(rt);
Type* res = nullptr;
if (ltp && rtp)
{
PrimitiveType::PrimitiveTypes primitive = PrimitiveType::resultFromBinaryOperation(ltp->type(), rtp->type());
if (primitive != PrimitiveType::VOID)
res = new PrimitiveType(primitive, ltp->isValueType());
}
if (!res) res = new ErrorType("Incompatible types for binary operation");
SAFE_DELETE(lt);
SAFE_DELETE(rt);
return res;
}
// *****************************************************************************
bool PodNode::isNumeric() const
{
return isValueType(INT | FLOAT);
}
bool RuntimeType::isReferenceType()
{
return !isValueType();
}
