Making an Array of Function Calls

General Discussion Other

Tavlor

Making an Array of Function Calls

in General Discussion • Other • 2 months ago

In a program I am writing, I want to loop through several object functions and use the results. To make it simple, I want to have an array that contains the function calls, which I can then loop through with a for loop. How would I do this? My understanding is that I'd need to declare the array type, and I don't know what data type I'd use. Thanks.

*Edit* I forgot to mention that these function calls will be to functions inside several separate objects of different types.

Replies(7)

dimkir

Re: Making an Array of Function Calls

2 months ago

Just use array of objects. You can loop through the array of object and call a method upon each of them.

// declare array of the MyClass objects
MyClass[] myObjects;
void setup(){
size(800,600);
// initialize the arrray of my objects
myObjects = new MyClass[10];
// populate the array with objects
for(int i = 0 ; i < myObjects.length ; i++){
myObjects[i] = new MyClass();
}
// now iterate through the array of your objects
// and call your super-function
for(int i = 0 ; i < myObjects.length ; i++){
myObjects[i].mySuperFunction();
}
}
void draw(){
}
class MyClass
{
void mySuperFunction(){
println("Super function was called");
}
}

GoToLoop

Re: Making an Array of Function Calls

2 months ago

An alternative method:

Processing has 2 undocumented functions which can invoke a function label as a String: method() & thread().
And thread() has an additional effect on invoking a function as a separate Thread.

/** 
 * Method() Usage Example (v1.01)
 * by GoToLoop (2013/Aug)
 * 
 * http://forum.processing.org/topic/making-an-array-of-function-calls
 */

final static int NUM = 7;
final static String NAME = "function";
final static String[] functions = new String[NUM];

void setup() {
  for (int i = 0; i != NUM; functions[i] = NAME + i++);
  for (String funct: functions)  method(funct);
  //for (String funct: functions)  thread(funct);

  exit();
}

void function0() {
  println("Hello!\n");
}

void function1() {
  println("Welcome");
}

void function2() {
  println("to Processing.\n");
}

void function3() {
  println("Using");
}

void function4() {
  println("non-documented");
}

void function5() {
  println("method()");
}

void function6() {
  println("function!\n");
}

Tavlor

Re: Re: Making an Array of Function Calls

1 month ago

I tried this and it works fine until I tried to call a function that was inside an object. Then it went crazy, giving me the error message : "There is no public thing.function0() method in the class Object_ArrayTests". I guess I should have mentioned that the functions being called are all in different objects. Is it still possible? My understanding so far is that the method() function can only call public functions.

GoToLoop

Re: Re: Making an Array of Function Calls

1 month ago

I'm afraid both method() & thread() work only for the main sketch functions.
We can't use them to invoke custom named methods from our own classes.

Internally they use something like "reflexion". But it's too advanced for me yet.

Only other path is go for method polymorphism through Interface or Abstract Class;
like both PaultR451 & PhiLho have demonstrated already.

To make it easier for you, I've remade my previous example.
But this time, using anonymous instantiations of interface Function,
by implementing its method function() w/ different actions each time.
Then, storing them in an Array of Function:

/** 
 * Anonymous Custom Functions (v1.01)
 * by GoToLoop (2013/Aug)
 * 
 * http://forum.processing.org/topic/making-an-array-of-function-calls
 */

interface Function {
  void function();   // custom functions.
}

final static int NUM = 7;
final static Function[] functions = new Function[NUM];

void setup() {
  createCustomFunctions();
  for (Function f: functions)  f.function();
  exit();
}

static final void createCustomFunctions() {
  functions[0] = new Function() {
    public void function() {
      println("Hello!\n");
    }
  };

  functions[1] = new Function() {
    public void function() {
      println("Welcome");
    }
  };

  functions[2] = new Function() {
    public void function() {
      println("to Processing.\n");
    }
  };

  functions[3] = new Function() {
    public void function() {
      println("Using");
    }
  };

  functions[4] = new Function() {
    public void function() {
      println("custom");
    }
  };

  functions[5] = new Function() {
    public void function() {
      println("anonymous");
    }
  };

  functions[6] = new Function() {
    public void function() {
      println("functions\n");
    }
  };
}

paulr451

Re: Making an Array of Function Calls

2 months ago

Hard to tell exactly what you're after, the solutions given will work. Function pointers were the way in "C" languages. they have been dropped and now we use Interfaces. Again, not sure exactly how you need it to work, but here is an interface example, showing a "queue" of "function" objects that return values and are executed in "batch mode". There are many ways to implement this and the amount of data returned is unlimited, you can create a large class to hold return values, and return an arraylist of them. I used a FloatList for example.

interface Executable {
float execute(float data);
}
class Squarer implements Executable {
float execute(float data) {
return data * data;
}
}
class Cuber implements Executable {
float execute(float data) {
return data * data * data;
}
}
class Executer {
ArrayList<Executable> executers;

Executer() {
    executers = new ArrayList<Executable>();
}

void enqueue(Executable ex) {
    executers.add(ex);
}

FloatList execute(float data) {
    FloatList results = new FloatList();
    for(Executable ex : executers) {
      results.append(ex.execute(data));
    }
    return results;
}
}
void setup() {
size(300,200); noLoop();
Executer myExecuter = new Executer();
myExecuter.enqueue(new Squarer());
myExecuter.enqueue(new Cuber());
FloatList results = myExecuter.execute(3.0);
for(int i = 0; i < results.size(); i++) {
text(results.get(i), 10, 14 + i * 14);
}
}

PhiLho

Re: Making an Array of Function Calls

2 months ago

I was about to suggest to use an interface too, but paulr451 did it already with a nice wrapper class.

So I will just add that you don't need to explicitly create each implementation of the interface in a named class, particularly if these functions have only slightly different features, hard to name (unless numbering them).

You can use anonymous classes for that:

void setup() {
size(300, 200);
noLoop();
Executer myExecuter = new Executer();
myExecuter.enqueue(new Executable() {
public float execute(float data) {
return data * data;
}
});
myExecuter.enqueue(new Executable() {
public float execute(float data) {
return data * data * data;
}
});
FloatList results = myExecuter.execute(3.0);
for (int i = 0; i < results.size(); i++) {
text(results.get(i), 10, 14 + i * 14);
}
}

Remainder of code identical, but there are no Squarer nor Cuber classes.

Yes, the syntax is quite verbose, a common issue in Java... When Processing will adopt Java 8 syntax (if ever...

Probably quite some work!), we will be able to use anonymous functions with a lighter syntax!

PS for paulr451: in this forum, you have to paste your code, select it, then only click on the Insert Code button. Alas, it looses empty lines, a workaround is to put at least one space in these lines.

PhiLho

Re: Making an Array of Function Calls

1 month ago

@Tavlor: you answered in a comment above, but Zoho's comment system is clunky, so it is hard to answer properly (threaded) to this comment.

Indeed, mentioning the functions are in classes would have been critical to scope the answers!

If all functions have the same name, just create an interface with this function, and make the classes to implement the interface. Then you can use the method described above by paulr451.

Maybe method() can call methods within classes*, but it is easier / cleaner to adapt your code to the more standard (Java) way with interfaces. And it is more flexible, as you can add parameters and use a return value.

* [EDIT] Actually, not really, unless the methods are static (and within static classes!) since otherwise, there is no simple way to specify which instance of the class to use for calling the method.

Top Reply