Delegating whole class bad practice?

Question

Suppose I have the following struct:

struct Dimension
{
    void setDimension(Vector2i dim);
    Vector2i getDimension() const;
    bool canShowInformation();
}

And this struct uses the Dimension struct:

struct ApplicationState
{
    Dimension dim;
    State currentState;

    //Delegate everything to Dimension struct.
    void setDimension(Vector2i dim)
    {
        dim.setDimension(dim);
    }
    Vector2i getDimension() const
    {
        return dim.getDimension();
    }
    bool canShowInformation()
    {
        return canShowInformation();
    }
}

Is it bad to wrap almost all methods of Dimension struct in the ApplicationState struct? I do this so that I won't have long method calls like this:

appState.dim.setDimension(...)
//or
appState->dim.setDimension(...)

Is there a design principle or pattern which solves this problem?

Thanks in advance.

Answer 1

It depends on your design intention:

• If ApplicationState and Dimension address different concerns and may evolve due to different reasons, then it is fine.

• Likewise, if ApplicationState is just there for using a Dimension with another interface/protocol, then it is an adapter and is also fine.

• If ApplicationState is nothing else than a specialized Dimension, then this might be overkill.

To make up your design decision, you should also be aware that lots of appState.dim.dimOperation() creates a de facto coupling that works well in practice but makes the code difficult to maintain (see also principle of least knowledge).