fixup

reverse_migrate.py

@@ -0,0 +1,53 @@
+import os
+
+def replace_in_file(file_path):
+    """Replace occurrences of 'from xrpl' with 'from xahau' in the given file."""
+    try:
+        with open(file_path, "r") as file:
+            content = file.read()
+
+        # Replace the text
+        new_content = (
+            content.replace("xrpld/app/", "ripple/app/")
+            .replace("xrpld/core/", "ripple/core/")
+            .replace("xrpld/nodestore/", "ripple/nodestore/")
+            .replace("xrpl/basics/", "ripple/basics/")
+            .replace("xrpl/protocol/", "ripple/protocol/")
+            .replace("xrpl/json/", "ripple/json/")
+            .replace("xrpld/overlay/", "ripple/overlay/")
+            .replace("xrpl/resource/", "ripple/resource/")
+            .replace("xrpl/crypto/", "ripple/crypto/")
+            .replace("xrpl/beast/", "ripple/beast/")
+            .replace("xrpld/shamap/", "ripple/shamap/")
+            .replace("xrpld/rpc/", "ripple/rpc/")
+            .replace("xrpld/perflog/", "ripple/perflog/")
+            .replace("xrpld/nodestore/detail/", "ripple/nodestore/impl/")
+            .replace("xrpld/ledger/", "ripple/ledger/")
+            .replace("xrpld/app/misc/detail/AccountTxPaging.h", "ripple/app/misc/impl/AccountTxPaging.h")
+            .replace("xrpld/perflog/PerfLog.h", "ripple/basics/PerfLog.h")
+            .replace("xrpld/rpc/detail/RPCHelpers.h", "ripple/rpc/impl/RPCHelpers.h")
+            .replace("xrpld/protocol/RPCErr.h", "ripple/net/RPCErr.h")
+        )
+
+        # Write the changes back to the file
+        with open(file_path, "w") as file:
+            file.write(new_content)
+        print(f"Updated: {file_path}")
+
+    except Exception as e:
+        print(f"Error processing file {file_path}: {e}")
+
+
+def search_and_replace_in_folders(folder_paths):
+    """Search for Python files in the given list of folders and replace text."""
+    for folder_path in folder_paths:
+        for root, dirs, files in os.walk(folder_path):
+            for file in files:
+                if file.endswith(".cpp") or file.endswith(".h"):
+                    file_path = os.path.join(root, file)
+                    replace_in_file(file_path)
+
+
+if __name__ == "__main__":
+    folder_list = ["src/ripple", "src/test"]
+    search_and_replace_in_folders(folder_list)

src/ripple/app/main/Application.cpp

@@ -47,30 +47,34 @@
 #include <ripple/app/paths/PathRequests.h>
 #include <ripple/app/rdb/RelationalDatabase.h>
 #include <ripple/app/rdb/Wallet.h>
+#include <ripple/app/rdb/backend/PostgresDatabase.h>
+#include <ripple/app/reporting/ReportingETL.h>
 #include <ripple/app/tx/apply.h>
-#include <ripple/core/DatabaseCon.h>
-#include <ripple/nodestore/DummyScheduler.h>
-#include <ripple/overlay/Cluster.h>
-#include <ripple/overlay/PeerReservationTable.h>
-#include <ripple/overlay/PeerSet.h>
-#include <ripple/overlay/make_Overlay.h>
-#include <ripple/perflog/PerfLog.h>
-#include <ripple/rpc/detail/RPCHelpers.h>
-#include <ripple/shamap/NodeFamily.h>
 #include <ripple/basics/ByteUtilities.h>
+#include <ripple/basics/PerfLog.h>
 #include <ripple/basics/ResolverAsio.h>
 #include <ripple/basics/TaggedCache.ipp>
 #include <ripple/basics/random.h>
 #include <ripple/basics/safe_cast.h>
 #include <ripple/beast/asio/io_latency_probe.h>
 #include <ripple/beast/core/LexicalCast.h>
+#include <ripple/core/DatabaseCon.h>
 #include <ripple/crypto/csprng.h>
 #include <ripple/json/json_reader.h>
+#include <ripple/nodestore/DummyScheduler.h>
+#include <ripple/overlay/Cluster.h>
+#include <ripple/overlay/PeerReservationTable.h>
+#include <ripple/overlay/PeerSet.h>
+#include <ripple/overlay/make_Overlay.h>
 #include <ripple/protocol/BuildInfo.h>
 #include <ripple/protocol/Feature.h>
 #include <ripple/protocol/Protocol.h>
 #include <ripple/protocol/STParsedJSON.h>
 #include <ripple/resource/Fees.h>
+#include <ripple/rpc/ShardArchiveHandler.h>
+#include <ripple/rpc/impl/RPCHelpers.h>
+#include <ripple/shamap/NodeFamily.h>
+#include <ripple/shamap/ShardFamily.h>
 
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/asio/steady_timer.hpp>

src/ripple/app/misc/NetworkOPs.cpp

@@ -19,6 +19,7 @@
 
 #include <ripple/app/consensus/RCLConsensus.h>
 #include <ripple/app/consensus/RCLValidations.h>
+#include <ripple/app/hook/applyHook.h>
 #include <ripple/app/ledger/AcceptedLedger.h>
 #include <ripple/app/ledger/InboundLedgers.h>
 #include <ripple/app/ledger/LedgerMaster.h>
@@ -29,7 +30,7 @@
 #include <ripple/app/ledger/TransactionMaster.h>
 #include <ripple/app/main/LoadManager.h>
 #include <ripple/app/misc/AmendmentTable.h>
-#include <ripple/app/misc/DeliverMax.h>
+// #include <ripple/app/misc/DeliverMax.h>
 #include <ripple/app/misc/HashRouter.h>
 #include <ripple/app/misc/LoadFeeTrack.h>
 #include <ripple/app/misc/NetworkOPs.h>
@@ -37,35 +38,40 @@
 #include <ripple/app/misc/TxQ.h>
 #include <ripple/app/misc/ValidatorKeys.h>
 #include <ripple/app/misc/ValidatorList.h>
-#include <ripple/app/misc/detail/AccountTxPaging.h>
+#include <ripple/app/misc/impl/AccountTxPaging.h>
 #include <ripple/app/rdb/backend/SQLiteDatabase.h>
 #include <ripple/app/tx/apply.h>
-#include <xrpld/consensus/Consensus.h>
-#include <xrpld/consensus/ConsensusParms.h>
-#include <ripple/overlay/Cluster.h>
-#include <ripple/overlay/Overlay.h>
-#include <ripple/overlay/predicates.h>
-#include <ripple/perflog/PerfLog.h>
-#include <ripple/rpc/BookChanges.h>
-#include <ripple/rpc/DeliveredAmount.h>
-#include <ripple/rpc/ServerHandler.h>
+#include <ripple/basics/PerfLog.h>
 #include <ripple/basics/TaggedCache.ipp>
 #include <ripple/basics/UptimeClock.h>
 #include <ripple/basics/mulDiv.h>
 #include <ripple/basics/safe_cast.h>
 #include <ripple/beast/rfc2616.h>
 #include <ripple/beast/utility/rngfill.h>
+#include <ripple/consensus/Consensus.h>
+#include <ripple/consensus/ConsensusParms.h>
 #include <ripple/crypto/RFC1751.h>
 #include <ripple/crypto/csprng.h>
 #include <ripple/json/to_string.h>
+#include <ripple/overlay/Cluster.h>
+#include <ripple/overlay/Overlay.h>
+#include <ripple/overlay/predicates.h>
 #include <ripple/protocol/BuildInfo.h>
 #include <ripple/protocol/Feature.h>
-#include <ripple/protocol/MultiApiJson.h>
-#include <ripple/protocol/RPCErr.h>
+#include <ripple/rpc/BookChanges.h>
+#include <ripple/rpc/DeliveredAmount.h>
+#include <ripple/rpc/ServerHandler.h>
+// #include <ripple/protocol/MultiApiJson.h>
+#include <ripple/app/rdb/backend/PostgresDatabase.h>
+#include <ripple/app/reporting/ReportingETL.h>
+#include <ripple/net/RPCErr.h>
+#include <ripple/nodestore/DatabaseShard.h>
 #include <ripple/protocol/STParsedJSON.h>
 #include <ripple/protocol/jss.h>
 #include <ripple/resource/Fees.h>
 #include <ripple/resource/ResourceManager.h>
+#include <ripple/rpc/CTID.h>
+#include <ripple/rpc/impl/RPCHelpers.h>
 #include <boost/asio/ip/host_name.hpp>
 #include <boost/asio/steady_timer.hpp>
 

src/ripple/basics/TaggedCache.ipp

@@ -20,7 +20,7 @@
 #ifndef RIPPLE_BASICS_TAGGEDCACHE_IPP_INCLUDED
 #define RIPPLE_BASICS_TAGGEDCACHE_IPP_INCLUDED
 
-#include <xrpl/basics/TaggedCache.h>
+#include <ripple/basics/TaggedCache.h>
 
 namespace ripple {
 

src/ripple/beast/container/detail/aged_ordered_container.h

@@ -145,111 +145,78 @@ private:
     };
 
     // VFALCO TODO This should only be enabled for maps.
-    class pair_value_compare
-        : public beast::detail::empty_base_optimization<Compare>
-#ifdef _LIBCPP_VERSION
-        ,
-          public std::binary_function<value_type, value_type, bool>
-#endif
+    class pair_value_compare : public Compare
     {
     public:
-#ifndef _LIBCPP_VERSION
         using first_argument = value_type;
         using second_argument = value_type;
         using result_type = bool;
-#endif
 
         bool
         operator()(value_type const& lhs, value_type const& rhs) const
         {
-            return this->member()(lhs.first, rhs.first);
+            return Compare::operator()(lhs.first, rhs.first);
         }
 
         pair_value_compare()
         {
         }
 
-        pair_value_compare(pair_value_compare const& other)
-            : beast::detail::empty_base_optimization<Compare>(other)
+        pair_value_compare(pair_value_compare const& other) : Compare(other)
         {
         }
 
     private:
         friend aged_ordered_container;
 
-        pair_value_compare(Compare const& compare)
-            : beast::detail::empty_base_optimization<Compare>(compare)
+        pair_value_compare(Compare const& compare) : Compare(compare)
         {
         }
     };
 
     // Compares value_type against element, used in insert_check
     // VFALCO TODO hoist to remove template argument dependencies
-    class KeyValueCompare
-        : public beast::detail::empty_base_optimization<Compare>
-#ifdef _LIBCPP_VERSION
-        ,
-          public std::binary_function<Key, element, bool>
-#endif
+    class KeyValueCompare : public Compare
     {
     public:
-#ifndef _LIBCPP_VERSION
         using first_argument = Key;
         using second_argument = element;
         using result_type = bool;
-#endif
 
         KeyValueCompare() = default;
 
-        KeyValueCompare(Compare const& compare)
-            : beast::detail::empty_base_optimization<Compare>(compare)
+        KeyValueCompare(Compare const& compare) : Compare(compare)
         {
         }
 
-        // VFALCO NOTE WE might want only to enable these overloads
-        //                if Compare has is_transparent
-#if 0
-        template <class K>
-        bool operator() (K const& k, element const& e) const
-        {
-            return this->member() (k, extract (e.value));
-        }
-
-        template <class K>
-        bool operator() (element const& e, K const& k) const
-        {
-            return this->member() (extract (e.value), k);
-        }
-#endif
-
         bool
         operator()(Key const& k, element const& e) const
         {
-            return this->member()(k, extract(e.value));
+            return Compare::operator()(k, extract(e.value));
         }
 
         bool
         operator()(element const& e, Key const& k) const
         {
-            return this->member()(extract(e.value), k);
+            return Compare::operator()(extract(e.value), k);
         }
 
         bool
         operator()(element const& x, element const& y) const
         {
-            return this->member()(extract(x.value), extract(y.value));
+            return Compare::operator()(extract(x.value), extract(y.value));
         }
 
         Compare&
         compare()
         {
-            return beast::detail::empty_base_optimization<Compare>::member();
+            return *this;
         }
 
         Compare const&
         compare() const
         {
-            return beast::detail::empty_base_optimization<Compare>::member();
+            return *this;
         }
     };
 

src/ripple/beast/container/detail/aged_unordered_container.h

@@ -148,115 +148,84 @@ private:
     };
 
     // VFALCO TODO hoist to remove template argument dependencies
-    class ValueHash : private beast::detail::empty_base_optimization<Hash>
-#ifdef _LIBCPP_VERSION
-        ,
-                      public std::unary_function<element, std::size_t>
-#endif
+    class ValueHash : public Hash
     {
     public:
-#ifndef _LIBCPP_VERSION
         using argument_type = element;
         using result_type = size_t;
-#endif
 
         ValueHash()
         {
         }
 
-        ValueHash(Hash const& h)
-            : beast::detail::empty_base_optimization<Hash>(h)
+        ValueHash(Hash const& h) : Hash(h)
         {
         }
 
         std::size_t
         operator()(element const& e) const
         {
-            return this->member()(extract(e.value));
+            return Hash::operator()(extract(e.value));
         }
 
         Hash&
         hash_function()
         {
-            return this->member();
+            return *this;
         }
 
         Hash const&
         hash_function() const
         {
-            return this->member();
+            return *this;
         }
     };
 
     // Compares value_type against element, used in find/insert_check
     // VFALCO TODO hoist to remove template argument dependencies
-    class KeyValueEqual
-        : private beast::detail::empty_base_optimization<KeyEqual>
-#ifdef _LIBCPP_VERSION
-        ,
-          public std::binary_function<Key, element, bool>
-#endif
+    class KeyValueEqual : public KeyEqual
     {
     public:
-#ifndef _LIBCPP_VERSION
         using first_argument_type = Key;
         using second_argument_type = element;
         using result_type = bool;
-#endif
 
         KeyValueEqual()
         {
         }
 
-        KeyValueEqual(KeyEqual const& keyEqual)
-            : beast::detail::empty_base_optimization<KeyEqual>(keyEqual)
+        KeyValueEqual(KeyEqual const& keyEqual) : KeyEqual(keyEqual)
         {
         }
 
-        // VFALCO NOTE WE might want only to enable these overloads
-        //                if KeyEqual has is_transparent
-#if 0
-        template <class K>
-        bool operator() (K const& k, element const& e) const
-        {
-            return this->member() (k, extract (e.value));
-        }
-
-        template <class K>
-        bool operator() (element const& e, K const& k) const
-        {
-            return this->member() (extract (e.value), k);
-        }
-#endif
-
         bool
         operator()(Key const& k, element const& e) const
         {
-            return this->member()(k, extract(e.value));
+            return KeyEqual::operator()(k, extract(e.value));
         }
 
         bool
         operator()(element const& e, Key const& k) const
         {
-            return this->member()(extract(e.value), k);
+            return KeyEqual::operator()(extract(e.value), k);
         }
 
         bool
         operator()(element const& lhs, element const& rhs) const
         {
-            return this->member()(extract(lhs.value), extract(rhs.value));
+            return KeyEqual::operator()(extract(lhs.value), extract(rhs.value));
         }
 
         KeyEqual&
         key_eq()
         {
-            return this->member();
+            return *this;
         }
 
         KeyEqual const&
         key_eq() const
         {
-            return this->member();
+            return *this;
         }
     };
 

src/ripple/ledger/impl/CachedView.cpp

@@ -17,7 +17,7 @@
 */
 //==============================================================================
 
-#include <xrpld/ledger/CachedView.h>
+#include <ripple/ledger/CachedView.h>
 #include <ripple/basics/TaggedCache.ipp>
 #include <ripple/basics/contract.h>
 #include <ripple/protocol/Serializer.h>

src/ripple/nodestore/impl/DatabaseNodeImp.cpp

@@ -17,7 +17,7 @@
 */
 //==============================================================================
 
-#include <ripple/nodestore/detail/DatabaseNodeImp.h>
+#include <ripple/nodestore/impl/DatabaseNodeImp.h>
 #include <ripple/basics/TaggedCache.ipp>
 #include <ripple/protocol/HashPrefix.h>
 

src/ripple/peerfinder/impl/Bootcache.h

@@ -91,17 +91,10 @@ private:
     using value_type = map_type::value_type;
 
     struct Transform
-#ifdef _LIBCPP_VERSION
-        : std::unary_function<
-              map_type::right_map::const_iterator::value_type const&,
-              beast::IP::Endpoint const&>
-#endif
     {
-#ifndef _LIBCPP_VERSION
         using first_argument_type =
             map_type::right_map::const_iterator::value_type const&;
         using result_type = beast::IP::Endpoint const&;
-#endif
 
         explicit Transform() = default;
 

src/ripple/peerfinder/impl/Livecache.h

@@ -69,14 +69,9 @@ public:
     public:
         // Iterator transformation to extract the endpoint from Element
         struct Transform
-#ifdef _LIBCPP_VERSION
-            : public std::unary_function<Element, Endpoint>
-#endif
         {
-#ifndef _LIBCPP_VERSION
             using first_argument = Element;
             using result_type = Endpoint;
-#endif
 
             explicit Transform() = default;
 
@@ -239,15 +234,9 @@ public:
 
         template <bool IsConst>
         struct Transform
-#ifdef _LIBCPP_VERSION
-            : public std::
-                  unary_function<typename lists_type::value_type, Hop<IsConst>>
-#endif
         {
-#ifndef _LIBCPP_VERSION
             using first_argument = typename lists_type::value_type;
             using result_type = Hop<IsConst>;
-#endif
 
             explicit Transform() = default;
 

src/ripple/rpc/handlers/GetCounts.cpp

@@ -23,15 +23,16 @@
 #include <ripple/app/main/Application.h>
 #include <ripple/app/misc/NetworkOPs.h>
 #include <ripple/app/rdb/backend/SQLiteDatabase.h>
-#include <xrpld/ledger/CachedSLEs.h>
-#include <ripple/nodestore/Database.h>
-#include <ripple/rpc/Context.h>
 #include <ripple/basics/TaggedCache.ipp>
 #include <ripple/basics/UptimeClock.h>
 #include <ripple/json/json_value.h>
+#include <ripple/ledger/CachedSLEs.h>
+#include <ripple/net/RPCErr.h>
+#include <ripple/nodestore/Database.h>
 #include <ripple/protocol/ErrorCodes.h>
-#include <ripple/protocol/RPCErr.h>
 #include <ripple/protocol/jss.h>
+#include <ripple/rpc/Context.h>
+#include <ripple/shamap/ShardFamily.h>
 
 namespace ripple {
 

src/ripple/shamap/FullBelowCache.h

@@ -21,6 +21,7 @@
 #define RIPPLE_SHAMAP_FULLBELOWCACHE_H_INCLUDED
 
 #include <ripple/basics/KeyCache.h>
+#include <ripple/basics/TaggedCache.h>
 #include <ripple/basics/TaggedCache.ipp>
 #include <ripple/basics/base_uint.h>
 #include <ripple/beast/insight/Collector.h>

src/ripple/shamap/impl/SHAMapInnerNode.cpp

@@ -398,7 +398,7 @@ SHAMapInnerNode::canonicalizeChild(
 void
 SHAMapInnerNode::invariants(bool is_root) const
 {
-    unsigned count = 0;
+    [[maybe_unused]] unsigned count = 0;
     auto [numAllocated, hashes, children] =
         hashesAndChildren_.getHashesAndChildren();
 

src/test/basics/KeyCache_test.cpp

@@ -17,6 +17,7 @@
 */
 //==============================================================================
 
+#include <ripple/basics/TaggedCache.h>
 #include <ripple/basics/TaggedCache.ipp>
 #include <ripple/basics/chrono.h>
 #include <ripple/beast/clock/manual_clock.h>

src/test/basics/TaggedCache_test.cpp

@@ -17,6 +17,7 @@
 */
 //==============================================================================
 
+#include <ripple/basics/TaggedCache.h>
 #include <ripple/basics/TaggedCache.ipp>
 #include <ripple/basics/chrono.h>
 #include <ripple/beast/clock/manual_clock.h>