SYMBOL INDEX (581 symbols across 60 files)

FILE: src/zk/acl.cpp
  type zk (line 8) | namespace zk
    function to_string (line 33) | std::string to_string(const permission& self)
    function hash (line 53) | std::size_t hash(const acl_rule& self)
    function to_string (line 101) | std::string to_string(const acl_rule& self)
    function to_string (line 144) | std::string to_string(const acl& self)
    function acl (line 155) | const acl& acls::creator_all()
    function acl (line 161) | const acl& acls::open_unsafe()
    function acl (line 167) | const acl& acls::read_unsafe()

FILE: src/zk/acl.hpp
  type zk (line 13) | namespace zk
    type permission (line 21) | enum class permission : unsigned int
    function permission (line 34) | inline constexpr permission operator|(permission a, permission b)
    function permission (line 39) | inline constexpr permission& operator|=(permission& self, permission m...
    function permission (line 47) | inline constexpr permission operator&(permission a, permission b)
    function permission (line 52) | inline constexpr permission& operator&=(permission& self, permission m...
    function permission (line 60) | inline constexpr permission operator~(permission a)
    function allows (line 68) | inline constexpr bool allows(permission self, permission perform)
    class acl_rule (line 82) | class acl_rule final
      method acl_rule (line 88) | acl_rule(const acl_rule&)            = default;
      method acl_rule (line 89) | acl_rule& operator=(const acl_rule&) = default;
      method acl_rule (line 91) | acl_rule(acl_rule&&)            = default;
      method acl_rule (line 92) | acl_rule& operator=(acl_rule&&) = default;
      method permission (line 124) | const permission& permissions() const
    class acl (line 159) | class acl final
      method acl (line 168) | acl() = default;
      method acl (line 174) | acl(std::initializer_list<acl_rule> rules) :
      method acl (line 178) | acl(const acl&)            = default;
      method acl (line 179) | acl& operator=(const acl&) = default;
      method acl (line 181) | acl(acl&&)            = default;
      method acl (line 182) | acl& operator=(acl&&) = default;
      method size_type (line 187) | size_type size() const { return _impl.size(); }
      method acl_rule (line 191) | const acl_rule& operator[](size_type idx) const { return _impl[idx]; }
      method acl_rule (line 192) | acl_rule&       operator[](size_type idx)       { return _impl[idx]; }
      method acl_rule (line 199) | const acl_rule& at(size_type idx) const { return _impl.at(idx); }
      method acl_rule (line 200) | acl_rule&       at(size_type idx)       { return _impl.at(idx); }
      method iterator (line 205) | iterator begin()              { return _impl.begin(); }
      method const_iterator (line 206) | const_iterator begin() const  { return _impl.begin(); }
      method const_iterator (line 207) | const_iterator cbegin() const { return _impl.begin(); }
      method iterator (line 212) | iterator end()              { return _impl.end(); }
      method const_iterator (line 213) | const_iterator end() const  { return _impl.end(); }
      method const_iterator (line 214) | const_iterator cend() const { return _impl.end(); }
      method reserve (line 218) | void reserve(size_type capacity) { _impl.reserve(capacity); }
      method emplace_back (line 224) | void emplace_back(TArgs&&... args)
      method push_back (line 231) | void push_back(acl_rule&& x)      { emplace_back(std::move(x)); }
      method push_back (line 232) | void push_back(const acl_rule& x) { emplace_back(x); }
    class acls (line 247) | class acls
  type std (line 265) | namespace std
    class hash<zk::acl_rule> (line 269) | class hash<zk::acl_rule>
      method result_type (line 275) | result_type operator()(const argument_type& x) const

FILE: src/zk/acl_tests.cpp
  type zk (line 5) | namespace zk
    function GTEST_TEST (line 12) | GTEST_TEST(permission_tests, all)
    function GTEST_TEST (line 23) | GTEST_TEST(permission_tests, stringification)
    function GTEST_TEST (line 36) | GTEST_TEST(acl_rule_tests, stringification)
    function GTEST_TEST (line 43) | GTEST_TEST(acl_rule_tests, comparisons)
    function GTEST_TEST (line 56) | GTEST_TEST(acl_rule_tests, hashing)
    function GTEST_TEST (line 68) | GTEST_TEST(acl_tests, stringification)

FILE: src/zk/buffer.hpp
  type zk (line 62) | namespace zk

FILE: src/zk/client.cpp
  type zk (line 10) | namespace zk

FILE: src/zk/client.hpp
  type zk (line 16) | namespace zk
    class client (line 25) | class client final
      method client (line 49) | client(const client&) noexcept = default;
      method client (line 50) | client(client&&) noexcept = default;
      method client (line 52) | client& operator=(const client&) noexcept = default;
      method client (line 53) | client& operator=(client&&) noexcept = default;

FILE: src/zk/client_tests.cpp
  type zk (line 14) | namespace zk
    function buffer (line 17) | static buffer buffer_from(string_view str)
    class client_tests (line 22) | class client_tests :
    function GTEST_TEST_F (line 26) | GTEST_TEST_F(client_tests, get_root)
    function GTEST_TEST_F (line 34) | GTEST_TEST_F(client_tests, exists)
    function GTEST_TEST_F (line 41) | GTEST_TEST_F(client_tests, create)
    function GTEST_TEST_F (line 50) | GTEST_TEST_F(client_tests, create_seq_and_set)
    function GTEST_TEST_F (line 65) | GTEST_TEST_F(client_tests, create_seq_and_erase)
    function GTEST_TEST_F (line 78) | GTEST_TEST_F(client_tests, create_seq_and_get_children)
    function GTEST_TEST_F (line 97) | GTEST_TEST_F(client_tests, acl)
    function GTEST_TEST_F (line 115) | GTEST_TEST_F(client_tests, watch_change)
    function GTEST_TEST_F (line 129) | GTEST_TEST_F(client_tests, watch_children)
    function GTEST_TEST_F (line 158) | GTEST_TEST_F(client_tests, watch_exists)
    function GTEST_TEST_F (line 180) | GTEST_TEST_F(client_tests, load_fence)
    function GTEST_TEST_F (line 187) | GTEST_TEST_F(client_tests, watch_close)
    class stopping_client_tests (line 200) | class stopping_client_tests :
    function GTEST_TEST_F (line 204) | GTEST_TEST_F(stopping_client_tests, watch_server_stop)

FILE: src/zk/config.hpp
  type zk (line 28) | namespace zk

FILE: src/zk/connection.cpp
  type zk (line 16) | namespace zk
    function string_view (line 79) | static string_view sv_from_match(const TMatch& src)
    function split_each_substr (line 85) | void split_each_substr(string_view src, char delim, const FAction& act...
    function extract_host_list (line 98) | static connection_params::host_list extract_host_list(string_view src)
    function extract_bool (line 106) | static bool extract_bool(string_view key, string_view val)
    function extract_millis (line 128) | static std::chrono::milliseconds extract_millis(string_view key, strin...
    function extract_advanced_options (line 144) | static void extract_advanced_options(string_view src, connection_param...
    function connection_params (line 187) | connection_params connection_params::parse(string_view conn_string)
    function to_string (line 269) | std::string to_string(const connection_params& x)

FILE: src/zk/connection.hpp
  type zk (line 17) | namespace zk
    class connection (line 26) | class connection
    class connection_params (line 84) | class connection_params final
      method host_list (line 142) | const host_list& hosts() const { return _hosts; }
      method host_list (line 143) | host_list&       hosts()       { return _hosts; }
      method randomize_hosts (line 158) | bool  randomize_hosts() const { return _randomize_hosts; }
      method read_only (line 164) | bool  read_only() const { return _read_only; }
      method timeout (line 175) | std::chrono::milliseconds  timeout() const { return _timeout; }

FILE: src/zk/connection_tests.cpp
  type zk (line 5) | namespace zk
    function GTEST_TEST (line 9) | GTEST_TEST(connection_params_tests, defaults)
    function GTEST_TEST (line 25) | GTEST_TEST(connection_params_tests, multi_hosts)
    function GTEST_TEST (line 33) | GTEST_TEST(connection_params_tests, chroot)
    function GTEST_TEST (line 42) | GTEST_TEST(connection_params_tests, randomize_hosts)
    function GTEST_TEST (line 51) | GTEST_TEST(connection_params_tests, read_only)
    function GTEST_TEST (line 60) | GTEST_TEST(connection_params_tests, randomize_and_read_only)
    function GTEST_TEST (line 70) | GTEST_TEST(connection_params_tests, timeout)

FILE: src/zk/connection_zk.cpp
  type zk (line 25) | namespace zk
    function with_str (line 33) | auto with_str(string_view src, FAction&& action) noexcept(noexcept(std...
    function ACL (line 42) | static ACL encode_acl_part(const acl_rule& src)
    function with_acl (line 52) | auto with_acl(const acl& rules, FAction&& action) noexcept(noexcept(st...
    function error_code (line 69) | static error_code error_code_from_raw(int raw)
    function event_type (line 89) | static event_type event_from_raw(int raw)
    function state (line 99) | static state state_from_raw(int raw)
    function stat (line 124) | static stat stat_from_raw(const struct Stat& raw)
    function string_vector_from_raw (line 141) | static std::vector<std::string> string_vector_from_raw(const struct St...
    function acl (line 150) | static acl acl_from_raw(const struct ACL_vector& raw)
    class connection_zk::watcher (line 207) | class connection_zk::watcher
      method watcher (line 210) | watcher() :
      method deliver_event (line 216) | virtual void deliver_event(event ev)
      method get_event_future (line 224) | future<event> get_event_future()
    class connection_zk::basic_watcher (line 235) | class connection_zk::basic_watcher :
      method basic_watcher (line 239) | basic_watcher() :
      method get_data_future (line 243) | future<TResult> get_data_future()
      method deliver_event (line 248) | virtual void deliver_event(event ev) override
      method deliver_data (line 258) | void deliver_data(optional<TResult> data, zk::exception_ptr ex_ptr)
    function connection_from_context (line 288) | static ptr<connection_zk> connection_from_context(ptr<zhandle_t> zh)
    type Stat (line 335) | struct Stat
    class connection_zk::data_watcher (line 363) | class connection_zk::data_watcher :
      method deliver_raw (line 367) | static void deliver_raw(int                    rc_in,
    type String_vector (line 419) | struct String_vector
    type Stat (line 420) | struct Stat
    class connection_zk::child_watcher (line 463) | class connection_zk::child_watcher :
      method deliver_raw (line 467) | static void deliver_raw(int                             rc_in,
    type Stat (line 523) | struct Stat
    class connection_zk::exists_watcher (line 553) | class connection_zk::exists_watcher :
      method deliver_raw (line 557) | static void deliver_raw(int rc_in, ptr<const struct Stat> stat_in, p...
    type Stat (line 655) | struct Stat
    type ACL_vector (line 725) | struct ACL_vector
    type Stat (line 725) | struct Stat
    type ACL_vector (line 768) | struct ACL_vector
    type connection_zk_commit_completer (line 794) | struct connection_zk_commit_completer
      method connection_zk_commit_completer (line 802) | explicit connection_zk_commit_completer(multi_op&& src) :
      method raw_stat_at (line 810) | ptr<Stat> raw_stat_at(std::size_t idx)
      method path_buffer_for (line 815) | ptr<std::vector<char>> path_buffer_for(std::size_t idx, const std::s...
      method deliver (line 823) | void deliver(error_code rc)

FILE: src/zk/connection_zk.hpp
  type _zhandle (line 13) | struct _zhandle
  type zk (line 15) | namespace zk
    class connection_zk (line 21) | class connection_zk final :
      class watcher (line 73) | class watcher
      class basic_watcher (line 76) | class basic_watcher
      class data_watcher (line 78) | class data_watcher
      class child_watcher (line 80) | class child_watcher
      class exists_watcher (line 82) | class exists_watcher

FILE: src/zk/error.cpp
  type zk (line 9) | namespace zk
    function to_string (line 25) | std::string to_string(const error_code& code)
    function throw_error (line 32) | void throw_error(error_code code)
    function get_exception_ptr_of (line 59) | zk::exception_ptr get_exception_ptr_of(error_code code)
    class error_category_impl (line 75) | class error_category_impl final : public std::error_category
      method name (line 78) | virtual ptr<const char> name() const noexcept override { return "zoo...
    function format_error (line 98) | static std::string format_error(error_code code, const std::string& de...

FILE: src/zk/error.hpp
  type zk (line 10) | namespace zk
    type error_code (line 19) | enum class error_code : int
    function is_transport_error (line 44) | inline constexpr bool is_transport_error(error_code code)
    function is_invalid_arguments (line 51) | inline constexpr bool is_invalid_arguments(error_code code)
    function is_invalid_ensemble_state (line 58) | inline constexpr bool is_invalid_ensemble_state(error_code code)
    function is_invalid_connection_state (line 66) | inline constexpr bool is_invalid_connection_state(error_code code)
    function is_check_failed (line 76) | inline constexpr bool is_check_failed(error_code code)
    class error (line 108) | class error :
      method error_code (line 117) | error_code code() const { return _code; }
    class transport_error (line 126) | class transport_error :
    class connection_loss (line 142) | class connection_loss:
    class marshalling_error (line 157) | class marshalling_error:
    class not_implemented (line 168) | class not_implemented:
    class invalid_arguments (line 179) | class invalid_arguments :
    class authentication_failed (line 196) | class authentication_failed:
    class invalid_ensemble_state (line 208) | class invalid_ensemble_state :
    class new_configuration_no_quorum (line 220) | class new_configuration_no_quorum:
    class reconfiguration_in_progress (line 231) | class reconfiguration_in_progress:
    class reconfiguration_disabled (line 241) | class reconfiguration_disabled:
    class invalid_connection_state (line 251) | class invalid_connection_state :
    class session_expired (line 271) | class session_expired:
    class not_authorized (line 281) | class not_authorized:
    class closed (line 292) | class closed:
    class ephemeral_on_local_session (line 304) | class ephemeral_on_local_session:
    class read_only_connection (line 316) | class read_only_connection :
    class check_failed (line 327) | class check_failed :
    class no_entry (line 337) | class no_entry :
    class entry_exists (line 347) | class entry_exists :
    class not_empty (line 357) | class not_empty :
    class version_mismatch (line 368) | class version_mismatch :
    class no_children_for_ephemerals (line 378) | class no_children_for_ephemerals :
    class transaction_failed (line 389) | class transaction_failed :
      method error_code (line 399) | error_code underlying_cause() const { return _underlying_cause; }
      method failed_op_index (line 403) | std::size_t failed_op_index() const { return _op_index; }
  type std (line 414) | namespace std
    type is_error_code_enum<zk::error_code> (line 418) | struct is_error_code_enum<zk::error_code> :

FILE: src/zk/error_tests.cpp
  type zk (line 5) | namespace zk
    function GTEST_TEST (line 31) | GTEST_TEST(error_code_tests, throwing)
    function GTEST_TEST (line 91) | GTEST_TEST(error_code_tests, to_string_bogus_code)

FILE: src/zk/exceptions.cpp
  type zk (line 3) | namespace zk
    function exception_ptr (line 6) | exception_ptr current_exception() noexcept

FILE: src/zk/exceptions.hpp
  type zk (line 16) | namespace zk
    function throw_exception (line 29) | [[noreturn]] inline void throw_exception(T const & e)
    function throw_exception (line 41) | [[noreturn]] inline void throw_exception(T const & e)

FILE: src/zk/forwards.hpp
  type zk (line 5) | namespace zk
    class acl (line 8) | class acl
    class acl_rule (line 9) | class acl_rule
    type acl_version (line 10) | struct acl_version
    type child_version (line 11) | struct child_version
    class client (line 12) | class client
    class connection (line 13) | class connection
    class connection_params (line 14) | class connection_params
    type create_mode (line 15) | enum class create_mode : unsigned int
    class create_result (line 16) | class create_result
    class error (line 17) | class error
    class event (line 18) | class event
    class exists_result (line 19) | class exists_result
    type error_code (line 20) | enum class error_code : int
    type event_type (line 21) | enum class event_type : int
    class get_acl_result (line 22) | class get_acl_result
    class get_children_result (line 23) | class get_children_result
    class get_result (line 24) | class get_result
    class multi_result (line 25) | class multi_result
    class multi_op (line 26) | class multi_op
    class op (line 27) | class op
    type op_type (line 28) | enum class op_type : int
    type permission (line 29) | enum class permission : unsigned int
    class set_result (line 30) | class set_result
    type state (line 31) | enum class state : int
    type transaction_id (line 32) | struct transaction_id
    type version (line 33) | struct version
    class watch_children_result (line 34) | class watch_children_result
    class watch_exists_result (line 35) | class watch_exists_result
    class watch_result (line 36) | class watch_result

FILE: src/zk/future.hpp
  type zk (line 101) | namespace zk

FILE: src/zk/multi.cpp
  type zk (line 9) | namespace zk
    function to_string_generic (line 13) | static std::string to_string_generic(const T& self)
    function to_string (line 36) | std::string to_string(const op_type& self)
    function op_type (line 57) | op_type op::type() const
    function T (line 63) | const T& op::as(ptr<const char> operation) const
    function op (line 93) | op op::check(std::string path, version check_)
    function op (line 120) | op op::create(std::string path, buffer data, acl rules, create_mode mode)
    function op (line 125) | op op::create(std::string path, buffer data, create_mode mode)
    function op (line 149) | op op::erase(std::string path, version check)
    function op (line 174) | op op::set(std::string path, buffer data, version check)
    function to_string (line 193) | std::string to_string(const op& self)
    function T (line 255) | const T& multi_result::part::as(ptr<const char> operation) const
    function create_result (line 271) | const create_result& multi_result::part::as_create() const
    function set_result (line 276) | const set_result& multi_result::part::as_set() const
    function to_string (line 313) | std::string to_string(const multi_result::part& self)
    function to_string (line 318) | std::string to_string(const multi_result& self)

FILE: src/zk/multi.hpp
  type zk (line 17) | namespace zk
    type op_type (line 24) | enum class op_type : int
    class op (line 37) | class op final
      type check_data (line 41) | struct check_data
        method op_type (line 48) | op_type type() const { return op_type::check; }
      type create_data (line 55) | struct create_data
        method op_type (line 64) | op_type type() const { return op_type::create; }
      type erase_data (line 76) | struct erase_data
        method op_type (line 83) | op_type type() const { return op_type::erase; }
      type set_data (line 92) | struct set_data
        method op_type (line 100) | op_type type() const { return op_type::set; }
      method op (line 112) | op& operator=(const op&) = delete;
      method op (line 113) | op& operator=(op&&) = delete;
    class multi_op (line 162) | class multi_op final
      method multi_op (line 171) | multi_op() noexcept
      method multi_op (line 178) | multi_op(std::initializer_list<op> ops) :
      method size_type (line 185) | size_type size() const { return _ops.size(); }
      method op (line 189) | const op& operator[](size_type idx) const { return _ops[idx]; }
      method op (line 190) | op&       operator[](size_type idx)       { return _ops[idx]; }
      method op (line 197) | const op& at(size_type idx) const { return _ops.at(idx); }
      method op (line 198) | op&       at(size_type idx)       { return _ops.at(idx); }
      method iterator (line 203) | iterator begin()              { return _ops.begin(); }
      method const_iterator (line 204) | const_iterator begin() const  { return _ops.begin(); }
      method const_iterator (line 205) | const_iterator cbegin() const { return _ops.begin(); }
      method iterator (line 210) | iterator end()              { return _ops.end(); }
      method const_iterator (line 211) | const_iterator end() const  { return _ops.end(); }
      method const_iterator (line 212) | const_iterator cend() const { return _ops.end(); }
      method reserve (line 216) | void reserve(size_type capacity) { _ops.reserve(capacity); }
      method emplace_back (line 222) | void emplace_back(TArgs&&... args)
      method push_back (line 229) | void push_back(op&&      x) { emplace_back(std::move(x)); }
      method push_back (line 230) | void push_back(const op& x) { emplace_back(x); }
    class multi_result (line 242) | class multi_result final
      class part (line 246) | class part final
        method part (line 256) | part& operator=(const part&) = delete;
        method part (line 257) | part& operator=(part&&) = delete;
        method op_type (line 262) | op_type type() const { return _type; }
      method multi_result (line 290) | multi_result() noexcept
      method multi_result (line 295) | multi_result(multi_result&&) = default;
      method multi_result (line 296) | multi_result & operator=(multi_result&&) = default;
      method size_type (line 301) | size_type size() const { return _parts.size(); }
      method part (line 307) | part&       operator[](size_type idx)       { return _parts[idx]; }
        method part (line 256) | part& operator=(const part&) = delete;
        method part (line 257) | part& operator=(part&&) = delete;
        method op_type (line 262) | op_type type() const { return _type; }
      method part (line 308) | const part& operator[](size_type idx) const { return _parts[idx]; }
        method part (line 256) | part& operator=(const part&) = delete;
        method part (line 257) | part& operator=(part&&) = delete;
        method op_type (line 262) | op_type type() const { return _type; }
      method part (line 315) | const part& at(size_type idx) const { return _parts.at(idx); }
        method part (line 256) | part& operator=(const part&) = delete;
        method part (line 257) | part& operator=(part&&) = delete;
        method op_type (line 262) | op_type type() const { return _type; }
      method part (line 316) | part&       at(size_type idx)       { return _parts.at(idx); }
        method part (line 256) | part& operator=(const part&) = delete;
        method part (line 257) | part& operator=(part&&) = delete;
        method op_type (line 262) | op_type type() const { return _type; }
      method iterator (line 321) | iterator begin()              { return _parts.begin(); }
      method const_iterator (line 322) | const_iterator begin() const  { return _parts.begin(); }
      method const_iterator (line 323) | const_iterator cbegin() const { return _parts.begin(); }
      method iterator (line 328) | iterator end()              { return _parts.end(); }
      method const_iterator (line 329) | const_iterator end() const  { return _parts.end(); }
      method const_iterator (line 330) | const_iterator cend() const { return _parts.end(); }
      method reserve (line 334) | void reserve(size_type capacity) { _parts.reserve(capacity); }
      method emplace_back (line 340) | void emplace_back(TArgs&&... args)
      method push_back (line 347) | void push_back(part&& x)      { emplace_back(std::move(x)); }
      method push_back (line 348) | void push_back(const part& x) { emplace_back(x); }

FILE: src/zk/multi_tests.cpp
  type zk (line 13) | namespace zk
    class multi_tests (line 16) | class multi_tests :
    function buffer (line 20) | static buffer buffer_from(string_view str)
    function GTEST_TEST_F (line 25) | GTEST_TEST_F(multi_tests, commit_no_fail)
    function GTEST_TEST_F (line 53) | GTEST_TEST_F(multi_tests, commit_fail_check)

FILE: src/zk/optional.hpp
  type zk (line 10) | namespace zk
    function map (line 25) | auto map(FUnary&& transform, const optional<T>&... x) -> optional<decl...
    function some (line 34) | optional<T> some(T x)

FILE: src/zk/optional_tests.cpp
  type zk (line 5) | namespace zk
    function GTEST_TEST (line 8) | GTEST_TEST(optional_test, integer)

FILE: src/zk/results.cpp
  type zk (line 7) | namespace zk
    type print_buffer_length_tag (line 19) | struct print_buffer_length_tag {}
    type print_buffer_content_tag (line 20) | struct print_buffer_content_tag  : public print_buffer_length_tag {}
    function print_buffer (line 23) | auto print_buffer(std::ostream& os, const TBuffer& buf, struct print_b...
    function print_buffer (line 30) | void print_buffer(std::ostream& os, const TBuffer& buf, struct print_b...
    function print_range (line 36) | void print_range(std::ostream& os, const TRange& range)
    function to_string_generic (line 52) | std::string to_string_generic(const T& x)
    function to_string (line 79) | std::string to_string(const get_result& self)
    function to_string (line 109) | std::string to_string(const get_children_result& self)
    function to_string (line 140) | std::string to_string(const exists_result& self)
    function to_string (line 166) | std::string to_string(const create_result& self)
    function to_string (line 192) | std::string to_string(const set_result& self)
    function to_string (line 219) | std::string to_string(const get_acl_result& self)
    function to_string (line 243) | std::string to_string(const event& self)
    function to_string (line 270) | std::string to_string(const watch_result& self)
    function to_string (line 295) | std::string to_string(const watch_children_result& self)
    function to_string (line 320) | std::string to_string(const watch_exists_result& self)

FILE: src/zk/results.hpp
  type zk (line 17) | namespace zk
    class get_result (line 24) | class get_result final
      method get_result (line 29) | get_result(const get_result&)            = default;
      method get_result (line 30) | get_result& operator=(const get_result&) = default;
      method get_result (line 32) | get_result(get_result&&)            = default;
      method get_result (line 33) | get_result& operator=(get_result&&) = default;
      method buffer (line 39) | const buffer& data() const & { return _data; }
      method buffer (line 40) | buffer&       data() &       { return _data; }
      method buffer (line 41) | buffer        data() &&      { return std::move(_data); }
    class get_children_result (line 61) | class get_children_result final
      method get_children_result (line 69) | get_children_result(const get_children_result&)            = default;
      method get_children_result (line 70) | get_children_result& operator=(const get_children_result&) = default;
      method get_children_result (line 72) | get_children_result(get_children_result&&)            = default;
      method get_children_result (line 73) | get_children_result& operator=(get_children_result&&) = default;
      method children_list_type (line 79) | const children_list_type& children() const & { return _children; }
      method children_list_type (line 80) | children_list_type&       children() &       { return _children; }
      method children_list_type (line 81) | children_list_type        children() &&      { return std::move(_chi...
      method stat (line 86) | const stat& parent_stat() const { return _parent_stat; }
      method stat (line 87) | stat&       parent_stat()       { return _parent_stat; }
    class exists_result (line 100) | class exists_result final
      method exists_result (line 105) | exists_result(const exists_result&)            = default;
      method exists_result (line 106) | exists_result& operator=(const exists_result&) = default;
      method exists_result (line 108) | exists_result(exists_result&&)            = default;
      method exists_result (line 109) | exists_result& operator=(exists_result&&) = default;
    class create_result (line 134) | class create_result final
      method create_result (line 139) | create_result(const create_result&)            = default;
      method create_result (line 140) | create_result& operator=(const create_result&) = default;
      method create_result (line 142) | create_result(create_result&&)            = default;
      method create_result (line 143) | create_result& operator=(create_result&&) = default;
      method name (line 153) | std::string        name() &&      { return std::move(_name); }
    class set_result (line 165) | class set_result final
      method set_result (line 170) | set_result(const set_result&)            = default;
      method set_result (line 171) | set_result& operator=(const set_result&) = default;
      method set_result (line 173) | set_result(set_result&&)            = default;
      method set_result (line 174) | set_result& operator=(set_result&&) = default;
    class get_acl_result (line 193) | class get_acl_result final
      method get_acl_result (line 198) | get_acl_result(const get_acl_result&)            = default;
      method get_acl_result (line 199) | get_acl_result& operator=(const get_acl_result&) = default;
      method get_acl_result (line 201) | get_acl_result(get_acl_result&&)            = default;
      method get_acl_result (line 202) | get_acl_result& operator=(get_acl_result&&) = default;
      method acl (line 210) | zk::acl        acl() &&      { return std::move(_acl); }
    class event (line 238) | class event final
      method event (line 243) | event(const event&)            = default;
      method event (line 244) | event& operator=(const event&) = default;
      method event (line 246) | event(event&&)            = default;
      method event (line 247) | event& operator=(event&&) = default;
      method event_type (line 250) | const event_type& type() const { return _type; }
    class watch_result (line 266) | class watch_result final
      method watch_result (line 271) | watch_result(const watch_result&)            = delete;
      method watch_result (line 272) | watch_result& operator=(const watch_result&) = delete;
      method watch_result (line 274) | watch_result(watch_result&&)            = default;
      method watch_result (line 275) | watch_result& operator=(watch_result&&) = default;
      method get_result (line 281) | const get_result& initial() const & { return _initial; }
      method get_result (line 282) | get_result&       initial() &       { return _initial; }
      method get_result (line 283) | get_result        initial() &&      { return std::move(_initial); }
      method next (line 290) | future<event>        next() &&      { return std::move(_next); }
    class watch_children_result (line 303) | class watch_children_result final
      method watch_children_result (line 308) | watch_children_result(const watch_children_result&)            = del...
      method watch_children_result (line 309) | watch_children_result& operator=(const watch_children_result&) = del...
      method watch_children_result (line 311) | watch_children_result(watch_children_result&&)            = default;
      method watch_children_result (line 312) | watch_children_result& operator=(watch_children_result&&) = default;
      method get_children_result (line 318) | const get_children_result& initial() const & { return _initial; }
      method get_children_result (line 319) | get_children_result&       initial() &       { return _initial; }
      method get_children_result (line 320) | get_children_result        initial() &&      { return std::move(_ini...
      method next (line 327) | future<event>        next() &&      { return std::move(_next); }
    class watch_exists_result (line 340) | class watch_exists_result final
      method watch_exists_result (line 345) | watch_exists_result(const watch_exists_result&)            = delete;
      method watch_exists_result (line 346) | watch_exists_result& operator=(const watch_exists_result&) = delete;
      method watch_exists_result (line 348) | watch_exists_result(watch_exists_result&&)            = default;
      method watch_exists_result (line 349) | watch_exists_result& operator=(watch_exists_result&&) = default;
      method exists_result (line 355) | const exists_result& initial() const & { return _initial; }
      method exists_result (line 356) | exists_result&       initial() &       { return _initial; }
      method exists_result (line 357) | exists_result        initial() &&      { return std::move(_initial); }
      method next (line 364) | future<event>        next() &&      { return std::move(_next); }

FILE: src/zk/server/classpath.cpp
  type zk::server (line 17) | namespace zk::server
    function join (line 21) | void join(std::ostream& os, const TContainer& src, TSep sep)
    function file_exists (line 32) | static bool file_exists(ptr<const char> path)
    function classpath (line 48) | static classpath find_system_default()
    function classpath (line 101) | classpath classpath::system_default()

FILE: src/zk/server/classpath.hpp
  type zk::server (line 9) | namespace zk::server
    class classpath (line 18) | class classpath final

FILE: src/zk/server/classpath_tests.cpp
  type zk::server (line 8) | namespace zk::server
    function GTEST_TEST (line 11) | GTEST_TEST(classpath_tests, system_default)

FILE: src/zk/server/configuration.cpp
  type zk::server (line 12) | namespace zk::server
    class zero_copy_streambuf (line 35) | class zero_copy_streambuf final :
      method zero_copy_streambuf (line 39) | zero_copy_streambuf(string_view input)
    function configuration (line 77) | configuration configuration::make_minimal(std::string data_directory, ...
    function parse_whitelist (line 88) | static std::set<std::string> parse_whitelist(string_view source)
    function configuration (line 118) | configuration configuration::from_lines(std::vector<std::string> lines)
    function configuration (line 185) | configuration configuration::from_stream(std::istream& stream)
    function configuration (line 201) | configuration configuration::from_file(std::string filename)
    function configuration (line 209) | configuration configuration::from_string(string_view value)
    function configuration (line 264) | configuration& configuration::client_port(optional<std::uint16_t> port)
    function configuration (line 275) | configuration& configuration::data_directory(optional<std::string> path)
    function configuration (line 286) | configuration& configuration::tick_time(optional<duration_type> tick_t...
    function configuration (line 297) | configuration& configuration::init_limit(optional<std::size_t> limit)
    function configuration (line 308) | configuration& configuration::sync_limit(optional<std::size_t> limit)
    function configuration (line 319) | configuration& configuration::leader_serves(optional<bool> serve)
    function configuration (line 333) | configuration& configuration::four_letter_word_whitelist(optional<std:...
    function configuration (line 368) | configuration& configuration::add_server(server_id     id,
    function configuration (line 398) | configuration& configuration::add_setting(std::string key, std::string...

FILE: src/zk/server/configuration.hpp
  type zk::server (line 16) | namespace zk::server
    type server_id (line 29) | struct server_id :
      method server_id (line 35) | server_id(std::size_t value) :
    class configuration (line 71) | class configuration final
      type setting (line 243) | struct setting
  type std (line 279) | namespace std
    type hash<zk::server::server_id> (line 283) | struct hash<zk::server::server_id>
      method result_type (line 288) | result_type operator()(const argument_type& x) const

FILE: src/zk/server/configuration_tests.cpp
  type zk::server (line 9) | namespace zk::server
    function GTEST_TEST (line 37) | GTEST_TEST(configuration_tests, from_example)
    function GTEST_TEST (line 75) | GTEST_TEST(configuration_tests, minimal)
    function GTEST_TEST (line 93) | GTEST_TEST(configuration_tests, four_letter_words)

FILE: src/zk/server/detail/close.cpp
  type zk::server::detail (line 9) | namespace zk::server::detail
    function close (line 12) | void close(int fd)

FILE: src/zk/server/detail/close.hpp
  type zk::server::detail (line 5) | namespace zk::server::detail

FILE: src/zk/server/detail/event_handle.cpp
  type zk::server::detail (line 11) | namespace zk::server::detail

FILE: src/zk/server/detail/event_handle.hpp
  type zk::server::detail (line 5) | namespace zk::server::detail
    class event_handle (line 8) | class event_handle final
      method event_handle (line 16) | event_handle(const event_handle&) = delete;
      method event_handle (line 18) | event_handle& operator=(const event_handle&) = delete;
      method native_handle_type (line 36) | native_handle_type native_handle() { return _fd; }

FILE: src/zk/server/detail/pipe.cpp
  type zk::server::detail (line 10) | namespace zk::server::detail
    function on_exec_flags (line 28) | static int on_exec_flags(on_exec exec)
    function close_if_open (line 57) | static void close_if_open(int& fd)
    function dup3 (line 153) | static int dup3(int src_fd, int redir_fd, on_exec exec)

FILE: src/zk/server/detail/pipe.hpp
  type zk::server::detail (line 9) | namespace zk::server::detail
    type on_exec (line 13) | enum class on_exec
    class pipe_closed (line 27) | class pipe_closed :
    class pipe (line 39) | class pipe final
      method pipe (line 52) | pipe(const pipe&) = delete;
      method pipe (line 53) | pipe& operator=(const pipe&) = delete;

FILE: src/zk/server/detail/pipe_tests.cpp
  type zk::server::detail (line 7) | namespace zk::server::detail
    function GTEST_TEST (line 10) | GTEST_TEST(pipe_tests, read_write)

FILE: src/zk/server/detail/subprocess.cpp
  type zk::server::detail (line 15) | namespace zk::server::detail
    function pid_t (line 18) | static pid_t create_subproc(pipe&                     stdin_pipe,
    function dont_leak (line 62) | static void dont_leak(pipe& p) noexcept

FILE: src/zk/server/detail/subprocess.hpp
  type zk::server::detail (line 13) | namespace zk::server::detail
    class subprocess (line 17) | class subprocess
      method subprocess (line 27) | subprocess(const subprocess&) = delete;
      method subprocess (line 28) | subprocess& operator=(const subprocess&) = delete;
      method pipe (line 38) | pipe& stdin()  noexcept { return _stdin; }
      method pipe (line 39) | pipe& stdout() noexcept { return _stdout; }
      method pipe (line 40) | pipe& stderr() noexcept { return _stderr; }

FILE: src/zk/server/detail/subprocess_tests.cpp
  type zk::server::detail (line 8) | namespace zk::server::detail
    function GTEST_TEST (line 11) | GTEST_TEST(subprocess_tests, echo)
    function GTEST_TEST (line 23) | GTEST_TEST(subprocess_tests, cat_kill)

FILE: src/zk/server/package_registry.cpp
  type zk::server (line 5) | namespace zk::server
    type package_registry::registration_info (line 8) | struct package_registry::registration_info final
      method registration_info (line 13) | registration_info(std::shared_ptr<package_registry> owner, std::stri...

FILE: src/zk/server/package_registry.hpp
  type zk::server (line 14) | namespace zk::server
    class package_registry (line 25) | class package_registry final
      type registration_info (line 30) | struct registration_info
      method empty (line 62) | bool empty() const

FILE: src/zk/server/package_registry_tests.cpp
  type zk::server (line 10) | namespace zk::server
    function package_registry (line 17) | package_registry& test_package_registry::instance()
    function GTEST_TEST (line 27) | GTEST_TEST(package_registry_tests, test_package_registry_global_instance)
    function GTEST_TEST (line 32) | GTEST_TEST(package_registry_tests, registration)

FILE: src/zk/server/package_registry_tests.hpp
  type zk::server (line 5) | namespace zk::server
    class package_registry (line 8) | class package_registry
    class test_package_registry (line 11) | class test_package_registry final

FILE: src/zk/server/server.cpp
  type zk::server (line 18) | namespace zk::server
    function validate_settings (line 21) | static void validate_settings(const configuration& settings)
    function wait_for_event (line 63) | static void wait_for_event(int fd1, int fd2, int fd3)

FILE: src/zk/server/server.hpp
  type zk::server (line 11) | namespace zk::server
    type detail (line 14) | namespace detail
      class event_handle (line 17) | class event_handle
    class classpath (line 25) | class classpath
    class configuration (line 26) | class configuration
    class server (line 29) | class server final
      method server (line 48) | server(const server&) = delete;

FILE: src/zk/server/server_group.cpp
  type zk::server (line 17) | namespace zk::server
    type server_group::info (line 20) | struct server_group::info
      method info (line 29) | info(const configuration& base) :
    function server_group (line 39) | server_group& server_group::operator=(server_group&& src) noexcept
    function create_directory (line 46) | static void create_directory(const std::string& path)
    function save_id_file (line 54) | static void save_id_file(const std::string& path, const server_id& id)
    function server_group (line 63) | server_group server_group::make_ensemble(std::size_t size, const confi...

FILE: src/zk/server/server_group.hpp
  type zk::server (line 13) | namespace zk::server
    class classpath (line 20) | class classpath
    class server (line 21) | class server
    class server_group (line 34) | class server_group final
      method size (line 60) | std::size_t size() const { return _servers.size(); }
      type info (line 63) | struct info

FILE: src/zk/server/server_group_tests.cpp
  type zk::server (line 12) | namespace zk::server
    function GTEST_TEST (line 17) | GTEST_TEST(server_group_tests, ensemble)

FILE: src/zk/server/server_tests.cpp
  type zk::server (line 20) | namespace zk::server
    function delete_directory (line 23) | void delete_directory(std::string path)
    function client (line 64) | client server_fixture::get_connected_client() const
    function client (line 102) | client single_server_fixture::get_connected_client()
    function GTEST_TEST (line 111) | GTEST_TEST(server_tests, start_stop)
    function GTEST_TEST (line 120) | GTEST_TEST(server_tests, shutdown_and_wait)

FILE: src/zk/server/server_tests.hpp
  type zk::server (line 9) | namespace zk::server
    class server (line 12) | class server
    class server_fixture (line 14) | class server_fixture :
    class single_server_fixture (line 36) | class single_server_fixture :

FILE: src/zk/string_view.hpp
  type zk (line 9) | namespace zk

FILE: src/zk/tests/main.cpp
  function main (line 3) | int main(int argc, char** argv)

FILE: src/zk/tests/test.hpp
  type zk::test (line 28) | namespace zk::test
    type detail (line 55) | namespace detail
      type check_throws_info (line 59) | struct check_throws_info
        method check_throws_info (line 64) | explicit check_throws_info(ptr<const char> filename, std::size_t l...

FILE: src/zk/types.cpp
  type zk (line 7) | namespace zk
    function to_string (line 29) | std::string to_string(const event_type& self)
    function to_string (line 52) | std::string to_string(const version& self)
    function to_string (line 75) | std::string to_string(const acl_version& self)
    function to_string (line 98) | std::string to_string(const child_version& self)
    function to_string (line 114) | std::string to_string(const transaction_id& self)
    function to_string (line 136) | std::string to_string(const stat& self)
    function to_string (line 161) | std::string to_string(const state& self)
    function to_string (line 186) | std::string to_string(const create_mode& self)

FILE: src/zk/types.hpp
  type zk (line 9) | namespace zk
    type strong_id (line 28) | struct strong_id
      method strong_id (line 38) | strong_id() noexcept = default;
      method strong_id (line 41) | constexpr explicit strong_id(value_type value) noexcept :
      method value_type (line 46) | constexpr value_type get() const noexcept { return value; }
      method TReal (line 57) | TReal& operator++()
      method TReal (line 63) | TReal operator++(int)
      method TReal (line 74) | TReal& operator--()
      method TReal (line 80) | TReal operator--(int)
    function hash (line 127) | inline std::size_t hash(const strong_id<TReal, TId>& x)
    type basic_version (line 140) | struct basic_version :
      method TReal (line 145) | static constexpr TReal invalid() { return TReal(-42); }
      method TReal (line 150) | static constexpr TReal any() { return TReal(-1); }
    type version (line 158) | struct version final :
    type acl_version (line 171) | struct acl_version final :
    type child_version (line 184) | struct child_version final :
    type transaction_id (line 199) | struct transaction_id final :
    type stat (line 220) | struct stat final
      method is_ephemeral (line 271) | bool is_ephemeral() const
    type create_mode (line 283) | enum class create_mode : unsigned int
    function create_mode (line 302) | constexpr create_mode operator|(create_mode a, create_mode b)
    function create_mode (line 308) | constexpr create_mode operator&(create_mode a, create_mode b)
    function create_mode (line 315) | constexpr create_mode operator~(create_mode a)
    function is_set (line 321) | constexpr bool is_set(create_mode self, create_mode flags)
    type event_type (line 331) | enum class event_type : int
    type state (line 385) | enum class state : int
  type std (line 412) | namespace std
    type hash<zk::version> (line 416) | struct hash<zk::version>
      method result_type (line 421) | result_type operator()(const argument_type& x) const
    type hash<zk::acl_version> (line 428) | struct hash<zk::acl_version>
      method result_type (line 433) | result_type operator()(const argument_type& x) const
    type hash<zk::child_version> (line 440) | struct hash<zk::child_version>
      method result_type (line 445) | result_type operator()(const argument_type& x) const
    type hash<zk::transaction_id> (line 452) | struct hash<zk::transaction_id>
      method result_type (line 457) | result_type operator()(const argument_type& x) const

FILE: src/zk/types_tests.cpp
  type zk (line 5) | namespace zk
    function GTEST_TEST (line 12) | GTEST_TEST(event_type_tests, stringification)
    function GTEST_TEST (line 28) | GTEST_TEST(state_tests, stringification)