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

com.gh.bmd.jrt.processor.routine.DefaultWrapperRoutineBuilder Maven / Gradle / Ivy

Go to download

Parallel programming on the go

There is a newer version: 6.0.0
Show newest version
/*
 * 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.
 */
package com.gh.bmd.jrt.processor.routine;

import com.gh.bmd.jrt.builder.RoutineConfiguration;
import com.gh.bmd.jrt.common.ClassToken;
import com.gh.bmd.jrt.processor.builder.AbstractWrapperBuilder;
import com.gh.bmd.jrt.processor.builder.WrapperRoutineBuilder;

import java.lang.ref.WeakReference;
import java.lang.reflect.Constructor;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;

import static com.gh.bmd.jrt.common.Reflection.findConstructor;

/**
 * Default implementation of a wrapper builder.
 * 

 * Created by davide on 3/23/15.
 */
class DefaultWrapperRoutineBuilder implements WrapperRoutineBuilder {

    private final WeakReference mTargetReference;

    private RoutineConfiguration mConfiguration;

    private String mShareGroup;

    /**
     * Constructor.
     *
     * @param target the target object.
     * @throws java.lang.IllegalArgumentException if a duplicate name in the annotations is
     *                                            detected.
     * @throws java.lang.NullPointerException     if the specified target is null.
     */
    @SuppressWarnings("ConstantConditions")
    DefaultWrapperRoutineBuilder(@Nonnull final Object target) {

        if (target == null) {

            throw new NullPointerException("the target object must not be null");
        }

        mTargetReference = new WeakReference(target);
    }

    @Nonnull
    public  TYPE buildWrapper(@Nonnull final Class itf) {

        return buildWrapper(ClassToken.tokenOf(itf));
    }

    @Nonnull
    public  TYPE buildWrapper(@Nonnull final ClassToken itf) {

        if (!itf.isInterface()) {

            throw new IllegalArgumentException(
                    "the specified class is not an interface: " + itf.getRawClass()
                                                                     .getCanonicalName());
        }

        final Object target = mTargetReference.get();

        if (target == null) {

            throw new IllegalStateException("the target object has been destroyed");
        }

        final RoutineConfiguration configuration = mConfiguration;
        final ObjectWrapperBuilder builder = new ObjectWrapperBuilder(target, itf);

        if (configuration != null) {

            builder.withConfiguration(configuration);
        }

        return builder.withShareGroup(mShareGroup).buildWrapper();
    }

    @Nonnull
    public WrapperRoutineBuilder withConfiguration(
            @Nullable final RoutineConfiguration configuration) {

        mConfiguration = configuration;
        return this;
    }

    @Nonnull
    public WrapperRoutineBuilder withShareGroup(@Nullable final String group) {

        mShareGroup = group;
        return this;
    }

    /**
     * Wrapper builder implementation.
     *
     * @param  the interface type.
     */
    private static class ObjectWrapperBuilder extends AbstractWrapperBuilder {

        private final ClassToken mInterfaceToken;

        private final Object mTarget;

        /**
         * Constructor.
         *
         * @param target         the target object instance.
         * @param interfaceToken the wrapper interface token.
         */
        private ObjectWrapperBuilder(@Nonnull final Object target,
                @Nonnull final ClassToken interfaceToken) {

            mTarget = target;
            mInterfaceToken = interfaceToken;
        }

        @Nonnull
        @Override
        protected ClassToken getInterfaceToken() {

            return mInterfaceToken;
        }

        @Nonnull
        @Override
        protected Object getTarget() {

            return mTarget;
        }

        @Nonnull
        @Override
        protected TYPE newWrapper(@Nonnull final String shareGroup,
                @Nonnull final RoutineConfiguration configuration) {

            try {

                final Object target = mTarget;
                final Class interfaceClass = mInterfaceToken.getRawClass();
                final Package classPackage = interfaceClass.getPackage();
                final String packageName =
                        (classPackage != null) ? classPackage.getName() + "." : "";
                final String className = packageName + "JRoutine_" + interfaceClass.getSimpleName();
                final Constructor constructor =
                        findConstructor(Class.forName(className), target, shareGroup,
                                        configuration);
                return interfaceClass.cast(
                        constructor.newInstance(target, shareGroup, configuration));

            } catch (final InstantiationException e) {

                throw new IllegalArgumentException(e.getCause());

            } catch (final Throwable t) {

                throw new IllegalArgumentException(t);
            }
        }
    }
}
    

    

    

            

    

            



    
    






    
© 2015 - 2024 Weber Informatics LLC | Privacy Policy