AbstractDynaProxyFactory.java

package org.csc.phynixx.connection;

/*
 * #%L
 * phynixx-connection
 * %%
 * Copyright (C) 2014 csc
 * %%
 * Licensed 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.
 * #L%
 */


import java.lang.reflect.Method;

class AbstractDynaProxyFactory {

    private Class[] supportedInterfaces = null;
    private Class[] requiredInterfaces = null;
    private Class[] optionalInterfaces = null;
    private Class[] implementedInterfaces = null;   


    /**
     * @param supportedInterfaces
     * @param requiredInterfaces
     * @param optionalInterfaces
     * @param synchronize
     */
    protected AbstractDynaProxyFactory(Class[] supportedInterfaces, Class[] requiredInterfaces, Class[] optionalInterfaces, boolean synchronize) {
        if (supportedInterfaces == null || supportedInterfaces.length == 0) {
            throw new IllegalArgumentException("supportedInterfaces are missing");
        }
        this.supportedInterfaces = supportedInterfaces;
        this.requiredInterfaces = requiredInterfaces;
        this.implementedInterfaces = supportedInterfaces;
        this.optionalInterfaces = optionalInterfaces;
        if (requiredInterfaces == null) {
            return;
        }
        for (int i = 0; i < requiredInterfaces.length; i++) {
            this.implementedInterfaces = this.addRequiredInterface(this.implementedInterfaces, requiredInterfaces[i]);
        }

    }


    private Class[] addRequiredInterface(Class[] implementedInterfaces, Class requiredInterface) {
        for (int i = 0; i < implementedInterfaces.length; i++) {
            if (implementedInterfaces[i].isInterface() &&
                    requiredInterface.isAssignableFrom(implementedInterfaces[i])) {
                return implementedInterfaces;
            }
        }

        // if not found extend the array of supported interfaces
        Class[] xImplementedInterfaces = new Class[implementedInterfaces.length + 1];
        xImplementedInterfaces[0] = requiredInterface;
        for (int i = 0; i < implementedInterfaces.length; i++) {
            xImplementedInterfaces[i + 1] = implementedInterfaces[i];
        }
        return xImplementedInterfaces;

    }


    protected Class[] getSupportedInterfaces() {
        return supportedInterfaces;
    }


    protected Class[] getImplementedInterfaces() {
        return implementedInterfaces;
    }

    protected Class[] getRequiredInterfaces() {
        return requiredInterfaces;
    }


    public Class[] getOptionalInterfaces() {
        return optionalInterfaces;
    }

    private boolean declaredBy(Method method, Class[] interfaces) {
        Class declaringClass = method.getDeclaringClass();
        for (int i = 0; i < interfaces.length; i++) {
            if (declaringClass.equals(interfaces[i])) {
                return true;
            }
        }
        return false;
    }

    protected boolean declaredBySupportedInterface(Method method) {
        return declaredBy(method, this.getSupportedInterfaces());
    }

    protected boolean declaredBySystemInterface(Method method) {
        return declaredBy(method, this.getRequiredInterfaces()) || declaredBy(method, this.getOptionalInterfaces());
    }

}