* See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.snapshot.impl;

public class MapEntrySnapshot<T> {
    private final T key;
    private final T value;

    public MapEntrySnapshot(T key, T value) {
        this.key = key;
        this.value = value;
    }

    public T getKey() {
        return key;
    }

    public T getValue() {

    public AbstractIsolatedMap(ImmutableList<MapEntrySnapshot<Isolatable<?>>> entries) {
        super(entries);
    }

    @Override
    public ValueSnapshot asSnapshot() {
        ImmutableList.Builder<MapEntrySnapshot<ValueSnapshot>> builder = ImmutableList.builderWithExpectedSize(entries.size());
        for (MapEntrySnapshot<Isolatable<?>> entry : entries) {

class AbstractMapSnapshot<T extends Hashable> implements Hashable {
    protected final ImmutableList<MapEntrySnapshot<T>> entries;

    public AbstractMapSnapshot(ImmutableList<MapEntrySnapshot<T>> entries) {
        this.entries = entries;
    }

    public ImmutableList<MapEntrySnapshot<T>> getEntries() {
        return entries;
    }

    @Override
    public void appendToHasher(Hasher hasher) {

    override suspend fun ReadContext.decode(): IsolatedMap {
        val elements = readNonNull<ImmutableList<MapEntrySnapshot<Isolatable<*>>>>()
        return IsolatedMap(elements)
    }
}


object MapEntrySnapshotCodec : Codec<MapEntrySnapshot<Any>> {
    override suspend fun WriteContext.encode(value: MapEntrySnapshot<Any>) {
        write(value.key)
        write(value.value)
    }

        protected abstract T getIsolatedObject(ImmutableList<MapEntrySnapshot<Isolatable<?>>> entries);

        @Override
        protected void serialize(Encoder encoder, T value) throws Exception {
            List<MapEntrySnapshot<Isolatable<?>>> entrySnapshots = value.getEntries();
            encoder.writeInt(entrySnapshots.size());
            for (MapEntrySnapshot<Isolatable<?>> entrySnapshot : entrySnapshots) {

        expect:
        original == written
    }

    def "serializes map properties"() {
        def builder = ImmutableList.<MapEntrySnapshot<ValueSnapshot>> builder()
        builder.add(new MapEntrySnapshot<ValueSnapshot>(string("123"), integer(123)))
        builder.add(new MapEntrySnapshot<ValueSnapshot>(string("456"), list(integer(-12), integer(12))))
        def original = new MapValueSnapshot(builder.build())
        write(original)

        }
    }

    private <T> T processMap(Map<?, ?> map, ValueVisitor<T> visitor) {
        ImmutableList.Builder<MapEntrySnapshot<T>> builder = ImmutableList.builderWithExpectedSize(map.size());
        for (Map.Entry<?, ?> entry : map.entrySet()) {
            builder.add(new MapEntrySnapshot<>(processValue(entry.getKey(), visitor), processValue(entry.getValue(), visitor)));
        }
        if (map instanceof Properties) {

            case MAP_SNAPSHOT:
                size = decoder.readSmallInt();
                ImmutableList.Builder<MapEntrySnapshot<ValueSnapshot>> mapBuilder = ImmutableList.builderWithExpectedSize(size);
                for (int i = 0; i < size; i++) {
                    mapBuilder.add(new MapEntrySnapshot<>(read(decoder), read(decoder)));
                }
                return new MapValueSnapshot(mapBuilder.build());

import javax.annotation.Nullable;
import java.util.Properties;

public class IsolatedProperties extends AbstractIsolatedMap<Properties> {
    public IsolatedProperties(ImmutableList<MapEntrySnapshot<Isolatable<?>>> entries) {
        super(entries);
    }

    @Nullable
    @Override
    public Properties create() {
        return new Properties();
    }

import javax.annotation.Nullable;
import java.util.LinkedHashMap;
import java.util.Map;

public class IsolatedMap extends AbstractIsolatedMap<Map<Object, Object>> {
    public IsolatedMap(ImmutableList<MapEntrySnapshot<Isolatable<?>>> entries) {
        super(entries);
    }

    @Nullable
    @Override
    public Map<Object, Object> create() {
        return new LinkedHashMap<>(getEntries().size());
    }