Question

There probably is a fairly simple and straight-forward answer for this, but for some reason I can’t see it.
I need to restrict calling methods from a class only to some methods implemented by derived classes of some interface.

Say I have

class A{
    public:
        static void foo();
};

class myInterface{
    public:
        virtual void onlyCallFooFromHere() = 0;
}

class myImplementation : public myInterface{
    public:
        virtual void onlyCallFooFromHere()
        {
            A::foo(); //this should work
        }
        void otherFoo()
        {
            A::foo(); //i want to get a compilation error here
        }

}

So I should be able to call A::foo only from the method onlyCallFooFromHere()

Is there a way to achieve this? I’m open to any suggestions, including changing the class design.

EDIT:

So… I feel there’s a need to further explain the issue. I have a utility class which interacts with a database (mainly updates records) – class A.
In my interface (which represents a basic database objects) I have the virtual function updateRecord() from which I call methods from the db utility class. I want to enforce updating the database only in the updateRecord() function of all extending classes and nowhere else. I don’t believe this to be a bad design choice, even if not possible. However, if indeed not possible, I would appreciate a different solution.

Answer 1

[Disclaimer: this solution will stop Murphy, not Macchiavelli.]

How about:

class DatabaseQueryInterface {
public:
  ~virtual DatabseQueryInterface() = 0;
  virtual Query compileQuery() const = 0; // or whatever
  virtual ResultSet runQuery(const Query&) const = 0; // etc
};

class DatabaseUpdateInterface : public DatabaseQueryInterface {
public:
   virtual Update compileUpdate() const = 0; // whatever
};

class DatabaseObject {
public:
  virtual ~DatabaseObject() = 0;
protected:
  virtual void queryRecord(const DatabaseQueryInterface& interface) = 0;
  virtual void updateRecord(const DatabaseUpdateInterface& interface) = 0;
};

class SomeConcreteDatabaseObject : public DatabaseObject {
  protected:
     virtual void updateRecord(const DatabaseUpdateInterface& interface) {
        // gets to use interface->compileUpdate()
     }

     virtual void queryRecord(const DatabaseQueryInterface& interface) {
        // only gets query methods, no updates
     }
};

So the basic idea is that your DatabaseObject base class squirrels away a private Query object and a private Update object and when it comes time to call the protected members of the subclass it hands off the Update interface to the updateRecord() method, and the Query interface to the queryRecord() method.

That way the natural thing for the subclasses is to use the object they are passed to talk to the database. Of course they can always resort to dirty tricks to store away a passed-in Update object and try to use it later from a query method, but frankly if they go to such lengths, they’re on their own.