org.apache.jackrabbit.oak.composite.NodeMap Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of aem-sdk-api Show documentation
The Adobe Experience Manager SDK
There is a newer version: 2024.11.18751.20241128T090041Z-241100
/*
 * 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.jackrabbit.oak.composite;

import org.apache.jackrabbit.guava.common.collect.ImmutableMap;
import org.apache.jackrabbit.oak.spi.mount.Mount;

import java.util.Map;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;

public class NodeMap {

    private final Map> suppliers;

    private NodeMap(Map> suppliers) {
        this.suppliers = suppliers;
    }

    public static  NodeMap create(Map nodes) {
        ImmutableMap.Builder> suppliers = ImmutableMap.builder();
        nodes.forEach((mns, node) -> suppliers.put(mns, new CacheableSupplier(node)));
        return new NodeMap<>(suppliers.build());
    }

    public T get(MountedNodeStore nodeStore) {
        if (!suppliers.containsKey(nodeStore)) {
            Mount mount = nodeStore.getMount();
            String mountName = mount.isDefault() ? "[default]" : mount.getName();
            throw new IllegalStateException("Node is not available for the node store " + mountName);
        }
        return suppliers.get(nodeStore).get();
    }

    public  NodeMap getAndApply(BiFunction function) {
        ImmutableMap.Builder> newSuppliers = ImmutableMap.builder();
        suppliers.forEach((mns, node) -> newSuppliers.put(mns, node.getAndApply(curry(function, mns))));
        return new NodeMap<>(newSuppliers.build());
    }

    public  NodeMap lazyApply(BiFunction function) {
        ImmutableMap.Builder> newSuppliers = ImmutableMap.builder();
        suppliers.forEach((mns, node) -> newSuppliers.put(mns, node.lazyApply(curry(function, mns))));
        return new NodeMap<>(newSuppliers.build());
    }

    private static  Function curry(BiFunction function, T value) {
        return u -> function.apply(value, u);
    }

    public NodeMap replaceNode(MountedNodeStore nodeStore, T node) {
        ImmutableMap.Builder> newSuppliers = ImmutableMap.builder();
        suppliers.forEach((mns, n) -> {
            if (mns != nodeStore) {
                newSuppliers.put(mns, n);
            }
        });
        newSuppliers.put(nodeStore, new CacheableSupplier<>(node));
        return new NodeMap<>(newSuppliers.build());
    }

    private static class CacheableSupplier implements Supplier {

        private Supplier supplier;

        private volatile T value;

        private CacheableSupplier(Supplier supplier) {
            this.supplier = supplier;
        }

        public CacheableSupplier(T value) {
            this.value = value;
        }

        @Override
        public T get() {
            if (value == null) {
                synchronized (this) {
                    if (value == null) {
                        value = supplier.get();
                        supplier = null;
                    }
                }
            }
            return value;
        }

        public  CacheableSupplier getAndApply(Function function) {
            return new CacheableSupplier<>(function.apply(get()));
        }

        public  CacheableSupplier lazyApply(Function function) {
            return new CacheableSupplier<>(() -> function.apply(get()));
        }
    }
}