librbd: migrate from boost::variant to std::variant

This change is part of a broader effort to reduce dependencies on
third-party libraries by leveraging C++ standard library alternatives.

Migrating from boost::variant to std::variant improves code readability
and maintainability while reducing external dependencies.

Signed-off-by: Kefu Chai <[email protected]>

Author: tchaikov

src/librbd/internal.cc

@@ -59,10 +59,10 @@
 #include "journal/Journaler.h"
 
 #include <boost/scope_exit.hpp>
-#include <boost/variant.hpp>
 #include "include/ceph_assert.h"
 
 #include <shared_mutex> // for std::shared_lock
+#include <variant>
 
 #define dout_subsys ceph_subsys_rbd
 #undef dout_prefix
@@ -275,7 +275,7 @@ int validate_pool(IoCtx &io_ctx, CephContext *cct) {
     return io_ctx.tmap_update(RBD_DIRECTORY, cmdbl);
   }
 
-  typedef boost::variant<std::string,uint64_t> image_option_value_t;
+  typedef std::variant<std::string, uint64_t> image_option_value_t;
   typedef std::map<int,image_option_value_t> image_options_t;
   typedef std::shared_ptr<image_options_t> image_options_ref;
 
@@ -433,7 +433,7 @@ int validate_pool(IoCtx &io_ctx, CephContext *cct) {
       return -ENOENT;
     }
 
-    *optval = boost::get<std::string>(j->second);
+    *optval = std::get<std::string>(j->second);
     return 0;
   }
 
@@ -454,7 +454,7 @@ int validate_pool(IoCtx &io_ctx, CephContext *cct) {
       return -ENOENT;
     }
 
-    *optval = boost::get<uint64_t>(j->second);
+    *optval = std::get<uint64_t>(j->second);
     return 0;
   }
 

src/librbd/io/ImageDispatchSpec.h

@@ -11,8 +11,8 @@
 #include "librbd/io/AioCompletion.h"
 #include "librbd/io/Types.h"
 #include "librbd/io/ReadResult.h"
-#include <boost/variant/variant.hpp>
 #include <atomic>
+#include <variant>
 
 namespace librbd {
 
@@ -99,13 +99,13 @@ class ImageDispatchSpec {
     }
   };
 
-  typedef boost::variant<Read,
-                         Discard,
-                         Write,
-                         WriteSame,
-                         CompareAndWrite,
-                         Flush,
-                         ListSnaps> Request;
+  typedef std::variant<Read,
+                       Discard,
+                       Write,
+                       WriteSame,
+                       CompareAndWrite,
+                       Flush,
+                       ListSnaps> Request;
 
   C_Dispatcher dispatcher_ctx;
 

src/librbd/io/ImageDispatcher.cc

@@ -14,7 +14,6 @@
 #include "librbd/io/RefreshImageDispatch.h"
 #include "librbd/io/Utils.h"
 #include "librbd/io/WriteBlockImageDispatch.h"
-#include <boost/variant.hpp>
 
 #include <shared_mutex> // for std::shared_lock
 
@@ -280,15 +279,15 @@ bool ImageDispatcher<I>::send_dispatch(
     }
   }
 
-  return boost::apply_visitor(
+  return std::visit(
     SendVisitor{image_dispatch, image_dispatch_spec},
     image_dispatch_spec->request);
 }
 
 template <typename I>
 bool ImageDispatcher<I>::preprocess(
     ImageDispatchSpec* image_dispatch_spec) {
-  return boost::apply_visitor(
+  return std::visit(
     PreprocessVisitor{this, image_dispatch_spec},
     image_dispatch_spec->request);
 }

src/test/librbd/crypto/luks/test_mock_FlattenRequest.cc

@@ -96,7 +96,7 @@ struct TestMockCryptoLuksFlattenRequest : public TestMockFixture {
     EXPECT_CALL(*mock_image_ctx->io_image_dispatcher, send(_))
             .WillOnce(Invoke([this, offset,
                               length](io::ImageDispatchSpec* spec) {
-                auto* read = boost::get<io::ImageDispatchSpec::Read>(
+                auto* read = std::get_if<io::ImageDispatchSpec::Read>(
                         &spec->request);
                 ASSERT_TRUE(read != nullptr);
 
@@ -122,7 +122,7 @@ struct TestMockCryptoLuksFlattenRequest : public TestMockFixture {
   void expect_image_write() {
     EXPECT_CALL(*mock_image_ctx->io_image_dispatcher, send(_))
             .WillOnce(Invoke([this](io::ImageDispatchSpec* spec) {
-                auto* write = boost::get<io::ImageDispatchSpec::Write>(
+                auto* write = std::get_if<io::ImageDispatchSpec::Write>(
                         &spec->request);
                 ASSERT_TRUE(write != nullptr);
 
@@ -145,7 +145,7 @@ struct TestMockCryptoLuksFlattenRequest : public TestMockFixture {
   void expect_image_flush(int r) {
     EXPECT_CALL(*mock_image_ctx->io_image_dispatcher, send(_)).WillOnce(
             Invoke([r](io::ImageDispatchSpec* spec) {
-              ASSERT_TRUE(boost::get<io::ImageDispatchSpec::Flush>(
+              ASSERT_TRUE(std::get_if<io::ImageDispatchSpec::Flush>(
                       &spec->request) != nullptr);
               spec->dispatch_result = io::DISPATCH_RESULT_COMPLETE;
               spec->aio_comp->set_request_count(1);

src/test/librbd/crypto/luks/test_mock_FormatRequest.cc

@@ -66,7 +66,7 @@ struct TestMockCryptoLuksFormatRequest : public TestMockFixture {
   void expect_image_write() {
     EXPECT_CALL(*mock_image_ctx->io_image_dispatcher, send(_))
             .WillOnce(Invoke([this](io::ImageDispatchSpec* spec) {
-                auto* write = boost::get<io::ImageDispatchSpec::Write>(
+                auto* write = std::get_if<io::ImageDispatchSpec::Write>(
                         &spec->request);
                 ASSERT_TRUE(write != nullptr);
 

src/test/librbd/crypto/luks/test_mock_LoadRequest.cc

@@ -81,7 +81,7 @@ struct TestMockCryptoLuksLoadRequest : public TestMockFixture {
     EXPECT_CALL(*mock_image_ctx->io_image_dispatcher, send(_))
             .WillOnce(Invoke([this, offset,
                               length](io::ImageDispatchSpec* spec) {
-                auto* read = boost::get<io::ImageDispatchSpec::Read>(
+                auto* read = std::get_if<io::ImageDispatchSpec::Read>(
                         &spec->request);
                 ASSERT_TRUE(read != nullptr);
 

src/test/librbd/crypto/test_mock_FormatRequest.cc

@@ -135,7 +135,7 @@ struct TestMockCryptoFormatRequest : public TestMockFixture {
   void expect_image_flush(int r) {
     EXPECT_CALL(*mock_image_ctx->io_image_dispatcher, send(_)).WillOnce(
             Invoke([r](io::ImageDispatchSpec* spec) {
-              ASSERT_TRUE(boost::get<io::ImageDispatchSpec::Flush>(
+              ASSERT_TRUE(std::get_if<io::ImageDispatchSpec::Flush>(
                       &spec->request) != nullptr);
               spec->dispatch_result = io::DISPATCH_RESULT_COMPLETE;
               spec->aio_comp->set_request_count(1);

src/test/librbd/crypto/test_mock_LoadRequest.cc

@@ -119,7 +119,7 @@ struct TestMockCryptoLoadRequest : public TestMockFixture {
   void expect_image_flush(int r = 0) {
     EXPECT_CALL(*mock_image_ctx->io_image_dispatcher, send(_)).WillOnce(
             Invoke([r](io::ImageDispatchSpec* spec) {
-              ASSERT_TRUE(boost::get<io::ImageDispatchSpec::Flush>(
+              ASSERT_TRUE(std::get_if<io::ImageDispatchSpec::Flush>(
                       &spec->request) != nullptr);
               spec->dispatch_result = io::DISPATCH_RESULT_COMPLETE;
               spec->aio_comp->set_request_count(1);

src/test/librbd/deep_copy/test_mock_ObjectCopyRequest.cc

@@ -119,12 +119,12 @@ void scribble(librbd::ImageCtx *image_ctx, int num_ops, size_t max_size,
 
 
 MATCHER(IsListSnaps, "") {
-  auto req = boost::get<io::ImageDispatchSpec::ListSnaps>(&arg->request);
+  auto req = std::get_if<io::ImageDispatchSpec::ListSnaps>(&arg->request);
   return (req != nullptr);
 }
 
 MATCHER_P2(IsRead, snap_id, image_interval, "") {
-  auto req = boost::get<io::ImageDispatchSpec::Read>(&arg->request);
+  auto req = std::get_if<io::ImageDispatchSpec::Read>(&arg->request);
   if (req == nullptr ||
       arg->io_context->get_read_snap() != snap_id) {
     return false;

src/test/librbd/exclusive_lock/test_mock_PreReleaseRequest.cc

@@ -168,7 +168,7 @@ class TestMockExclusiveLockPreReleaseRequest : public TestMockFixture {
   void expect_flush_io(MockTestImageCtx &mock_image_ctx, int r) {
     EXPECT_CALL(*mock_image_ctx.io_image_dispatcher, send(_))
       .WillOnce(Invoke([&mock_image_ctx, r](io::ImageDispatchSpec* spec) {
-                  ASSERT_TRUE(boost::get<io::ImageDispatchSpec::Flush>(
+                  ASSERT_TRUE(std::get_if<io::ImageDispatchSpec::Flush>(
                     &spec->request) != nullptr);
                   spec->dispatch_result = io::DISPATCH_RESULT_COMPLETE;
                   auto aio_comp = spec->aio_comp;