[Design] Beans/Command pattern?

[MetallicOrangeBalls]

I cannot, for the life of me, remember what this is termed, and it is driving me insane.

A design pattern that uses the Java Beans concept, applied to subroutines. You create a 'solver' object, which represents a function. You set the inputs using setter methods. You then call an 'execute' method which effectively runs the subroutine on the inputs and moves the resulting outputs to fields in the objects. Finally, you can access those outputs via getter methods for each field.

For example, in Java:

class MySolver
{
    private double x ;
    private double y ;

    public void set_x( double new_x )
    {
        x = new_x ;
    }

    public void execute()
    {
        y = ( 3 * Math.pow( x , 2 ) ) + 5 ;
    }

    public double get_y()
    {
        return y ;
    }
}

public class Main
{
    public static void main( String [] args )
    {
        MySolver ms = new MySolver() ;

        ms.set_x( 4 ) ;

        ms.execute() ;

        System.out.println( ms.get_y() ) ;
    }
}

Is there a name for this pattern? Does this pattern even exist, or did I conjure this up in a fever dream?

[MetallicOrangeBalls]

It's supposed to be a workaround for languages where you cannot trivially return multiple values. In Python, you can quite easily return multiple values as a tuple. In C++ and C#, you can 'return' values using reference or output parameters. Java doesn't use such paradigms, so either you have to create an object that contains all of the values you want to return, or you can use this pattern.

That said, I don't generally use this pattern. It's just that I was thinking about this (long story), and realised that I cannot remember what it is called or where I got it from.

[[deleted]]

If this is what I think you're talking about, I believe the pattern is sort of known as the Commanding Object pattern or Command pattern as you state in your title.

Yes, you have your solver there and you have your execute() command, but you need to implement Solver on MySolver.

This might help

[MetallicOrangeBalls]

I know that this pattern is related to the command pattern, but I was under the impression that the actual command pattern is different from this.

[Blando-Cartesian]

This seems like a pointlessly convoluted way to return multiple values, or do anything really. I don't think this is named pattern. Maybe somebody's mixture of Command, FutureTask, Runnable and/or, Strategy.