wgtmac commented on code in PR #92: URL: https://github.com/apache/iceberg-cpp/pull/92#discussion_r2080820923
########## src/iceberg/util/config.h: ########## @@ -0,0 +1,116 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +#pragma once + +#include <format> +#include <functional> +#include <string> +#include <unordered_map> + +namespace iceberg { + +// Default conversion functions +template <typename U> +std::string defaultToString(const U& val) { + if constexpr ((std::is_signed_v<U> && std::is_integral_v<U>) || + std::is_floating_point_v<U>) { + return std::to_string(val); + } else if constexpr (std::is_same_v<U, bool>) { + return val ? "true" : "false"; + } else if constexpr (std::is_same_v<U, std::string> || + std::is_same_v<U, std::string_view>) { + return val; + } else { + throw std::runtime_error( + std::format("Explicit toStr() is required for {}", typeid(U).name())); + } +} + +template <typename U> +U defaultFromString(const std::string& val) { + if constexpr (std::is_same_v<U, std::string>) { + return val; + } else if constexpr (std::is_same_v<U, bool>) { + return val == "true"; + } else if constexpr (std::is_signed_v<U> && std::is_integral_v<U>) { + return static_cast<U>(std::stoll(val)); + } else if constexpr (std::is_floating_point_v<U>) { + return static_cast<U>(std::stod(val)); + } else { + throw std::runtime_error( Review Comment: ditto ########## src/iceberg/util/config.h: ########## @@ -0,0 +1,116 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +#pragma once + +#include <format> +#include <functional> +#include <string> +#include <unordered_map> + +namespace iceberg { + +// Default conversion functions +template <typename U> +std::string defaultToString(const U& val) { + if constexpr ((std::is_signed_v<U> && std::is_integral_v<U>) || + std::is_floating_point_v<U>) { + return std::to_string(val); + } else if constexpr (std::is_same_v<U, bool>) { + return val ? "true" : "false"; + } else if constexpr (std::is_same_v<U, std::string> || + std::is_same_v<U, std::string_view>) { + return val; + } else { + throw std::runtime_error( + std::format("Explicit toStr() is required for {}", typeid(U).name())); + } +} + +template <typename U> +U defaultFromString(const std::string& val) { + if constexpr (std::is_same_v<U, std::string>) { + return val; + } else if constexpr (std::is_same_v<U, bool>) { + return val == "true"; + } else if constexpr (std::is_signed_v<U> && std::is_integral_v<U>) { + return static_cast<U>(std::stoll(val)); + } else if constexpr (std::is_floating_point_v<U>) { + return static_cast<U>(std::stod(val)); + } else { + throw std::runtime_error( + std::format("Explicit toT() is required for {}", typeid(U).name())); + } +} + +template <class ConcreteConfig> +class ConfigBase { + public: + template <typename T> + class Entry { + public: + Entry(std::string key, const T& val, + std::function<std::string(const T&)> to_str = defaultToString<T>, + std::function<T(const std::string&)> from_str = defaultFromString<T>) + : key_{std::move(key)}, default_{val}, to_str_{to_str}, from_str_{from_str} {} + + private: + const std::string key_; + const T default_; + const std::function<std::string(const T&)> to_str_; + const std::function<T(const std::string&)> from_str_; + + friend ConfigBase; + friend ConcreteConfig; + + public: + const std::string& key() const { return key_; } + + const T& value() const { return default_; } + }; + + template <typename T> + ConfigBase& set(const Entry<T>& entry, const T& val) { + configs_[entry.key_] = entry.to_str_(val); + return *this; + } + + template <typename T> + ConfigBase& unset(const Entry<T>& entry) { + configs_.erase(entry.key_); + return *this; + } + + ConfigBase& reset() { + configs_.clear(); + return *this; + } + + template <typename T> + T get(const Entry<T>& entry) const { + auto iter = configs_.find(entry.key_); + return iter != configs_.cend() ? entry.from_str_(iter->second) : entry.default_; + } + + std::unordered_map<std::string, std::string> const& configs() const { return configs_; } Review Comment: ```suggestion const std::unordered_map<std::string, std::string>& configs() const { return configs_; } ``` ########## src/iceberg/util/config.h: ########## @@ -0,0 +1,116 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +#pragma once + +#include <format> +#include <functional> +#include <string> +#include <unordered_map> + +namespace iceberg { + +// Default conversion functions +template <typename U> +std::string defaultToString(const U& val) { + if constexpr ((std::is_signed_v<U> && std::is_integral_v<U>) || + std::is_floating_point_v<U>) { + return std::to_string(val); + } else if constexpr (std::is_same_v<U, bool>) { + return val ? "true" : "false"; + } else if constexpr (std::is_same_v<U, std::string> || + std::is_same_v<U, std::string_view>) { + return val; + } else { + throw std::runtime_error( + std::format("Explicit toStr() is required for {}", typeid(U).name())); + } +} + +template <typename U> +U defaultFromString(const std::string& val) { + if constexpr (std::is_same_v<U, std::string>) { + return val; + } else if constexpr (std::is_same_v<U, bool>) { + return val == "true"; + } else if constexpr (std::is_signed_v<U> && std::is_integral_v<U>) { + return static_cast<U>(std::stoll(val)); + } else if constexpr (std::is_floating_point_v<U>) { + return static_cast<U>(std::stod(val)); + } else { + throw std::runtime_error( + std::format("Explicit toT() is required for {}", typeid(U).name())); + } +} + +template <class ConcreteConfig> +class ConfigBase { + public: + template <typename T> + class Entry { + public: + Entry(std::string key, const T& val, + std::function<std::string(const T&)> to_str = defaultToString<T>, + std::function<T(const std::string&)> from_str = defaultFromString<T>) + : key_{std::move(key)}, default_{val}, to_str_{to_str}, from_str_{from_str} {} + + private: + const std::string key_; + const T default_; + const std::function<std::string(const T&)> to_str_; + const std::function<T(const std::string&)> from_str_; + + friend ConfigBase; + friend ConcreteConfig; + + public: + const std::string& key() const { return key_; } + + const T& value() const { return default_; } + }; + + template <typename T> + ConfigBase& set(const Entry<T>& entry, const T& val) { + configs_[entry.key_] = entry.to_str_(val); Review Comment: Use emplace to avoid copy? ########## src/iceberg/util/config.h: ########## @@ -0,0 +1,116 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +#pragma once + +#include <format> +#include <functional> +#include <string> +#include <unordered_map> + +namespace iceberg { + +// Default conversion functions +template <typename U> +std::string defaultToString(const U& val) { Review Comment: Actually I think the original lambda functions look simpler. @lidavidm ########## src/iceberg/util/config.h: ########## @@ -0,0 +1,116 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +#pragma once + +#include <format> +#include <functional> +#include <string> +#include <unordered_map> + +namespace iceberg { + +// Default conversion functions +template <typename U> +std::string defaultToString(const U& val) { + if constexpr ((std::is_signed_v<U> && std::is_integral_v<U>) || + std::is_floating_point_v<U>) { + return std::to_string(val); + } else if constexpr (std::is_same_v<U, bool>) { + return val ? "true" : "false"; + } else if constexpr (std::is_same_v<U, std::string> || + std::is_same_v<U, std::string_view>) { + return val; + } else { + throw std::runtime_error( + std::format("Explicit toStr() is required for {}", typeid(U).name())); + } +} + +template <typename U> +U defaultFromString(const std::string& val) { + if constexpr (std::is_same_v<U, std::string>) { + return val; + } else if constexpr (std::is_same_v<U, bool>) { + return val == "true"; + } else if constexpr (std::is_signed_v<U> && std::is_integral_v<U>) { + return static_cast<U>(std::stoll(val)); + } else if constexpr (std::is_floating_point_v<U>) { + return static_cast<U>(std::stod(val)); + } else { + throw std::runtime_error( + std::format("Explicit toT() is required for {}", typeid(U).name())); + } +} + +template <class ConcreteConfig> +class ConfigBase { + public: + template <typename T> + class Entry { + public: + Entry(std::string key, const T& val, + std::function<std::string(const T&)> to_str = defaultToString<T>, + std::function<T(const std::string&)> from_str = defaultFromString<T>) + : key_{std::move(key)}, default_{val}, to_str_{to_str}, from_str_{from_str} {} + + private: + const std::string key_; + const T default_; + const std::function<std::string(const T&)> to_str_; + const std::function<T(const std::string&)> from_str_; + + friend ConfigBase; + friend ConcreteConfig; + + public: + const std::string& key() const { return key_; } + + const T& value() const { return default_; } + }; + + template <typename T> + ConfigBase& set(const Entry<T>& entry, const T& val) { Review Comment: ```suggestion ConfigBase& Set(const Entry<T>& entry, const T& val) { ``` Usually functions use capitalized initial. The above `Entry` does not need capitalized initial because they have only trivial getters. ########## src/iceberg/util/config.h: ########## @@ -0,0 +1,116 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +#pragma once + +#include <format> +#include <functional> +#include <string> +#include <unordered_map> + +namespace iceberg { + +// Default conversion functions +template <typename U> +std::string defaultToString(const U& val) { + if constexpr ((std::is_signed_v<U> && std::is_integral_v<U>) || + std::is_floating_point_v<U>) { + return std::to_string(val); + } else if constexpr (std::is_same_v<U, bool>) { + return val ? "true" : "false"; + } else if constexpr (std::is_same_v<U, std::string> || + std::is_same_v<U, std::string_view>) { + return val; + } else { + throw std::runtime_error( + std::format("Explicit toStr() is required for {}", typeid(U).name())); + } +} + +template <typename U> +U defaultFromString(const std::string& val) { + if constexpr (std::is_same_v<U, std::string>) { + return val; + } else if constexpr (std::is_same_v<U, bool>) { + return val == "true"; + } else if constexpr (std::is_signed_v<U> && std::is_integral_v<U>) { + return static_cast<U>(std::stoll(val)); + } else if constexpr (std::is_floating_point_v<U>) { + return static_cast<U>(std::stod(val)); + } else { + throw std::runtime_error( + std::format("Explicit toT() is required for {}", typeid(U).name())); + } +} + +template <class ConcreteConfig> +class ConfigBase { + public: + template <typename T> + class Entry { + public: + Entry(std::string key, const T& val, + std::function<std::string(const T&)> to_str = defaultToString<T>, + std::function<T(const std::string&)> from_str = defaultFromString<T>) + : key_{std::move(key)}, default_{val}, to_str_{to_str}, from_str_{from_str} {} + + private: + const std::string key_; + const T default_; + const std::function<std::string(const T&)> to_str_; + const std::function<T(const std::string&)> from_str_; + + friend ConfigBase; + friend ConcreteConfig; + + public: + const std::string& key() const { return key_; } + + const T& value() const { return default_; } + }; + + template <typename T> + ConfigBase& set(const Entry<T>& entry, const T& val) { + configs_[entry.key_] = entry.to_str_(val); + return *this; + } + + template <typename T> + ConfigBase& unset(const Entry<T>& entry) { + configs_.erase(entry.key_); + return *this; + } + + ConfigBase& reset() { + configs_.clear(); + return *this; + } + + template <typename T> + T get(const Entry<T>& entry) const { Review Comment: ```suggestion T Get(const Entry<T>& entry) const { ``` ########## src/iceberg/util/config.h: ########## @@ -0,0 +1,116 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +#pragma once + +#include <format> +#include <functional> +#include <string> +#include <unordered_map> + +namespace iceberg { + +// Default conversion functions +template <typename U> +std::string defaultToString(const U& val) { Review Comment: ```suggestion std::string DefaultToString(const U& val) { ``` ########## src/iceberg/util/config.h: ########## @@ -0,0 +1,116 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +#pragma once + +#include <format> +#include <functional> +#include <string> +#include <unordered_map> + +namespace iceberg { + +// Default conversion functions +template <typename U> +std::string defaultToString(const U& val) { + if constexpr ((std::is_signed_v<U> && std::is_integral_v<U>) || + std::is_floating_point_v<U>) { + return std::to_string(val); + } else if constexpr (std::is_same_v<U, bool>) { + return val ? "true" : "false"; + } else if constexpr (std::is_same_v<U, std::string> || + std::is_same_v<U, std::string_view>) { + return val; + } else { + throw std::runtime_error( + std::format("Explicit toStr() is required for {}", typeid(U).name())); + } +} + +template <typename U> +U defaultFromString(const std::string& val) { + if constexpr (std::is_same_v<U, std::string>) { + return val; + } else if constexpr (std::is_same_v<U, bool>) { + return val == "true"; + } else if constexpr (std::is_signed_v<U> && std::is_integral_v<U>) { + return static_cast<U>(std::stoll(val)); + } else if constexpr (std::is_floating_point_v<U>) { + return static_cast<U>(std::stod(val)); + } else { + throw std::runtime_error( + std::format("Explicit toT() is required for {}", typeid(U).name())); + } +} + +template <class ConcreteConfig> +class ConfigBase { + public: + template <typename T> + class Entry { + public: + Entry(std::string key, const T& val, + std::function<std::string(const T&)> to_str = defaultToString<T>, + std::function<T(const std::string&)> from_str = defaultFromString<T>) + : key_{std::move(key)}, default_{val}, to_str_{to_str}, from_str_{from_str} {} + + private: + const std::string key_; + const T default_; + const std::function<std::string(const T&)> to_str_; + const std::function<T(const std::string&)> from_str_; + + friend ConfigBase; + friend ConcreteConfig; + + public: + const std::string& key() const { return key_; } + + const T& value() const { return default_; } + }; + + template <typename T> + ConfigBase& set(const Entry<T>& entry, const T& val) { + configs_[entry.key_] = entry.to_str_(val); + return *this; + } + + template <typename T> + ConfigBase& unset(const Entry<T>& entry) { Review Comment: ```suggestion ConfigBase& Unset(const Entry<T>& entry) { ``` ########## src/iceberg/util/config.h: ########## @@ -0,0 +1,116 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +#pragma once + +#include <format> +#include <functional> +#include <string> +#include <unordered_map> + +namespace iceberg { + +// Default conversion functions +template <typename U> +std::string defaultToString(const U& val) { + if constexpr ((std::is_signed_v<U> && std::is_integral_v<U>) || + std::is_floating_point_v<U>) { + return std::to_string(val); + } else if constexpr (std::is_same_v<U, bool>) { + return val ? "true" : "false"; + } else if constexpr (std::is_same_v<U, std::string> || + std::is_same_v<U, std::string_view>) { + return val; + } else { + throw std::runtime_error( + std::format("Explicit toStr() is required for {}", typeid(U).name())); + } +} + +template <typename U> +U defaultFromString(const std::string& val) { Review Comment: ```suggestion U DefaultFromString(const std::string& val) { ``` ########## src/iceberg/util/config.h: ########## @@ -0,0 +1,116 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +#pragma once + +#include <format> +#include <functional> +#include <string> +#include <unordered_map> + +namespace iceberg { + +// Default conversion functions +template <typename U> +std::string defaultToString(const U& val) { + if constexpr ((std::is_signed_v<U> && std::is_integral_v<U>) || + std::is_floating_point_v<U>) { + return std::to_string(val); + } else if constexpr (std::is_same_v<U, bool>) { + return val ? "true" : "false"; + } else if constexpr (std::is_same_v<U, std::string> || + std::is_same_v<U, std::string_view>) { + return val; + } else { + throw std::runtime_error( Review Comment: Include `iceberg/exception.h` and replace it with `IcebergError` exception ########## src/iceberg/util/config.h: ########## @@ -0,0 +1,116 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +#pragma once + +#include <format> +#include <functional> +#include <string> +#include <unordered_map> + +namespace iceberg { + +// Default conversion functions +template <typename U> +std::string defaultToString(const U& val) { + if constexpr ((std::is_signed_v<U> && std::is_integral_v<U>) || + std::is_floating_point_v<U>) { + return std::to_string(val); + } else if constexpr (std::is_same_v<U, bool>) { + return val ? "true" : "false"; + } else if constexpr (std::is_same_v<U, std::string> || + std::is_same_v<U, std::string_view>) { + return val; + } else { + throw std::runtime_error( + std::format("Explicit toStr() is required for {}", typeid(U).name())); + } +} + +template <typename U> +U defaultFromString(const std::string& val) { + if constexpr (std::is_same_v<U, std::string>) { + return val; + } else if constexpr (std::is_same_v<U, bool>) { + return val == "true"; + } else if constexpr (std::is_signed_v<U> && std::is_integral_v<U>) { + return static_cast<U>(std::stoll(val)); + } else if constexpr (std::is_floating_point_v<U>) { + return static_cast<U>(std::stod(val)); + } else { + throw std::runtime_error( + std::format("Explicit toT() is required for {}", typeid(U).name())); + } +} + +template <class ConcreteConfig> +class ConfigBase { + public: + template <typename T> + class Entry { + public: + Entry(std::string key, const T& val, + std::function<std::string(const T&)> to_str = defaultToString<T>, + std::function<T(const std::string&)> from_str = defaultFromString<T>) + : key_{std::move(key)}, default_{val}, to_str_{to_str}, from_str_{from_str} {} + + private: + const std::string key_; + const T default_; + const std::function<std::string(const T&)> to_str_; + const std::function<T(const std::string&)> from_str_; + + friend ConfigBase; + friend ConcreteConfig; + + public: + const std::string& key() const { return key_; } + + const T& value() const { return default_; } + }; + + template <typename T> + ConfigBase& set(const Entry<T>& entry, const T& val) { + configs_[entry.key_] = entry.to_str_(val); + return *this; + } + + template <typename T> + ConfigBase& unset(const Entry<T>& entry) { + configs_.erase(entry.key_); + return *this; + } + + ConfigBase& reset() { Review Comment: ```suggestion ConfigBase& Reset() { ``` ########## src/iceberg/util/config.h: ########## @@ -0,0 +1,116 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +#pragma once + +#include <format> +#include <functional> +#include <string> +#include <unordered_map> + +namespace iceberg { + +// Default conversion functions +template <typename U> +std::string defaultToString(const U& val) { Review Comment: BTW, what about wrapping these functions in the `namespace iceberg::internal`? -- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. To unsubscribe, e-mail: issues-unsubscr...@iceberg.apache.org For queries about this service, please contact Infrastructure at: us...@infra.apache.org --------------------------------------------------------------------- To unsubscribe, e-mail: issues-unsubscr...@iceberg.apache.org For additional commands, e-mail: issues-h...@iceberg.apache.org
