SERVER-18579: Clang-Format - reformat code, no comment reflow

1 files changed, 286 insertions, 282 deletions

diff --git a/src/mongo/db/service_context.h b/src/mongo/db/service_context.h
index 066f6c6bc70..8f07c34d5a1 100644
--- a/src/mongo/db/service_context.h
+++ b/src/mongo/db/service_context.h
@@ -40,362 +40,366 @@
 
 namespace mongo {
 
-    class AbstractMessagingPort;
-    class Client;
-    class OperationContext;
-    class OpObserver;
+class AbstractMessagingPort;
+class Client;
+class OperationContext;
+class OpObserver;
 
+/**
+ * Classes that implement this interface can receive notification on killOp.
+ *
+ * See GlobalEnvironmentExperiment::registerKillOpListener() for more information, including
+ * limitations on the lifetime of registered listeners.
+ */
+class KillOpListenerInterface {
+public:
     /**
-     * Classes that implement this interface can receive notification on killOp.
-     *
-     * See GlobalEnvironmentExperiment::registerKillOpListener() for more information, including
-     * limitations on the lifetime of registered listeners.
+     * Will be called *after* ops have been told they should die.
+     * Callback must not fail.
      */
-    class KillOpListenerInterface {
-    public:
-        /**
-         * Will be called *after* ops have been told they should die.
-         * Callback must not fail.
-         */
-        virtual void interrupt(unsigned opId) = 0;
-        virtual void interruptAll() = 0;
+    virtual void interrupt(unsigned opId) = 0;
+    virtual void interruptAll() = 0;
 
-    protected:
-        // Should not delete through a pointer of this type
-        virtual ~KillOpListenerInterface() {}
-    };
+protected:
+    // Should not delete through a pointer of this type
+    virtual ~KillOpListenerInterface() {}
+};
+
+class StorageFactoriesIterator {
+    MONGO_DISALLOW_COPYING(StorageFactoriesIterator);
+
+public:
+    virtual ~StorageFactoriesIterator() {}
+    virtual bool more() const = 0;
+    virtual const StorageEngine::Factory* next() = 0;
 
-    class StorageFactoriesIterator {
-        MONGO_DISALLOW_COPYING(StorageFactoriesIterator);
+protected:
+    StorageFactoriesIterator() {}
+};
+
+/**
+ * Class representing the context of a service, such as a MongoD database service or
+ * a MongoS routing service.
+ *
+ * A ServiceContext is the root of a hierarchy of contexts.  A ServiceContext owns
+ * zero or more Clients, which in turn each own OperationContexts.
+ */
+class ServiceContext : public Decorable<ServiceContext> {
+    MONGO_DISALLOW_COPYING(ServiceContext);
+
+public:
+    /**
+     * Special deleter used for cleaning up Client objects owned by a ServiceContext.
+     * See UniqueClient, below.
+     */
+    class ClientDeleter {
     public:
-        virtual ~StorageFactoriesIterator() { }
-        virtual bool more() const = 0;
-        virtual const StorageEngine::Factory* next() = 0;
-    protected:
-        StorageFactoriesIterator() { }
+        void operator()(Client* client) const;
     };
 
     /**
-     * Class representing the context of a service, such as a MongoD database service or
-     * a MongoS routing service.
-     *
-     * A ServiceContext is the root of a hierarchy of contexts.  A ServiceContext owns
-     * zero or more Clients, which in turn each own OperationContexts.
+     * Observer interface implemented to hook client and operation context creation and
+     * destruction.
      */
-    class ServiceContext : public Decorable<ServiceContext> {
-        MONGO_DISALLOW_COPYING(ServiceContext);
+    class ClientObserver {
     public:
-        /**
-         * Special deleter used for cleaning up Client objects owned by a ServiceContext.
-         * See UniqueClient, below.
-         */
-        class ClientDeleter {
-        public:
-            void operator()(Client* client) const;
-        };
+        virtual ~ClientObserver() = default;
 
         /**
-         * Observer interface implemented to hook client and operation context creation and
-         * destruction.
-         */
-        class ClientObserver {
-        public:
-            virtual ~ClientObserver() = default;
-
-            /**
-             * Hook called after a new client "client" is created on a service by
-             * service->makeClient().
-             *
-             * For a given client and registered instance of ClientObserver, if onCreateClient
-             * returns without throwing an exception, onDestroyClient will be called when "client"
-             * is deleted.
-             */
-            virtual void onCreateClient(Client* client) = 0;
-
-            /**
-             * Hook called on a "client" created by a service before deleting "client".
-             *
-             * Like a destructor, must not throw exceptions.
-             */
-            virtual void onDestroyClient(Client* client) = 0;
-
-            /**
-             * Hook called after a new operation context is created on a client by
-             * service->makeOperationContext(client)  or client->makeOperationContext().
-             *
-             * For a given operation context and registered instance of ClientObserver, if
-             * onCreateOperationContext returns without throwing an exception,
-             * onDestroyOperationContext will be called when "opCtx" is deleted.
-             */
-            virtual void onCreateOperationContext(OperationContext* opCtx) = 0;
-
-            /**
-             * Hook called on a "opCtx" created by a service before deleting "opCtx".
-             *
-             * Like a destructor, must not throw exceptions.
-             */
-            virtual void onDestroyOperationContext(OperationContext* opCtx) = 0;
-        };
-
-        using ClientSet = unordered_set<Client*>;
-
-        /**
-         * Cursor for enumerating the live Client objects belonging to a ServiceContext.
+         * Hook called after a new client "client" is created on a service by
+         * service->makeClient().
          *
-         * Lifetimes of this type are synchronized with client creation and destruction.
-         */
-        class LockedClientsCursor {
-        public:
-            /**
-             * Constructs a cursor for enumerating the clients of "service", blocking "service" from
-             * creating or destroying Client objects until this instance is destroyed.
-             */
-            explicit LockedClientsCursor(ServiceContext* service);
-
-            /**
-             * Returns the next client in the enumeration, or nullptr if there are no more clients.
-             */
-            Client* next();
-
-        private:
-            stdx::unique_lock<stdx::mutex> _lock;
-            ClientSet::const_iterator _curr;
-            ClientSet::const_iterator _end;
-        };
-
-        /**
-         * Special deleter used for cleaning up OperationContext objects owned by a ServiceContext.
-         * See UniqueOperationContext, below.
-         */
-        class OperationContextDeleter {
-        public:
-            void operator()(OperationContext* opCtx) const;
-        };
-
-        /**
-         * This is the unique handle type for Clients created by a ServiceContext.
+         * For a given client and registered instance of ClientObserver, if onCreateClient
+         * returns without throwing an exception, onDestroyClient will be called when "client"
+         * is deleted.
          */
-        using UniqueClient = std::unique_ptr<Client, ClientDeleter>;
+        virtual void onCreateClient(Client* client) = 0;
 
         /**
-         * This is the unique handle type for OperationContexts created by a ServiceContext.
-         */
-        using UniqueOperationContext = std::unique_ptr<OperationContext, OperationContextDeleter>;
-
-        virtual ~ServiceContext();
-
-        /**
-         * Registers an observer of lifecycle events on Clients created by this ServiceContext.
-         *
-         * See the ClientObserver type, above, for details.
+         * Hook called on a "client" created by a service before deleting "client".
          *
-         * All calls to registerClientObserver must complete before ServiceContext
-         * is used in multi-threaded operation, or is used to create clients via calls
-         * to makeClient.
+         * Like a destructor, must not throw exceptions.
          */
-        void registerClientObserver(std::unique_ptr<ClientObserver> observer);
+        virtual void onDestroyClient(Client* client) = 0;
 
         /**
-         * Creates a new Client object representing a client session associated with this
-         * ServiceContext.
+         * Hook called after a new operation context is created on a client by
+         * service->makeOperationContext(client)  or client->makeOperationContext().
          *
-         * The "desc" string is used to set a descriptive name for the client, used in logging.
-         *
-         * If supplied, "p" is the communication channel used for communicating with the client.
+         * For a given operation context and registered instance of ClientObserver, if
+         * onCreateOperationContext returns without throwing an exception,
+         * onDestroyOperationContext will be called when "opCtx" is deleted.
          */
-        UniqueClient makeClient(std::string desc, AbstractMessagingPort* p = nullptr);
+        virtual void onCreateOperationContext(OperationContext* opCtx) = 0;
 
         /**
-         * Creates a new OperationContext on "client".
+         * Hook called on a "opCtx" created by a service before deleting "opCtx".
          *
-         * "client" must not have an active operation context.
+         * Like a destructor, must not throw exceptions.
          */
-        UniqueOperationContext makeOperationContext(Client* client);
+        virtual void onDestroyOperationContext(OperationContext* opCtx) = 0;
+    };
 
-        //
-        // Storage
-        //
-
-        /**
-         * Register a storage engine.  Called from a MONGO_INIT that depends on initializiation of
-         * the global environment.
-         * Ownership of 'factory' is transferred to global environment upon registration.
-         */
-        virtual void registerStorageEngine(const std::string& name,
-                                           const StorageEngine::Factory* factory) = 0;
+    using ClientSet = unordered_set<Client*>;
 
+    /**
+     * Cursor for enumerating the live Client objects belonging to a ServiceContext.
+     *
+     * Lifetimes of this type are synchronized with client creation and destruction.
+     */
+    class LockedClientsCursor {
+    public:
         /**
-         * Returns true if "name" refers to a registered storage engine.
+         * Constructs a cursor for enumerating the clients of "service", blocking "service" from
+         * creating or destroying Client objects until this instance is destroyed.
          */
-        virtual bool isRegisteredStorageEngine(const std::string& name) = 0;
+        explicit LockedClientsCursor(ServiceContext* service);
 
         /**
-         * Produce an iterator over all registered storage engine factories.
-         * Caller owns the returned object and is responsible for deleting when finished.
-         *
-         * Never returns nullptr.
+         * Returns the next client in the enumeration, or nullptr if there are no more clients.
          */
-        virtual StorageFactoriesIterator* makeStorageFactoriesIterator() = 0;
+        Client* next();
 
-        virtual void initializeGlobalStorageEngine() = 0;
+    private:
+        stdx::unique_lock<stdx::mutex> _lock;
+        ClientSet::const_iterator _curr;
+        ClientSet::const_iterator _end;
+    };
 
-        /**
-         * Shuts down storage engine cleanly and releases any locks on mongod.lock.
-         */
-        virtual void shutdownGlobalStorageEngineCleanly() = 0;
+    /**
+     * Special deleter used for cleaning up OperationContext objects owned by a ServiceContext.
+     * See UniqueOperationContext, below.
+     */
+    class OperationContextDeleter {
+    public:
+        void operator()(OperationContext* opCtx) const;
+    };
 
-        /**
-         * Return the storage engine instance we're using.
-         */
-        virtual StorageEngine* getGlobalStorageEngine() = 0;
+    /**
+     * This is the unique handle type for Clients created by a ServiceContext.
+     */
+    using UniqueClient = std::unique_ptr<Client, ClientDeleter>;
 
-        //
-        // Global operation management.  This may not belong here and there may be too many methods
-        // here.
-        //
+    /**
+     * This is the unique handle type for OperationContexts created by a ServiceContext.
+     */
+    using UniqueOperationContext = std::unique_ptr<OperationContext, OperationContextDeleter>;
 
-        /**
-         * Signal all OperationContext(s) that they have been killed.
-         */
-        virtual void setKillAllOperations() = 0;
+    virtual ~ServiceContext();
 
-        /**
-         * Reset the operation kill state after a killAllOperations.
-         * Used for testing.
-         */
-        virtual void unsetKillAllOperations() = 0;
+    /**
+     * Registers an observer of lifecycle events on Clients created by this ServiceContext.
+     *
+     * See the ClientObserver type, above, for details.
+     *
+     * All calls to registerClientObserver must complete before ServiceContext
+     * is used in multi-threaded operation, or is used to create clients via calls
+     * to makeClient.
+     */
+    void registerClientObserver(std::unique_ptr<ClientObserver> observer);
 
-        /**
-         * Get the state for killing all operations.
-         */
-        virtual bool getKillAllOperations() = 0;
+    /**
+     * Creates a new Client object representing a client session associated with this
+     * ServiceContext.
+     *
+     * The "desc" string is used to set a descriptive name for the client, used in logging.
+     *
+     * If supplied, "p" is the communication channel used for communicating with the client.
+     */
+    UniqueClient makeClient(std::string desc, AbstractMessagingPort* p = nullptr);
 
-        /**
-         * @param i opid of operation to kill
-         * @return if operation was found 
-         **/
-        virtual bool killOperation(unsigned int opId) = 0;
+    /**
+     * Creates a new OperationContext on "client".
+     *
+     * "client" must not have an active operation context.
+     */
+    UniqueOperationContext makeOperationContext(Client* client);
 
-        /**
-         * Kills all operations that have a Client that is associated with an incoming user
-         * connection, except for the one associated with txn.
-         */
-        virtual void killAllUserOperations(const OperationContext* txn) = 0;
+    //
+    // Storage
+    //
 
-        /**
-         * Registers a listener to be notified each time an op is killed.
-         *
-         * listener does not become owned by the environment. As there is currently no way to
-         * unregister, the listener object must outlive this ServiceContext object.
-         */
-        virtual void registerKillOpListener(KillOpListenerInterface* listener) = 0;
+    /**
+     * Register a storage engine.  Called from a MONGO_INIT that depends on initializiation of
+     * the global environment.
+     * Ownership of 'factory' is transferred to global environment upon registration.
+     */
+    virtual void registerStorageEngine(const std::string& name,
+                                       const StorageEngine::Factory* factory) = 0;
 
-        //
-        // Global OpObserver.
-        //
+    /**
+     * Returns true if "name" refers to a registered storage engine.
+     */
+    virtual bool isRegisteredStorageEngine(const std::string& name) = 0;
 
-        /**
-         * Set the OpObserver.
-         */
-        virtual void setOpObserver(std::unique_ptr<OpObserver> opObserver) = 0;
+    /**
+     * Produce an iterator over all registered storage engine factories.
+     * Caller owns the returned object and is responsible for deleting when finished.
+     *
+     * Never returns nullptr.
+     */
+    virtual StorageFactoriesIterator* makeStorageFactoriesIterator() = 0;
 
-        /**
-         * Return the OpObserver instance we're using.
-         */
-        virtual OpObserver* getOpObserver() = 0;
+    virtual void initializeGlobalStorageEngine() = 0;
 
-        /**
-         * Returns the tick source set in this context.
-         */
-        TickSource* getTickSource() const;
+    /**
+     * Shuts down storage engine cleanly and releases any locks on mongod.lock.
+     */
+    virtual void shutdownGlobalStorageEngineCleanly() = 0;
 
-        /**
-         * Replaces the current tick source with a new one. In other words, the old tick source
-         * will be destroyed. So make sure that no one is using the old tick source when
-         * calling this.
-         */
-        void setTickSource(std::unique_ptr<TickSource> newSource);
+    /**
+     * Return the storage engine instance we're using.
+     */
+    virtual StorageEngine* getGlobalStorageEngine() = 0;
 
-    protected:
-        ServiceContext() = default;
+    //
+    // Global operation management.  This may not belong here and there may be too many methods
+    // here.
+    //
 
-        /**
-         * Mutex used to synchronize access to mutable state of this ServiceContext instance,
-         * including possibly by its subclasses.
-         */
-        stdx::mutex _mutex;
+    /**
+     * Signal all OperationContext(s) that they have been killed.
+     */
+    virtual void setKillAllOperations() = 0;
 
-    private:
-        /**
-         * Returns a new OperationContext. Private, for use by makeOperationContext.
-         */
-        virtual std::unique_ptr<OperationContext> _newOpCtx(Client* client) = 0;
+    /**
+     * Reset the operation kill state after a killAllOperations.
+     * Used for testing.
+     */
+    virtual void unsetKillAllOperations() = 0;
 
-        /**
-         * Vector of registered observers.
-         */
-        std::vector<std::unique_ptr<ClientObserver>> _clientObservers;
-        ClientSet _clients;
+    /**
+     * Get the state for killing all operations.
+     */
+    virtual bool getKillAllOperations() = 0;
 
-        std::unique_ptr<TickSource> _tickSource;
-    };
+    /**
+     * @param i opid of operation to kill
+     * @return if operation was found
+     **/
+    virtual bool killOperation(unsigned int opId) = 0;
 
     /**
-     * Returns true if there is a global ServiceContext.
+     * Kills all operations that have a Client that is associated with an incoming user
+     * connection, except for the one associated with txn.
      */
-    bool hasGlobalServiceContext();
+    virtual void killAllUserOperations(const OperationContext* txn) = 0;
 
     /**
-     * Returns the singleton ServiceContext for this server process.
-     *
-     * Fatal if there is currently no global ServiceContext.
+     * Registers a listener to be notified each time an op is killed.
      *
-     * Caller does not own pointer.
+     * listener does not become owned by the environment. As there is currently no way to
+     * unregister, the listener object must outlive this ServiceContext object.
      */
-    ServiceContext* getGlobalServiceContext();
+    virtual void registerKillOpListener(KillOpListenerInterface* listener) = 0;
+
+    //
+    // Global OpObserver.
+    //
 
     /**
-     * Sets the global ServiceContext.  If 'serviceContext' is NULL, un-sets and deletes
-     * the current global ServiceContext.
-     *
-     * Takes ownership of 'serviceContext'.
+     * Set the OpObserver.
      */
-    void setGlobalServiceContext(std::unique_ptr<ServiceContext>&& serviceContext);
+    virtual void setOpObserver(std::unique_ptr<OpObserver> opObserver) = 0;
 
     /**
-     * Shortcut for querying the storage engine about whether it supports document-level locking.
-     * If this call becomes too expensive, we could cache the value somewhere so we don't have to
-     * fetch the storage engine every time.
+     * Return the OpObserver instance we're using.
      */
-    bool supportsDocLocking();
+    virtual OpObserver* getOpObserver() = 0;
 
     /**
-     * Returns true if the storage engine in use is MMAPV1.
+     * Returns the tick source set in this context.
      */
-    bool isMMAPV1();
-
-    /*
-     * Extracts the storageEngine bson from the CollectionOptions provided.  Loops through each
-     * provided storageEngine and asks the matching registered storage engine if the
-     * collection/index options are valid.  Returns an error if the collection/index options are
-     * invalid.
-     * If no matching registered storage engine is found, return an error.
-     * Validation function 'func' must be either:
-     * - &StorageEngine::Factory::validateCollectionStorageOptions; or
-     * - &StorageEngine::Factory::validateIndexStorageOptions
+    TickSource* getTickSource() const;
+
+    /**
+     * Replaces the current tick source with a new one. In other words, the old tick source
+     * will be destroyed. So make sure that no one is using the old tick source when
+     * calling this.
      */
-    Status validateStorageOptions(const BSONObj& storageEngineOptions,
-        stdx::function<Status (const StorageEngine::Factory* const, const BSONObj&)> validateFunc);
+    void setTickSource(std::unique_ptr<TickSource> newSource);
+
+protected:
+    ServiceContext() = default;
 
-    /*
-     * Returns a BSONArray containing the names of available storage engines, or an empty
-     * array if there is no global ServiceContext
+    /**
+     * Mutex used to synchronize access to mutable state of this ServiceContext instance,
+     * including possibly by its subclasses.
      */
-    BSONArray storageEngineList();
+    stdx::mutex _mutex;
 
-    /*
-     * Appends a the list of available storage engines to a BSONObjBuilder for reporting purposes.
+private:
+    /**
+     * Returns a new OperationContext. Private, for use by makeOperationContext.
      */
-    void appendStorageEngineList(BSONObjBuilder* result);
+    virtual std::unique_ptr<OperationContext> _newOpCtx(Client* client) = 0;
+
+    /**
+     * Vector of registered observers.
+     */
+    std::vector<std::unique_ptr<ClientObserver>> _clientObservers;
+    ClientSet _clients;
+
+    std::unique_ptr<TickSource> _tickSource;
+};
+
+/**
+ * Returns true if there is a global ServiceContext.
+ */
+bool hasGlobalServiceContext();
+
+/**
+ * Returns the singleton ServiceContext for this server process.
+ *
+ * Fatal if there is currently no global ServiceContext.
+ *
+ * Caller does not own pointer.
+ */
+ServiceContext* getGlobalServiceContext();
+
+/**
+ * Sets the global ServiceContext.  If 'serviceContext' is NULL, un-sets and deletes
+ * the current global ServiceContext.
+ *
+ * Takes ownership of 'serviceContext'.
+ */
+void setGlobalServiceContext(std::unique_ptr<ServiceContext>&& serviceContext);
+
+/**
+ * Shortcut for querying the storage engine about whether it supports document-level locking.
+ * If this call becomes too expensive, we could cache the value somewhere so we don't have to
+ * fetch the storage engine every time.
+ */
+bool supportsDocLocking();
+
+/**
+ * Returns true if the storage engine in use is MMAPV1.
+ */
+bool isMMAPV1();
+
+/*
+ * Extracts the storageEngine bson from the CollectionOptions provided.  Loops through each
+ * provided storageEngine and asks the matching registered storage engine if the
+ * collection/index options are valid.  Returns an error if the collection/index options are
+ * invalid.
+ * If no matching registered storage engine is found, return an error.
+ * Validation function 'func' must be either:
+ * - &StorageEngine::Factory::validateCollectionStorageOptions; or
+ * - &StorageEngine::Factory::validateIndexStorageOptions
+ */
+Status validateStorageOptions(
+    const BSONObj& storageEngineOptions,
+    stdx::function<Status(const StorageEngine::Factory* const, const BSONObj&)> validateFunc);
+
+/*
+ * Returns a BSONArray containing the names of available storage engines, or an empty
+ * array if there is no global ServiceContext
+ */
+BSONArray storageEngineList();
+
+/*
+ * Appends a the list of available storage engines to a BSONObjBuilder for reporting purposes.
+ */
+void appendStorageEngineList(BSONObjBuilder* result);
 
 }  // namespace mongo