Hi

I have to come up with a series of classes for holding information in the background of a GUI application I am creating. The application is to help farm systems modellers to create simulations which will be run through a 3rd party application.

Basically what the user does is define a bunch Factors (ie Fertiliser Application, Rainfall, Stocking Rate for arguments sake), then set up some Values for each Factor. After this they create Simulations which consist of a combination of different Factor Values

So I guess you could represent it like this (assuming we have 4 classes, Experiment, Factor, Value and Simulation):

- An Experiment consists of 1 to many Factors and 1 to many Simulations
- A Factor consists of 1 to many Values
- A Simulation consists of 1 to many *Factor Values* (MUST have every Factor, and ONE Value for each Factor)

My question is, what is the best way of representing *Factor Values*?
If I was to do this the way I usually do I would create a data structure that would hold the indexes of a Factor and Value (assuming Factors were stored in an array in Experiment, and Values were stored in an array in Factor), then simply put an array of that data structure inside Simulation. Is this correct from an object-oriented design point of view?

Factor is primarily an attribute of Experiment, Simulation just references it so we can get the values out for generating the file to run through the simulation software.

Any ideas/advice would be great (and if this is in the wrong topic then can a mod please move it)

Sounds a bit convoluted and too coupled. Why not just store a structure of Factors (e.g. an array of Factors). Each factor type is responsible for how it stores values.

Correctness is hard to define. But people can take potshots at an idea and you can see how many problems are flagged. In other words, how much does an idea smell? Your mechanism sounds a bit fishy already to me.

EDIT: Also to note, there isn't much to note on OO. It's more of just general design and approach. Storing indices and the like sounds a bit convoluted.

This post has been edited by Oler1s: 28 Jun, 2009 - 03:25 PM

Thanks, that sounds like a good idea.

A good method of implementing one to many relationships in OO programming is to implement a vector of the type of (the many side) objects in the (one side) class. So if you had a factor class that could contain 1 to many value types you would put a vector of value types inside the factor class.

Using C++ and the STL here. Other implementations would be similar.

Aet