SYMBOL INDEX (744 symbols across 32 files)

FILE: examples/graceful_shutdown.rs
  function main (line 15) | async fn main() {

FILE: src/conshash/mod.rs
  type Action (line 18) | pub enum Action {
  type InitTableError (line 24) | pub enum InitTableError {
  type CHError (line 33) | pub enum CHError {
  type LookupTables (line 38) | struct LookupTables {
  type ConsistentHashing (line 43) | pub struct ConsistentHashing {
    method new_with_id (line 55) | pub async fn new_with_id(
    method new (line 144) | pub async fn new(
    method new_client (line 151) | pub async fn new_client(
    method new_client_with_id (line 158) | pub async fn new_client_with_id(
    method to_server_name (line 172) | pub fn to_server_name(&self, server_id: u64) -> String {
    method to_server_name_option (line 181) | pub fn to_server_name_option(&self, server_id: Option<u64>) -> Option<...
    method get_server_id (line 189) | pub fn get_server_id(&self, hash: u64) -> Option<u64> {
    method jump_hash (line 200) | pub fn jump_hash(&self, slot_count: usize, hash: u64) -> usize {
    method get_server (line 218) | pub fn get_server(&self, hash: u64) -> Option<String> {
    method get_server_by_string (line 221) | pub fn get_server_by_string(&self, string: &String) -> Option<String> {
    method get_server_by (line 224) | pub fn get_server_by<T>(&self, obj: &T) -> Option<String>
    method get_server_id_by_string (line 230) | pub fn get_server_id_by_string(&self, string: &String) -> Option<u64> {
    method get_server_id_by (line 233) | pub fn get_server_id_by<T>(&self, obj: &T) -> Option<u64>
    method rand_server (line 239) | pub fn rand_server(&self) -> Option<String> {
    method rand_server_id (line 243) | pub fn rand_server_id(&self) -> Option<u64> {
    method nodes_count (line 247) | pub fn nodes_count(&self) -> usize {
    method server_count (line 251) | pub fn server_count(&self) -> usize {
    method set_weight (line 254) | pub async fn set_weight(&self, server_name: &String, weight: u64) -> R...
    method watch_all_actions (line 261) | fn watch_all_actions<F>(&self, f: F)
    method watch_server_nodes_range_changed (line 268) | pub fn watch_server_nodes_range_changed<F>(&self, server: &String, f: F)
    method init_table (line 296) | pub async fn init_table(&self) -> Result<(), InitTableError> {
    method membership (line 361) | pub fn membership(&self) -> &Arc<MembershipClient> {
  function server_joined (line 366) | async fn server_joined(ch: Arc<ConsistentHashing>, member: Member, versi...
  function server_left (line 369) | async fn server_left(ch: Arc<ConsistentHashing>, member: Member, version...
  function server_changed (line 372) | async fn server_changed(ch: Arc<ConsistentHashing>, member: Member, acti...
  function primary (line 418) | async fn primary() {

FILE: src/conshash/weights.rs
  type Weights (line 15) | pub struct Weights {
    method new_with_id (line 70) | pub async fn new_with_id(id: u64, raft_service: &Arc<RaftService>) {
    method new (line 78) | pub async fn new(raft_service: &Arc<RaftService>) {
  method set_weight (line 20) | fn set_weight(&mut self, group: u64, id: u64, weight: u64) -> BoxFuture<...
  method get_weights (line 29) | fn get_weights(&self, group: u64) -> BoxFuture<Option<HashMap<u64, u64>>> {
  method get_weight (line 36) | fn get_weight(&self, group: u64, id: u64) -> BoxFuture<Option<u64>> {
  method id (line 49) | fn id(&self) -> u64 {
  method snapshot (line 52) | fn snapshot(&self) -> Vec<u8> {
  method recover (line 55) | fn recover(&mut self, data: Vec<u8>) -> BoxFuture<()> {
  method recoverable (line 65) | fn recoverable(&self) -> bool {

FILE: src/hasher/src/lib.rs
  function hash_bytes (line 6) | pub fn hash_bytes(bytes: &[u8]) -> u64 {
  function hash_str (line 12) | pub fn hash_str<'a>(text: &'a str) -> u64 {
  function hash_bytes_secondary (line 18) | pub fn hash_bytes_secondary(bytes: &[u8]) -> u64 {

FILE: src/membership/client.rs
  type Member (line 14) | pub struct Member {
  type Group (line 21) | pub struct Group {
  type MemberClient (line 27) | pub struct MemberClient {
    method join_group (line 33) | pub async fn join_group(&self, group: &String) -> Result<bool, ExecErr...
    method leave_group (line 36) | pub async fn leave_group(&self, group: &String) -> Result<bool, ExecEr...
  type ObserverClient (line 41) | pub struct ObserverClient {
    method new (line 46) | pub fn new(raft_client: &Arc<RaftClient>) -> ObserverClient {
    method new_from_sm (line 51) | pub fn new_from_sm(sm_client: &Arc<SMClient>) -> ObserverClient {
    method new_group (line 56) | pub async fn new_group(&self, name: &String) -> Result<Result<u64, u64...
    method del_group (line 59) | pub async fn del_group(&self, name: &String) -> Result<bool, ExecError> {
    method group_leader (line 62) | pub async fn group_leader(
    method group_members (line 68) | pub async fn group_members(
    method all_members (line 77) | pub async fn all_members(&self, online_only: bool) -> Result<(Vec<Memb...
    method on_group_member_offline (line 80) | pub async fn on_group_member_offline<F>(
    method on_any_member_offline (line 92) | pub async fn on_any_member_offline<F>(
    method on_group_member_online (line 101) | pub async fn on_group_member_online<F>(
    method on_any_member_online (line 113) | pub async fn on_any_member_online<F>(
    method on_group_member_joined (line 122) | pub async fn on_group_member_joined<F>(
    method on_any_member_joined (line 134) | pub async fn on_any_member_joined<F>(
    method on_group_member_left (line 143) | pub async fn on_group_member_left<F>(
    method on_any_member_left (line 155) | pub async fn on_any_member_left<F>(
    method on_group_leader_changed (line 164) | pub async fn on_group_leader_changed<F>(
    method all_groups (line 179) | pub async fn all_groups(&self) -> Result<BTreeMap<u64, MemberGroup>, E...

FILE: src/membership/member.rs
  type MemberService (line 18) | pub struct MemberService {
    method new (line 27) | pub async fn new(
    method close (line 74) | pub fn close(&self) {
    method leave (line 77) | pub async fn leave(&self) -> Result<bool, ExecError> {
    method join_group (line 81) | pub async fn join_group(&self, group: &String) -> Result<bool, ExecErr...
    method leave_group (line 84) | pub async fn leave_group(&self, group: &String) -> Result<bool, ExecEr...
    method client (line 87) | pub fn client(&self) -> ObserverClient {
    method get_server_id (line 90) | pub fn get_server_id(&self) -> u64 {
  method drop (line 96) | fn drop(&mut self) {

FILE: src/membership/mod.rs
  function primary (line 64) | async fn primary() {

FILE: src/membership/server.rs
  type HBStatus (line 33) | struct HBStatus {
  type HeartbeatService (line 41) | pub struct HeartbeatService {
    method update_raft (line 83) | async fn update_raft(&self, online: &Vec<u64>, offline: &Vec<u64>) {
    method transfer_leadership (line 100) | async fn transfer_leadership(&self) {
    method shutdown (line 121) | pub async fn shutdown(&self) {
  method ping (line 50) | fn ping(&self, id: u64) -> BoxFuture<()> {
  type Member (line 144) | struct Member {
  type MemberGroup (line 150) | pub struct MemberGroup {
  type Membership (line 166) | pub struct Membership {
    method new (line 188) | pub async fn new(server: &Arc<Server>, raft_service: &Arc<RaftService>) {
    method compose_client_member (line 351) | async fn compose_client_member(&self, id: u64) -> Option<ClientMember> {
    method init_callback (line 360) | async fn init_callback(&mut self, raft_service: &Arc<RaftService>) {
    method notify_for_member_online (line 363) | async fn notify_for_member_online(&self, id: u64) {
    method notify_for_member_offline (line 393) | async fn notify_for_member_offline(&self, id: u64) {
    method notify_for_member_left (line 423) | async fn notify_for_member_left(&self, id: u64) {
    method notify_for_group_member_left (line 447) | async fn notify_for_group_member_left(&self, group: u64, member: &Clie...
    method leave_group_ (line 456) | async fn leave_group_(&mut self, group_id: u64, id: u64, need_notify: ...
    method member_groups (line 483) | fn member_groups(&self, member: u64) -> Option<HashSet<u64>> {
    method group_first_online_member_id (line 490) | async fn group_first_online_member_id(&self, group: u64) -> Result<Opt...
    method change_leader (line 504) | async fn change_leader(&mut self, group_id: u64, new: Option<u64>) -> ...
    method group_leader_candidate_available (line 537) | async fn group_leader_candidate_available(&mut self, group_id: u64, me...
    method group_leader_candidate_unavailable (line 554) | async fn group_leader_candidate_unavailable(&mut self, group_id: u64, ...
    method leader_candidate_available (line 575) | async fn leader_candidate_available(&mut self, member: u64) {
    method leader_candidate_unavailable (line 582) | async fn leader_candidate_unavailable(&mut self, member: u64) {
  method drop (line 174) | fn drop(&mut self) {
  method hb_online_changed (line 592) | fn hb_online_changed(&mut self, online: Vec<u64>, offline: Vec<u64>) -> ...
  method join (line 634) | fn join(&mut self, address: String) -> BoxFuture<Option<u64>> {
  method leave (line 681) | fn leave(&mut self, id: u64) -> BoxFuture<bool> {
  method join_group (line 706) | fn join_group(&mut self, group_name: String, id: u64) -> BoxFuture<bool> {
  method leave_group (line 752) | fn leave_group(&mut self, group_id: u64, id: u64) -> BoxFuture<bool> {
  method new_group (line 759) | fn new_group(&mut self, name: String) -> BoxFuture<Result<u64, u64>> {
  method del_group (line 780) | fn del_group(&mut self, id: u64) -> BoxFuture<bool> {
  method group_leader (line 801) | fn group_leader(&self, group_id: u64) -> BoxFuture<Option<(Option<Client...
  method group_members (line 817) | fn group_members(
  method all_members (line 844) | fn all_members(&self, online_only: bool) -> BoxFuture<(Vec<ClientMember>...
  method all_groups (line 863) | fn all_groups(&self) -> BoxFuture<BTreeMap<u64, MemberGroup>> {
  method id (line 869) | fn id(&self) -> u64 {
  method snapshot (line 872) | fn snapshot(&self) -> Vec<u8> {
  method recover (line 879) | fn recover(&mut self, _: Vec<u8>) -> BoxFuture<()> {
  method recoverable (line 884) | fn recoverable(&self) -> bool {

FILE: src/plugins/src/lib.rs
  function hash_ident (line 11) | pub fn hash_ident(item: TokenStream) -> TokenStream {

FILE: src/proc_macro/src/lib.rs
  type Args (line 11) | struct Args {
  method parse (line 16) | fn parse(input: ParseStream) -> Result<Self> {
  function adjust_caller_identifiers (line 23) | pub fn adjust_caller_identifiers(input: TokenStream) -> TokenStream {
  function adjust_function_signature (line 64) | pub fn adjust_function_signature(input: TokenStream) -> TokenStream {
  function deref_tuple_types (line 108) | pub fn deref_tuple_types(input: TokenStream) -> TokenStream {

FILE: src/raft/client.rs
  constant ORDERING (line 22) | const ORDERING: Ordering = Ordering::Relaxed;
  type Client (line 23) | pub type Client = Arc<AsyncServiceClient>;
  type SubscriptionReceipt (line 24) | pub type SubscriptionReceipt = (SubKey, u64);
  type ClientError (line 31) | pub enum ClientError {
    method fmt (line 37) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type SubscriptionError (line 48) | pub enum SubscriptionError {
  type PlaneClientState (line 54) | struct PlaneClientState {
  type Members (line 61) | struct Members {
  type AsRaftPlaneClient (line 66) | pub trait AsRaftPlaneClient: Send + Sync {
    method as_raft_plane_client (line 67) | fn as_raft_plane_client(self: &Arc<Self>) -> Arc<RaftPlaneClient>;
    method as_raft_plane_client (line 133) | fn as_raft_plane_client(self: &Arc<Self>) -> Arc<RaftPlaneClient> {
    method as_raft_plane_client (line 139) | fn as_raft_plane_client(self: &Arc<Self>) -> Arc<RaftPlaneClient> {
  type RaftPlaneClient (line 71) | pub struct RaftPlaneClient {
    method plane_id (line 77) | pub fn plane_id(&self) -> PlaneId {
    method execute (line 81) | pub async fn execute<R, M>(&self, sm_id: u64, msg: M) -> Result<R, Exe...
    method subscribe (line 91) | pub async fn subscribe<M, R, F>(
    method unsubscribe (line 107) | pub async fn unsubscribe(
    method cluster_info (line 114) | pub async fn cluster_info(&self) -> Result<ClientClusterInfo, ExecErro...
    method have_state_machine (line 118) | pub async fn have_state_machine(&self, sm_id: u64) -> Result<bool, Exe...
  type RaftClient (line 125) | pub struct RaftClient {
    method new_plane_state (line 145) | fn new_plane_state() -> Arc<PlaneClientState> {
    method new (line 154) | pub async fn new(servers: &Vec<String>, service_id: u64) -> Result<Arc...
    method plane_state (line 168) | async fn plane_state(&self, plane_id: PlaneId) -> Arc<PlaneClientState> {
    method plane (line 187) | pub fn plane(self: &Arc<Self>, plane_id: PlaneId) -> Arc<RaftPlaneClie...
    method type1 (line 194) | pub fn type1(self: &Arc<Self>) -> Arc<RaftPlaneClient> {
    method add_root_member (line 198) | pub async fn add_root_member(&self, address: &String) -> Result<bool, ...
    method remove_root_member (line 203) | pub async fn remove_root_member(&self, address: &String) -> Result<(),...
    method root_member_addresses (line 208) | pub async fn root_member_addresses(&self) -> Result<Vec<String>, ExecE...
    method prepare_subscription (line 212) | pub async fn prepare_subscription(server: &Arc<rpc::Server>) -> Option...
    method cluster_info (line 223) | async fn cluster_info<'a>(
    method update_info (line 384) | async fn update_info(&self, servers: &Vec<String>) -> Result<(), Clien...
    method update_plane_info (line 469) | async fn update_plane_info(
    method probe_servers (line 503) | pub async fn probe_servers(
    method execute (line 532) | pub async fn execute<R, M>(&self, sm_id: u64, msg: M) -> Result<R, Exe...
    method execute_on_plane (line 540) | pub async fn execute_on_plane<R, M>(
    method can_callback (line 567) | pub async fn can_callback() -> bool {
    method get_sub_key (line 570) | fn get_sub_key<M, R>(&self, plane_id: PlaneId, sm_id: u64, msg: M) -> ...
    method get_callback (line 583) | pub async fn get_callback(&self) -> Result<Arc<SubscriptionService>, S...
    method subscribe (line 593) | pub async fn subscribe<M, R, F>(
    method subscribe_on_plane (line 608) | pub async fn subscribe_on_plane<M, R, F>(
    method unsubscribe (line 647) | pub async fn unsubscribe(
    method query_on_plane (line 685) | async fn query_on_plane(
    method command_on_plane (line 802) | async fn command_on_plane(
    method gen_log_entry (line 1056) | fn gen_log_entry(
    method leader_id (line 1072) | pub fn leader_id(&self) -> u64 {
    method leader_client (line 1076) | pub async fn leader_client(&self) -> Option<(u64, Client)> {
    method any_known_client (line 1081) | async fn any_known_client(&self) -> Option<Client> {
    method preferred_client_on_plane (line 1086) | async fn preferred_client_on_plane(&self, state: &PlaneClientState) ->...
    method leader_client_on_plane (line 1094) | async fn leader_client_on_plane(&self, state: &PlaneClientState) -> Op...
    method current_leader_client_on_plane (line 1104) | async fn current_leader_client_on_plane(
    method current_leader_rpc_client (line 1152) | pub async fn current_leader_rpc_client(&self) -> Result<Arc<rpc::RPCCl...
    method cluster_info_on_plane (line 1160) | pub async fn cluster_info_on_plane(
    method have_state_machine_on_plane (line 1178) | pub async fn have_state_machine_on_plane(
  function swap_when_greater (line 1198) | fn swap_when_greater(atomic: &AtomicU64, value: u64) {
  type CachedStateMachine (line 1215) | pub struct CachedStateMachine<T: StateMachineClient> {
  function new (line 1224) | pub fn new(
  function get (line 1245) | pub async fn get(&self) -> Arc<T> {

FILE: src/raft/disk.rs
  type DiskOptions (line 18) | pub struct DiskOptions {
    method new (line 29) | pub fn new(path: String) -> Self {
  type StorageEntity (line 41) | pub struct StorageEntity {
    method new_with_options (line 131) | pub fn new_with_options(
    method new_with_options_on_plane (line 148) | pub fn new_with_options_on_plane(
    method append_logs (line 277) | pub async fn append_logs<'a>(
    method post_processing (line 323) | pub async fn post_processing<'a>(
    method flush_wal (line 371) | pub async fn flush_wal(&mut self) -> io::Result<()> {
    method write_commit_progress (line 384) | pub async fn write_commit_progress(
    method read_commit_progress (line 401) | pub async fn read_commit_progress(&self) -> io::Result<Option<(u64, u6...
    method write_snapshot (line 417) | pub async fn write_snapshot(&mut self, snapshot: &SnapshotEntity) -> i...
    method read_snapshot (line 460) | pub async fn read_snapshot(&self) -> io::Result<Option<SnapshotEntity>> {
  type DiskLogEntry (line 49) | pub struct DiskLogEntry {
    method encode (line 74) | pub fn encode(&self) -> Vec<u8> {
    method decode (line 92) | pub fn decode(data: &[u8]) -> io::Result<Self> {

FILE: src/raft/mod.rs
  type PlaneId (line 42) | pub struct PlaneId(u64);
    method type1 (line 50) | pub const fn type1() -> Self {
    method type2 (line 54) | pub fn type2(raw: u64) -> Result<Self, PlaneIdError> {
    method raw (line 62) | pub const fn raw(self) -> u64 {
    method is_type1 (line 66) | pub const fn is_type1(self) -> bool {
    method is_type2 (line 70) | pub const fn is_type2(self) -> bool {
  type PlaneIdError (line 45) | pub enum PlaneIdError {
  method fmt (line 76) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  function from (line 88) | fn from(value: PlaneId) -> Self {
  type RaftMsg (line 93) | pub trait RaftMsg<R>: Send + Sync {
    method encode (line 94) | fn encode(self) -> (u64, OpType, Vec<u8>);
    method decode_return (line 95) | fn decode_return(data: &Vec<u8>) -> R;
  constant CHECKER_MS (line 98) | const CHECKER_MS: i64 = 200;
  constant HEARTBEAT_MS (line 99) | const HEARTBEAT_MS: i64 = 1000;
  constant HEARTBEAT_TASK_TIMEOUT_MS (line 101) | const HEARTBEAT_TASK_TIMEOUT_MS: i64 = 5000;
  type LogEntry (line 104) | pub struct LogEntry {
  type ClientCmdResponse (line 113) | pub enum ClientCmdResponse {
  type ClientQryResponse (line 127) | pub enum ClientQryResponse {
  type ClientClusterInfo (line 139) | pub struct ClientClusterInfo {
  type AppendEntriesResult (line 147) | pub enum AppendEntriesResult {
  type SnapshotEntity (line 154) | pub struct SnapshotEntity {
  type LogEntries (line 160) | type LogEntries = Vec<LogEntry>;
  type LogsMap (line 161) | type LogsMap = BTreeMap<u64, LogEntry>;
  function gen_rand (line 178) | fn gen_rand(lower: i64, higher: i64) -> i64 {
  function gen_timeout (line 183) | fn gen_timeout() -> i64 {
  type FollowerStatus (line 187) | struct FollowerStatus {
  type LeaderMeta (line 192) | pub struct LeaderMeta {
    method new (line 198) | fn new() -> LeaderMeta {
  type Membership (line 206) | pub enum Membership {
  type LifecycleState (line 215) | enum LifecycleState {
  type RaftMeta (line 221) | pub struct RaftMeta {
  type Storage (line 239) | pub enum Storage {
    method default (line 245) | pub fn default() -> Storage {
  type Options (line 251) | pub struct Options {
  type PlaneSpec (line 258) | pub struct PlaneSpec {
  type PlaneBootstrap (line 263) | pub struct PlaneBootstrap {
  type PlaneError (line 269) | pub enum PlaneError {
  method fmt (line 276) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  type PlaneBootstrapError (line 292) | pub enum PlaneBootstrapError {
    method from (line 377) | fn from(value: PlaneError) -> Self {
    method from (line 383) | fn from(value: ExecError) -> Self {
    method from (line 389) | fn from(value: ClientError) -> Self {
  method fmt (line 317) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  type RaftPlaneRuntime (line 394) | struct RaftPlaneRuntime {
    method new (line 403) | fn new(opts: &Options, plane_id: PlaneId) -> Result<Self, PlaneError> {
  type PlaneHandle (line 449) | pub struct PlaneHandle {
    method id (line 455) | pub const fn id(&self) -> PlaneId {
    method callback (line 459) | pub async fn callback(&self, state_machine_id: u64) -> Result<SMCallba...
    method register_state_machine (line 463) | pub async fn register_state_machine(
    method recover_after_register (line 472) | pub async fn recover_after_register(&self) -> Result<(), PlaneError> {
    method cluster_info (line 478) | pub async fn cluster_info(&self) -> Result<ClientClusterInfo, PlaneErr...
    method have_state_machine (line 484) | pub async fn have_state_machine(&self, sm_id: u64) -> Result<bool, Pla...
    method is_leader (line 490) | pub async fn is_leader(&self) -> Result<bool, PlaneError> {
    method flush_persistence (line 494) | pub async fn flush_persistence(&self) -> Result<(), PlaneError> {
    method shutdown (line 498) | pub async fn shutdown(&self) -> Result<(), PlaneError> {
  function options_for_plane (line 503) | fn options_for_plane(opts: &Options, plane_id: PlaneId) -> Options {
  type RaftService (line 522) | pub struct RaftService {
    method plane_id (line 604) | pub const fn plane_id(&self) -> PlaneId {
    method check_plane (line 608) | fn check_plane(&self, plane_id: PlaneId) {
    method lifecycle_is_stopping (line 619) | fn lifecycle_is_stopping(state: LifecycleState) -> bool {
    method wait_for_apply_drain_for_meta (line 623) | async fn wait_for_apply_drain_for_meta(
    method start_managed_runtime (line 644) | async fn start_managed_runtime(self: &Arc<Self>, runtime: Option<Arc<R...
    method shutdown_managed_runtime (line 806) | async fn shutdown_managed_runtime(&self, runtime: Option<Arc<RaftPlane...
    method recover_after_register (line 872) | pub async fn recover_after_register(&self) {
    method plane_storage_path (line 894) | fn plane_storage_path(&self, plane_id: PlaneId) -> Option<String> {
    method plane_has_persisted_state (line 903) | fn plane_has_persisted_state(&self, plane_id: PlaneId) -> bool {
    method load_snapshot_into_meta (line 914) | async fn load_snapshot_into_meta(
    method recover_config_state_from_logs (line 993) | async fn recover_config_state_from_logs(
    method initialize_runtime_meta (line 1027) | async fn initialize_runtime_meta(
    method resolve_plane_runtime (line 1106) | async fn resolve_plane_runtime(
    method runtime_for_plane (line 1150) | async fn runtime_for_plane(
    method canonicalize_member_addresses (line 1159) | fn canonicalize_member_addresses(mut members: Vec<String>) -> Vec<Stri...
    method validate_plane_bootstrap (line 1165) | fn validate_plane_bootstrap(
    method plane_members_from_seed_nodes (line 1181) | async fn plane_members_from_seed_nodes(
    method plane_member_addresses (line 1199) | async fn plane_member_addresses(&self, plane_id: PlaneId) -> Result<Ve...
    method add_plane_member_via_log (line 1225) | async fn add_plane_member_via_log(
    method ensure_plane (line 1253) | pub async fn ensure_plane(
    method plane (line 1270) | pub async fn plane(self: &Arc<Self>, plane_id: PlaneId) -> Result<Plan...
    method ensure_plane_membership (line 1281) | async fn ensure_plane_membership(
    method ensure_plane_from_seeds (line 1320) | pub async fn ensure_plane_from_seeds(
    method loaded_type2_planes (line 1334) | pub async fn loaded_type2_planes(&self) -> Vec<PlaneId> {
    method recover_after_register_on_plane (line 1339) | pub async fn recover_after_register_on_plane(
    method register_state_machine_on_plane (line 1363) | pub async fn register_state_machine_on_plane(
    method subscriptions_on_plane (line 1379) | pub(crate) async fn subscriptions_on_plane(
    method cluster_info_on_plane_local (line 1394) | pub async fn cluster_info_on_plane_local(
    method have_state_machine_on_plane_local (line 1424) | pub async fn have_state_machine_on_plane_local(
    method is_leader_on_plane (line 1440) | pub async fn is_leader_on_plane(&self, plane_id: PlaneId) -> Result<bo...
    method flush_persistence_on_plane (line 1448) | pub async fn flush_persistence_on_plane(&self, plane_id: PlaneId) -> R...
    method shutdown_plane (line 1468) | pub async fn shutdown_plane(&self, plane_id: PlaneId) -> Result<(), Pl...
    method new (line 1516) | pub fn new(opts: Options) -> Arc<RaftService> {
    method load_snapshot_on_startup (line 1580) | async fn load_snapshot_on_startup(&self) -> bool {
    method start (line 1654) | pub async fn start(server: &Arc<RaftService>, recover_registered: bool...
    method new_server (line 1680) | pub async fn new_server(opts: Options) -> (bool, Arc<RaftService>, Arc...
    method probe_and_join (line 1689) | pub async fn probe_and_join(&self, servers: &Vec<String>) -> Result<bo...
    method bootstrap (line 1713) | pub async fn bootstrap(&self) {
    method conservative_bootstrap (line 1721) | pub async fn conservative_bootstrap(&self, servers: &Vec<String>) {
    method join (line 1766) | pub async fn join(&self, servers: &Vec<String>) -> Result<bool, ExecEr...
    method leave (line 1845) | pub async fn leave(&self) -> bool {
    method cluster_info (line 1960) | pub async fn cluster_info(&self) -> ClientClusterInfo {
    method num_members (line 1977) | pub async fn num_members(&self) -> usize {
    method num_logs (line 1983) | pub async fn num_logs(&self) -> usize {
    method last_log_id (line 1988) | pub async fn last_log_id(&self) -> Option<u64> {
    method leader_id (line 1993) | pub async fn leader_id(&self) -> u64 {
    method is_leader_for_real (line 1997) | pub async fn is_leader_for_real(&self) -> bool {
    method is_leader (line 2004) | pub fn is_leader(&self) -> bool {
    method get_server_id (line 2007) | pub fn get_server_id(&self) -> u64 {
    method flush_persistence (line 2012) | pub async fn flush_persistence(&self) {
    method shutdown (line 2030) | pub async fn shutdown(&self) {
    method register_state_machine (line 2052) | pub async fn register_state_machine(&self, state_machine: SubStateMach...
    method switch_membership (line 2057) | fn switch_membership(&self, meta: &mut RwLockWriteGuard<RaftMeta>, mem...
    method get_log_info_ (line 2061) | fn get_log_info_(&self, log: Option<(&u64, &LogEntry)>) -> (u64, u64) {
    method insert_leader_follower_meta (line 2067) | fn insert_leader_follower_meta(
    method reload_leader_meta (line 2084) | fn reload_leader_meta(
    method write_meta (line 2094) | async fn write_meta<'a>(&'a self) -> RwLockWriteGuard<'a, RaftMeta> {
    method read_meta (line 2098) | pub async fn read_meta(&self) -> RwLockReadGuard<'_, RaftMeta> {
    method become_candidate_on_plane (line 2102) | async fn become_candidate_on_plane<'a>(
    method become_candidate (line 2229) | async fn become_candidate<'a>(&'a self, meta: &'a mut RwLockWriteGuard...
    method become_follower_on_plane (line 2234) | fn become_follower_on_plane(
    method become_follower (line 2247) | fn become_follower(&self, meta: &mut RwLockWriteGuard<RaftMeta>, term:...
    method become_leader_on_plane (line 2251) | async fn become_leader_on_plane(
    method become_leader (line 2276) | async fn become_leader(&self, meta: &mut RwLockWriteGuard<'_, RaftMeta...
    method send_followers_heartbeat_on_plane (line 2281) | async fn send_followers_heartbeat_on_plane<'a>(
    method send_followers_heartbeat (line 2432) | async fn send_followers_heartbeat<'a>(
    method send_follower_heartbeat (line 2442) | async fn send_follower_heartbeat(
    method check_term_on_plane (line 2657) | fn check_term_on_plane(
    method reset_last_checked (line 2672) | fn reset_last_checked(&self, meta: &mut RwLockWriteGuard<RaftMeta>) {
    method handle_append_entries_on_meta (line 2683) | async fn handle_append_entries_on_meta<'a>(
    method handle_request_vote_on_meta (line 2764) | async fn handle_request_vote_on_meta<'a>(
    method handle_install_snapshot_on_meta (line 2793) | async fn handle_install_snapshot_on_meta<'a>(
    method handle_client_command_on_meta (line 2835) | async fn handle_client_command_on_meta<'a>(
    method handle_client_query_on_meta (line 2920) | async fn handle_client_query_on_meta<'a>(
    method leader_append_log (line 2942) | async fn leader_append_log<'a>(
    method logs_post_processing (line 2968) | async fn logs_post_processing<'a>(
    method try_sync_log_to_followers_on_plane (line 2980) | async fn try_sync_log_to_followers_on_plane<'a>(
    method try_sync_config_to_followers_on_plane (line 3051) | async fn try_sync_config_to_followers_on_plane<'a>(
    method should_take_snapshot (line 3074) | fn should_take_snapshot(
    method take_snapshot (line 3111) | async fn take_snapshot(&self, meta: &mut RwLockWriteGuard<'_, RaftMeta...
    method compact_logs_after_snapshot (line 3172) | async fn compact_logs_after_snapshot(
  type CheckerAction (line 535) | enum CheckerAction {
  type RequestVoteResponse (line 543) | enum RequestVoteResponse {
  type HeartbeatReplicationResult (line 549) | enum HeartbeatReplicationResult {
  function check_commit (line 561) | async fn check_commit(meta: &mut RwLockWriteGuard<'_, RaftMeta>) {
  function is_majority (line 1479) | fn is_majority(members: u64, granted: u64) -> bool {
  function apply_committed_entry (line 1489) | async fn apply_committed_entry<'a>(
  function is_leader (line 1496) | fn is_leader(meta: &RwLockWriteGuard<RaftMeta>) -> bool {
  function alter_term (line 1502) | fn alter_term(meta: &mut RwLockWriteGuard<RaftMeta>, term: u64) {
  function ensure_direct_leader_term (line 1509) | fn ensure_direct_leader_term(meta: &mut RwLockWriteGuard<'_, RaftMeta>) {
  method append_entries (line 3224) | fn append_entries<'a>(
  method request_vote (line 3277) | fn request_vote(
  method install_snapshot (line 3322) | fn install_snapshot(
  method c_command (line 3372) | fn c_command<'a>(
  method c_query (line 3402) | fn c_query<'a>(
  method c_server_cluster_info (line 3433) | fn c_server_cluster_info(&self, plane_id: PlaneId) -> BoxFuture<ClientCl...
  method c_put_offline (line 3455) | fn c_put_offline(&self) -> BoxFuture<bool> {
  method c_have_state_machine (line 3459) | fn c_have_state_machine(&self, plane_id: PlaneId, id: u64) -> BoxFuture<...
  method c_ping (line 3476) | fn c_ping(&self) -> BoxFuture<()> {
  method reelect (line 3480) | fn reelect<'a>(&'a self, plane_id: PlaneId) -> futures::future::BoxFutur...
  type RaftStateMachine (line 3521) | pub struct RaftStateMachine {
    method new (line 3527) | pub fn new(name: &String) -> RaftStateMachine {
  type CounterStateMachine (line 3553) | struct CounterStateMachine {
  method add (line 3563) | fn add(&mut self, value: u64) -> BoxFuture<u64> {
  method get (line 3568) | fn get(&self) -> BoxFuture<u64> {
  method id (line 3576) | fn id(&self) -> u64 {
  method snapshot (line 3580) | fn snapshot(&self) -> Vec<u8> {
  method recover (line 3584) | fn recover(&mut self, _: Vec<u8>) -> BoxFuture<()> {
  method recoverable (line 3588) | fn recoverable(&self) -> bool {
  type PersistentCounterStateMachine (line 3593) | struct PersistentCounterStateMachine {
  method add (line 3598) | fn add(&mut self, value: u64) -> BoxFuture<u64> {
  method get (line 3603) | fn get(&self) -> BoxFuture<u64> {
  method id (line 3611) | fn id(&self) -> u64 {
  method snapshot (line 3615) | fn snapshot(&self) -> Vec<u8> {
  method recover (line 3619) | fn recover(&mut self, data: Vec<u8>) -> BoxFuture<()> {
  method recoverable (line 3626) | fn recoverable(&self) -> bool {
  function wait_for_plane (line 3631) | async fn wait_for_plane(service: &Arc<RaftService>, plane_id: PlaneId) -...
  function query_counter_locally (line 3641) | async fn query_counter_locally(
  function add_counter_locally (line 3661) | async fn add_counter_locally(
  function startup (line 3683) | async fn startup() {
  function type2_plane_client_roundtrip (line 3694) | async fn type2_plane_client_roundtrip() {
  function loaded_type2_planes_only_reports_materialized_type2_runtimes (line 3739) | async fn loaded_type2_planes_only_reports_materialized_type2_runtimes() {
  function type2_plane_shutdown_rejects_commands (line 3765) | async fn type2_plane_shutdown_rejects_commands() {
  function unknown_type2_plane_does_not_fall_back_to_type1 (line 3814) | async fn unknown_type2_plane_does_not_fall_back_to_type1() {
  function unknown_type2_plane_rejects_commands_without_leader_discovery_loop (line 3841) | async fn unknown_type2_plane_rejects_commands_without_leader_discovery_l...
  function root_membership_helpers_hide_config_sm_commands (line 3867) | async fn root_membership_helpers_hide_config_sm_commands() {
  function type2_plane_bootstrap_is_idempotent_for_same_members (line 3926) | async fn type2_plane_bootstrap_is_idempotent_for_same_members() {
  function type2_plane_bootstrap_rejects_conflicting_member_set (line 3965) | async fn type2_plane_bootstrap_rejects_conflicting_member_set() {
  function type2_plane_multinode_replication_and_reelection (line 4030) | async fn type2_plane_multinode_replication_and_reelection() {
  function type2_plane_multinode_follower_restart_recovers_without_eager_load (line 4168) | async fn type2_plane_multinode_follower_restart_recovers_without_eager_l...
  function type2_plane_lazy_loads_after_unload (line 4302) | async fn type2_plane_lazy_loads_after_unload() {
  function server_membership (line 4410) | async fn server_membership() {
  function log_replication (line 4510) | async fn log_replication() {
  type SM (line 4649) | struct SM {
  method answer_to_the_universe (line 4653) | fn answer_to_the_universe<'a>(&'a self, name: String) -> BoxFuture<'_, S...
  method take_a_shot (line 4657) | fn take_a_shot(&mut self, num: i32) -> BoxFuture<i32> {
  method get_shot (line 4662) | fn get_shot(&self) -> BoxFuture<i32> {
  method id (line 4668) | fn id(&self) -> u64 {
  method snapshot (line 4671) | fn snapshot(&self) -> Vec<u8> {
  method recover (line 4675) | fn recover(&mut self, data: Vec<u8>) -> BoxFuture<()> {
  method recoverable (line 4683) | fn recoverable(&self) -> bool {
  function query_and_command (line 4689) | async fn query_and_command() {
  function multi_server_command (line 4724) | async fn multi_server_command() {
  function snapshot_disk_persistence (line 4820) | async fn snapshot_disk_persistence() {
  function snapshot_persistence_and_recovery (line 4885) | async fn snapshot_persistence_and_recovery() {
  function test_snapshot_recovery_on_startup (line 4942) | async fn test_snapshot_recovery_on_startup() {
  function test_snapshot_write_and_read (line 4985) | async fn test_snapshot_write_and_read() {
  function test_snapshot_corruption_detection (line 5034) | async fn test_snapshot_corruption_detection() {
  function test_log_compaction_removes_old_logs (line 5082) | async fn test_log_compaction_removes_old_logs() {
  function test_snapshot_threshold_configuration (line 5175) | async fn test_snapshot_threshold_configuration() {
  function test_state_machine_snapshot_and_recovery (line 5228) | async fn test_state_machine_snapshot_and_recovery() {
  function test_install_snapshot_compacts_logs (line 5252) | async fn test_install_snapshot_compacts_logs() {
  function test_wal_logs_written_to_disk (line 5365) | async fn test_wal_logs_written_to_disk() {
  function test_wal_recovery_after_crash (line 5439) | async fn test_wal_recovery_after_crash() {
  function test_wal_log_file_format (line 5568) | async fn test_wal_log_file_format() {
  function test_wal_fsync_durability (line 5652) | async fn test_wal_fsync_durability() {
  function test_wal_log_recovery_integration (line 5737) | async fn test_wal_log_recovery_integration() {
  function test_wal_deterministic_encoding (line 5892) | async fn test_wal_deterministic_encoding() {
  function test_wal_encoding_with_empty_data (line 5968) | async fn test_wal_encoding_with_empty_data() {
  function test_wal_encoding_with_large_data (line 5996) | async fn test_wal_encoding_with_large_data() {
  function test_wal_only_minimal_rsm_recovery (line 6031) | async fn test_wal_only_minimal_rsm_recovery() {
  function test_abrupt_crash_full_recovery (line 6192) | async fn test_abrupt_crash_full_recovery() {
  function test_wal_partial_write_truncation (line 6295) | async fn test_wal_partial_write_truncation() {
  function test_wal_crc_corruption_stops_at_bad_entry (line 6389) | async fn test_wal_crc_corruption_stops_at_bad_entry() {
  function test_snapshot_plus_wal_not_start_over (line 6501) | async fn test_snapshot_plus_wal_not_start_over() {

FILE: src/raft/state_machine/callback/client.rs
  type SubscriptionService (line 12) | pub struct SubscriptionService {
    method initialize (line 45) | pub async fn initialize(server: &Arc<Server>) -> Arc<SubscriptionServi...
  method notify (line 19) | fn notify<'a>(&'a self, key: SubKey, data: &'a Vec<u8>) -> BoxFuture<'a,...

FILE: src/raft/state_machine/callback/mod.rs
  type SubKey (line 10) | pub struct SubKey {
    method new (line 19) | pub const fn new(
  type Trigger (line 54) | pub struct Trigger {
  method trigger (line 65) | fn trigger(&mut self) -> BoxFuture<()> {
  method id (line 79) | fn id(&self) -> u64 {
  method snapshot (line 82) | fn snapshot(&self) -> Vec<u8> {
  method recover (line 85) | fn recover(&mut self, _: Vec<u8>) -> BoxFuture<()> {
  method recoverable (line 88) | fn recoverable(&self) -> bool {
  function dummy (line 94) | async fn dummy() {
  function dummy_type2_plane (line 156) | async fn dummy_type2_plane() {

FILE: src/raft/state_machine/callback/server.rs
  type Subscriber (line 14) | pub struct Subscriber {
  type Subscriptions (line 19) | pub struct Subscriptions {
    method new (line 29) | pub fn new() -> Subscriptions {
    method subscribe (line 40) | pub async fn subscribe(
    method remove_subscriber (line 108) | pub fn remove_subscriber(&mut self, suber_id: u64) {
    method remove_subscription (line 122) | pub fn remove_subscription(&mut self, id: u64) {
  type InternalSubscription (line 135) | pub struct InternalSubscription {
  type SMCallback (line 139) | pub struct SMCallback {
    method new (line 158) | pub async fn new(state_machine_id: u64, raft_service: Arc<RaftService>...
    method new_on_plane (line 164) | pub async fn new_on_plane(
    method notify (line 179) | pub async fn notify<M, R>(
    method internal_subscribe (line 272) | pub async fn internal_subscribe<R, F, M>(&self, msg: M, trigger: F) ->...
  type NotifyError (line 148) | pub enum NotifyError {
  function notify (line 299) | pub async fn notify<M, R, F>(callback: &Option<SMCallback>, msg: M, data...
  function test_subscriptions_new (line 323) | fn test_subscriptions_new() {
  function test_remove_subscription_nonexistent (line 335) | fn test_remove_subscription_nonexistent() {
  function test_remove_subscription (line 346) | fn test_remove_subscription() {
  function test_remove_subscriber (line 371) | fn test_remove_subscriber() {
  function test_remove_subscriber_nonexistent (line 400) | fn test_remove_subscriber_nonexistent() {
  function test_notify_error_debug (line 410) | fn test_notify_error_debug() {
  function test_subscriptions_next_id_increment (line 426) | fn test_subscriptions_next_id_increment() {
  function test_subscriptions_multiple_subs_per_subscriber (line 444) | fn test_subscriptions_multiple_subs_per_subscriber() {

FILE: src/raft/state_machine/configs.rs
  constant CONFIG_SM_ID (line 13) | pub const CONFIG_SM_ID: u64 = 1;
  type RaftMember (line 16) | pub struct RaftMember {
  type Configures (line 22) | pub struct Configures {
    method new (line 137) | pub fn new(service_id: u64) -> Configures {
    method recover_members (line 144) | async fn recover_members(&mut self, snapshot: MemberConfigSnapshot) {
    method new_member (line 158) | pub async fn new_member(&mut self, address: String) -> bool {
    method del_member (line 161) | pub async fn del_member(&mut self, address: String) {
    method member_existed (line 164) | pub fn member_existed(&self, id: u64) -> bool {
  type MemberConfigSnapshot (line 29) | pub type MemberConfigSnapshot = HashSet<String>;
  type ConfigSnapshot (line 32) | pub struct ConfigSnapshot {
  method new_member_ (line 47) | fn new_member_(&mut self, address: String) -> BoxFuture<bool> {
  method del_member_ (line 74) | fn del_member_(&mut self, address: String) -> BoxFuture<()> {
  method member_address (line 81) | fn member_address(&self) -> BoxFuture<Vec<String>> {
  method subscribe (line 84) | fn subscribe(
  method unsubscribe (line 96) | fn unsubscribe(&mut self, sub_id: u64) -> BoxFuture<()> {
  method id (line 107) | fn id(&self) -> u64 {
  method snapshot (line 110) | fn snapshot(&self) -> Vec<u8> {
  method recover (line 119) | fn recover(&mut self, data: Vec<u8>) -> BoxFuture<()> {
  method recoverable (line 131) | fn recoverable(&self) -> bool {
  function test_configures_new (line 175) | fn test_configures_new() {
  function test_configures_id (line 185) | fn test_configures_id() {
  function test_configures_recoverable (line 192) | fn test_configures_recoverable() {
  function test_member_existed (line 198) | fn test_member_existed() {
  function test_member_address (line 208) | async fn test_member_address() {
  function test_snapshot_empty (line 215) | fn test_snapshot_empty() {
  function test_recover_empty_snapshot (line 229) | async fn test_recover_empty_snapshot() {
  function test_recover_invalid_data (line 239) | async fn test_recover_invalid_data() {
  function test_del_member (line 251) | async fn test_del_member() {
  function test_config_snapshot_serialization (line 261) | fn test_config_snapshot_serialization() {
  function test_configures_has_subscriptions (line 279) | fn test_configures_has_subscriptions() {
  function test_membership_server_join (line 291) | async fn test_membership_server_join() {
  function test_membership_server_leave (line 325) | async fn test_membership_server_leave() {
  function test_membership_server_rejoin (line 356) | async fn test_membership_server_rejoin() {
  function test_membership_multiple_servers_join (line 388) | async fn test_membership_multiple_servers_join() {
  function test_membership_partial_leave (line 433) | async fn test_membership_partial_leave() {
  function test_membership_duplicate_join_attempt (line 478) | async fn test_membership_duplicate_join_attempt() {
  function test_membership_snapshot_with_members (line 505) | async fn test_membership_snapshot_with_members() {
  function test_membership_recovery_with_changes (line 550) | async fn test_membership_recovery_with_changes() {
  function test_membership_leave_nonexistent (line 600) | async fn test_membership_leave_nonexistent() {
  function test_membership_join_unreachable_server (line 610) | async fn test_membership_join_unreachable_server() {

FILE: src/raft/state_machine/master.rs
  type ExecError (line 11) | pub enum ExecError {
  type RegisterResult (line 22) | pub enum RegisterResult {
  type ExecOk (line 28) | pub type ExecOk = Vec<u8>;
  type ExecResult (line 29) | pub type ExecResult = Result<ExecOk, ExecError>;
  type SubStateMachine (line 30) | pub type SubStateMachine = Box<dyn StateMachineCtl>;
  type SnapshotDataItem (line 31) | pub type SnapshotDataItem = (u64, Vec<u8>);
  type SnapshotDataItems (line 32) | pub type SnapshotDataItems = Vec<SnapshotDataItem>;
  type MasterStateMachine (line 36) | pub struct MasterStateMachine {
    method new (line 96) | pub fn new(service_id: u64) -> MasterStateMachine {
    method new_on_plane (line 100) | pub fn new_on_plane(service_id: u64, plane_id: PlaneId) -> MasterState...
    method is_recoverable (line 111) | pub fn is_recoverable(&self, sm_id: u64) -> bool {
    method register (line 122) | pub fn register(&mut self, smc: SubStateMachine) -> RegisterResult {
    method recover_registered_snapshots (line 134) | pub async fn recover_registered_snapshots(&mut self) {
    method members (line 154) | pub fn members(&self) -> &HashMap<u64, RaftMember> {
    method commit_cmd (line 158) | pub async fn commit_cmd(&mut self, entry: &LogEntry) -> ExecResult {
    method exec_qry (line 205) | pub async fn exec_qry(&self, entry: &LogEntry) -> ExecResult {
    method clear_subs (line 252) | pub fn clear_subs(&mut self) {
    method has_sub (line 255) | pub fn has_sub(&self, id: &u64) -> bool {
  method id (line 47) | fn id(&self) -> u64 {
  method snapshot (line 50) | fn snapshot(&self) -> Vec<u8> {
  method recover (line 63) | fn recover(&mut self, data: Vec<u8>) -> BoxFuture<()> {
  method recoverable (line 81) | fn recoverable(&self) -> bool {
  function parse_output (line 86) | pub fn parse_output<'a>(r: Option<Vec<u8>>) -> ExecResult {
  method fmt (line 262) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {
  type MockStateMachine (line 273) | struct MockStateMachine {
  method id (line 283) | fn id(&self) -> u64 {
  method snapshot (line 287) | fn snapshot(&self) -> Vec<u8> {
  method recover (line 291) | fn recover(&mut self, data: Vec<u8>) -> BoxFuture<()> {
  method recoverable (line 296) | fn recoverable(&self) -> bool {
  function test_master_state_machine_new (line 304) | fn test_master_state_machine_new() {
  function test_master_state_machine_id (line 316) | fn test_master_state_machine_id() {
  function test_master_state_machine_recoverable (line 322) | fn test_master_state_machine_recoverable() {
  function test_is_recoverable_config_sm (line 328) | fn test_is_recoverable_config_sm() {
  function test_is_recoverable_registered_sm (line 336) | fn test_is_recoverable_registered_sm() {
  function test_is_recoverable_non_recoverable_sm (line 351) | fn test_is_recoverable_non_recoverable_sm() {
  function test_is_recoverable_unregistered_sm (line 366) | fn test_is_recoverable_unregistered_sm() {
  function test_register_ok (line 374) | fn test_register_ok() {
  function test_register_reserved (line 390) | fn test_register_reserved() {
  function test_register_existed (line 417) | fn test_register_existed() {
  function test_register_with_snapshot_recovery (line 442) | async fn test_register_with_snapshot_recovery() {
  function test_recover_registered_snapshots_applies_config_snapshot (line 477) | async fn test_recover_registered_snapshots_applies_config_snapshot() {
  function test_members (line 502) | fn test_members() {
  function test_clear_subs (line 510) | fn test_clear_subs() {
  function test_has_sub (line 529) | fn test_has_sub() {
  function test_snapshot_empty (line 547) | fn test_snapshot_empty() {
  function test_snapshot_with_recoverable_sm (line 559) | fn test_snapshot_with_recoverable_sm() {
  function test_snapshot_non_recoverable_sm_excluded (line 586) | fn test_snapshot_non_recoverable_sm_excluded() {
  function test_recover_valid_snapshot (line 610) | async fn test_recover_valid_snapshot() {
  function test_recover_invalid_snapshot (line 626) | async fn test_recover_invalid_snapshot() {
  function test_parse_output_some (line 641) | fn test_parse_output_some() {
  function test_parse_output_none (line 650) | fn test_parse_output_none() {
  function test_exec_error_display (line 658) | fn test_exec_error_display() {
  function test_exec_error_debug (line 669) | fn test_exec_error_debug() {
  function test_exec_error_clone (line 676) | fn test_exec_error_clone() {
  function test_all_exec_error_variants (line 684) | fn test_all_exec_error_variants() {
  function test_register_result_variants (line 697) | fn test_register_result_variants() {
  type KeyValueStateMachine (line 709) | struct KeyValueStateMachine {
  method id (line 717) | fn id(&self) -> u64 {
  method snapshot (line 721) | fn snapshot(&self) -> Vec<u8> {
  method recover (line 725) | fn recover(&mut self, data: Vec<u8>) -> BoxFuture<()> {
  method recoverable (line 732) | fn recoverable(&self) -> bool {
  method dispatch_cmd_ (line 738) | fn dispatch_cmd_<'a>(
  method dispatch_qry_ (line 771) | fn dispatch_qry_<'a>(
  method op_type_ (line 797) | fn op_type_(&self, _fn_id: u64) -> Option<OpType> {
  function test_real_world_kv_store_workflow (line 803) | async fn test_real_world_kv_store_workflow() {
  function test_real_world_multiple_operations (line 846) | async fn test_real_world_multiple_operations() {
  function test_real_world_snapshot_and_recovery (line 907) | async fn test_real_world_snapshot_and_recovery() {
  function test_real_world_multiple_state_machines (line 966) | async fn test_real_world_multiple_state_machines() {
  function test_real_world_error_handling (line 1034) | async fn test_real_world_error_handling() {
  function test_real_world_query_on_non_existent_sm (line 1071) | async fn test_real_world_query_on_non_existent_sm() {
  function test_real_world_config_sm_operations (line 1088) | async fn test_real_world_config_sm_operations() {
  function test_real_world_state_machine_lifecycle (line 1109) | async fn test_real_world_state_machine_lifecycle() {
  function test_real_world_concurrent_queries (line 1155) | async fn test_real_world_concurrent_queries() {

FILE: src/raft/state_machine/mod.rs
  type Storage (line 5) | pub enum Storage {
  type OpType (line 11) | pub enum OpType {
  type StateMachineCtl (line 17) | pub trait StateMachineCtl: Sync + Send + Any {
    method id (line 18) | fn id(&self) -> u64;
    method snapshot (line 19) | fn snapshot(&self) -> Vec<u8>;
    method recover (line 20) | fn recover(&mut self, data: Vec<u8>) -> ::futures::future::BoxFuture<()>;
    method recoverable (line 21) | fn recoverable(&self) -> bool;
    method fn_dispatch_qry (line 22) | fn fn_dispatch_qry<'a>(
    method fn_dispatch_cmd (line 27) | fn fn_dispatch_cmd<'a>(
    method op_type (line 32) | fn op_type(&mut self, fn_id: u64) -> Option<OpType>;
  type OpTypes (line 35) | pub trait OpTypes {
    method op_type (line 36) | fn op_type(&self, fn_id: u64) -> Option<OpType>;
  type StateMachineClient (line 39) | pub trait StateMachineClient {
    method new_instance (line 40) | fn new_instance(sm_id: u64, client: &Arc<RaftPlaneClient>) -> Self;
  constant MASTER_SM_ID (line 43) | pub const MASTER_SM_ID: u64 = 0;
  constant CONFIG_SM_ID (line 44) | pub const CONFIG_SM_ID: u64 = 1;
  constant RESERVED_INTERNAL_SM_ID_END (line 45) | pub const RESERVED_INTERNAL_SM_ID_END: u64 = 2;
  function is_reserved_internal_sm_id (line 47) | pub const fn is_reserved_internal_sm_id(sm_id: u64) -> bool {

FILE: src/rpc/cluster.rs
  function broadcast_to_members (line 13) | pub async fn broadcast_to_members<C, F, R, Fut>(
  function all_server_ids (line 26) | pub async fn all_server_ids(
  function broadcast_with_server_ids (line 33) | pub async fn broadcast_with_server_ids<C, F, R, I, Fut>(
  function client_by_server_id (line 63) | pub async fn client_by_server_id<C>(
  function client_by_rpc_client (line 77) | pub fn client_by_rpc_client<C>(client: &Arc<RPCClient>) -> Arc<C>
  type TestService (line 100) | pub struct TestService {
  method get_id (line 105) | fn get_id(&self) -> BoxFuture<u64> {
  method echo (line 109) | fn echo(&self, msg: String) -> BoxFuture<String> {
  constant SERVICE_ID (line 116) | const SERVICE_ID: u64 = 999;
  function test_client_by_rpc_client_creation (line 121) | fn test_client_by_rpc_client_creation() {

FILE: src/rpc/mod.rs
  type RPCRequestError (line 28) | pub enum RPCRequestError {
  type RPCError (line 36) | pub enum RPCError {
  type RPCService (line 42) | pub trait RPCService: Sync + Send {
    method dispatch (line 43) | fn dispatch(&self, data: BytesMut) -> BoxFuture<Result<BytesMut, RPCRe...
    method register_shortcut_service (line 44) | fn register_shortcut_service(
    method service_symbol (line 50) | fn service_symbol(&self) -> &'static str;
  type Server (line 53) | pub struct Server {
    method new (line 105) | pub fn new(address: &String) -> Arc<Server> {
    method listen (line 115) | pub async fn listen(server: &Arc<Server>) -> Result<(), Box<dyn Error>> {
    method listen_and_resume (line 165) | pub async fn listen_and_resume(server: &Arc<Server>) {
    method shutdown (line 229) | pub async fn shutdown(&self) {
    method register_service_with_id (line 243) | pub async fn register_service_with_id<T>(&self, service_id: u64, servi...
    method register_service (line 264) | pub async fn register_service<T>(&self, service: &Arc<T>)
    method remove_service (line 271) | pub async fn remove_service(&self, service_id: u64) {
    method address (line 274) | pub fn address(&self) -> &String {
  type ClientPool (line 63) | pub struct ClientPool {
    method new (line 314) | pub fn new() -> ClientPool {
    method get (line 320) | pub async fn get(&self, addr: &String) -> io::Result<Arc<RPCClient>> {
    method get_by_id (line 326) | pub async fn get_by_id<F>(&self, server_id: u64, addr_fn: F) -> io::Re...
  function encode_res (line 67) | fn encode_res(res: Result<BytesMut, RPCRequestError>) -> BytesMut {
  function decode_res (line 81) | fn decode_res(res: io::Result<BytesMut>) -> Result<BytesMut, RPCError> {
  function read_u64_head (line 99) | pub fn read_u64_head(mut data: BytesMut) -> (u64, BytesMut) {
  type RPCClient (line 279) | pub struct RPCClient {
    method send_async (line 293) | pub async fn send_async(
    method new_async (line 303) | pub async fn new_async(addr: &String) -> io::Result<Arc<RPCClient>> {
  function prepend_u64 (line 285) | pub fn prepend_u64(num: u64, data: BytesMut) -> BytesMut {
  type ServiceClient (line 345) | pub trait ServiceClient: Send + Sync {
    method new_instance_with_service_id (line 346) | fn new_instance_with_service_id(server_id: u64, client: &Arc<RPCClient...
    method server_id (line 347) | fn server_id(&self) -> u64;
    method new_with_service_id (line 348) | fn new_with_service_id(server_id: u64, client: &Arc<RPCClient>) -> Arc...
  type ServiceClientWithId (line 356) | pub trait ServiceClientWithId: ServiceClient {
    constant SERVICE_ID (line 357) | const SERVICE_ID: u64;
    method new (line 359) | fn new(client: &Arc<RPCClient>) -> Arc<Self>
  type RPCServiceWithId (line 367) | pub trait RPCServiceWithId: RPCService {
    constant SERVICE_ID (line 368) | const SERVICE_ID: u64;
  type HelloServer (line 388) | struct HelloServer;
  method hello (line 391) | fn hello(&self, name: String) -> BoxFuture<String> {
  method error (line 394) | fn error(&self, message: String) -> BoxFuture<Result<(), String>> {
  function simple_rpc (line 401) | pub async fn simple_rpc() {
  type Greeting (line 431) | pub struct Greeting {
  type Respond (line 437) | pub struct Respond {
  type HelloServer (line 446) | pub struct HelloServer;
  method hello (line 449) | fn hello(&self, gret: Greeting) -> BoxFuture<Respond> {
  function struct_rpc (line 460) | pub async fn struct_rpc() {
  type ComplexAnswer (line 491) | pub struct ComplexAnswer {
  type IdServer (line 504) | struct IdServer {
  method query_server_id (line 508) | fn query_server_id(&self) -> BoxFuture<u64> {
  method query_answer (line 512) | fn query_answer(&self, req: Option<String>) -> BoxFuture<ComplexAnswer> {
  method large_query (line 521) | fn large_query(&self, req: Option<String>) -> BoxFuture<Vec<ComplexAnswe...
  method large_req (line 533) | fn large_req(
  function multi_server_rpc (line 545) | async fn multi_server_rpc() {
  function lots_of_reqs (line 602) | pub async fn lots_of_reqs() {

FILE: src/rpc/proto.rs
  type A (line 238) | pub struct A {

FILE: src/tcp/client.rs
  type Client (line 24) | pub struct Client {
    method connect_with_timeout (line 34) | pub async fn connect_with_timeout(address: &String, timeout: Duration)...
    method connect (line 94) | pub async fn connect(address: &String) -> io::Result<Self> {
    method send_msg (line 97) | pub async fn send_msg(&self, msg: TcpReq) -> io::Result<BytesMut> {
  function test_client_connect_timeout (line 137) | async fn test_client_connect_timeout() {
  function test_client_standalone_address (line 153) | async fn test_client_standalone_address() {
  function test_client_server_id (line 168) | async fn test_client_server_id() {

FILE: src/tcp/server.rs
  type RPCFuture (line 14) | pub type RPCFuture = dyn Future<Output = TcpRes>;
  type BoxedRPCFuture (line 15) | pub type BoxedRPCFuture = Box<RPCFuture>;
  type TcpReq (line 16) | pub type TcpReq = BytesMut;
  type TcpRes (line 17) | pub type TcpRes = Pin<Box<dyn Future<Output = BytesMut> + Send>>;
  type Server (line 19) | pub struct Server {
    method new (line 24) | pub fn new() -> Server {
    method shutdown_handle (line 29) | pub fn shutdown_handle(&self) -> broadcast::Sender<()> {
    method listen (line 33) | pub async fn listen(
    method shutdown (line 105) | pub fn shutdown(&self) {
  function test_server_creation (line 120) | async fn test_server_creation() {
  function test_shutdown_handle (line 129) | async fn test_shutdown_handle() {
  function test_server_listen_and_shutdown (line 142) | async fn test_server_listen_and_shutdown() {
  function test_server_callback_invocation (line 177) | async fn test_server_callback_invocation() {

FILE: src/tcp/shortcut.rs
  function register_server (line 17) | pub async fn register_server(
  function call (line 26) | pub async fn call(server_id: u64, data: TcpReq) -> Result<BytesMut> {
  function is_local (line 37) | pub async fn is_local(server_id: u64) -> bool {

FILE: src/utils/bindings.rs
  type Binding (line 6) | pub struct Binding<T>
  function new (line 18) | pub fn new(default: T) -> Binding<T> {
  function get (line 24) | pub fn get(&self) -> T {
  function set (line 32) | pub fn set(&self, val: T) {
  function del (line 37) | pub fn del(&self) {
  type RefBinding (line 44) | pub struct RefBinding<T> {
  function new (line 48) | pub fn new(default: T) -> RefBinding<T> {
  function get (line 53) | pub fn get(&self) -> Arc<T> {
  function set (line 56) | pub fn set(&self, val: T) {
  function del (line 59) | pub fn del(&self) {

FILE: src/utils/math.rs
  function min (line 1) | pub fn min<T>(nums: &Vec<T>) -> Option<T>
  function max (line 10) | pub fn max<T>(nums: &Vec<T>) -> Option<T>
  function avg_scale (line 19) | pub fn avg_scale(nums: &Vec<u64>) -> Option<u64> {
  function max (line 36) | fn max() {
  function min (line 43) | fn min() {

FILE: src/utils/serde.rs
  function serialize (line 5) | pub fn serialize<T>(obj: &T) -> Vec<u8>
  function deserialize (line 16) | pub fn deserialize<'a, T>(data: &'a [u8]) -> Option<T>
  function serialize (line 34) | pub fn serialize<T>(obj: &T) -> Vec<u8>
  function deserialize (line 45) | pub fn deserialize<'a, T>(data: &'a [u8]) -> Option<T>
  function hash (line 64) | pub fn hash<T>(obj: &T) -> u64

FILE: src/utils/time.rs
  function get_time (line 5) | pub fn get_time() -> i64 {
  function duration_to_ms (line 13) | pub fn duration_to_ms(duration: Duration) -> u64 {
  function async_wait (line 18) | pub async fn async_wait(duration: Duration) {
  function async_wait_secs (line 22) | pub async fn async_wait_secs() {

FILE: src/vector_clock/mod.rs
  type Relation (line 7) | pub enum Relation {
  type VectorClock (line 15) | pub struct VectorClock<S: std::hash::Hash + Ord + Eq + Copy> {
  method partial_cmp (line 20) | fn partial_cmp(&self, other: &VectorClock<S>) -> Option<Ordering> {
  method cmp (line 32) | fn cmp(&self, other: &Self) -> Ordering {
  method eq (line 43) | fn eq(&self, other: &VectorClock<S>) -> bool {
  function new (line 50) | pub fn new() -> VectorClock<S> {
  function from_vec (line 54) | pub fn from_vec(vec: Vec<(S, u64)>) -> Self {
  function inc (line 58) | pub fn inc(&mut self, server: S) {
  function happened_before (line 70) | pub fn happened_before(&self, clock_b: &VectorClock<S>) -> bool {
  function equals (line 108) | pub fn equals(&self, clock_b: &VectorClock<S>) -> bool {
  function relation (line 150) | pub fn relation(&self, clock_b: &VectorClock<S>) -> Relation {
  function merge_with (line 163) | pub fn merge_with(&mut self, clock_b: &VectorClock<S>) {
  function learn_from (line 210) | pub fn learn_from(&mut self, clock_b: &VectorClock<S>) {
  type ServerVectorClock (line 254) | pub struct ServerVectorClock {
    method new (line 260) | pub fn new(server_address: &String) -> ServerVectorClock {
    method inc (line 266) | pub fn inc(&self) -> StandardVectorClock {
    method happened_before (line 272) | pub fn happened_before(&self, clock_b: &StandardVectorClock) -> bool {
    method equals (line 276) | pub fn equals(&self, clock_b: &StandardVectorClock) -> bool {
    method relation (line 280) | pub fn relation(&self, clock_b: &StandardVectorClock) -> Relation {
    method merge_with (line 284) | pub fn merge_with(&self, clock_b: &StandardVectorClock) {
    method learn_from (line 288) | pub fn learn_from(&self, clock_b: &StandardVectorClock) {
    method to_clock (line 292) | pub fn to_clock(&self) -> StandardVectorClock {
  type StandardVectorClock (line 298) | pub type StandardVectorClock = VectorClock<u64>;
  function general (line 305) | fn general() {
  function unaligned_clock_eq (line 355) | fn unaligned_clock_eq() {
  function unaligned_clock_rel_disjoint_concurrent (line 367) | fn unaligned_clock_rel_disjoint_concurrent() {
  function unaligned_clock_rel_joint_concurrent (line 379) | fn unaligned_clock_rel_joint_concurrent() {
  function test_merge_with (line 391) | fn test_merge_with() {
  function test_merge_with_empty (line 406) | fn test_merge_with_empty() {
  function test_merge_with_into_empty (line 417) | fn test_merge_with_into_empty() {
  function test_learn_from (line 427) | fn test_learn_from() {
  function test_learn_from_empty (line 438) | fn test_learn_from_empty() {
  function test_learn_from_into_empty (line 449) | fn test_learn_from_into_empty() {
  function test_server_vector_clock (line 459) | fn test_server_vector_clock() {
  function test_server_vector_clock_relation (line 484) | fn test_server_vector_clock_relation() {
  function test_inc_new_server (line 499) | fn test_inc_new_server() {
  function test_partial_ord (line 510) | fn test_partial_ord() {
  function test_ord (line 521) | fn test_ord() {
  function test_happened_before_empty_clocks (line 534) | fn test_happened_before_empty_clocks() {
  function test_equals_empty_clocks (line 544) | fn test_equals_empty_clocks() {
  function test_equals_with_zero_values (line 552) | fn test_equals_with_zero_values() {

FILE: tests/graceful_shutdown_tests.rs
  function test_tcp_server_shutdown_releases_port (line 17) | async fn test_tcp_server_shutdown_releases_port() {
  function test_rpc_server_shutdown_releases_port (line 88) | async fn test_rpc_server_shutdown_releases_port() {
  function test_raft_service_shutdown_stops_tasks (line 131) | async fn test_raft_service_shutdown_stops_tasks() {
  function test_full_stack_shutdown_releases_port (line 187) | async fn test_full_stack_shutdown_releases_port() {
  function test_rapid_shutdown_restart_cycles (line 255) | async fn test_rapid_shutdown_restart_cycles() {
  function test_active_connections_close_on_shutdown (line 285) | async fn test_active_connections_close_on_shutdown() {
  function test_shutdown_completes_within_timeout (line 322) | async fn test_shutdown_completes_within_timeout() {

FILE: tests/single_node_recovery_test.rs
  function test_single_node_cluster_recovery_becomes_leader (line 12) | async fn test_single_node_cluster_recovery_becomes_leader() {
  function test_single_node_multiple_restart_cycles (line 194) | async fn test_single_node_multiple_restart_cycles() {