Struct SegmentConfigBuilder 

pub struct SegmentConfigBuilder { /* private fields */ }

Ergonomic builder for SegmentConfig.

SegmentConfig is #[non_exhaustive], so direct struct-literal construction is forbidden outside the crate. The builder is the recommended way for callers to override one or two fields without re-typing every default.

use segment_buffer::{FlushPolicy, SegmentConfig};
use std::time::Duration;

let config = SegmentConfig::builder()
    .flush_policy(FlushPolicy::Batch(64))
    .compression_level(6)
    .build();
assert_eq!(config.flush_policy, FlushPolicy::Batch(64));
assert_eq!(config.compression_level, 6);
// Untouched fields fall back to Default.
assert_eq!(config.max_size_bytes, 10 * 1024 * 1024 * 1024);

Implementations

impl SegmentConfigBuilder

pub fn flush_policy(self, policy: FlushPolicy) -> Self

Override the auto-flush policy. See FlushPolicy for variants.

pub fn flush_at_batch_size(self, batch_size: usize) -> Self

Convenience: install a FlushPolicy::Batch(batch_size).

pub fn flush_at_interval(self, interval: Duration) -> Self

Convenience: install a FlushPolicy::Interval(interval).

pub fn flush_at_batch_or_interval( self, batch_size: usize, interval: Duration, ) -> Self

Convenience: install a FlushPolicy::BatchOrInterval { .. } with both triggers set.

pub fn flush_manually(self) -> Self

Convenience: install a FlushPolicy::Manual (no auto-flush).

pub fn max_size_bytes(self, max_size_bytes: u64) -> Self

Override the disk-usage ceiling that triggers is_overloaded().

pub fn compression_level(self, compression_level: i32) -> Self

Override the zstd compression level (1-22; default 3, fast with a good ratio).

pub fn durability(self, policy: DurabilityPolicy) -> Self

Override the per-flush durability policy. See DurabilityPolicy for the three policies and their crash-loss tradeoffs.

The default is DurabilityPolicy::Segment for backward compatibility. For cloud-sync deployments where the cloud endpoint holds the durable copy, DurabilityPolicy::Throughput eliminates the per-flush fsync from the hot path (typically a 5–10× win on fast storage).

pub fn cipher(self, cipher: Arc<dyn SegmentCipher + Send + Sync>) -> Self

Install a SegmentCipher so segment payloads are encrypted at rest.

Accepts an Arc so the same cipher can be shared across multiple buffers or cloned into a recommended_cipher() helper. The canonical construction pattern is:

use segment_buffer::{AesGcmCipher, SegmentConfig};
use std::sync::Arc;
let cfg = SegmentConfig::builder()
    .cipher(Arc::new(AesGcmCipher::new(&[0u8; 32])))
    .build();

pub fn recommended_cipher(self, key: [u8; 32]) -> Self

Available on crate feature encryption only.

Install the cipher this crate recommends for new buffers.

Available only under the encryption feature. Picks XChaCha20Poly1305Cipher (24-byte extended nonce, no 2³²-message limit per key, constant-time on hosts without AES-NI). Legacy AES-GCM segments still decrypt through AesGcmCipher; the two formats are byte-distinguishable only by which cipher the buffer was opened with.

Example

use segment_buffer::SegmentConfig;
let cfg = SegmentConfig::builder()
    .recommended_cipher([0u8; 32])
    .build();

pub fn build(self) -> SegmentConfig

Materialise the configured SegmentConfig.

Trait Implementations

impl Clone for SegmentConfigBuilder

fn clone(&self) -> SegmentConfigBuilder

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SegmentConfigBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.