SERVER-43000 Remove typedefs for vectors of OplogEntry

24 files changed, 132 insertions, 139 deletions

diff --git a/src/mongo/db/repl/apply_ops.cpp b/src/mongo/db/repl/apply_ops.cpp
index fdc1d412f6d..8ab2dffb19b 100644
--- a/src/mongo/db/repl/apply_ops.cpp
+++ b/src/mongo/db/repl/apply_ops.cpp
@@ -494,8 +494,8 @@ Status applyOps(OperationContext* opCtx,
 }
 
 // static
-MultiApplier::Operations ApplyOps::extractOperations(const OplogEntry& applyOpsOplogEntry) {
-    MultiApplier::Operations result;
+std::vector<OplogEntry> ApplyOps::extractOperations(const OplogEntry& applyOpsOplogEntry) {
+    std::vector<OplogEntry> result;
     extractOperationsTo(applyOpsOplogEntry, applyOpsOplogEntry.toBSON(), &result);
     return result;
 }
@@ -503,7 +503,7 @@ MultiApplier::Operations ApplyOps::extractOperations(const OplogEntry& applyOpsO
 // static
 void ApplyOps::extractOperationsTo(const OplogEntry& applyOpsOplogEntry,
                                    const BSONObj& topLevelDoc,
-                                   MultiApplier::Operations* operations) {
+                                   std::vector<OplogEntry>* operations) {
     uassert(ErrorCodes::TypeMismatch,
             str::stream() << "ApplyOps::extractOperations(): not a command: "
                           << redact(applyOpsOplogEntry.toBSON()),
diff --git a/src/mongo/db/repl/apply_ops.h b/src/mongo/db/repl/apply_ops.h
index 7489c94a486..470692d8dfb 100644
--- a/src/mongo/db/repl/apply_ops.h
+++ b/src/mongo/db/repl/apply_ops.h
@@ -50,7 +50,7 @@ public:
      * Extracts CRUD operations from an atomic applyOps oplog entry.
      * Throws UserException on error.
      */
-    static MultiApplier::Operations extractOperations(const OplogEntry& applyOpsOplogEntry);
+    static std::vector<OplogEntry> extractOperations(const OplogEntry& applyOpsOplogEntry);
 
     /**
      * This variant allows optimization for extracting multiple applyOps operations.  The entry for
@@ -60,7 +60,7 @@ public:
      */
     static void extractOperationsTo(const OplogEntry& applyOpsOplogEntry,
                                     const BSONObj& topLevelDoc,
-                                    MultiApplier::Operations* operations);
+                                    std::vector<OplogEntry>* operations);
 };
 
 /**
diff --git a/src/mongo/db/repl/data_replicator_external_state_mock.cpp b/src/mongo/db/repl/data_replicator_external_state_mock.cpp
index 68bf2798e06..10b4ae6fd3d 100644
--- a/src/mongo/db/repl/data_replicator_external_state_mock.cpp
+++ b/src/mongo/db/repl/data_replicator_external_state_mock.cpp
@@ -58,7 +58,8 @@ public:
 
 private:
     void _run(OplogBuffer* oplogBuffer) final {}
-    StatusWith<OpTime> _applyOplogBatch(OperationContext* opCtx, Operations ops) final {
+    StatusWith<OpTime> _applyOplogBatch(OperationContext* opCtx,
+                                        std::vector<OplogEntry> ops) final {
         return _externalState->applyOplogBatchFn(opCtx, ops, _observer);
     }
 
@@ -70,7 +71,7 @@ private:
 
 DataReplicatorExternalStateMock::DataReplicatorExternalStateMock()
     : applyOplogBatchFn([](OperationContext*,
-                           const MultiApplier::Operations& ops,
+                           const std::vector<OplogEntry>& ops,
                            OplogApplier::Observer*) { return ops.back().getOpTime(); }) {}
 
 executor::TaskExecutor* DataReplicatorExternalStateMock::getTaskExecutor() const {
diff --git a/src/mongo/db/repl/data_replicator_external_state_mock.h b/src/mongo/db/repl/data_replicator_external_state_mock.h
index 76aee22e70a..7aee165ce85 100644
--- a/src/mongo/db/repl/data_replicator_external_state_mock.h
+++ b/src/mongo/db/repl/data_replicator_external_state_mock.h
@@ -89,7 +89,7 @@ public:
 
     // Override to change applyOplogBatch behavior.
     using ApplyOplogBatchFn = std::function<StatusWith<OpTime>(
-        OperationContext*, MultiApplier::Operations, OplogApplier::Observer*)>;
+        OperationContext*, std::vector<OplogEntry>, OplogApplier::Observer*)>;
     ApplyOplogBatchFn applyOplogBatchFn;
 
     StatusWith<ReplSetConfig> replSetConfigResult = ReplSetConfig();
diff --git a/src/mongo/db/repl/initial_syncer.cpp b/src/mongo/db/repl/initial_syncer.cpp
index bd8bdbbbf7e..363358dbe29 100644
--- a/src/mongo/db/repl/initial_syncer.cpp
+++ b/src/mongo/db/repl/initial_syncer.cpp
@@ -122,7 +122,6 @@ using namespace executor;
 using CallbackArgs = executor::TaskExecutor::CallbackArgs;
 using Event = executor::TaskExecutor::EventHandle;
 using Handle = executor::TaskExecutor::CallbackHandle;
-using Operations = MultiApplier::Operations;
 using QueryResponseStatus = StatusWith<Fetcher::QueryResponse>;
 using UniqueLock = stdx::unique_lock<Latch>;
 using LockGuard = stdx::lock_guard<Latch>;
@@ -1240,7 +1239,7 @@ void InitialSyncer::_getNextApplierBatchCallback(
     if (!ops.empty()) {
         _fetchCount.store(0);
         MultiApplier::MultiApplyFn applyBatchOfOperationsFn = [this](OperationContext* opCtx,
-                                                                     MultiApplier::Operations ops) {
+                                                                     std::vector<OplogEntry> ops) {
             return _oplogApplier->applyOplogBatch(opCtx, std::move(ops));
         };
         OpTime lastApplied = ops.back().getOpTime();
@@ -1688,12 +1687,12 @@ void InitialSyncer::_shutdownComponent_inlock(Component& component) {
     component->shutdown();
 }
 
-StatusWith<Operations> InitialSyncer::_getNextApplierBatch_inlock() {
+StatusWith<std::vector<OplogEntry>> InitialSyncer::_getNextApplierBatch_inlock() {
     // If the fail-point is active, delay the apply batch by returning an empty batch so that
     // _getNextApplierBatchCallback() will reschedule itself at a later time.
     // See InitialSyncerOptions::getApplierBatchCallbackRetryWait.
     if (MONGO_unlikely(rsSyncApplyStop.shouldFail())) {
-        return Operations();
+        return std::vector<OplogEntry>();
     }
 
     // Obtain next batch of operations from OplogApplier.
diff --git a/src/mongo/db/repl/initial_syncer.h b/src/mongo/db/repl/initial_syncer.h
index 59d95acc506..6d3b1293b8d 100644
--- a/src/mongo/db/repl/initial_syncer.h
+++ b/src/mongo/db/repl/initial_syncer.h
@@ -527,7 +527,7 @@ private:
     void _appendInitialSyncProgressMinimal_inlock(BSONObjBuilder* bob) const;
     BSONObj _getInitialSyncProgress_inlock() const;
 
-    StatusWith<MultiApplier::Operations> _getNextApplierBatch_inlock();
+    StatusWith<std::vector<OplogEntry>> _getNextApplierBatch_inlock();
 
     /**
      * Schedules a fetcher to get the last oplog entry from the sync source.
diff --git a/src/mongo/db/repl/initial_syncer_test.cpp b/src/mongo/db/repl/initial_syncer_test.cpp
index c1ee51b42b2..bc64db24df7 100644
--- a/src/mongo/db/repl/initial_syncer_test.cpp
+++ b/src/mongo/db/repl/initial_syncer_test.cpp
@@ -3712,7 +3712,7 @@ TEST_F(InitialSyncerTest, InitialSyncerPassesThroughMultiApplierCallbackError) {
     auto opCtx = makeOpCtx();
 
     getExternalState()->applyOplogBatchFn =
-        [](OperationContext*, const MultiApplier::Operations&, OplogApplier::Observer*) {
+        [](OperationContext*, const std::vector<OplogEntry>&, OplogApplier::Observer*) {
             return Status(ErrorCodes::OperationFailed, "applyOplogBatch failed");
         };
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
diff --git a/src/mongo/db/repl/insert_group.cpp b/src/mongo/db/repl/insert_group.cpp
index 4c4f1c2e513..24acf95b0d2 100644
--- a/src/mongo/db/repl/insert_group.cpp
+++ b/src/mongo/db/repl/insert_group.cpp
@@ -56,7 +56,7 @@ constexpr auto kInsertGroupMaxOpCount = 64;
 
 }  // namespace
 
-InsertGroup::InsertGroup(MultiApplier::OperationPtrs* ops,
+InsertGroup::InsertGroup(std::vector<const OplogEntry*>* ops,
                          OperationContext* opCtx,
                          InsertGroup::Mode mode)
     : _doNotGroupBeforePoint(ops->cbegin()), _end(ops->cend()), _opCtx(opCtx), _mode(mode) {}
@@ -86,7 +86,7 @@ StatusWith<InsertGroup::ConstIterator> InsertGroup::groupAndApplyInserts(ConstIt
 
     // Make sure to include the first op in the group size.
     size_t groupSize = entry.getObject().objsize();
-    auto opCount = MultiApplier::OperationPtrs::size_type(1);
+    auto opCount = std::vector<const OplogEntry*>::size_type(1);
     auto groupNamespace = entry.getNss();
 
     /**
diff --git a/src/mongo/db/repl/insert_group.h b/src/mongo/db/repl/insert_group.h
index adc48753767..43b1b058c3f 100644
--- a/src/mongo/db/repl/insert_group.h
+++ b/src/mongo/db/repl/insert_group.h
@@ -40,7 +40,7 @@ namespace repl {
 /**
  * Groups consecutive insert operations on the same namespace and applies the combined operation
  * as a single oplog entry.
- * Advances the the MultiApplier::OperationPtrs iterator if the grouped insert is applied
+ * Advances the the std::vector<const OplogEntry*> iterator if the grouped insert is applied
  * successfully.
  */
 class InsertGroup {
@@ -48,10 +48,10 @@ class InsertGroup {
     InsertGroup& operator=(const InsertGroup&) = delete;
 
 public:
-    using ConstIterator = MultiApplier::OperationPtrs::const_iterator;
+    using ConstIterator = std::vector<const OplogEntry*>::const_iterator;
     using Mode = OplogApplication::Mode;
 
-    InsertGroup(MultiApplier::OperationPtrs* ops, OperationContext* opCtx, Mode mode);
+    InsertGroup(std::vector<const OplogEntry*>* ops, OperationContext* opCtx, Mode mode);
 
     /**
      * Attempts to group insert operations starting at 'iter'.
diff --git a/src/mongo/db/repl/multiapplier.cpp b/src/mongo/db/repl/multiapplier.cpp
index 02c993a0e67..e4c9a20079f 100644
--- a/src/mongo/db/repl/multiapplier.cpp
+++ b/src/mongo/db/repl/multiapplier.cpp
@@ -42,7 +42,7 @@ namespace mongo {
 namespace repl {
 
 MultiApplier::MultiApplier(executor::TaskExecutor* executor,
-                           const Operations& operations,
+                           const std::vector<OplogEntry>& operations,
                            const MultiApplyFn& multiApply,
                            CallbackFn onCompletion)
     : _executor(executor),
diff --git a/src/mongo/db/repl/multiapplier.h b/src/mongo/db/repl/multiapplier.h
index 22023e6eafc..bd77a7a8ba8 100644
--- a/src/mongo/db/repl/multiapplier.h
+++ b/src/mongo/db/repl/multiapplier.h
@@ -57,19 +57,12 @@ class MultiApplier {
 
 public:
     /**
-     * Operations sorted by timestamp in ascending order.
-     */
-    using Operations = std::vector<OplogEntry>;
-
-    using OperationPtrs = std::vector<const OplogEntry*>;
-
-    /**
      * Callback function to report final status of applying operations.
      */
     using CallbackFn = unique_function<void(const Status&)>;
 
     using MultiApplyFn =
-        std::function<StatusWith<OpTime>(OperationContext*, MultiApplier::Operations)>;
+        std::function<StatusWith<OpTime>(OperationContext*, std::vector<OplogEntry>)>;
 
     /**
      * Creates MultiApplier in inactive state.
@@ -85,7 +78,7 @@ public:
      * contained in 'operations' are not validated.
      */
     MultiApplier(executor::TaskExecutor* executor,
-                 const Operations& operations,
+                 const std::vector<OplogEntry>& operations,
                  const MultiApplyFn& multiApply,
                  CallbackFn onCompletion);
 
@@ -144,7 +137,7 @@ private:
     // Not owned by us.
     executor::TaskExecutor* _executor;
 
-    Operations _operations;
+    std::vector<OplogEntry> _operations;
     MultiApplyFn _multiApply;
     CallbackFn _onCompletion;
 
diff --git a/src/mongo/db/repl/multiapplier_test.cpp b/src/mongo/db/repl/multiapplier_test.cpp
index 663f85db19e..a48decf298c 100644
--- a/src/mongo/db/repl/multiapplier_test.cpp
+++ b/src/mongo/db/repl/multiapplier_test.cpp
@@ -85,8 +85,8 @@ OplogEntry makeOplogEntry(int ts) {
 }
 
 TEST_F(MultiApplierTest, InvalidConstruction) {
-    const MultiApplier::Operations operations{makeOplogEntry(123)};
-    auto multiApply = [](OperationContext*, MultiApplier::Operations) -> StatusWith<OpTime> {
+    const std::vector<OplogEntry> operations{makeOplogEntry(123)};
+    auto multiApply = [](OperationContext*, std::vector<OplogEntry>) -> StatusWith<OpTime> {
         return Status(ErrorCodes::InternalError, "not implemented");
     };
     auto callback = [](const Status&) {};
@@ -99,7 +99,7 @@ TEST_F(MultiApplierTest, InvalidConstruction) {
 
     // Empty list of operations.
     ASSERT_THROWS_CODE_AND_WHAT(
-        MultiApplier(&getExecutor(), MultiApplier::Operations(), multiApply, callback),
+        MultiApplier(&getExecutor(), std::vector<OplogEntry>(), multiApply, callback),
         AssertionException,
         ErrorCodes::BadValue,
         "empty list of operations");
@@ -120,9 +120,9 @@ TEST_F(MultiApplierTest, InvalidConstruction) {
 }
 
 TEST_F(MultiApplierTest, MultiApplierTransitionsDirectlyToCompleteIfShutdownBeforeStarting) {
-    const MultiApplier::Operations operations{makeOplogEntry(123)};
+    const std::vector<OplogEntry> operations{makeOplogEntry(123)};
 
-    auto multiApply = [](OperationContext*, MultiApplier::Operations) -> StatusWith<OpTime> {
+    auto multiApply = [](OperationContext*, std::vector<OplogEntry>) -> StatusWith<OpTime> {
         return OpTime();
     };
     auto callback = [](const Status&) {};
@@ -135,11 +135,11 @@ TEST_F(MultiApplierTest, MultiApplierTransitionsDirectlyToCompleteIfShutdownBefo
 }
 
 TEST_F(MultiApplierTest, MultiApplierInvokesCallbackWithCallbackCanceledStatusUponCancellation) {
-    const MultiApplier::Operations operations{makeOplogEntry(123)};
+    const std::vector<OplogEntry> operations{makeOplogEntry(123)};
 
     bool multiApplyInvoked = false;
     auto multiApply = [&](OperationContext* opCtx,
-                          MultiApplier::Operations operations) -> StatusWith<OpTime> {
+                          std::vector<OplogEntry> operations) -> StatusWith<OpTime> {
         multiApplyInvoked = true;
         return operations.back().getOpTime();
     };
@@ -171,11 +171,11 @@ TEST_F(MultiApplierTest, MultiApplierInvokesCallbackWithCallbackCanceledStatusUp
 }
 
 TEST_F(MultiApplierTest, MultiApplierPassesMultiApplyErrorToCallback) {
-    const MultiApplier::Operations operations{makeOplogEntry(123)};
+    const std::vector<OplogEntry> operations{makeOplogEntry(123)};
 
     bool multiApplyInvoked = false;
     Status multiApplyError(ErrorCodes::OperationFailed, "multi apply failed");
-    auto multiApply = [&](OperationContext*, MultiApplier::Operations) -> StatusWith<OpTime> {
+    auto multiApply = [&](OperationContext*, std::vector<OplogEntry>) -> StatusWith<OpTime> {
         multiApplyInvoked = true;
         return multiApplyError;
     };
@@ -198,12 +198,12 @@ TEST_F(MultiApplierTest, MultiApplierPassesMultiApplyErrorToCallback) {
 }
 
 TEST_F(MultiApplierTest, MultiApplierCatchesMultiApplyExceptionAndConvertsToCallbackStatus) {
-    const MultiApplier::Operations operations{makeOplogEntry(123)};
+    const std::vector<OplogEntry> operations{makeOplogEntry(123)};
 
     bool multiApplyInvoked = false;
     Status multiApplyError(ErrorCodes::OperationFailed, "multi apply failed");
     auto multiApply = [&](OperationContext* opCtx,
-                          MultiApplier::Operations operations) -> StatusWith<OpTime> {
+                          std::vector<OplogEntry> operations) -> StatusWith<OpTime> {
         multiApplyInvoked = true;
         uassertStatusOK(multiApplyError);
         return operations.back().getOpTime();
@@ -229,12 +229,12 @@ TEST_F(MultiApplierTest, MultiApplierCatchesMultiApplyExceptionAndConvertsToCall
 TEST_F(
     MultiApplierTest,
     MultiApplierProvidesOperationContextToMultiApplyFunctionButDisposesBeforeInvokingFinishCallback) {
-    const MultiApplier::Operations operations{makeOplogEntry(123)};
+    const std::vector<OplogEntry> operations{makeOplogEntry(123)};
 
     OperationContext* multiApplyTxn = nullptr;
-    MultiApplier::Operations operationsToApply;
+    std::vector<OplogEntry> operationsToApply;
     auto multiApply = [&](OperationContext* opCtx,
-                          MultiApplier::Operations operations) -> StatusWith<OpTime> {
+                          std::vector<OplogEntry> operations) -> StatusWith<OpTime> {
         multiApplyTxn = opCtx;
         operationsToApply = operations;
         return operationsToApply.back().getOpTime();
@@ -283,10 +283,10 @@ TEST_F(MultiApplierTest, MultiApplierResetsOnCompletionCallbackFunctionPointerUp
     bool sharedCallbackStateDestroyed = false;
     auto sharedCallbackData = std::make_shared<SharedCallbackState>(&sharedCallbackStateDestroyed);
 
-    const MultiApplier::Operations operations{makeOplogEntry(123)};
+    const std::vector<OplogEntry> operations{makeOplogEntry(123)};
 
     auto multiApply = [&](OperationContext*,
-                          MultiApplier::Operations operations) -> StatusWith<OpTime> {
+                          std::vector<OplogEntry> operations) -> StatusWith<OpTime> {
         return operations.back().getOpTime();
     };
 
diff --git a/src/mongo/db/repl/oplog_applier.cpp b/src/mongo/db/repl/oplog_applier.cpp
index 91936537985..8872664b0c1 100644
--- a/src/mongo/db/repl/oplog_applier.cpp
+++ b/src/mongo/db/repl/oplog_applier.cpp
@@ -96,8 +96,8 @@ void OplogApplier::waitForSpace(OperationContext* opCtx, std::size_t size) {
  * Pushes operations read from sync source into oplog buffer.
  */
 void OplogApplier::enqueue(OperationContext* opCtx,
-                           Operations::const_iterator begin,
-                           Operations::const_iterator end) {
+                           std::vector<OplogEntry>::const_iterator begin,
+                           std::vector<OplogEntry>::const_iterator end) {
     OplogBuffer::Batch batch;
     for (auto i = begin; i != end; ++i) {
         batch.push_back(i->getRaw());
@@ -115,7 +115,8 @@ void OplogApplier::enqueue(OperationContext* opCtx,
     _oplogBuffer->push(opCtx, begin, end);
 }
 
-StatusWith<OpTime> OplogApplier::applyOplogBatch(OperationContext* opCtx, Operations ops) {
+StatusWith<OpTime> OplogApplier::applyOplogBatch(OperationContext* opCtx,
+                                                 std::vector<OplogEntry> ops) {
     _observer->onBatchBegin(ops);
     auto lastApplied = _applyOplogBatch(opCtx, std::move(ops));
     _observer->onBatchEnd(lastApplied, {});
diff --git a/src/mongo/db/repl/oplog_applier.h b/src/mongo/db/repl/oplog_applier.h
index 474b66adf30..301757d2f4b 100644
--- a/src/mongo/db/repl/oplog_applier.h
+++ b/src/mongo/db/repl/oplog_applier.h
@@ -84,8 +84,6 @@ public:
     // Used to report oplog application progress.
     class Observer;
 
-    using Operations = std::vector<OplogEntry>;
-
     /**
      * OpQueueBatcher is an implementation detail that should be abstracted from all levels above
      * the OplogApplier. Parts of the system that need to modify BatchLimits can do so through the
@@ -134,13 +132,13 @@ public:
 
     /**
      * Pushes operations read into oplog buffer.
-     * Accepts both Operations (OplogEntry) and OplogBuffer::Batch (BSONObj) iterators.
+     * Accepts both std::vector<OplogEntry> and OplogBuffer::Batch (BSONObj) iterators.
      * This supports current implementations of OplogFetcher and OplogBuffer which work in terms of
      * BSONObj.
      */
     void enqueue(OperationContext* opCtx,
-                 Operations::const_iterator begin,
-                 Operations::const_iterator end);
+                 std::vector<OplogEntry>::const_iterator begin,
+                 std::vector<OplogEntry>::const_iterator end);
     void enqueue(OperationContext* opCtx,
                  OplogBuffer::Batch::const_iterator begin,
                  OplogBuffer::Batch::const_iterator end);
@@ -158,7 +156,7 @@ public:
      *
      * TODO: remove when enqueue() is implemented.
      */
-    StatusWith<OpTime> applyOplogBatch(OperationContext* opCtx, Operations ops);
+    StatusWith<OpTime> applyOplogBatch(OperationContext* opCtx, std::vector<OplogEntry> ops);
 
     /**
      * Calls the OpQueueBatcher's getNextApplierBatch.
@@ -180,7 +178,8 @@ private:
      * Called from applyOplogBatch() to apply a batch of operations in parallel.
      * Implemented in subclasses but not visible otherwise.
      */
-    virtual StatusWith<OpTime> _applyOplogBatch(OperationContext* opCtx, Operations ops) = 0;
+    virtual StatusWith<OpTime> _applyOplogBatch(OperationContext* opCtx,
+                                                std::vector<OplogEntry> ops) = 0;
 
     // Used to schedule task for oplog application loop.
     // Not owned by us.
@@ -217,7 +216,7 @@ public:
      * Called when the OplogApplier is ready to start applying a batch of operations read from the
      * OplogBuffer.
      **/
-    virtual void onBatchBegin(const OplogApplier::Operations& operations) = 0;
+    virtual void onBatchBegin(const std::vector<OplogEntry>& operations) = 0;
 
     /**
      * When the OplogApplier has completed applying a batch of operations, it will call this
@@ -225,13 +224,13 @@ public:
      * will also be here.
      */
     virtual void onBatchEnd(const StatusWith<OpTime>& lastOpTimeApplied,
-                            const OplogApplier::Operations& operations) = 0;
+                            const std::vector<OplogEntry>& operations) = 0;
 };
 
 class NoopOplogApplierObserver : public repl::OplogApplier::Observer {
 public:
-    void onBatchBegin(const repl::OplogApplier::Operations&) final {}
-    void onBatchEnd(const StatusWith<repl::OpTime>&, const repl::OplogApplier::Operations&) final {}
+    void onBatchBegin(const std::vector<OplogEntry>&) final {}
+    void onBatchEnd(const StatusWith<repl::OpTime>&, const std::vector<OplogEntry>&) final {}
 };
 
 extern NoopOplogApplierObserver noopOplogApplierObserver;
diff --git a/src/mongo/db/repl/oplog_applier_impl.cpp b/src/mongo/db/repl/oplog_applier_impl.cpp
index 36e32743193..611a9215f3b 100644
--- a/src/mongo/db/repl/oplog_applier_impl.cpp
+++ b/src/mongo/db/repl/oplog_applier_impl.cpp
@@ -209,7 +209,7 @@ void processCrudOp(OperationContext* opCtx,
  * Adds a single oplog entry to the appropriate writer vector.
  */
 void addToWriterVector(OplogEntry* op,
-                       std::vector<MultiApplier::OperationPtrs>* writerVectors,
+                       std::vector<std::vector<const OplogEntry*>>* writerVectors,
                        uint32_t hash) {
     const uint32_t numWriters = writerVectors->size();
     auto& writer = (*writerVectors)[hash % numWriters];
@@ -223,8 +223,8 @@ void addToWriterVector(OplogEntry* op,
  * Adds a set of derivedOps to writerVectors.
  */
 void addDerivedOps(OperationContext* opCtx,
-                   MultiApplier::Operations* derivedOps,
-                   std::vector<MultiApplier::OperationPtrs>* writerVectors,
+                   std::vector<OplogEntry>* derivedOps,
+                   std::vector<std::vector<const OplogEntry*>>* writerVectors,
                    CachedCollectionProperties* collPropertiesCache) {
     for (auto&& op : *derivedOps) {
         auto hashedNs = StringMapHasher().hashed_key(op.getNss().ns());
@@ -236,7 +236,7 @@ void addDerivedOps(OperationContext* opCtx,
     }
 }
 
-void stableSortByNamespace(MultiApplier::OperationPtrs* oplogEntryPointers) {
+void stableSortByNamespace(std::vector<const OplogEntry*>* oplogEntryPointers) {
     auto nssComparator = [](const OplogEntry* l, const OplogEntry* r) {
         return l->getNss() < r->getNss();
     };
@@ -491,7 +491,7 @@ void OplogApplierImpl::_run(OplogBuffer* oplogBuffer) {
 void scheduleWritesToOplog(OperationContext* opCtx,
                            StorageInterface* storageInterface,
                            ThreadPool* writerPool,
-                           const MultiApplier::Operations& ops) {
+                           const std::vector<OplogEntry>& ops) {
     auto makeOplogWriterForRange = [storageInterface, &ops](size_t begin, size_t end) {
         // The returned function will be run in a separate thread after this returns. Therefore all
         // captures other than 'ops' must be by value since they will not be available. The caller
@@ -554,7 +554,7 @@ void scheduleWritesToOplog(OperationContext* opCtx,
 }
 
 StatusWith<OpTime> OplogApplierImpl::_applyOplogBatch(OperationContext* opCtx,
-                                                      MultiApplier::Operations ops) {
+                                                      std::vector<OplogEntry> ops) {
     invariant(!ops.empty());
 
     LOG(2) << "replication batch size is " << ops.size();
@@ -595,9 +595,10 @@ StatusWith<OpTime> OplogApplierImpl::_applyOplogBatch(OperationContext* opCtx,
         // - ops to update config.transactions. Normal writes to config.transactions in the
         //   primary don't create an oplog entry, so extract info from writes with transactions
         //   and create a pseudo oplog.
-        std::vector<MultiApplier::Operations> derivedOps;
+        std::vector<std::vector<OplogEntry>> derivedOps;
 
-        std::vector<MultiApplier::OperationPtrs> writerVectors(_writerPool->getStats().numThreads);
+        std::vector<std::vector<const OplogEntry*>> writerVectors(
+            _writerPool->getStats().numThreads);
         fillWriterVectors(opCtx, &ops, &writerVectors, &derivedOps);
 
         // Wait for writes to finish before applying ops.
@@ -724,9 +725,9 @@ StatusWith<OpTime> OplogApplierImpl::_applyOplogBatch(OperationContext* opCtx,
  */
 void OplogApplierImpl::_deriveOpsAndFillWriterVectors(
     OperationContext* opCtx,
-    MultiApplier::Operations* ops,
-    std::vector<MultiApplier::OperationPtrs>* writerVectors,
-    std::vector<MultiApplier::Operations>* derivedOps,
+    std::vector<OplogEntry>* ops,
+    std::vector<std::vector<const OplogEntry*>>* writerVectors,
+    std::vector<std::vector<OplogEntry>>* derivedOps,
     SessionUpdateTracker* sessionUpdateTracker) noexcept {
 
     LogicalSessionIdMap<std::vector<OplogEntry*>> partialTxnOps;
@@ -827,9 +828,9 @@ void OplogApplierImpl::_deriveOpsAndFillWriterVectors(
 
 void OplogApplierImpl::fillWriterVectors(
     OperationContext* opCtx,
-    MultiApplier::Operations* ops,
-    std::vector<MultiApplier::OperationPtrs>* writerVectors,
-    std::vector<MultiApplier::Operations>* derivedOps) noexcept {
+    std::vector<OplogEntry>* ops,
+    std::vector<std::vector<const OplogEntry*>>* writerVectors,
+    std::vector<std::vector<OplogEntry>>* derivedOps) noexcept {
 
     SessionUpdateTracker sessionUpdateTracker;
     _deriveOpsAndFillWriterVectors(opCtx, ops, writerVectors, derivedOps, &sessionUpdateTracker);
@@ -950,7 +951,7 @@ Status applyOplogEntryOrGroupedInserts(OperationContext* opCtx,
 }
 
 Status OplogApplierImpl::applyOplogBatchPerWorker(OperationContext* opCtx,
-                                                  MultiApplier::OperationPtrs* ops,
+                                                  std::vector<const OplogEntry*>* ops,
                                                   WorkerMultikeyPathInfo* workerMultikeyPathInfo) {
     UnreplicatedWritesBlock uwb(opCtx);
     DisableDocumentValidation validationDisabler(opCtx);
diff --git a/src/mongo/db/repl/oplog_applier_impl.h b/src/mongo/db/repl/oplog_applier_impl.h
index 4cc5e717bc3..a43e18dc41f 100644
--- a/src/mongo/db/repl/oplog_applier_impl.h
+++ b/src/mongo/db/repl/oplog_applier_impl.h
@@ -96,12 +96,12 @@ private:
      * to at least the last optime of the batch. If 'minValid' is already greater than or equal
      * to the last optime of this batch, it will not be updated.
      */
-    StatusWith<OpTime> _applyOplogBatch(OperationContext* opCtx, MultiApplier::Operations ops);
+    StatusWith<OpTime> _applyOplogBatch(OperationContext* opCtx, std::vector<OplogEntry> ops);
 
     void _deriveOpsAndFillWriterVectors(OperationContext* opCtx,
-                                        MultiApplier::Operations* ops,
-                                        std::vector<MultiApplier::OperationPtrs>* writerVectors,
-                                        std::vector<MultiApplier::Operations>* derivedOps,
+                                        std::vector<OplogEntry>* ops,
+                                        std::vector<std::vector<const OplogEntry*>>* writerVectors,
+                                        std::vector<std::vector<OplogEntry>>* derivedOps,
                                         SessionUpdateTracker* sessionUpdateTracker) noexcept;
 
     // Not owned by us.
@@ -120,23 +120,22 @@ private:
     OpTime _beginApplyingOpTime = OpTime();
 
     void fillWriterVectors(OperationContext* opCtx,
-                           MultiApplier::Operations* ops,
-                           std::vector<MultiApplier::OperationPtrs>* writerVectors,
-                           std::vector<MultiApplier::Operations>* derivedOps) noexcept;
+                           std::vector<OplogEntry>* ops,
+                           std::vector<std::vector<const OplogEntry*>>* writerVectors,
+                           std::vector<std::vector<OplogEntry>>* derivedOps) noexcept;
 
 protected:
     // Marked as protected for use in unit tests.
     /**
      * This function is used by the thread pool workers to write ops to the db.
-     * This consumes the passed in OperationPtrs and callers should not make any assumptions about
-     * the state of the container after calling. However, this function cannot modify the pointed-to
-     * operations because the OperationPtrs container contains const pointers.
+     * It modifies the passed-in vector, and callers should not make any assumptions about the
+     * state of the vector after calling. The OplogEntry objects themselves are not modified.
      *
      * This function has been marked as virtual to allow certain unit tests to skip oplog
      * application.
      */
     virtual Status applyOplogBatchPerWorker(OperationContext* opCtx,
-                                            MultiApplier::OperationPtrs* ops,
+                                            std::vector<const OplogEntry*>* ops,
                                             WorkerMultikeyPathInfo* workerMultikeyPathInfo);
 };
 
diff --git a/src/mongo/db/repl/oplog_applier_impl_test.cpp b/src/mongo/db/repl/oplog_applier_impl_test.cpp
index 9338da454d6..29dacb12728 100644
--- a/src/mongo/db/repl/oplog_applier_impl_test.cpp
+++ b/src/mongo/db/repl/oplog_applier_impl_test.cpp
@@ -298,14 +298,14 @@ public:
     using OplogApplierImpl::OplogApplierImpl;
 
     Status applyOplogBatchPerWorker(OperationContext* opCtx,
-                                    MultiApplier::OperationPtrs* ops,
+                                    std::vector<const OplogEntry*>* ops,
                                     WorkerMultikeyPathInfo* workerMultikeyPathInfo) override;
-    MultiApplier::Operations operationsApplied;
+    std::vector<OplogEntry> operationsApplied;
 };
 
 Status TrackOpsAppliedApplier::applyOplogBatchPerWorker(
     OperationContext* opCtx,
-    MultiApplier::OperationPtrs* ops,
+    std::vector<const OplogEntry*>* ops,
     WorkerMultikeyPathInfo* workerMultikeyPathInfo) {
     for (auto&& opPtr : *ops) {
         operationsApplied.push_back(*opPtr);
@@ -388,7 +388,7 @@ TEST_F(OplogApplierImplTest,
     NamespaceString nss("local." + _agent.getSuiteName() + "_" + _agent.getTestName());
     auto op = makeCreateCollectionOplogEntry({Timestamp(Seconds(1), 0), 1LL}, nss);
 
-    MultiApplier::OperationPtrs ops = {&op};
+    std::vector<const OplogEntry*> ops = {&op};
     WorkerMultikeyPathInfo pathInfo;
 
     TestApplyOplogGroupApplier oplogApplier(
@@ -1307,7 +1307,7 @@ void testWorkerMultikeyPaths(OperationContext* opCtx,
     TestApplyOplogGroupApplier oplogApplier(
         nullptr, nullptr, OplogApplier::Options(OplogApplication::Mode::kSecondary));
     WorkerMultikeyPathInfo pathInfo;
-    MultiApplier::OperationPtrs ops = {&op};
+    std::vector<const OplogEntry*> ops = {&op};
     ASSERT_OK(oplogApplier.applyOplogBatchPerWorker(opCtx, &ops, &pathInfo));
     ASSERT_EQ(pathInfo.size(), numPaths);
 }
@@ -1365,7 +1365,7 @@ TEST_F(OplogApplierImplTest, OplogApplicationThreadFuncAddsMultipleWorkerMultike
         TestApplyOplogGroupApplier oplogApplier(
             nullptr, nullptr, OplogApplier::Options(OplogApplication::Mode::kSecondary));
         WorkerMultikeyPathInfo pathInfo;
-        MultiApplier::OperationPtrs ops = {&opA, &opB};
+        std::vector<const OplogEntry*> ops = {&opA, &opB};
         ASSERT_OK(oplogApplier.applyOplogBatchPerWorker(_opCtx.get(), &ops, &pathInfo));
         ASSERT_EQ(pathInfo.size(), 2UL);
     }
@@ -1410,7 +1410,7 @@ TEST_F(OplogApplierImplTest, OplogApplicationThreadFuncFailsWhenCollectionCreati
 
     TestApplyOplogGroupApplier oplogApplier(
         nullptr, nullptr, OplogApplier::Options(OplogApplication::Mode::kSecondary));
-    MultiApplier::OperationPtrs ops = {&op};
+    std::vector<const OplogEntry*> ops = {&op};
     ASSERT_EQUALS(ErrorCodes::InvalidOptions,
                   oplogApplier.applyOplogBatchPerWorker(_opCtx.get(), &ops, nullptr));
 }
@@ -1527,7 +1527,7 @@ TEST_F(OplogApplierImplTest,
             docsInserted.push_back(docs);
         };
 
-    MultiApplier::Operations ops = {
+    std::vector<OplogEntry> ops = {
         createOp1, createOp2, insertOp1a, insertOp2a, insertOp1b, insertOp2b};
     ASSERT_OK(runOpsSteadyState(ops));
 
@@ -1559,11 +1559,11 @@ TEST_F(OplogApplierImplTest,
     // Generate operations to apply:
     // {create}, {insert_1}, {insert_2}, .. {insert_(limit)}, {insert_(limit+1)}
     std::size_t limit = 64;
-    MultiApplier::Operations insertOps;
+    std::vector<OplogEntry> insertOps;
     for (std::size_t i = 0; i < limit + 1; ++i) {
         insertOps.push_back(makeOp(nss));
     }
-    MultiApplier::Operations operationsToApply;
+    std::vector<OplogEntry> operationsToApply;
     operationsToApply.push_back(createOp);
     std::copy(insertOps.begin(), insertOps.end(), std::back_inserter(operationsToApply));
 
@@ -1614,13 +1614,13 @@ TEST_F(OplogApplierImplTest,
     int opSize = maxBatchSize / opsPerBatch - 500;  // Leave some room for other oplog fields.
 
     // Create the insert ops.
-    MultiApplier::Operations insertOps;
+    std::vector<OplogEntry> insertOps;
     int numOps = 4;
     for (int i = 0; i < numOps; i++) {
         insertOps.push_back(makeSizedInsertOp(nss, opSize, seconds++));
     }
 
-    MultiApplier::Operations operationsToApply;
+    std::vector<OplogEntry> operationsToApply;
     operationsToApply.push_back(createOp);
     std::copy(insertOps.begin(), insertOps.end(), std::back_inserter(operationsToApply));
 
@@ -1663,7 +1663,7 @@ TEST_F(OplogApplierImplTest,
     auto insertOpLarge = makeSizedInsertOp(nss, maxBatchSize, seconds++);
     auto insertOpSmall = makeSizedInsertOp(nss, 100, seconds++);
 
-    MultiApplier::Operations operationsToApply = {createOp, insertOpLarge, insertOpSmall};
+    std::vector<OplogEntry> operationsToApply = {createOp, insertOpLarge, insertOpSmall};
 
     // Each element in 'docsInserted' is a grouped insert operation.
     std::vector<std::vector<BSONObj>> docsInserted;
@@ -1699,9 +1699,9 @@ TEST_F(OplogApplierImplTest,
 
     // Create a sequence of 3 'insert' ops that can't be grouped because they are from different
     // namespaces.
-    MultiApplier::Operations operationsToApply = {makeOp(NamespaceString(testNs + "_1")),
-                                                  makeOp(NamespaceString(testNs + "_2")),
-                                                  makeOp(NamespaceString(testNs + "_3"))};
+    std::vector<OplogEntry> operationsToApply = {makeOp(NamespaceString(testNs + "_1")),
+                                                 makeOp(NamespaceString(testNs + "_2")),
+                                                 makeOp(NamespaceString(testNs + "_3"))};
 
     for (const auto& oplogEntry : operationsToApply) {
         createCollectionWithUuid(_opCtx.get(), oplogEntry.getNss());
@@ -1740,11 +1740,11 @@ TEST_F(OplogApplierImplTest,
     // Generate operations to apply:
     // {create}, {insert_1}, {insert_2}, .. {insert_(limit)}, {insert_(limit+1)}
     std::size_t limit = 64;
-    MultiApplier::Operations insertOps;
+    std::vector<OplogEntry> insertOps;
     for (std::size_t i = 0; i < limit + 1; ++i) {
         insertOps.push_back(makeOp(nss));
     }
-    MultiApplier::Operations operationsToApply;
+    std::vector<OplogEntry> operationsToApply;
     operationsToApply.push_back(createOp);
     std::copy(insertOps.begin(), insertOps.end(), std::back_inserter(operationsToApply));
 
@@ -1794,7 +1794,7 @@ TEST_F(OplogApplierImplTest, ApplyGroupIgnoresUpdateOperationIfDocumentIsMissing
     }
     auto op = makeUpdateDocumentOplogEntry(
         {Timestamp(Seconds(1), 0), 1LL}, nss, BSON("_id" << 0), BSON("_id" << 0 << "x" << 2));
-    MultiApplier::OperationPtrs ops = {&op};
+    std::vector<const OplogEntry*> ops = {&op};
     WorkerMultikeyPathInfo pathInfo;
     ASSERT_OK(oplogApplier.applyOplogBatchPerWorker(_opCtx.get(), &ops, &pathInfo));
 
@@ -1817,7 +1817,7 @@ TEST_F(OplogApplierImplTest,
     auto op1 = makeInsertDocumentOplogEntry({Timestamp(Seconds(2), 0), 1LL}, nss, doc1);
     auto op2 = makeInsertDocumentOplogEntry({Timestamp(Seconds(3), 0), 1LL}, badNss, doc2);
     auto op3 = makeInsertDocumentOplogEntry({Timestamp(Seconds(4), 0), 1LL}, nss, doc3);
-    MultiApplier::OperationPtrs ops = {&op0, &op1, &op2, &op3};
+    std::vector<const OplogEntry*> ops = {&op0, &op1, &op2, &op3};
     WorkerMultikeyPathInfo pathInfo;
     ASSERT_OK(oplogApplier.applyOplogBatchPerWorker(_opCtx.get(), &ops, &pathInfo));
 
@@ -1843,7 +1843,7 @@ TEST_F(OplogApplierImplTest,
     auto op2 = makeCreateIndexOplogEntry(
         {Timestamp(Seconds(3), 0), 1LL}, badNss, "a_1", keyPattern, kUuid);
     auto op3 = makeInsertDocumentOplogEntry({Timestamp(Seconds(4), 0), 1LL}, nss, doc3);
-    MultiApplier::OperationPtrs ops = {&op0, &op1, &op2, &op3};
+    std::vector<const OplogEntry*> ops = {&op0, &op1, &op2, &op3};
     WorkerMultikeyPathInfo pathInfo;
     ASSERT_OK(oplogApplier.applyOplogBatchPerWorker(_opCtx.get(), &ops, &pathInfo));
 
diff --git a/src/mongo/db/repl/oplog_applier_impl_test_fixture.cpp b/src/mongo/db/repl/oplog_applier_impl_test_fixture.cpp
index 7e5c0cb4569..523bb93f1a1 100644
--- a/src/mongo/db/repl/oplog_applier_impl_test_fixture.cpp
+++ b/src/mongo/db/repl/oplog_applier_impl_test_fixture.cpp
@@ -208,7 +208,7 @@ Status OplogApplierImplTest::runOpsSteadyState(std::vector<OplogEntry> ops) {
         getConsistencyMarkers(),
         getStorageInterface(),
         repl::OplogApplier::Options(repl::OplogApplication::Mode::kSecondary));
-    MultiApplier::OperationPtrs opsPtrs;
+    std::vector<const OplogEntry*> opsPtrs;
     for (auto& op : ops) {
         opsPtrs.push_back(&op);
     }
diff --git a/src/mongo/db/repl/oplog_applier_test.cpp b/src/mongo/db/repl/oplog_applier_test.cpp
index 994a2cd02dd..efd8a75a421 100644
--- a/src/mongo/db/repl/oplog_applier_test.cpp
+++ b/src/mongo/db/repl/oplog_applier_test.cpp
@@ -55,7 +55,7 @@ public:
     explicit OplogApplierMock(OplogBuffer* oplogBuffer);
 
     void _run(OplogBuffer* oplogBuffer) final;
-    StatusWith<OpTime> _applyOplogBatch(OperationContext* opCtx, Operations ops) final;
+    StatusWith<OpTime> _applyOplogBatch(OperationContext* opCtx, std::vector<OplogEntry> ops) final;
 };
 
 OplogApplierMock::OplogApplierMock(OplogBuffer* oplogBuffer)
@@ -66,7 +66,8 @@ OplogApplierMock::OplogApplierMock(OplogBuffer* oplogBuffer)
 
 void OplogApplierMock::_run(OplogBuffer* oplogBuffer) {}
 
-StatusWith<OpTime> OplogApplierMock::_applyOplogBatch(OperationContext* opCtx, Operations ops) {
+StatusWith<OpTime> OplogApplierMock::_applyOplogBatch(OperationContext* opCtx,
+                                                      std::vector<OplogEntry> ops) {
     return OpTime();
 }
 
@@ -185,9 +186,9 @@ OplogEntry makeCommitTransactionOplogEntry(int t, StringData dbName, bool prepar
 }
 
 /**
- * Returns string representation of OplogApplier::Operations.
+ * Returns string representation of std::vector<OplogEntry>.
  */
-std::string toString(const OplogApplier::Operations& ops) {
+std::string toString(const std::vector<OplogEntry>& ops) {
     StringBuilder sb;
     sb << "[";
     for (const auto& op : ops) {
@@ -200,7 +201,7 @@ std::string toString(const OplogApplier::Operations& ops) {
 constexpr auto dbName = "test"_sd;
 
 TEST_F(OplogApplierTest, GetNextApplierBatchGroupsCrudOps) {
-    OplogApplier::Operations srcOps;
+    std::vector<OplogEntry> srcOps;
     srcOps.push_back(makeInsertOplogEntry(1, NamespaceString(dbName, "foo")));
     srcOps.push_back(makeInsertOplogEntry(2, NamespaceString(dbName, "bar")));
     _applier->enqueue(_opCtx.get(), srcOps.cbegin(), srcOps.cend());
@@ -212,7 +213,7 @@ TEST_F(OplogApplierTest, GetNextApplierBatchGroupsCrudOps) {
 }
 
 TEST_F(OplogApplierTest, GetNextApplierBatchReturnsPreparedApplyOpsOpInOwnBatch) {
-    OplogApplier::Operations srcOps;
+    std::vector<OplogEntry> srcOps;
     srcOps.push_back(makeApplyOpsOplogEntry(1, true));
     srcOps.push_back(makeInsertOplogEntry(2, NamespaceString(dbName, "bar")));
     _applier->enqueue(_opCtx.get(), srcOps.cbegin(), srcOps.cend());
@@ -223,7 +224,7 @@ TEST_F(OplogApplierTest, GetNextApplierBatchReturnsPreparedApplyOpsOpInOwnBatch)
 }
 
 TEST_F(OplogApplierTest, GetNextApplierBatchGroupsUnpreparedApplyOpsOpWithOtherOps) {
-    OplogApplier::Operations srcOps;
+    std::vector<OplogEntry> srcOps;
     srcOps.push_back(makeApplyOpsOplogEntry(1, false));
     srcOps.push_back(makeInsertOplogEntry(2, NamespaceString(dbName, "bar")));
     _applier->enqueue(_opCtx.get(), srcOps.cbegin(), srcOps.cend());
@@ -235,7 +236,7 @@ TEST_F(OplogApplierTest, GetNextApplierBatchGroupsUnpreparedApplyOpsOpWithOtherO
 }
 
 TEST_F(OplogApplierTest, GetNextApplierBatchReturnsSystemDotViewsOpInOwnBatch) {
-    OplogApplier::Operations srcOps;
+    std::vector<OplogEntry> srcOps;
     srcOps.push_back(makeInsertOplogEntry(
         1, NamespaceString(dbName, NamespaceString::kSystemDotViewsCollectionName)));
     srcOps.push_back(makeInsertOplogEntry(2, NamespaceString(dbName, "bar")));
@@ -247,7 +248,7 @@ TEST_F(OplogApplierTest, GetNextApplierBatchReturnsSystemDotViewsOpInOwnBatch) {
 }
 
 TEST_F(OplogApplierTest, GetNextApplierBatchReturnsServerConfigurationOpInOwnBatch) {
-    OplogApplier::Operations srcOps;
+    std::vector<OplogEntry> srcOps;
     srcOps.push_back(makeInsertOplogEntry(1, NamespaceString::kServerConfigurationNamespace));
     srcOps.push_back(makeInsertOplogEntry(2, NamespaceString(dbName, "bar")));
     _applier->enqueue(_opCtx.get(), srcOps.cbegin(), srcOps.cend());
@@ -258,7 +259,7 @@ TEST_F(OplogApplierTest, GetNextApplierBatchReturnsServerConfigurationOpInOwnBat
 }
 
 TEST_F(OplogApplierTest, GetNextApplierBatchReturnsPreparedCommitTransactionOpInOwnBatch) {
-    OplogApplier::Operations srcOps;
+    std::vector<OplogEntry> srcOps;
     srcOps.push_back(makeCommitTransactionOplogEntry(1, dbName, true, 3));
     srcOps.push_back(makeInsertOplogEntry(2, NamespaceString(dbName, "bar")));
     _applier->enqueue(_opCtx.get(), srcOps.cbegin(), srcOps.cend());
@@ -269,7 +270,7 @@ TEST_F(OplogApplierTest, GetNextApplierBatchReturnsPreparedCommitTransactionOpIn
 }
 
 TEST_F(OplogApplierTest, GetNextApplierBatchGroupsUnpreparedCommitTransactionOpWithOtherOps) {
-    OplogApplier::Operations srcOps;
+    std::vector<OplogEntry> srcOps;
     srcOps.push_back(makeCommitTransactionOplogEntry(1, dbName, false, 3));
     srcOps.push_back(makeInsertOplogEntry(2, NamespaceString(dbName, "bar")));
     _applier->enqueue(_opCtx.get(), srcOps.cbegin(), srcOps.cend());
@@ -281,7 +282,7 @@ TEST_F(OplogApplierTest, GetNextApplierBatchGroupsUnpreparedCommitTransactionOpW
 }
 
 TEST_F(OplogApplierTest, GetNextApplierBatchChecksBatchLimitsForNumberOfOperations) {
-    OplogApplier::Operations srcOps;
+    std::vector<OplogEntry> srcOps;
     srcOps.push_back(makeInsertOplogEntry(1, NamespaceString(dbName, "bar")));
     srcOps.push_back(makeInsertOplogEntry(2, NamespaceString(dbName, "bar")));
     srcOps.push_back(makeInsertOplogEntry(3, NamespaceString(dbName, "bar")));
@@ -307,7 +308,7 @@ TEST_F(OplogApplierTest, GetNextApplierBatchChecksBatchLimitsForNumberOfOperatio
 }
 
 TEST_F(OplogApplierTest, GetNextApplierBatchChecksBatchLimitsForSizeOfOperations) {
-    OplogApplier::Operations srcOps;
+    std::vector<OplogEntry> srcOps;
     srcOps.push_back(makeInsertOplogEntry(1, NamespaceString(dbName, "bar")));
     srcOps.push_back(makeInsertOplogEntry(2, NamespaceString(dbName, "bar")));
     srcOps.push_back(makeInsertOplogEntry(3, NamespaceString(dbName, "bar")));
@@ -330,7 +331,7 @@ TEST_F(OplogApplierTest, GetNextApplierBatchChecksBatchLimitsForSizeOfOperations
 
 TEST_F(OplogApplierTest,
        GetNextApplierBatchChecksBatchLimitsUsingEmbededCountInUnpreparedCommitTransactionOp1) {
-    OplogApplier::Operations srcOps;
+    std::vector<OplogEntry> srcOps;
     srcOps.push_back(makeInsertOplogEntry(1, NamespaceString(dbName, "bar")));
     srcOps.push_back(makeCommitTransactionOplogEntry(2, dbName, false, 3));
     srcOps.push_back(makeInsertOplogEntry(3, NamespaceString(dbName, "bar")));
@@ -353,7 +354,7 @@ TEST_F(OplogApplierTest,
 
 TEST_F(OplogApplierTest,
        GetNextApplierBatchChecksBatchLimitsUsingEmbededCountInUnpreparedCommitTransactionOp2) {
-    OplogApplier::Operations srcOps;
+    std::vector<OplogEntry> srcOps;
     srcOps.push_back(makeInsertOplogEntry(1, NamespaceString(dbName, "bar")));
     srcOps.push_back(makeInsertOplogEntry(2, NamespaceString(dbName, "bar")));
     srcOps.push_back(makeCommitTransactionOplogEntry(3, dbName, false, 3));
@@ -379,7 +380,7 @@ TEST_F(OplogApplierTest,
 
 TEST_F(OplogApplierTest,
        GetNextApplierBatchChecksBatchLimitsUsingEmbededCountInUnpreparedCommitTransactionOp3) {
-    OplogApplier::Operations srcOps;
+    std::vector<OplogEntry> srcOps;
     srcOps.push_back(makeInsertOplogEntry(1, NamespaceString(dbName, "bar")));
     srcOps.push_back(makeCommitTransactionOplogEntry(2, dbName, false, 5));
     srcOps.push_back(makeInsertOplogEntry(3, NamespaceString(dbName, "bar")));
diff --git a/src/mongo/db/repl/oplog_entry_or_grouped_inserts.h b/src/mongo/db/repl/oplog_entry_or_grouped_inserts.h
index d09a7f74f69..8b86fbd473f 100644
--- a/src/mongo/db/repl/oplog_entry_or_grouped_inserts.h
+++ b/src/mongo/db/repl/oplog_entry_or_grouped_inserts.h
@@ -41,8 +41,7 @@ namespace repl {
  */
 class OplogEntryOrGroupedInserts {
 public:
-    using OperationPtrs = std::vector<const OplogEntry*>;
-    using ConstIterator = OperationPtrs::const_iterator;
+    using ConstIterator = std::vector<const OplogEntry*>::const_iterator;
 
     OplogEntryOrGroupedInserts() = delete;
 
@@ -71,7 +70,7 @@ public:
         return _entryOrGroupedInserts.size() > 1;
     }
 
-    const OperationPtrs& getGroupedInserts() const {
+    const std::vector<const OplogEntry*>& getGroupedInserts() const {
         invariant(isGroupedInserts());
         return _entryOrGroupedInserts;
     }
@@ -81,7 +80,7 @@ public:
 
 private:
     // A single oplog entry or a batch of grouped insert oplog entries to be applied.
-    OperationPtrs _entryOrGroupedInserts;
+    std::vector<const OplogEntry*> _entryOrGroupedInserts;
 };
 }  // namespace repl
 }  // namespace mongo
diff --git a/src/mongo/db/repl/replication_recovery.cpp b/src/mongo/db/repl/replication_recovery.cpp
index 7c48135808b..5be259ad537 100644
--- a/src/mongo/db/repl/replication_recovery.cpp
+++ b/src/mongo/db/repl/replication_recovery.cpp
@@ -65,7 +65,7 @@ const auto kRecoveryOperationLogLevel = logger::LogSeverity::Debug(3);
  */
 class RecoveryOplogApplierStats : public OplogApplier::Observer {
 public:
-    void onBatchBegin(const OplogApplier::Operations& batch) final {
+    void onBatchBegin(const std::vector<OplogEntry>& batch) final {
         _numBatches++;
         LOG_FOR_RECOVERY(kRecoveryBatchLogLevel)
             << "Applying operations in batch: " << _numBatches << "(" << batch.size()
@@ -86,7 +86,7 @@ public:
         }
     }
 
-    void onBatchEnd(const StatusWith<OpTime>&, const OplogApplier::Operations&) final {}
+    void onBatchEnd(const StatusWith<OpTime>&, const std::vector<OplogEntry>&) final {}
 
     void complete(const OpTime& applyThroughOpTime) const {
         log() << "Applied " << _numOpsApplied << " operations in " << _numBatches
@@ -371,7 +371,7 @@ void ReplicationRecoveryImpl::_applyToEndOfOplog(OperationContext* opCtx,
     batchLimits.ops = getBatchLimitOplogEntries();
 
     OpTime applyThroughOpTime;
-    OplogApplier::Operations batch;
+    std::vector<OplogEntry> batch;
     while (
         !(batch = fassert(50763, oplogApplier.getNextApplierBatch(opCtx, batchLimits))).empty()) {
         applyThroughOpTime = uassertStatusOK(oplogApplier.applyOplogBatch(opCtx, std::move(batch)));
diff --git a/src/mongo/db/repl/transaction_oplog_application.cpp b/src/mongo/db/repl/transaction_oplog_application.cpp
index 4d887c90e27..71b344f7ac5 100644
--- a/src/mongo/db/repl/transaction_oplog_application.cpp
+++ b/src/mongo/db/repl/transaction_oplog_application.cpp
@@ -59,7 +59,7 @@ MONGO_FAIL_POINT_DEFINE(skipReconstructPreparedTransactions);
 
 // Apply the oplog entries for a prepare or a prepared commit during recovery/initial sync.
 Status _applyOperationsForTransaction(OperationContext* opCtx,
-                                      const repl::MultiApplier::Operations& ops,
+                                      const std::vector<OplogEntry>& ops,
                                       repl::OplogApplication::Mode oplogApplicationMode) {
     // Apply each the operations via repl::applyOperation.
     for (const auto& op : ops) {
@@ -228,14 +228,14 @@ Status applyAbortTransaction(OperationContext* opCtx,
     MONGO_UNREACHABLE;
 }
 
-repl::MultiApplier::Operations readTransactionOperationsFromOplogChain(
+std::vector<OplogEntry> readTransactionOperationsFromOplogChain(
     OperationContext* opCtx,
     const OplogEntry& lastEntryInTxn,
     const std::vector<OplogEntry*>& cachedOps) noexcept {
     // Traverse the oplog chain with its own snapshot and read timestamp.
     ReadSourceScope readSourceScope(opCtx);
 
-    repl::MultiApplier::Operations ops;
+    std::vector<OplogEntry> ops;
 
     // The cachedOps are the ops for this transaction that are from the same oplog application batch
     // as the commit or prepare, those which have not necessarily been written to the oplog.  These
diff --git a/src/mongo/db/repl/transaction_oplog_application.h b/src/mongo/db/repl/transaction_oplog_application.h
index ad85ccca6fa..add871d6dac 100644
--- a/src/mongo/db/repl/transaction_oplog_application.h
+++ b/src/mongo/db/repl/transaction_oplog_application.h
@@ -60,7 +60,7 @@ const repl::OplogEntry getPreviousOplogEntry(OperationContext* opCtx,
  * Follow an oplog chain and copy the operations to destination.  Operations will be copied in
  * forward oplog order (increasing optimes).
  */
-repl::MultiApplier::Operations readTransactionOperationsFromOplogChain(
+std::vector<repl::OplogEntry> readTransactionOperationsFromOplogChain(
     OperationContext* opCtx,
     const repl::OplogEntry& entry,
     const std::vector<repl::OplogEntry*>& cachedOps) noexcept;
diff --git a/src/mongo/dbtests/storage_timestamp_tests.cpp b/src/mongo/dbtests/storage_timestamp_tests.cpp
index 1c35aa31f09..8670b784130 100644
--- a/src/mongo/dbtests/storage_timestamp_tests.cpp
+++ b/src/mongo/dbtests/storage_timestamp_tests.cpp
@@ -145,8 +145,8 @@ BSONCollectionCatalogEntry::IndexMetaData getIndexMetaData(
 
 class DoNothingOplogApplierObserver : public repl::OplogApplier::Observer {
 public:
-    void onBatchBegin(const repl::OplogApplier::Operations&) final {}
-    void onBatchEnd(const StatusWith<repl::OpTime>&, const repl::OplogApplier::Operations&) final {}
+    void onBatchBegin(const std::vector<repl::OplogEntry>&) final {}
+    void onBatchEnd(const StatusWith<repl::OpTime>&, const std::vector<repl::OplogEntry>&) final {}
 };
 
 class StorageTimestampTest {
@@ -2513,7 +2513,7 @@ public:
           _taskFuture(taskFuture) {}
 
     Status applyOplogBatchPerWorker(OperationContext* opCtx,
-                                    repl::MultiApplier::OperationPtrs* operationsToApply,
+                                    std::vector<const repl::OplogEntry*>* operationsToApply,
                                     WorkerMultikeyPathInfo* pathInfo) override;
 
 private:
@@ -2530,7 +2530,7 @@ private:
 // and this test case fails without crashing the entire suite.
 Status SecondaryReadsDuringBatchApplicationAreAllowedApplier::applyOplogBatchPerWorker(
     OperationContext* opCtx,
-    repl::MultiApplier::OperationPtrs* operationsToApply,
+    std::vector<const repl::OplogEntry*>* operationsToApply,
     WorkerMultikeyPathInfo* pathInfo) {
     if (!_testOpCtx->lockState()->isLockHeldForMode(resourceIdParallelBatchWriterMode, MODE_X)) {
         return {ErrorCodes::BadValue, "Batch applied was not holding PBWM lock in MODE_X"};