org.apache.flink.runtime.state.StateSnapshotTransformers Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of flink-runtime_2.11 Show documentation
There is a newer version: 1.13.6
/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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 org.apache.flink.runtime.state;

import org.apache.flink.runtime.state.StateSnapshotTransformer.StateSnapshotTransformFactory;

import javax.annotation.Nullable;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;

import static org.apache.flink.runtime.state.StateSnapshotTransformer.CollectionStateSnapshotTransformer.TransformStrategy.STOP_ON_FIRST_INCLUDED;

/** Collection of common state snapshot transformers and their factories. */
public class StateSnapshotTransformers {
	/**
	 * General implementation of list state transformer.
	 *
	 * This transformer wraps a transformer per-entry
	 * and transforms the whole list state.
	 * If the wrapped per entry transformer is {@link CollectionStateSnapshotTransformer},
	 * it respects its {@link CollectionStateSnapshotTransformer.TransformStrategy}.
	 */
	public static class ListStateSnapshotTransformer implements StateSnapshotTransformer> {
		private final StateSnapshotTransformer entryValueTransformer;
		private final CollectionStateSnapshotTransformer.TransformStrategy transformStrategy;

		public ListStateSnapshotTransformer(StateSnapshotTransformer entryValueTransformer) {
			this.entryValueTransformer = entryValueTransformer;
			this.transformStrategy = entryValueTransformer instanceof CollectionStateSnapshotTransformer ?
				((CollectionStateSnapshotTransformer) entryValueTransformer).getFilterStrategy() :
				CollectionStateSnapshotTransformer.TransformStrategy.TRANSFORM_ALL;
		}

		@Override
		@Nullable
		public List filterOrTransform(@Nullable List list) {
			if (list == null) {
				return null;
			}
			List transformedList = new ArrayList<>();
			boolean anyChange = false;
			for (int i = 0; i < list.size(); i++) {
				T entry = list.get(i);
				T transformedEntry = entryValueTransformer.filterOrTransform(entry);
				if (transformedEntry != null) {
					if (transformStrategy == STOP_ON_FIRST_INCLUDED) {
						transformedList = list.subList(i, list.size());
						anyChange = i > 0;
						break;
					} else {
						transformedList.add(transformedEntry);
					}
				}
				anyChange |= transformedEntry == null || !Objects.equals(entry, transformedEntry);
			}
			transformedList = anyChange ? transformedList : list;
			return transformedList.isEmpty() ? null : transformedList;
		}
	}

	public static class ListStateSnapshotTransformFactory extends StateSnapshotTransformFactoryWrapAdaptor> {
		public ListStateSnapshotTransformFactory(StateSnapshotTransformFactory originalSnapshotTransformFactory) {
			super(originalSnapshotTransformFactory);
		}

		@Override
		public Optional>> createForDeserializedState() {
			return originalSnapshotTransformFactory.createForDeserializedState().map(ListStateSnapshotTransformer::new);
		}
	}

	/**
	 * General implementation of map state transformer.
	 *
	 * This transformer wraps a transformer per-entry
	 * and transforms the whole map state.
	 */
	public static class MapStateSnapshotTransformer implements StateSnapshotTransformer> {
		private final StateSnapshotTransformer entryValueTransformer;

		public MapStateSnapshotTransformer(StateSnapshotTransformer entryValueTransformer) {
			this.entryValueTransformer = entryValueTransformer;
		}

		@Nullable
		@Override
		public Map filterOrTransform(@Nullable Map map) {
			if (map == null) {
				return null;
			}
			Map transformedMap = new HashMap<>();
			boolean anyChange = false;
			for (Map.Entry entry : map.entrySet()) {
				V transformedValue = entryValueTransformer.filterOrTransform(entry.getValue());
				if (transformedValue != null) {
					transformedMap.put(entry.getKey(), transformedValue);
				}
				anyChange |= transformedValue == null || !Objects.equals(entry.getValue(), transformedValue);
			}
			return anyChange ? (transformedMap.isEmpty() ? null : transformedMap) : map;
		}
	}

	public static class MapStateSnapshotTransformFactory extends StateSnapshotTransformFactoryWrapAdaptor> {
		public MapStateSnapshotTransformFactory(StateSnapshotTransformFactory originalSnapshotTransformFactory) {
			super(originalSnapshotTransformFactory);
		}

		@Override
		public Optional>> createForDeserializedState() {
			return originalSnapshotTransformFactory.createForDeserializedState().map(MapStateSnapshotTransformer::new);
		}
	}

	public abstract static class StateSnapshotTransformFactoryWrapAdaptor implements StateSnapshotTransformFactory {
		final StateSnapshotTransformFactory originalSnapshotTransformFactory;

		StateSnapshotTransformFactoryWrapAdaptor(StateSnapshotTransformFactory originalSnapshotTransformFactory) {
			this.originalSnapshotTransformFactory = originalSnapshotTransformFactory;
		}

		@Override
		public Optional> createForDeserializedState() {
			throw new UnsupportedOperationException();
		}

		@Override
		public Optional> createForSerializedState() {
			throw new UnsupportedOperationException();
		}
	}
}