private Epochs()

in accord-core/src/main/java/accord/topology/TopologyManager.java [278:336]
55 lines of code
17 McCabe index (conditional complexity)

        private Epochs(EpochState[] epochs, List<Notifications> pending, List<FutureEpoch> futureEpochs, long prevFirstNonEmptyEpoch)
        {
            this.currentEpoch = epochs.length > 0 ? epochs[0].epoch() : 0;
            if (prevFirstNonEmptyEpoch != -1)
                this.firstNonEmptyEpoch = prevFirstNonEmptyEpoch;
            else if (epochs.length > 0  && !epochs[0].global().isEmpty())
                this.firstNonEmptyEpoch = currentEpoch;
            else
                this.firstNonEmptyEpoch = prevFirstNonEmptyEpoch;

            this.pending = pending;
            this.futureEpochs = futureEpochs;
            if (!futureEpochs.isEmpty())
                Invariants.require(futureEpochs.get(0).epoch == currentEpoch + 1);

            for (int i = 1; i < futureEpochs.size(); i++)
                Invariants.requireArgument(futureEpochs.get(i).epoch == futureEpochs.get(i - 1).epoch + 1);
            for (int i = 1; i < epochs.length; i++)
                Invariants.requireArgument(epochs[i].epoch() == epochs[i - 1].epoch() - 1);
            int truncateFrom = -1;
            // > 0 because we do not want to be left without epochs in case they're all empty
            for (int i = epochs.length - 1; i > 0; i--)
            {
                EpochState epochState = epochs[i];
                if (epochState.allRetired() &&
                    (truncateFrom == -1 || truncateFrom == i + 1))
                {
                    Invariants.require(epochs[i].syncComplete());
                    truncateFrom = i;
                }
            }

            if (truncateFrom == -1)
            {
                this.epochs = epochs;
            }
            else
            {
                this.epochs = Arrays.copyOf(epochs, truncateFrom);
                if (logger.isDebugEnabled())
                {
                    for (int i = truncateFrom; i < epochs.length; i++)
                    {
                        EpochState state = epochs[i];
                        Invariants.require(epochs[i].syncComplete());
                        logger.debug("Retired epoch {} with added/removed ranges {}/{}. Topology: {}. Closed: {}", state.epoch(), state.addedRanges, state.removedRanges, state.global.ranges, state.closed);
                    }
                }
                if (logger.isTraceEnabled())
                {
                    for (int i = 0; i < truncateFrom; i++)
                    {
                        EpochState state = epochs[i];
                        Invariants.require(state.syncComplete());
                        logger.trace("Leaving epoch {} with added/removed ranges {}/{}", state.epoch(), state.addedRanges, state.removedRanges);
                    }
                }
            }
        }