bitcoin-ipc 0.1.16-alpha.0

tools for handling inter-process communication
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

crate::ix!();

use crate::protocol::Protocol;

//-------------------------------------------[.cpp/bitcoin/src/ipc/capnp/protocol.h]
//-------------------------------------------[.cpp/bitcoin/src/ipc/capnp/protocol.cpp]

/**
  | Cap'n Proto context struct. Generally the
  | parent ipc::Context struct should be used
  | instead of this struct to give all IPC
  | protocols access to application state, so
  | there aren't unnecessary differences between
  | IPC protocols. But this specialized struct can
  | be used to pass capnp-specific function and
  | object types to capnp hooks.
  */
pub struct CapnpContext {

}

pub fn capnp_ipc_log_fn(
        raise:   bool,
        message: String)  {
    
    todo!();
        /*
            LogPrint(BCLog::IPC, "%s\n", message);
        if (raise) throw Exception(message);
        */
}

pub type NotLinked                = i32; //TODO
pub type MultiProcessingEventLoop = NotLinked;
pub type TypeIndex                = std::any::TypeId;

pub struct CapnpProtocol {
    context:     CapnpContext,
    loop_thread: Thread,
    loop_:       Option<MultiProcessingEventLoop>,
}

impl Drop for CapnpProtocol {

    fn drop(&mut self) {
        todo!();
        /*
            if (m_loop) {
                std::unique_lock<std::mutex> lock(m_loop->m_mutex);
                m_loop->removeClient(lock);
            }
            if (m_loop_thread.joinable()) m_loop_thread.join();
            assert(!m_loop);
        }{
        */
    }
}

impl Protocol for CapnpProtocol {}

impl Connect for CapnpProtocol {

    fn connect(&mut self, 
        fd:       i32,
        exe_name: *const u8) -> Box<dyn Init> {
        
        todo!();
        /*
            startLoop(exe_name);
            return MultiProcessingConnectStream<messages::Init>(*m_loop, fd);
        */
    }
}

impl Serve for CapnpProtocol {

    fn serve(&mut self, 
        fd:       i32,
        exe_name: *const u8,
        init:     Rc<RefCell<dyn Init>>)  {
        
        todo!();
        /*
            assert(!m_loop);
            mp::g_thread_context.thread_name = MultiProcessingThreadName(exe_name);
            m_loop.emplace(exe_name, &IpcLogFn, &m_context);
            MultiProcessingServeStream<messages::Init>(*m_loop, fd, init);
            m_loop->loop();
            m_loop.reset();
        */
    }
}

impl AddCleanup for CapnpProtocol {

    fn add_cleanup(&mut self, 
        ty:      TypeIndex,
        iface:   *mut c_void,
        cleanup: fn() -> ())  {
        
        todo!();
        /*
            MultiProcessingProxyTypeRegister::types().at(type)(iface).cleanup.emplace_back(std::move(cleanup));
        */
    }
}
    
impl Context for CapnpProtocol {

    fn context(&mut self) -> Rc<RefCell<IpcContext>> {
        
        todo!();
        /*
            return m_context;
        */
    }
}
    
impl CapnpProtocol {
    pub fn start_loop(&mut self, exe_name: *const u8)  {
        
        todo!();
        /*
            if (m_loop) return;
            std::promise<c_void> promise;
            m_loop_thread = std::thread([&] {
                util::ThreadRename("capnp-loop");
                m_loop.emplace(exe_name, &IpcLogFn, &m_context);
                {
                    std::unique_lock<std::mutex> lock(m_loop->m_mutex);
                    m_loop->addClient(lock);
                }
                promise.set_value();
                m_loop->loop();
                m_loop.reset();
            });
            promise.get_future().wait();
        */
    }
}

pub fn make_capnp_protocol() -> Box<dyn Protocol> {
    
    todo!();
        /*
            return std::make_unique<CapnpProtocol>();
        */
}