couchbase 1.0.1

The official Couchbase Rust SDK
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

/*
 *
 *  * Copyright (c) 2025 Couchbase, Inc.
 *  *
 *  * Licensed under the Apache License, Version 2.0 (the "License");
 *  * you may not use this file except in compliance with the License.
 *  * You may obtain a copy of the License at
 *  *
 *  *    http://www.apache.org/licenses/LICENSE-2.0
 *  *
 *  * Unless required by applicable law or agreed to in writing, software
 *  * distributed under the License is distributed on an "AS IS" BASIS,
 *  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  * See the License for the specific language governing permissions and
 *  * limitations under the License.
 *
 */

//! Diagnostics types for inspecting connection state.
//!
//! Contains the [`ConnectionState`] enum used in diagnostic results such as
//! [`DiagnosticsResult`](crate::results::diagnostics::DiagnosticsResult).

use serde::Serialize;
use std::fmt::Display;

/// The state of a connection to a Couchbase node.
///
/// Reported in diagnostics results (see [`DiagnosticsResult`](crate::results::diagnostics::DiagnosticsResult)).
#[derive(Copy, Debug, Clone, PartialEq, Eq, Serialize)]
#[non_exhaustive]
pub enum ConnectionState {
    /// The connection is established and active.
    Connected,
    /// The connection is not established.
    Disconnected,
    /// The connection is in the process of being established.
    Connecting,
    /// The connection is being shut down.
    Disconnecting,
}

impl Display for ConnectionState {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let txt = match self {
            ConnectionState::Connected => "connected",
            ConnectionState::Disconnected => "disconnected",
            ConnectionState::Connecting => "connecting",
            ConnectionState::Disconnecting => "disconnecting",
        };
        write!(f, "{txt}")
    }
}

impl From<couchbase_core::connection_state::ConnectionState> for ConnectionState {
    fn from(state: couchbase_core::connection_state::ConnectionState) -> Self {
        match state {
            couchbase_core::connection_state::ConnectionState::Connected => {
                ConnectionState::Connected
            }
            couchbase_core::connection_state::ConnectionState::Disconnected => {
                ConnectionState::Disconnected
            }
            couchbase_core::connection_state::ConnectionState::Connecting => {
                ConnectionState::Connecting
            }
            couchbase_core::connection_state::ConnectionState::Disconnecting => {
                ConnectionState::Disconnecting
            }
        }
    }
}