com.google.gerrit.server.query.change.AndSource.java Source code

Introduction

Here is the source code for com.google.gerrit.server.query.change.AndSource.java

Source

// Copyright (C) 2010 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package com.google.gerrit.server.query.change;

import com.google.common.base.Function;
import com.google.common.base.Throwables;
import com.google.common.collect.FluentIterable;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.google.gerrit.reviewdb.server.ReviewDb;
import com.google.gerrit.server.query.AndPredicate;
import com.google.gerrit.server.query.Predicate;
import com.google.gwtorm.server.ListResultSet;
import com.google.gwtorm.server.OrmException;
import com.google.gwtorm.server.OrmRuntimeException;
import com.google.gwtorm.server.ResultSet;
import com.google.inject.Provider;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

class AndSource extends AndPredicate<ChangeData> implements ChangeDataSource {
    private static final Comparator<Predicate<ChangeData>> CMP = new Comparator<Predicate<ChangeData>>() {
        @Override
        public int compare(Predicate<ChangeData> a, Predicate<ChangeData> b) {
            int ai = a instanceof ChangeDataSource ? 0 : 1;
            int bi = b instanceof ChangeDataSource ? 0 : 1;
            int cmp = ai - bi;

            if (cmp == 0) {
                cmp = a.getCost() - b.getCost();
            }

            if (cmp == 0 //
                    && a instanceof ChangeDataSource //
                    && b instanceof ChangeDataSource) {
                ChangeDataSource as = (ChangeDataSource) a;
                ChangeDataSource bs = (ChangeDataSource) b;
                cmp = as.getCardinality() - bs.getCardinality();

                if (cmp == 0) {
                    cmp = (as.hasChange() ? 0 : 1) - (bs.hasChange() ? 0 : 1);
                }
            }

            return cmp;
        }
    };

    private static List<Predicate<ChangeData>> sort(Collection<? extends Predicate<ChangeData>> that) {
        ArrayList<Predicate<ChangeData>> r = new ArrayList<Predicate<ChangeData>>(that);
        Collections.sort(r, CMP);
        return r;
    }

    private final Provider<ReviewDb> db;
    private int cardinality = -1;

    AndSource(Provider<ReviewDb> db, Collection<? extends Predicate<ChangeData>> that) {
        super(sort(that));
        this.db = db;
    }

    @Override
    public boolean hasChange() {
        ChangeDataSource source = source();
        return source != null && source.hasChange();
    }

    @Override
    public ResultSet<ChangeData> read() throws OrmException {
        try {
            return readImpl();
        } catch (OrmRuntimeException err) {
            Throwables.propagateIfInstanceOf(err.getCause(), OrmException.class);
            throw new OrmException(err);
        }
    }

    private ResultSet<ChangeData> readImpl() throws OrmException {
        ChangeDataSource source = source();
        if (source == null) {
            throw new OrmException("No ChangeDataSource: " + this);
        }

        List<ChangeData> r = Lists.newArrayList();
        ChangeData last = null;
        boolean skipped = false;
        for (ChangeData data : buffer(source, source.read())) {
            if (match(data)) {
                r.add(data);
            } else {
                skipped = true;
            }
            last = data;
        }

        if (skipped && last != null && source instanceof Paginated) {
            // If our source is a paginated source and we skipped at
            // least one of its results, we may not have filled the full
            // limit the caller wants.  Restart the source and continue.
            //
            Paginated p = (Paginated) source;
            while (skipped && r.size() < p.limit()) {
                ChangeData lastBeforeRestart = last;
                skipped = false;
                last = null;
                for (ChangeData data : buffer(source, p.restart(lastBeforeRestart))) {
                    if (match(data)) {
                        r.add(data);
                    } else {
                        skipped = true;
                    }
                    last = data;
                }
            }
        }

        return new ListResultSet<ChangeData>(r);
    }

    private Iterable<ChangeData> buffer(ChangeDataSource source, ResultSet<ChangeData> scanner) {
        final boolean loadChange = !source.hasChange();
        return FluentIterable.from(Iterables.partition(scanner, 50))
                .transformAndConcat(new Function<List<ChangeData>, List<ChangeData>>() {
                    @Override
                    public List<ChangeData> apply(List<ChangeData> buffer) {
                        if (loadChange) {
                            try {
                                ChangeData.ensureChangeLoaded(db, buffer);
                            } catch (OrmException e) {
                                throw new OrmRuntimeException(e);
                            }
                        }
                        return buffer;
                    }
                });
    }

    private ChangeDataSource source() {
        for (Predicate<ChangeData> p : getChildren()) {
            if (p instanceof ChangeDataSource) {
                return (ChangeDataSource) p;
            }
        }
        return null;
    }

    @Override
    public int getCardinality() {
        if (cardinality < 0) {
            cardinality = Integer.MAX_VALUE;
            for (Predicate<ChangeData> p : getChildren()) {
                if (p instanceof ChangeDataSource) {
                    int c = ((ChangeDataSource) p).getCardinality();
                    cardinality = Math.min(cardinality, c);
                }
            }
        }
        return cardinality;
    }
}