Question

Suppose I have the following classes:

class X;
class Y;

class Collection
{
   public:
      virtual void AddItemX(X*) = 0;
      virtual void AddItemY(Y*) = 0;
      //So on...
};

class Collector
{
   public:
      virtual void Fill(Collection&) = 0;
};

Is there any way to ensure that an implementation of Collector class will fill all the needed items in the passed Collection class?

Answer 1

One method, given a known number of AddItemX() calls is to move those AddItem() functions to protected and have the Collection class keep track of the additions and the number, e.g:

(I actually don’t like this solution, lol, but given your design it would suffice:)

class X;
class Y;

class Collection
{
private:
    int m_nItems;
    int m_nItemsAdded;

protected:
    virtual void AddItemXImpl(X&) = 0;
    virtual void AddItemYImpl(Y&) = 0;

public:
    Collection() : m_nItems(2), m_nItemsAdded(0){};

    void AddItemX(X& _x) {m_nMethodsAdded++; AddItemXImpl(_x); };
    void AddItemY(Y& _y) {m_nMethodsAdded++; AddItemYImpl(_y); };

    // function to find out if we're filled
    bool isFilled() const {return(m_nItemsAdded == m_nItems); };
}; // eo class Collection

EDIT: For clarification, your Collector could be implemented thusly:

class Collector
{
protected:
    virtual void FillImpl(Collection& _collection) = 0;

public:
    void Fill(Collection& _collection)
    {
        FillImpl(_collection);
        if(!_collection.isFilled())
            throw(std::exception("Not filled dammit!"));
    };
}; // eo class Collector