* limitations under the License.
 */
package org.gradle.internal.service;

import java.lang.reflect.Method;

import static org.gradle.internal.Cast.uncheckedNonnullCast;

/**
 * A service method factory that will try to use method handles if available, otherwise fallback on reflection.
 */
class DefaultServiceMethodFactory implements ServiceMethodFactory {

        return concat(node, key, isolate(value));
    }

    private <T> Isolatable<T> isolate(@Nullable T value) {
        if (value instanceof String) {
            return Cast.uncheckedNonnullCast(new CoercingStringValueSnapshot((String) value, instantiator));
        } else {
            return isolatableFactory.isolate(value);
        }
    }

    @Override

import org.gradle.api.internal.properties.GradleProperties;
import org.gradle.initialization.EnvironmentChangeTracker;

import java.util.Map;

import static org.gradle.internal.Cast.uncheckedNonnullCast;

public class DefaultSystemPropertiesInstaller implements SystemPropertiesInstaller {

    private final EnvironmentChangeTracker environmentChangeTracker;

    private final StartParameterInternal startParameter;

            return defaultArgsSerializer.forTypes(types);
        }

        final Serializer<Object>[] serializers = Cast.uncheckedNonnullCast(new Serializer<?>[types.length]);
        for (int i = 0; i < types.length; i++) {
            Class<?> type = types[i];
            serializers[i] = Cast.uncheckedNonnullCast(selected.build(type));
        }
        return new ArraySerializer(serializers);
    }

        return Cast.uncheckedNonnullCast(getInstantiator().newInstance(DefaultNamedDomainObjectSet.class, this, elementFilter, getInstantiator(), getNamer()));
    }

    @Override
    protected <S extends T> DefaultNamedDomainObjectSet<S> filtered(Spec<String> nameFilter, CollectionFilter<S> elementFilter) {

            Object arg = args[i];
            Class<?> type = types[i].getTheClass();
            if (type.isEnum() && arg instanceof CharSequence) {
                transformed[i] = toEnumValue(Cast.uncheckedNonnullCast(type), arg);
            } else {
                transformed[i] = args[i];
            }
        }
        return transformed;
    }

    @Override
    public boolean canTransform(Object[] args) {

        public Type getGenericType() {
            return elementType;
        }

        @Override
        public void setValue(Object target, Object value) {
            Property<Object> property = Cast.uncheckedNonnullCast(JavaMethod.of(Object.class, method).invoke(target));
            property.set(value);
        }

        protected Method getMethod() {
            return method;
        }
    }

        }
        if (spec == SATISFIES_NONE) {
            return satisfyAll();
        }
        if (spec instanceof NotSpec) {
            NotSpec<? super T> notSpec = Cast.uncheckedNonnullCast(spec);
            return Cast.uncheckedNonnullCast(notSpec.getSourceSpec());
        }
        return new NotSpec<>(spec);
    }

        return factory;
    }

    @Override
    public synchronized <T> T get(Class<T> serviceType) throws UnknownServiceException {
        if (services.containsKey(serviceType)) {
            return Cast.uncheckedNonnullCast(services.get(serviceType));
        }
        T t = delegate.get(serviceType);
        services.put(serviceType, t);
        return t;
    }

    @Override

        public Type getGenericType() {
            return elementType;
        }

        @Override
        public void setValue(Object target, Object value) {
            Property<Object> property = Cast.uncheckedNonnullCast(JavaMethod.of(Object.class, getter).invoke(target));
            property.set(value);
        }

        protected Method getGetter() {
            return getter;
        }
    }