Struct StoreImpl

pub struct StoreImpl<State, Action>
where
    State: Send + Sync + Clone + 'static,
    Action: Send + Sync + Clone + 'static,
{ /* private fields */ }

StoreImpl is the default implementation of a Redux store

Implementations

impl<State, Action> StoreImpl<State, Action>

where State: Send + Sync + Clone + 'static, Action: Send + Sync + Clone + 'static,

pub fn new(state: State) -> Arc<StoreImpl<State, Action>>

create a new store with an initial state

pub fn new_with_reducer( state: State, reducer: Box<dyn Reducer<State, Action> + Send + Sync>, ) -> Arc<StoreImpl<State, Action>>

create a new store with a reducer and an initial state

Examples found in repository

examples/calc_basic.rs (lines 96-99)

pub fn main() {
    println!("Hello, Basic!");

    let store = StoreImpl::<CalcState, CalcAction>::new_with_reducer(
        CalcState::default(),
        Box::new(CalcReducer::default()),
    );

    println!("add subscriber");
    store.add_subscriber(Arc::new(CalcSubscriber::default()));
    store.dispatch(CalcAction::Add(1)).expect("no dispatch failed");
    store.dispatch(CalcAction::Subtract(1)).expect("no dispatch failed");

    // stop the store
    store.stop();

    assert_eq!(store.get_state().count, 0);
}

examples/iter_state.rs (lines 5-11)

fn main() {
    // new store with reducer
    let store = StoreImpl::new_with_reducer(
        0,
        Box::new(FnReducer::from(|state: &i32, action: &i32| {
            println!("reducer: {} + {}", state, action);
            DispatchOp::Dispatch(state + action, None)
        })),
    );

    let mut iter = store.iter();

    // dispatch actions
    let _ = store.dispatch(41);
    let _ = store.dispatch(1);

    assert_eq!(iter.next(), Some((41, 41)));
    assert_eq!(iter.next(), Some((42, 1)));

    // stop the store
    store.stop();

    assert_eq!(iter.next(), None);
    eprintln!("exit");
}

pub fn new_with_name( state: State, reducer: Box<dyn Reducer<State, Action> + Send + Sync>, name: String, ) -> Result<Arc<StoreImpl<State, Action>>, StoreError>

create a new store with name

pub fn new_with( state: State, reducers: Vec<Box<dyn Reducer<State, Action> + Send + Sync>>, name: String, capacity: usize, policy: BackpressurePolicy<Action>, middlewares: Vec<Arc<dyn Middleware<State, Action> + Send + Sync>>, ) -> Result<Arc<StoreImpl<State, Action>>, StoreError>

create a new store

pub fn get_state(&self) -> State

get the latest state(for debugging)

prefer to use subscribe to get the state

Examples found in repository

examples/calc_basic.rs (line 109)

pub fn main() {
    println!("Hello, Basic!");

    let store = StoreImpl::<CalcState, CalcAction>::new_with_reducer(
        CalcState::default(),
        Box::new(CalcReducer::default()),
    );

    println!("add subscriber");
    store.add_subscriber(Arc::new(CalcSubscriber::default()));
    store.dispatch(CalcAction::Add(1)).expect("no dispatch failed");
    store.dispatch(CalcAction::Subtract(1)).expect("no dispatch failed");

    // stop the store
    store.stop();

    assert_eq!(store.get_state().count, 0);
}

examples/simple.rs (line 28)

pub fn main() {
    // new store with reducer
    let store = StoreBuilder::new(0)
        .with_reducer(Box::new(FnReducer::from(|state: &i32, action: &i32| {
            println!("reducer: {} + {}", state, action);
            DispatchOp::Dispatch(state + action, None)
        })))
        .build()
        .unwrap();

    // add subscriber
    store.add_subscriber(Arc::new(FnSubscriber::from(
        |state: &i32, _action: &i32| {
            println!("subscriber: state: {}", state);
        },
    )));

    // dispatch actions
    store.dispatch(41).expect("no error");
    store.dispatch(1).expect("no error");

    // stop the store
    store.stop();

    assert_eq!(store.get_state(), 42);
}

examples/calc_basic_builder.rs (line 114)

pub fn main() {
    println!("Hello, Builder!");

    let store =
        StoreBuilder::new_with_reducer(CalcState::default(), Box::new(CalcReducer::default()))
            .with_name("calc".to_string())
            .build()
            .unwrap();
    println!("add subscriber");
    store.add_subscriber(Arc::new(CalcSubscriber::default()));
    let _ = store.dispatch(CalcAction::Add(1)).expect("no dispatch failed");

    thread::sleep(std::time::Duration::from_secs(1));
    println!("add more subscriber");
    store.add_subscriber(Arc::new(CalcSubscriber::default()));
    let _ = store.dispatch(CalcAction::Subtract(1));

    // stop the store
    store.stop();

    assert_eq!(store.get_state().count, 0);
}

examples/dropoldest_if.rs (line 58)

fn main() {
    // predicate 기반 drop 정책 사용 예시
    // 작은 값들을 우선적으로 drop하는 predicate
    let predicate = Arc::new(|action_op: &rs_store::ActionOp<i32>| {
        match action_op {
            rs_store::ActionOp::Action(value) => *value < 5, // 5보다 작은 값들은 drop
            rs_store::ActionOp::Exit(_) => false,            // Exit는 drop하지 않음
        }
    });

    let policy = BackpressurePolicy::DropOldestIf { predicate };

    // 매우 작은 capacity로 store 생성하여 backpressure 상황 시뮬레이션
    let store = StoreBuilder::new(0)
        .with_reducer(Box::new(FnReducer::from(|state: &i32, action: &i32| {
            // reducer에서 지연을 추가하여 backpressure 상황 생성
            std::thread::sleep(std::time::Duration::from_millis(200));
            println!("reducer: {} + {}", state, action);
            DispatchOp::Dispatch(state + action, None)
        })))
        .with_capacity(2) // 매우 작은 capacity로 설정
        .with_policy(policy)
        .build()
        .unwrap();

    // subscriber 추가
    store.add_subscriber(Arc::new(FnSubscriber::from(|state: &i32, action: &i32| {
        println!("subscriber: state: {}, action: {}", state, action);
    })));

    println!("=== Predicate 기반 Backpressure 테스트 ===");
    println!("채널 capacity: 2");
    println!("predicate: 5보다 작은 값들은 drop");
    println!("reducer 지연: 200ms");
    println!();

    // 다양한 값들을 빠르게 dispatch
    let actions = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

    for action in actions {
        println!("dispatch: {}", action);
        match store.dispatch(action) {
            Ok(_) => println!("  -> 성공"),
            Err(e) => println!("  -> 실패: {:?}", e),
        }

        // 빠른 dispatch로 backpressure 상황 생성
        std::thread::sleep(std::time::Duration::from_millis(50));
    }

    // 처리 완료 대기
    std::thread::sleep(std::time::Duration::from_millis(3000));

    // 최종 상태 확인
    let final_state = store.get_state();
    println!();
    println!("최종 상태: {}", final_state);

    // 메트릭 확인
    let metrics = store.get_metrics();
    println!("메트릭:");
    println!("  - 받은 액션: {}", metrics.action_received);
    println!("  - 처리된 액션: {}", metrics.action_reduced);
    println!("  - drop된 액션: {}", metrics.action_dropped);

    store.stop();
}

pub fn get_metrics(&self) -> MetricsSnapshot

get the metrics

Examples found in repository

examples/dropoldest_if.rs (line 63)

fn main() {
    // predicate 기반 drop 정책 사용 예시
    // 작은 값들을 우선적으로 drop하는 predicate
    let predicate = Arc::new(|action_op: &rs_store::ActionOp<i32>| {
        match action_op {
            rs_store::ActionOp::Action(value) => *value < 5, // 5보다 작은 값들은 drop
            rs_store::ActionOp::Exit(_) => false,            // Exit는 drop하지 않음
        }
    });

    let policy = BackpressurePolicy::DropOldestIf { predicate };

    // 매우 작은 capacity로 store 생성하여 backpressure 상황 시뮬레이션
    let store = StoreBuilder::new(0)
        .with_reducer(Box::new(FnReducer::from(|state: &i32, action: &i32| {
            // reducer에서 지연을 추가하여 backpressure 상황 생성
            std::thread::sleep(std::time::Duration::from_millis(200));
            println!("reducer: {} + {}", state, action);
            DispatchOp::Dispatch(state + action, None)
        })))
        .with_capacity(2) // 매우 작은 capacity로 설정
        .with_policy(policy)
        .build()
        .unwrap();

    // subscriber 추가
    store.add_subscriber(Arc::new(FnSubscriber::from(|state: &i32, action: &i32| {
        println!("subscriber: state: {}, action: {}", state, action);
    })));

    println!("=== Predicate 기반 Backpressure 테스트 ===");
    println!("채널 capacity: 2");
    println!("predicate: 5보다 작은 값들은 drop");
    println!("reducer 지연: 200ms");
    println!();

    // 다양한 값들을 빠르게 dispatch
    let actions = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

    for action in actions {
        println!("dispatch: {}", action);
        match store.dispatch(action) {
            Ok(_) => println!("  -> 성공"),
            Err(e) => println!("  -> 실패: {:?}", e),
        }

        // 빠른 dispatch로 backpressure 상황 생성
        std::thread::sleep(std::time::Duration::from_millis(50));
    }

    // 처리 완료 대기
    std::thread::sleep(std::time::Duration::from_millis(3000));

    // 최종 상태 확인
    let final_state = store.get_state();
    println!();
    println!("최종 상태: {}", final_state);

    // 메트릭 확인
    let metrics = store.get_metrics();
    println!("메트릭:");
    println!("  - 받은 액션: {}", metrics.action_received);
    println!("  - 처리된 액션: {}", metrics.action_reduced);
    println!("  - drop된 액션: {}", metrics.action_dropped);

    store.stop();
}

pub fn add_reducer( &self, reducer: Box<dyn Reducer<State, Action> + Send + Sync>, )

add a reducer to the store

pub fn add_subscriber( &self, subscriber: Arc<dyn Subscriber<State, Action> + Send + Sync>, ) -> Box<dyn Subscription>

add a subscriber to the store

Examples found in repository

examples/calc_effect.rs (line 133)

pub fn main() {
    println!("Hello, Effect!");

    let store =
        StoreBuilder::new_with_reducer(CalcState::default(), Box::new(CalcReducer::default()))
            .with_name("store-effect".into())
            .build()
            .unwrap();

    store.add_subscriber(Arc::new(CalcSubscriber::default()));
    let _ = store.dispatch(CalcAction::AddWillProduceThunk(1));

    store.stop();
}

examples/calc_basic.rs (line 102)

pub fn main() {
    println!("Hello, Basic!");

    let store = StoreImpl::<CalcState, CalcAction>::new_with_reducer(
        CalcState::default(),
        Box::new(CalcReducer::default()),
    );

    println!("add subscriber");
    store.add_subscriber(Arc::new(CalcSubscriber::default()));
    store.dispatch(CalcAction::Add(1)).expect("no dispatch failed");
    store.dispatch(CalcAction::Subtract(1)).expect("no dispatch failed");

    // stop the store
    store.stop();

    assert_eq!(store.get_state().count, 0);
}

examples/calc_fn_basic.rs (line 69)

pub fn main() {
    println!("Hello, reduce function !");

    let store = StoreBuilder::new_with_reducer(
        CalcState::default(),
        Box::new(FnReducer::from(calc_reducer)),
    )
    .with_name("store-reduce-fn".into())
    .build()
    .unwrap();

    store.add_subscriber(Arc::new(FnSubscriber::from(calc_subscriber)));
    let _ = store.dispatch(CalcAction::Add(1));

    thread::sleep(std::time::Duration::from_secs(1));
    store.add_subscriber(Arc::new(FnSubscriber::from(calc_subscriber)));
    let _ = store.dispatch(CalcAction::Subtract(1));

    store.stop();
}

examples/simple.rs (lines 15-19)

pub fn main() {
    // new store with reducer
    let store = StoreBuilder::new(0)
        .with_reducer(Box::new(FnReducer::from(|state: &i32, action: &i32| {
            println!("reducer: {} + {}", state, action);
            DispatchOp::Dispatch(state + action, None)
        })))
        .build()
        .unwrap();

    // add subscriber
    store.add_subscriber(Arc::new(FnSubscriber::from(
        |state: &i32, _action: &i32| {
            println!("subscriber: state: {}", state);
        },
    )));

    // dispatch actions
    store.dispatch(41).expect("no error");
    store.dispatch(1).expect("no error");

    // stop the store
    store.stop();

    assert_eq!(store.get_state(), 42);
}

examples/calc_basic_builder.rs (line 103)

pub fn main() {
    println!("Hello, Builder!");

    let store =
        StoreBuilder::new_with_reducer(CalcState::default(), Box::new(CalcReducer::default()))
            .with_name("calc".to_string())
            .build()
            .unwrap();
    println!("add subscriber");
    store.add_subscriber(Arc::new(CalcSubscriber::default()));
    let _ = store.dispatch(CalcAction::Add(1)).expect("no dispatch failed");

    thread::sleep(std::time::Duration::from_secs(1));
    println!("add more subscriber");
    store.add_subscriber(Arc::new(CalcSubscriber::default()));
    let _ = store.dispatch(CalcAction::Subtract(1));

    // stop the store
    store.stop();

    assert_eq!(store.get_state().count, 0);
}

examples/calc_concurrent.rs (line 117)

pub fn main() {
    println!("Hello, Concurrent!");

    let store =
        StoreBuilder::new_with_reducer(CalcState::default(), Box::new(CalcReducer::default()))
            .with_name("store-concurrent".into())
            .build()
            .unwrap();

    println!("add subscriber");
    store.add_subscriber(Arc::new(CalcSubscriber::default()));
    let _ = store.dispatch(CalcAction::Add(1));

    let store_clone = store.clone();
    thread::spawn(move || {
        thread::sleep(std::time::Duration::from_secs(1));

        println!("add more subscriber");
        store_clone.add_subscriber(Arc::new(CalcSubscriber::new(1)));
        let _ = store_clone.dispatch(CalcAction::Subtract(1));
    })
    .join()
    .unwrap();

    store.stop();
}

Additional examples can be found in:

• examples/calc_thunk.rs
• examples/calc_unsubscribe.rs
• examples/dropoldest_if.rs

pub fn close(&self)

close the store

send an exit action to the store and drop the dispatch channel

pub fn stop(&self)

close the store and wait for the dispatcher to finish

Examples found in repository

examples/calc_effect.rs (line 136)

pub fn main() {
    println!("Hello, Effect!");

    let store =
        StoreBuilder::new_with_reducer(CalcState::default(), Box::new(CalcReducer::default()))
            .with_name("store-effect".into())
            .build()
            .unwrap();

    store.add_subscriber(Arc::new(CalcSubscriber::default()));
    let _ = store.dispatch(CalcAction::AddWillProduceThunk(1));

    store.stop();
}

examples/calc_basic.rs (line 107)

pub fn main() {
    println!("Hello, Basic!");

    let store = StoreImpl::<CalcState, CalcAction>::new_with_reducer(
        CalcState::default(),
        Box::new(CalcReducer::default()),
    );

    println!("add subscriber");
    store.add_subscriber(Arc::new(CalcSubscriber::default()));
    store.dispatch(CalcAction::Add(1)).expect("no dispatch failed");
    store.dispatch(CalcAction::Subtract(1)).expect("no dispatch failed");

    // stop the store
    store.stop();

    assert_eq!(store.get_state().count, 0);
}

examples/calc_fn_basic.rs (line 76)

pub fn main() {
    println!("Hello, reduce function !");

    let store = StoreBuilder::new_with_reducer(
        CalcState::default(),
        Box::new(FnReducer::from(calc_reducer)),
    )
    .with_name("store-reduce-fn".into())
    .build()
    .unwrap();

    store.add_subscriber(Arc::new(FnSubscriber::from(calc_subscriber)));
    let _ = store.dispatch(CalcAction::Add(1));

    thread::sleep(std::time::Duration::from_secs(1));
    store.add_subscriber(Arc::new(FnSubscriber::from(calc_subscriber)));
    let _ = store.dispatch(CalcAction::Subtract(1));

    store.stop();
}

examples/iter_state.rs (line 23)

fn main() {
    // new store with reducer
    let store = StoreImpl::new_with_reducer(
        0,
        Box::new(FnReducer::from(|state: &i32, action: &i32| {
            println!("reducer: {} + {}", state, action);
            DispatchOp::Dispatch(state + action, None)
        })),
    );

    let mut iter = store.iter();

    // dispatch actions
    let _ = store.dispatch(41);
    let _ = store.dispatch(1);

    assert_eq!(iter.next(), Some((41, 41)));
    assert_eq!(iter.next(), Some((42, 1)));

    // stop the store
    store.stop();

    assert_eq!(iter.next(), None);
    eprintln!("exit");
}

examples/simple.rs (line 26)

pub fn main() {
    // new store with reducer
    let store = StoreBuilder::new(0)
        .with_reducer(Box::new(FnReducer::from(|state: &i32, action: &i32| {
            println!("reducer: {} + {}", state, action);
            DispatchOp::Dispatch(state + action, None)
        })))
        .build()
        .unwrap();

    // add subscriber
    store.add_subscriber(Arc::new(FnSubscriber::from(
        |state: &i32, _action: &i32| {
            println!("subscriber: state: {}", state);
        },
    )));

    // dispatch actions
    store.dispatch(41).expect("no error");
    store.dispatch(1).expect("no error");

    // stop the store
    store.stop();

    assert_eq!(store.get_state(), 42);
}

examples/calc_basic_builder.rs (line 112)

pub fn main() {
    println!("Hello, Builder!");

    let store =
        StoreBuilder::new_with_reducer(CalcState::default(), Box::new(CalcReducer::default()))
            .with_name("calc".to_string())
            .build()
            .unwrap();
    println!("add subscriber");
    store.add_subscriber(Arc::new(CalcSubscriber::default()));
    let _ = store.dispatch(CalcAction::Add(1)).expect("no dispatch failed");

    thread::sleep(std::time::Duration::from_secs(1));
    println!("add more subscriber");
    store.add_subscriber(Arc::new(CalcSubscriber::default()));
    let _ = store.dispatch(CalcAction::Subtract(1));

    // stop the store
    store.stop();

    assert_eq!(store.get_state().count, 0);
}

Additional examples can be found in:

• examples/calc_concurrent.rs
• examples/calc_thunk.rs
• examples/calc_unsubscribe.rs
• examples/dropoldest_if.rs

pub fn stop_with_timeout(&self, timeout: Duration)

close the store and wait for the dispatcher to finish

pub fn dispatch(&self, action: Action) -> Result<(), StoreError>

dispatch an action

Return

• Ok(()) : if the action is dispatched
• Err(StoreError) : if the dispatch channel is closed

Examples found in repository

examples/calc_fn_basic.rs (line 70)

pub fn main() {
    println!("Hello, reduce function !");

    let store = StoreBuilder::new_with_reducer(
        CalcState::default(),
        Box::new(FnReducer::from(calc_reducer)),
    )
    .with_name("store-reduce-fn".into())
    .build()
    .unwrap();

    store.add_subscriber(Arc::new(FnSubscriber::from(calc_subscriber)));
    let _ = store.dispatch(CalcAction::Add(1));

    thread::sleep(std::time::Duration::from_secs(1));
    store.add_subscriber(Arc::new(FnSubscriber::from(calc_subscriber)));
    let _ = store.dispatch(CalcAction::Subtract(1));

    store.stop();
}

examples/iter_state.rs (line 16)

fn main() {
    // new store with reducer
    let store = StoreImpl::new_with_reducer(
        0,
        Box::new(FnReducer::from(|state: &i32, action: &i32| {
            println!("reducer: {} + {}", state, action);
            DispatchOp::Dispatch(state + action, None)
        })),
    );

    let mut iter = store.iter();

    // dispatch actions
    let _ = store.dispatch(41);
    let _ = store.dispatch(1);

    assert_eq!(iter.next(), Some((41, 41)));
    assert_eq!(iter.next(), Some((42, 1)));

    // stop the store
    store.stop();

    assert_eq!(iter.next(), None);
    eprintln!("exit");
}

examples/calc_basic_builder.rs (line 104)

pub fn main() {
    println!("Hello, Builder!");

    let store =
        StoreBuilder::new_with_reducer(CalcState::default(), Box::new(CalcReducer::default()))
            .with_name("calc".to_string())
            .build()
            .unwrap();
    println!("add subscriber");
    store.add_subscriber(Arc::new(CalcSubscriber::default()));
    let _ = store.dispatch(CalcAction::Add(1)).expect("no dispatch failed");

    thread::sleep(std::time::Duration::from_secs(1));
    println!("add more subscriber");
    store.add_subscriber(Arc::new(CalcSubscriber::default()));
    let _ = store.dispatch(CalcAction::Subtract(1));

    // stop the store
    store.stop();

    assert_eq!(store.get_state().count, 0);
}

examples/calc_concurrent.rs (line 118)

pub fn main() {
    println!("Hello, Concurrent!");

    let store =
        StoreBuilder::new_with_reducer(CalcState::default(), Box::new(CalcReducer::default()))
            .with_name("store-concurrent".into())
            .build()
            .unwrap();

    println!("add subscriber");
    store.add_subscriber(Arc::new(CalcSubscriber::default()));
    let _ = store.dispatch(CalcAction::Add(1));

    let store_clone = store.clone();
    thread::spawn(move || {
        thread::sleep(std::time::Duration::from_secs(1));

        println!("add more subscriber");
        store_clone.add_subscriber(Arc::new(CalcSubscriber::new(1)));
        let _ = store_clone.dispatch(CalcAction::Subtract(1));
    })
    .join()
    .unwrap();

    store.stop();
}

examples/calc_unsubscribe.rs (line 118)

pub fn main() {
    println!("Hello, Unsubscribe!");

    let store =
        StoreBuilder::new_with_reducer(CalcState::default(), Box::new(CalcReducer::default()))
            .with_name("store-unsubscribe".into())
            .build()
            .unwrap();

    println!("add subscriber");
    store.add_subscriber(Arc::new(CalcSubscriber::default()));
    let _ = store.dispatch(CalcAction::Add(1));

    let store_clone = store.clone();
    let handle = thread::spawn(move || {
        thread::sleep(std::time::Duration::from_secs(1));

        // subscribe
        println!("add more subscriber");
        let subscription = store_clone.add_subscriber(Arc::new(CalcSubscriber::new(1)));
        let _ = store_clone.dispatch(CalcAction::Subtract(1));
        subscription
    });

    let subscription = handle.join().unwrap();

    println!("Unsubscribing...");
    subscription.unsubscribe();

    println!("Send 42...");
    let _ = store.dispatch(CalcAction::Add(42));

    store.stop();

    println!("Done!");
}

examples/dropoldest_if.rs (line 45)

fn main() {
    // predicate 기반 drop 정책 사용 예시
    // 작은 값들을 우선적으로 drop하는 predicate
    let predicate = Arc::new(|action_op: &rs_store::ActionOp<i32>| {
        match action_op {
            rs_store::ActionOp::Action(value) => *value < 5, // 5보다 작은 값들은 drop
            rs_store::ActionOp::Exit(_) => false,            // Exit는 drop하지 않음
        }
    });

    let policy = BackpressurePolicy::DropOldestIf { predicate };

    // 매우 작은 capacity로 store 생성하여 backpressure 상황 시뮬레이션
    let store = StoreBuilder::new(0)
        .with_reducer(Box::new(FnReducer::from(|state: &i32, action: &i32| {
            // reducer에서 지연을 추가하여 backpressure 상황 생성
            std::thread::sleep(std::time::Duration::from_millis(200));
            println!("reducer: {} + {}", state, action);
            DispatchOp::Dispatch(state + action, None)
        })))
        .with_capacity(2) // 매우 작은 capacity로 설정
        .with_policy(policy)
        .build()
        .unwrap();

    // subscriber 추가
    store.add_subscriber(Arc::new(FnSubscriber::from(|state: &i32, action: &i32| {
        println!("subscriber: state: {}, action: {}", state, action);
    })));

    println!("=== Predicate 기반 Backpressure 테스트 ===");
    println!("채널 capacity: 2");
    println!("predicate: 5보다 작은 값들은 drop");
    println!("reducer 지연: 200ms");
    println!();

    // 다양한 값들을 빠르게 dispatch
    let actions = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

    for action in actions {
        println!("dispatch: {}", action);
        match store.dispatch(action) {
            Ok(_) => println!("  -> 성공"),
            Err(e) => println!("  -> 실패: {:?}", e),
        }

        // 빠른 dispatch로 backpressure 상황 생성
        std::thread::sleep(std::time::Duration::from_millis(50));
    }

    // 처리 완료 대기
    std::thread::sleep(std::time::Duration::from_millis(3000));

    // 최종 상태 확인
    let final_state = store.get_state();
    println!();
    println!("최종 상태: {}", final_state);

    // 메트릭 확인
    let metrics = store.get_metrics();
    println!("메트릭:");
    println!("  - 받은 액션: {}", metrics.action_received);
    println!("  - 처리된 액션: {}", metrics.action_reduced);
    println!("  - drop된 액션: {}", metrics.action_dropped);

    store.stop();
}

pub fn add_middleware( &self, middleware: Arc<dyn Middleware<State, Action> + Send + Sync>, )

Add middleware

pub fn iter(&self) -> impl Iterator<Item = (State, Action)>

Iterator for the state

it uses a channel to subscribe to the state changes the channel is rendezvous(capacity 1), the store will block on the channel until the subscriber consumes the state

Examples found in repository

examples/iter_state.rs (line 13)

fn main() {
    // new store with reducer
    let store = StoreImpl::new_with_reducer(
        0,
        Box::new(FnReducer::from(|state: &i32, action: &i32| {
            println!("reducer: {} + {}", state, action);
            DispatchOp::Dispatch(state + action, None)
        })),
    );

    let mut iter = store.iter();

    // dispatch actions
    let _ = store.dispatch(41);
    let _ = store.dispatch(1);

    assert_eq!(iter.next(), Some((41, 41)));
    assert_eq!(iter.next(), Some((42, 1)));

    // stop the store
    store.stop();

    assert_eq!(iter.next(), None);
    eprintln!("exit");
}

pub fn subscribed( &self, subscriber: Box<dyn Subscriber<State, Action> + Send + Sync>, ) -> Result<Box<dyn Subscription>, StoreError>

subscribing to store updates in new context with default capacity and BlockOnFull policy when the channel is full

Parameters

• subscriber: The subscriber to subscribe to the store

Return

• Subscription: Subscription for the store,

pub fn subscribed_with( &self, capacity: usize, policy: BackpressurePolicy<(Instant, State, Action)>, subscriber: Box<dyn Subscriber<State, Action> + Send + Sync>, ) -> Result<Box<dyn Subscription>, StoreError>

subscribing to store updates in new context

Parameters

• capacity: Channel buffer capacity
• policy: Backpressure policy for when channel is full, BlockOnFull or DropLatestIf is supported to prevent from dropping the ActionOp::Exit

Return

• Subscription: Subscription for the store,

Trait Implementations

impl<State, Action> Drop for StoreImpl<State, Action>

where State: Send + Sync + Clone + 'static, Action: Send + Sync + Clone + 'static,

close tx channel when the store is dropped, but not the dispatcher if you want to stop the dispatcher, call the stop method

fn drop(&mut self)

Executes the destructor for this type.

impl<State, Action> Store<State, Action> for StoreImpl<State, Action>

where State: Send + Sync + Clone + 'static, Action: Send + Sync + Clone + 'static,

fn get_state(&self) -> State

Get the current state

fn dispatch(&self, action: Action) -> Result<(), StoreError>

Dispatch an action

fn add_subscriber( &self, subscriber: Arc<dyn Subscriber<State, Action> + Send + Sync>, ) -> Box<dyn Subscription>

Add a subscriber to the store store updates are delivered to the subscriber in same reducer thread

fn subscribed( &self, subscriber: Box<dyn Subscriber<State, Action> + Send + Sync>, ) -> Result<Box<dyn Subscription>, StoreError>

Iterate over the store’s state and action pairs subscribe to the store in new context store updates are delivered to the subscriber in the new context

fn subscribed_with( &self, capacity: usize, policy: BackpressurePolicy<(Instant, State, Action)>, subscriber: Box<dyn Subscriber<State, Action> + Send + Sync>, ) -> Result<Box<dyn Subscription>, StoreError>

subscribe to the store in new context store updates are delivered to the subscriber in the new context

fn stop(&self)

Stop the store