org.dellroad.querystream.jpa.DoubleStreamImpl Maven / Gradle / Ivy

Go to download

/*
 * Copyright (C) 2018 Archie L. Cobbs. All rights reserved.
 */

package org.dellroad.querystream.jpa;

import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import java.util.function.Function;

import javax.persistence.EntityManager;
import javax.persistence.FlushModeType;
import javax.persistence.LockModeType;
import javax.persistence.Parameter;
import javax.persistence.TemporalType;
import javax.persistence.criteria.AbstractQuery;
import javax.persistence.criteria.Expression;
import javax.persistence.criteria.Order;
import javax.persistence.criteria.Root;
import javax.persistence.criteria.Selection;

import org.dellroad.querystream.jpa.querytype.SearchType;

class DoubleStreamImpl extends ExprStreamImpl> implements DoubleStream {

// Constructors

    DoubleStreamImpl(EntityManager entityManager,
      QueryConfigurer, Double, ? extends Expression> configurer, QueryInfo queryInfo) {
        super(entityManager, new SearchType(Double.class), configurer, queryInfo);
    }

// Aggregation

    @Override
    public DoubleValue average() {
        QueryStreamImpl.checkOffsetLimit(this, "average()");
        return new DoubleValueImpl(this.entityManager,
          (builder, query) -> builder.avg(this.configurer.configure(builder, query)), this.queryInfo);
    }

    @Override
    public DoubleValue max() {
        QueryStreamImpl.checkOffsetLimit(this, "max()");
        return new DoubleValueImpl(this.entityManager,
          (builder, query) -> builder.max(this.configurer.configure(builder, query)), this.queryInfo);
    }

    @Override
    public DoubleValue min() {
        QueryStreamImpl.checkOffsetLimit(this, "min()");
        return new DoubleValueImpl(this.entityManager,
          (builder, query) -> builder.min(this.configurer.configure(builder, query)), this.queryInfo);
    }

    @Override
    public DoubleValue sum() {
        QueryStreamImpl.checkOffsetLimit(this, "sum()");
        return new DoubleValueImpl(this.entityManager,
          (builder, query) -> builder.sum(this.configurer.configure(builder, query)), this.queryInfo);
    }

// Narrowing overrides (SearchStreamImpl)

    @Override
    DoubleStream create(EntityManager entityManager, SearchType queryType,
      QueryConfigurer, Double, ? extends Expression> configurer, QueryInfo queryInfo) {
        return new DoubleStreamImpl(entityManager, configurer, queryInfo);
    }

    @Override
    DoubleValue toValue() {
        return this.toValue(false);
    }

    @Override
    DoubleValue toValue(boolean forceLimit) {
        return new DoubleValueImpl(this.entityManager,
          this.configurer, forceLimit ? this.queryInfo.withMaxResults(1) : this.queryInfo);
    }

    @Override
    public DoubleStream distinct() {
        return (DoubleStream)super.distinct();
    }

    @Override
    public DoubleStream orderBy(Ref> ref, boolean asc) {
        return (DoubleStream)super.orderBy(ref, asc);
    }

    @Override
    public DoubleStream orderBy(Function, ? extends Expression> orderExprFunction, boolean asc) {
        return (DoubleStream)super.orderBy(orderExprFunction, asc);
    }

    @Override
    public DoubleStream orderBy(Order... orders) {
        return (DoubleStream)super.orderBy(orders);
    }

    @Override
    public DoubleStream orderByMulti(Function, ? extends List> orderListFunction) {
        return (DoubleStream)super.orderByMulti(orderListFunction);
    }

    @Override
    public DoubleStream thenOrderBy(Ref> ref, boolean asc) {
        return (DoubleStream)super.thenOrderBy(ref, asc);
    }

    @Override
    public DoubleStream thenOrderBy(Order... orders) {
        return (DoubleStream)super.thenOrderBy(orders);
    }

    @Override
    public DoubleStream thenOrderBy(Function, ? extends Expression> orderExprFunction, boolean asc) {
        return (DoubleStream)super.thenOrderBy(orderExprFunction, asc);
    }

    @Override
    public DoubleStream groupBy(Ref> ref) {
        return (DoubleStream)super.groupBy(ref);
    }

    @Override
    public DoubleStream groupBy(Function, ? extends Expression> groupFunction) {
        return (DoubleStream)super.groupBy(groupFunction);
    }

    @Override
    public DoubleStream groupByMulti(Function, ? extends List>> groupFunction) {
        return (DoubleStream)super.groupByMulti(groupFunction);
    }

    @Override
    public DoubleStream having(Function, ? extends Expression> havingFunction) {
        return (DoubleStream)super.having(havingFunction);
    }

    @Override
    public DoubleValue findAny() {
        return (DoubleValue)super.findAny();
    }

    @Override
    public DoubleValue findFirst() {
        return (DoubleValue)super.findFirst();
    }

    @Override
    public DoubleValue findSingle() {
        return (DoubleValue)super.findSingle();
    }

    @Override
    public  DoubleStream addRoot(Ref> ref, Class type) {
        return (DoubleStream)super.addRoot(ref, type);
    }

// Narrowing overrides (QueryStreamImpl)

    @Override
    public DoubleStream bind(Ref> ref) {
        return (DoubleStream)super.bind(ref);
    }

    @Override
    public DoubleStream peek(Consumer> peeker) {
        return (DoubleStream)super.peek(peeker);
    }

    @Override
    public > DoubleStream bind(
      Ref ref, Function, ? extends S2> refFunction) {
        return (DoubleStream)super.bind(ref, refFunction);
    }

    @Override
    public DoubleStream filter(Function, ? extends Expression> predicateBuilder) {
        return (DoubleStream)super.filter(predicateBuilder);
    }

    @Override
    public DoubleStream limit(int limit) {
        return (DoubleStream)super.limit(limit);
    }

    @Override
    public DoubleStream skip(int skip) {
        return (DoubleStream)super.skip(skip);
    }

    @Override
    public DoubleStream withFlushMode(FlushModeType flushMode) {
        return (DoubleStream)super.withFlushMode(flushMode);
    }

    @Override
    public DoubleStream withLockMode(LockModeType lockMode) {
        return (DoubleStream)super.withLockMode(lockMode);
    }

    @Override
    public DoubleStream withHint(String name, Object value) {
        return (DoubleStream)super.withHint(name, value);
    }

    @Override
    public DoubleStream withHints(Map hints) {
        return (DoubleStream)super.withHints(hints);
    }

    @Override
    public  DoubleStream withParam(Parameter parameter, T value) {
        return (DoubleStream)super.withParam(parameter, value);
    }

    @Override
    public DoubleStream withParam(Parameter parameter, Date value, TemporalType temporalType) {
        return (DoubleStream)super.withParam(parameter, value, temporalType);
    }

    @Override
    public DoubleStream withParam(Parameter parameter, Calendar value, TemporalType temporalType) {
        return (DoubleStream)super.withParam(parameter, value, temporalType);
    }

    @Override
    public DoubleStream withParams(Iterable> params) {
        return (DoubleStream)super.withParams(params);
    }

    @Override
    public DoubleStream withLoadGraph(String name) {
        return (DoubleStream)super.withLoadGraph(name);
    }

    @Override
    public DoubleStream withFetchGraph(String name) {
        return (DoubleStream)super.withFetchGraph(name);
    }
}