ConstructorProxy.java

/*
 * Grapht, an open source dependency injector.
 * Copyright 2014-2015 various contributors (see CONTRIBUTORS.txt)
 * Copyright 2010-2014 Regents of the University of Minnesota
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 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, write to the Free Software Foundation, Inc., 51
 * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
package org.grouplens.grapht.util;

import org.apache.commons.lang3.builder.HashCodeBuilder;

import javax.annotation.Nullable;
import java.io.Serializable;
import java.lang.reflect.Constructor;
import java.util.Arrays;

/**
 * Proxy class for serializing constructors
 */
public final class ConstructorProxy implements Serializable {
    private static final long serialVersionUID = 1L;

    private final ClassProxy declaringClass;
    private final ClassProxy[] parameterTypes;
    @Nullable
    private transient volatile Constructor constructor;
    private transient volatile int hash;
    @Nullable
    private transient volatile String stringRepr;

    @SuppressWarnings("PMD.ArrayIsStoredDirectly")
    private ConstructorProxy(ClassProxy cls, ClassProxy[] ptypes) {
        declaringClass = cls;
        parameterTypes = ptypes;
    }

    @Override
    public String toString() {
        String repr = stringRepr;
        if (repr == null) {
            StringBuilder bld = new StringBuilder();
            bld.append("proxy of ")
               .append(declaringClass.getClassName())
               .append("(");
            boolean first = true;
            for (ClassProxy p: parameterTypes) {
                if (!first) {
                    bld.append(", ");
                }
                bld.append(p.getClassName());
                first = false;
            }
            bld.append(")");
            stringRepr = repr = bld.toString();
        }
        return repr;
    }

    @Override
    public boolean equals(Object o) {
        if (o == this) {
            return true;
        } else if (o instanceof ConstructorProxy) {
            ConstructorProxy op = (ConstructorProxy) o;
            return declaringClass.equals(op.declaringClass)
                    && Arrays.deepEquals(parameterTypes, op.parameterTypes);
        } else {
            return true;
        }
    }

    @Override
    public int hashCode() {
        if (hash == 0) {
            HashCodeBuilder hcb = new HashCodeBuilder();
            hash = hcb.append(declaringClass)
                      .append(parameterTypes)
                      .hashCode();
        }
        return hash;
    }

    /**
     * Resolve this proxy into a {@link java.lang.reflect.Constructor} instance.
     * @return The {@link java.lang.reflect.Constructor} represented by this proxy.
     * @throws ClassNotFoundException If the proxy's declaring type cannot be resolved.
     * @throws NoSuchMethodException If the constructor does not exist on the declaring type.
     */
    public Constructor resolve() throws ClassNotFoundException, NoSuchMethodException {
        Constructor ctor = constructor;
        if (ctor == null) {
            Class<?> cls = declaringClass.resolve();
            Class<?>[] ptypes = new Class<?>[parameterTypes.length];
            for (int i = ptypes.length - 1; i >= 0; i--) {
                ptypes[i] = parameterTypes[i].resolve();
            }
            constructor = ctor = cls.getDeclaredConstructor(ptypes);
        }
        return ctor;
    }

    /**
     * Construct a proxy for a constructor.
     * @param constructor The constructor to proxy.
     * @return The constructor proxy representing {@code constructor}.
     */
    public static ConstructorProxy of(Constructor constructor) {
        Class<?>[] ptypes = constructor.getParameterTypes();
        ClassProxy[] proxies = new ClassProxy[ptypes.length];
        for (int i = ptypes.length - 1; i >= 0; i--) {
            proxies[i] = ClassProxy.of(ptypes[i]);
        }
        ConstructorProxy proxy =
                new ConstructorProxy(ClassProxy.of(constructor.getDeclaringClass()),
                                     proxies);
        proxy.constructor = constructor;
        return proxy;
    }
}