Method evalAggregate

src/App/Expression.cpp:1991–2056

};

Py::Object FunctionExpression::evalAggregate(
        const Expression *owner, int f, const std::vector<Expression*> &args)
{
    std::unique_ptr<Collector> c;

    switch (f) {
    case SUM:
        c = std::make_unique<SumCollector>();
        break;
    case AVERAGE:
        c = std::make_unique<AverageCollector>();
        break;
    case STDDEV:
        c = std::make_unique<StdDevCollector>();
        break;
    case COUNT:
        c = std::make_unique<CountCollector>();
        break;
    case MIN:
        c = std::make_unique<MinCollector>();
        break;
    case MAX:
        c = std::make_unique<MaxCollector>();
        break;
    case AND:
        c = std::make_unique<AndCollector>();
        break;
    case OR:
        c = std::make_unique<OrCollector>();
        break;
    default:
        assert(false);
    }

    for (auto &arg : args) {
        if (arg->isDerivedFrom<RangeExpression>()) {
            Range range(static_cast<const RangeExpression&>(*arg).getRange());

            do {
                Property * p = owner->getOwner()->getPropertyByName(range.address().c_str());
                PropertyQuantity * qp;
                PropertyFloat * fp;
                PropertyInteger * ip;

                if (!p)
                    continue;

                if ((qp = freecad_cast<PropertyQuantity*>(p)))
                    c->collect(qp->getQuantityValue());
                else if ((fp = freecad_cast<PropertyFloat*>(p)))
                    c->collect(Quantity(fp->getValue()));
                else if ((ip = freecad_cast<PropertyInteger*>(p)))
                    c->collect(Quantity(ip->getValue()));
                else
                    _EXPR_THROW("Invalid property type for aggregate.", owner);
            } while (range.next());
        }
        else {