Method validateExpression

src/App/PropertyExpressionEngine.cpp:806–876

}

std::string
PropertyExpressionEngine::validateExpression(const ObjectIdentifier& path,
                                             std::shared_ptr<const Expression> expr) const
{
    std::string error;
    ObjectIdentifier usePath(canonicalPath(path));

    if (validator) {
        error = validator(usePath, expr);
        if (!error.empty()) {
            return error;
        }
    }

    // Get document object
    DocumentObject* pathDocObj = usePath.getDocumentObject();
    assert(pathDocObj);

    if (GetApplication().isFineGrainedRecomputeEnabled()) {
        // Fully mimics the else part except for taking into account input properties.
        auto inList = pathDocObj->getInListEx(true);

        std::map<DocumentObject*, bool> depObjects;
        std::map<std::pair<std::string, DocumentObject*>, bool> propDeps;
        expr->getDepObjects(depObjects, nullptr, &propDeps);

        for (const auto& [pair, hidden] : propDeps) {
            auto* docObj = pair.second;
            auto& propName = pair.first;
            if (!hidden && inList.contains(docObj) && !docObj->isInputProperty(propName)) {
                std::stringstream ss;
                ss << "cyclic reference to " << docObj->getFullName() << "." << propName;
                return ss.str();
            }
        }
    }
    else {
        auto inList = pathDocObj->getInListEx(true);
        for (auto& v : expr->getDepObjects()) {
            auto docObj = v.first;
            if (!v.second && inList.contains(docObj)) {
                std::stringstream ss;
                ss << "cyclic reference to " << docObj->getFullName();
                return ss.str();
            }
        }
    }


    // Check for internal document object dependencies

    // Copy current expressions
    ExpressionMap newExpressions = expressions;

    // Add expression in question
    std::shared_ptr<Expression> exprClone(expr->copy());
    newExpressions[usePath].expression = exprClone;