Move the lambdas to be helper functions

Author: ximinez

src/libxrpl/ledger/ApplyView.cpp

@@ -24,6 +24,8 @@
 
 namespace ripple {
 
+namespace directory {
+
 struct Gap
 {
     uint64_t const page;
@@ -32,143 +34,155 @@ struct Gap
     SLE::pointer next;
 };
 
-std::optional<std::uint64_t>
-ApplyView::dirAdd(
-    bool preserveOrder,
+std::uint64_t
+createRoot(
+    ApplyView& view,
     Keylet const& directory,
     uint256 const& key,
     std::function<void(std::shared_ptr<SLE> const&)> const& describe)
 {
-    auto createRoot =
-        [this](
-            Keylet const& directory,
-            uint256 const& key,
-            std::function<void(std::shared_ptr<SLE> const&)> const& describe) {
-            auto newRoot = std::make_shared<SLE>(directory);
-            newRoot->setFieldH256(sfRootIndex, directory.key);
-            describe(newRoot);
+    auto newRoot = std::make_shared<SLE>(directory);
+    newRoot->setFieldH256(sfRootIndex, directory.key);
+    describe(newRoot);
 
-            STVector256 v;
-            v.push_back(key);
-            newRoot->setFieldV256(sfIndexes, v);
+    STVector256 v;
+    v.push_back(key);
+    newRoot->setFieldV256(sfIndexes, v);
 
-            insert(newRoot);
-            return std::uint64_t{0};
-        };
+    view.insert(newRoot);
+    return std::uint64_t{0};
+}
 
-    auto findPreviousPage = [this](Keylet const& directory, SLE::ref start) {
-        std::uint64_t page = start->getFieldU64(sfIndexPrevious);
+auto
+findPreviousPage(ApplyView& view, Keylet const& directory, SLE::ref start)
+{
+    std::uint64_t page = start->getFieldU64(sfIndexPrevious);
 
-        auto node = start;
+    auto node = start;
 
-        if (page)
-        {
-            node = peek(keylet::page(directory, page));
-            if (!node)
-                LogicError("Directory chain: root back-pointer broken.");
-        }
+    if (page)
+    {
+        node = view.peek(keylet::page(directory, page));
+        if (!node)
+            LogicError("Directory chain: root back-pointer broken.");
+    }
 
-        auto indexes = node->getFieldV256(sfIndexes);
-        return std::make_tuple(page, node, indexes);
-    };
-    auto insertKey = [this](
-                         SLE::ref node,
-                         std::uint64_t page,
-                         bool preserveOrder,
-                         STVector256& indexes,
-                         uint256 const& key) {
-        if (preserveOrder)
-        {
-            if (std::find(indexes.begin(), indexes.end(), key) != indexes.end())
-                LogicError("dirInsert: double insertion");
+    auto indexes = node->getFieldV256(sfIndexes);
+    return std::make_tuple(page, node, indexes);
+}
 
-            indexes.push_back(key);
-        }
-        else
-        {
-            // We can't be sure if this page is already sorted because
-            // it may be a legacy page we haven't yet touched. Take
-            // the time to sort it.
-            std::sort(indexes.begin(), indexes.end());
+std::uint64_t
+insertKey(
+    ApplyView& view,
+    SLE::ref node,
+    std::uint64_t page,
+    bool preserveOrder,
+    STVector256& indexes,
+    uint256 const& key)
+{
+    if (preserveOrder)
+    {
+        if (std::find(indexes.begin(), indexes.end(), key) != indexes.end())
+            LogicError("dirInsert: double insertion");
 
-            auto pos = std::lower_bound(indexes.begin(), indexes.end(), key);
+        indexes.push_back(key);
+    }
+    else
+    {
+        // We can't be sure if this page is already sorted because
+        // it may be a legacy page we haven't yet touched. Take
+        // the time to sort it.
+        std::sort(indexes.begin(), indexes.end());
 
-            if (pos != indexes.end() && key == *pos)
-                LogicError("dirInsert: double insertion");
+        auto pos = std::lower_bound(indexes.begin(), indexes.end(), key);
 
-            indexes.insert(pos, key);
-        }
+        if (pos != indexes.end() && key == *pos)
+            LogicError("dirInsert: double insertion");
 
-        node->setFieldV256(sfIndexes, indexes);
-        update(node);
-        return page;
-    };
-    auto insertPage =
-        [this](
-            std::uint64_t page,
-            SLE::pointer node,
-            std::uint64_t nextPage,
-            SLE::ref next,
-            uint256 const& key,
-            STVector256& indexes,
-            Keylet const& directory,
-            std::function<void(std::shared_ptr<SLE> const&)> const& describe)
-        -> std::optional<std::uint64_t> {
-        // Check whether we're out of pages.
-        if (++page >= dirNodeMaxPages)
-        {
-            return std::nullopt;
-        }
+        indexes.insert(pos, key);
+    }
 
-        // We are about to create a new node; we'll link it to
-        // the chain first:
-        node->setFieldU64(sfIndexNext, page);
-        update(node);
+    node->setFieldV256(sfIndexes, indexes);
+    view.update(node);
+    return page;
+}
 
-        next->setFieldU64(sfIndexPrevious, page);
-        update(next);
+std::optional<std::uint64_t>
+insertPage(
+    ApplyView& view,
+    std::uint64_t page,
+    SLE::pointer node,
+    std::uint64_t nextPage,
+    SLE::ref next,
+    uint256 const& key,
+    Keylet const& directory,
+    std::function<void(std::shared_ptr<SLE> const&)> const& describe)
+{
+    // Check whether we're out of pages.
+    if (++page >= dirNodeMaxPages)
+    {
+        return std::nullopt;
+    }
 
-        // Insert the new key:
-        indexes.clear();
-        indexes.push_back(key);
+    // We are about to create a new node; we'll link it to
+    // the chain first:
+    node->setFieldU64(sfIndexNext, page);
+    view.update(node);
 
-        node = std::make_shared<SLE>(keylet::page(directory, page));
-        node->setFieldH256(sfRootIndex, directory.key);
-        node->setFieldV256(sfIndexes, indexes);
+    next->setFieldU64(sfIndexPrevious, page);
+    view.update(next);
 
-        // Save some space by not specifying the value 0 since
-        // it's the default.
-        if (page != 1)
-            node->setFieldU64(sfIndexPrevious, page - 1);
-        if (nextPage)
-            node->setFieldU64(sfIndexNext, nextPage);
-        describe(node);
-        insert(node);
+    // Insert the new key:
+    STVector256 indexes;
+    indexes.push_back(key);
 
-        return page;
-    };
+    node = std::make_shared<SLE>(keylet::page(directory, page));
+    node->setFieldH256(sfRootIndex, directory.key);
+    node->setFieldV256(sfIndexes, indexes);
 
+    // Save some space by not specifying the value 0 since
+    // it's the default.
+    if (page != 1)
+        node->setFieldU64(sfIndexPrevious, page - 1);
+    if (nextPage)
+        node->setFieldU64(sfIndexNext, nextPage);
+    describe(node);
+    view.insert(node);
+
+    return page;
+}
+
+}  // namespace directory
+
+std::optional<std::uint64_t>
+ApplyView::dirAdd(
+    bool preserveOrder,
+    Keylet const& directory,
+    uint256 const& key,
+    std::function<void(std::shared_ptr<SLE> const&)> const& describe)
+{
     auto const root = peek(directory);
 
     if (!root)
     {
         // No root, make it.
-        return createRoot(directory, key, describe);
+        return directory::createRoot(*this, directory, key, describe);
     }
 
-    auto [page, node, indexes] = findPreviousPage(directory, root);
+    auto [page, node, indexes] =
+        directory::findPreviousPage(*this, directory, root);
 
     if (rules().enabled(featureDefragDirectories))
     {
         // If there are more nodes than just the root, and there's no space in
         // the last one, walk backwards to find one with space, or to find one
         // missing.
-        std::optional<Gap> gapPages;
+        std::optional<directory::Gap> gapPages;
         while (page && indexes.size() >= dirNodeMaxEntries)
         {
             // Find a page with space, or a gap in pages.
             auto [prevPage, prevNode, prevIndexes] =
-                findPreviousPage(directory, node);
+                directory::findPreviousPage(*this, directory, node);
             if (!gapPages && prevPage != page - 1)
                 gapPages.emplace(prevPage, prevNode, page, node);
             page = prevPage;
@@ -181,27 +195,30 @@ ApplyView::dirAdd(
             // If we found a gap, use it.
             if (gapPages)
             {
-                return insertPage(
+                return directory::insertPage(
+                    *this,
                     gapPages->page,
                     gapPages->node,
                     gapPages->nextPage,
-                    gapPages->node,
+                    gapPages->next,
                     key,
-                    indexes,
                     directory,
                     describe);
             }
-            std::tie(page, node, indexes) = findPreviousPage(directory, root);
+            std::tie(page, node, indexes) =
+                directory::findPreviousPage(*this, directory, root);
         }
     }
 
     // If there's space, we use it:
     if (indexes.size() < dirNodeMaxEntries)
     {
-        return insertKey(node, page, preserveOrder, indexes, key);
+        return directory::insertKey(
+            *this, node, page, preserveOrder, indexes, key);
     }
 
-    return insertPage(page, node, 0, root, key, indexes, directory, describe);
+    return directory::insertPage(
+        *this, page, node, 0, root, key, directory, describe);
 }
 
 bool