* limitations under the License.
 */

package org.gradle.internal.reflect;

import javax.annotation.Nullable;
import java.lang.ref.WeakReference;

public class CachedInvokable<T> {
    private final WeakReference<T> invokable;

    public CachedInvokable(T invokable) {
        this.invokable = new WeakReference<T>(invokable);
    }

    @Nullable
    public T getMethod() {
        return invokable.get();
    }

import org.gradle.api.InvalidUserDataException;
import org.gradle.internal.Cast;
import org.gradle.internal.UncheckedException;
import org.gradle.internal.exceptions.DiagnosticsVisitor;
import org.gradle.internal.reflect.CachedInvokable;
import org.gradle.internal.reflect.ReflectionCache;
import org.gradle.util.internal.ConfigureUtil;

import javax.annotation.Nullable;
import java.lang.annotation.Annotation;

 * in a weak reference, allowing the GC to recover memory if required.
 *
 * @param <T> the type of the element stored in the cache.
 */
public abstract class ReflectionCache<T extends CachedInvokable<?>> {
    private final Object lock = new Object();

    private final WeaklyClassReferencingCache cache = new WeaklyClassReferencingCache();

    public T get(final Class<?> receiver, final Class<?>[] key) {

                    return false;
                }
            }
            return true;
        }
    }

    private static class CachedConstructor extends CachedInvokable<Constructor<?>> {
        public CachedConstructor(Constructor<?> ctor) {
            super(ctor);
        }
    }