io.activej.ot.reducers.AbstractGraphReducer Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of activej-ot Show documentation

Implementation of operational transformation technology. Allows building collaborative software systems.

There is a newer version: 6.0-rc2

/*
 * Copyright (C) 2020 ActiveJ LLC.
 *
 * 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 io.activej.ot.reducers;

import io.activej.ot.OTCommit;
import io.activej.promise.Promise;
import org.jetbrains.annotations.NotNull;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

import static io.activej.ot.reducers.GraphReducer.Result.completePromise;
import static io.activej.ot.reducers.GraphReducer.Result.resumePromise;
import static java.util.Collections.singletonMap;

public abstract class AbstractGraphReducer implements GraphReducer {
	private final DiffsReducer diffsReducer;
	private final Map> accumulators = new HashMap<>();
	private final Map> headCommits = new HashMap<>();

	protected AbstractGraphReducer(DiffsReducer diffsReducer) {
		this.diffsReducer = diffsReducer;
	}

	@Override
	public void onStart(@NotNull Collection> queue) {
		for (OTCommit headCommit : queue) {
			this.headCommits.put(headCommit.getId(), headCommit);
			this.accumulators.put(headCommit.getId(), new HashMap<>(singletonMap(headCommit.getId(), diffsReducer.initialValue())));
		}
	}

	protected abstract @NotNull Promise> tryGetResult(OTCommit commit, Map> accumulators,
			Map> headCommits);

	@Override
	public final @NotNull Promise> onCommit(@NotNull OTCommit commit) {
		return tryGetResult(commit, accumulators, headCommits)
				.then(maybeResult -> {
					if (maybeResult.isPresent()) {
						return completePromise(maybeResult.get());
					}

					Map toHeads = accumulators.remove(commit.getId());
					for (K parent : commit.getParents().keySet()) {
						Map parentToHeads = accumulators.computeIfAbsent(parent, $ -> new HashMap<>());
						for (Map.Entry entry : toHeads.entrySet()) {
							A newAccumulatedDiffs = diffsReducer.accumulate(entry.getValue(), commit.getParents().get(parent));
							A existingAccumulatedDiffs = parentToHeads.get(entry.getKey());
							A combinedAccumulatedDiffs = existingAccumulatedDiffs == null ?
									newAccumulatedDiffs :
									diffsReducer.combine(existingAccumulatedDiffs, newAccumulatedDiffs);
							parentToHeads.put(entry.getKey(), combinedAccumulatedDiffs);
						}
					}
					return resumePromise();
				});
	}
}