Hello I would like your opinions about design/implementation choices for an application I am writing. I have a list of models. Each model is a kind of black box that takes inputs and produces outputs. All the inputs are either of boolean or arithmetic type. (bool, int, double) A subset of inputs is valid for all models. Then different models have different number of other inputs. For a fixed set of inputs, the model produces 1 fixed set of outputs. It is desired to vary the values of some/all (at least 1) of the inputs and get different outputs sets, and then plot that. The inputs are specified in files (considered as std::istream in the code), the syntax is trivial: input1 = value1 ... inputn = valuen When it is desired to vary the input values, the syntax changes a little: input1 = value1 input2 = value21..value22 ... inputn = valuen in this example only input2 changes, and the idea is to plot one of the outputs over the differnt values of input2. Each derived model has a concrete struct input_i_s { ... } that holds its inputs. class model { public: virtual fixed_inputs get_fixed_inputs( std::istream& ) const =0; /// throws if syntax error, or not all inputs are specified, or some values are not valid virtual variable_inputs get_variable_inputs( std::istream& ) const =0; /// the same, allows the '..' notation though for ranges, at least of the inputs need to be a range }; // fixed_inputs is a pointer to a base class of all inputs for all models 1 implementation pseud-code looks like: fixed_inputs model_i::get_fixed_inputs( std::istream& input) const { size_t inputs = 7; std::string buffer; while (inputs>0 && input.good()) { input >> buffer; if ( buffer.substr(0, sizeof("input1")) == "input1=") { std::istringstream is(buffer.substr(0, sizeof("input1"))); is >> .... ; /// pseudo-code : stores the value into a field in fixed_input1s // if wrong value, throws an exception } else if ... ... } return fixed_inputs( new input_i_s() ); // pseudo-code, say for model number i } I would like then to write the implementation for the syntax which accepts ranges as well. (the get_variable_inputs function) I hope to be able to factorize code between the 2 implementations. 1. boost::program_options can read options from input streams. Given that I am interested in ranges as well, is it adviced to go down that road? 2. Is there a library that helps to generate the expected format of the input stream from the struct of inputs for each model, and reads the stream automatically. Can it do range values as well? 3. is it possible then to factorize code between the get_fixed_inputs and get_variable_inputs? Regards,