class ExecutionOneParamBuilderImpl<T, P0>
    extends AbstractExecutionBuilder<T>
    implements ExecutionOneParamBuilder<T, P0> {
    
    private final Class<P0> param0;
    private final State state0;

    private BiConsumer<T, P0> executeAction;
    
    ExecutionOneParamBuilderImpl(
            Class<T> component, State state,
            Class<P0> param0, State state0) {
        
        super(component, state);
        this.param0 = requireNonNull(param0);
        this.state0 = requireNonNull(state0);
    }

    @Override
    public <P1> ExecutionTwoParamBuilder<T, P0, P1> withState(
            State state1, Class<P1> param1) {
        
        return new ExecutionTwoParamBuilderImpl<>(
            getComponent(), getState(), 
            param0, state0,
            param1, state1
        );
    }

    @Override
    public ExecutionBuilder<T> withExecute(BiConsumer<T, P0> 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);
        
        return new AbstractExecution<T>(
                getComponent(), getState(), singleton(dep0),
                MissingArgumentStrategy.THROW_EXCEPTION) {
                    
            @Override
            public boolean invoke(T component, ClassMapper classMapper) {
                final P0 arg0 = classMapper.apply(param0);
                executeAction.accept(component, arg0);
                return true;
            }
        };
    
<methods><variables>private final non-sealed Class<T> component,private final non-sealed com.speedment.common.injector.State state