Replace boost::any_cast with olp::porting::any_cast

olp-cpp-sdk-core/src/cache/InMemoryCache.cpp

@@ -65,7 +65,7 @@ bool InMemoryCache::Put(const std::string& key, const boost::any& item,
   return ret.second;
 }
 
-boost::any InMemoryCache::Get(const std::string& key) {
+olp::porting::any InMemoryCache::Get(const std::string& key) {
   std::lock_guard<std::mutex> lock{mutex_};
   auto it = item_tuples_.Find(key);
   if (it != item_tuples_.end()) {

olp-cpp-sdk-core/src/client/repository/ApiCacheRepository.cpp

@@ -55,7 +55,7 @@ porting::optional<std::string> ApiCacheRepository::Get(
     return porting::none;
   }
 
-  return boost::any_cast<std::string>(url);
+  return olp::porting::any_cast<std::string>(url);
 }
 
 }  // namespace repository

olp-cpp-sdk-core/tests/cache/DefaultCacheImplTest.cpp

@@ -431,7 +431,7 @@ TEST_F(DefaultCacheImplTest, MutableCacheExpired) {
 
   ASSERT_NE(value.get(), nullptr);
   ASSERT_EQ(value2.type(), typeid(std::string));
-  auto str = boost::any_cast<std::string>(value2);
+  auto str = olp::porting::any_cast<std::string>(value2);
   EXPECT_EQ(str, data_string);
 
   std::this_thread::sleep_for(std::chrono::seconds(3));
@@ -473,7 +473,7 @@ TEST_F(DefaultCacheImplTest, ProtectedCacheExpired) {
 
   EXPECT_FALSE(value.get() == nullptr);
   EXPECT_EQ(value2.type(), typeid(std::string));
-  auto str = boost::any_cast<std::string>(value2);
+  auto str = olp::porting::any_cast<std::string>(value2);
   EXPECT_EQ(str, data_string);
 
   std::this_thread::sleep_for(std::chrono::seconds(3));
@@ -892,7 +892,8 @@ TEST_F(DefaultCacheImplTest, ProtectTest) {
     auto key2_data_read =
         cache.Get(key2, [](const std::string& data) { return data; });
     ASSERT_FALSE(key2_data_read.empty());
-    ASSERT_EQ(key2_data_string, boost::any_cast<std::string>(key2_data_read));
+    ASSERT_EQ(key2_data_string,
+              olp::porting::any_cast<std::string>(key2_data_read));
   }
   {
     SCOPED_TRACE("Check if key still protected exist after closing");
@@ -901,7 +902,8 @@ TEST_F(DefaultCacheImplTest, ProtectTest) {
     auto key2_data_read =
         cache.Get(key2, [](const std::string& data) { return data; });
     ASSERT_FALSE(key2_data_read.empty());
-    ASSERT_EQ(key2_data_string, boost::any_cast<std::string>(key2_data_read));
+    ASSERT_EQ(key2_data_string,
+              olp::porting::any_cast<std::string>(key2_data_read));
     ASSERT_TRUE(cache.IsProtected(key2));
     ASSERT_TRUE(cache.IsProtected(key3));
     // key which do not exist

olp-cpp-sdk-core/tests/cache/DefaultCacheTest.cpp

@@ -55,7 +55,7 @@ void BasicCacheTestWithSettings(const olp::cache::CacheSettings& settings) {
         cache.Get("key", [](const std::string& data) { return data; });
 
     EXPECT_FALSE(data_read.empty());
-    EXPECT_EQ(data_string, boost::any_cast<std::string>(data_read));
+    EXPECT_EQ(data_string, olp::porting::any_cast<std::string>(data_read));
   }
 
   {
@@ -218,7 +218,7 @@ TEST(DefaultCacheTest, BasicTest) {
   auto key1DataRead =
       cache.Get("key1", [](const std::string& data) { return data; });
   ASSERT_FALSE(key1DataRead.empty());
-  ASSERT_EQ(key1DataString, boost::any_cast<std::string>(key1DataRead));
+  ASSERT_EQ(key1DataString, olp::porting::any_cast<std::string>(key1DataRead));
   ASSERT_TRUE(cache.Clear());
 }
 
@@ -232,7 +232,7 @@ TEST(DefaultCacheTest, BasicInMemTest) {
   auto key1DataRead =
       cache.Get("key1", [](const std::string& data) { return data; });
   ASSERT_FALSE(key1DataRead.empty());
-  ASSERT_EQ(key1DataString, boost::any_cast<std::string>(key1DataRead));
+  ASSERT_EQ(key1DataString, olp::porting::any_cast<std::string>(key1DataRead));
   ASSERT_TRUE(cache.Clear());
 }
 
@@ -250,7 +250,8 @@ TEST(DefaultCacheTest, MemSizeTest) {
     auto key1DataRead =
         cache.Get(key1, [](const std::string& data) { return data; });
     ASSERT_FALSE(key1DataRead.empty());
-    ASSERT_EQ(key1DataString, boost::any_cast<std::string>(key1DataRead));
+    ASSERT_EQ(key1DataString,
+              olp::porting::any_cast<std::string>(key1DataRead));
   }
 
   std::string key2{"key2"};
@@ -261,7 +262,8 @@ TEST(DefaultCacheTest, MemSizeTest) {
     auto key2DataRead =
         cache.Get(key2, [](const std::string& data) { return data; });
     ASSERT_FALSE(key2DataRead.empty());
-    ASSERT_EQ(key2DataString, boost::any_cast<std::string>(key2DataRead));
+    ASSERT_EQ(key2DataString,
+              olp::porting::any_cast<std::string>(key2DataRead));
 
     auto key1DataRead =
         cache.Get(key1, [](const std::string& data) { return data; });
@@ -282,7 +284,7 @@ TEST(DefaultCacheTest, BasicDiskTest) {
   auto key1DataRead =
       cache.Get("key1", [](const std::string& data) { return data; });
   ASSERT_FALSE(key1DataRead.empty());
-  ASSERT_EQ(key1DataString, boost::any_cast<std::string>(key1DataRead));
+  ASSERT_EQ(key1DataString, olp::porting::any_cast<std::string>(key1DataRead));
   ASSERT_TRUE(cache.Clear());
 }
 
@@ -367,7 +369,8 @@ TEST(DefaultCacheTest, ProtectedCacheTest) {
     auto key1_data_read =
         cache.Get(key1, [](const std::string& data) { return data; });
     ASSERT_FALSE(key1_data_read.empty());
-    ASSERT_EQ(key1_data_string, boost::any_cast<std::string>(key1_data_read));
+    ASSERT_EQ(key1_data_string,
+              olp::porting::any_cast<std::string>(key1_data_read));
   }
   {
     SCOPED_TRACE("Get from protected - missing key");
@@ -402,7 +405,8 @@ TEST(DefaultCacheTest, ProtectedCacheTest) {
     auto key2_data_read =
         cache.Get(key2, [](const std::string& data) { return data; });
     ASSERT_FALSE(key2_data_read.empty());
-    ASSERT_EQ(key2_data_string, boost::any_cast<std::string>(key2_data_read));
+    ASSERT_EQ(key2_data_string,
+              olp::porting::any_cast<std::string>(key2_data_read));
     ASSERT_TRUE(cache.Clear());
   }
   {
@@ -417,7 +421,8 @@ TEST(DefaultCacheTest, ProtectedCacheTest) {
     auto key1_data_read =
         cache.Get(key1, [](const std::string& data) { return data; });
     ASSERT_FALSE(key1_data_read.empty());
-    ASSERT_EQ(key1_data_string, boost::any_cast<std::string>(key1_data_read));
+    ASSERT_EQ(key1_data_string,
+              olp::porting::any_cast<std::string>(key1_data_read));
   }
   {
     SCOPED_TRACE("Put to protected - blocked");
@@ -440,7 +445,8 @@ TEST(DefaultCacheTest, ProtectedCacheTest) {
     auto key1_data_read =
         cache.Get(key1, [](const std::string& data) { return data; });
     ASSERT_FALSE(key1_data_read.empty());
-    ASSERT_EQ(key1_data_string, boost::any_cast<std::string>(key1_data_read));
+    ASSERT_EQ(key1_data_string,
+              olp::porting::any_cast<std::string>(key1_data_read));
   }
 
   {

olp-cpp-sdk-core/tests/cache/InMemoryCacheTest.cpp

@@ -62,11 +62,11 @@ TEST(InMemoryCacheTest, NoLimit) {
 
   auto i0 = cache.Get("key0");
   ASSERT_FALSE(i0.empty());
-  ASSERT_EQ("value0", boost::any_cast<std::string>(i0));
+  ASSERT_EQ("value0", olp::porting::any_cast<std::string>(i0));
 
   auto i9 = cache.Get("key9");
   ASSERT_FALSE(i9.empty());
-  ASSERT_EQ("value9", boost::any_cast<std::string>(i9));
+  ASSERT_EQ("value9", olp::porting::any_cast<std::string>(i9));
 
   ASSERT_TRUE(cache.Get("key10").empty());
 }
@@ -127,14 +127,14 @@ TEST(InMemoryCacheTest, PutOverwritesPrevious) {
   ASSERT_EQ(1u, cache.Size());
   auto value = cache.Get(key);
   ASSERT_FALSE(value.empty());
-  ASSERT_EQ(orig_value, boost::any_cast<std::string>(value));
+  ASSERT_EQ(orig_value, olp::porting::any_cast<std::string>(value));
 
   std::string updated_value("updatedValue");
   cache.Put(key, updated_value);
 
   value = cache.Get(key);
   ASSERT_FALSE(value.empty());
-  ASSERT_EQ(updated_value, boost::any_cast<std::string>(value));
+  ASSERT_EQ(updated_value, olp::porting::any_cast<std::string>(value));
 }
 
 TEST(InMemoryCacheTest, InsertOverLimit) {
@@ -145,7 +145,7 @@ TEST(InMemoryCacheTest, InsertOverLimit) {
   ASSERT_TRUE(cache.Get("key0").empty());
   auto i1 = cache.Get("key1");
   ASSERT_FALSE(i1.empty());
-  ASSERT_EQ("value1", boost::any_cast<std::string>(i1));
+  ASSERT_EQ("value1", olp::porting::any_cast<std::string>(i1));
 }
 
 TEST(InMemoryCacheTest, GetReorders) {
@@ -155,14 +155,14 @@ TEST(InMemoryCacheTest, GetReorders) {
 
   auto i0 = cache.Get("key0");
   ASSERT_FALSE(i0.empty());
-  ASSERT_EQ("value0", boost::any_cast<std::string>(i0));
+  ASSERT_EQ("value0", olp::porting::any_cast<std::string>(i0));
 
   Populate(cache, 1, 2);
   ASSERT_TRUE(cache.Get("key1").empty());
 
   auto i2 = cache.Get("key2");
   ASSERT_FALSE(i2.empty());
-  ASSERT_EQ("value2", boost::any_cast<std::string>(i2));
+  ASSERT_EQ("value2", olp::porting::any_cast<std::string>(i2));
 }
 
 TEST(InMemoryCacheTest, GetSingleExpired) {
@@ -370,7 +370,7 @@ TEST(InMemoryCacheTest, ClassBasedCustomCost) {
     auto model_item = std::get<2>(tuple);
     std::size_t result(1u);
 
-    if (auto data_container = boost::any_cast<Data>(model_item)) {
+    if (auto data_container = olp::porting::any_cast<Data>(model_item)) {
       auto data_size = data_container->size();
       result = (data_size > 0) ? data_size : result;
     }

olp-cpp-sdk-dataservice-read/src/repositories/ApiCacheRepository.cpp

@@ -57,7 +57,7 @@ porting::optional<std::string> ApiCacheRepository::Get(
     return olp::porting::none;
   }
 
-  return boost::any_cast<std::string>(url);
+  return olp::porting::any_cast<std::string>(url);
 }
 
 }  // namespace repository

olp-cpp-sdk-dataservice-read/src/repositories/CatalogCacheRepository.cpp

@@ -77,7 +77,7 @@ porting::optional<model::Catalog> CatalogCacheRepository::Get() {
     return olp::porting::none;
   }
 
-  return boost::any_cast<model::Catalog>(cached_catalog);
+  return olp::porting::any_cast<model::Catalog>(cached_catalog);
 }
 
 bool CatalogCacheRepository::PutVersion(const model::VersionResponse& version) {
@@ -102,7 +102,7 @@ porting::optional<model::VersionResponse> CatalogCacheRepository::GetVersion() {
   if (cached_version.empty()) {
     return olp::porting::none;
   }
-  return boost::any_cast<model::VersionResponse>(cached_version);
+  return olp::porting::any_cast<model::VersionResponse>(cached_version);
 }
 
 bool CatalogCacheRepository::Clear() {

olp-cpp-sdk-dataservice-read/src/repositories/PartitionsCacheRepository.cpp

@@ -190,7 +190,7 @@ porting::optional<model::LayerVersions> PartitionsCacheRepository::Get(
   }
 
   return std::move(
-      boost::any_cast<model::LayerVersions&&>(cached_layer_versions));
+      olp::porting::any_cast<model::LayerVersions&&>(cached_layer_versions));
 }
 
 client::ApiNoResponse PartitionsCacheRepository::Put(

olp-cpp-sdk-dataservice-write/src/ApiClientLookup.cpp

@@ -149,7 +149,7 @@ ApiClientLookup::ApiClientResponse ApiClientLookup::LookupApiClient(
     auto url =
         cache->Get(cache_key, [](const std::string& value) { return value; });
     if (!url.empty()) {
-      auto base_url = boost::any_cast<std::string>(url);
+      auto base_url = olp::porting::any_cast<std::string>(url);
       OLP_SDK_LOG_INFO_F(kLogTag, "LookupApiClient(%s, %s) -> from cache",
                          service.c_str(), service_version.c_str());
       client::OlpClient client(settings, base_url);

olp-cpp-sdk-dataservice-write/src/CatalogSettings.cpp

@@ -112,7 +112,8 @@ CatalogSettings::LayerSettingsResult CatalogSettings::GetLayerSettings(
             .str());
   }
 
-  const auto& catalog = boost::any_cast<const model::Catalog&>(cached_catalog);
+  const auto& catalog =
+      olp::porting::any_cast<const model::Catalog&>(cached_catalog);
   return GetLayerSettingsFromModel(catalog, layer_id);
 }
 

olp-cpp-sdk-dataservice-write/src/StreamLayerClientImpl.cpp

@@ -94,7 +94,7 @@ size_t StreamLayerClientImpl::QueueSize() const {
       cache_->Get(GetUuidListKey(), [](const std::string& s) { return s; });
   std::string uuid_list = "";
   if (!uuid_list_any.empty()) {
-    uuid_list = boost::any_cast<std::string>(uuid_list_any);
+    uuid_list = olp::porting::any_cast<std::string>(uuid_list_any);
     return std::count(uuid_list.cbegin(), uuid_list.cend(), ',');
   }
 
@@ -135,7 +135,7 @@ porting::optional<std::string> StreamLayerClientImpl::Queue(
         cache_->Get(GetUuidListKey(), [](const std::string& s) { return s; });
     std::string uuid_list = "";
     if (!uuid_list_any.empty()) {
-      uuid_list = boost::any_cast<std::string>(uuid_list_any);
+      uuid_list = olp::porting::any_cast<std::string>(uuid_list_any);
     }
     uuid_list += publish_data_key + ",";
 
@@ -158,7 +158,7 @@ StreamLayerClientImpl::PopFromQueue() {
     return olp::porting::none;
   }
 
-  auto uuid_list = boost::any_cast<std::string>(uuid_list_any);
+  auto uuid_list = olp::porting::any_cast<std::string>(uuid_list_any);
 
   auto pos = uuid_list.find(",");
   if (pos == std::string::npos) {
@@ -182,7 +182,7 @@ StreamLayerClientImpl::PopFromQueue() {
     return olp::porting::none;
   }
 
-  return boost::any_cast<model::PublishDataRequest>(publish_data_any);
+  return olp::porting::any_cast<model::PublishDataRequest>(publish_data_any);
 }
 
 olp::client::CancellableFuture<StreamLayerClient::FlushResponse>