Struct FeatureFlags 

pub struct FeatureFlags {
    pub experimental: bool,
    pub beta: bool,
    pub enhanced_telemetry: bool,
    pub performance_profiling: bool,
    pub debug_mode: bool,
    pub compression_optimization: bool,
    pub adaptive_retry: bool,
}

Feature flags for runtime feature toggling

Examples

Using the default configuration (production-ready features enabled):

use chie_shared::FeatureFlags;

let flags = FeatureFlags::default();
assert!(!flags.experimental);
assert!(!flags.beta);
assert!(flags.compression_optimization);
assert!(flags.adaptive_retry);
assert!(!flags.has_unstable_features());

Using preset configurations:

use chie_shared::FeatureFlags;

// All features disabled (minimal mode)
let minimal = FeatureFlags::none();
assert!(!minimal.compression_optimization);
assert!(!minimal.has_diagnostic_features());

// All features enabled (debug/testing mode)
let all = FeatureFlags::all();
assert!(all.experimental);
assert!(all.debug_mode);
assert!(all.has_unstable_features());
assert!(all.has_diagnostic_features());

Building a custom configuration:

use chie_shared::FeatureFlagsBuilder;

let flags = FeatureFlagsBuilder::new()
    .experimental(true)
    .performance_profiling(true)
    .enhanced_telemetry(true)
    .build();

assert!(flags.experimental);
assert!(flags.performance_profiling);
assert!(flags.has_unstable_features());
assert!(flags.has_diagnostic_features());

Fields

experimental: bool

Enable experimental features

beta: bool

Enable beta features

enhanced_telemetry: bool

Enable enhanced telemetry

performance_profiling: bool

Enable performance profiling

debug_mode: bool

Enable debug mode

compression_optimization: bool

Enable compression optimization

adaptive_retry: bool

Enable adaptive retry

Implementations

impl FeatureFlags

pub const fn none() -> Self

Create a new feature flags configuration with all features disabled

pub const fn all() -> Self

Create a new feature flags configuration with all features enabled

pub const fn has_unstable_features(&self) -> bool

Check if any experimental or beta feature is enabled

pub const fn has_diagnostic_features(&self) -> bool

Check if any diagnostic feature is enabled

Trait Implementations

impl Clone for FeatureFlags

fn clone(&self) -> FeatureFlags

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FeatureFlags

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

Formats the value using the given formatter.

impl Default for FeatureFlags

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for FeatureFlags

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for FeatureFlags

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.