struct MyBadClass{
    double calculateTheta(){
        // complex calculation
        return theta;
    }   

    void toFile(std::string filename) const{
        // formatting here
    }

    void plot() const{
        // plotting
    }   
    // ...
};

Before, we had an object responsible for logic, formatting, serialization and visualisation

If we wanted to change the file format, we must change the class, even though the logic remains the same

Forces others to adopt changes, can cause merge conflicts, dependency issues, ...

How do you test MyBadClass?

struct MyBetterClass{
    double calculateTheta(){
        // complex calculation
        return theta;
    }   
    // other theta related stuff
};

// read and write operators
istream& operator>>(istream& is, MyBetterClass& myclass);
ostream& operator<<(ostream& os, const MyBetterClass& myclass);

// create a separate plotter object
struct MyBetterClassPlotter{
    void operator()(const MyBetterClass& myclass) const{
        // do plot
    }
};

void process(const std::vector< OptionEnum >& options, 
             const MyPlasmaObject& obj){
    for(auto option: options){
        switch(option){
            case DO_PLASMA_INIT:
                obj.plasma_init();
                // ...
            case DO_PLASMA_COMPUTE:
                // ...
            case DO_PLASMA_READ_FROM_FILE:
                // ...
            case DO_PLASMA_WRITE_TO_FILE:
                //.. 
            case DO_PLASMA_END:
                // ..
        }
    }
}

If we want to add another process, we needed to add another enum and switch statement to the process function

Before we know it we have 50+ switch statements, with 50+ enums!

Again, how do you test it?

Here process is not closed for modification and not open for extension

struct INonConstProcess{ // abstract base class
    virtual void go() = 0;
};

struct PlasmaComputeProcess : public INonConstProcess{
    PlasmaComputeProcess(MyPlasmaObject& obj) : _obj(obj) {}
    virtual void go() { 
        // logic here 
    }
};

struct ProcessManager{
    void add(const std::shared_ptr< INonConstProcess >& process){
        _processes.push_back(process);
    }
    void run() const{
        for(auto& process: _processes)
            process->go();
    }
    private:
        std::vector< std::shared_ptr< INonConstProcess > > _processes;
};

We've now made a ProcessManager to handle looping over all processes

Code is more modular and easier to understand

Now ProcessManager is closed for modification and is open for extension - just add a new process via add

No switch statement or any enums, just types

Very easy to mock to test logic

struct MockPlasmaComputeProcess : public INonConstProcess{
    virtual void go() { 
        std::cout << "Hello from mock!"; 
        // or asserts for testing library
    }
};

ProcessManager manager;
manager.add(std::make_shared< MockPlasmaComputeProcess >());
manager.run();

struct Plot{
    virtual void setXLabel(std::string label){
        _xlabel = label;
    }    
    virtual void setYLabel(std::string label){
        _ylabel = label;
    }
    // getters + other stuff + member vars
}

struct NormalisedHistogramPlot : public Plot{
    NormalisedHistogramPlot() : _ylabel("counts") {}

    virtual void setYLabel(std::string label) override{
        // problem: Throws exception 
        // since normalised histogram y label (in this case)
        // has a fixed ylabel 
        throw std::runtime_error(
            "NormalisedHistogramPlot::setYLabel - Should not be called!");
    }
}

// a silly test for demonstration purposes only
void testPlot(std::shared_ptr< Plot >& plot, 
              std::string property)
{
    plot->setXLabel("Energy (eV)");
    // this will throw an exception for NormalisedHistogramPlot
    plot->setYLabel(property);

    assert(plot->getXLabel() == "Energy (eV)");
    assert(plot->getYLabel() == property);
}        
                            

Fundamental architecture problem

NormalisedHistogramPlot is not a Plot

Not a is-a relationship

It is a has-a relationship - use composition

Better to rethink your object relationships and architecture

// very abstract interface
struct IEverything{
    virtual void validate() const = 0;
    virtual void reset() = 0;

    virtual int operator()() const = 0;
    virtual void operator()(int value) = 0;
    virtual operator bool() const = 0;

    // many others
};
                            

We should look at the single responsibility principle again

And the Liskov substitution principle

What if we want to build something that can be reset but not validated?

Again, testing is difficult - we must implement every method

// beware the 'ible's
struct IResetible{
    virtual void reset() = 0;
};

struct IConstValidatible{
    virtual void validate() const = 0;
};

struct ISimpleAccess{
    virtual int operator()() const = 0;
    virtual void operator()(int value) = 0;
    virtual operator bool() const = 0;
};
                                

// multiple inheritance for interfaces
struct NoCheatGuesser : public IConstValidatible,
                        public ISimpleAccess // no IResetible to avoid resetting guess count
{
    //...
}
                            

// our class depends on the implementation of VerySimpleLogger
struct MyCoolClass{

    void method1(){
        _logger.addMessage("Called method1!");
        //other stuff
    }
    // more stuff ...

  private:
    // to change this logger to another i.e. BetterLogger
    // from external library would cause
    // us to change the implementation in this class
    VerySimpleLogger _logger;
};                       

We are strongly coupled to implementation of VerySimpleLogger

We therefore break Open/Closed principle

What if we want to change our logging library to something better?

Did I mention testing?

// remember the I - only provide an interface for what you need
// we dictate the interface we need,
// we invert the dependency
// by depending on the interface,
// not the specific implementation of a logger
struct ISimpleLogger{
    virtual void append(std::string message) = 0;
    virtual size_t size() const = 0;
    virtual std::string get(int index) const = 0;
    virtual operator bool() const = 0;
};

// Wraps the simple logger
class SimpleLoggerAdapter : public ISimpleLogger{
    VerySimpleLogger _logger;
    // ...
};
// wraps the another logger 
struct AnotherLoggerAdapter : public ISimpleLogger{
    // ...
};

// our class depends on the interface we dictated
struct MyCoolClass{
    // create the class using construction injection
    MyCoolClass(ISimpleLogger& logger) : _logger(logger) {}
    // ...
  private:
    // this is now an interface
    // set by our code not the external library
    ISimpleLogger& _logger;
};

{
    // we can easily replace the logger now 
    SimpleLoggerAdapter logger;
    // AnotherLoggerAdapter logger;
    // MockNoErrorLogger logger;

    // class that depends on logger
    MyCoolClass cc(logger);

    // has error?
    if(logger){
        // ...
    }
}