All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.neo4j.collection.Dependencies Maven / Gradle / Ivy

Go to download

Collections and collection utilities for Neo4j.

There is a newer version: 5.24.0
Show newest version
/*
 * Copyright (c) "Neo4j"
 * Neo4j Sweden AB [https://neo4j.com]
 *
 * This file is part of Neo4j.
 *
 * Neo4j is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see .
 */
package org.neo4j.collection;

import static org.apache.commons.lang3.ClassUtils.getAllInterfaces;
import static org.apache.commons.lang3.ClassUtils.getAllSuperclasses;

import java.util.List;
import java.util.Objects;
import java.util.function.Supplier;
import org.eclipse.collections.api.RichIterable;
import org.eclipse.collections.api.multimap.set.MutableSetMultimap;
import org.eclipse.collections.api.set.MutableSet;
import org.eclipse.collections.impl.factory.Multimaps;
import org.eclipse.collections.impl.factory.Sets;
import org.neo4j.common.DependencyResolver;
import org.neo4j.common.DependencySatisfier;
import org.neo4j.exceptions.UnsatisfiedDependencyException;

@SuppressWarnings("unchecked")
public class Dependencies implements DependencyResolver, DependencySatisfier {
    private final DependencyResolver parent;
    private final MutableSetMultimap, Object> typeDependencies = Multimaps.mutable.set.empty();

    public static Dependencies dependenciesOf(Object object) {
        var dependencies = new Dependencies();
        dependencies.satisfyDependency(object);
        return dependencies;
    }

    public static Dependencies dependenciesOf(Object... objects) {
        var dependencies = new Dependencies();
        for (Object object : objects) {
            dependencies.satisfyDependency(object);
        }
        return dependencies;
    }

    public Dependencies() {
        parent = null;
    }

    public Dependencies(DependencyResolver parent) {
        Objects.requireNonNull(parent);
        this.parent = parent;
    }

    @Override
    public  T resolveDependency(Class type, SelectionStrategy selector) {
        RichIterable options = typeDependencies.get(type);
        if (options.notEmpty()) {
            return selector.select(type, (Iterable) options);
        }

        // Try parent
        if (parent != null) {
            return parent.resolveDependency(type, selector);
        }

        // Out of options
        throw new UnsatisfiedDependencyException(type);
    }

    @Override
    public  Iterable resolveTypeDependencies(Class type) {
        MutableSet options = (MutableSet) typeDependencies.get(type);
        if (parent != null) {
            options = Sets.mutable.ofAll(options);
            parent.resolveTypeDependencies(type).forEach(options::add);
        }
        return options;
    }

    @Override
    public  Supplier provideDependency(final Class type) {
        return () -> resolveDependency(type);
    }

    @Override
    public  T satisfyDependency(T dependency) {
        // File this object under all its possible types
        Class type = dependency.getClass();
        typeDependencies.put(type, dependency);

        addSuperclasses(type, dependency);
        addInterfaces(type, dependency);

        return dependency;
    }

    @Override
    public boolean containsDependency(Class type) {
        if (typeDependencies.containsKey(type)) {
            return true;
        }
        if (parent != null) {
            return parent.containsDependency(type);
        }
        return false;
    }

    private  void addInterfaces(Class type, T dependency) {
        List> interfaces = getAllInterfaces(type);
        if (interfaces != null) {
            interfaces.remove(type);
            for (Class iType : interfaces) {
                typeDependencies.put(iType, dependency);
            }
        }
    }

    private  void addSuperclasses(Class type, T dependency) {
        List> allSuperclasses = getAllSuperclasses(type);
        if (allSuperclasses != null) {
            for (Class aClass : allSuperclasses) {
                typeDependencies.put(aClass, dependency);
            }
        }
    }

    public void satisfyDependencies(Object... dependencies) {
        for (Object dependency : dependencies) {
            satisfyDependency(dependency);
        }
    }
}
    

    

    

            

    

            



    
    






    
© 2015 - 2024 Weber Informatics LLC | Privacy Policy