What is the proper way to encapsulate this kind of functionality? - encapsulation

Question

For example I have a function that basically works this way:
function myfunc(data,type_of_analysis){
if type_of_analysis is "Smith-Jones Method"
return smith_jones(data)
else if type_of_analysis is "Pineapple-Mango Method"
return pineapple_mango(data)
}
Names are made up of course, and imagine that there are several more types of analysis than this. What would be the correct way to restructure myfunc()? Is there a better / more standard way for people to pass in arguments to determine what kind of analysis they want to perform? Or is this something the user would have to look up in a documentation?

Answer 1

Here is an example in C++ which uses a map between enum values and function objects to give a type safe and flexible dispatch framework:
//dummy analysis functions
void smithJonesAnalysis (int data){cout << "Smith";}
void pineappleMangoAnalysis (int data){cout << "Pineapple";}
class Analyzer
{
//different analysis methods
enum class AnalysisMethod {SmithJones, PineappleMango};
//a map from analysis method to a function object
std::map<AnalysisMethod, std::function<void(int)>> m_analysis_map;
AnalysisMethod stringToMethod (std::string method)
{
//some basic string canonicalisation
std::transform(method.begin(), method.end(), method.begin(), ::tolower);
if (method == "smith-jones method")
return AnalysisMethod::SmithJones;
if (method == "pineapple-mango method")
return AnalysisMethod::PineappleMango;
throw std::runtime_error("Invalid analysis method");
}
public:
Analyzer()
{
//register all the different functions here
m_analysis_map[AnalysisMethod::SmithJones] = smithJonesAnalysis;
m_analysis_map[AnalysisMethod::PineappleMango] = pineappleMangoAnalysis;
}
//dispatcher function
void operator() (std::string method, int data)
{
AnalysisMethod am = stringToMethod(method);
m_analysis_map[am](data);
}
};
It is used like so:
Analyzer a;
a("Smith-Jones Method", 0);
a("Pineapple-Mango Method", 0);
Demo
This has a bunch of advantages compared to simple switch statements:
It's easier to add/remove analysis methods
It's way easier to change the type of data which the methods accept
You could have different Analyzers for different areas, templated and specialized, and all you'd need to change would be the registration method.
You could enable/disable analysis methods at runtime in a very clear fashion