class ExecutionThreeParamBuilderImpl<T, P0, P1, P2>
    extends AbstractExecutionBuilder<T>
    implements ExecutionThreeParamBuilder<T, P0, P1, P2> {
    
    private final Class<P0> param0;
    private final Class<P1> param1;
    private final Class<P2> param2;
    private final State state0;
    private final State state1;
    private final State state2;

    private QuadConsumer<T, P0, P1, P2> executeAction;
    
    ExecutionThreeParamBuilderImpl(
            Class<T> component, State state,
            Class<P0> param0, State state0,
            Class<P1> param1, State state1,
            Class<P2> param2, State state2) {
        
        super(component, state);
        this.param0 = requireNonNull(param0);
        this.state0 = requireNonNull(state0);
        this.param1 = requireNonNull(param1);
        this.state1 = requireNonNull(state1);
        this.param2 = requireNonNull(param2);
        this.state2 = requireNonNull(state2);
    }

    @Override
    public ExecutionBuilder<T> withExecute(QuadConsumer<T, P0, P1, P2> executeAction) {
        this.executeAction = requireNonNull(executeAction);
        return this;
    }

    @Override
    public Execution<T> build(DependencyGraph graph) {<FILL_FUNCTION_BODY>}
}

        
        requireNonNull(executeAction, "No execution has been specified.");
        
        final DependencyNode node0 = graph.get(param0);
        final Dependency dep0 = new DependencyImpl(node0, state0);
        
        final DependencyNode node1 = graph.get(param1);
        final Dependency dep1 = new DependencyImpl(node1, state1);
        
        final DependencyNode node2 = graph.get(param2);
        final Dependency dep2 = new DependencyImpl(node2, state2);
        
        return new AbstractExecution<T>(
                getComponent(),
                getState(),
                unmodifiableSet(dep0, dep1, dep2),
                MissingArgumentStrategy.THROW_EXCEPTION) {
                    
            @Override
            public boolean invoke(T component, Execution.ClassMapper classMapper) {
                
                final P0 arg0 = classMapper.apply(param0);
                final P1 arg1 = classMapper.apply(param1);
                final P2 arg2 = classMapper.apply(param2);
                executeAction.accept(component, arg0, arg1, arg2);
                return true;
            }
        };
    
<methods><variables>private final non-sealed Class<T> component,private final non-sealed com.speedment.common.injector.State state