Command pattern design

What is nice about design principles is that sooner or later, they conflict with each other.

In the situation described, I think I would prefer to go with some kind of context that each command can take information from and put information to (especially if those are key-value pairs). This is based on a trade off : I do not want separate commands to be coupled just because they are some kind of input to each other. Inside CommandB, I do not care how UserName was set - just that it is there for me to use. Same thing in CommandA : I set the information in, I do not want to know what other are doing with it - neither who they are.

This means a sort of passing context, which you can find bad. For me, the alternative is worse, especially if this simple key-value context (can be a simple bean with getters and setters, to limit a bit the "free form" factor) can allow the solution to be simple and testable, with well separated commands, each with its own business logic.

Lets assume you have a command interface:

class Command {
public:
    void execute() = 0;
};

And a subject:

class Subject {
    std::string name;
public:
    void setName(const std::string& name) {this->name = name;}
}

What you need is:

class NameObserver {
public:
    void update(const std::string& name) = 0;
};

class Subject {
    NameObserver& o;
    std::string name;
private:
    void setName(const std::string& name) {
        this->name = name;
        o.update(name);
    }
};

class CommandB: public Command, public NameObserver {
    std::string name;
public:
    void execute();
    void update(const std::string& name) {
        this->name = name;
        execute();
    }
};

Set NameObserver& o as a reference to CommandB. Now whenever CommandA changes the Subjects name CommandB can execute with the correct information. If name is used by more command use a std::list<NameObserver>

I don't know if this is the right way to handle this on Programmers (in which case I apologize), but, after having checked all the answers here (@Frank's in particular). I refactored my code this way:

• Dropped DIParameters. I'll have individual (generic) objects as DIOperation's input (immutable). Example:

class RelatedObjectTriplet {
private:
    std::string const m_sPrimaryObjectId;
    std::string const m_sSecondaryObjectId;
    std::string const m_sRelationObjectId;

    RelatedObjectTriplet& operator=(RelatedObjectTriplet other);

public:
    RelatedObjectTriplet(std::string const& sPrimaryObjectId,
                         std::string const& sSecondaryObjectId,
                         std::string const& sRelationObjectId);

    RelatedObjectTriplet(RelatedObjectTriplet const& other);


    std::string const& getPrimaryObjectId() const;
    std::string const& getSecondaryObjectId() const;
    std::string const& getRelationObjectId() const;

    ~RelatedObjectTriplet();
};

• New DIOperation class (with example) defined as:
  

template <class T = void> 
class DIOperation {
public:
    virtual int perform() = 0;

    virtual T getResult() = 0;

    virtual ~DIOperation() = 0;
};

class CreateRelation : public DIOperation<RelatedObjectTriplet> {
private:
    static std::string const TYPE;

    // Params (immutable)
    RelatedObjectTriplet const m_sParams;

    // Hidden
    CreateRelation & operator=(CreateRelation const& source);
    CreateRelation (CreateRelation const& source);

    // Internal
    std::string m_sNewRelationId;

public:
    CreateRelation(RelatedObjectTriplet const& params);

    int perform();

    RelatedObjectTriplet getResult();

    ~CreateRelation();
};

• It can be used like this:

RelatedObjectTriplet triplet("33333", "55555", "77777");
CreateRelation createRel(triplet);
createRel.perform();
const RelatedObjectTriplet res = createRel.getResult();

Thanks for the help and I hope I haven't made mistakes here :)