slbotbm commented on code in PR #4022:
URL: https://github.com/apache/iggy/pull/4022#discussion_r3991294243
##########
foreign/cpp/include/iggy.hpp:
##########
@@ -98,186 +876,613 @@ class SnapshotCompression final : private
detail::StringTag<SnapshotCompression>
/** @brief Returns the uncompressed storage option. */
static SnapshotCompression Stored() { return
SnapshotCompression("stored"); }
- /** @brief Returns the Deflate compression option. */
- static SnapshotCompression Deflated() { return
SnapshotCompression("deflated"); }
+ /** @brief Returns the Deflate compression option. */
+ static SnapshotCompression Deflated() { return
SnapshotCompression("deflated"); }
+
+ /** @brief Uses bzip2 for better compression with slower processing. */
+ static SnapshotCompression Bzip2() { return SnapshotCompression("bzip2"); }
+
+ /** @brief Uses Zstandard for fast compression and decompression. */
+ static SnapshotCompression Zstd() { return SnapshotCompression("zstd"); }
+
+ /** @brief Uses LZMA for high compression, especially for larger files. */
+ static SnapshotCompression Lzma() { return SnapshotCompression("lzma"); }
+
+ /** @brief Uses XZ for LZMA-like compression with faster decompression. */
+ static SnapshotCompression Xz() { return SnapshotCompression("xz"); }
+
+ /**
+ * @brief Returns the snapshot compression algorithm name.
+ * @return Snapshot compression algorithm name.
+ */
+ [[nodiscard]] std::string_view Value() const { return
detail::StringTag<SnapshotCompression>::Value(); }
+
+ private:
+ explicit SnapshotCompression(std::string snapshot_compression)
+ :
detail::StringTag<SnapshotCompression>(std::move(snapshot_compression)) {}
+};
+
+/**
+ * @brief Selects data to include in a system snapshot.
+ */
+class SystemSnapshotType final : private detail::StringTag<SystemSnapshotType>
{
+ public:
+ /** @brief Includes an overview of the file-system structure. */
+ static SystemSnapshotType FilesystemOverview() { return
SystemSnapshotType("filesystem_overview"); }
+
+ /** @brief Includes currently running processes. */
+ static SystemSnapshotType ProcessList() { return
SystemSnapshotType("process_list"); }
+
+ /** @brief Includes CPU, memory, and other resource usage statistics. */
+ static SystemSnapshotType ResourceUsage() { return
SystemSnapshotType("resource_usage"); }
+
+ /** @brief Includes the test snapshot used for development and testing. */
+ static SystemSnapshotType Test() { return SystemSnapshotType("test"); }
+
+ /** @brief Includes server logs from the configured logging directory. */
+ static SystemSnapshotType ServerLogs() { return
SystemSnapshotType("server_logs"); }
+
+ /** @brief Includes server configuration. */
+ static SystemSnapshotType ServerConfig() { return
SystemSnapshotType("server_config"); }
+
+ /** @brief Includes all available snapshot data. */
+ static SystemSnapshotType All() { return SystemSnapshotType("all"); }
+
+ /**
+ * @brief Returns the value passed to the client implementation.
+ * @return System snapshot type name.
+ */
+ [[nodiscard]] std::string_view SnapshotTypeValue() const { return Value();
}
+
+ private:
+ explicit SystemSnapshotType(std::string snapshot_type)
+ : detail::StringTag<SystemSnapshotType>(std::move(snapshot_type)) {}
+};
+
+/**
+ * @brief Maximum retained size of a topic.
+ *
+ * A topic may use the server default, have no size limit, or use an explicit
+ * byte limit.
+ *
+ * Use ServerDefault(), Unlimited(), or FromBytes() to select the retention
+ * limit.
+ */
+class MaxTopicSize final : private detail::StringTag<MaxTopicSize> {
+ public:
+ /** @brief Returns the server-default size option. */
+ static MaxTopicSize ServerDefault() { return
MaxTopicSize("server_default"); }
+
+ /** @brief Returns the unlimited size option. */
+ static MaxTopicSize Unlimited() { return MaxTopicSize("unlimited"); }
+
+ /**
+ * @brief Creates an explicit topic size limit.
+ * @param bytes Maximum topic size in bytes.
+ * @return Server-default size for zero, unlimited size for
+ * std::numeric_limits<std::uint64_t>::max(), or the requested
limit.
+ * @note The configured limit cannot be smaller than the server segment
size.
+ */
+ static MaxTopicSize FromBytes(std::uint64_t bytes) {
+ if (bytes == 0) {
+ return ServerDefault();
+ }
+ if (bytes == std::numeric_limits<std::uint64_t>::max()) {
+ return Unlimited();
+ }
+ return MaxTopicSize(std::to_string(bytes));
+ }
+
+ /**
+ * @brief Returns the value passed to the client implementation.
+ * @return Topic size option or decimal byte count.
+ */
+ [[nodiscard]] std::string_view Value() const { return
detail::StringTag<MaxTopicSize>::Value(); }
+
+ private:
+ explicit MaxTopicSize(std::string max_topic_size) :
detail::StringTag<MaxTopicSize>(std::move(max_topic_size)) {}
+};
+
+/**
+ * @brief Message retention policy for a topic.
+ *
+ * Use ServerDefault(), NeverExpire(), or Duration() to select the retention
+ * policy.
+ */
+class Expiry final {
+ public:
+ /** @brief Returns the server-default expiry policy. */
+ static Expiry ServerDefault() { return Expiry("server_default", 0); }
+
+ /**
+ * @brief Keeps messages until another operation removes them, such as
+ * topic deletion.
+ */
+ static Expiry NeverExpire() { return Expiry("never_expire",
std::numeric_limits<std::uint64_t>::max()); }
+
+ /**
+ * @brief Creates a time-based expiry policy.
+ * @param micros Message lifetime in microseconds.
+ * @return Time-based expiry policy.
+ */
+ static Expiry Duration(std::uint64_t micros) { return Expiry("duration",
micros); }
+
+ /**
+ * @brief Returns the expiry policy kind.
+ * @return One of server_default, never_expire, or duration.
+ */
+ [[nodiscard]] std::string_view Kind() const { return expiry_kind_; }
+
+ /**
+ * @brief Returns the value associated with the expiry policy.
+ * @return Duration in microseconds for Duration(), zero for
ServerDefault(),
+ * or std::numeric_limits<std::uint64_t>::max() for NeverExpire().
+ */
+ [[nodiscard]] std::uint64_t Value() const { return expiry_value_; }
+
+ private:
+ explicit Expiry(std::string expiry_kind, std::uint64_t expiry_value)
+ : expiry_kind_(std::move(expiry_kind)), expiry_value_(expiry_value) {}
+
+ std::string expiry_kind_;
+ std::uint64_t expiry_value_;
+};
+
+enum class Durability { Replicated, Persisted };
+
+constexpr std::string_view to_string(const Durability durability) {
+ switch (durability) {
+ case Durability::Replicated:
+ return "replicated";
+ case Durability::Persisted:
+ return "persisted";
+ }
+ throw std::invalid_argument("Unknown durability");
+}
+
+/**
+ * @brief Options for creating a topic.
+ *
+ * Use the typed setters to configure supported topic settings. Leave a setting
+ * unset to use the server default. Use SetRawEntries() for supported options
+ * that do not yet have a typed setter. When both specify the same option, the
+ * typed setting takes precedence.
+ */
+class TopicCreateOptions final {
+ public:
+ TopicCreateOptions() = default;
+
+ /**
+ * @brief Returns the number of partitions to create.
+ * @return Configured partition count, or `std::nullopt` to use the server
Review Comment:
done
##########
foreign/cpp/src/type_conversion.rs:
##########
@@ -525,6 +528,167 @@ impl From<RustOptionSpec> for ffi::OptionSpec {
}
}
+impl TryFrom<ffi::TopicCreateOptions> for RustTopicCreateOptions {
+ type Error = String;
+
+ fn try_from(options: ffi::TopicCreateOptions) -> Result<Self, Self::Error>
{
+ use std::str::FromStr;
Review Comment:
done
--
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: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
