SERVER-36094 Add override/final to DBClientBase methods

5 files changed, 123 insertions, 102 deletions

diff --git a/src/mongo/client/dbclient_base.h b/src/mongo/client/dbclient_base.h
index cee91bd8bf0..ef8333fcf34 100644
--- a/src/mongo/client/dbclient_base.h
+++ b/src/mongo/client/dbclient_base.h
@@ -67,9 +67,35 @@ std::string nsGetDB(const std::string& ns);
 std::string nsGetCollection(const std::string& ns);
 
 /**
+ * This class pre-declares all the "query()" methods for DBClient so the subclasses can mark
+ * them as "final" or "override" as appropriate.
+ */
+class DBClientQueryInterface {
+    virtual std::unique_ptr<DBClientCursor> query(const std::string& ns,
+                                                  Query query,
+                                                  int nToReturn = 0,
+                                                  int nToSkip = 0,
+                                                  const BSONObj* fieldsToReturn = 0,
+                                                  int queryOptions = 0,
+                                                  int batchSize = 0) = 0;
+
+    virtual unsigned long long query(stdx::function<void(const BSONObj&)> f,
+                                     const std::string& ns,
+                                     Query query,
+                                     const BSONObj* fieldsToReturn = 0,
+                                     int queryOptions = 0) = 0;
+
+    virtual unsigned long long query(stdx::function<void(DBClientCursorBatchIterator&)> f,
+                                     const std::string& ns,
+                                     Query query,
+                                     const BSONObj* fieldsToReturn = 0,
+                                     int queryOptions = 0) = 0;
+};
+
+/**
  abstract class that implements the core db operations
  */
-class DBClientBase {
+class DBClientBase : public DBClientQueryInterface {
     MONGO_DISALLOW_COPYING(DBClientBase);
 
 public:
@@ -546,13 +572,13 @@ public:
      @return    cursor.   0 if error (connection failure)
      @throws AssertionException
     */
-    virtual std::unique_ptr<DBClientCursor> query(const std::string& ns,
-                                                  Query query,
-                                                  int nToReturn = 0,
-                                                  int nToSkip = 0,
-                                                  const BSONObj* fieldsToReturn = 0,
-                                                  int queryOptions = 0,
-                                                  int batchSize = 0);
+    std::unique_ptr<DBClientCursor> query(const std::string& ns,
+                                          Query query,
+                                          int nToReturn = 0,
+                                          int nToSkip = 0,
+                                          const BSONObj* fieldsToReturn = 0,
+                                          int queryOptions = 0,
+                                          int batchSize = 0) override;
 
 
     /** Uses QueryOption_Exhaust, when available.
@@ -563,17 +589,17 @@ public:
         Use the DBClientCursorBatchIterator version, below, if you want to do items in large
         blocks, perhaps to avoid granular locking and such.
      */
-    virtual unsigned long long query(stdx::function<void(const BSONObj&)> f,
-                                     const std::string& ns,
-                                     Query query,
-                                     const BSONObj* fieldsToReturn = 0,
-                                     int queryOptions = 0);
-
-    virtual unsigned long long query(stdx::function<void(DBClientCursorBatchIterator&)> f,
-                                     const std::string& ns,
-                                     Query query,
-                                     const BSONObj* fieldsToReturn = 0,
-                                     int queryOptions = 0);
+    unsigned long long query(stdx::function<void(const BSONObj&)> f,
+                             const std::string& ns,
+                             Query query,
+                             const BSONObj* fieldsToReturn = 0,
+                             int queryOptions = 0) final;
+
+    unsigned long long query(stdx::function<void(DBClientCursorBatchIterator&)> f,
+                             const std::string& ns,
+                             Query query,
+                             const BSONObj* fieldsToReturn = 0,
+                             int queryOptions = 0) override;
 
 
     /** don't use this - called automatically by DBClientCursor for you
diff --git a/src/mongo/client/dbclient_connection.h b/src/mongo/client/dbclient_connection.h
index 9958c2d3bbe..39b1ff057cc 100644
--- a/src/mongo/client/dbclient_connection.h
+++ b/src/mongo/client/dbclient_connection.h
@@ -144,25 +144,25 @@ public:
      * @param info the result object for the logout command (provided for backwards
      *     compatibility with mongo shell)
      */
-    virtual void logout(const std::string& dbname, BSONObj& info);
-
-    virtual std::unique_ptr<DBClientCursor> query(const std::string& ns,
-                                                  Query query = Query(),
-                                                  int nToReturn = 0,
-                                                  int nToSkip = 0,
-                                                  const BSONObj* fieldsToReturn = 0,
-                                                  int queryOptions = 0,
-                                                  int batchSize = 0) {
+    void logout(const std::string& dbname, BSONObj& info) override;
+
+    std::unique_ptr<DBClientCursor> query(const std::string& ns,
+                                          Query query = Query(),
+                                          int nToReturn = 0,
+                                          int nToSkip = 0,
+                                          const BSONObj* fieldsToReturn = 0,
+                                          int queryOptions = 0,
+                                          int batchSize = 0) override {
         checkConnection();
         return DBClientBase::query(
             ns, query, nToReturn, nToSkip, fieldsToReturn, queryOptions, batchSize);
     }
 
-    virtual unsigned long long query(stdx::function<void(DBClientCursorBatchIterator&)> f,
-                                     const std::string& ns,
-                                     Query query,
-                                     const BSONObj* fieldsToReturn,
-                                     int queryOptions);
+    unsigned long long query(stdx::function<void(DBClientCursorBatchIterator&)> f,
+                             const std::string& ns,
+                             Query query,
+                             const BSONObj* fieldsToReturn,
+                             int queryOptions) override;
 
     using DBClientBase::runCommandWithTarget;
     std::pair<rpc::UniqueReply, DBClientBase*> runCommandWithTarget(OpMsgRequest request) override;
@@ -176,11 +176,11 @@ public:
        @return true if this connection is currently in a failed state.  When autoreconnect is on,
                a connection will transition back to an ok state after reconnecting.
      */
-    bool isFailed() const {
+    bool isFailed() const override {
         return _failed;
     }
 
-    bool isStillConnected();
+    bool isStillConnected() override;
 
     void setTags(transport::Session::TagMask tag);
 
@@ -199,7 +199,7 @@ public:
         return _maxWireVersion;
     }
 
-    std::string toString() const {
+    std::string toString() const override {
         std::stringstream ss;
         ss << _serverAddress;
         if (!_resolvedAddress.empty())
@@ -209,29 +209,32 @@ public:
         return ss.str();
     }
 
-    std::string getServerAddress() const {
+    std::string getServerAddress() const override {
         return _serverAddress.toString();
     }
     const HostAndPort& getServerHostAndPort() const {
         return _serverAddress;
     }
 
-    virtual void say(Message& toSend, bool isRetry = false, std::string* actualServer = 0);
-    virtual bool recv(Message& m, int lastRequestId);
-    virtual void checkResponse(const std::vector<BSONObj>& batch,
-                               bool networkError,
-                               bool* retry = NULL,
-                               std::string* host = NULL);
-    virtual bool call(Message& toSend, Message& response, bool assertOk, std::string* actualServer);
-    virtual ConnectionString::ConnectionType type() const {
+    void say(Message& toSend, bool isRetry = false, std::string* actualServer = 0) override;
+    bool recv(Message& m, int lastRequestId) override;
+    void checkResponse(const std::vector<BSONObj>& batch,
+                       bool networkError,
+                       bool* retry = NULL,
+                       std::string* host = NULL) override;
+    bool call(Message& toSend,
+              Message& response,
+              bool assertOk,
+              std::string* actualServer) override;
+    ConnectionString::ConnectionType type() const override {
         return ConnectionString::MASTER;
     }
     void setSoTimeout(double timeout);
-    double getSoTimeout() const {
+    double getSoTimeout() const override {
         return _socketTimeout.value_or(Milliseconds{0}).count() / 1000.0;
     }
 
-    virtual bool lazySupported() const {
+    bool lazySupported() const override {
         return true;
     }
 
@@ -271,7 +274,7 @@ protected:
     bool _isReplicaSetMember = false;
     bool _isMongos = false;
 
-    virtual void _auth(const BSONObj& params);
+    void _auth(const BSONObj& params) override;
 
     transport::SessionHandle _session;
     boost::optional<Milliseconds> _socketTimeout;
diff --git a/src/mongo/client/dbclient_rs.h b/src/mongo/client/dbclient_rs.h
index 27d0c3acb5a..fb7fb748079 100644
--- a/src/mongo/client/dbclient_rs.h
+++ b/src/mongo/client/dbclient_rs.h
@@ -78,36 +78,36 @@ public:
      * @param info the result object for the logout command (provided for backwards
      *     compatibility with mongo shell)
      */
-    virtual void logout(const std::string& dbname, BSONObj& info);
+    void logout(const std::string& dbname, BSONObj& info) override;
 
     // ----------- simple functions --------------
 
     /** throws userassertion "no master found" */
-    virtual std::unique_ptr<DBClientCursor> query(const std::string& ns,
-                                                  Query query,
-                                                  int nToReturn = 0,
-                                                  int nToSkip = 0,
-                                                  const BSONObj* fieldsToReturn = 0,
-                                                  int queryOptions = 0,
-                                                  int batchSize = 0);
+    std::unique_ptr<DBClientCursor> query(const std::string& ns,
+                                          Query query,
+                                          int nToReturn = 0,
+                                          int nToSkip = 0,
+                                          const BSONObj* fieldsToReturn = 0,
+                                          int queryOptions = 0,
+                                          int batchSize = 0) override;
 
     /** throws userassertion "no master found" */
-    virtual BSONObj findOne(const std::string& ns,
-                            const Query& query,
-                            const BSONObj* fieldsToReturn = 0,
-                            int queryOptions = 0);
+    BSONObj findOne(const std::string& ns,
+                    const Query& query,
+                    const BSONObj* fieldsToReturn = 0,
+                    int queryOptions = 0) override;
 
-    virtual void insert(const std::string& ns, BSONObj obj, int flags = 0);
+    void insert(const std::string& ns, BSONObj obj, int flags = 0) override;
 
     /** insert multiple objects.  Note that single object insert is asynchronous, so this version
         is only nominally faster and not worth a special effort to try to use.  */
-    virtual void insert(const std::string& ns, const std::vector<BSONObj>& v, int flags = 0);
+    void insert(const std::string& ns, const std::vector<BSONObj>& v, int flags = 0) override;
 
-    virtual void remove(const std::string& ns, Query obj, int flags);
+    void remove(const std::string& ns, Query obj, int flags) override;
 
-    virtual void update(const std::string& ns, Query query, BSONObj obj, int flags);
+    void update(const std::string& ns, Query query, BSONObj obj, int flags) override;
 
-    virtual void killCursor(const NamespaceString& ns, long long cursorID);
+    void killCursor(const NamespaceString& ns, long long cursorID) override;
 
     // ---- access raw connections ----
 
@@ -130,12 +130,12 @@ public:
 
     // ---- callback pieces -------
 
-    virtual void say(Message& toSend, bool isRetry = false, std::string* actualServer = 0);
-    virtual bool recv(Message& toRecv, int lastRequestId);
-    virtual void checkResponse(const std::vector<BSONObj>& batch,
-                               bool networkError,
-                               bool* retry = NULL,
-                               std::string* targetHost = NULL);
+    void say(Message& toSend, bool isRetry = false, std::string* actualServer = 0) override;
+    bool recv(Message& toRecv, int lastRequestId) override;
+    void checkResponse(const std::vector<BSONObj>& batch,
+                       bool networkError,
+                       bool* retry = NULL,
+                       std::string* targetHost = NULL) override;
 
     /* this is the callback from our underlying connections to notify us that we got a "not master"
      * error.
@@ -148,10 +148,10 @@ public:
 
     // ----- status ------
 
-    virtual bool isFailed() const {
+    bool isFailed() const override {
         return !_master || _master->isFailed();
     }
-    bool isStillConnected();
+    bool isStillConnected() override;
 
     // ----- informational ----
 
@@ -168,20 +168,20 @@ public:
      */
     HostAndPort getSuspectedPrimaryHostAndPort() const;
 
-    double getSoTimeout() const {
+    double getSoTimeout() const override {
         return _so_timeout;
     }
 
-    std::string toString() const {
+    std::string toString() const override {
         return getServerAddress();
     }
 
-    std::string getServerAddress() const;
+    std::string getServerAddress() const override;
 
-    virtual ConnectionString::ConnectionType type() const {
+    ConnectionString::ConnectionType type() const override {
         return ConnectionString::SET;
     }
-    virtual bool lazySupported() const {
+    bool lazySupported() const override {
         return true;
     }
 
@@ -199,7 +199,10 @@ public:
     int getMaxWireVersion() final;
     // ---- low level ------
 
-    virtual bool call(Message& toSend, Message& response, bool assertOk, std::string* actualServer);
+    bool call(Message& toSend,
+              Message& response,
+              bool assertOk,
+              std::string* actualServer) override;
 
     /**
      * Returns whether a query or command can be sent to secondaries based on the query object
@@ -217,7 +220,7 @@ public:
      * Performs a "soft reset" by clearing all states relating to secondary nodes and
      * returning secondary connections to the pool.
      */
-    virtual void reset();
+    void reset() override;
 
     bool isReplicaSetMember() const override {
         return true;
@@ -236,7 +239,7 @@ public:
 protected:
     /** Authorize.  Authorizes all nodes as needed
     */
-    virtual void _auth(const BSONObj& params);
+    void _auth(const BSONObj& params) override;
 
 private:
     /**
diff --git a/src/mongo/dbtests/mock/mock_dbclient_connection.cpp b/src/mongo/dbtests/mock/mock_dbclient_connection.cpp
index 802391855ec..52426ad4818 100644
--- a/src/mongo/dbtests/mock/mock_dbclient_connection.cpp
+++ b/src/mongo/dbtests/mock/mock_dbclient_connection.cpp
@@ -121,15 +121,6 @@ string MockDBClientConnection::toString() const {
     return _remoteServer->toString();
 }
 
-unsigned long long MockDBClientConnection::query(stdx::function<void(const BSONObj&)> f,
-                                                 const string& ns,
-                                                 mongo::Query query,
-                                                 const BSONObj* fieldsToReturn,
-                                                 int queryOptions) {
-    verify(false);
-    return 0;
-}
-
 unsigned long long MockDBClientConnection::query(
     stdx::function<void(mongo::DBClientCursorBatchIterator&)> f,
     const std::string& ns,
diff --git a/src/mongo/dbtests/mock/mock_dbclient_connection.h b/src/mongo/dbtests/mock/mock_dbclient_connection.h
index bcecd30d37f..2e78ae67799 100644
--- a/src/mongo/dbtests/mock/mock_dbclient_connection.h
+++ b/src/mongo/dbtests/mock/mock_dbclient_connection.h
@@ -57,10 +57,13 @@ public:
     //
     // DBClientBase methods
     //
+    using DBClientBase::query;
 
     bool connect(const char* hostName, StringData applicationName, std::string& errmsg);
 
-    inline bool connect(const HostAndPort& host, StringData applicationName, std::string& errmsg) {
+    inline bool connect(const HostAndPort& host,
+                        StringData applicationName,
+                        std::string& errmsg) override {
         return connect(host.toString().c_str(), applicationName, errmsg);
     }
 
@@ -87,20 +90,15 @@ public:
     // Getters
     //
 
-    mongo::ConnectionString::ConnectionType type() const;
-    bool isFailed() const;
+    mongo::ConnectionString::ConnectionType type() const override;
+    bool isFailed() const override;
     double getSoTimeout() const override;
-    std::string getServerAddress() const;
-    std::string toString() const;
+    std::string getServerAddress() const override;
+    std::string toString() const override;
 
     //
     // Unsupported methods (defined to get rid of virtual function was hidden error)
     //
-    unsigned long long query(stdx::function<void(const mongo::BSONObj&)> f,
-                             const std::string& ns,
-                             mongo::Query query,
-                             const mongo::BSONObj* fieldsToReturn = 0,
-                             int queryOptions = 0) override;
 
     unsigned long long query(stdx::function<void(mongo::DBClientCursorBatchIterator&)> f,
                              const std::string& ns,
@@ -118,10 +116,10 @@ public:
               bool assertOk,
               std::string* actualServer) override;
     void say(mongo::Message& toSend, bool isRetry = false, std::string* actualServer = 0) override;
-    bool lazySupported() const;
+    bool lazySupported() const override;
 
 private:
-    void checkConnection();
+    void checkConnection() override;
 
     MockRemoteDBServer::InstanceID _remoteServerInstanceID;
     MockRemoteDBServer* _remoteServer;