SYMBOL INDEX (6408 symbols across 714 files)

FILE: contrib/devtools/check-doc.py
  function main (line 27) | def main():

FILE: contrib/devtools/check-rpc-mappings.py
  class RPCCommand (line 27) | class RPCCommand:
    method __init__ (line 28) | def __init__(self, name, args):
  class RPCArgument (line 32) | class RPCArgument:
    method __init__ (line 33) | def __init__(self, names, idx):
  function parse_string (line 38) | def parse_string(s):
  function process_commands (line 43) | def process_commands(fname):
  function process_mapping (line 69) | def process_mapping(fname):
  function main (line 92) | def main():

FILE: contrib/devtools/clang-format-diff.py
  function main (line 83) | def main():

FILE: contrib/devtools/copyright_header.py
  function applies_to_file (line 46) | def applies_to_file(filename):
  function call_git_ls (line 56) | def call_git_ls():
  function get_filenames_to_examine (line 60) | def get_filenames_to_examine():
  function compile_copyright_regex (line 83) | def compile_copyright_regex(copyright_style, year_style, name):
  function get_count_of_copyrights_of_any_style_any_holder (line 129) | def get_count_of_copyrights_of_any_style_any_holder(contents):
  function file_has_dominant_style_copyright_for_holder (line 132) | def file_has_dominant_style_copyright_for_holder(contents, holder_name):
  function file_has_year_list_style_copyright_for_holder (line 136) | def file_has_year_list_style_copyright_for_holder(contents, holder_name):
  function file_has_without_c_style_copyright_for_holder (line 140) | def file_has_without_c_style_copyright_for_holder(contents, holder_name):
  function read_file (line 148) | def read_file(filename):
  function gather_file_info (line 151) | def gather_file_info(filename):
  function print_filenames (line 183) | def print_filenames(filenames, verbose):
  function print_report (line 189) | def print_report(file_infos, verbose):
  function exec_report (line 262) | def exec_report(base_directory, verbose):
  function report_cmd (line 286) | def report_cmd(argv):
  function call_git_log (line 309) | def call_git_log(filename):
  function get_git_change_years (line 313) | def get_git_change_years(filename):
  function get_most_recent_git_change_year (line 320) | def get_most_recent_git_change_year(filename):
  function read_file_lines (line 327) | def read_file_lines(filename):
  function write_file_lines (line 333) | def write_file_lines(filename, file_lines):
  function get_updatable_copyright_line (line 348) | def get_updatable_copyright_line(file_lines):
  function parse_year_range (line 356) | def parse_year_range(year_range):
  function year_range_to_str (line 363) | def year_range_to_str(start_year, end_year):
  function create_updated_copyright_line (line 368) | def create_updated_copyright_line(line, last_git_change_year):
  function update_updatable_copyright (line 385) | def update_updatable_copyright(filename):
  function exec_update_header_year (line 401) | def exec_update_header_year(base_directory):
  function print_file_action_message (line 441) | def print_file_action_message(filename, action):
  function update_cmd (line 444) | def update_cmd(argv):
  function get_header_lines (line 457) | def get_header_lines(header, start_year, end_year):
  function get_cpp_header_lines_to_insert (line 468) | def get_cpp_header_lines_to_insert(start_year, end_year):
  function get_python_header_lines_to_insert (line 477) | def get_python_header_lines_to_insert(start_year, end_year):
  function get_git_change_year_range (line 484) | def get_git_change_year_range(filename):
  function file_already_has_core_copyright (line 492) | def file_already_has_core_copyright(file_lines):
  function file_has_hashbang (line 500) | def file_has_hashbang(file_lines):
  function insert_python_header (line 507) | def insert_python_header(filename, file_lines, start_year, end_year):
  function insert_cpp_header (line 517) | def insert_cpp_header(filename, file_lines, start_year, end_year):
  function exec_insert_header (line 523) | def exec_insert_header(filename, style):
  function insert_cmd (line 563) | def insert_cmd(argv):

FILE: contrib/devtools/github-merge.py
  function git_config_get (line 43) | def git_config_get(option, default=None):
  function retrieve_pr_info (line 52) | def retrieve_pr_info(repo,pull):
  function ask_prompt (line 67) | def ask_prompt(text):
  function get_symlink_files (line 74) | def get_symlink_files():
  function tree_sha512sum (line 82) | def tree_sha512sum(commit='HEAD'):
  function print_merge_details (line 131) | def print_merge_details(pull, title, branch, base_branch, head_branch):
  function parse_arguments (line 135) | def parse_arguments():
  function main (line 152) | def main():

FILE: contrib/devtools/optimize-pngs.py
  function file_hash (line 15) | def file_hash(filename):
  function content_hash (line 20) | def content_hash(filename):

FILE: contrib/devtools/security-check.py
  function check_ELF_PIE (line 20) | def check_ELF_PIE(executable):
  function get_ELF_program_headers (line 36) | def get_ELF_program_headers(executable):
  function check_ELF_NX (line 65) | def check_ELF_NX(executable):
  function check_ELF_RELRO (line 78) | def check_ELF_RELRO(executable):
  function check_ELF_Canary (line 105) | def check_ELF_Canary(executable):
  function get_PE_dll_characteristics (line 119) | def get_PE_dll_characteristics(executable):
  function check_PE_DYNAMIC_BASE (line 143) | def check_PE_DYNAMIC_BASE(executable):
  function check_PE_HIGH_ENTROPY_VA (line 151) | def check_PE_HIGH_ENTROPY_VA(executable):
  function check_PE_NX (line 161) | def check_PE_NX(executable):
  function identify_executable (line 180) | def identify_executable(executable):

FILE: contrib/devtools/symbol-check.py
  class CPPFilt (line 74) | class CPPFilt(object):
    method __init__ (line 80) | def __init__(self):
    method __call__ (line 83) | def __call__(self, mangled):
    method close (line 88) | def close(self):
  function read_symbols (line 93) | def read_symbols(executable, imports=True):
  function check_version (line 114) | def check_version(max_versions, version):
  function read_libraries (line 125) | def read_libraries(filename):

FILE: contrib/devtools/test-security-check.py
  function write_testcode (line 12) | def write_testcode(filename):
  function call_security_check (line 23) | def call_security_check(cc, source, executable, options):
  class TestSecurityChecks (line 29) | class TestSecurityChecks(unittest.TestCase):
    method test_ELF (line 30) | def test_ELF(self):
    method test_PE (line 47) | def test_PE(self):

FILE: contrib/devtools/update-translations.py
  function check_at_repository_root (line 35) | def check_at_repository_root():
  function fetch_all_translations (line 41) | def fetch_all_translations():
  function find_format_specifiers (line 46) | def find_format_specifiers(s):
  function split_format_specifiers (line 58) | def split_format_specifiers(specifiers):
  function sanitize_string (line 79) | def sanitize_string(s):
  function check_format_specifiers (line 83) | def check_format_specifiers(source, translation, errors, numerus):
  function all_ts_files (line 102) | def all_ts_files(suffix=''):
  function remove_invalid_characters (line 113) | def remove_invalid_characters(s):
  function escape_cdata (line 120) | def escape_cdata(text):
  function postprocess_translations (line 126) | def postprocess_translations(reduce_diff_hacks=False):

FILE: contrib/linearize/linearize-data.py
  function hex_switchEndian (line 25) | def hex_switchEndian(s):
  function uint32 (line 30) | def uint32(x):
  function bytereverse (line 33) | def bytereverse(x):
  function bufreverse (line 37) | def bufreverse(in_buf):
  function wordreverse (line 44) | def wordreverse(in_buf):
  function calc_hdr_hash (line 51) | def calc_hdr_hash(blk_hdr):
  function calc_hash_str (line 62) | def calc_hash_str(blk_hdr):
  function get_blk_dt (line 69) | def get_blk_dt(blk_hdr):
  function get_block_hashes (line 77) | def get_block_hashes(settings):
  function mkblockmap (line 91) | def mkblockmap(blkindex):
  class BlockDataCopier (line 100) | class BlockDataCopier:
    method __init__ (line 101) | def __init__(self, settings, blkindex, blkmap):
    method writeBlock (line 132) | def writeBlock(self, inhdr, blk_hdr, rawblock):
    method inFileName (line 177) | def inFileName(self, fn):
    method fetchBlock (line 180) | def fetchBlock(self, extent):
    method copyOneBlock (line 186) | def copyOneBlock(self):
    method run (line 198) | def run(self):

FILE: contrib/linearize/linearize-hashes.py
  function hex_switchEndian (line 25) | def hex_switchEndian(s):
  class BitcoinRPC (line 30) | class BitcoinRPC:
    method __init__ (line 31) | def __init__(self, host, port, username, password):
    method execute (line 37) | def execute(self, obj):
    method build_request (line 57) | def build_request(idx, method, params):
    method response_is_error (line 68) | def response_is_error(resp_obj):
  function get_block_hashes (line 71) | def get_block_hashes(settings, max_blocks_per_call=10000):
  function get_rpc_cookie (line 98) | def get_rpc_cookie():

FILE: contrib/seeds/generate-seeds.py
  function name_to_ipv6 (line 45) | def name_to_ipv6(addr):
  function parse_spec (line 75) | def parse_spec(s, defaultport):
  function process_nodes (line 95) | def process_nodes(g, f, structname, defaultport):
  function main (line 114) | def main():

FILE: contrib/seeds/makeseeds.py
  function parseline (line 34) | def parseline(line):
  function filtermultiport (line 101) | def filtermultiport(ips):
  function filterbyasn (line 109) | def filterbyasn(ips, max_per_asn, max_total):
  function main (line 139) | def main():

FILE: contrib/testgen/base58.py
  class SHA256 (line 12) | class SHA256:
  function ord (line 17) | def ord(c):
  function chr (line 19) | def chr(n):
  function b58encode (line 26) | def b58encode(v):
  function b58decode (line 49) | def b58decode(v, length = None):
  function checksum (line 74) | def checksum(v):
  function b58encode_chk (line 78) | def b58encode_chk(v):
  function b58decode_chk (line 82) | def b58decode_chk(v):
  function get_bcaddress_version (line 92) | def get_bcaddress_version(strAddress):

FILE: contrib/testgen/gen_base58_test_vectors.py
  function is_valid (line 43) | def is_valid(v):
  function gen_valid_vectors (line 56) | def gen_valid_vectors():
  function gen_invalid_vector (line 68) | def gen_invalid_vector(template, corrupt_prefix, randomize_payload_size,...
  function randbool (line 87) | def randbool(p = 0.5):
  function gen_invalid_vectors (line 91) | def gen_invalid_vectors():

FILE: contrib/zmq/zmq_sub.py
  class ZMQHandler (line 39) | class ZMQHandler():
    method __init__ (line 40) | def __init__(self):
    method handle (line 51) | async def handle(self) :
    method start (line 74) | def start(self):
    method stop (line 79) | def stop(self):

FILE: contrib/zmq/zmq_sub3.4.py
  class ZMQHandler (line 43) | class ZMQHandler():
    method __init__ (line 44) | def __init__(self):
    method handle (line 56) | def handle(self) :
    method start (line 79) | def start(self):
    method stop (line 84) | def stop(self):

FILE: share/qt/extract_strings_qt.py
  function parse_po (line 18) | def parse_po(text):

FILE: src/addrdb.cpp
  function SerializeDB (line 20) | bool SerializeDB(Stream& stream, const Data& data)
  function SerializeFileDB (line 36) | bool SerializeFileDB(const std::string& prefix, const fs::path& path, co...
  function DeserializeDB (line 63) | bool DeserializeDB(Stream& stream, Data& data, bool fCheckSum = true)
  function DeserializeFileDB (line 94) | bool DeserializeFileDB(const fs::path& path, Data& data)

FILE: src/addrdb.h
  type BanReason (line 19) | typedef enum BanReason
  function class (line 26) | class CBanEntry
  function SetNull (line 56) | void SetNull()
  type std (line 77) | typedef std::map<CSubNet, CBanEntry> banmap_t;
  function class (line 80) | class CAddrDB
  function class (line 92) | class CBanDB

FILE: src/addrman.cpp
  function CAddrInfo (line 68) | CAddrInfo* CAddrMan::Find(const CNetAddr& addr, int* pnId)
  function CAddrInfo (line 81) | CAddrInfo* CAddrMan::Create(const CAddress& addr, const CNetAddr& addrSo...
  function CAddrInfo (line 337) | CAddrInfo CAddrMan::Select_(bool newOnly)

FILE: src/addrman.h
  function class (line 24) | class CAddrInfo : public CAddress
  function Init (line 68) | void Init()
  function GetNewBucket (line 96) | int GetNewBucket(const uint256 &nKey) const
  function class (line 182) | class CAddrMan
  function Clear (line 456) | void Clear()
  function size (line 491) | size_t size() const
  function Good (line 540) | void Good(const CService &addr, int64_t nTime = GetAdjustedTime())
  function Attempt (line 549) | void Attempt(const CService &addr, bool fCountFailure, int64_t nTime = G...
  function Connected (line 586) | void Connected(const CService &addr, int64_t nTime = GetAdjustedTime())
  function SetServices (line 594) | void SetServices(const CService &addr, ServiceFlags nServices)

FILE: src/amount.h
  type CAmount (line 13) | typedef int64_t CAmount;
  function MoneyRange (line 34) | inline bool MoneyRange(const CAmount& nValue) { return (nValue >= 0 && n...

FILE: src/arith_uint256.cpp
  function arith_uint256 (line 206) | arith_uint256& arith_uint256::SetCompact(uint32_t nCompact, bool* pfNega...
  function uint256 (line 249) | uint256 ArithToUint256(const arith_uint256 &a)
  function arith_uint256 (line 256) | arith_uint256 UintToArith256(const uint256 &a)

FILE: src/arith_uint256.h
  function class (line 18) | class uint_error : public std::runtime_error {
  function class (line 259) | class arith_uint256 : public base_uint<256> {

FILE: src/base58.cpp
  function DecodeBase58 (line 24) | bool DecodeBase58(const char* psz, std::vector<unsigned char>& vch)
  function EncodeBase58 (line 74) | std::string EncodeBase58(const unsigned char* pbegin, const unsigned cha...
  function EncodeBase58 (line 114) | std::string EncodeBase58(const std::vector<unsigned char>& vch)
  function DecodeBase58 (line 119) | bool DecodeBase58(const std::string& str, std::vector<unsigned char>& vc...
  function EncodeBase58Check (line 124) | std::string EncodeBase58Check(const std::vector<unsigned char>& vchIn)
  function DecodeBase58Check (line 133) | bool DecodeBase58Check(const char* psz, std::vector<unsigned char>& vchRet)
  function DecodeBase58Check (line 150) | bool DecodeBase58Check(const std::string& str, std::vector<unsigned char...
  class DestinationEncoder (line 218) | class DestinationEncoder : public boost::static_visitor<std::string>
    method DestinationEncoder (line 224) | DestinationEncoder(const CChainParams& params) : m_params(params) {}
  function CTxDestination (line 267) | CTxDestination DecodeDestination(const std::string& str, const CChainPar...
  function CKey (line 334) | CKey CBitcoinSecret::GetKey()
  function EncodeDestination (line 359) | std::string EncodeDestination(const CTxDestination& dest)
  function CTxDestination (line 364) | CTxDestination DecodeDestination(const std::string& str)
  function IsValidDestinationString (line 369) | bool IsValidDestinationString(const std::string& str, const CChainParams...
  function IsValidDestinationString (line 374) | bool IsValidDestinationString(const std::string& str)

FILE: src/base58.h
  function class (line 70) | class CBase58Data
  function class (line 100) | class CBitcoinSecret : public CBase58Data
  function K (line 122) | K GetKey() {
  type CBitcoinExtKeyBase (line 142) | typedef CBitcoinExtKeyBase<CExtKey, BIP32_EXTKEY_SIZE, CChainParams::EXT...
  type CBitcoinExtKeyBase (line 143) | typedef CBitcoinExtKeyBase<CExtPubKey, BIP32_EXTKEY_SIZE, CChainParams::...

FILE: src/bech32.cpp
  function data (line 28) | data Cat(data x, const data& y)
  function PolyMod (line 37) | uint32_t PolyMod(const data& v)
  function LowerCase (line 97) | inline unsigned char LowerCase(unsigned char c)
  function data (line 103) | data ExpandHRP(const std::string& hrp)
  function VerifyChecksum (line 118) | bool VerifyChecksum(const std::string& hrp, const data& values)
  function data (line 128) | data CreateChecksum(const std::string& hrp, const data& values)
  type bech32 (line 143) | namespace bech32
    function Encode (line 147) | std::string Encode(const std::string& hrp, const data& values) {
    function Decode (line 159) | std::pair<std::string, data> Decode(const std::string& str) {

FILE: src/bech32.h
  function namespace (line 16) | namespace bech32

FILE: src/bench/Examples.cpp
  function Sleep7ms (line 11) | static void Sleep7ms(benchmark::State& state)
  function Trig (line 25) | static void Trig(benchmark::State& state)

FILE: src/bench/base58.cpp
  function Base58Encode (line 15) | static void Base58Encode(benchmark::State& state)
  function Base58CheckEncode (line 30) | static void Base58CheckEncode(benchmark::State& state)
  function Base58Decode (line 47) | static void Base58Decode(benchmark::State& state)

FILE: src/bench/bench.h
  function namespace (line 41) | namespace benchmark {
  type std (line 83) | typedef std::function<void(State&)> BenchFunction;
  function class (line 85) | class BenchRunner
  function class (line 101) | class Printer
  function class (line 111) | class ConsolePrinter : public Printer
  function class (line 120) | class PlotlyPrinter : public Printer

FILE: src/bench/bench_bitcoin.cpp
  function main (line 25) | int

FILE: src/bench/ccoins_caching.cpp
  function SetupDummyInputs (line 19) | static std::vector<CMutableTransaction>
  function CCoinsCaching (line 56) | static void CCoinsCaching(benchmark::State& state)

FILE: src/bench/checkblock.cpp
  type block_bench (line 12) | namespace block_bench {
  function DeserializeBlockTest (line 20) | static void DeserializeBlockTest(benchmark::State& state)
  function DeserializeAndCheckBlockTest (line 35) | static void DeserializeAndCheckBlockTest(benchmark::State& state)

FILE: src/bench/checkqueue.cpp
  function CCheckQueueSpeedPrevectorJob (line 24) | static void CCheckQueueSpeedPrevectorJob(benchmark::State& state)

FILE: src/bench/coin_selection.cpp
  function addCoin (line 10) | static void addCoin(const CAmount& nValue, const CWallet& wallet, std::v...
  function CoinSelection (line 33) | static void CoinSelection(benchmark::State& state)

FILE: src/bench/crypto_hash.cpp
  function RIPEMD160 (line 21) | static void RIPEMD160(benchmark::State& state)
  function SHA1 (line 29) | static void SHA1(benchmark::State& state)
  function SHA256 (line 37) | static void SHA256(benchmark::State& state)
  function SHA256_32b (line 45) | static void SHA256_32b(benchmark::State& state)
  function SHA512 (line 55) | static void SHA512(benchmark::State& state)
  function SipHash_32b (line 63) | static void SipHash_32b(benchmark::State& state)
  function FastRandom_32bit (line 72) | static void FastRandom_32bit(benchmark::State& state)
  function FastRandom_1bit (line 81) | static void FastRandom_1bit(benchmark::State& state)

FILE: src/bench/lockedpool.cpp
  function BenchLockedPool (line 16) | static void BenchLockedPool(benchmark::State& state)

FILE: src/bench/mempool_eviction.cpp
  function AddTx (line 12) | static void AddTx(const CTransaction& tx, const CAmount& nFee, CTxMemPoo...
  function MempoolEviction (line 27) | static void MempoolEviction(benchmark::State& state)

FILE: src/bench/perf.cpp
  function perf_init (line 12) | void perf_init(void) { }
  function perf_fini (line 13) | void perf_fini(void) { }
  type perf_event_attr (line 22) | struct perf_event_attr
  function perf_init (line 24) | void perf_init(void)
  function perf_fini (line 31) | void perf_fini(void)
  function perf_cpucycles (line 38) | uint64_t perf_cpucycles(void)
  function perf_init (line 49) | void perf_init(void) { }
  function perf_fini (line 50) | void perf_fini(void) { }
  function perf_cpucycles (line 51) | uint64_t perf_cpucycles(void) { return 0; }

FILE: src/bench/perf.h
  function perf_cpucycles (line 13) | static inline uint64_t perf_cpucycles(void)
  function perf_cpucycles (line 22) | static inline uint64_t perf_cpucycles(void)

FILE: src/bench/prevector_destructor.cpp
  function PrevectorDestructor (line 8) | static void PrevectorDestructor(benchmark::State& state)
  function PrevectorClear (line 20) | static void PrevectorClear(benchmark::State& state)

FILE: src/bench/rollingbloom.cpp
  function RollingBloom (line 10) | static void RollingBloom(benchmark::State& state)

FILE: src/bench/verify_script.cpp
  function CMutableTransaction (line 17) | static CMutableTransaction BuildCreditingTransaction(const CScript& scri...
  function CMutableTransaction (line 34) | static CMutableTransaction BuildSpendingTransaction(const CScript& scrip...
  function VerifyScriptBench (line 53) | static void VerifyScriptBench(benchmark::State& state)

FILE: src/bitcoin-cli.cpp
  function HelpMessageCli (line 32) | std::string HelpMessageCli()
  class CConnectionFailed (line 66) | class CConnectionFailed : public std::runtime_error
    method CConnectionFailed (line 70) | explicit inline CConnectionFailed(const std::string& msg) :
  function AppInitRPC (line 80) | static int AppInitRPC(int argc, char* argv[])
  type HTTPReply (line 132) | struct HTTPReply
    method HTTPReply (line 134) | HTTPReply(): status(0), error(-1) {}
  function http_request_done (line 163) | static void http_request_done(struct evhttp_request *req, void *ctx)
  function http_error_cb (line 189) | static void http_error_cb(enum evhttp_request_error err, void *ctx)
  class BaseRequestHandler (line 199) | class BaseRequestHandler
  class GetinfoRequestHandler (line 207) | class GetinfoRequestHandler: public BaseRequestHandler
    method UniValue (line 215) | UniValue PrepareRequest(const std::string& method, const std::vector<s...
    method UniValue (line 228) | UniValue ProcessReply(const UniValue &batch_in) override
  class DefaultRequestHandler (line 269) | class DefaultRequestHandler: public BaseRequestHandler {
    method UniValue (line 271) | UniValue PrepareRequest(const std::string& method, const std::vector<s...
    method UniValue (line 282) | UniValue ProcessReply(const UniValue &reply) override
  function UniValue (line 288) | static UniValue CallRPC(BaseRequestHandler *rh, const std::string& strMe...
  function CommandLineRPC (line 381) | int CommandLineRPC(int argc, char *argv[])
  function main (line 488) | int main(int argc, char* argv[])

FILE: src/bitcoin-tx.cpp
  function AppInitRawTx (line 38) | static int AppInitRawTx(int argc, char* argv[])
  function RegisterSetJson (line 114) | static void RegisterSetJson(const std::string& key, const std::string& r...
  function RegisterSet (line 125) | static void RegisterSet(const std::string& strInput)
  function RegisterLoad (line 140) | static void RegisterLoad(const std::string& strInput)
  function CAmount (line 181) | static CAmount ExtractAndValidateValue(const std::string& strValue)
  function MutateTxVersion (line 189) | static void MutateTxVersion(CMutableTransaction& tx, const std::string& ...
  function MutateTxLocktime (line 198) | static void MutateTxLocktime(CMutableTransaction& tx, const std::string&...
  function MutateTxRBFOptIn (line 207) | static void MutateTxRBFOptIn(CMutableTransaction& tx, const std::string&...
  function MutateTxAddInput (line 227) | static void MutateTxAddInput(CMutableTransaction& tx, const std::string&...
  function MutateTxAddOutAddr (line 261) | static void MutateTxAddOutAddr(CMutableTransaction& tx, const std::strin...
  function MutateTxAddOutPubKey (line 286) | static void MutateTxAddOutPubKey(CMutableTransaction& tx, const std::str...
  function MutateTxAddOutMultiSig (line 330) | static void MutateTxAddOutMultiSig(CMutableTransaction& tx, const std::s...
  function MutateTxAddOutData (line 404) | static void MutateTxAddOutData(CMutableTransaction& tx, const std::strin...
  function MutateTxAddOutScript (line 431) | static void MutateTxAddOutScript(CMutableTransaction& tx, const std::str...
  function MutateTxDelInput (line 476) | static void MutateTxDelInput(CMutableTransaction& tx, const std::string&...
  function MutateTxDelOutput (line 489) | static void MutateTxDelOutput(CMutableTransaction& tx, const std::string...
  function findSighashFlags (line 515) | static bool findSighashFlags(int& flags, const std::string& flagStr)
  function CAmount (line 529) | static CAmount AmountFromValue(const UniValue& value)
  function MutateTxSign (line 541) | static void MutateTxSign(CMutableTransaction& tx, const std::string& fla...
  class Secp256k1Init (line 671) | class Secp256k1Init
    method Secp256k1Init (line 676) | Secp256k1Init() {
  function MutateTx (line 684) | static void MutateTx(CMutableTransaction& tx, const std::string& command,
  function OutputTxJSON (line 732) | static void OutputTxJSON(const CTransaction& tx)
  function OutputTxHash (line 741) | static void OutputTxHash(const CTransaction& tx)
  function OutputTxHex (line 748) | static void OutputTxHex(const CTransaction& tx)
  function OutputTx (line 755) | static void OutputTx(const CTransaction& tx)
  function readStdin (line 765) | static std::string readStdin()
  function CommandLineRawTx (line 785) | static int CommandLineRawTx(int argc, char* argv[])
  function main (line 852) | int main(int argc, char* argv[])

FILE: src/bitcoind.cpp
  function WaitForShutdown (line 42) | void WaitForShutdown()
  function AppInit (line 58) | bool AppInit(int argc, char* argv[])
  function main (line 179) | int main(int argc, char* argv[])

FILE: src/blockencodings.cpp
  function ReadStatus (line 48) | ReadStatus PartiallyDownloadedBlock::InitData(const CBlockHeaderAndShort...
  function ReadStatus (line 176) | ReadStatus PartiallyDownloadedBlock::FillBlock(CBlock& block, const std:...

FILE: src/blockencodings.h
  type TransactionCompressor (line 15) | struct TransactionCompressor {
  function class (line 29) | class BlockTransactionsRequest {
  function class (line 71) | class BlockTransactions {
  type PrefilledTransaction (line 103) | struct PrefilledTransaction {
  type ReadStatus (line 122) | typedef enum ReadStatus_t
  function class (line 131) | class CBlockHeaderAndShortTxIDs {
  function class (line 194) | class PartiallyDownloadedBlock {

FILE: src/bloom.cpp
  function RollingBloomHash (line 244) | static inline uint32_t RollingBloomHash(unsigned int nHashNum, uint32_t ...

FILE: src/bloom.h
  type bloomflags (line 24) | enum bloomflags
  function class (line 44) | class CBloomFilter
  function class (line 119) | class CRollingBloomFilter

FILE: src/chain.cpp
  function CBlockLocator (line 23) | CBlockLocator CChain::GetLocator(const CBlockIndex *pindex) const {
  function CBlockIndex (line 51) | const CBlockIndex *CChain::FindFork(const CBlockIndex *pindex) const {
  function CBlockIndex (line 62) | CBlockIndex* CChain::FindEarliestAtLeast(int64_t nTime) const
  function InvertLowestOne (line 70) | int static inline InvertLowestOne(int n) { return n & (n - 1); }
  function GetSkipHeight (line 73) | int static inline GetSkipHeight(int height) {
  function CBlockIndex (line 83) | const CBlockIndex* CBlockIndex::GetAncestor(int height) const
  function CBlockIndex (line 110) | CBlockIndex* CBlockIndex::GetAncestor(int height)
  function arith_uint256 (line 121) | arith_uint256 GetBlockProof(const CBlockIndex& block)
  function GetBlockProofEquivalentTime (line 136) | int64_t GetBlockProofEquivalentTime(const CBlockIndex& to, const CBlockI...
  function CBlockIndex (line 155) | const CBlockIndex* LastCommonAncestor(const CBlockIndex* pa, const CBloc...

FILE: src/chain.h
  function class (line 46) | class CBlockFileInfo
  function SetNull (line 70) | void SetNull() {
  function AddBlock (line 87) | void AddBlock(unsigned int nHeightIn, uint64_t nTimeIn) {
  function CDiskBlockPos (line 100) | struct CDiskBlockPos
  function SetNull (line 130) | void SetNull() { nFile = -1; nPos = 0; }
  type BlockStatus (line 140) | enum BlockStatus: uint32_t {
  function class (line 185) | class CBlockIndex
  function CDiskBlockPos (line 295) | CDiskBlockPos GetUndoPos() const {
  function GetMedianTimePast (line 344) | int64_t GetMedianTimePast() const
  function IsValid (line 367) | bool IsValid(enum BlockStatus nUpTo = BLOCK_VALID_TRANSACTIONS) const
  function RaiseValidity (line 377) | bool RaiseValidity(enum BlockStatus nUpTo)
  function class (line 405) | class CDiskBlockIndex : public CBlockIndex
  function class (line 470) | class CChain {

FILE: src/chainparams.cpp
  function CBlock (line 21) | static CBlock CreateGenesisBlock(const char* pszTimestamp, const CScript...
  function CBlock (line 94) | static CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nNonce, uint32...
  class CMainParams (line 121) | class CMainParams : public CChainParams {
    method CMainParams (line 123) | CMainParams() {
  class CTestNetParams (line 305) | class CTestNetParams : public CChainParams {
    method CTestNetParams (line 307) | CTestNetParams() {
  class CRegTestParams (line 478) | class CRegTestParams : public CChainParams {
    method CRegTestParams (line 480) | CRegTestParams() {
  function CChainParams (line 621) | const CChainParams &Params() {
  function CreateChainParams (line 626) | std::unique_ptr<CChainParams> CreateChainParams(const std::string& chain)
  function SelectParams (line 637) | void SelectParams(const std::string& network)
  function UpdateVersionBitsParameters (line 643) | void UpdateVersionBitsParameters(Consensus::DeploymentPos d, int64_t nSt...

FILE: src/chainparams.h
  type SeedSpec6 (line 17) | struct SeedSpec6 {
  type std (line 22) | typedef std::map<int, uint256> MapCheckpoints;
  type CCheckpointData (line 24) | struct CCheckpointData {
  type ChainTxData (line 28) | struct ChainTxData {
  function class (line 41) | class CChainParams

FILE: src/chainparamsbase.cpp
  function AppendParamsHelpMessages (line 18) | void AppendParamsHelpMessages(std::string& strUsage, bool debugHelp)
  class CBaseMainParams (line 31) | class CBaseMainParams : public CBaseChainParams
    method CBaseMainParams (line 34) | CBaseMainParams()
  class CBaseTestNetParams (line 43) | class CBaseTestNetParams : public CBaseChainParams
    method CBaseTestNetParams (line 46) | CBaseTestNetParams()
  class CBaseRegTestParams (line 56) | class CBaseRegTestParams : public CBaseChainParams
    method CBaseRegTestParams (line 59) | CBaseRegTestParams()
  function CBaseChainParams (line 68) | const CBaseChainParams& BaseParams()
  function CreateBaseChainParams (line 74) | std::unique_ptr<CBaseChainParams> CreateBaseChainParams(const std::strin...
  function SelectBaseParams (line 86) | void SelectBaseParams(const std::string& chain)
  function ChainNameFromCommandLine (line 91) | std::string ChainNameFromCommandLine()

FILE: src/chainparamsbase.h
  function class (line 16) | class CBaseChainParams

FILE: src/checkpoints.cpp
  type Checkpoints (line 15) | namespace Checkpoints {
    function CBlockIndex (line 17) | CBlockIndex* GetLastCheckpoint(const CCheckpointData& data)

FILE: src/checkpoints.h
  type CCheckpointData (line 13) | struct CCheckpointData
  function namespace (line 19) | namespace Checkpoints

FILE: src/checkqueue.h
  function Wait (line 140) | bool Wait()
  function Add (line 146) | void Add(std::vector<T>& vChecks)

FILE: src/clientversion.cpp
  function FormatVersion (line 71) | static std::string FormatVersion(int nVersion)
  function FormatFullVersion (line 79) | std::string FormatFullVersion()
  function FormatSubVersion (line 87) | std::string FormatSubVersion(const std::string& name, int nClientVersion...

FILE: src/coins.cpp
  function uint256 (line 11) | uint256 CCoinsView::GetBestBlock() const { return uint256(); }
  function CCoinsViewCursor (line 14) | CCoinsViewCursor *CCoinsView::Cursor() const { return nullptr; }
  function uint256 (line 25) | uint256 CCoinsViewBacked::GetBestBlock() const { return base->GetBestBlo...
  function CCoinsViewCursor (line 29) | CCoinsViewCursor *CCoinsViewBacked::Cursor() const { return base->Cursor...
  function AddCoins (line 87) | void AddCoins(CCoinsViewCache& cache, const CTransaction &tx, int nHeigh...
  function Coin (line 116) | const Coin& CCoinsViewCache::AccessCoin(const COutPoint &outpoint) const {
  function uint256 (line 135) | uint256 CCoinsViewCache::GetBestBlock() const {
  function CAmount (line 223) | CAmount CCoinsViewCache::GetValueIn(const CTransaction& tx) const
  function Coin (line 250) | const Coin& AccessByTxid(const CCoinsViewCache& view, const uint256& txid)

FILE: src/coins.h
  function class (line 29) | class Coin
  function DynamicMemoryUsage (line 79) | size_t DynamicMemoryUsage() const {
  function CCoinsViewCursor (line 103) | struct CCoinsCacheEntry
  function GetValueSize (line 133) | virtual unsigned int GetValueSize() const = 0;
  function class (line 182) | class CCoinsViewBacked : public CCoinsView

FILE: src/compat.h
  type SOCKET (line 52) | typedef unsigned int SOCKET;
  function IsSelectableSocket (line 89) | bool static inline IsSelectableSocket(const SOCKET& s) {

FILE: src/compat/byteswap.h
  function bswap_16 (line 36) | inline uint16_t bswap_16(uint16_t x)
  function bswap_32 (line 43) | inline uint32_t bswap_32(uint32_t x)
  function bswap_64 (line 51) | inline uint64_t bswap_64(uint64_t x)

FILE: src/compat/endian.h
  function htobe16 (line 70) | inline uint16_t htobe16(uint16_t host_16bits)
  function htole16 (line 77) | inline uint16_t htole16(uint16_t host_16bits)
  function be16toh (line 84) | inline uint16_t be16toh(uint16_t big_endian_16bits)
  function le16toh (line 91) | inline uint16_t le16toh(uint16_t little_endian_16bits)
  function htobe32 (line 98) | inline uint32_t htobe32(uint32_t host_32bits)
  function htole32 (line 105) | inline uint32_t htole32(uint32_t host_32bits)
  function be32toh (line 112) | inline uint32_t be32toh(uint32_t big_endian_32bits)
  function le32toh (line 119) | inline uint32_t le32toh(uint32_t little_endian_32bits)
  function htobe64 (line 126) | inline uint64_t htobe64(uint64_t host_64bits)
  function htole64 (line 133) | inline uint64_t htole64(uint64_t host_64bits)
  function be64toh (line 140) | inline uint64_t be64toh(uint64_t big_endian_64bits)
  function le64toh (line 147) | inline uint64_t le64toh(uint64_t little_endian_64bits)
  function htobe16 (line 156) | inline uint16_t htobe16(uint16_t host_16bits)
  function htole16 (line 163) | inline uint16_t htole16(uint16_t host_16bits)
  function be16toh (line 170) | inline uint16_t be16toh(uint16_t big_endian_16bits)
  function le16toh (line 177) | inline uint16_t le16toh(uint16_t little_endian_16bits)
  function htobe32 (line 184) | inline uint32_t htobe32(uint32_t host_32bits)
  function htole32 (line 191) | inline uint32_t htole32(uint32_t host_32bits)
  function be32toh (line 198) | inline uint32_t be32toh(uint32_t big_endian_32bits)
  function le32toh (line 205) | inline uint32_t le32toh(uint32_t little_endian_32bits)
  function htobe64 (line 212) | inline uint64_t htobe64(uint64_t host_64bits)
  function htole64 (line 219) | inline uint64_t htole64(uint64_t host_64bits)
  function be64toh (line 226) | inline uint64_t be64toh(uint64_t big_endian_64bits)
  function le64toh (line 233) | inline uint64_t le64toh(uint64_t little_endian_64bits)

FILE: src/compat/glibc_compat.cpp
  function FDELT_TYPE (line 23) | FDELT_TYPE __fdelt_warn(FDELT_TYPE a)

FILE: src/compat/glibc_sanity.cpp
  function sanity_test_memcpy (line 29) | bool sanity_test_memcpy()
  function sanity_test_fdelt (line 50) | bool sanity_test_fdelt()
  function glibc_sanity_test (line 61) | bool glibc_sanity_test()

FILE: src/compat/glibcxx_sanity.cpp
  function sanity_test_widen (line 14) | bool sanity_test_widen(char testchar)
  function sanity_test_list (line 24) | bool sanity_test_list(unsigned int size)
  function sanity_test_range_fmt (line 46) | bool sanity_test_range_fmt()
  function glibcxx_sanity_test (line 58) | bool glibcxx_sanity_test()

FILE: src/compat/strnlen.cpp
  function strnlen (line 12) | size_t strnlen( const char *start, size_t max_len)

FILE: src/compressor.h
  function class (line 28) | class CScriptCompressor
  function class (line 93) | class CTxOutCompressor

FILE: src/consensus/merkle.cpp
  function MerkleComputation (line 46) | static void MerkleComputation(const std::vector<uint256>& leaves, uint25...
  function uint256 (line 133) | uint256 ComputeMerkleRoot(const std::vector<uint256>& leaves, bool* muta...
  function ComputeMerkleBranch (line 139) | std::vector<uint256> ComputeMerkleBranch(const std::vector<uint256>& lea...
  function uint256 (line 145) | uint256 ComputeMerkleRootFromBranch(const uint256& leaf, const std::vect...
  function uint256 (line 158) | uint256 BlockMerkleRoot(const CBlock& block, bool* mutated)
  function uint256 (line 168) | uint256 BlockWitnessMerkleRoot(const CBlock& block, bool* mutated)
  function BlockMerkleBranch (line 179) | std::vector<uint256> BlockMerkleBranch(const CBlock& block, uint32_t pos...

FILE: src/consensus/params.h
  function namespace (line 17) | namespace Consensus {

FILE: src/consensus/tx_verify.cpp
  function IsFinalTx (line 17) | bool IsFinalTx(const CTransaction &tx, int nBlockHeight, int64_t nBlockT...
  function CalculateSequenceLocks (line 30) | std::pair<int, int64_t> CalculateSequenceLocks(const CTransaction &tx, i...
  function EvaluateSequenceLocks (line 92) | bool EvaluateSequenceLocks(const CBlockIndex& block, std::pair<int, int6...
  function SequenceLocks (line 102) | bool SequenceLocks(const CTransaction &tx, int flags, std::vector<int>* ...
  function GetLegacySigOpCount (line 107) | unsigned int GetLegacySigOpCount(const CTransaction& tx)
  function GetP2SHSigOpCount (line 121) | unsigned int GetP2SHSigOpCount(const CTransaction& tx, const CCoinsViewC...
  function GetTransactionSigOpCost (line 138) | int64_t GetTransactionSigOpCost(const CTransaction& tx, const CCoinsView...
  function CheckTransaction (line 159) | bool CheckTransaction(const CTransaction& tx, CValidationState &state, b...

FILE: src/consensus/tx_verify.h
  function namespace (line 23) | namespace Consensus {

FILE: src/consensus/validation.h
  function class (line 26) | class CValidationState {
  function Error (line 59) | bool Error(const std::string& strRejectReasonIn) {
  function IsInvalid (line 74) | bool IsInvalid(int &nDoSOut) const {
  function SetCorruptionPossible (line 84) | void SetCorruptionPossible() {
  function GetTransactionWeight (line 96) | static inline int64_t GetTransactionWeight(const CTransaction& tx)
  function GetBlockWeight (line 100) | static inline int64_t GetBlockWeight(const CBlock& block)

FILE: src/core_io.h
  type CMutableTransaction (line 16) | struct CMutableTransaction

FILE: src/core_memusage.h
  function RecursiveDynamicUsage (line 12) | static inline size_t RecursiveDynamicUsage(const CScript& script) {
  function RecursiveDynamicUsage (line 16) | static inline size_t RecursiveDynamicUsage(const COutPoint& out) {
  function RecursiveDynamicUsage (line 20) | static inline size_t RecursiveDynamicUsage(const CTxIn& in) {
  function RecursiveDynamicUsage (line 28) | static inline size_t RecursiveDynamicUsage(const CTxOut& out) {
  function RecursiveDynamicUsage (line 32) | static inline size_t RecursiveDynamicUsage(const CTransaction& tx) {
  function RecursiveDynamicUsage (line 43) | static inline size_t RecursiveDynamicUsage(const CMutableTransaction& tx) {
  function RecursiveDynamicUsage (line 54) | static inline size_t RecursiveDynamicUsage(const CBlock& block) {

FILE: src/core_read.cpp
  function CScript (line 22) | CScript ParseScript(const std::string& s)
  function CheckTxScriptsSanity (line 91) | bool CheckTxScriptsSanity(const CMutableTransaction& tx)
  function DecodeHexTx (line 111) | bool DecodeHexTx(CMutableTransaction& tx, const std::string& hex_tx, boo...
  function DecodeHexBlk (line 146) | bool DecodeHexBlk(CBlock& block, const std::string& strHexBlk)
  function uint256 (line 163) | uint256 ParseHashUV(const UniValue& v, const std::string& strName)
  function uint256 (line 171) | uint256 ParseHashStr(const std::string& strHex, const std::string& strName)
  function ParseHexUV (line 181) | std::vector<unsigned char> ParseHexUV(const UniValue& v, const std::stri...

FILE: src/core_write.cpp
  function UniValue (line 19) | UniValue ValueFromAmount(const CAmount& amount)
  function FormatScript (line 29) | std::string FormatScript(const CScript& script)
  function ScriptToAsmStr (line 80) | std::string ScriptToAsmStr(const CScript& script, const bool fAttemptSig...
  function EncodeHexTx (line 124) | std::string EncodeHexTx(const CTransaction& tx, const int serializeFlags)
  function ScriptPubKeyToUniv (line 131) | void ScriptPubKeyToUniv(const CScript& scriptPubKey,
  function TxToUniv (line 157) | void TxToUniv(const CTransaction& tx, const uint256& hashBlock, UniValue...

FILE: src/crypto/aes.cpp
  function CBCEncrypt (line 77) | static int CBCEncrypt(const T& enc, const unsigned char iv[AES_BLOCKSIZE...
  function CBCDecrypt (line 113) | static int CBCDecrypt(const T& dec, const unsigned char iv[AES_BLOCKSIZE...

FILE: src/crypto/aes.h
  function class (line 19) | class AES128Encrypt
  function class (line 31) | class AES128Decrypt
  function class (line 43) | class AES256Encrypt
  function class (line 55) | class AES256Decrypt
  function class (line 66) | class AES256CBCEncrypt
  function class (line 79) | class AES256CBCDecrypt
  function class (line 92) | class AES128CBCEncrypt
  function class (line 105) | class AES128CBCDecrypt

FILE: src/crypto/chacha20.cpp
  function rotl32 (line 13) | constexpr static inline uint32_t rotl32(uint32_t v, int c) { return (v <...

FILE: src/crypto/chacha20.h
  function class (line 12) | class ChaCha20

FILE: src/crypto/common.h
  function ReadLE16 (line 17) | uint16_t static inline ReadLE16(const unsigned char* ptr)
  function ReadLE32 (line 24) | uint32_t static inline ReadLE32(const unsigned char* ptr)
  function ReadLE64 (line 31) | uint64_t static inline ReadLE64(const unsigned char* ptr)
  function WriteLE16 (line 38) | void static inline WriteLE16(unsigned char* ptr, uint16_t x)
  function WriteLE32 (line 44) | void static inline WriteLE32(unsigned char* ptr, uint32_t x)
  function WriteLE64 (line 50) | void static inline WriteLE64(unsigned char* ptr, uint64_t x)
  function ReadBE32 (line 56) | uint32_t static inline ReadBE32(const unsigned char* ptr)
  function ReadBE64 (line 63) | uint64_t static inline ReadBE64(const unsigned char* ptr)
  function WriteBE32 (line 70) | void static inline WriteBE32(unsigned char* ptr, uint32_t x)
  function WriteBE64 (line 76) | void static inline WriteBE64(unsigned char* ptr, uint64_t x)
  function CountBits (line 83) | uint64_t static inline CountBits(uint64_t x)

FILE: src/crypto/ctaes/bench.c
  function gettimedouble (line 7) | static double gettimedouble(void) {
  function print_number (line 13) | static void print_number(double x) {
  function run_benchmark (line 26) | static void run_benchmark(char *name, void (*benchmark)(void*), void (*s...
  function bench_AES128_init (line 59) | static void bench_AES128_init(void* data) {
  function bench_AES128_encrypt_setup (line 67) | static void bench_AES128_encrypt_setup(void* data) {
  function bench_AES128_encrypt (line 73) | static void bench_AES128_encrypt(void* data) {
  function bench_AES128_decrypt (line 82) | static void bench_AES128_decrypt(void* data) {
  function bench_AES192_init (line 91) | static void bench_AES192_init(void* data) {
  function bench_AES192_encrypt_setup (line 99) | static void bench_AES192_encrypt_setup(void* data) {
  function bench_AES192_encrypt (line 105) | static void bench_AES192_encrypt(void* data) {
  function bench_AES192_decrypt (line 114) | static void bench_AES192_decrypt(void* data) {
  function bench_AES256_init (line 123) | static void bench_AES256_init(void* data) {
  function bench_AES256_encrypt_setup (line 132) | static void bench_AES256_encrypt_setup(void* data) {
  function bench_AES256_encrypt (line 138) | static void bench_AES256_encrypt(void* data) {
  function bench_AES256_decrypt (line 147) | static void bench_AES256_decrypt(void* data) {
  function main (line 156) | int main(void) {

FILE: src/crypto/ctaes/ctaes.c
  function LoadByte (line 25) | static void LoadByte(AES_state* s, unsigned char byte, int r, int c) {
  function LoadBytes (line 34) | static void LoadBytes(AES_state *s, const unsigned char* data16) {
  function SaveBytes (line 45) | static void SaveBytes(unsigned char* data16, const AES_state *s) {
  function SubBytes (line 64) | static void SubBytes(AES_state *s, int inv) {
  function ShiftRows (line 263) | static void ShiftRows(AES_state* s) {
  function InvShiftRows (line 275) | static void InvShiftRows(AES_state* s) {
  function MixColumns (line 289) | static void MixColumns(AES_state* s, int inv) {
  function AddRoundKey (line 354) | static void AddRoundKey(AES_state* s, const AES_state* round) {
  function GetOneColumn (line 362) | static void GetOneColumn(AES_state* s, const AES_state* a, int c) {
  function KeySetupColumnMix (line 370) | static void KeySetupColumnMix(AES_state* s, AES_state* r, const AES_stat...
  function KeySetupTransform (line 378) | static void KeySetupTransform(AES_state* s, const AES_state* r) {
  function MultX (line 386) | static void MultX(AES_state* s) {
  function AES_setup (line 407) | static void AES_setup(AES_state* rounds, const uint8_t* key, int nkeywor...
  function AES_encrypt (line 449) | static void AES_encrypt(const AES_state* rounds, int nrounds, unsigned c...
  function AES_decrypt (line 470) | static void AES_decrypt(const AES_state* rounds, int nrounds, unsigned c...
  function AES128_init (line 497) | void AES128_init(AES128_ctx* ctx, const unsigned char* key16) {
  function AES128_encrypt (line 501) | void AES128_encrypt(const AES128_ctx* ctx, size_t blocks, unsigned char*...
  function AES128_decrypt (line 509) | void AES128_decrypt(const AES128_ctx* ctx, size_t blocks, unsigned char*...
  function AES192_init (line 517) | void AES192_init(AES192_ctx* ctx, const unsigned char* key24) {
  function AES192_encrypt (line 521) | void AES192_encrypt(const AES192_ctx* ctx, size_t blocks, unsigned char*...
  function AES192_decrypt (line 530) | void AES192_decrypt(const AES192_ctx* ctx, size_t blocks, unsigned char*...
  function AES256_init (line 538) | void AES256_init(AES256_ctx* ctx, const unsigned char* key32) {
  function AES256_encrypt (line 542) | void AES256_encrypt(const AES256_ctx* ctx, size_t blocks, unsigned char*...
  function AES256_decrypt (line 550) | void AES256_decrypt(const AES256_ctx* ctx, size_t blocks, unsigned char*...

FILE: src/crypto/ctaes/ctaes.h
  type AES_state (line 13) | typedef struct {
  type AES128_ctx (line 17) | typedef struct {
  type AES192_ctx (line 21) | typedef struct {
  type AES256_ctx (line 25) | typedef struct {

FILE: src/crypto/ctaes/test.c
  type ctaes_test (line 13) | typedef struct {
  function from_hex (line 41) | static void from_hex(unsigned char* data, int len, const char* hex) {
  function main (line 60) | int main(void) {

FILE: src/crypto/hmac_sha256.h
  function class (line 14) | class CHMAC_SHA256

FILE: src/crypto/hmac_sha512.h
  function class (line 14) | class CHMAC_SHA512

FILE: src/crypto/ripemd160.cpp
  type ripemd160 (line 15) | namespace ripemd160
    function f1 (line 17) | uint32_t inline f1(uint32_t x, uint32_t y, uint32_t z) { return x ^ y ...
    function f2 (line 18) | uint32_t inline f2(uint32_t x, uint32_t y, uint32_t z) { return (x & y...
    function f3 (line 19) | uint32_t inline f3(uint32_t x, uint32_t y, uint32_t z) { return (x | ~...
    function f4 (line 20) | uint32_t inline f4(uint32_t x, uint32_t y, uint32_t z) { return (x & z...
    function f5 (line 21) | uint32_t inline f5(uint32_t x, uint32_t y, uint32_t z) { return x ^ (y...
    function Initialize (line 24) | void inline Initialize(uint32_t* s)
    function rol (line 33) | uint32_t inline rol(uint32_t x, int i) { return (x << i) | (x >> (32 -...
    function Round (line 35) | void inline Round(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, ui...
    function R11 (line 41) | void inline R11(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint...
    function R21 (line 42) | void inline R21(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint...
    function R31 (line 43) | void inline R31(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint...
    function R41 (line 44) | void inline R41(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint...
    function R51 (line 45) | void inline R51(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint...
    function R12 (line 47) | void inline R12(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint...
    function R22 (line 48) | void inline R22(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint...
    function R32 (line 49) | void inline R32(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint...
    function R42 (line 50) | void inline R42(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint...
    function R52 (line 51) | void inline R52(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint...
    function Transform (line 54) | void Transform(uint32_t* s, const unsigned char* chunk)
  function CRIPEMD160 (line 247) | CRIPEMD160& CRIPEMD160::Write(const unsigned char* data, size_t len)
  function CRIPEMD160 (line 287) | CRIPEMD160& CRIPEMD160::Reset()

FILE: src/crypto/ripemd160.h
  function class (line 12) | class CRIPEMD160

FILE: src/crypto/sha1.cpp
  type sha1 (line 15) | namespace sha1
    function Round (line 18) | void inline Round(uint32_t a, uint32_t& b, uint32_t c, uint32_t d, uin...
    function f1 (line 24) | uint32_t inline f1(uint32_t b, uint32_t c, uint32_t d) { return d ^ (b...
    function f2 (line 25) | uint32_t inline f2(uint32_t b, uint32_t c, uint32_t d) { return b ^ c ...
    function f3 (line 26) | uint32_t inline f3(uint32_t b, uint32_t c, uint32_t d) { return (b & c...
    function left (line 28) | uint32_t inline left(uint32_t x) { return (x << 1) | (x >> 31); }
    function Initialize (line 31) | void inline Initialize(uint32_t* s)
    function Transform (line 46) | void Transform(uint32_t* s, const unsigned char* chunk)
  function CSHA1 (line 154) | CSHA1& CSHA1::Write(const unsigned char* data, size_t len)
  function CSHA1 (line 194) | CSHA1& CSHA1::Reset()

FILE: src/crypto/sha1.h
  function class (line 12) | class CSHA1

FILE: src/crypto/sha256.cpp
  type sha256_sse4 (line 15) | namespace sha256_sse4
  type sha256 (line 26) | namespace sha256
    function Ch (line 28) | uint32_t inline Ch(uint32_t x, uint32_t y, uint32_t z) { return z ^ (x...
    function Maj (line 29) | uint32_t inline Maj(uint32_t x, uint32_t y, uint32_t z) { return (x & ...
    function Sigma0 (line 30) | uint32_t inline Sigma0(uint32_t x) { return (x >> 2 | x << 30) ^ (x >>...
    function Sigma1 (line 31) | uint32_t inline Sigma1(uint32_t x) { return (x >> 6 | x << 26) ^ (x >>...
    function sigma0 (line 32) | uint32_t inline sigma0(uint32_t x) { return (x >> 7 | x << 25) ^ (x >>...
    function sigma1 (line 33) | uint32_t inline sigma1(uint32_t x) { return (x >> 17 | x << 15) ^ (x >...
    function Round (line 36) | void inline Round(uint32_t a, uint32_t b, uint32_t c, uint32_t& d, uin...
    function Initialize (line 45) | void inline Initialize(uint32_t* s)
    function Transform (line 58) | void Transform(uint32_t* s, const unsigned char* chunk, size_t blocks)
  function SelfTest (line 148) | bool SelfTest(TransformType tr) {
  function SHA256AutoDetect (line 179) | std::string SHA256AutoDetect()
  function CSHA256 (line 201) | CSHA256& CSHA256::Write(const unsigned char* data, size_t len)
  function CSHA256 (line 244) | CSHA256& CSHA256::Reset()

FILE: src/crypto/sha256.h
  function class (line 13) | class CSHA256

FILE: src/crypto/sha512.cpp
  type sha512 (line 15) | namespace sha512
    function Ch (line 17) | uint64_t inline Ch(uint64_t x, uint64_t y, uint64_t z) { return z ^ (x...
    function Maj (line 18) | uint64_t inline Maj(uint64_t x, uint64_t y, uint64_t z) { return (x & ...
    function Sigma0 (line 19) | uint64_t inline Sigma0(uint64_t x) { return (x >> 28 | x << 36) ^ (x >...
    function Sigma1 (line 20) | uint64_t inline Sigma1(uint64_t x) { return (x >> 14 | x << 50) ^ (x >...
    function sigma0 (line 21) | uint64_t inline sigma0(uint64_t x) { return (x >> 1 | x << 63) ^ (x >>...
    function sigma1 (line 22) | uint64_t inline sigma1(uint64_t x) { return (x >> 19 | x << 45) ^ (x >...
    function Round (line 25) | void inline Round(uint64_t a, uint64_t b, uint64_t c, uint64_t& d, uin...
    function Initialize (line 34) | void inline Initialize(uint64_t* s)
    function Transform (line 47) | void Transform(uint64_t* s, const unsigned char* chunk)
  function CSHA512 (line 159) | CSHA512& CSHA512::Write(const unsigned char* data, size_t len)
  function CSHA512 (line 202) | CSHA512& CSHA512::Reset()

FILE: src/crypto/sha512.h
  function class (line 12) | class CSHA512

FILE: src/crypto/yespower-1.0.1/benchmark.c
  function time_us (line 36) | static uint64_t time_us(void)
  function main (line 50) | int main(int argc, const char * const *argv)

FILE: src/crypto/yespower-1.0.1/sha256.c
  function be32enc_vect (line 52) | static void
  function be32dec_vect (line 69) | static void
  function SHA256_Transform (line 134) | static void
  function SHA256_Pad (line 205) | static void
  function SHA256_Init (line 243) | void
  function _SHA256_Update (line 258) | static void
  function SHA256_Update (line 299) | void
  function _SHA256_Final (line 316) | static void
  function SHA256_Final (line 329) | void
  function SHA256_Buf (line 348) | void
  function _HMAC_SHA256_Init (line 368) | static void
  function HMAC_SHA256_Init (line 401) | void
  function _HMAC_SHA256_Update (line 421) | static void
  function HMAC_SHA256_Update (line 431) | void
  function _HMAC_SHA256_Final (line 448) | static void
  function HMAC_SHA256_Final (line 464) | void
  function HMAC_SHA256_Buf (line 483) | void
  function SHA256_Pad_Almost (line 502) | static int
  function PBKDF2_SHA256 (line 533) | void

FILE: src/crypto/yespower-1.0.1/sha256.h
  type SHA256_CTX (line 53) | typedef struct {
  type HMAC_SHA256_CTX (line 85) | typedef struct {

FILE: src/crypto/yespower-1.0.1/sysendian.h
  function be32dec (line 39) | static inline uint32_t
  function be32enc (line 48) | static inline void
  function be64enc (line 59) | static inline void
  function le32dec (line 74) | static inline uint32_t
  function le32enc (line 83) | static inline void

FILE: src/crypto/yespower-1.0.1/tests.c
  function print_PBKDF2_SHA256_raw (line 33) | static void print_PBKDF2_SHA256_raw(const char *passwd, size_t passwdlen,
  function print_PBKDF2_SHA256 (line 52) | static void print_PBKDF2_SHA256(const char *passwd,
  function print_yespower (line 62) | static void print_yespower(yespower_version_t version, uint32_t N, uint3...
  function print_yespower_loop (line 97) | static void print_yespower_loop(yespower_version_t version, const char *...
  function main (line 139) | int main(void)

FILE: src/crypto/yespower-1.0.1/yespower-opt.c
  type salsa20_blk_t (line 125) | typedef union {
  function salsa20_simd_shuffle (line 133) | static inline void salsa20_simd_shuffle(const salsa20_blk_t *Bin,
  function salsa20_simd_unshuffle (line 149) | static inline void salsa20_simd_unshuffle(const salsa20_blk_t *Bin,
  function salsa20 (line 282) | static inline void salsa20(salsa20_blk_t *restrict B,
  function blockmix_salsa (line 383) | static inline void blockmix_salsa(const salsa20_blk_t *restrict Bin,
  function blockmix_salsa_xor (line 393) | static inline uint32_t blockmix_salsa_xor(const salsa20_blk_t *restrict ...
  type pwxform_ctx_t (line 430) | typedef struct {
  function blockmix (line 669) | static void blockmix(const salsa20_blk_t *restrict Bin,
  function integerify (line 831) | static inline uint32_t integerify(const salsa20_blk_t *B, size_t r)
  function smix2 (line 927) | static void smix2(uint8_t *B, size_t r, uint32_t N, uint32_t Nloop,
  function smix (line 984) | static void smix(uint8_t *B, size_t r, uint32_t N,
  function yespower (line 1029) | int yespower(yespower_local_t *local,
  function yespower_tls (line 1129) | int yespower_tls(const uint8_t *src, size_t srclen,
  function yespower_init_local (line 1143) | int yespower_init_local(yespower_local_t *local)
  function yespower_free_local (line 1149) | int yespower_free_local(yespower_local_t *local)

FILE: src/crypto/yespower-1.0.1/yespower-platform.c
  function init_region (line 89) | static inline void init_region(yespower_region_t *region)
  function free_region (line 95) | static int free_region(yespower_region_t *region)

FILE: src/crypto/yespower-1.0.1/yespower-ref.c
  function blkcpy (line 59) | static void blkcpy(uint32_t *dst, const uint32_t *src, size_t count)
  function blkxor (line 66) | static void blkxor(uint32_t *dst, const uint32_t *src, size_t count)
  function salsa20 (line 77) | static void salsa20(uint32_t B[16], uint32_t rounds)
  function blockmix_salsa (line 126) | static void blockmix_salsa(uint32_t *B, uint32_t rounds)
  type pwxform_ctx_t (line 168) | typedef struct {
  function pwxform (line 181) | static void pwxform(uint32_t *B, pwxform_ctx_t *ctx)
  function blockmix_pwxform (line 254) | static void blockmix_pwxform(uint32_t *B, pwxform_ctx_t *ctx, size_t r)
  function integerify (line 301) | static uint32_t integerify(const uint32_t *B, size_t r)
  function p2floor (line 315) | static uint32_t p2floor(uint32_t x)
  function wrap (line 327) | static uint32_t wrap(uint32_t x, uint32_t i)
  function smix1 (line 339) | static void smix1(uint32_t *B, size_t r, uint32_t N,
  function smix2 (line 391) | static void smix2(uint32_t *B, size_t r, uint32_t N, uint32_t Nloop,
  function smix (line 431) | static void smix(uint32_t *B, size_t r, uint32_t N,
  function yespower (line 456) | int yespower(yespower_local_t *local,
  function yespower_tls (line 562) | int yespower_tls(const uint8_t *src, size_t srclen,
  function yespower_init_local (line 569) | int yespower_init_local(yespower_local_t *local)
  function yespower_free_local (line 577) | int yespower_free_local(yespower_local_t *local)

FILE: src/crypto/yespower-1.0.1/yespower.h
  type yespower_region_t (line 44) | typedef struct {
  type yespower_region_t (line 52) | typedef yespower_region_t yespower_local_t;
  type yespower_version_t (line 57) | typedef enum { YESPOWER_0_5 = 5, YESPOWER_1_0 = 10 } yespower_version_t;
  type yespower_params_t (line 62) | typedef struct {
  type yespower_binary_t (line 72) | typedef struct {

FILE: src/cuckoocache.h
  function namespace (line 27) | namespace CuckooCache
  function contains (line 467) | inline bool contains(const Element& e, const bool erase) const

FILE: src/dbwrapper.cpp
  class CBitcoinLevelDBLogger (line 17) | class CBitcoinLevelDBLogger : public leveldb::Logger {
    method Logv (line 21) | void Logv(const char * format, va_list ap) override {
  function GetOptions (line 75) | static leveldb::Options GetOptions(size_t nCacheSize)
  type dbwrapper_private (line 196) | namespace dbwrapper_private {
    function HandleError (line 198) | void HandleError(const leveldb::Status& status)

FILE: src/dbwrapper.h
  function class (line 22) | class dbwrapper_error : public std::runtime_error
  function namespace (line 32) | namespace dbwrapper_private {
  function class (line 47) | class CDBBatch
  function class (line 117) | class CDBIterator
  function class (line 176) | class CDBWrapper

FILE: src/fs.cpp
  type fsbridge (line 3) | namespace fsbridge {
    function FILE (line 5) | FILE *fopen(const fs::path& p, const char *mode)
    function FILE (line 10) | FILE *freopen(const fs::path& p, const char *mode, FILE *stream)

FILE: src/fs.h
  function namespace (line 22) | namespace fsbridge {

FILE: src/hash.cpp
  function ROTL32 (line 10) | inline uint32_t ROTL32(uint32_t x, int8_t r)
  function MurmurHash3 (line 15) | unsigned int MurmurHash3(unsigned int nHashSeed, const std::vector<unsig...
  function BIP32Hash (line 71) | void BIP32Hash(const ChainCode &chainCode, unsigned int nChild, unsigned...
  function CSipHasher (line 102) | CSipHasher& CSipHasher::Write(uint64_t data)
  function CSipHasher (line 122) | CSipHasher& CSipHasher::Write(const unsigned char* data, size_t size)
  function SipHashUint256 (line 168) | uint64_t SipHashUint256(uint64_t k0, uint64_t k1, const uint256& val)
  function SipHashUint256Extra (line 208) | uint64_t SipHashUint256Extra(uint64_t k0, uint64_t k1, const uint256& va...

FILE: src/hash.h
  type uint256 (line 18) | typedef uint256 ChainCode;
  function class (line 21) | class CHash256 {
  function class (line 45) | class CHash160 {
  function uint256 (line 70) | uint256 Hash(const T1 pbegin, const T1 pend)
  function uint256 (line 81) | uint256 Hash(const T1 p1begin, const T1 p1end,
  function uint160 (line 93) | uint160 Hash160(const T1 pbegin, const T1 pend)
  function uint160 (line 103) | inline uint160 Hash160(const std::vector<unsigned char>& vch)
  function uint160 (line 110) | uint160 Hash160(const prevector<N, unsigned char>& vch)
  function class (line 116) | class CHashWriter
  function write (line 130) | void write(const char *pch, size_t size) {
  function uint256 (line 135) | uint256 GetHash() {
  function read (line 159) | void read(char* pch, size_t nSize)
  function ignore (line 165) | void ignore(size_t nSize)
  function class (line 198) | class CSipHasher

FILE: src/httprpc.cpp
  class HTTPRPCTimer (line 30) | class HTTPRPCTimer : public RPCTimerBase
    method HTTPRPCTimer (line 33) | HTTPRPCTimer(struct event_base* eventBase, std::function<void(void)>& ...
  class HTTPRPCTimerInterface (line 45) | class HTTPRPCTimerInterface : public RPCTimerInterface
    method HTTPRPCTimerInterface (line 48) | explicit HTTPRPCTimerInterface(struct event_base* _base) : base(_base)
    method RPCTimerBase (line 55) | RPCTimerBase* NewTimer(std::function<void(void)>& func, int64_t millis...
    type event_base (line 60) | struct event_base
  function JSONErrorReply (line 69) | static void JSONErrorReply(HTTPRequest* req, const UniValue& objError, c...
  function multiUserAuthorized (line 88) | static bool multiUserAuthorized(std::string strUserPass)
  function RPCAuthorized (line 127) | static bool RPCAuthorized(const std::string& strAuth, std::string& strAu...
  function HTTPReq_JSONRPC (line 147) | static bool HTTPReq_JSONRPC(HTTPRequest* req, const std::string &)
  function InitRPCAuthentication (line 213) | static bool InitRPCAuthentication()
  function StartHTTPRPC (line 231) | bool StartHTTPRPC()
  function InterruptHTTPRPC (line 248) | void InterruptHTTPRPC()
  function StopHTTPRPC (line 253) | void StopHTTPRPC()

FILE: src/httpserver.cpp
  class HTTPWorkItem (line 45) | class HTTPWorkItem final : public HTTPClosure
    method HTTPWorkItem (line 48) | HTTPWorkItem(std::unique_ptr<HTTPRequest> _req, const std::string &_pa...
  class WorkQueue (line 68) | class WorkQueue
    method WorkQueue (line 79) | explicit WorkQueue(size_t _maxDepth) : running(true),
    method Enqueue (line 89) | bool Enqueue(WorkItem* item)
    method Run (line 100) | void Run()
    method Interrupt (line 117) | void Interrupt()
  type HTTPPathHandler (line 125) | struct HTTPPathHandler
    method HTTPPathHandler (line 127) | HTTPPathHandler() {}
    method HTTPPathHandler (line 128) | HTTPPathHandler(std::string _prefix, bool _exactMatch, HTTPRequestHand...
  type event_base (line 140) | struct event_base
  type evhttp (line 142) | struct evhttp
  function ClientAllowed (line 153) | static bool ClientAllowed(const CNetAddr& netaddr)
  function InitHTTPAllowList (line 164) | static bool InitHTTPAllowList()
  function RequestMethodString (line 192) | static std::string RequestMethodString(HTTPRequest::RequestMethod m)
  function http_request_cb (line 213) | static void http_request_cb(struct evhttp_request* req, void* arg)
  function http_reject_request_cb (line 275) | static void http_reject_request_cb(struct evhttp_request* req, void*)
  function ThreadHTTP (line 282) | static bool ThreadHTTP(struct event_base* base, struct evhttp* http)
  function HTTPBindAddresses (line 293) | static bool HTTPBindAddresses(struct evhttp* http)
  function HTTPWorkQueueRun (line 331) | static void HTTPWorkQueueRun(WorkQueue<HTTPClosure>* queue)
  function libevent_log_cb (line 338) | static void libevent_log_cb(int severity, const char *msg)
  function InitHTTPServer (line 350) | bool InitHTTPServer()
  function UpdateHTTPServerLogging (line 408) | bool UpdateHTTPServerLogging(bool enable) {
  function StartHTTPServer (line 426) | bool StartHTTPServer()
  function InterruptHTTPServer (line 441) | void InterruptHTTPServer()
  function StopHTTPServer (line 456) | void StopHTTPServer()
  type event_base (line 495) | struct event_base
  function httpevent_callback_fn (line 500) | static void httpevent_callback_fn(evutil_socket_t, short, void* data)
  type event_base (line 509) | struct event_base
  type timeval (line 519) | struct timeval
  type evhttp_request (line 526) | struct evhttp_request
  type evkeyvalq (line 542) | struct evkeyvalq
  type evbuffer (line 553) | struct evbuffer
  type evkeyvalq (line 573) | struct evkeyvalq
  type evbuffer (line 587) | struct evbuffer
  function CService (line 610) | CService HTTPRequest::GetPeer()
  function RegisterHTTPHandler (line 650) | void RegisterHTTPHandler(const std::string &prefix, bool exactMatch, con...
  function UnregisterHTTPHandler (line 656) | void UnregisterHTTPHandler(const std::string &prefix, bool exactMatch)
  function urlDecode (line 670) | std::string urlDecode(const std::string &urlEncoded) {

FILE: src/httpserver.h
  type evhttp_request (line 16) | struct evhttp_request
  type event_base (line 17) | struct event_base
  type std (line 40) | typedef std::function<bool(HTTPRequest* req, const std::string &)> HTTPR...
  type event_base (line 52) | struct event_base
  function class (line 57) | class HTTPRequest
  function class (line 121) | class HTTPClosure
  function class (line 130) | class HTTPEvent

FILE: src/indirectmap.h
  function const (line 9) | bool operator()(const T a, const T b) const { return *a < *b; }
  type typename (line 28) | typedef typename base::const_iterator const_iterator;
  type typename (line 29) | typedef typename base::size_type size_type;
  type typename (line 30) | typedef typename base::value_type value_type;
  function iterator (line 36) | iterator find(const K& key)                     { return m.find(&key); }
  function const_iterator (line 37) | const_iterator find(const K& key) const         { return m.find(&key); }
  function iterator (line 38) | iterator lower_bound(const K& key)              { return m.lower_bound(&...
  function const_iterator (line 39) | const_iterator lower_bound(const K& key) const  { return m.lower_bound(&...
  function size_type (line 40) | size_type erase(const K& key)                   { return m.erase(&key); }
  function size_type (line 41) | size_type count(const K& key) const             { return m.count(&key); }
  function clear (line 47) | void clear()                    { m.clear(); }
  function iterator (line 48) | iterator begin()                { return m.begin(); }
  function iterator (line 49) | iterator end()                  { return m.end(); }

FILE: src/init.cpp
  function StartShutdown (line 122) | void StartShutdown()
  function ShutdownRequested (line 126) | bool ShutdownRequested()
  class CCoinsViewErrorCatcher (line 136) | class CCoinsViewErrorCatcher final : public CCoinsViewBacked
    method CCoinsViewErrorCatcher (line 139) | explicit CCoinsViewErrorCatcher(CCoinsView* view) : CCoinsViewBacked(v...
    method GetCoin (line 140) | bool GetCoin(const COutPoint &outpoint, Coin &coin) const override {
  function Interrupt (line 162) | void Interrupt()
  function Shutdown (line 173) | void Shutdown()
  function HandleSIGTERM (line 288) | static void HandleSIGTERM(int)
  function HandleSIGHUP (line 293) | static void HandleSIGHUP(int)
  function BOOL (line 298) | static BOOL WINAPI consoleCtrlHandler(DWORD dwCtrlType)
  function registerSignalHandler (line 307) | static void registerSignalHandler(int signal, void(*handler)(int))
  function OnRPCStarted (line 317) | void OnRPCStarted()
  function OnRPCStopped (line 322) | void OnRPCStopped()
  function HelpMessage (line 330) | std::string HelpMessage(HelpMessageMode mode)
  function LicenseInfo (line 530) | std::string LicenseInfo()
  function BlockNotifyCallback (line 566) | static void BlockNotifyCallback(bool initialSync, const CBlockIndex *pBl...
  function BlockNotifyGenesisWait (line 582) | static void BlockNotifyGenesisWait(bool, const CBlockIndex *pBlockIndex)
  type CImportingNow (line 593) | struct CImportingNow
    method CImportingNow (line 595) | CImportingNow() {
  function CleanupBlockRevFiles (line 613) | void CleanupBlockRevFiles()
  function ThreadImport (line 648) | void ThreadImport(std::vector<fs::path> vImportFiles)
  function InitSanityCheck (line 726) | bool InitSanityCheck(void)
  function AppInitServers (line 744) | bool AppInitServers()
  function InitParameterInteraction (line 762) | void InitParameterInteraction()
  function ResolveErrMsg (line 825) | static std::string ResolveErrMsg(const char * const optname, const std::...
  function InitLogging (line 830) | void InitLogging()
  function new_handler_terminate (line 857) | [[noreturn]] static void new_handler_terminate()
  function AppInitBasicSetup (line 870) | bool AppInitBasicSetup()
  function AppInitParameterInteraction (line 920) | bool AppInitParameterInteraction()
  function LockDataDirectory (line 1180) | static bool LockDataDirectory(bool probeOnly)
  function AppInitSanityChecks (line 1190) | bool AppInitSanityChecks()
  function AppInitLockDataDirectory (line 1211) | bool AppInitLockDataDirectory()
  function AppInitMain (line 1223) | bool AppInitMain()

FILE: src/init.h
  function namespace (line 14) | namespace boost
  type HelpMessageMode (line 60) | enum HelpMessageMode {

FILE: src/key.cpp
  function ec_privkey_import_der (line 35) | static int ec_privkey_import_der(const secp256k1_context* ctx, unsigned ...
  function ec_privkey_export_der (line 92) | static int ec_privkey_export_der(const secp256k1_context *ctx, unsigned ...
  function CPrivKey (line 166) | CPrivKey CKey::GetPrivKey() const {
  function CPubKey (line 179) | CPubKey CKey::GetPubKey() const {
  function CExtPubKey (line 287) | CExtPubKey CExtKey::Neuter() const {
  function ECC_InitSanityCheck (line 316) | bool ECC_InitSanityCheck() {
  function ECC_Start (line 323) | void ECC_Start() {
  function ECC_Stop (line 340) | void ECC_Stop() {

FILE: src/key.h
  type std (line 24) | typedef std::vector<unsigned char, secure_allocator<unsigned char> > CPr...
  function class (line 27) | class CKey
  function else (line 78) | else if (Check(&pbegin[0])) {
  function CPrivKey (line 105) | CPrivKey GetPrivKey() const;

FILE: src/keystore.cpp
  function ExtractPubKey (line 128) | static bool ExtractPubKey(const CScript &dest, CPubKey& pubKeyOut)
  function CKeyID (line 181) | CKeyID GetKeyForDestination(const CKeyStore& store, const CTxDestination...

FILE: src/keystore.h
  function virtual (line 33) | virtual std::set<CKeyID> GetKeys() const =0;
  type std (line 82) | typedef std::vector<unsigned char, secure_allocator<unsigned char> > CKe...
  type std (line 83) | typedef std::map<CKeyID, std::pair<CPubKey, std::vector<unsigned char> >...

FILE: src/leveldb/db/autocompact_test.cc
  type leveldb (line 11) | namespace leveldb {
    class AutoCompactTest (line 13) | class AutoCompactTest {
      method AutoCompactTest (line 20) | AutoCompactTest() {
      method Key (line 36) | std::string Key(int i) {
      method Size (line 42) | uint64_t Size(const Slice& start, const Slice& limit) {
    function TEST (line 106) | TEST(AutoCompactTest, ReadAll) {
    function TEST (line 110) | TEST(AutoCompactTest, ReadHalf) {
  function main (line 116) | int main(int argc, char** argv) {

FILE: src/leveldb/db/builder.cc
  type leveldb (line 15) | namespace leveldb {
    function Status (line 17) | Status BuildTable(const std::string& dbname,

FILE: src/leveldb/db/builder.h
  function namespace (line 10) | namespace leveldb {

FILE: src/leveldb/db/c.cc
  type leveldb_t (line 46) | struct leveldb_t              { DB*               rep; }
  type leveldb_iterator_t (line 47) | struct leveldb_iterator_t     { Iterator*         rep; }
  type leveldb_writebatch_t (line 48) | struct leveldb_writebatch_t   { WriteBatch        rep; }
  type leveldb_snapshot_t (line 49) | struct leveldb_snapshot_t     { const Snapshot*   rep; }
  type leveldb_readoptions_t (line 50) | struct leveldb_readoptions_t  { ReadOptions       rep; }
  type leveldb_writeoptions_t (line 51) | struct leveldb_writeoptions_t { WriteOptions      rep; }
  type leveldb_options_t (line 52) | struct leveldb_options_t      { Options           rep; }
  type leveldb_cache_t (line 53) | struct leveldb_cache_t        { Cache*            rep; }
  type leveldb_seqfile_t (line 54) | struct leveldb_seqfile_t      { SequentialFile*   rep; }
  type leveldb_randomfile_t (line 55) | struct leveldb_randomfile_t   { RandomAccessFile* rep; }
  type leveldb_writablefile_t (line 56) | struct leveldb_writablefile_t { WritableFile*     rep; }
  type leveldb_logger_t (line 57) | struct leveldb_logger_t       { Logger*           rep; }
  type leveldb_filelock_t (line 58) | struct leveldb_filelock_t     { FileLock*         rep; }
  type leveldb_comparator_t (line 60) | struct leveldb_comparator_t : public Comparator {
    method Compare (line 73) | virtual int Compare(const Slice& a, const Slice& b) const {
    method FindShortestSeparator (line 82) | virtual void FindShortestSeparator(std::string*, const Slice&) const { }
    method FindShortSuccessor (line 83) | virtual void FindShortSuccessor(std::string* key) const { }
  type leveldb_filterpolicy_t (line 86) | struct leveldb_filterpolicy_t : public FilterPolicy {
    method CreateFilter (line 108) | virtual void CreateFilter(const Slice* keys, int n, std::string* dst) ...
    method KeyMayMatch (line 121) | virtual bool KeyMayMatch(const Slice& key, const Slice& filter) const {
  type leveldb_env_t (line 127) | struct leveldb_env_t {
  function SaveError (line 132) | static bool SaveError(char** errptr, const Status& s) {
  function leveldb_t (line 152) | leveldb_t* leveldb_open(
  function leveldb_close (line 165) | void leveldb_close(leveldb_t* db) {
  function leveldb_put (line 170) | void leveldb_put(
  function leveldb_delete (line 180) | void leveldb_delete(
  function leveldb_write (line 189) | void leveldb_write(
  function leveldb_iterator_t (line 218) | leveldb_iterator_t* leveldb_create_iterator(
  function leveldb_snapshot_t (line 226) | const leveldb_snapshot_t* leveldb_create_snapshot(
  function leveldb_release_snapshot (line 233) | void leveldb_release_snapshot(
  function leveldb_approximate_sizes (line 252) | void leveldb_approximate_sizes(
  function leveldb_compact_range (line 267) | void leveldb_compact_range(
  function leveldb_destroy_db (line 278) | void leveldb_destroy_db(
  function leveldb_repair_db (line 285) | void leveldb_repair_db(
  function leveldb_iter_destroy (line 292) | void leveldb_iter_destroy(leveldb_iterator_t* iter) {
  function leveldb_iter_valid (line 297) | unsigned char leveldb_iter_valid(const leveldb_iterator_t* iter) {
  function leveldb_iter_seek_to_first (line 301) | void leveldb_iter_seek_to_first(leveldb_iterator_t* iter) {
  function leveldb_iter_seek_to_last (line 305) | void leveldb_iter_seek_to_last(leveldb_iterator_t* iter) {
  function leveldb_iter_seek (line 309) | void leveldb_iter_seek(leveldb_iterator_t* iter, const char* k, size_t k...
  function leveldb_iter_next (line 313) | void leveldb_iter_next(leveldb_iterator_t* iter) {
  function leveldb_iter_prev (line 317) | void leveldb_iter_prev(leveldb_iterator_t* iter) {
  function leveldb_iter_get_error (line 333) | void leveldb_iter_get_error(const leveldb_iterator_t* iter, char** errpt...
  function leveldb_writebatch_t (line 337) | leveldb_writebatch_t* leveldb_writebatch_create() {
  function leveldb_writebatch_destroy (line 341) | void leveldb_writebatch_destroy(leveldb_writebatch_t* b) {
  function leveldb_writebatch_clear (line 345) | void leveldb_writebatch_clear(leveldb_writebatch_t* b) {
  function leveldb_writebatch_put (line 349) | void leveldb_writebatch_put(
  function leveldb_writebatch_delete (line 356) | void leveldb_writebatch_delete(
  function leveldb_writebatch_iterate (line 362) | void leveldb_writebatch_iterate(
  function leveldb_options_t (line 386) | leveldb_options_t* leveldb_options_create() {
  function leveldb_options_destroy (line 390) | void leveldb_options_destroy(leveldb_options_t* options) {
  function leveldb_options_set_comparator (line 394) | void leveldb_options_set_comparator(
  function leveldb_options_set_filter_policy (line 400) | void leveldb_options_set_filter_policy(
  function leveldb_options_set_create_if_missing (line 406) | void leveldb_options_set_create_if_missing(
  function leveldb_options_set_error_if_exists (line 411) | void leveldb_options_set_error_if_exists(
  function leveldb_options_set_paranoid_checks (line 416) | void leveldb_options_set_paranoid_checks(
  function leveldb_options_set_env (line 421) | void leveldb_options_set_env(leveldb_options_t* opt, leveldb_env_t* env) {
  function leveldb_options_set_info_log (line 425) | void leveldb_options_set_info_log(leveldb_options_t* opt, leveldb_logger...
  function leveldb_options_set_write_buffer_size (line 429) | void leveldb_options_set_write_buffer_size(leveldb_options_t* opt, size_...
  function leveldb_options_set_max_open_files (line 433) | void leveldb_options_set_max_open_files(leveldb_options_t* opt, int n) {
  function leveldb_options_set_cache (line 437) | void leveldb_options_set_cache(leveldb_options_t* opt, leveldb_cache_t* ...
  function leveldb_options_set_block_size (line 441) | void leveldb_options_set_block_size(leveldb_options_t* opt, size_t s) {
  function leveldb_options_set_block_restart_interval (line 445) | void leveldb_options_set_block_restart_interval(leveldb_options_t* opt, ...
  function leveldb_options_set_compression (line 449) | void leveldb_options_set_compression(leveldb_options_t* opt, int t) {
  function leveldb_comparator_t (line 453) | leveldb_comparator_t* leveldb_comparator_create(
    method Compare (line 73) | virtual int Compare(const Slice& a, const Slice& b) const {
    method FindShortestSeparator (line 82) | virtual void FindShortestSeparator(std::string*, const Slice&) const { }
    method FindShortSuccessor (line 83) | virtual void FindShortSuccessor(std::string* key) const { }
  function leveldb_comparator_destroy (line 469) | void leveldb_comparator_destroy(leveldb_comparator_t* cmp) {
  function leveldb_filterpolicy_t (line 473) | leveldb_filterpolicy_t* leveldb_filterpolicy_create(
    method CreateFilter (line 108) | virtual void CreateFilter(const Slice* keys, int n, std::string* dst) ...
    method KeyMayMatch (line 121) | virtual bool KeyMayMatch(const Slice& key, const Slice& filter) const {
  function leveldb_filterpolicy_destroy (line 495) | void leveldb_filterpolicy_destroy(leveldb_filterpolicy_t* filter) {
  function leveldb_filterpolicy_t (line 499) | leveldb_filterpolicy_t* leveldb_filterpolicy_create_bloom(int bits_per_k...
    method CreateFilter (line 108) | virtual void CreateFilter(const Slice* keys, int n, std::string* dst) ...
    method KeyMayMatch (line 121) | virtual bool KeyMayMatch(const Slice& key, const Slice& filter) const {
  function leveldb_readoptions_t (line 522) | leveldb_readoptions_t* leveldb_readoptions_create() {
  function leveldb_readoptions_destroy (line 526) | void leveldb_readoptions_destroy(leveldb_readoptions_t* opt) {
  function leveldb_readoptions_set_verify_checksums (line 530) | void leveldb_readoptions_set_verify_checksums(
  function leveldb_readoptions_set_fill_cache (line 536) | void leveldb_readoptions_set_fill_cache(
  function leveldb_readoptions_set_snapshot (line 541) | void leveldb_readoptions_set_snapshot(
  function leveldb_writeoptions_t (line 547) | leveldb_writeoptions_t* leveldb_writeoptions_create() {
  function leveldb_writeoptions_destroy (line 551) | void leveldb_writeoptions_destroy(leveldb_writeoptions_t* opt) {
  function leveldb_writeoptions_set_sync (line 555) | void leveldb_writeoptions_set_sync(
  function leveldb_cache_t (line 560) | leveldb_cache_t* leveldb_cache_create_lru(size_t capacity) {
  function leveldb_cache_destroy (line 566) | void leveldb_cache_destroy(leveldb_cache_t* cache) {
  function leveldb_env_t (line 571) | leveldb_env_t* leveldb_create_default_env() {
  function leveldb_env_destroy (line 578) | void leveldb_env_destroy(leveldb_env_t* env) {
  function leveldb_free (line 583) | void leveldb_free(void* ptr) {
  function leveldb_major_version (line 587) | int leveldb_major_version() {
  function leveldb_minor_version (line 591) | int leveldb_minor_version() {

FILE: src/leveldb/db/c_test.c
  function StartPhase (line 17) | static void StartPhase(const char* name) {
  function CheckEqual (line 41) | static void CheckEqual(const char* expected, const char* v, size_t n) {
  function Free (line 57) | static void Free(char** ptr) {
  function CheckGet (line 64) | static void CheckGet(
  function CheckIter (line 78) | static void CheckIter(leveldb_iterator_t* iter,
  function CheckPut (line 89) | static void CheckPut(void* ptr,
  function CheckDel (line 108) | static void CheckDel(void* ptr, const char* k, size_t klen) {
  function CmpDestroy (line 115) | static void CmpDestroy(void* arg) { }
  function CmpCompare (line 117) | static int CmpCompare(void* arg, const char* a, size_t alen,
  function FilterDestroy (line 134) | static void FilterDestroy(void* arg) { }
  function FilterKeyMatch (line 148) | unsigned char FilterKeyMatch(
  function main (line 157) | int main(int argc, char** argv) {

FILE: src/leveldb/db/corruption_test.cc
  type leveldb (line 23) | namespace leveldb {
    class CorruptionTest (line 27) | class CorruptionTest {
      method CorruptionTest (line 35) | CorruptionTest() {
      method Status (line 54) | Status TryReopen() {
      method Reopen (line 60) | void Reopen() {
      method RepairDB (line 64) | void RepairDB() {
      method Build (line 70) | void Build(int n) {
      method Check (line 88) | void Check(int min_expected, int max_expected) {
      method Corrupt (line 126) | void Corrupt(FileType filetype, int offset, int bytes_to_corrupt) {
      method Property (line 176) | int Property(const std::string& name) {
      method Slice (line 188) | Slice Key(int i, std::string* storage) {
      method Slice (line 196) | Slice Value(int k, std::string* storage) {
    function TEST (line 202) | TEST(CorruptionTest, Recovery) {
    function TEST (line 213) | TEST(CorruptionTest, RecoverWriteError) {
    function TEST (line 219) | TEST(CorruptionTest, NewFileErrorDuringWrite) {
    function TEST (line 236) | TEST(CorruptionTest, TableFile) {
    function TEST (line 247) | TEST(CorruptionTest, TableFileRepair) {
    function TEST (line 263) | TEST(CorruptionTest, TableFileIndexData) {
    function TEST (line 273) | TEST(CorruptionTest, MissingDescriptor) {
    function TEST (line 280) | TEST(CorruptionTest, SequenceNumberRecovery) {
    function TEST (line 301) | TEST(CorruptionTest, CorruptedDescriptor) {
    function TEST (line 318) | TEST(CorruptionTest, CompactionInputError) {
    function TEST (line 333) | TEST(CorruptionTest, CompactionInputErrorParanoid) {
    function TEST (line 354) | TEST(CorruptionTest, UnrelatedKeys) {
  function main (line 372) | int main(int argc, char** argv) {

FILE: src/leveldb/db/db_bench.cc
  type leveldb (line 117) | namespace leveldb {
    class RandomGenerator (line 123) | class RandomGenerator {
      method RandomGenerator (line 129) | RandomGenerator() {
      method Slice (line 144) | Slice Generate(size_t len) {
    function Slice (line 155) | static Slice TrimSpace(Slice s) {
    function AppendWithSpace (line 168) | static void AppendWithSpace(std::string* str, Slice msg) {
    class Stats (line 176) | class Stats {
      method Stats (line 189) | Stats() { Start(); }
      method Start (line 191) | void Start() {
      method Merge (line 203) | void Merge(const Stats& other) {
      method Stop (line 215) | void Stop() {
      method AddMessage (line 220) | void AddMessage(Slice msg) {
      method FinishedSingleOp (line 224) | void FinishedSingleOp() {
      method AddBytes (line 250) | void AddBytes(int64_t n) {
      method Report (line 254) | void Report(const Slice& name) {
    type SharedState (line 284) | struct SharedState {
      method SharedState (line 299) | SharedState() : cv(&mu) { }
    type ThreadState (line 303) | struct ThreadState {
      method ThreadState (line 309) | ThreadState(int index)
    class Benchmark (line 317) | class Benchmark {
      method PrintHeader (line 329) | void PrintHeader() {
      method PrintWarnings (line 347) | void PrintWarnings() {
      method PrintEnvironment (line 368) | void PrintEnvironment() {
      method Benchmark (line 404) | Benchmark()
      method Run (line 433) | void Run() {
      type ThreadArg (line 551) | struct ThreadArg {
      method ThreadBody (line 558) | static void ThreadBody(void* v) {
      method RunBenchmark (line 586) | void RunBenchmark(int n, Slice name,
      method Crc32c (line 627) | void Crc32c(ThreadState* thread) {
      method AcquireLoad (line 646) | void AcquireLoad(ThreadState* thread) {
      method SnappyCompress (line 662) | void SnappyCompress(ThreadState* thread) {
      method SnappyUncompress (line 687) | void SnappyUncompress(ThreadState* thread) {
      method Open (line 709) | void Open() {
      method OpenBench (line 728) | void OpenBench(ThreadState* thread) {
      method WriteSeq (line 736) | void WriteSeq(ThreadState* thread) {
      method WriteRandom (line 740) | void WriteRandom(ThreadState* thread) {
      method DoWrite (line 744) | void DoWrite(ThreadState* thread, bool seq) {
      method ReadSequential (line 774) | void ReadSequential(ThreadState* thread) {
      method ReadReverse (line 787) | void ReadReverse(ThreadState* thread) {
      method ReadRandom (line 800) | void ReadRandom(ThreadState* thread) {
      method ReadMissing (line 818) | void ReadMissing(ThreadState* thread) {
      method ReadHot (line 830) | void ReadHot(ThreadState* thread) {
      method SeekRandom (line 843) | void SeekRandom(ThreadState* thread) {
      method DoDelete (line 861) | void DoDelete(ThreadState* thread, bool seq) {
      method DeleteSeq (line 882) | void DeleteSeq(ThreadState* thread) {
      method DeleteRandom (line 886) | void DeleteRandom(ThreadState* thread) {
      method ReadWhileWriting (line 890) | void ReadWhileWriting(ThreadState* thread) {
      method Compact (line 920) | void Compact(ThreadState* thread) {
      method PrintStats (line 924) | void PrintStats(const char* key) {
      method WriteToFile (line 932) | static void WriteToFile(void* arg, const char* buf, int n) {
      method HeapProfile (line 936) | void HeapProfile() {
  function main (line 956) | int main(int argc, char** argv) {

FILE: src/leveldb/db/db_impl.cc
  type leveldb (line 36) | namespace leveldb {
    type DBImpl::Writer (line 41) | struct DBImpl::Writer {
      method Writer (line 48) | explicit Writer(port::Mutex* mu) : cv(mu) { }
    type DBImpl::CompactionState (line 51) | struct DBImpl::CompactionState {
      type Output (line 61) | struct Output {
      method Output (line 74) | Output* current_output() { return &outputs[outputs.size()-1]; }
      method CompactionState (line 76) | explicit CompactionState(Compaction* c)
    function ClipToRange (line 86) | static void ClipToRange(T* ptr, V minvalue, V maxvalue) {
    function Options (line 90) | Options SanitizeOptions(const std::string& dbname,
    function Status (line 177) | Status DBImpl::NewDB() {
    function Status (line 274) | Status DBImpl::Recover(VersionEdit* edit, bool *save_manifest) {
    function Status (line 365) | Status DBImpl::RecoverLogFile(uint64_t log_number, bool last_log,
    function Status (line 488) | Status DBImpl::WriteLevel0Table(MemTable* mem, VersionEdit* edit,
    function Status (line 621) | Status DBImpl::TEST_CompactMemTable() {
    function Status (line 788) | Status DBImpl::OpenCompactionOutputFile(CompactionState* compact) {
    function Status (line 813) | Status DBImpl::FinishCompactionOutputFile(CompactionState* compact,
    function Status (line 866) | Status DBImpl::InstallCompactionResults(CompactionState* compact) {
    function Status (line 887) | Status DBImpl::DoCompactionWork(CompactionState* compact) {
    type IterState (line 1049) | struct IterState {
    function CleanupIteratorState (line 1056) | static void CleanupIteratorState(void* arg1, void* arg2) {
    function Iterator (line 1067) | Iterator* DBImpl::NewInternalIterator(const ReadOptions& options,
    function Iterator (line 1098) | Iterator* DBImpl::TEST_NewInternalIterator() {
    function Status (line 1109) | Status DBImpl::Get(const ReadOptions& options,
    function Iterator (line 1156) | Iterator* DBImpl::NewIterator(const ReadOptions& options) {
    function Snapshot (line 1175) | const Snapshot* DBImpl::GetSnapshot() {
    function Status (line 1186) | Status DBImpl::Put(const WriteOptions& o, const Slice& key, const Slic...
    function Status (line 1190) | Status DBImpl::Delete(const WriteOptions& options, const Slice& key) {
    function Status (line 1194) | Status DBImpl::Write(const WriteOptions& options, WriteBatch* my_batch) {
    function WriteBatch (line 1269) | WriteBatch* DBImpl::BuildBatchGroup(Writer** last_writer) {
    function Status (line 1318) | Status DBImpl::MakeRoomForWrite(bool force) {
    function Status (line 1476) | Status DB::Put(const WriteOptions& opt, const Slice& key, const Slice&...
    function Status (line 1482) | Status DB::Delete(const WriteOptions& opt, const Slice& key) {
    function Status (line 1490) | Status DB::Open(const Options& options, const std::string& dbname,
    function Status (line 1537) | Status DestroyDB(const std::string& dbname, const Options& options) {

FILE: src/leveldb/db/db_impl.h
  type CompactionState (line 69) | struct CompactionState
  type Writer (line 70) | struct Writer
  type ManualCompaction (line 162) | struct ManualCompaction {
  type CompactionStats (line 178) | struct CompactionStats {

FILE: src/leveldb/db/db_iter.cc
  type leveldb (line 17) | namespace leveldb {
    function DumpInternalIter (line 20) | static void DumpInternalIter(Iterator* iter) {
    class DBIter (line 39) | class DBIter: public Iterator {
      type Direction (line 46) | enum Direction {
      method DBIter (line 51) | DBIter(DBImpl* db, const Comparator* cmp, Iterator* iter, SequenceNu...
      method Valid (line 65) | virtual bool Valid() const { return valid_; }
      method Slice (line 66) | virtual Slice key() const {
      method Slice (line 70) | virtual Slice value() const {
      method Status (line 74) | virtual Status status() const {
      method SaveKey (line 93) | inline void SaveKey(const Slice& k, std::string* dst) {
      method ClearSavedValue (line 97) | inline void ClearSavedValue() {
      method RandomPeriod (line 107) | ssize_t RandomPeriod() {
    function Iterator (line 308) | Iterator* NewDBIterator(

FILE: src/leveldb/db/db_iter.h
  function namespace (line 12) | namespace leveldb {

FILE: src/leveldb/db/db_test.cc
  type leveldb (line 20) | namespace leveldb {
    function RandomString (line 22) | static std::string RandomString(Random* rnd, int len) {
    class AtomicCounter (line 29) | class AtomicCounter {
      method AtomicCounter (line 34) | AtomicCounter() : count_(0) { }
      method Increment (line 35) | void Increment() {
      method IncrementBy (line 38) | void IncrementBy(int count) {
      method Read (line 42) | int Read() {
      method Reset (line 46) | void Reset() {
    function DelayMilliseconds (line 52) | void DelayMilliseconds(int millis) {
    class SpecialEnv (line 58) | class SpecialEnv : public EnvWrapper {
      method SpecialEnv (line 81) | explicit SpecialEnv(Env* base) : EnvWrapper(base) {
      method Status (line 91) | Status NewWritableFile(const std::string& f, WritableFile** r) {
      method Status (line 164) | Status NewRandomAccessFile(const std::string& f, RandomAccessFile** ...
    class DBTest (line 189) | class DBTest {
      type OptionConfig (line 194) | enum OptionConfig {
      method DBTest (line 210) | DBTest() : option_config_(kDefault),
      method ChangeOptions (line 228) | bool ChangeOptions() {
      method Options (line 239) | Options CurrentOptions() {
      method DBImpl (line 258) | DBImpl* dbfull() {
      method Reopen (line 262) | void Reopen(Options* options = NULL) {
      method Close (line 266) | void Close() {
      method DestroyAndReopen (line 271) | void DestroyAndReopen(Options* options = NULL) {
      method Status (line 278) | Status TryReopen(Options* options) {
      method Status (line 293) | Status Put(const std::string& k, const std::string& v) {
      method Status (line 297) | Status Delete(const std::string& k) {
      method Get (line 301) | std::string Get(const std::string& k, const Snapshot* snapshot = NUL...
      method Contents (line 316) | std::string Contents() {
      method AllEntriesFor (line 341) | std::string AllEntriesFor(const Slice& user_key) {
      method NumTableFilesAtLevel (line 383) | int NumTableFilesAtLevel(int level) {
      method TotalTableFiles (line 391) | int TotalTableFiles() {
      method FilesPerLevel (line 400) | std::string FilesPerLevel() {
      method CountFiles (line 416) | int CountFiles() {
      method Size (line 422) | uint64_t Size(const Slice& start, const Slice& limit) {
      method Compact (line 429) | void Compact(const Slice& start, const Slice& limit) {
      method MakeTables (line 435) | void MakeTables(int n, const std::string& small, const std::string& ...
      method FillLevels (line 445) | void FillLevels(const std::string& smallest, const std::string& larg...
      method DumpFileCounts (line 449) | void DumpFileCounts(const char* label) {
      method DumpSSTableList (line 462) | std::string DumpSSTableList() {
      method IterStatus (line 468) | std::string IterStatus(Iterator* iter) {
      method DeleteAnSSTFile (line 478) | bool DeleteAnSSTFile() {
      method RenameLDBToSST (line 493) | int RenameLDBToSST() {
    function TEST (line 511) | TEST(DBTest, Empty) {
    function TEST (line 518) | TEST(DBTest, ReadWrite) {
    function TEST (line 529) | TEST(DBTest, PutDeleteGet) {
    function TEST (line 540) | TEST(DBTest, GetFromImmutableLayer) {
    function TEST (line 558) | TEST(DBTest, GetFromVersions) {
    function TEST (line 566) | TEST(DBTest, GetMemUsage) {
    function TEST (line 577) | TEST(DBTest, GetSnapshot) {
    function TEST (line 595) | TEST(DBTest, GetLevel0Ordering) {
    function TEST (line 610) | TEST(DBTest, GetOrderedByLevels) {
    function TEST (line 622) | TEST(DBTest, GetPicksCorrectFile) {
    function TEST (line 637) | TEST(DBTest, GetEncountersEmptyLevel) {
    function TEST (line 676) | TEST(DBTest, IterEmpty) {
    function TEST (line 691) | TEST(DBTest, IterSingle) {
    function TEST (line 729) | TEST(DBTest, IterMulti) {
    function TEST (line 812) | TEST(DBTest, IterSmallAndLargeMix) {
    function TEST (line 850) | TEST(DBTest, IterMultiWithDelete) {
    function TEST (line 867) | TEST(DBTest, Recover) {
    function TEST (line 889) | TEST(DBTest, RecoveryWithEmptyLog) {
    function TEST (line 903) | TEST(DBTest, RecoverDuringMemtableCompaction) {
    function Key (line 924) | static std::string Key(int i) {
    function TEST (line 930) | TEST(DBTest, MinorCompactionsHappen) {
    function TEST (line 955) | TEST(DBTest, RecoverWithLargeLog) {
    function TEST (line 979) | TEST(DBTest, CompactionsGenerateMultipleFiles) {
    function TEST (line 1005) | TEST(DBTest, RepeatedWritesToSameKey) {
    function TEST (line 1024) | TEST(DBTest, SparseMerge) {
    function Between (line 1064) | static bool Between(uint64_t val, uint64_t low, uint64_t high) {
    function TEST (line 1075) | TEST(DBTest, ApproximateSizes) {
    function TEST (line 1133) | TEST(DBTest, ApproximateSizes_MixOfSmallAndLarge) {
    function TEST (line 1176) | TEST(DBTest, IteratorPinsRef) {
    function TEST (line 1198) | TEST(DBTest, Snapshot) {
    function TEST (line 1227) | TEST(DBTest, HiddenValuesAreRemoved) {
    function TEST (line 1258) | TEST(DBTest, DeletionMarkers1) {
    function TEST (line 1287) | TEST(DBTest, DeletionMarkers2) {
    function TEST (line 1313) | TEST(DBTest, OverlapInLevel0) {
    function TEST (line 1354) | TEST(DBTest, L0_CompactionBug_Issue44_a) {
    function TEST (line 1371) | TEST(DBTest, L0_CompactionBug_Issue44_b) {
    function TEST (line 1397) | TEST(DBTest, ComparatorCheck) {
    function TEST (line 1420) | TEST(DBTest, CustomComparator) {
    function TEST (line 1475) | TEST(DBTest, ManualCompaction) {
    function TEST (line 1509) | TEST(DBTest, DBOpen_Options) {
    function TEST (line 1548) | TEST(DBTest, Locking) {
    function TEST (line 1555) | TEST(DBTest, NoSpace) {
    function TEST (line 1574) | TEST(DBTest, NonWritableFileSystem) {
    function TEST (line 1594) | TEST(DBTest, WriteSyncError) {
    function TEST (line 1625) | TEST(DBTest, ManifestWriteError) {
    function TEST (line 1666) | TEST(DBTest, MissingSSTFile) {
    function TEST (line 1684) | TEST(DBTest, StillReadSST) {
    function TEST (line 1700) | TEST(DBTest, FilesDeletedAfterCompaction) {
    function TEST (line 1711) | TEST(DBTest, BloomFilter) {
    type MTState (line 1765) | struct MTState {
    type MTThread (line 1772) | struct MTThread {
    function MTThreadBody (line 1777) | static void MTThreadBody(void* arg) {
    function TEST (line 1824) | TEST(DBTest, MultiThreaded) {
    class ModelDB (line 1860) | class ModelDB: public DB {
      class ModelSnapshot (line 1862) | class ModelSnapshot : public Snapshot {
      method ModelDB (line 1867) | explicit ModelDB(const Options& options): options_(options) { }
      method Status (line 1869) | virtual Status Put(const WriteOptions& o, const Slice& k, const Slic...
      method Status (line 1872) | virtual Status Delete(const WriteOptions& o, const Slice& key) {
      method Status (line 1875) | virtual Status Get(const ReadOptions& options,
      method Iterator (line 1880) | virtual Iterator* NewIterator(const ReadOptions& options) {
      method Snapshot (line 1891) | virtual const Snapshot* GetSnapshot() {
      method ReleaseSnapshot (line 1897) | virtual void ReleaseSnapshot(const Snapshot* snapshot) {
      method Status (line 1900) | virtual Status Write(const WriteOptions& options, WriteBatch* batch) {
      method GetProperty (line 1916) | virtual bool GetProperty(const Slice& property, std::string* value) {
      method GetApproximateSizes (line 1919) | virtual void GetApproximateSizes(const Range* r, int n, uint64_t* si...
      method CompactRange (line 1924) | virtual void CompactRange(const Slice* start, const Slice* end) {
      class ModelIter (line 1928) | class ModelIter: public Iterator {
        method ModelIter (line 1930) | ModelIter(const KVMap* map, bool owned)
        method Valid (line 1936) | virtual bool Valid() const { return iter_ != map_->end(); }
        method SeekToFirst (line 1937) | virtual void SeekToFirst() { iter_ = map_->begin(); }
        method SeekToLast (line 1938) | virtual void SeekToLast() {
        method Seek (line 1945) | virtual void Seek(const Slice& k) {
        method Next (line 1948) | virtual void Next() { ++iter_; }
        method Prev (line 1949) | virtual void Prev() { --iter_; }
        method Slice (line 1950) | virtual Slice key() const { return iter_->first; }
        method Slice (line 1951) | virtual Slice value() const { return iter_->second; }
        method Status (line 1952) | virtual Status status() const { return Status::OK(); }
    function RandomKey (line 1962) | static std::string RandomKey(Random* rnd) {
    function CompareIterators (line 1969) | static bool CompareIterators(int step,
    function TEST (line 2017) | TEST(DBTest, Randomized) {
    function MakeKey (line 2088) | std::string MakeKey(unsigned int num) {
    function BM_LogAndApply (line 2094) | void BM_LogAndApply(int iters, int num_base_files) {
  function main (line 2148) | int main(int argc, char** argv) {

FILE: src/leveldb/db/dbformat.cc
  type leveldb (line 10) | namespace leveldb {
    function PackSequenceAndType (line 12) | static uint64_t PackSequenceAndType(uint64_t seq, ValueType t) {
    function AppendInternalKey (line 18) | void AppendInternalKey(std::string* result, const ParsedInternalKey& k...

FILE: src/leveldb/db/dbformat.h
  function namespace (line 17) | namespace leveldb {

FILE: src/leveldb/db/dbformat_test.cc
  type leveldb (line 9) | namespace leveldb {
    function IKey (line 11) | static std::string IKey(const std::string& user_key,
    function Shorten (line 19) | static std::string Shorten(const std::string& s, const std::string& l) {
    function ShortSuccessor (line 25) | static std::string ShortSuccessor(const std::string& s) {
    function TestKey (line 31) | static void TestKey(const std::string& key,
    class FormatTest (line 47) | class FormatTest { }
    function TEST (line 49) | TEST(FormatTest, InternalKey_EncodeDecode) {
    function TEST (line 65) | TEST(FormatTest, InternalKeyShortSeparator) {
    function TEST (line 101) | TEST(FormatTest, InternalKeyShortestSuccessor) {
  function main (line 110) | int main(int argc, char** argv) {

FILE: src/leveldb/db/dumpfile.cc
  type leveldb (line 19) | namespace leveldb {
    function GuessType (line 23) | bool GuessType(const std::string& fname, FileType* type) {
    class CorruptionReporter (line 36) | class CorruptionReporter : public log::Reader::Reporter {
      method Corruption (line 39) | virtual void Corruption(size_t bytes, const Status& status) {
    function Status (line 50) | Status PrintLogContents(Env* env, const std::string& fname,
    class WriteBatchItemPrinter (line 71) | class WriteBatchItemPrinter : public WriteBatch::Handler {
      method Put (line 74) | virtual void Put(const Slice& key, const Slice& value) {
      method Delete (line 82) | virtual void Delete(const Slice& key) {
    function WriteBatchPrinter (line 93) | static void WriteBatchPrinter(uint64_t pos, Slice record, WritableFile...
    function Status (line 118) | Status DumpLog(Env* env, const std::string& fname, WritableFile* dst) {
    function VersionEditPrinter (line 124) | static void VersionEditPrinter(uint64_t pos, Slice record, WritableFil...
    function Status (line 139) | Status DumpDescriptor(Env* env, const std::string& fname, WritableFile...
    function Status (line 143) | Status DumpTable(Env* env, const std::string& fname, WritableFile* dst) {
    function Status (line 210) | Status DumpFile(Env* env, const std::string& fname, WritableFile* dst) {

FILE: src/leveldb/db/fault_injection_test.cc
  type leveldb (line 26) | namespace leveldb {
    class FaultInjectionTestEnv (line 32) | class FaultInjectionTestEnv
      method FaultInjectionTestEnv (line 129) | FaultInjectionTestEnv() : EnvWrapper(Env::Default()), filesystem_act...
      method IsFilesystemActive (line 149) | bool IsFilesystemActive() const { return filesystem_active_; }
      method SetFilesystemActive (line 150) | void SetFilesystemActive(bool active) { filesystem_active_ = active; }
    function GetDirName (line 37) | static std::string GetDirName(const std::string filename) {
    function Status (line 46) | Status SyncDir(const std::string& dir) {
    function Status (line 52) | Status Truncate(const std::string& filename, uint64_t length) {
    type FileState (line 84) | struct FileState {
      method FileState (line 90) | FileState(const std::string& filename)
      method FileState (line 96) | FileState() : pos_(-1), pos_at_last_sync_(-1), pos_at_last_flush_(-1...
      method IsFullySynced (line 98) | bool IsFullySynced() const { return pos_ <= 0 || pos_ == pos_at_last...
    class TestWritableFile (line 107) | class TestWritableFile : public WritableFile {
    class FaultInjectionTestEnv (line 127) | class FaultInjectionTestEnv : public EnvWrapper {
      method FaultInjectionTestEnv (line 129) | FaultInjectionTestEnv() : EnvWrapper(Env::Default()), filesystem_act...
      method IsFilesystemActive (line 149) | bool IsFilesystemActive() const { return filesystem_active_; }
      method SetFilesystemActive (line 150) | void SetFilesystemActive(bool active) { filesystem_active_ = active; }
    function Status (line 176) | Status TestWritableFile::Append(const Slice& data) {
    function Status (line 184) | Status TestWritableFile::Close() {
    function Status (line 193) | Status TestWritableFile::Flush() {
    function Status (line 201) | Status TestWritableFile::SyncParent() {
    function Status (line 209) | Status TestWritableFile::Sync() {
    function Status (line 227) | Status FaultInjectionTestEnv::NewWritableFile(const std::string& fname,
    function Status (line 245) | Status FaultInjectionTestEnv::NewAppendableFile(const std::string& fname,
    function Status (line 265) | Status FaultInjectionTestEnv::DropUnsyncedFileData() {
    function Status (line 297) | Status FaultInjectionTestEnv::DeleteFile(const std::string& f) {
    function Status (line 306) | Status FaultInjectionTestEnv::RenameFile(const std::string& s,
    function Status (line 335) | Status FaultInjectionTestEnv::DeleteFilesCreatedAfterLastDirSync() {
    function Status (line 354) | Status FileState::DropUnsyncedData() const {
    class FaultInjectionTest (line 359) | class FaultInjectionTest {
      type ExpectedVerifResult (line 361) | enum ExpectedVerifResult { VAL_EXPECT_NO_ERROR, VAL_EXPECT_ERROR }
      type ResetMethod (line 362) | enum ResetMethod { RESET_DROP_UNSYNCED_DATA, RESET_DELETE_UNSYNCED_F...
      method FaultInjectionTest (line 370) | FaultInjectionTest()
      method ReuseLogs (line 390) | void ReuseLogs(bool reuse) {
      method Build (line 394) | void Build(int start_idx, int num_vals) {
      method Status (line 406) | Status ReadValue(int i, std::string* val) const {
      method Status (line 414) | Status Verify(int start_idx, int num_vals,
      method Slice (line 437) | Slice Key(int i, std::string* storage) const {
      method Slice (line 445) | Slice Value(int k, std::string* storage) const {
      method Status (line 450) | Status OpenDB() {
      method CloseDB (line 457) | void CloseDB() {
      method DeleteAllData (line 462) | void DeleteAllData() {
      method ResetDBState (line 472) | void ResetDBState(ResetMethod reset_method) {
      method PartialCompactTestPreFault (line 485) | void PartialCompactTestPreFault(int num_pre_sync, int num_post_sync) {
      method PartialCompactTestReopenWithFault (line 492) | void PartialCompactTestReopenWithFault(ResetMethod reset_method,
      method NoWriteTestPreFault (line 503) | void NoWriteTestPreFault() {
      method NoWriteTestReopenWithFault (line 506) | void NoWriteTestReopenWithFault(ResetMethod reset_method) {
      method DoTest (line 512) | void DoTest() {
    function TEST (line 540) | TEST(FaultInjectionTest, FaultTestNoLogReuse) {
    function TEST (line 545) | TEST(FaultInjectionTest, FaultTestWithLogReuse) {
  function main (line 552) | int main(int argc, char** argv) {

FILE: src/leveldb/db/filename.cc
  type leveldb (line 12) | namespace leveldb {
    function MakeFileName (line 18) | static std::string MakeFileName(const std::string& name, uint64_t number,
    function LogFileName (line 27) | std::string LogFileName(const std::string& name, uint64_t number) {
    function TableFileName (line 32) | std::string TableFileName(const std::string& name, uint64_t number) {
    function SSTTableFileName (line 37) | std::string SSTTableFileName(const std::string& name, uint64_t number) {
    function DescriptorFileName (line 42) | std::string DescriptorFileName(const std::string& dbname, uint64_t num...
    function CurrentFileName (line 50) | std::string CurrentFileName(const std::string& dbname) {
    function LockFileName (line 54) | std::string LockFileName(const std::string& dbname) {
    function TempFileName (line 58) | std::string TempFileName(const std::string& dbname, uint64_t number) {
    function InfoLogFileName (line 63) | std::string InfoLogFileName(const std::string& dbname) {
    function OldInfoLogFileName (line 68) | std::string OldInfoLogFileName(const std::string& dbname) {
    function ParseFileName (line 80) | bool ParseFileName(const std::string& fname,
    function Status (line 126) | Status SetCurrentFile(Env* env, const std::string& dbname,

FILE: src/leveldb/db/filename.h
  function namespace (line 16) | namespace leveldb {

FILE: src/leveldb/db/filename_test.cc
  type leveldb (line 12) | namespace leveldb {
    class FileNameTest (line 14) | class FileNameTest { }
    function TEST (line 16) | TEST(FileNameTest, Parse) {
    function TEST (line 77) | TEST(FileNameTest, Construction) {
  function main (line 121) | int main(int argc, char** argv) {

FILE: src/leveldb/db/leveldbutil.cc
  type leveldb (line 10) | namespace leveldb {
    class StdoutPrinter (line 13) | class StdoutPrinter : public WritableFile {
      method Status (line 15) | virtual Status Append(const Slice& data) {
      method Status (line 19) | virtual Status Close() { return Status::OK(); }
      method Status (line 20) | virtual Status Flush() { return Status::OK(); }
      method Status (line 21) | virtual Status Sync() { return Status::OK(); }
      method GetName (line 22) | virtual std::string GetName() const { return "[stdout]"; }
    function HandleDumpCommand (line 25) | bool HandleDumpCommand(Env* env, char** files, int num) {
  function Usage (line 41) | static void Usage() {
  function main (line 49) | int main(int argc, char** argv) {

FILE: src/leveldb/db/log_format.h
  function namespace (line 11) | namespace leveldb {

FILE: src/leveldb/db/log_reader.cc
  type leveldb (line 12) | namespace leveldb {
    type log (line 13) | namespace log {

FILE: src/leveldb/db/log_reader.h
  function namespace (line 14) | namespace leveldb {

FILE: src/leveldb/db/log_test.cc
  type leveldb (line 13) | namespace leveldb {
    type log (line 14) | namespace log {
      function BigString (line 18) | static std::string BigString(const std::string& partial_string, size...
      function NumberString (line 28) | static std::string NumberString(int n) {
      function RandomSkewedString (line 35) | static std::string RandomSkewedString(int i, Random* rnd) {
      class LogTest (line 39) | class LogTest {
        class StringDest (line 41) | class StringDest : public WritableFile {
          method Status (line 45) | virtual Status Close() { return Status::OK(); }
          method Status (line 46) | virtual Status Flush() { return Status::OK(); }
          method Status (line 47) | virtual Status Sync() { return Status::OK(); }
          method Status (line 48) | virtual Status Append(const Slice& slice) {
        class StringSource (line 54) | class StringSource : public SequentialFile {
          method StringSource (line 59) | StringSource() : force_error_(false), returned_partial_(false) { }
          method Status (line 61) | virtual Status Read(size_t n, Slice* result, char* scratch) {
          method Status (line 79) | virtual Status Skip(uint64_t n) {
        class ReportCollector (line 91) | class ReportCollector : public Reader::Reporter {
          method ReportCollector (line 96) | ReportCollector() : dropped_bytes_(0) { }
          method Corruption (line 97) | virtual void Corruption(size_t bytes, const Status& status) {
        method LogTest (line 116) | LogTest() : reading_(false),
        method ReopenForAppend (line 127) | void ReopenForAppend() {
        method Write (line 132) | void Write(const std::string& msg) {
        method WrittenBytes (line 137) | size_t WrittenBytes() const {
        method Read (line 141) | std::string Read() {
        method IncrementByte (line 155) | void IncrementByte(int offset, int delta) {
        method SetByte (line 159) | void SetByte(int offset, char new_byte) {
        method ShrinkSize (line 163) | void ShrinkSize(int bytes) {
        method FixChecksum (line 167) | void FixChecksum(int header_offset, int len) {
        method ForceError (line 174) | void ForceError() {
        method DroppedBytes (line 178) | size_t DroppedBytes() const {
        method ReportMessage (line 182) | std::string ReportMessage() const {
        method MatchError (line 187) | std::string MatchError(const std::string& msg) const {
        method WriteInitialOffsetLog (line 195) | void WriteInitialOffsetLog() {
        method StartReadingAt (line 203) | void StartReadingAt(uint64_t initial_offset) {
        method CheckOffsetPastEndReturnsNoRecords (line 208) | void CheckOffsetPastEndReturnsNoRecords(uint64_t offset_past_end) {
        method CheckInitialOffsetRecord (line 220) | void CheckInitialOffsetRecord(uint64_t initial_offset,
      function TEST (line 270) | TEST(LogTest, Empty) {
      function TEST (line 274) | TEST(LogTest, ReadWrite) {
      function TEST (line 287) | TEST(LogTest, ManyBlocks) {
      function TEST (line 297) | TEST(LogTest, Fragmentation) {
      function TEST (line 307) | TEST(LogTest, MarginalTrailer) {
      function TEST (line 320) | TEST(LogTest, MarginalTrailer2) {
      function TEST (line 333) | TEST(LogTest, ShortTrailer) {
      function TEST (line 345) | TEST(LogTest, AlignedEof) {
      function TEST (line 353) | TEST(LogTest, OpenForAppend) {
      function TEST (line 362) | TEST(LogTest, RandomRead) {
      function TEST (line 377) | TEST(LogTest, ReadError) {
      function TEST (line 385) | TEST(LogTest, BadRecordType) {
      function TEST (line 395) | TEST(LogTest, TruncatedTrailingRecordIsIgnored) {
      function TEST (line 404) | TEST(LogTest, BadLength) {
      function TEST (line 415) | TEST(LogTest, BadLengthAtEndIsIgnored) {
      function TEST (line 423) | TEST(LogTest, ChecksumMismatch) {
      function TEST (line 431) | TEST(LogTest, UnexpectedMiddleType) {
      function TEST (line 440) | TEST(LogTest, UnexpectedLastType) {
      function TEST (line 449) | TEST(LogTest, UnexpectedFullType) {
      function TEST (line 460) | TEST(LogTest, UnexpectedFirstType) {
      function TEST (line 471) | TEST(LogTest, MissingLastIsIgnored) {
      function TEST (line 480) | TEST(LogTest, PartialLastIsIgnored) {
      function TEST (line 489) | TEST(LogTest, SkipIntoMultiRecord) {
      function TEST (line 505) | TEST(LogTest, ErrorJoinsRecords) {
      function TEST (line 528) | TEST(LogTest, ReadStart) {
      function TEST (line 532) | TEST(LogTest, ReadSecondOneOff) {
      function TEST (line 536) | TEST(LogTest, ReadSecondTenThousand) {
      function TEST (line 540) | TEST(LogTest, ReadSecondStart) {
      function TEST (line 544) | TEST(LogTest, ReadThirdOneOff) {
      function TEST (line 548) | TEST(LogTest, ReadThirdStart) {
      function TEST (line 552) | TEST(LogTest, ReadFourthOneOff) {
      function TEST (line 556) | TEST(LogTest, ReadFourthFirstBlockTrailer) {
      function TEST (line 560) | TEST(LogTest, ReadFourthMiddleBlock) {
      function TEST (line 564) | TEST(LogTest, ReadFourthLastBlock) {
      function TEST (line 568) | TEST(LogTest, ReadFourthStart) {
      function TEST (line 574) | TEST(LogTest, ReadInitialOffsetIntoBlockPadding) {
      function TEST (line 578) | TEST(LogTest, ReadEnd) {
      function TEST (line 582) | TEST(LogTest, ReadPastEnd) {
  function main (line 589) | int main(int argc, char** argv) {

FILE: src/leveldb/db/log_writer.cc
  type leveldb (line 12) | namespace leveldb {
    type log (line 13) | namespace log {
      function InitTypeCrc (line 15) | static void InitTypeCrc(uint32_t* type_crc) {
      function Status (line 36) | Status Writer::AddRecord(const Slice& slice) {
      function Status (line 84) | Status Writer::EmitPhysicalRecord(RecordType t, const char* ptr, siz...

FILE: src/leveldb/db/log_writer.h
  function namespace (line 13) | namespace leveldb {

FILE: src/leveldb/db/memtable.cc
  type leveldb (line 12) | namespace leveldb {
    function Slice (line 14) | static Slice GetLengthPrefixedSlice(const char* data) {
    class MemTableIterator (line 51) | class MemTableIterator: public Iterator {
      method MemTableIterator (line 53) | explicit MemTableIterator(MemTable::Table* table) : iter_(table) { }
      method Valid (line 55) | virtual bool Valid() const { return iter_.Valid(); }
      method Seek (line 56) | virtual void Seek(const Slice& k) { iter_.Seek(EncodeKey(&tmp_, k)); }
      method SeekToFirst (line 57) | virtual void SeekToFirst() { iter_.SeekToFirst(); }
      method SeekToLast (line 58) | virtual void SeekToLast() { iter_.SeekToLast(); }
      method Next (line 59) | virtual void Next() { iter_.Next(); }
      method Prev (line 60) | virtual void Prev() { iter_.Prev(); }
      method Slice (line 61) | virtual Slice key() const { return GetLengthPrefixedSlice(iter_.key(...
      method Slice (line 62) | virtual Slice value() const {
      method Status (line 67) | virtual Status status() const { return Status::OK(); }
    function Iterator (line 78) | Iterator* MemTable::NewIterator() {

FILE: src/leveldb/db/memtable.h
  function namespace (line 14) | namespace leveldb {

FILE: src/leveldb/db/recovery_test.cc
  type leveldb (line 16) | namespace leveldb {
    class RecoveryTest (line 18) | class RecoveryTest {
      method RecoveryTest (line 20) | RecoveryTest() : env_(Env::Default()), db_(NULL) {
      method DBImpl (line 31) | DBImpl* dbfull() const { return reinterpret_cast<DBImpl*>(db_); }
      method Env (line 32) | Env* env() const { return env_; }
      method CanAppend (line 34) | bool CanAppend() {
      method Close (line 45) | void Close() {
      method Open (line 50) | void Open(Options* options = NULL) {
      method Status (line 66) | Status Put(const std::string& k, const std::string& v) {
      method Get (line 70) | std::string Get(const std::string& k, const Snapshot* snapshot = NUL...
      method ManifestFileName (line 81) | std::string ManifestFileName() {
      method LogName (line 91) | std::string LogName(uint64_t number) {
      method DeleteLogFiles (line 95) | size_t DeleteLogFiles() {
      method FirstLogFile (line 103) | uint64_t FirstLogFile() {
      method GetFiles (line 107) | std::vector<uint64_t> GetFiles(FileType t) {
      method NumLogs (line 121) | int NumLogs() {
      method NumTables (line 125) | int NumTables() {
      method FileSize (line 129) | uint64_t FileSize(const std::string& fname) {
      method CompactMemTable (line 135) | void CompactMemTable() {
      method MakeLogFile (line 140) | void MakeLogFile(uint64_t lognum, SequenceNumber seq, Slice key, Sli...
    function TEST (line 159) | TEST(RecoveryTest, ManifestReused) {
    function TEST (line 175) | TEST(RecoveryTest, LargeManifestCompacted) {
    function TEST (line 206) | TEST(RecoveryTest, NoLogFiles) {
    function TEST (line 215) | TEST(RecoveryTest, LogFileReuse) {
    function TEST (line 245) | TEST(RecoveryTest, MultipleMemTables) {
    function TEST (line 274) | TEST(RecoveryTest, MultipleLogFiles) {
  function main (line 322) | int main(int argc, char** argv) {

FILE: src/leveldb/db/repair.cc
  type leveldb (line 41) | namespace leveldb {
    class Repairer (line 45) | class Repairer {
      method Repairer (line 47) | Repairer(const std::string& dbname, const Options& options)
      method Status (line 70) | Status Run() {
      type TableInfo (line 95) | struct TableInfo {
      method Status (line 116) | Status FindFiles() {
      method ConvertLogFilesToTables (line 149) | void ConvertLogFilesToTables() {
      method Status (line 162) | Status ConvertLogToTable(uint64_t log) {
      method ExtractMetaData (line 244) | void ExtractMetaData() {
      method Iterator (line 250) | Iterator* NewTableIterator(const FileMetaData& meta) {
      method ScanTable (line 258) | void ScanTable(uint64_t number) {
      method RepairTable (line 321) | void RepairTable(const std::string& src, TableInfo t) {
      method Status (line 375) | Status WriteDescriptor() {
      method ArchiveFile (line 434) | void ArchiveFile(const std::string& fname) {
    function Status (line 456) | Status RepairDB(const std::string& dbname, const Options& options) {

FILE: src/leveldb/db/skiplist.h
  function namespace (line 36) | namespace leveldb {

FILE: src/leveldb/db/skiplist_test.cc
  type leveldb (line 13) | namespace leveldb {
    type Comparator (line 17) | struct Comparator {
    class SkipTest (line 29) | class SkipTest { }
    function TEST (line 31) | TEST(SkipTest, Empty) {
    function TEST (line 47) | TEST(SkipTest, InsertAndLookup) {
    class ConcurrentTest (line 149) | class ConcurrentTest {
      method key (line 153) | static uint64_t key(Key key) { return (key >> 40); }
      method gen (line 154) | static uint64_t gen(Key key) { return (key >> 8) & 0xffffffffu; }
      method hash (line 155) | static uint64_t hash(Key key) { return key & 0xff; }
      method HashNumbers (line 157) | static uint64_t HashNumbers(uint64_t k, uint64_t g) {
      method Key (line 162) | static Key MakeKey(uint64_t k, uint64_t g) {
      method IsValidKey (line 169) | static bool IsValidKey(Key k) {
      method Key (line 173) | static Key RandomTarget(Random* rnd) {
      type State (line 188) | struct State {
        method Set (line 190) | void Set(int k, intptr_t v) {
        method Get (line 193) | intptr_t Get(int k) {
        method State (line 197) | State() {
      method ConcurrentTest (line 214) | ConcurrentTest() : list_(Comparator(), &arena_) { }
      method WriteStep (line 217) | void WriteStep(Random* rnd) {
      method ReadStep (line 225) | void ReadStep(Random* rnd) {
    function TEST (line 288) | TEST(SkipTest, ConcurrentWithoutThreads) {
    class TestState (line 297) | class TestState {
      type ReaderState (line 303) | enum ReaderState {
      method TestState (line 309) | explicit TestState(int s)
      method Wait (line 315) | void Wait(ReaderState s) {
      method Change (line 323) | void Change(ReaderState s) {
    function ConcurrentReader (line 336) | static void ConcurrentReader(void* arg) {
    function RunConcurrent (line 348) | static void RunConcurrent(int run) {
    function TEST (line 368) | TEST(SkipTest, Concurrent1) { RunConcurrent(1); }
    function TEST (line 369) | TEST(SkipTest, Concurrent2) { RunConcurrent(2); }
    function TEST (line 370) | TEST(SkipTest, Concurrent3) { RunConcurrent(3); }
    function TEST (line 371) | TEST(SkipTest, Concurrent4) { RunConcurrent(4); }
    function TEST (line 372) | TEST(SkipTest, Concurrent5) { RunConcurrent(5); }
  function main (line 376) | int main(int argc, char** argv) {

FILE: src/leveldb/db/snapshot.h
  function namespace (line 11) | namespace leveldb {

FILE: src/leveldb/db/table_cache.cc
  type leveldb (line 12) | namespace leveldb {
    type TableAndFile (line 14) | struct TableAndFile {
    function DeleteEntry (line 19) | static void DeleteEntry(const Slice& key, void* value) {
    function UnrefEntry (line 26) | static void UnrefEntry(void* arg1, void* arg2) {
    function Status (line 45) | Status TableCache::FindTable(uint64_t file_number, uint64_t file_size,
    function Iterator (line 82) | Iterator* TableCache::NewIterator(const ReadOptions& options,
    function Status (line 105) | Status TableCache::Get(const ReadOptions& options,

FILE: src/leveldb/db/table_cache.h
  function namespace (line 17) | namespace leveldb {

FILE: src/leveldb/db/version_edit.cc
  type leveldb (line 10) | namespace leveldb {
    type Tag (line 14) | enum Tag {
    function GetInternalKey (line 88) | static bool GetInternalKey(Slice* input, InternalKey* dst) {
    function GetLevel (line 98) | static bool GetLevel(Slice* input, int* level) {
    function Status (line 109) | Status VersionEdit::DecodeFrom(const Slice& src) {

FILE: src/leveldb/db/version_edit.h
  function namespace (line 13) | namespace leveldb {

FILE: src/leveldb/db/version_edit_test.cc
  type leveldb (line 8) | namespace leveldb {
    function TestEncodeDecode (line 10) | static void TestEncodeDecode(const VersionEdit& edit) {
    class VersionEditTest (line 20) | class VersionEditTest { }
    function TEST (line 22) | TEST(VersionEditTest, EncodeDecode) {
  function main (line 44) | int main(int argc, char** argv) {

FILE: src/leveldb/db/version_set.cc
  type leveldb (line 21) | namespace leveldb {
    function TargetFileSize (line 23) | static size_t TargetFileSize(const Options* options) {
    function MaxGrandParentOverlapBytes (line 29) | static int64_t MaxGrandParentOverlapBytes(const Options* options) {
    function ExpandedCompactionByteSizeLimit (line 36) | static int64_t ExpandedCompactionByteSizeLimit(const Options* options) {
    function MaxBytesForLevel (line 40) | static double MaxBytesForLevel(const Options* options, int level) {
    function MaxFileSizeForLevel (line 53) | static uint64_t MaxFileSizeForLevel(const Options* options, int level) {
    function TotalFileSize (line 58) | static int64_t TotalFileSize(const std::vector<FileMetaData*>& files) {
    function FindFile (line 86) | int FindFile(const InternalKeyComparator& icmp,
    function AfterFile (line 107) | static bool AfterFile(const Comparator* ucmp,
    function BeforeFile (line 114) | static bool BeforeFile(const Comparator* ucmp,
    function SomeFileOverlapsRange (line 121) | bool SomeFileOverlapsRange(
    class Version::LevelFileNumIterator (line 163) | class Version::LevelFileNumIterator : public Iterator {
      method LevelFileNumIterator (line 165) | LevelFileNumIterator(const InternalKeyComparator& icmp,
      method Valid (line 171) | virtual bool Valid() const {
      method Seek (line 174) | virtual void Seek(const Slice& target) {
      method SeekToFirst (line 177) | virtual void SeekToFirst() { index_ = 0; }
      method SeekToLast (line 178) | virtual void SeekToLast() {
      method Next (line 181) | virtual void Next() {
      method Prev (line 185) | virtual void Prev() {
      method Slice (line 193) | Slice key() const {
      method Slice (line 197) | Slice value() const {
      method Status (line 203) | virtual Status status() const { return Status::OK(); }
    function Iterator (line 213) | static Iterator* GetFileIterator(void* arg,
    function Iterator (line 227) | Iterator* Version::NewConcatenatingIterator(const ReadOptions& options,
    type SaverState (line 255) | enum SaverState {
    type Saver (line 261) | struct Saver {
    function SaveValue (line 268) | static void SaveValue(void* arg, const Slice& ikey, const Slice& v) {
    function NewestFirst (line 283) | static bool NewestFirst(FileMetaData* a, FileMetaData* b) {
    function Status (line 332) | Status Version::Get(const ReadOptions& options,
    type State (line 450) | struct State {
      method Match (line 454) | static bool Match(void* arg, int level, FileMetaData* f) {
    class VersionSet::Builder (line 603) | class VersionSet::Builder {
      type BySmallestKey (line 606) | struct BySmallestKey {
      type LevelState (line 621) | struct LevelState {
      method Builder (line 632) | Builder(VersionSet* vset, Version* base)
      method Apply (line 665) | void Apply(VersionEdit* edit) {
      method SaveTo (line 711) | void SaveTo(Version* v) {
      method MaybeAddFile (line 759) | void MaybeAddFile(Version* v, int level, FileMetaData* f) {
    function Status (line 820) | Status VersionSet::LogAndApply(VersionEdit* edit, port::Mutex* mu) {
    function Status (line 905) | Status VersionSet::Recover(bool *save_manifest) {
    function Status (line 1102) | Status VersionSet::WriteSnapshot(log::Writer* log) {
    function Iterator (line 1258) | Iterator* VersionSet::MakeInputIterator(Compaction* c) {
    function Compaction (line 1291) | Compaction* VersionSet::PickCompaction() {
    function Compaction (line 1413) | Compaction* VersionSet::CompactRange(

FILE: src/leveldb/db/version_set.h
  function namespace (line 26) | namespace leveldb {

FILE: src/leveldb/db/version_set_test.cc
  type leveldb (line 10) | namespace leveldb {
    class FindFileTest (line 12) | class FindFileTest {
      method FindFileTest (line 17) | FindFileTest() : disjoint_sorted_files_(true) { }
      method Add (line 25) | void Add(const char* smallest, const char* largest,
      method Find (line 35) | int Find(const char* key) {
      method Overlaps (line 41) | bool Overlaps(const char* smallest, const char* largest) {
    function TEST (line 51) | TEST(FindFileTest, Empty) {
    function TEST (line 59) | TEST(FindFileTest, Single) {
    function TEST (line 90) | TEST(FindFileTest, Multiple) {
    function TEST (line 128) | TEST(FindFileTest, MultipleNullBoundaries) {
    function TEST (line 148) | TEST(FindFileTest, OverlapSequenceChecks) {
    function TEST (line 157) | TEST(FindFileTest, OverlappingFiles) {
  function main (line 177) | int main(int argc, char** argv) {

FILE: src/leveldb/db/write_batch.cc
  type leveldb (line 24) | namespace leveldb {
    function Status (line 42) | Status WriteBatch::Iterate(Handler* handler) const {
    function SequenceNumber (line 90) | SequenceNumber WriteBatchInternal::Sequence(const WriteBatch* b) {
    class MemTableInserter (line 112) | class MemTableInserter : public WriteBatch::Handler {
      method Put (line 117) | virtual void Put(const Slice& key, const Slice& value) {
      method Delete (line 121) | virtual void Delete(const Slice& key) {
    function Status (line 128) | Status WriteBatchInternal::InsertInto(const WriteBatch* b,

FILE: src/leveldb/db/write_batch_internal.h
  function namespace (line 11) | namespace leveldb {

FILE: src/leveldb/db/write_batch_test.cc
  type leveldb (line 13) | namespace leveldb {
    function PrintContents (line 15) | static std::string PrintContents(WriteBatch* b) {
    class WriteBatchTest (line 55) | class WriteBatchTest { }
    function TEST (line 57) | TEST(WriteBatchTest, Empty) {
    function TEST (line 63) | TEST(WriteBatchTest, Multiple) {
    function TEST (line 77) | TEST(WriteBatchTest, Corruption) {
    function TEST (line 90) | TEST(WriteBatchTest, Append) {
  function main (line 118) | int main(int argc, char** argv) {

FILE: src/leveldb/doc/bench/db_bench_sqlite3.cc
  function ExecErrorCheck (line 81) | inline
  function StepErrorCheck (line 90) | inline
  function ErrorCheck (line 98) | inline
  function WalCheckpoint (line 106) | inline
  type leveldb (line 114) | namespace leveldb {
    class RandomGenerator (line 118) | class RandomGenerator {
      method RandomGenerator (line 124) | RandomGenerator() {
      method Slice (line 139) | Slice Generate(int len) {
    function Slice (line 149) | static Slice TrimSpace(Slice s) {
    class Benchmark (line 163) | class Benchmark {
      method PrintHeader (line 181) | void PrintHeader() {
      method PrintWarnings (line 194) | void PrintWarnings() {
      method PrintEnvironment (line 206) | void PrintEnvironment() {
      method Start (line 240) | void Start() {
      method FinishedSingleOp (line 250) | void FinishedSingleOp() {
      method Stop (line 276) | void Stop(const Slice& name) {
      type Order (line 306) | enum Order {
      type DBState (line 310) | enum DBState {
      method Benchmark (line 315) | Benchmark()
      method Run (line 343) | void Run() {
      method Open (line 417) | void Open() {
      method Write (line 478) | void Write(bool write_sync, Order order, DBState state,
      method Read (line 581) | void Read(Order order, int entries_per_batch) {
      method ReadSequential (line 649) | void ReadSequential() {
  function main (line 669) | int main(int argc, char** argv) {

FILE: src/leveldb/doc/bench/db_bench_tree_db.cc
  function DBSynchronize (line 74) | inline
  type leveldb (line 83) | namespace leveldb {
    class RandomGenerator (line 87) | class RandomGenerator {
      method RandomGenerator (line 93) | RandomGenerator() {
      method Slice (line 108) | Slice Generate(int len) {
    function Slice (line 118) | static Slice TrimSpace(Slice s) {
    class Benchmark (line 132) | class Benchmark {
      method PrintHeader (line 151) | void PrintHeader() {
      method PrintWarnings (line 169) | void PrintWarnings() {
      method PrintEnvironment (line 181) | void PrintEnvironment() {
      method Start (line 216) | void Start() {
      method FinishedSingleOp (line 226) | void FinishedSingleOp() {
      method Stop (line 252) | void Stop(const Slice& name) {
      type Order (line 282) | enum Order {
      type DBState (line 286) | enum DBState {
      method Benchmark (line 291) | Benchmark()
      method Run (line 319) | void Run() {
      method Open (line 389) | void Open(bool sync) {
      method Write (line 424) | void Write(bool sync, Order order, DBState state,
      method ReadSequential (line 459) | void ReadSequential() {
      method ReadRandom (line 470) | void ReadRandom() {
  function main (line 484) | int main(int argc, char** argv) {

FILE: src/leveldb/helpers/memenv/memenv.cc
  type leveldb (line 16) | namespace leveldb {
    class FileState (line 20) | class FileState {
      method FileState (line 24) | FileState() : refs_(0), size_(0) {}
      method Ref (line 27) | void Ref() {
      method Unref (line 33) | void Unref() {
      method Size (line 50) | uint64_t Size() const { return size_; }
      method Status (line 52) | Status Read(uint64_t offset, size_t n, Slice* result, char* scratch)...
      method Status (line 95) | Status Append(const Slice& data) {
    class SequentialFileImpl (line 149) | class SequentialFileImpl : public SequentialFile {
      method SequentialFileImpl (line 151) | explicit SequentialFileImpl(FileState* file) : file_(file), pos_(0) {
      method Status (line 159) | virtual Status Read(size_t n, Slice* result, char* scratch) {
      method Status (line 167) | virtual Status Skip(uint64_t n) {
      method GetName (line 179) | virtual std::string GetName() const { return "[memenv]"; }
    class RandomAccessFileImpl (line 185) | class RandomAccessFileImpl : public RandomAccessFile {
      method RandomAccessFileImpl (line 187) | explicit RandomAccessFileImpl(FileState* file) : file_(file) {
      method Status (line 195) | virtual Status Read(uint64_t offset, size_t n, Slice* result,
      method GetName (line 200) | virtual std::string GetName() const { return "[memenv]"; }
    class WritableFileImpl (line 205) | class WritableFileImpl : public WritableFile {
      method WritableFileImpl (line 207) | WritableFileImpl(FileState* file) : file_(file) {
      method Status (line 215) | virtual Status Append(const Slice& data) {
      method Status (line 219) | virtual Status Close() { return Status::OK(); }
      method Status (line 220) | virtual Status Flush() { return Status::OK(); }
      method Status (line 221) | virtual Status Sync() { return Status::OK(); }
      method GetName (line 223) | virtual std::string GetName() const { return "[memenv]"; }
    class NoOpLogger (line 228) | class NoOpLogger : public Logger {
      method Logv (line 230) | virtual void Logv(const char* format, va_list ap) { }
    class InMemoryEnv (line 233) | class InMemoryEnv : public EnvWrapper {
      method InMemoryEnv (line 235) | explicit InMemoryEnv(Env* base_env) : EnvWrapper(base_env) { }
      method Status (line 244) | virtual Status NewSequentialFile(const std::string& fname,
      method Status (line 256) | virtual Status NewRandomAccessFile(const std::string& fname,
      method Status (line 268) | virtual Status NewWritableFile(const std::string& fname,
      method Status (line 283) | virtual Status NewAppendableFile(const std::string& fname,
      method FileExists (line 296) | virtual bool FileExists(const std::string& fname) {
      method Status (line 301) | virtual Status GetChildren(const std::string& dir,
      method DeleteFileInternal (line 318) | void DeleteFileInternal(const std::string& fname) {
      method Status (line 327) | virtual Status DeleteFile(const std::string& fname) {
      method Status (line 337) | virtual Status CreateDir(const std::string& dirname) {
      method Status (line 341) | virtual Status DeleteDir(const std::string& dirname) {
      method Status (line 345) | virtual Status GetFileSize(const std::string& fname, uint64_t* file_...
      method Status (line 355) | virtual Status RenameFile(const std::string& src,
      method Status (line 368) | virtual Status LockFile(const std::string& fname, FileLock** lock) {
      method Status (line 373) | virtual Status UnlockFile(FileLock* lock) {
      method Status (line 378) | virtual Status GetTestDirectory(std::string* path) {
      method Status (line 383) | virtual Status NewLogger(const std::string& fname, Logger** result) {
    function Env (line 397) | Env* NewMemEnv(Env* base_env) {

FILE: src/leveldb/helpers/memenv/memenv.h
  function namespace (line 8) | namespace leveldb {

FILE: src/leveldb/helpers/memenv/memenv_test.cc
  type leveldb (line 14) | namespace leveldb {
    class MemEnvTest (line 16) | class MemEnvTest {
      method MemEnvTest (line 20) | MemEnvTest()
    function TEST (line 28) | TEST(MemEnvTest, Basics) {
    function TEST (line 96) | TEST(MemEnvTest, ReadWrite) {
    function TEST (line 138) | TEST(MemEnvTest, Locks) {
    function TEST (line 146) | TEST(MemEnvTest, Misc) {
    function TEST (line 161) | TEST(MemEnvTest, LargeWrite) {
    function TEST (line 194) | TEST(MemEnvTest, DBTest) {
  function main (line 239) | int main(int argc, char** argv) {

FILE: src/leveldb/include/leveldb/c.h
  type leveldb_t (line 53) | typedef struct leveldb_t               leveldb_t;
  type leveldb_cache_t (line 54) | typedef struct leveldb_cache_t         leveldb_cache_t;
  type leveldb_comparator_t (line 55) | typedef struct leveldb_comparator_t    leveldb_comparator_t;
  type leveldb_env_t (line 56) | typedef struct leveldb_env_t           leveldb_env_t;
  type leveldb_filelock_t (line 57) | typedef struct leveldb_filelock_t      leveldb_filelock_t;
  type leveldb_filterpolicy_t (line 58) | typedef struct leveldb_filterpolicy_t  leveldb_filterpolicy_t;
  type leveldb_iterator_t (line 59) | typedef struct leveldb_iterator_t      leveldb_iterator_t;
  type leveldb_logger_t (line 60) | typedef struct leveldb_logger_t        leveldb_logger_t;
  type leveldb_options_t (line 61) | typedef struct leveldb_options_t       leveldb_options_t;
  type leveldb_randomfile_t (line 62) | typedef struct leveldb_randomfile_t    leveldb_randomfile_t;
  type leveldb_readoptions_t (line 63) | typedef struct leveldb_readoptions_t   leveldb_readoptions_t;
  type leveldb_seqfile_t (line 64) | typedef struct leveldb_seqfile_t       leveldb_seqfile_t;
  type leveldb_snapshot_t (line 65) | typedef struct leveldb_snapshot_t      leveldb_snapshot_t;
  type leveldb_writablefile_t (line 66) | typedef struct leveldb_writablefile_t  leveldb_writablefile_t;
  type leveldb_writebatch_t (line 67) | typedef struct leveldb_writebatch_t    leveldb_writebatch_t;
  type leveldb_writeoptions_t (line 68) | typedef struct leveldb_writeoptions_t  leveldb_writeoptions_t;

FILE: src/leveldb/include/leveldb/cache.h
  function namespace (line 24) | namespace leveldb {

FILE: src/leveldb/include/leveldb/comparator.h
  function namespace (line 10) | namespace leveldb {

FILE: src/leveldb/include/leveldb/db.h
  function namespace (line 13) | namespace leveldb {

FILE: src/leveldb/include/leveldb/dumpfile.h
  function namespace (line 12) | namespace leveldb {

FILE: src/leveldb/include/leveldb/env.h
  function namespace (line 22) | namespace leveldb {

FILE: src/leveldb/include/leveldb/filter_policy.h
  function namespace (line 21) | namespace leveldb {

FILE: src/leveldb/include/leveldb/iterator.h
  type Cleanup (line 79) | struct Cleanup {

FILE: src/leveldb/include/leveldb/options.h
  type CompressionType (line 23) | enum CompressionType {
  type Options (line 31) | struct Options {
  type WriteOptions (line 187) | struct WriteOptions {

FILE: src/leveldb/include/leveldb/slice.h
  function namespace (line 23) | namespace leveldb {
  function compare (line 96) | inline int Slice::compare(const Slice& b) const {

FILE: src/leveldb/include/leveldb/status.h
  function namespace (line 19) | namespace leveldb {

FILE: src/leveldb/include/leveldb/table.h
  function namespace (line 11) | namespace leveldb {

FILE: src/leveldb/include/leveldb/table_builder.h
  function namespace (line 20) | namespace leveldb {

FILE: src/leveldb/include/leveldb/write_batch.h
  function namespace (line 27) | namespace leveldb {

FILE: src/leveldb/issues/issue178_test.cc
  function Key1 (line 18) | std::string Key1(int i) {
  function Key2 (line 24) | std::string Key2(int i) {
  class Issue178 (line 28) | class Issue178 { }
  function TEST (line 30) | TEST(Issue178, Test) {
  function main (line 90) | int main(int argc, char** argv) {

FILE: src/leveldb/issues/issue200_test.cc
  type leveldb (line 12) | namespace leveldb {
    class Issue200 (line 14) | class Issue200 { }
    function TEST (line 16) | TEST(Issue200, Test) {
  function main (line 57) | int main(int argc, char** argv) {

FILE: src/leveldb/port/atomic_pointer.h
  function namespace (line 46) | namespace leveldb {

FILE: src/leveldb/port/port_example.h
  function namespace (line 13) | namespace leveldb {

FILE: src/leveldb/port/port_posix.cc
  type leveldb (line 15) | namespace leveldb {
    type port (line 16) | namespace port {
      function PthreadCall (line 18) | static void PthreadCall(const char* label, int result) {
      function InitOnce (line 52) | void InitOnce(OnceType* once, void (*initializer)()) {
      function HasAcceleratedCRC32C (line 56) | bool HasAcceleratedCRC32C() {

FILE: src/leveldb/port/port_posix.h
  function namespace (line 78) | namespace leveldb {

FILE: src/leveldb/port/port_posix_sse.cc
  type leveldb (line 26) | namespace leveldb {
    type port (line 27) | namespace port {
      function LE_LOAD32 (line 32) | static inline uint32_t LE_LOAD32(const uint8_t *p) {
      function LE_LOAD64 (line 42) | static inline uint64_t LE_LOAD64(const uint8_t *p) {
      function AcceleratedCRC32C (line 54) | uint32_t AcceleratedCRC32C(uint32_t crc, const char* buf, size_t siz...

FILE: src/leveldb/port/port_win.cc
  type leveldb (line 37) | namespace leveldb {
    type port (line 38) | namespace port {
      function InitOnce (line 125) | void InitOnce(OnceType* once, void (*initializer)()) {
      function HasAcceleratedCRC32C (line 147) | bool HasAcceleratedCRC32C() {

FILE: src/leveldb/port/port_win.h
  function namespace (line 46) | namespace leveldb {

FILE: src/leveldb/table/block.cc
  type leveldb (line 16) | namespace leveldb {
    class Block::Iter (line 76) | class Block::Iter : public Iterator {
      method Compare (line 90) | inline int Compare(const Slice& a, const Slice& b) const {
      method NextEntryOffset (line 95) | inline uint32_t NextEntryOffset() const {
      method GetRestartPoint (line 99) | uint32_t GetRestartPoint(uint32_t index) {
      method SeekToRestartPoint (line 104) | void SeekToRestartPoint(uint32_t index) {
      method Iter (line 115) | Iter(const Comparator* comparator,
      method Valid (line 128) | virtual bool Valid() const { return current_ < restarts_; }
      method Status (line 129) | virtual Status status() const { return status_; }
      method Slice (line 130) | virtual Slice key() const {
      method Slice (line 134) | virtual Slice value() const {
      method Next (line 139) | virtual void Next() {
      method Prev (line 144) | virtual void Prev() {
      method Seek (line 165) | virtual void Seek(const Slice& target) {
      method SeekToFirst (line 205) | virtual void SeekToFirst() {
      method SeekToLast (line 210) | virtual void SeekToLast() {
      method CorruptionError (line 218) | void CorruptionError() {
      method ParseNextKey (line 226) | bool ParseNextKey() {
    function Iterator (line 256) | Iterator* Block::NewIterator(const Comparator* cmp) {

FILE: src/leveldb/table/block.h
  function namespace (line 12) | namespace leveldb {

FILE: src/leveldb/table/block_builder.cc
  type leveldb (line 37) | namespace leveldb {
    function Slice (line 63) | Slice BlockBuilder::Finish() {

FILE: src/leveldb/table/block_builder.h
  function namespace (line 13) | namespace leveldb {

FILE: src/leveldb/table/filter_block.cc
  type leveldb (line 10) | namespace leveldb {
    function Slice (line 36) | Slice FilterBlockBuilder::Finish() {

FILE: src/leveldb/table/filter_block.h
  function namespace (line 19) | namespace leveldb {

FILE: src/leveldb/table/filter_block_test.cc
  type leveldb (line 14) | namespace leveldb {
    class TestHashFilter (line 17) | class TestHashFilter : public FilterPolicy {
      method CreateFilter (line 23) | virtual void CreateFilter(const Slice* keys, int n, std::string* dst...
      method KeyMayMatch (line 30) | virtual bool KeyMayMatch(const Slice& key, const Slice& filter) const {
    class FilterBlockTest (line 41) | class FilterBlockTest {
    function TEST (line 46) | TEST(FilterBlockTest, EmptyBuilder) {
    function TEST (line 55) | TEST(FilterBlockTest, SingleChunk) {
    function TEST (line 76) | TEST(FilterBlockTest, MultiChunk) {
  function main (line 126) | int main(int argc, char** argv) {

FILE: src/leveldb/table/format.cc
  type leveldb (line 13) | namespace leveldb {
    function Status (line 23) | Status BlockHandle::DecodeFrom(Slice* input) {
    function Status (line 43) | Status Footer::DecodeFrom(Slice* input) {
    function Status (line 65) | Status ReadBlock(RandomAccessFile* file,

FILE: src/leveldb/table/format.h
  function namespace (line 14) | namespace leveldb {

FILE: src/leveldb/table/iterator.cc
  type leveldb (line 7) | namespace leveldb {
    class EmptyIterator (line 42) | class EmptyIterator : public Iterator {
      method EmptyIterator (line 44) | EmptyIterator(const Status& s) : status_(s) { }
      method Valid (line 45) | virtual bool Valid() const { return false; }
      method Seek (line 46) | virtual void Seek(const Slice& target) { }
      method SeekToFirst (line 47) | virtual void SeekToFirst() { }
      method SeekToLast (line 48) | virtual void SeekToLast() { }
      method Next (line 49) | virtual void Next() { assert(false); }
      method Prev (line 50) | virtual void Prev() { assert(false); }
      method Slice (line 51) | Slice key() const { assert(false); return Slice(); }
      method Slice (line 52) | Slice value() const { assert(false); return Slice(); }
      method Status (line 53) | virtual Status status() const { return status_; }
    function Iterator (line 59) | Iterator* NewEmptyIterator() {
    function Iterator (line 63) | Iterator* NewErrorIterator(const Status& status) {

FILE: src/leveldb/table/iterator_wrapper.h
  function namespace (line 11) | namespace leveldb {

FILE: src/leveldb/table/merger.cc
  type leveldb (line 11) | namespace leveldb {
    class MergingIterator (line 14) | class MergingIterator : public Iterator {
      method MergingIterator (line 16) | MergingIterator(const Comparator* comparator, Iterator** children, i...
      method Valid (line 31) | virtual bool Valid() const {
      method SeekToFirst (line 35) | virtual void SeekToFirst() {
      method SeekToLast (line 43) | virtual void SeekToLast() {
      method Seek (line 51) | virtual void Seek(const Slice& target) {
      method Next (line 59) | virtual void Next() {
      method Prev (line 85) | virtual void Prev() {
      method Slice (line 114) | virtual Slice key() const {
      method Slice (line 119) | virtual Slice value() const {
      method Status (line 124) | virtual Status status() const {
      type Direction (line 148) | enum Direction {
    function Iterator (line 186) | Iterator* NewMergingIterator(const Comparator* cmp, Iterator** list, i...

FILE: src/leveldb/table/merger.h
  function namespace (line 8) | namespace leveldb {

FILE: src/leveldb/table/table.cc
  type leveldb (line 18) | namespace leveldb {
    type Table::Rep (line 20) | struct Table::Rep {
    function Status (line 38) | Status Table::Open(const Options& options,
    function DeleteBlock (line 147) | static void DeleteBlock(void* arg, void* ignored) {
    function DeleteCachedBlock (line 151) | static void DeleteCachedBlock(const Slice& key, void* value) {
    function ReleaseBlock (line 156) | static void ReleaseBlock(void* arg, void* h) {
    function Iterator (line 164) | Iterator* Table::BlockReader(void* arg,
    function Iterator (line 220) | Iterator* Table::NewIterator(const ReadOptions& options) const {
    function Status (line 226) | Status Table::InternalGet(const ReadOptions& options, const Slice& k,

FILE: src/leveldb/table/table_builder.cc
  type leveldb (line 18) | namespace leveldb {
    type TableBuilder::Rep (line 20) | struct TableBuilder::Rep {
      method Rep (line 47) | Rep(const Options& opt, WritableFile* f)
    function Status (line 76) | Status TableBuilder::ChangeOptions(const Options& options) {
    function Status (line 195) | Status TableBuilder::status() const {
    function Status (line 199) | Status TableBuilder::Finish() {

FILE: src/leveldb/table/table_test.cc
  type leveldb (line 23) | namespace leveldb {
    function Reverse (line 27) | static std::string Reverse(const Slice& key) {
    class ReverseKeyComparator (line 38) | class ReverseKeyComparator : public Comparator {
      method Compare (line 44) | virtual int Compare(const Slice& a, const Slice& b) const {
      method FindShortestSeparator (line 48) | virtual void FindShortestSeparator(
      method FindShortSuccessor (line 57) | virtual void FindShortSuccessor(std::string* key) const {
    function Increment (line 66) | static void Increment(const Comparator* cmp, std::string* key) {
    type STLLessThan (line 79) | struct STLLessThan {
      method STLLessThan (line 82) | STLLessThan() : cmp(BytewiseComparator()) { }
      method STLLessThan (line 83) | STLLessThan(const Comparator* c) : cmp(c) { }
    class StringSink (line 90) | class StringSink: public WritableFile {
      method Status (line 96) | virtual Status Close() { return Status::OK(); }
      method Status (line 97) | virtual Status Flush() { return Status::OK(); }
      method Status (line 98) | virtual Status Sync() { return Status::OK(); }
      method Status (line 100) | virtual Status Append(const Slice& data) {
    class StringSource (line 110) | class StringSource: public RandomAccessFile {
      method StringSource (line 112) | StringSource(const Slice& contents)
      method Size (line 118) | uint64_t Size() const { return contents_.size(); }
      method Status (line 120) | virtual Status Read(uint64_t offset, size_t n, Slice* result,
    class Constructor (line 141) | class Constructor {
      method Constructor (line 143) | explicit Constructor(const Comparator* cmp) : data_(STLLessThan(cmp)...
      method Add (line 146) | void Add(const std::string& key, const Slice& value) {
      method Finish (line 153) | void Finish(const Options& options,
      method KVMap (line 173) | virtual const KVMap& data() { return data_; }
      method DB (line 175) | virtual DB* db() const { return NULL; }
    class BlockConstructor (line 181) | class BlockConstructor: public Constructor {
      method BlockConstructor (line 183) | explicit BlockConstructor(const Comparator* cmp)
      method Status (line 190) | virtual Status FinishImpl(const Options& options, const KVMap& data) {
      method Iterator (line 209) | virtual Iterator* NewIterator() const {
    class TableConstructor (line 221) | class TableConstructor: public Constructor {
      method TableConstructor (line 223) | TableConstructor(const Comparator* cmp)
      method Status (line 230) | virtual Status FinishImpl(const Options& options, const KVMap& data) {
      method Iterator (line 253) | virtual Iterator* NewIterator() const {
      method ApproximateOffsetOf (line 257) | uint64_t ApproximateOffsetOf(const Slice& key) const {
      method Reset (line 262) | void Reset() {
    class KeyConvertingIterator (line 276) | class KeyConvertingIterator: public Iterator {
      method KeyConvertingIterator (line 278) | explicit KeyConvertingIterator(Iterator* iter) : iter_(iter) { }
      method Valid (line 280) | virtual bool Valid() const { return iter_->Valid(); }
      method Seek (line 281) | virtual void Seek(const Slice& target) {
      method SeekToFirst (line 287) | virtual void SeekToFirst() { iter_->SeekToFirst(); }
      method SeekToLast (line 288) | virtual void SeekToLast() { iter_->SeekToLast(); }
      method Next (line 289) | virtual void Next() { iter_->Next(); }
      method Prev (line 290) | virtual void Prev() { iter_->Prev(); }
      method Slice (line 292) | virtual Slice key() const {
      method Slice (line 302) | virtual Slice value() const { return iter_->value(); }
      method Status (line 303) | virtual Status status() const {
    class MemTableConstructor (line 316) | class MemTableConstructor: public Constructor {
      method MemTableConstructor (line 318) | explicit MemTableConstructor(const Comparator* cmp)
      method Status (line 327) | virtual Status FinishImpl(const Options& options, const KVMap& data) {
      method Iterator (line 340) | virtual Iterator* NewIterator() const {
    class DBConstructor (line 349) | class DBConstructor: public Constructor {
      method DBConstructor (line 351) | explicit DBConstructor(const Comparator* cmp)
      method Status (line 360) | virtual Status FinishImpl(const Options& options, const KVMap& data) {
      method Iterator (line 373) | virtual Iterator* NewIterator() const {
      method DB (line 377) | virtual DB* db() const { return db_; }
      method NewDB (line 380) | void NewDB() {
    type TestType (line 399) | enum TestType {
    type TestArgs (line 406) | struct TestArgs {
    class Harness (line 437) | class Harness {
      method Harness (line 439) | Harness() : constructor_(NULL) { }
      method Init (line 441) | void Init(const TestArgs& args) {
      method Add (line 473) | void Add(const std::string& key, const std::string& value) {
      method Test (line 477) | void Test(Random* rnd) {
      method TestForwardScan (line 487) | void TestForwardScan(const std::vector<std::string>& keys,
      method TestBackwardScan (line 502) | void TestBackwardScan(const std::vector<std::string>& keys,
      method TestRandomAccess (line 517) | void TestRandomAccess(Random* rnd,
      method ToString (line 587) | std::string ToString(const KVMap& data, const KVMap::const_iterator&...
      method ToString (line 595) | std::string ToString(const KVMap& data,
      method ToString (line 604) | std::string ToString(const Iterator* it) {
      method PickRandomKey (line 612) | std::string PickRandomKey(Random* rnd, const std::vector<std::string...
      method DB (line 640) | DB* db() const { return constructor_->db(); }
    function TEST (line 648) | TEST(Harness, Empty) {
    function TEST (line 659) | TEST(Harness, ZeroRestartPointsInBlock) {
    function TEST (line 678) | TEST(Harness, SimpleEmptyKey) {
    function TEST (line 687) | TEST(Harness, SimpleSingle) {
    function TEST (line 696) | TEST(Harness, SimpleMulti) {
    function TEST (line 707) | TEST(Harness, SimpleSpecialKey) {
    function TEST (line 716) | TEST(Harness, Randomized) {
    function TEST (line 736) | TEST(Harness, RandomizedLongDB) {
    class MemTableTest (line 760) | class MemTableTest { }
    function TEST (line 762) | TEST(MemTableTest, Simple) {
    function Between (line 787) | static bool Between(uint64_t val, uint64_t low, uint64_t high) {
    class TableTest (line 798) | class TableTest { }
    function TEST (line 800) | TEST(TableTest, ApproximateOffsetOfPlain) {
    function SnappyCompressionSupported (line 830) | static bool SnappyCompressionSupported() {
    function TEST (line 836) | TEST(TableTest, ApproximateOffsetOfCompressed) {
  function main (line 874) | int main(int argc, char** argv) {

FILE: src/leveldb/table/two_level_iterator.cc
  type leveldb (line 12) | namespace leveldb {
    class TwoLevelIterator (line 18) | class TwoLevelIterator: public Iterator {
      method Valid (line 34) | virtual bool Valid() const {
      method Slice (line 37) | virtual Slice key() const {
      method Slice (line 41) | virtual Slice value() const {
      method Status (line 45) | virtual Status status() const {
      method SaveError (line 57) | void SaveError(const Status& s) {
    function Iterator (line 174) | Iterator* NewTwoLevelIterator(

FILE: src/leveldb/table/two_level_iterator.h
  function namespace (line 10) | namespace leveldb {

FILE: src/leveldb/util/arena.cc
  type leveldb (line 8) | namespace leveldb {

FILE: src/leveldb/util/arena.h
  function namespace (line 14) | namespace leveldb {

FILE: src/leveldb/util/arena_test.cc
  type leveldb (line 10) | namespace leveldb {
    class ArenaTest (line 12) | class ArenaTest { }
    function TEST (line 14) | TEST(ArenaTest, Empty) {
    function TEST (line 18) | TEST(ArenaTest, Simple) {
  function main (line 66) | int main(int argc, char** argv) {

FILE: src/leveldb/util/bloom.cc
  type leveldb (line 10) | namespace leveldb {
    function BloomHash (line 13) | static uint32_t BloomHash(const Slice& key) {
    class BloomFilterPolicy (line 17) | class BloomFilterPolicy : public FilterPolicy {
      method BloomFilterPolicy (line 23) | explicit BloomFilterPolicy(int bits_per_key)
      method CreateFilter (line 35) | virtual void CreateFilter(const Slice* keys, int n, std::string* dst...
      method KeyMayMatch (line 63) | virtual bool KeyMayMatch(const Slice& key, const Slice& bloom_filter...
    function FilterPolicy (line 91) | const FilterPolicy* NewBloomFilterPolicy(int bits_per_key) {

FILE: src/leveldb/util/bloom_test.cc
  type leveldb (line 12) | namespace leveldb {
    function Slice (line 16) | static Slice Key(int i, char* buffer) {
    class BloomTest (line 21) | class BloomTest {
      method BloomTest (line 28) | BloomTest() : policy_(NewBloomFilterPolicy(10)) { }
      method Reset (line 34) | void Reset() {
      method Add (line 39) | void Add(const Slice& s) {
      method Build (line 43) | void Build() {
      method FilterSize (line 55) | size_t FilterSize() const {
      method DumpFilter (line 59) | void DumpFilter() {
      method Matches (line 70) | bool Matches(const Slice& s) {
      method FalsePositiveRate (line 77) | double FalsePositiveRate() {
    function TEST (line 89) | TEST(BloomTest, EmptyFilter) {
    function TEST (line 94) | TEST(BloomTest, Small) {
    function NextLength (line 103) | static int NextLength(int length) {
    function TEST (line 116) | TEST(BloomTest, VaryingLengths) {
  function main (line 160) | int main(int argc, char** argv) {

FILE: src/leveldb/util/cache.cc
  type leveldb (line 14) | namespace leveldb {
    type LRUHandle (line 42) | struct LRUHandle {
      method Slice (line 55) | Slice key() const {
    class HandleTable (line 71) | class HandleTable {
      method HandleTable (line 73) | HandleTable() : length_(0), elems_(0), list_(NULL) { Resize(); }
      method LRUHandle (line 76) | LRUHandle* Lookup(const Slice& key, uint32_t hash) {
      method LRUHandle (line 80) | LRUHandle* Insert(LRUHandle* h) {
      method LRUHandle (line 96) | LRUHandle* Remove(const Slice& key, uint32_t hash) {
      method LRUHandle (line 116) | LRUHandle** FindPointer(const Slice& key, uint32_t hash) {
      method Resize (line 125) | void Resize() {
    class LRUCache (line 153) | class LRUCache {
      method SetCapacity (line 159) | void SetCapacity(size_t capacity) { capacity_ = capacity; }
      method TotalCharge (line 169) | size_t TotalCharge() const {
    class ShardedLRUCache (line 338) | class ShardedLRUCache : public Cache {
      method HashSlice (line 344) | static inline uint32_t HashSlice(const Slice& s) {
      method Shard (line 348) | static uint32_t Shard(uint32_t hash) {
      method ShardedLRUCache (line 353) | explicit ShardedLRUCache(size_t capacity)
      method Handle (line 361) | virtual Handle* Insert(const Slice& key, void* value, size_t charge,
      method Handle (line 366) | virtual Handle* Lookup(const Slice& key) {
      method Release (line 370) | virtual void Release(Handle* handle) {
      method Erase (line 374) | virtual void Erase(const Slice& key) {
      method NewId (line 381) | virtual uint64_t NewId() {
      method Prune (line 385) | virtual void Prune() {
      method TotalCharge (line 390) | virtual size_t TotalCharge() const {
    function Cache (line 401) | Cache* NewLRUCache(size_t capacity) {

FILE: src/leveldb/util/cache_test.cc
  type leveldb (line 11) | namespace leveldb {
    function EncodeKey (line 14) | static std::string EncodeKey(int k) {
    function DecodeKey (line 19) | static int DecodeKey(const Slice& k) {
    function DecodeValue (line 24) | static int DecodeValue(void* v) { return reinterpret_cast<uintptr_t>(v...
    class CacheTest (line 26) | class CacheTest {
      method Deleter (line 30) | static void Deleter(const Slice& key, void* v) {
      method CacheTest (line 40) | CacheTest() : cache_(NewLRUCache(kCacheSize)) {
      method Lookup (line 48) | int Lookup(int key) {
      method Insert (line 57) | void Insert(int key, int value, int charge = 1) {
      method Erase (line 67) | void Erase(int key) {
    function TEST (line 73) | TEST(CacheTest, HitAndMiss) {
    function TEST (line 96) | TEST(CacheTest, Erase) {
    function TEST (line 115) | TEST(CacheTest, EntriesArePinned) {
    function TEST (line 140) | TEST(CacheTest, EvictionPolicy) {
    function TEST (line 159) | TEST(CacheTest, UseExceedsCacheSize) {
    function TEST (line 176) | TEST(CacheTest, HeavyEntries) {
    function TEST (line 203) | TEST(CacheTest, NewId) {
    function TEST (line 209) | TEST(CacheTest, Prune) {
  function main (line 224) | int main(int argc, char** argv) {

FILE: src/leveldb/util/coding.cc
  type leveldb (line 7) | namespace leveldb {
    function EncodeFixed32 (line 9) | void EncodeFixed32(char* buf, uint32_t value) {
    function EncodeFixed64 (line 20) | void EncodeFixed64(char* buf, uint64_t value) {
    function PutFixed32 (line 35) | void PutFixed32(std::string* dst, uint32_t value) {
    function PutFixed64 (line 41) | void PutFixed64(std::string* dst, uint64_t value) {
    function PutVarint32 (line 75) | void PutVarint32(std::string* dst, uint32_t v) {
    function PutVarint64 (line 92) | void PutVarint64(std::string* dst, uint64_t v) {
    function PutLengthPrefixedSlice (line 98) | void PutLengthPrefixedSlice(std::string* dst, const Slice& value) {
    function VarintLength (line 103) | int VarintLength(uint64_t v) {
    function GetVarint32 (line 131) | bool GetVarint32(Slice* input, uint32_t* value) {
    function GetVarint64 (line 160) | bool GetVarint64(Slice* input, uint64_t* value) {
    function GetLengthPrefixedSlice (line 182) | bool GetLengthPrefixedSlice(Slice* input, Slice* result) {

FILE: src/leveldb/util/coding.h
  function namespace (line 19) | namespace leveldb {

FILE: src/leveldb/util/coding_test.cc
  type leveldb (line 9) | namespace leveldb {
    class Coding (line 11) | class Coding { }
    function TEST (line 13) | TEST(Coding, Fixed32) {
    function TEST (line 27) | TEST(Coding, Fixed64) {
    function TEST (line 55) | TEST(Coding, EncodingOutput) {
    function TEST (line 77) | TEST(Coding, Varint32) {
    function TEST (line 98) | TEST(Coding, Varint64) {
    function TEST (line 134) | TEST(Coding, Varint32Overflow) {
    function TEST (line 141) | TEST(Coding, Varint32Truncation) {
    function TEST (line 153) | TEST(Coding, Varint64Overflow) {
    function TEST (line 160) | TEST(Coding, Varint64Truncation) {
    function TEST (line 172) | TEST(Coding, Strings) {
  function main (line 194) | int main(int argc, char** argv) {

FILE: src/leveldb/util/comparator.cc
  type leveldb (line 12) | namespace leveldb {
    class BytewiseComparatorImpl (line 17) | class BytewiseComparatorImpl : public Comparator {
      method BytewiseComparatorImpl (line 19) | BytewiseComparatorImpl() { }
      method Compare (line 25) | virtual int Compare(const Slice& a, const Slice& b) const {
      method FindShortestSeparator (line 29) | virtual void FindShortestSeparator(
      method FindShortSuccessor (line 53) | virtual void FindShortSuccessor(std::string* key) const {
    function InitModule (line 72) | static void InitModule() {
    function Comparator (line 76) | const Comparator* BytewiseComparator() {

FILE: src/leveldb/util/crc32c.cc
  type leveldb (line 15) | namespace leveldb {
    type crc32c (line 16) | namespace crc32c {
      function LE_LOAD32 (line 284) | static inline uint32_t LE_LOAD32(const uint8_t *p) {
      function CanAccelerateCRC32C (line 290) | static bool CanAccelerateCRC32C() {
      function Extend (line 303) | uint32_t Extend(uint32_t crc, const char* buf, size_t size) {

FILE: src/leveldb/util/crc32c.h
  function namespace (line 11) | namespace leveldb {

FILE: src/leveldb/util/crc32c_test.cc
  type leveldb (line 8) | namespace leveldb {
    type crc32c (line 9) | namespace crc32c {
      class CRC (line 11) | class CRC { }
      function TEST (line 13) | TEST(CRC, StandardResults) {
      function TEST (line 50) | TEST(CRC, Values) {
      function TEST (line 54) | TEST(CRC, Extend) {
      function TEST (line 59) | TEST(CRC, Mask) {
  function main (line 70) | int main(int argc, char** argv) {

FILE: src/leveldb/util/env.cc
  type leveldb (line 7) | namespace leveldb {
    function Status (line 12) | Status Env::NewAppendableFile(const std::string& fname, WritableFile**...
    function Log (line 31) | void Log(Logger* info_log, const char* format, ...) {
    function Status (line 40) | static Status DoWriteStringToFile(Env* env, const Slice& data,
    function Status (line 62) | Status WriteStringToFile(Env* env, const Slice& data,
    function Status (line 67) | Status WriteStringToFileSync(Env* env, const Slice& data,
    function Status (line 72) | Status ReadFileToString(Env* env, const std::string& fname, std::strin...

FILE: src/leveldb/util/env_posix.cc
  type leveldb (line 31) | namespace leveldb {
    function Status (line 38) | static Status IOError(const std::string& context, int err_number) {
    class Limiter (line 46) | class Limiter {
      method Limiter (line 49) | Limiter(intptr_t n) {
      method Acquire (line 55) | bool Acquire() {
      method Release (line 71) | void Release() {
      method GetAllowed (line 80) | intptr_t GetAllowed() const {
      method SetAllowed (line 85) | void SetAllowed(intptr_t v) {
    class PosixSequentialFile (line 93) | class PosixSequentialFile: public SequentialFile {
      method PosixSequentialFile (line 99) | PosixSequentialFile(const std::string& fname, FILE* f)
      method Status (line 103) | virtual Status Read(size_t n, Slice* result, char* scratch) {
      method Status (line 118) | virtual Status Skip(uint64_t n) {
      method GetName (line 125) | virtual std::string GetName() const { return filename_; }
    class PosixRandomAccessFile (line 129) | class PosixRandomAccessFile: public RandomAccessFile {
      method PosixRandomAccessFile (line 137) | PosixRandomAccessFile(const std::string& fname, int fd, Limiter* lim...
      method Status (line 154) | virtual Status Read(uint64_t offset, size_t n, Slice* result,
      method GetName (line 178) | virtual std::string GetName() const { return filename_; }
    class PosixMmapReadableFile (line 182) | class PosixMmapReadableFile: public RandomAccessFile {
      method PosixMmapReadableFile (line 191) | PosixMmapReadableFile(const std::string& fname, void* base, size_t l...
      method Status (line 202) | virtual Status Read(uint64_t offset, size_t n, Slice* result,
      method GetName (line 214) | virtual std::string GetName() const { return filename_; }
    class PosixWritableFile (line 217) | class PosixWritableFile : public WritableFile {
      method PosixWritableFile (line 223) | PosixWritableFile(const std::string& fname, FILE* f)
      method Status (line 233) | virtual Status Append(const Slice& data) {
      method Status (line 241) | virtual Status Close() {
      method Status (line 250) | virtual Status Flush() {
      method Status (line 257) | Status SyncDirIfManifest() {
      method Status (line 284) | virtual Status Sync() {
      method GetName (line 297) | virtual std::string GetName() const { return filename_; }
    function LockOrUnlock (line 300) | static int LockOrUnlock(int fd, bool lock) {
    class PosixFileLock (line 311) | class PosixFileLock : public FileLock {
    class PosixLockTable (line 320) | class PosixLockTable {
      method Insert (line 325) | bool Insert(const std::string& fname) {
      method Remove (line 329) | void Remove(const std::string& fname) {
    class PosixEnv (line 335) | class PosixEnv : public Env {
      method Status (line 344) | virtual Status NewSequentialFile(const std::string& fname,
      method Status (line 356) | virtual Status NewRandomAccessFile(const std::string& fname,
      method Status (line 384) | virtual Status NewWritableFile(const std::string& fname,
      method Status (line 397) | virtual Status NewAppendableFile(const std::string& fname,
      method FileExists (line 410) | virtual bool FileExists(const std::string& fname) {
      method Status (line 414) | virtual Status GetChildren(const std::string& dir,
      method Status (line 429) | virtual Status DeleteFile(const std::string& fname) {
      method Status (line 437) | virtual Status CreateDir(const std::string& name) {
      method Status (line 445) | virtual Status DeleteDir(const std::string& name) {
      method Status (line 453) | virtual Status GetFileSize(const std::string& fname, uint64_t* size) {
      method Status (line 465) | virtual Status RenameFile(const std::string& src, const std::string&...
      method Status (line 473) | virtual Status LockFile(const std::string& fname, FileLock** lock) {
      method Status (line 495) | virtual Status UnlockFile(FileLock* lock) {
      method Status (line 511) | virtual Status GetTestDirectory(std::string* result) {
      method gettid (line 525) | static uint64_t gettid() {
      method Status (line 532) | virtual Status NewLogger(const std::string& fname, Logger** result) {
      method NowMicros (line 543) | virtual uint64_t NowMicros() {
      method SleepForMicroseconds (line 549) | virtual void SleepForMicroseconds(int micros) {
      method PthreadCall (line 554) | void PthreadCall(const char* label, int result) {
      type BGItem (line 574) | struct BGItem { void* arg; void (*function)(void*); }
    function MaxMmaps (line 584) | static int MaxMmaps() {
    function MaxOpenFiles (line 594) | static intptr_t MaxOpenFiles() {
    type StartThreadState (line 662) | struct StartThreadState {
    function InitDefaultEnv (line 687) | static void InitDefaultEnv() { default_env = new PosixEnv; }
    function Env (line 699) | Env* Env::Default() {

FILE: src/leveldb/util/env_posix_test.cc
  type leveldb (line 11) | namespace leveldb {
    class EnvPosixTest (line 17) | class EnvPosixTest {
      method EnvPosixTest (line 20) | EnvPosixTest() : env_(Env::Default()) { }
      method SetFileLimits (line 22) | static void SetFileLimits(int read_only_file_limit, int mmap_limit) {
    function TEST (line 28) | TEST(EnvPosixTest, TestOpenOnRead) {
  function main (line 61) | int main(int argc, char** argv) {

FILE: src/leveldb/util/env_posix_test_helper.h
  function namespace (line 8) | namespace leveldb {

FILE: src/leveldb/util/env_test.cc
  type leveldb (line 10) | namespace leveldb {
    class EnvTest (line 16) | class EnvTest {
      method EnvTest (line 23) | EnvTest() : env_(Env::Default()) { }
    function SetBool (line 26) | static void SetBool(void* ptr) {
    function TEST (line 30) | TEST(EnvTest, RunImmediately) {
    function TEST (line 37) | TEST(EnvTest, RunMany) {
    type State (line 69) | struct State {
    function ThreadBody (line 75) | static void ThreadBody(void* arg) {
    function TEST (line 83) | TEST(EnvTest, StartThread) {
  function main (line 104) | int main(int argc, char** argv) {

FILE: src/leveldb/util/env_win.cc
  type leveldb (line 38) | namespace leveldb
    type Win32 (line 41) | namespace Win32
      type WorkItemWrapper (line 64) | struct WorkItemWrapper
      class Win32SequentialFile (line 73) | class Win32SequentialFile : public SequentialFile
        method GetName (line 81) | virtual std::string GetName() const { return _filename; }
      class Win32RandomAccessFile (line 91) | class Win32RandomAccessFile : public RandomAccessFile
        method GetName (line 98) | virtual std::string GetName() const { return _filename; }
      class Win32WritableFile (line 108) | class Win32WritableFile : public WritableFile
        method GetName (line 119) | virtual std::string GetName() const { return filename_; }
      class Win32FileLock (line 125) | class Win32FileLock : public FileLock
      class Win32Logger (line 140) | class Win32Logger : public Logger
      class Win32Env (line 152) | class Win32Env : public Env
      function ToWidePath (line 204) | void ToWidePath(const std::string& value, std::wstring& target) {
      function ToNarrowPath (line 210) | void ToNarrowPath(const std::wstring& value, std::string& target) {
      function GetCurrentDir (line 216) | std::string GetCurrentDir()
      function GetCurrentDirW (line 224) | std::wstring GetCurrentDirW()
      function GetLastErrSz (line 251) | std::string GetLastErrSz()
      function GetLastErrSzW (line 271) | std::wstring GetLastErrSzW()
      function DWORD (line 296) | DWORD WINAPI WorkItemWrapperProc(LPVOID pContent)
      function GetPageSize (line 306) | size_t GetPageSize()
      function Status (line 327) | Status Win32SequentialFile::Read( size_t n, Slice* result, char* scr...
      function Status (line 339) | Status Win32SequentialFile::Skip( uint64_t n )
      function BOOL (line 350) | BOOL Win32SequentialFile::isEnable()
      function BOOL (line 355) | BOOL Win32SequentialFile::_Init()
      function Status (line 392) | Status Win32RandomAccessFile::Read(uint64_t offset,size_t n,Slice* r...
      function BOOL (line 407) | BOOL Win32RandomAccessFile::_Init( LPCWSTR path )
      function BOOL (line 420) | BOOL Win32RandomAccessFile::isEnable()
      function Status (line 461) | Status Win32WritableFile::Append(const Slice& data)
      function Status (line 470) | Status Win32WritableFile::Close()
      function Status (line 479) | Status Win32WritableFile::Flush()
      function Status (line 485) | Status Win32WritableFile::Sync()
      function BOOL (line 493) | BOOL Win32WritableFile::isEnable()
      function BOOL (line 511) | BOOL Win32FileLock::_Init( LPCWSTR path )
      function BOOL (line 530) | BOOL Win32FileLock::isEnable()
      function Status (line 622) | Status Win32Env::GetChildren(const std::string& dir, std::vector<std...
      function Status (line 656) | Status Win32Env::DeleteFile( const std::string& fname )
      function Status (line 669) | Status Win32Env::GetFileSize( const std::string& fname, uint64_t* fi...
      function Status (line 687) | Status Win32Env::RenameFile( const std::string& src, const std::stri...
      function Status (line 710) | Status Win32Env::LockFile( const std::string& fname, FileLock** lock )
      function Status (line 726) | Status Win32Env::UnlockFile( FileLock* lock )
      function Status (line 745) | Status Win32Env::GetTestDirectory( std::string* path )
      function Status (line 764) | static Status CreateDirInner( const std::string& dirname )
      function Status (line 783) | Status Win32Env::CreateDir( const std::string& dirname )
      function Status (line 794) | Status Win32Env::DeleteDir( const std::string& dirname )
      function Status (line 806) | Status Win32Env::NewSequentialFile( const std::string& fname, Sequen...
      function Status (line 821) | Status Win32Env::NewRandomAccessFile( const std::string& fname, Rand...
      function Status (line 835) | Status Win32Env::NewLogger( const std::string& fname, Logger** result )
      function Status (line 851) | Status Win32Env::NewWritableFile( const std::string& fname, Writable...
      function Status (line 864) | Status Win32Env::NewAppendableFile( const std::string& fname, Writab...
    function InitDefaultEnv (line 892) | static void InitDefaultEnv() { default_env = new Win32::Win32Env(); }
    function Env (line 894) | Env* Env::Default() {

FILE: src/leveldb/util/filter_policy.cc
  type leveldb (line 7) | namespace leveldb {

FILE: src/leveldb/util/hash.cc
  type leveldb (line 16) | namespace leveldb {
    function Hash (line 18) | uint32_t Hash(const char* data, size_t n, uint32_t seed) {

FILE: src/leveldb/util/hash.h
  function namespace (line 13) | namespace leveldb {

FILE: src/leveldb/util/hash_test.cc
  type leveldb (line 8) | namespace leveldb {
    class HASH (line 10) | class HASH { }
    function TEST (line 12) | TEST(HASH, SignedUnsignedIssue) {
  function main (line 52) | int main(int argc, char** argv) {

FILE: src/leveldb/util/histogram.cc
  type leveldb (line 10) | namespace leveldb {

FILE: src/leveldb/util/histogram.h
  function namespace (line 10) | namespace leveldb {

FILE: src/leveldb/util/logging.cc
  type leveldb (line 14) | namespace leveldb {
    function AppendNumberTo (line 16) | void AppendNumberTo(std::string* str, uint64_t num) {
    function AppendEscapedStringTo (line 22) | void AppendEscapedStringTo(std::string* str, const Slice& value) {
    function NumberToString (line 36) | std::string NumberToString(uint64_t num) {
    function EscapeString (line 42) | std::string EscapeString(const Slice& value) {
    function ConsumeDecimalNumber (line 48) | bool ConsumeDecimalNumber(Slice* in, uint64_t* val) {

FILE: src/leveldb/util/logging.h
  function namespace (line 16) | namespace leveldb {

FILE: src/leveldb/util/mutexlock.h
  function namespace (line 11) | namespace leveldb {

FILE: src/leveldb/util/options.cc
  type leveldb (line 10) | namespace leveldb {

FILE: src/leveldb/util/posix_logger.h
  function namespace (line 17) | namespace leveldb {

FILE: src/leveldb/util/random.h
  function namespace (line 10) | namespace leveldb {

FILE: src/leveldb/util/status.cc
  type leveldb (line 9) | namespace leveldb {

FILE: src/leveldb/util/testharness.cc
  type leveldb (line 12) | namespace leveldb {
    type test (line 13) | namespace test {
      type Test (line 16) | struct Test {
      function RegisterTest (line 24) | bool RegisterTest(const char* base, const char* name, void (*func)()) {
      function RunAllTests (line 36) | int RunAllTests() {
      function TmpDir (line 60) | std::string TmpDir() {
      function RandomSeed (line 67) | int RandomSeed() {

FILE: src/leveldb/util/testharness.h
  function namespace (line 15) | namespace leveldb {

FILE: src/leveldb/util/testutil.cc
  type leveldb (line 9) | namespace leveldb {
    type test (line 10) | namespace test {
      function Slice (line 12) | Slice RandomString(Random* rnd, int len, std::string* dst) {
      function RandomKey (line 20) | std::string RandomKey(Random* rnd, int len) {
      function Slice (line 34) | extern Slice CompressibleString(Random* rnd, double compressed_fract...

FILE: src/leveldb/util/testutil.h
  function namespace (line 12) | namespace leveldb {

FILE: src/limitedmap.h
  type V (line 17) | typedef V mapped_type;
  type std (line 18) | typedef std::pair<const key_type, mapped_type> value_type;
  type typename (line 19) | typedef typename std::map<K, V>::const_iterator const_iterator;
  type typename (line 20) | typedef typename std::map<K, V>::size_type size_type;
  type typename (line 24) | typedef typename std::map<K, V>::iterator iterator;
  type typename (line 26) | typedef typename std::multimap<V, iterator>::iterator rmap_iterator;
  function const_iterator (line 39) | const_iterator find(const key_type& k) const { return map.find(k); }
  function size_type (line 40) | size_type count(const key_type& k) const { return map.count(k); }
  function insert (line 41) | void insert(const value_type& x)
  function erase (line 52) | void erase(const key_type& k)
  function update (line 67) | void update(const_iterator itIn, const mapped_type& v)
  function size_type (line 88) | size_type max_size(size_type s)

FILE: src/memusage.h
  function namespace (line 20) | namespace memusage
  function DynamicUsage (line 97) | inline size_t DynamicUsage(const std::set<X, Y>& s)
  function IncrementalDynamicUsage (line 103) | inline size_t IncrementalDynamicUsage(const std::set<X, Y>& s)
  function DynamicUsage (line 109) | inline size_t DynamicUsage(const std::map<X, Y, Z>& m)
  function IncrementalDynamicUsage (line 115) | inline size_t IncrementalDynamicUsage(const std::map<X, Y, Z>& m)
  function DynamicUsage (line 123) | inline size_t DynamicUsage(const indirectmap<X, Y>& m)
  function IncrementalDynamicUsage (line 129) | inline size_t IncrementalDynamicUsage(const indirectmap<X, Y>& m)
  function DynamicUsage (line 135) | inline size_t DynamicUsage(const std::unique_ptr<X>& p)
  function DynamicUsage (line 141) | inline size_t DynamicUsage(const std::shared_ptr<X>& p)
  function DynamicUsage (line 157) | inline size_t DynamicUsage(const std::unordered_set<X, Y>& s)
  function DynamicUsage (line 163) | inline size_t DynamicUsage(const std::unordered_map<X, Y, Z>& m)

FILE: src/merkleblock.cpp
  function uint256 (line 40) | uint256 CPartialMerkleTree::CalcHash(int height, unsigned int pos, const...
  function uint256 (line 78) | uint256 CPartialMerkleTree::TraverseAndExtract(int height, unsigned int ...
  function uint256 (line 132) | uint256 CPartialMerkleTree::ExtractMatches(std::vector<uint256> &vMatch,...

FILE: src/merkleblock.h
  function class (line 50) | class CPartialMerkleTree
  function class (line 133) | class CMerkleBlock

FILE: src/miner.cpp
  function UpdateTime (line 48) | int64_t UpdateTime(CBlockHeader* pblock, const Consensus::Params& consen...
  function DefaultOptions (line 75) | static BlockAssembler::Options DefaultOptions(const CChainParams& params)
  function IncrementExtraNonce (line 441) | void IncrementExtraNonce(CBlock* pblock, const CBlockIndex* pindexPrev, ...

FILE: src/miner.h
  function namespace (line 21) | namespace Consensus { struct Params; }
  type CBlockTemplate (line 25) | struct CBlockTemplate
  function GetModifiedFee (line 35) | struct CTxMemPoolModifiedEntry {
  type CompareCTxMemPoolIter (line 61) | struct CompareCTxMemPoolIter {
  type modifiedentry_iter (line 68) | struct modifiedentry_iter {
  type CompareTxIterByAncestorCount (line 79) | struct CompareTxIterByAncestorCount {
  type boost (line 88) | typedef boost::multi_index_container<
  type indexed_modified_transaction_set (line 105) | typedef indexed_modified_transaction_set::nth_index<0>::type::iterator m...
  type indexed_modified_transaction_set (line 106) | typedef indexed_modified_transaction_set::index<ancestor_score>::type::i...
  type update_for_parent_inclusion (line 108) | struct update_for_parent_inclusion
  function class (line 123) | class BlockAssembler

FILE: src/net.cpp
  type BindFlags (line 67) | enum BindFlags {
  function GetListenPort (line 97) | unsigned short GetListenPort()
  function GetLocal (line 103) | bool GetLocal(CService& addr, const CNetAddr *paddrPeer)
  function convertSeed6 (line 128) | static std::vector<CAddress> convertSeed6(const std::vector<SeedSpec6> &...
  function CAddress (line 151) | CAddress GetLocalAddress(const CNetAddr *paddrPeer, ServiceFlags nLocalS...
  function GetnScore (line 163) | int GetnScore(const CService& addr)
  function IsPeerAddrLocalGood (line 172) | bool IsPeerAddrLocalGood(CNode *pnode)
  function AdvertiseLocal (line 180) | void AdvertiseLocal(CNode *pnode)
  function AddLocal (line 203) | bool AddLocal(const CService& addr, int nScore)
  function AddLocal (line 229) | bool AddLocal(const CNetAddr &addr, int nScore)
  function RemoveLocal (line 234) | bool RemoveLocal(const CService& addr)
  function SetLimited (line 243) | void SetLimited(enum Network net, bool fLimited)
  function IsLimited (line 251) | bool IsLimited(enum Network net)
  function IsLimited (line 257) | bool IsLimited(const CNetAddr &addr)
  function SeenLocal (line 263) | bool SeenLocal(const CService& addr)
  function IsLocal (line 276) | bool IsLocal(const CService& addr)
  function IsReachable (line 283) | bool IsReachable(enum Network net)
  function IsReachable (line 290) | bool IsReachable(const CNetAddr& addr)
  function CNode (line 297) | CNode* CConnman::FindNode(const CNetAddr& ip)
  function CNode (line 308) | CNode* CConnman::FindNode(const CSubNet& subNet)
  function CNode (line 319) | CNode* CConnman::FindNode(const std::string& addrName)
  function CNode (line 330) | CNode* CConnman::FindNode(const CService& addr)
  function CAddress (line 352) | static CAddress GetBindAddress(SOCKET sock)
  function CNode (line 367) | CNode* CConnman::ConnectNode(CAddress addrConnect, const char *pszDest, ...
  function CService (line 665) | CService CNode::GetAddrLocal() const {
  function uint256 (line 865) | const uint256& CNetMessage::GetMessageHash() const
  type NodeEvictionCandidate (line 934) | struct NodeEvictionCandidate
  function ReverseCompareNodeMinPingTime (line 948) | static bool ReverseCompareNodeMinPingTime(const NodeEvictionCandidate &a...
  function ReverseCompareNodeTimeConnected (line 953) | static bool ReverseCompareNodeTimeConnected(const NodeEvictionCandidate ...
  function CompareNetGroupKeyed (line 958) | static bool CompareNetGroupKeyed(const NodeEvictionCandidate &a, const N...
  function CompareNodeBlockTime (line 962) | static bool CompareNodeBlockTime(const NodeEvictionCandidate &a, const N...
  function CompareNodeTXTime (line 970) | static bool CompareNodeTXTime(const NodeEvictionCandidate &a, const Node...
  function EraseLastKElements (line 982) | static void EraseLastKElements(std::vector<T> &elements, Comparator comp...
  type sockaddr_storage (line 1072) | struct sockaddr_storage
  type sockaddr (line 1074) | struct sockaddr
  type sockaddr (line 1080) | struct sockaddr
  type timeval (line 1221) | struct timeval
  function ThreadMapPort (line 1463) | void ThreadMapPort()
  function MapPort (line 1550) | void MapPort(bool fUseUPnP)
  function MapPort (line 1570) | void MapPort(bool)
  type sockaddr_storage (line 2056) | struct sockaddr_storage
  type sockaddr (line 2058) | struct sockaddr
  type sockaddr (line 2096) | struct sockaddr
  function Discover (line 2126) | void Discover(boost::thread_group& threadGroup)
  function NodeId (line 2213) | NodeId CConnman::GetNewNodeId()
  type in_addr (line 2241) | struct in_addr
  class CNetCleanup (line 2368) | class CNetCleanup
    method CNetCleanup (line 2371) | CNetCleanup() {}
  function ServiceFlags (line 2669) | ServiceFlags CConnman::GetLocalServices() const
  function PoissonNextSend (line 2852) | int64_t PoissonNextSend(int64_t nNow, int average_interval_seconds) {
  function CSipHasher (line 2856) | CSipHasher CConnman::GetDeterministicRandomizer(uint64_t id) const

FILE: src/net.h
  function namespace (line 40) | namespace boost {
  type NodeId (line 90) | typedef int64_t NodeId;
  type AddedNodeInfo (line 92) | struct AddedNodeInfo
  type CSerializedNetMsg (line 103) | struct CSerializedNetMsg
  function class (line 117) | class CConnman
  type CombinerAll (line 449) | struct CombinerAll
  function class (line 467) | class NetEventsInterface
  type Network (line 489) | enum Network
  type Network (line 490) | enum Network
  type Network (line 498) | enum Network
  type LocalServiceInfo (line 512) | struct LocalServiceInfo {
  type std (line 519) | typedef std::map<std::string, uint64_t> mapMsgCmdSize;
  function class (line 521) | class CNodeStats
  function class (line 556) | class CNetMessage {
  function uint256 (line 587) | const uint256& GetMessageHash() const;

FILE: src/net_processing.cpp
  type IteratorComparator (line 42) | struct IteratorComparator
  type COrphanTx (line 51) | struct COrphanTx {
  type QueuedBlock (line 113) | struct QueuedBlock {
  type CBlockReject (line 145) | struct CBlockReject {
  type CNodeState (line 157) | struct CNodeState {
    type ChainSyncTimeoutState (line 227) | struct ChainSyncTimeoutState {
    method CNodeState (line 243) | CNodeState(CAddress addrIn, std::string addrNameIn) : address(addrIn),...
  function CNodeState (line 274) | CNodeState *State(NodeId pnode) {
    type ChainSyncTimeoutState (line 227) | struct ChainSyncTimeoutState {
    method CNodeState (line 243) | CNodeState(CAddress addrIn, std::string addrNameIn) : address(addrIn),...
  function UpdatePreferredDownload (line 281) | void UpdatePreferredDownload(CNode* node, CNodeState* state)
  function PushNodeVersion (line 291) | void PushNodeVersion(CNode *pnode, CConnman* connman, int64_t nTime)
  function MarkBlockAsReceived (line 315) | bool MarkBlockAsReceived(const uint256& hash) {
  function MarkBlockAsInFlight (line 341) | bool MarkBlockAsInFlight(NodeId nodeid, const uint256& hash, const CBloc...
  function ProcessBlockAvailability (line 375) | void ProcessBlockAvailability(NodeId nodeid) {
  function UpdateBlockAvailability (line 390) | void UpdateBlockAvailability(NodeId nodeid, const uint256 &hash) {
  function MaybeSetPeerAsAnnouncingHeaderAndIDs (line 407) | void MaybeSetPeerAsAnnouncingHeaderAndIDs(NodeId nodeid, CConnman* connm...
  function TipMayBeStale (line 440) | bool TipMayBeStale(const Consensus::Params &consensusParams)
  function CanDirectFetch (line 450) | bool CanDirectFetch(const Consensus::Params &consensusParams)
  function PeerHasHeader (line 456) | bool PeerHasHeader(CNodeState *state, const CBlockIndex *pindex)
  function FindNextBlocksToDownload (line 467) | void FindNextBlocksToDownload(NodeId nodeid, unsigned int count, std::ve...
  function UpdateLastBlockAnnounceTime (line 557) | void UpdateLastBlockAnnounceTime(NodeId node, int64_t time_in_seconds)
  function IsOutboundDisconnectionCandidate (line 566) | bool IsOutboundDisconnectionCandidate(const CNode *node)
  function GetNodeStateStats (line 618) | bool GetNodeStateStats(NodeId nodeid, CNodeStateStats &stats) {
  function EXCLUSIVE_LOCKS_REQUIRED (line 638) | EXCLUSIVE_LOCKS_REQUIRED(g_cs_orphans)
  function EXCLUSIVE_LOCKS_REQUIRED (line 649) | EXCLUSIVE_LOCKS_REQUIRED(g_cs_orphans)
  function EXCLUSIVE_LOCKS_REQUIRED (line 682) | EXCLUSIVE_LOCKS_REQUIRED(g_cs_orphans)
  function EraseOrphansFor (line 700) | void EraseOrphansFor(NodeId peer)
  function LimitOrphanTxSize (line 717) | unsigned int LimitOrphanTxSize(unsigned int nMaxOrphans)
  function Misbehaving (line 756) | void Misbehaving(NodeId pnode, int howmuch)
  function BlockRequestAllowed (line 791) | static bool BlockRequestAllowed(const CBlockIndex* pindex, const Consens...
  function EXCLUSIVE_LOCKS_REQUIRED (line 963) | EXCLUSIVE_LOCKS_REQUIRED(cs_main)
  function RelayTransaction (line 999) | static void RelayTransaction(const CTransaction& tx, CConnman* connman)
  function RelayAddress (line 1008) | static void RelayAddress(const CAddress& addr, bool fReachable, CConnman...
  function ProcessGetBlockData (line 1044) | void static ProcessGetBlockData(CNode* pfrom, const Consensus::Params& c...
  function ProcessGetData (line 1186) | void static ProcessGetData(CNode* pfrom, const Consensus::Params& consen...
  function GetFetchFlags (line 1250) | uint32_t GetFetchFlags(CNode* pfrom) {
  function SendBlockTransactions (line 1258) | inline void static SendBlockTransactions(const CBlock& block, const Bloc...
  function ProcessHeadersMessage (line 1275) | bool static ProcessHeadersMessage(CNode *pfrom, CConnman *connman, const...
  function ProcessMessage (line 1498) | bool static ProcessMessage(CNode* pfrom, const std::string& strCommand, ...
  function SendRejectsAndCheckIfBanned (line 2862) | static bool SendRejectsAndCheckIfBanned(CNode* pnode, CConnman* connman)
  class CompareInvMempoolOrder (line 3144) | class CompareInvMempoolOrder
    method CompareInvMempoolOrder (line 3148) | explicit CompareInvMempoolOrder(CTxMemPool *_mempool)
  class CNetProcessingCleanup (line 3697) | class CNetProcessingCleanup
    method CNetProcessingCleanup (line 3700) | CNetProcessingCleanup() {}

FILE: src/net_processing.h
  type CNodeStateStats (line 81) | struct CNodeStateStats {

FILE: src/netaddress.cpp
  type in_addr (line 75) | struct in_addr
  type in6_addr (line 80) | struct in6_addr
  type Network (line 242) | enum Network
  type sockaddr_storage (line 266) | struct sockaddr_storage
  type sockaddr (line 268) | struct sockaddr
  type sockaddr (line 270) | struct sockaddr
  type in_addr (line 303) | struct in_addr
  type in6_addr (line 311) | struct in6_addr
  function GetExtNetwork (line 404) | int static GetExtNetwork(const CNetAddr *addr)
  type Reachability (line 416) | enum Reachability {
  type in_addr (line 486) | struct in_addr
  type in6_addr (line 490) | struct in6_addr
  type sockaddr_in (line 494) | struct sockaddr_in
  type sockaddr_in6 (line 499) | struct sockaddr_in6
  type sockaddr (line 504) | struct sockaddr
  type sockaddr_in (line 508) | struct sockaddr_in
  type sockaddr_in6 (line 511) | struct sockaddr_in6
  type sockaddr (line 538) | struct sockaddr
  type sockaddr_in (line 541) | struct sockaddr_in
  type sockaddr_in (line 543) | struct sockaddr_in
  type sockaddr_in (line 544) | struct sockaddr_in
  type sockaddr_in (line 544) | struct sockaddr_in
  type sockaddr_in6 (line 553) | struct sockaddr_in6
  type sockaddr_in6 (line 555) | struct sockaddr_in6
  type sockaddr_in6 (line 556) | struct sockaddr_in6
  type sockaddr_in6 (line 556) | struct sockaddr_in6
  function NetmaskBits (line 663) | static inline int NetmaskBits(uint8_t x)

FILE: src/netaddress.h
  type Network (line 19) | enum Network
  type in_addr (line 39) | struct in_addr
  function IsIPv4 (line 56) | bool IsIPv4() const;    // IPv4 mapped address (::FFFF:0:0/96, 0.0.0.0/0)

FILE: src/netbase.cpp
  function ParseNetwork (line 42) | enum Network ParseNetwork(std::string net) {
  function GetNetworkName (line 50) | std::string GetNetworkName(enum Network net) {
  function LookupIntern (line 60) | bool static LookupIntern(const char *pszName, std::vector<CNetAddr>& vIP...
  function LookupHost (line 117) | bool LookupHost(const char *pszName, std::vector<CNetAddr>& vIP, unsigne...
  function LookupHost (line 130) | bool LookupHost(const char *pszName, CNetAddr& addr, bool fAllowLookup)
  function Lookup (line 140) | bool Lookup(const char *pszName, std::vector<CService>& vAddr, int portD...
  function Lookup (line 158) | bool Lookup(const char *pszName, CService& addr, int portDefault, bool f...
  function CService (line 168) | CService LookupNumeric(const char *pszName, int portDefault)
  function MillisToTimeval (line 178) | struct timeval MillisToTimeval(int64_t nTimeout)
  type SOCKSVersion (line 187) | enum SOCKSVersion: uint8_t {
  type SOCKS5Method (line 193) | enum SOCKS5Method: uint8_t {
  type SOCKS5Command (line 201) | enum SOCKS5Command: uint8_t {
  type SOCKS5Reply (line 208) | enum SOCKS5Reply: uint8_t {
  type SOCKS5Atyp (line 221) | enum SOCKS5Atyp: uint8_t {
  type IntrRecvError (line 228) | enum class IntrRecvError {
  function IntrRecvError (line 247) | static IntrRecvError InterruptibleRecv(uint8_t* data, size_t len, int ti...
  type ProxyCredentials (line 287) | struct ProxyCredentials
  function Socks5ErrorString (line 294) | std::string Socks5ErrorString(uint8_t err)
  function Socks5 (line 319) | static bool Socks5(const std::string& strDest, int port, const ProxyCred...
  function SOCKET (line 438) | SOCKET CreateSocket(const CService &addrConnect)
  function ConnectSocketDirectly (line 474) | bool ConnectSocketDirectly(const CService &addrConnect, const SOCKET& hS...
  function SetProxy (line 540) | bool SetProxy(enum Network net, const proxyType &addrProxy) {
  function GetProxy (line 549) | bool GetProxy(enum Network net, proxyType &proxyInfoOut) {
  function SetNameProxy (line 558) | bool SetNameProxy(const proxyType &addrProxy) {
  function GetNameProxy (line 566) | bool GetNameProxy(proxyType &nameProxyOut) {
  function HaveNameProxy (line 574) | bool HaveNameProxy() {
  function IsProxy (line 579) | bool IsProxy(const CNetAddr &addr) {
  function ConnectThroughProxy (line 588) | bool ConnectThroughProxy(const proxyType &proxy, const std::string& strD...
  function LookupSubNet (line 611) | bool LookupSubNet(const char* pszName, CSubNet& ret)
  function NetworkErrorString (line 649) | std::string NetworkErrorString(int err)
  function NetworkErrorString (line 665) | std::string NetworkErrorString(int err)
  function CloseSocket (line 683) | bool CloseSocket(SOCKET& hSocket)
  function SetSocketNoDelay (line 726) | bool SetSocketNoDelay(const SOCKET& hSocket)
  function InterruptSocks5 (line 733) | void InterruptSocks5(bool interrupt)

FILE: src/netbase.h
  function class (line 28) | class proxyType
  type Network (line 40) | enum Network
  type Network (line 41) | enum Network
  type Network (line 42) | enum Network
  type Network (line 43) | enum Network
  type timeval (line 68) | struct timeval

FILE: src/netmessagemaker.h
  function class (line 12) | class CNetMsgMaker

FILE: src/noui.cpp
  function noui_ThreadSafeMessageBox (line 15) | static bool noui_ThreadSafeMessageBox(const std::string& message, const ...
  function noui_ThreadSafeQuestion (line 42) | static bool noui_ThreadSafeQuestion(const std::string& /* ignored intera...
  function noui_InitMessage (line 47) | static void noui_InitMessage(const std::string& message)
  function noui_connect (line 52) | void noui_connect()

FILE: src/policy/feerate.cpp
  function CAmount (line 23) | CAmount CFeeRate::GetFee(size_t nBytes_) const

FILE: src/policy/feerate.h
  function class (line 19) | class CFeeRate

FILE: src/policy/fees.cpp
  function StringForFeeEstimateHorizon (line 17) | std::string StringForFeeEstimateHorizon(FeeEstimateHorizon horizon) {
  function StringForFeeReason (line 30) | std::string StringForFeeReason(FeeReason reason) {
  function FeeModeFromString (line 50) | bool FeeModeFromString(const std::string& mode_string, FeeEstimateMode& ...
  class TxConfirmStats (line 72) | class TxConfirmStats
    method GetMaxConfirms (line 162) | unsigned int GetMaxConfirms() const { return scale * confAvg.size(); }
  function CFeeRate (line 664) | CFeeRate CBlockPolicyEstimator::estimateFee(int confTarget) const
  function CFeeRate (line 673) | CFeeRate CBlockPolicyEstimator::estimateRawFee(int confTarget, double su...
  function CFeeRate (line 820) | CFeeRate CBlockPolicyEstimator::estimateSmartFee(int confTarget, FeeCalc...
  function CAmount (line 1005) | CAmount FeeFilterRounder::round(CAmount currentMinFee)

FILE: src/policy/fees.h
  type FeeEstimateHorizon (line 72) | enum FeeEstimateHorizon {
  type class (line 81) | enum class
  type class (line 97) | enum class
  type EstimatorBucket (line 106) | struct EstimatorBucket
  type EstimationResult (line 117) | struct EstimationResult
  type FeeCalculation (line 125) | struct FeeCalculation
  type TxStatsInfo (line 238) | struct TxStatsInfo

FILE: src/policy/policy.cpp
  function CAmount (line 18) | CAmount GetDustThreshold(const CTxOut& txout, const CFeeRate& dustRelayF...
  function IsDust (line 52) | bool IsDust(const CTxOut& txout, const CFeeRate& dustRelayFeeIn)
  function IsStandard (line 57) | bool IsStandard(const CScript& scriptPubKey, txnouttype& whichType, cons...
  function IsStandardTx (line 82) | bool IsStandardTx(const CTransaction& tx, std::string& reason, const boo...
  function AreInputsStandard (line 162) | bool AreInputsStandard(const CTransaction& tx, const CCoinsViewCache& ma...
  function IsWitnessStandard (line 196) | bool IsWitnessStandard(const CTransaction& tx, const CCoinsViewCache& ma...
  function GetVirtualTransactionSize (line 252) | int64_t GetVirtualTransactionSize(int64_t nWeight, int64_t nSigOpCost)
  function GetVirtualTransactionSize (line 257) | int64_t GetVirtualTransactionSize(const CTransaction& tx, int64_t nSigOp...

FILE: src/policy/rbf.cpp
  function SignalsOptInRBF (line 7) | bool SignalsOptInRBF(const CTransaction &tx)
  function RBFTransactionState (line 17) | RBFTransactionState IsRBFOptIn(const CTransaction &tx, CTxMemPool &pool)

FILE: src/policy/rbf.h
  type RBFTransactionState (line 12) | enum RBFTransactionState {

FILE: src/pow.cpp
  function GetNextWorkRequired_BTC (line 15) | unsigned int GetNextWorkRequired_BTC(const CBlockIndex* pindexLast, cons...
  function GetNextWorkRequired (line 52) | unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CB...
  function CalculateNextWorkRequired_BTC (line 100) | unsigned int CalculateNextWorkRequired_BTC(const CBlockIndex* pindexLast...
  function CalculateNextWorkRequired (line 126) | unsigned int CalculateNextWorkRequired(arith_uint256 bnAvg,
  function CheckProofOfWork (line 152) | bool CheckProofOfWork(uint256 hash, unsigned int nBits, const Consensus:...

FILE: src/prevector.h
  type Diff (line 39) | typedef Diff difference_type;
  type T (line 40) | typedef T value_type;
  type value_type (line 41) | typedef value_type& reference;
  type value_type (line 42) | typedef const value_type& const_reference;
  type value_type (line 43) | typedef value_type* pointer;
  type value_type (line 44) | typedef const value_type* const_pointer;
  function class (line 46) | class iterator {
  function T (line 157) | T* direct_ptr(difference_type pos) { return reinterpret_cast<T*>(_union....
  function T (line 158) | const T* direct_ptr(difference_type pos) const { return reinterpret_cast...
  function T (line 159) | T* indirect_ptr(difference_type pos) { return reinterpret_cast<T*>(_unio...
  function T (line 160) | const T* indirect_ptr(difference_type pos) const { return reinterpret_ca...
  function change_capacity (line 163) | void change_capacity(size_type new_capacity) {
  function T (line 194) | T* item_ptr(difference_type pos) { return is_direct() ? direct_ptr(pos) ...
  function T (line 195) | const T* item_ptr(difference_type pos) const { return is_direct() ? dire...
  function explicit (line 225) | explicit prevector(size_type n) : _size(0) {
  function iterator (line 290) | iterator begin() { return iterator(item_ptr(0)); }
  function iterator (line 292) | iterator end() { return iterator(item_ptr(size())); }
  function const_iterator (line 293) | const_iterator end() const { return const_iterator(item_ptr(size())); }
  function reverse_iterator (line 297) | reverse_iterator rend() { return reverse_iterator(item_ptr(-1)); }
  function T (line 312) | const T& operator[](size_type pos) const {
  function resize (line 316) | void resize(size_type new_size) {
  function reserve (line 329) | void reserve(size_type new_capacity) {
  function shrink_to_fit (line 335) | void shrink_to_fit() {
  function clear (line 339) | void clear() {
  function iterator (line 343) | iterator insert(iterator pos, const T& value) {
  function insert (line 355) | void insert(iterator pos, size_type count, const T& value) {
  function iterator (line 385) | iterator erase(iterator pos) {
  function iterator (line 389) | iterator erase(iterator first, iterator last) {
  function push_back (line 411) | void push_back(const T& value) {
  function pop_back (line 420) | void pop_back() {
  function swap (line 440) | void swap(prevector<N, T, Size, Diff>& other) {
  function value_type (line 507) | value_type* data() {
  function value_type (line 511) | const value_type* data() const {

FILE: src/primitives/block.cpp
  function uint256 (line 25) | uint256 CBlockHeaderUncached::GetHash() const
  function uint256 (line 31) | uint256 CBlockHeaderUncached::GetPoWHash() const
  function uint256 (line 51) | uint256 CBlockHeader::GetPoWHash_cached() const

FILE: src/primitives/block.h
  function class (line 24) | class CBlockHeaderUncached
  function SetNull (line 52) | void SetNull()
  function uint256 (line 67) | uint256 GetHash() const;
  function uint256 (line 103) | uint256 GetPoWHash_cached() const;
  function SetNull (line 134) | void SetNull()
  function CBlockHeader (line 141) | CBlockHeader GetBlockHeader() const

FILE: src/primitives/transaction.cpp
  function uint256 (line 60) | uint256 CMutableTransaction::GetHash() const
  function uint256 (line 65) | uint256 CTransaction::ComputeHash() const
  function uint256 (line 70) | uint256 CTransaction::GetWitnessHash() const
  function CAmount (line 83) | CAmount CTransaction::GetValueOut() const

FILE: src/primitives/transaction.h
  function class (line 18) | class COutPoint
  function SetNull (line 35) | void SetNull() { hash.SetNull(); n = (uint32_t) -1; }
  function class (line 61) | class CTxIn
  function class (line 131) | class CTxOut
  function SetNull (line 152) | void SetNull()
  type CMutableTransaction (line 177) | struct CMutableTransaction
  function SerializeTransaction (line 232) | void SerializeTransaction(const TxType& tx, Stream& s) {
  function class (line 264) | class CTransaction
  function CTransaction (line 308) | CTransaction(CMutableTransaction(deserialize, s)) {}
  function uint256 (line 319) | uint256 GetWitnessHash() const;
  function Unserialize (line 362) | struct CMutableTransaction
  function uint256 (line 391) | uint256 GetHash() const;
  type std (line 409) | typedef std::shared_ptr<const CTransaction> CTransactionRef;
  function CTransactionRef (line 410) | static inline CTransactionRef MakeTransactionRef() { return std::make_sh...
  function CTransactionRef (line 411) | inline CTransactionRef MakeTransactionRef(Tx&& txIn) { return std::make_...

FILE: src/protocol.cpp
  type NetMsgType (line 15) | namespace NetMsgType {

FILE: src/protocol.h
  function class (line 27) | class CMessageHeader
  function namespace (line 66) | namespace NetMsgType {
  type ServiceFlags (line 246) | enum ServiceFlags : uint64_t {
  function ServiceFlags (line 304) | static ServiceFlags GetDesirableServiceFlags(ServiceFlags services) {
  function HasAllDesirableServiceFlags (line 313) | static inline bool HasAllDesirableServiceFlags(ServiceFlags services) {
  function MayHaveUsefulAddressDB (line 321) | static inline bool MayHaveUsefulAddressDB(ServiceFlags services) {
  function class (line 326) | class CAddress : public CService
  type GetDataMsg (line 369) | enum GetDataMsg
  function class (line 383) | class CInv

FILE: src/pubkey.cpp
  function ecdsa_signature_parse_der_lax (line 27) | static int ecdsa_signature_parse_der_lax(const secp256k1_context* ctx, s...

FILE: src/pubkey.h
  function class (line 20) | class CKeyID : public uint160
  type uint256 (line 27) | typedef uint256 ChainCode;
  function class (line 30) | class CPubKey
  function explicit (line 98) | explicit CPubKey(const std::vector<unsigned char>& _vch)
  function const (line 107) | const unsigned char& operator[](unsigned int pos) const { return vch[pos...
  function IsFullyValid (line 171) | bool IsFullyValid() const;
  function class (line 248) | class ECCVerifyHandle

FILE: src/qt/addressbookpage.h
  function namespace (line 13) | namespace Ui {
  type Tabs (line 31) | enum Tabs {
  type Mode (line 36) | enum Mode {

FILE: src/qt/addresstablemodel.cpp
  type AddressTableEntry (line 20) | struct AddressTableEntry
    type Type (line 22) | enum Type {
    method AddressTableEntry (line 32) | AddressTableEntry() {}
    method AddressTableEntry (line 33) | AddressTableEntry(Type _type, const QString &_label, const QString &_a...
  type AddressTableEntryLessThan (line 37) | struct AddressTableEntryLessThan
  function translateTransactionType (line 54) | static AddressTableEntry::Type translateTransactionType(const QString &s...
  class AddressTablePriv (line 68) | class AddressTablePriv
    method AddressTablePriv (line 75) | AddressTablePriv(CWallet *_wallet, AddressTableModel *_parent):
    method refreshAddressTable (line 78) | void refreshAddressTable()
    method updateEntry (line 101) | void updateEntry(const QString &address, const QString &label, bool is...
    method size (line 148) | int size()
    method AddressTableEntry (line 153) | AddressTableEntry *index(int idx)
  function QVariant (line 191) | QVariant AddressTableModel::data(const QModelIndex &index, int role) const
  function QVariant (line 294) | QVariant AddressTableModel::headerData(int section, Qt::Orientation orie...
  function QModelIndex (line 323) | QModelIndex AddressTableModel::index(int row, int column, const QModelIn...
  function QString (line 344) | QString AddressTableModel::addRow(const QString &type, const QString &la...
  function QString (line 423) | QString AddressTableModel::labelForAddress(const QString &address) const

FILE: src/qt/addresstablemodel.h
  type OutputType (line 11) | enum OutputType : int
  function class (line 21) | class AddressTableModel : public QAbstractTableModel

FILE: src/qt/askpassphrasedialog.cpp
  function SecureClearQLineEdit (line 273) | static void SecureClearQLineEdit(QLineEdit* edit)

FILE: src/qt/askpassphrasedialog.h
  function namespace (line 12) | namespace Ui {
  function class (line 18) | class AskPassphraseDialog : public QDialog

FILE: src/qt/bantablemodel.cpp
  class BanTablePriv (line 37) | class BanTablePriv
    method refreshBanlist (line 48) | void refreshBanlist()
    method size (line 71) | int size() const
    method CCombinedBan (line 76) | CCombinedBan *index(int idx)
  function QVariant (line 115) | QVariant BanTableModel::data(const QModelIndex &index, int role) const
  function QVariant (line 137) | QVariant BanTableModel::headerData(int section, Qt::Orientation orientat...
  function QModelIndex (line 158) | QModelIndex BanTableModel::index(int row, int column, const QModelIndex ...

FILE: src/qt/bantablemodel.h
  type CCombinedBan (line 18) | struct CCombinedBan {
  function class (line 23) | class BannedNodeLessThan
  function class (line 39) | class BanTableModel : public QAbstractTableModel

FILE: src/qt/bitcoin.cpp
  function InitMessage (line 85) | void InitMessage(const std::string &message)
  function Translate (line 93) | static std::string Translate(const char* psz)
  function QString (line 98) | static QString GetLangTerritory()
  function initTranslations (line 114) | static void initTranslations(QTranslator &qtTranslatorBase, QTranslator ...
  function DebugMessageHandler (line 153) | void DebugMessageHandler(QtMsgType type, const char *msg)
  function DebugMessageHandler (line 162) | void DebugMessageHandler(QtMsgType type, const QMessageLogContext& conte...
  class BitcoinCore (line 176) | class BitcoinCore: public QObject
  class BitcoinApplication (line 202) | class BitcoinApplication: public QApplication
    method getReturnValue (line 228) | int getReturnValue() const { return returnValue; }
  function WId (line 536) | WId BitcoinApplication::getMainWinId() const
  function main (line 545) | int main(int argc, char *argv[])

FILE: src/qt/bitcoinaddressvalidator.h
  function class (line 13) | class BitcoinAddressEntryValidator : public QValidator
  function class (line 25) | class BitcoinAddressCheckValidator : public QValidator

FILE: src/qt/bitcoinamountfield.cpp
  class AmountSpinBox (line 20) | class AmountSpinBox: public QAbstractSpinBox
  function fixup (line 45) | void fixup(QString &input) const
  function CAmount (line 56) | CAmount value(bool *valid_out=0) const
  function setValue (line 61) | void setValue(const CAmount& value)
  function stepBy (line 67) | void stepBy(int steps)
  function setDisplayUnit (line 76) | void setDisplayUnit(int unit)
  function setSingleStep (line 89) | void setSingleStep(const CAmount& step)
  function QSize (line 94) | QSize minimumSizeHint() const
  function CAmount (line 137) | CAmount parse(const QString &text, bool *valid_out=0) const
  function StepEnabled (line 167) | StepEnabled stepEnabled() const
  function QWidget (line 261) | QWidget *BitcoinAmountField::setupTabChain(QWidget *prev)
  function CAmount (line 268) | CAmount BitcoinAmountField::value(bool *valid_out) const

FILE: src/qt/bitcoingui.cpp
  type BlockSource (line 781) | enum BlockSource
  function ThreadSafeMessageBox (line 1166) | static bool ThreadSafeMessageBox(BitcoinGUI *gui, const std::string& mes...

FILE: src/qt/bitcoingui.h
  function class (line 246) | class UnitDisplayStatusBarControl : public QLabel

FILE: src/qt/bitcoinunits.cpp
  function QString (line 39) | QString BitcoinUnits::longName(int unit)
  function QString (line 50) | QString BitcoinUnits::shortName(int unit)
  function QString (line 59) | QString BitcoinUnits::description(int unit)
  function qint64 (line 70) | qint64 BitcoinUnits::factor(int unit)
  function QString (line 92) | QString BitcoinUnits::format(int unit, const CAmount& nIn, bool fPlus, S...
  function QString (line 131) | QString BitcoinUnits::formatWithUnit(int unit, const CAmount& amount, bo...
  function QString (line 136) | QString BitcoinUnits::formatHtmlWithUnit(int unit, const CAmount& amount...
  function QString (line 183) | QString BitcoinUnits::getAmountColumnTitle(int unit)
  function QVariant (line 199) | QVariant BitcoinUnits::data(const QModelIndex &index, int role) const
  function CAmount (line 219) | CAmount BitcoinUnits::maxMoney()

FILE: src/qt/bitcoinunits.h
  function class (line 47) | class BitcoinUnits: public QAbstractListModel
  type BitcoinUnits (line 128) | typedef BitcoinUnits::Unit BitcoinUnit;

FILE: src/qt/callback.h
  function class (line 6) | class Callback : public QObject
  function call (line 21) | void call() override { f(this); }

FILE: src/qt/clientmodel.cpp
  class CBlockIndex (line 28) | class CBlockIndex
  function quint64 (line 104) | quint64 ClientModel::getTotalBytesRecv() const
  function quint64 (line 111) | quint64 ClientModel::getTotalBytesSent() const
  function QDateTime (line 118) | QDateTime ClientModel::getLastBlockDate() const
  type BlockSource (line 177) | enum BlockSource
  function QString (line 204) | QString ClientModel::getStatusBarWarnings() const
  function OptionsModel (line 209) | OptionsModel *ClientModel::getOptionsModel()
  function PeerTableModel (line 214) | PeerTableModel *ClientModel::getPeerTableModel()
  function BanTableModel (line 219) | BanTableModel *ClientModel::getBanTableModel()
  function QString (line 224) | QString ClientModel::formatFullVersion() const
  function QString (line 229) | QString ClientModel::formatSubVersion() const
  function QString (line 239) | QString ClientModel::formatClientStartupTime() const
  function QString (line 244) | QString ClientModel::dataDir() const
  function ShowProgress (line 255) | static void ShowProgress(ClientModel *clientmodel, const std::string &ti...
  function NotifyNumConnectionsChanged (line 263) | static void NotifyNumConnectionsChanged(ClientModel *clientmodel, int ne...
  function NotifyNetworkActiveChanged (line 270) | static void NotifyNetworkActiveChanged(ClientModel *clientmodel, bool ne...
  function NotifyAlertChanged (line 276) | static void NotifyAlertChanged(ClientModel *clientmodel)
  function BannedListChanged (line 282) | static void BannedListChanged(ClientModel *clientmodel)
  function BlockTipChanged (line 288) | static void BlockTipChanged(ClientModel *clientmodel, bool initialSync, ...

FILE: src/qt/clientmodel.h
  type NumConnections (line 30) | enum NumConnections {

FILE: src/qt/coincontroldialog.cpp
  function CCoinControl (line 602) | CCoinControl* CoinControlDialog::coinControl()

FILE: src/qt/coincontroldialog.h
  function namespace (line 24) | namespace Ui {
  function class (line 30) | class CCoinControlWidgetItem : public QTreeWidgetItem
  function class (line 41) | class CoinControlDialog : public QDialog

FILE: src/qt/coincontroltreewidget.h
  function class (line 11) | class CoinControlTreeWidget : public QTreeWidget

FILE: src/qt/csvmodelwriter.cpp
  function writeValue (line 32) | static void writeValue(QTextStream &f, const QString &value)
  function writeSep (line 39) | static void writeSep(QTextStream &f)
  function writeNewline (line 44) | static void writeNewline(QTextStream &f)

FILE: src/qt/csvmodelwriter.h
  type Column (line 37) | struct Column

FILE: src/qt/editaddressdialog.cpp
  function QString (line 138) | QString EditAddressDialog::getAddress() const

FILE: src/qt/editaddressdialog.h
  function namespace (line 12) | namespace Ui {
  type Mode (line 27) | enum Mode {

FILE: src/qt/guiutil.cpp
  type GUIUtil (line 79) | namespace GUIUtil {
    function QString (line 81) | QString dateTimeStr(const QDateTime &date)
    function QString (line 86) | QString dateTimeStr(qint64 nTime)
    function QFont (line 91) | QFont fixedPitchFont()
    function DummyAddress (line 110) | static std::string DummyAddress(const CChainParams &params)
    function setupAddressWidget (line 124) | void setupAddressWidget(QValidatedLineEdit *widget, QWidget *parent)
    function setupAmountWidget (line 139) | void setupAmountWidget(QLineEdit *widget, QWidget *parent)
    function parseBitcoinURI (line 148) | bool parseBitcoinURI(const QUrl &uri, SendCoinsRecipient *out)
    function parseBitcoinURI (line 209) | bool parseBitcoinURI(QString uri, SendCoinsRecipient *out)
    function QString (line 227) | QString formatBitcoinURI(const SendCoinsRecipient &info)
    function isDust (line 255) | bool isDust(const QString& address, const CAmount& amount)
    function QString (line 263) | QString HtmlEscape(const QString& str, bool fMultiLine)
    function QString (line 277) | QString HtmlEscape(const std::string& str, bool fMultiLine)
    function copyEntryData (line 282) | void copyEntryData(QAbstractItemView *view, int column, int role)
    function getEntryData (line 295) | QList<QModelIndex> getEntryData(QAbstractItemView *view, int column)
    function QString (line 302) | QString getSaveFileName(QWidget *parent, const QString &caption, const...
    function QString (line 352) | QString getOpenFileName(QWidget *parent, const QString &caption, const...
    function blockingGUIThreadConnection (line 387) | Qt::ConnectionType blockingGUIThreadConnection()
    function checkPoint (line 399) | bool checkPoint(const QPoint &p, const QWidget *w)
    function isObscured (line 406) | bool isObscured(QWidget *w)
    function openDebugLogfile (line 415) | void openDebugLogfile()
    function openBitcoinConf (line 424) | bool openBitcoinConf()
    function SubstituteFonts (line 440) | void SubstituteFonts(const QString& language)
    function StartupShortcutPath (line 620) | fs::path static StartupShortcutPath()
    function GetStartOnSystemStartup (line 630) | bool GetStartOnSystemStartup()
    function SetStartOnSystemStartup (line 636) | bool SetStartOnSystemStartup(bool fAutoStart)
    function GetAutostartDir (line 709) | fs::path static GetAutostartDir()
    function GetAutostartFilePath (line 718) | fs::path static GetAutostartFilePath()
    function GetStartOnSystemStartup (line 726) | bool GetStartOnSystemStartup()
    function SetStartOnSystemStartup (line 745) | bool SetStartOnSystemStartup(bool fAutoStart)
    function LSSharedFileListItemRef (line 788) | LSSharedFileListItemRef findStartupItemInList(LSSharedFileListRef list...
    function GetStartOnSystemStartup (line 827) | bool GetStartOnSystemStartup()
    function SetStartOnSystemStartup (line 841) | bool SetStartOnSystemStartup(bool fAutoStart)
    function GetStartOnSystemStartup (line 866) | bool GetStartOnSystemStartup() { return false; }
    function SetStartOnSystemStartup (line 867) | bool SetStartOnSystemStartup(bool fAutoStart) { return false; }
    function setClipboard (line 871) | void setClipboard(const QString& str)
    function qstringToBoostPath (line 877) | fs::path qstringToBoostPath(const QString &path)
    function QString (line 886) | QString boostPathToQString(const fs::path &path)
    function QString (line 895) | QString formatDurationStr(int secs)
    function QString (line 915) | QString formatServicesStr(quint64 mask)
    function QString (line 953) | QString formatPingTime(double dPingTime)
    function QString (line 958) | QString formatTimeOffset(int64_t nTimeOffset)
    function QString (line 963) | QString formatNiceTimeOffset(qint64 secs)
    function QString (line 1000) | QString formatBytes(uint64_t bytes)
    function qreal (line 1015) | qreal calculateIdealFontSize(int width, const QString& text, QFont fon...

FILE: src/qt/guiutil.h
  function QT_END_NAMESPACE (line 30) | QT_END_NAMESPACE

FILE: src/qt/intro.cpp
  class FreespaceChecker (line 41) | class FreespaceChecker : public QObject
    type Status (line 48) | enum Status {
  function QString (line 164) | QString Intro::getDataDirectory()
  function QString (line 184) | QString Intro::getDefaultDataDirectory()
  function QString (line 325) | QString Intro::getPathToCheck()

FILE: src/qt/intro.h
  function namespace (line 16) | namespace Ui {
  function class (line 24) | class Intro : public QDialog

FILE: src/qt/macnotificationhandler.h
  function class (line 12) | class MacNotificationHandler : public QObject

FILE: src/qt/modaloverlay.h
  function namespace (line 14) | namespace Ui {
  function class (line 19) | class ModalOverlay : public QWidget

FILE: src/qt/networkstyle.cpp
  function NetworkStyle (line 82) | const NetworkStyle *NetworkStyle::instantiate(const QString &networkId)

FILE: src/qt/networkstyle.h
  function class (line 13) | class NetworkStyle

FILE: src/qt/notificator.cpp
  class FreedesktopImage (line 75) | class FreedesktopImage
    method FreedesktopImage (line 78) | FreedesktopImage() {}
  function QDBusArgument (line 128) | QDBusArgument &operator<<(QDBusArgument &a, const FreedesktopImage &i)
  function QDBusArgument (line 136) | const QDBusArgument &operator>>(const QDBusArgument &a, FreedesktopImage...
  function QVariant (line 149) | QVariant FreedesktopImage::toVariant(const QImage &img)

FILE: src/qt/notificator.h
  type Class (line 36) | enum Class
  type Mode (line 57) | enum Mode {

FILE: src/qt/openuridialog.cpp
  function QString (line 28) | QString OpenURIDialog::getURI()

FILE: src/qt/openuridialog.h
  function namespace (line 10) | namespace Ui {
  function class (line 14) | class OpenURIDialog : public QDialog

FILE: src/qt/optionsdialog.h
  function QT_END_NAMESPACE (line 16) | QT_END_NAMESPACE
  function class (line 24) | class ProxyAddressValidator : public QValidator
  function class (line 35) | class OptionsDialog : public QDialog

FILE: src/qt/optionsmodel.cpp
  function CopySettings (line 160) | static void CopySettings(QSettings& dst, const QSettings& src)
  function BackupSettings (line 168) | static void BackupSettings(const fs::path& filename, const QSettings& src)
  type ProxySetting (line 206) | struct ProxySetting {
  function ProxySetting (line 212) | static ProxySetting GetProxySetting(QSettings &settings, const QString &...
  function SetProxySetting (line 228) | static void SetProxySetting(QSettings &settings, const QString &name, co...
  function QString (line 233) | static const QString GetDefaultProxyAddress()
  function QVariant (line 239) | QVariant OptionsModel::data(const QModelIndex & index, int role) const

FILE: src/qt/optionsmodel.h
  function class (line 25) | class OptionsModel : public QAbstractListModel

FILE: src/qt/overviewpage.cpp
  class TxViewDelegate (line 24) | class TxViewDelegate : public QAbstractItemDelegate
    method paint (line 35) | inline void paint(QPainter *painter, const QStyleOptionViewItem &option,
    method QSize (line 100) | inline QSize sizeHint(const QStyleOptionViewItem &option, const QModel...

FILE: src/qt/overviewpage.h
  function namespace (line 19) | namespace Ui {

FILE: src/qt/paymentrequestplus.cpp
  class SSLVerifyError (line 22) | class SSLVerifyError : public std::runtime_error
    method SSLVerifyError (line 25) | explicit SSLVerifyError(std::string err) : std::runtime_error(err) { }

FILE: src/qt/paymentrequestplus.h
  function class (line 28) | class PaymentRequestPlus

FILE: src/qt/paymentserver.cpp
  type X509StoreDeleter (line 60) | struct X509StoreDeleter {
  type X509Deleter (line 66) | struct X509Deleter {
  function QString (line 80) | static QString ipcServerName()
  function ReportInvalidCertificate (line 100) | static void ReportInvalidCertificate(const QSslCertificate& cert)
  function X509_STORE (line 806) | X509_STORE* PaymentServer::getCertStore()

FILE: src/qt/paymentserver.h
  function class (line 58) | class PaymentServer : public QObject

FILE: src/qt/peertablemodel.cpp
  class PeerTablePriv (line 46) | class PeerTablePriv
    method refreshPeers (line 59) | void refreshPeers()
    method size (line 102) | int size() const
    method CNodeCombinedStats (line 107) | CNodeCombinedStats *index(int idx)
  function QVariant (line 162) | QVariant PeerTableModel::data(const QModelIndex &index, int role) const
  function QVariant (line 199) | QVariant PeerTableModel::headerData(int section, Qt::Orientation orienta...
  function QModelIndex (line 220) | QModelIndex PeerTableModel::index(int row, int column, const QModelIndex...
  function CNodeCombinedStats (line 230) | const CNodeCombinedStats *PeerTableModel::getNodeStats(int idx)

FILE: src/qt/peertablemodel.h
  function QT_END_NAMESPACE (line 21) | QT_END_NAMESPACE
  function class (line 29) | class NodeLessThan
  function class (line 45) | class PeerTableModel : public QAbstractTableModel

FILE: src/qt/platformstyle.cpp
  function MakeSingleColorImage (line 33) | void MakeSingleColorImage(QImage& img, const QColor& colorbase)
  function QIcon (line 46) | QIcon ColorizeIcon(const QIcon& ico, const QColor& colorbase)
  function QImage (line 58) | QImage ColorizeImage(const QString& filename, const QColor& colorbase)
  function QIcon (line 65) | QIcon ColorizeIcon(const QString& filename, const QColor& colorbase)
  function QImage (line 98) | QImage PlatformStyle::SingleColorImage(const QString& filename) const
  function QIcon (line 105) | QIcon PlatformStyle::SingleColorIcon(const QString& filename) const
  function QIcon (line 112) | QIcon PlatformStyle::SingleColorIcon(const QIcon& icon) const
  function QIcon (line 119) | QIcon PlatformStyle::TextColorIcon(const QString& filename) const
  function QIcon (line 124) | QIcon PlatformStyle::TextColorIcon(const QIcon& icon) const
  function PlatformStyle (line 129) | const PlatformStyle *PlatformStyle::instantiate(const QString &platformId)

FILE: src/qt/platformstyle.h
  function class (line 13) | class PlatformStyle

FILE: src/qt/qvalidatedlineedit.h
  function class (line 13) | class QValidatedLineEdit : public QLineEdit

FILE: src/qt/qvaluecombobox.cpp
  function QVariant (line 13) | QVariant QValueComboBox::value() const

FILE: src/qt/qvaluecombobox.h
  function class (line 12) | class QValueComboBox : public QComboBox

FILE: src/qt/receivecoinsdialog.cpp
  function QModelIndex (line 232) | QModelIndex ReceiveCoinsDialog::selectedRow()

FILE: src/qt/receivecoinsdialog.h
  function namespace (line 21) | namespace Ui {
  type ColumnWidths (line 35) | enum ColumnWidths {

FILE: src/qt/receiverequestdialog.cpp
  function QImage (line 43) | QImage QRImageWidget::exportImage()

FILE: src/qt/receiverequestdialog.h
  function namespace (line 17) | namespace Ui {
  function class (line 48) | class ReceiveRequestDialog : public QDialog

FILE: src/qt/recentrequeststablemodel.cpp
  function QVariant (line 52) | QVariant RecentRequestsTableModel::data(const QModelIndex &index, int ro...
  function QVariant (line 104) | QVariant RecentRequestsTableModel::headerData(int section, Qt::Orientati...
  function QString (line 124) | QString RecentRequestsTableModel::getAmountTitle()
  function QModelIndex (line 129) | QModelIndex RecentRequestsTableModel::index(int row, int column, const Q...

FILE: src/qt/recentrequeststablemodel.h
  function class (line 16) | class RecentRequestEntry
  function class (line 43) | class RecentRequestEntryLessThan
  function class (line 58) | class RecentRequestsTableModel: public QAbstractTableModel

FILE: src/qt/rpcconsole.cpp
  class RPCExecutor (line 81) | class RPCExecutor : public QObject
  class QtRPCTimerBase (line 95) | class QtRPCTimerBase: public QObject, public RPCTimerBase
    method Q_OBJECT (line 97) | Q_OBJECT
    method timeout (line 108) | void timeout() { func(); }
  class QtRPCTimerInterface (line 114) | class QtRPCTimerInterface: public RPCTimerInterface
    method RPCTimerBase (line 119) | RPCTimerBase* NewTimer(std::function<void(void)>& func, int64_t millis)
  type CmdParseState (line 152) | enum CmdParseState
  function QString (line 689) | static QString categoryClass(int category)
  type TabTypes (line 1227) | enum TabTypes

FILE: src/qt/rpcconsole.h
  function namespace (line 21) | namespace Ui {
  type MessageClass (line 46) | enum MessageClass {
  type TabTypes (line 54) | enum TabTypes {
  type TabTypes (line 118) | enum TabTypes
  type ColumnWidths (line 131) | enum ColumnWidths

FILE: src/qt/sendcoinsdialog.cpp
  function getConfTargetForIndex (line 32) | int getConfTargetForIndex(int index) {
  function getIndexForConfTarget (line 41) | int getIndexForConfTarget(int target) {
  function SendCoinsEntry (line 404) | SendCoinsEntry *SendCoinsDialog::addEntry()
  function QWidget (line 446) | QWidget *SendCoinsDialog::setupTabChain(QWidget *prev)

FILE: src/qt/sendcoinsdialog.h
  function namespace (line 20) | namespace Ui {
  function class (line 106) | class SendConfirmationDialog : public QMessageBox

FILE: src/qt/sendcoinsentry.cpp
  function SendCoinsRecipient (line 169) | SendCoinsRecipient SendCoinsEntry::getValue()
  function QWidget (line 185) | QWidget *SendCoinsEntry::setupTabChain(QWidget *prev)

FILE: src/qt/sendcoinsentry.h
  function namespace (line 15) | namespace Ui {
  function class (line 24) | class SendCoinsEntry : public QStackedWidget

FILE: src/qt/signverifymessagedialog.h
  function namespace (line 13) | namespace Ui {
  function class (line 17) | class SignVerifyMessageDialog : public QDialog

FILE: src/qt/splashscreen.cpp
  function InitMessage (line 188) | static void InitMessage(SplashScreen *splash, const std::string &message)
  function ShowProgress (line 197) | static void ShowProgress(SplashScreen *splash, const std::string &title,...

FILE: src/qt/splashscreen.h
  function class (line 20) | class SplashScreen : public QWidget

FILE: src/qt/test/compattests.h
  function class (line 11) | class CompatTests : public QObject

FILE: src/qt/test/paymentservertests.cpp
  function X509 (line 23) | X509 *parse_b64der_cert(const char* cert_data)
  function SendCoinsRecipient (line 37) | static SendCoinsRecipient handleRequest(PaymentServer* server, std::vect...

FILE: src/qt/test/paymentservertests.h
  function class (line 13) | class PaymentServerTests : public QObject
  function class (line 24) | class RecipientCatcher : public QObject

FILE: src/qt/test/rpcnestedtests.cpp
  function UniValue (line 21) | static UniValue rpcNestedTest_rpc(const JSONRPCRequest& request)

FILE: src/qt/test/rpcnestedtests.h
  function class (line 14) | class RPCNestedTests : public QObject

FILE: src/qt/test/test_main.cpp
  function main (line 50) | int main(int argc, char *argv[])

FILE: src/qt/test/uritests.h
  function class (line 11) | class URITests : public QObject

FILE: src/qt/test/wallettests.cpp
  function ConfirmMessage (line 37) | void ConfirmMessage(QString* text = nullptr)
  function ConfirmSend (line 52) | void ConfirmSend(QString* text = nullptr, bool cancel = false)
  function uint256 (line 69) | uint256 SendCoins(CWallet& wallet, SendCoinsDialog& sendCoinsDialog, con...
  function QModelIndex (line 89) | QModelIndex FindTx(const QAbstractItemModel& model, const uint256& txid)
  function RequestContextMenu (line 103) | void RequestContextMenu(QWidget* widget)
  function BumpFee (line 114) | void BumpFee(TransactionView& view, const uint256& txid, bool expectDisa...
  function TestGUI (line 152) | void TestGUI()

FILE: src/qt/test/wallettests.h
  function class (line 7) | class WalletTests : public QObject

FILE: src/qt/transactiondesc.cpp
  function QString (line 24) | QString TransactionDesc::FormatTxStatus(const CWalletTx& wtx)
  function QString (line 48) | QString TransactionDesc::toHTML(CWallet *wallet, CWalletTx &wtx, Transac...

FILE: src/qt/transactiondesc.h
  function class (line 18) | class TransactionDesc: public QObject

FILE: src/qt/transactiondescdialog.h
  function namespace (line 10) | namespace Ui {

FILE: src/qt/transactionfilterproxy.h
  function class (line 14) | class TransactionFilterProxy : public QSortFilterProxyModel

FILE: src/qt/transactionrecord.cpp
  function QString (line 249) | QString TransactionRecord::getTxID() const

FILE: src/qt/transactionrecord.h
  function class (line 19) | class TransactionStatus
  function class (line 69) | class TransactionRecord

FILE: src/qt/transactiontablemodel.cpp
  type TxLessThan (line 40) | struct TxLessThan
  class TransactionTablePriv (line 57) | class TransactionTablePriv
    method TransactionTablePriv (line 60) | TransactionTablePriv(CWallet *_wallet, TransactionTableModel *_parent) :
    method refreshWallet (line 77) | void refreshWallet()
    method updateWallet (line 96) | void updateWallet(const uint256 &hash, int status, bool showTransaction)
    method size (line 177) | int size()
    method TransactionRecord (line 182) | TransactionRecord *index(int idx)
    method QString (line 214) | QString describe(TransactionRecord *rec, int unit)
    method QString (line 227) | QString getTxHex(TransactionRecord *rec)
  function QString (line 299) | QString TransactionTableModel::formatTxStatus(const TransactionRecord *w...
  function QString (line 337) | QString TransactionTableModel::formatTxDate(const TransactionRecord *wtx...
  function QString (line 349) | QString TransactionTableModel::lookupAddress(const std::string &address,...
  function QString (line 364) | QString TransactionTableModel::formatTxType(const TransactionRecord *wtx...
  function QVariant (line 384) | QVariant TransactionTableModel::txAddressDecoration(const TransactionRec...
  function QString (line 401) | QString TransactionTableModel::formatTxToAddress(const TransactionRecord...
  function QVariant (line 425) | QVariant TransactionTableModel::addressColor(const TransactionRecord *wt...
  function QString (line 446) | QString TransactionTableModel::formatTxAmount(const TransactionRecord *w...
  function QVariant (line 459) | QVariant TransactionTableModel::txStatusDecoration(const TransactionReco...
  function QVariant (line 495) | QVariant TransactionTableModel::txWatchonlyDecoration(const TransactionR...
  function QString (line 503) | QString TransactionTableModel::formatTooltip(const TransactionRecord *re...
  function QVariant (line 514) | QVariant TransactionTableModel::data(const QModelIndex &index, int role)...
  function QVariant (line 654) | QVariant TransactionTableModel::headerData(int section, Qt::Orientation ...
  function QModelIndex (line 687) | QModelIndex TransactionTableModel::index(int row, int column, const QMod...
  type TransactionNotification (line 706) | struct TransactionNotification
    method TransactionNotification (line 709) | TransactionNotification() {}
    method TransactionNotification (line 710) | TransactionNotification(uint256 _hash, ChangeType _status, bool _showT...
    method invoke (line 713) | void invoke(QObject *ttm)
  function NotifyTransactionChanged (line 731) | static void NotifyTransactionChanged(TransactionTableModel *ttm, CWallet...
  function ShowProgress (line 749) | static void ShowProgress(TransactionTableModel *ttm, const std::string &...

FILE: src/qt/transactiontablemodel.h
  function class (line 22) | class TransactionTableModel : public QAbstractTableModel

FILE: src/qt/transactionview.cpp
  function QWidget (line 540) | QWidget *TransactionView::createDateRangeWidget()

FILE: src/qt/transactionview.h
  type DateEnum (line 41) | enum DateEnum
  type ColumnWidths (line 52) | enum ColumnWidths {

FILE: src/qt/utilitydialog.cpp
  function QWidget (line 174) | QWidget *ShutdownWindow::showShutdownWindow(BitcoinGUI *window)

FILE: src/qt/utilitydialog.h
  function namespace (line 13) | namespace Ui {
  function class (line 18) | class HelpMessageDialog : public QDialog
  function class (line 39) | class ShutdownWindow : public QWidget

FILE: src/qt/walletframe.cpp
  function WalletView (line 197) | WalletView *WalletFrame::currentWalletView()

FILE: src/qt/walletmodel.cpp
  function CAmount (line 69) | CAmount WalletModel::getBalance(const CCoinControl *coinControl) const
  function CAmount (line 79) | CAmount WalletModel::getUnconfirmedBalance() const
  function CAmount (line 84) | CAmount WalletModel::getImmatureBalance() const
  function CAmount (line 94) | CAmount WalletModel::getWatchBalance() const
  function CAmount (line 99) | CAmount WalletModel::getWatchUnconfirmedBalance() const
  function CAmount (line 104) | CAmount WalletModel::getWatchImmatureBalance() const
  function OptionsModel (line 398) | OptionsModel *WalletModel::getOptionsModel()
  function AddressTableModel (line 403) | AddressTableModel *WalletModel::getAddressTableModel()
  function TransactionTableModel (line 408) | TransactionTableModel *WalletModel::getTransactionTableModel()
  function RecentRequestsTableModel (line 413) | RecentRequestsTableModel *WalletModel::getRecentRequestsTableModel()
  function NotifyKeyStoreStatusChanged (line 479) | static void NotifyKeyStoreStatusChanged(WalletModel *walletmodel, CCrypt...
  function NotifyAddressBookChanged (line 485) | static void NotifyAddressBookChanged(WalletModel *walletmodel, CWallet *...
  function NotifyTransactionChanged (line 502) | static void NotifyTransactionChanged(WalletModel *walletmodel, CWallet *...
  function ShowProgress (line 510) | static void ShowProgress(WalletModel *walletmodel, const std::string &ti...
  function NotifyWatchonlyChanged (line 518) | static void NotifyWatchonlyChanged(WalletModel *walletmodel, bool fHaveW...
  function OutputType (line 759) | OutputType WalletModel::getDefaultAddressType() const

FILE: src/qt/walletmodel.h
  type OutputType (line 18) | enum OutputType : int
  function QT_END_NAMESPACE (line 37) | QT_END_NAMESPACE
  function class (line 100) | class WalletModel : public QObject

FILE: src/qt/walletmodeltransaction.cpp
  function CWalletTx (line 28) | CWalletTx *WalletModelTransaction::getTransaction() const
  function CAmount (line 38) | CAmount WalletModelTransaction::getTransactionFee() const
  function CAmount (line 80) | CAmount WalletModelTransaction::getTotalTransactionAmount() const
  function CReserveKey (line 95) | CReserveKey *WalletModelTransaction::getPossibleKeyChange()

FILE: src/qt/walletmodeltransaction.h
  function class (line 21) | class WalletModelTransaction

FILE: src/qt/winshutdownmonitor.h
  function class (line 17) | class WinShutdownMonitor : public QAbstractNativeEventFilter

FILE: src/random.cpp
  function RandFailure (line 49) | [[noreturn]] static void RandFailure()
  function GetPerformanceCounter (line 55) | static inline int64_t GetPerformanceCounter()
  function RDRandInit (line 80) | static void RDRandInit()
  function RDRandInit (line 90) | static void RDRandInit() {}
  function GetHWRand (line 93) | static bool GetHWRand(unsigned char* ent32) {
  function RandAddSeed (line 130) | void RandAddSeed()
  function RandAddSeedPerfmon (line 138) | static void RandAddSeedPerfmon()
  function GetDevURandom (line 182) | void GetDevURandom(unsigned char *ent32)
  function GetOSRand (line 202) | void GetOSRand(unsigned char *ent32)
  function GetRandBytes (line 273) | void GetRandBytes(unsigned char* buf, int num)
  function RandAddSeedSleep (line 282) | void RandAddSeedSleep()
  function AddDataToRng (line 301) | static void AddDataToRng(void* data, size_t len) {
  function GetStrongRandBytes (line 317) | void GetStrongRandBytes(unsigned char* out, int num)
  function GetRand (line 352) | uint64_t GetRand(uint64_t nMax)
  function GetRandInt (line 367) | int GetRandInt(int nMax)
  function uint256 (line 372) | uint256 GetRandHash()
  function uint256 (line 386) | uint256 FastRandomContext::rand256()
  function Random_SanityCheck (line 411) | bool Random_SanityCheck()
  function RandomInit (line 464) | void RandomInit()

FILE: src/random.h
  function class (line 44) | class FastRandomContext {

FILE: src/rest.cpp
  type RetFormat (line 27) | enum RetFormat {
  type RetFormat (line 35) | enum RetFormat
  type CCoin (line 44) | struct CCoin {
    method CCoin (line 50) | CCoin() : nHeight(0) {}
    method CCoin (line 51) | explicit CCoin(Coin&& in) : nHeight(in.nHeight), out(std::move(in.out)...
    method SerializationOp (line 54) | inline void SerializationOp(Stream& s, Operation ser_action)
  function RESTERR (line 63) | static bool RESTERR(HTTPRequest* req, enum HTTPStatusCode status, std::s...
  function ParseDataFormat (line 70) | static enum RetFormat ParseDataFormat(std::string& param, const std::str...
  function AvailableDataFormatsString (line 91) | static std::string AvailableDataFormatsString()
  function ParseHashStr (line 107) | static bool ParseHashStr(const std::string& strReq, uint256& v)
  function CheckWarmup (line 116) | static bool CheckWarmup(HTTPRequest* req)
  function rest_headers (line 124) | static bool rest_headers(HTTPRequest* req,
  function rest_block (line 198) | static bool rest_block(HTTPRequest* req,
  function rest_block_extended (line 262) | static bool rest_block_extended(HTTPRequest* req, const std::string& str...
  function rest_block_notxdetails (line 267) | static bool rest_block_notxdetails(HTTPRequest* req, const std::string& ...
  function rest_chaininfo (line 275) | static bool rest_chaininfo(HTTPRequest* req, const std::string& strURIPart)
  function rest_mempool_info (line 298) | static bool rest_mempool_info(HTTPRequest* req, const std::string& strUR...
  function rest_mempool_contents (line 320) | static bool rest_mempool_contents(HTTPRequest* req, const std::string& s...
  function rest_tx (line 342) | static bool rest_tx(HTTPRequest* req, const std::string& strURIPart)
  function rest_getutxos (line 391) | static bool rest_getutxos(HTTPRequest* req, const std::string& strURIPart)
  function StartREST (line 587) | bool StartREST()
  function InterruptREST (line 594) | void InterruptREST()
  function StopREST (line 598) | void StopREST()

FILE: src/rpc/blockchain.cpp
  type CUpdatedBlock (line 40) | struct CUpdatedBlock
  function GetDifficulty (line 55) | double GetDifficulty(const CChain& chain, const CBlockIndex* blockindex)
  function GetDifficulty (line 83) | double GetDifficulty(const CBlockIndex* blockindex)
  function UniValue (line 88) | UniValue blockheaderToJSON(const CBlockIndex* blockindex)
  function UniValue (line 118) | UniValue blockToJSON(const CBlock& block, const CBlockIndex* blockindex,...
  function UniValue (line 164) | UniValue getblockcount(const JSONRPCRequest& request)
  function UniValue (line 181) | UniValue getbestblockhash(const JSONRPCRequest& request)
  function RPCNotifyBlockChange (line 198) | void RPCNotifyBlockChange(bool ibd, const CBlockIndex * pindex)
  function UniValue (line 208) | UniValue waitfornewblock(const JSONRPCRequest& request)
  function UniValue (line 246) | UniValue waitforblock(const JSONRPCRequest& request)
  function UniValue (line 288) | UniValue waitforblockheight(const JSONRPCRequest& request)
  function UniValue (line 330) | UniValue syncwithvalidationinterfacequeue(const JSONRPCRequest& request)
  function UniValue (line 345) | UniValue getdifficulty(const JSONRPCRequest& request)
  function EntryDescriptionString (line 362) | std::string EntryDescriptionString()
  function entryToJSON (line 381) | void entryToJSON(UniValue &info, const CTxMemPoolEntry &e)
  function UniValue (line 414) | UniValue mempoolToJSON(bool fVerbose)
  function UniValue (line 442) | UniValue getrawmempool(const JSONRPCRequest& request)
  function UniValue (line 474) | UniValue getmempoolancestors(const JSONRPCRequest& request)
  function UniValue (line 538) | UniValue getmempooldescendants(const JSONRPCRequest& request)
  function UniValue (line 602) | UniValue getmempoolentry(const JSONRPCRequest& request)
  function UniValue (line 635) | UniValue getblockhash(const JSONRPCRequest& request)
  function UniValue (line 660) | UniValue getblockheader(const JSONRPCRequest& request)
  function UniValue (line 720) | UniValue getblock(const JSONRPCRequest& request)
  type CCoinsStats (line 812) | struct CCoinsStats
    method CCoinsStats (line 823) | CCoinsStats() : nHeight(0), nTransactions(0), nTransactionOutputs(0), ...
  function ApplyStats (line 826) | static void ApplyStats(CCoinsStats &stats, CHashWriter& ss, const uint25...
  function GetUTXOStats (line 845) | static bool GetUTXOStats(CCoinsView *view, CCoinsStats &stats)
  function UniValue (line 883) | UniValue pruneblockchain(const JSONRPCRequest& request)
  function UniValue (line 932) | UniValue gettxoutsetinfo(const JSONRPCRequest& request)
  function UniValue (line 974) | UniValue gettxout(const JSONRPCRequest& request)
  function UniValue (line 1054) | UniValue verifychain(const JSONRPCRequest& request)
  function UniValue (line 1083) | static UniValue SoftForkMajorityDesc(int version, CBlockIndex* pindex, c...
  function UniValue (line 1103) | static UniValue SoftForkDesc(const std::string &name, int version, CBloc...
  function UniValue (line 1112) | static UniValue BIP9SoftForkDesc(const Consensus::Params& consensusParam...
  function BIP9SoftForkDescPushBack (line 1144) | void BIP9SoftForkDescPushBack(UniValue& bip9_softforks, const Consensus:...
  function UniValue (line 1153) | UniValue getblockchaininfo(const JSONRPCRequest& request)
  type CompareBlocksByHeight (line 1256) | struct CompareBlocksByHeight
  function UniValue (line 1270) | UniValue getchaintips(const JSONRPCRequest& request)
  function UniValue (line 1373) | UniValue mempoolInfoToJSON()
  function UniValue (line 1387) | UniValue getmempoolinfo(const JSONRPCRequest& request)
  function UniValue (line 1410) | UniValue preciousblock(const JSONRPCRequest& request)
  function UniValue (line 1448) | UniValue invalidateblock(const JSONRPCRequest& request)
  function UniValue (line 1486) | UniValue reconsiderblock(const JSONRPCRequest& request)
  function UniValue (line 1523) | UniValue getchaintxstats(const JSONRPCRequest& request)
  function UniValue (line 1602) | UniValue savemempool(const JSONRPCRequest& request)
  function RegisterBlockchainRPCCommands (line 1655) | void RegisterBlockchainRPCCommands(CRPCTable &t)

FILE: src/rpc/client.cpp
  class CRPCConvertParam (line 13) | class CRPCConvertParam
  class CRPCConvertTable (line 148) | class CRPCConvertTable
    method convert (line 157) | bool convert(const std::string& method, int idx) {
    method convert (line 160) | bool convert(const std::string& method, const std::string& name) {
  function UniValue (line 183) | UniValue ParseNonRFCJSONValue(const std::string& strVal)
  function UniValue (line 192) | UniValue RPCConvertValues(const std::string &strMethod, const std::vecto...
  function UniValue (line 211) | UniValue RPCConvertNamedValues(const std::string &strMethod, const std::...

FILE: src/rpc/mining.cpp
  function ParseConfirmTarget (line 32) | unsigned int ParseConfirmTarget(const UniValue& value)
  function UniValue (line 47) | UniValue GetNetworkHashPS(int lookup, int height) {
  function UniValue (line 84) | UniValue getnetworkhashps(const JSONRPCRequest& request)
  function UniValue (line 106) | UniValue generateBlocks(std::shared_ptr<CReserveScript> coinbaseScript, ...
  function UniValue (line 154) | UniValue generatetoaddress(const JSONRPCRequest& request)
  function UniValue (line 188) | UniValue getmininginfo(const JSONRPCRequest& request)
  function UniValue (line 232) | UniValue prioritisetransaction(const JSONRPCRequest& request)
  function UniValue (line 267) | static UniValue BIP22ValidationResult(const CValidationState& state)
  function gbt_vb_name (line 285) | std::string gbt_vb_name(const Consensus::DeploymentPos pos) {
  function UniValue (line 294) | UniValue getblocktemplate(const JSONRPCRequest& request)
  class submitblock_StateCatcher (line 684) | class submitblock_StateCatcher : public CValidationInterface
    method submitblock_StateCatcher (line 691) | explicit submitblock_StateCatcher(const uint256 &hashIn) : hash(hashIn...
    method BlockChecked (line 694) | void BlockChecked(const CBlock& block, const CValidationState& stateIn...
  function UniValue (line 702) | UniValue submitblock(const JSONRPCRequest& request)
  function UniValue (line 773) | UniValue estimatefee(const JSONRPCRequest& request)
  function UniValue (line 814) | UniValue estimatesmartfee(const JSONRPCRequest& request)
  function UniValue (line 875) | UniValue estimaterawfee(const JSONRPCRequest& request)
  function RegisterMiningRPCCommands (line 995) | void RegisterMiningRPCCommands(CRPCTable &t)

FILE: src/rpc/misc.cpp
  class DescribeAddressVisitor (line 37) | class DescribeAddressVisitor : public boost::static_visitor<UniValue>
    method DescribeAddressVisitor (line 42) | explicit DescribeAddressVisitor(CWallet *_pwallet) : pwallet(_pwallet) {}
    method ProcessSubScript (line 44) | void ProcessSubScript(const CScript& subscript, UniValue& obj, bool in...
    method UniValue (line 84) | UniValue operator()(const CNoDestination &dest) const { return UniValu...
    method UniValue (line 86) | UniValue operator()(const CKeyID &keyID) const {
    method UniValue (line 98) | UniValue operator()(const CScriptID &scriptID) const {
    method UniValue (line 109) | UniValue operator()(const WitnessV0KeyHash& id) const
    method UniValue (line 123) | UniValue operator()(const WitnessV0ScriptHash& id) const
    method UniValue (line 140) | UniValue operator()(const WitnessUnknown& id) const
  function UniValue (line 152) | UniValue validateaddress(const JSONRPCRequest& request)
  class CWallet (line 256) | class CWallet
  function UniValue (line 258) | UniValue createmultisig(const JSONRPCRequest& request)
  function UniValue (line 323) | UniValue verifymessage(const JSONRPCRequest& request)
  function UniValue (line 379) | UniValue signmessagewithprivkey(const JSONRPCRequest& request)
  function UniValue (line 421) | UniValue setmocktime(const JSONRPCRequest& request)
  function UniValue (line 448) | static UniValue RPCLockedMemoryInfo()
  function RPCMallocInfo (line 462) | static std::string RPCMallocInfo()
  function UniValue (line 480) | UniValue getmemoryinfo(const JSONRPCRequest& request)
  function getCategoryMask (line 527) | uint32_t getCategoryMask(UniValue cats) {
  function UniValue (line 544) | UniValue logging(const JSONRPCRequest& request)
  function UniValue (line 613) | UniValue echo(const JSONRPCRequest& request)
  function UniValue (line 626) | static UniValue getinfo_deprecated(const JSONRPCRequest& request)
  function RegisterMiscRPCCommands (line 655) | void RegisterMiscRPCCommands(CRPCTable &t)

FILE: src/rpc/net.cpp
  function UniValue (line 26) | UniValue getconnectioncount(const JSONRPCRequest& request)
  function UniValue (line 45) | UniValue ping(const JSONRPCRequest& request)
  function UniValue (line 68) | UniValue getpeerinfo(const JSONRPCRequest& request)
  function UniValue (line 193) | UniValue addnode(const JSONRPCRequest& request)
  function UniValue (line 240) | UniValue disconnectnode(const JSONRPCRequest& request)
  function UniValue (line 283) | UniValue getaddednodeinfo(const JSONRPCRequest& request)
  function UniValue (line 350) | UniValue getnettotals(const JSONRPCRequest& request)
  function UniValue (line 395) | static UniValue GetNetworksInfo()
  function UniValue (line 416) | UniValue getnetworkinfo(const JSONRPCRequest& request)
  function UniValue (line 492) | UniValue setban(const JSONRPCRequest& request)
  function UniValue (line 556) | UniValue listbanned(const JSONRPCRequest& request)
  function UniValue (line 589) | UniValue clearbanned(const JSONRPCRequest& request)
  function UniValue (line 607) | UniValue setnetworkactive(const JSONRPCRequest& request)
  function RegisterNetRPCCommands (line 644) | void RegisterNetRPCCommands(CRPCTable &t)

FILE: src/rpc/protocol.cpp
  function UniValue (line 26) | UniValue JSONRPCRequestObj(const std::string& strMethod, const UniValue&...
  function UniValue (line 35) | UniValue JSONRPCReplyObj(const UniValue& result, const UniValue& error, ...
  function JSONRPCReply (line 47) | std::string JSONRPCReply(const UniValue& result, const UniValue& error, ...
  function UniValue (line 53) | UniValue JSONRPCError(int code, const std::string& message)
  function GetAuthCookieFile (line 69) | static fs::path GetAuthCookieFile(bool temp=false)
  function GenerateAuthCookie (line 80) | bool GenerateAuthCookie(std::string *cookie_out)
  function GetAuthCookie (line 112) | bool GetAuthCookie(std::string *cookie_out)
  function DeleteAuthCookie (line 128) | void DeleteAuthCookie()
  function JSONRPCProcessBatchReply (line 137) | std::vector<UniValue> JSONRPCProcessBatchReply(const UniValue &in, size_...

FILE: src/rpc/protocol.h
  type HTTPStatusCode (line 19) | enum HTTPStatusCode
  type RPCErrorCode (line 32) | enum RPCErrorCode

FILE: src/rpc/rawtransaction.cpp
  function TxToJSON (line 40) | void TxToJSON(const CTransaction& tx, const uint256 hashBlock, UniValue&...
  function UniValue (line 65) | UniValue getrawtransaction(const JSONRPCRequest& request)
  function UniValue (line 198) | UniValue gettxoutproof(const JSONRPCRequest& request)
  function UniValue (line 283) | UniValue verifytxoutproof(const JSONRPCRequest& request)
  function UniValue (line 322) | UniValue createrawtransaction(const JSONRPCRequest& request)
  function UniValue (line 452) | UniValue decoderawtransaction(const JSONRPCRequest& request)
  function UniValue (line 527) | UniValue decodescript(const JSONRPCRequest& request)
  function TxInErrorToJSON (line 577) | static void TxInErrorToJSON(const CTxIn& txin, UniValue& vErrorsRet, con...
  function UniValue (line 593) | UniValue combinerawtransaction(const JSONRPCRequest& request)
  function UniValue (line 680) | UniValue signrawtransaction(const JSONRPCRequest& request)
  function UniValue (line 940) | UniValue sendrawtransaction(const JSONRPCRequest& request)
  function RegisterRawTransactionRPCCommands (line 1052) | void RegisterRawTransactionRPCCommands(CRPCTable &t)

FILE: src/rpc/register.h
  function RegisterAllCoreRPCCommands (line 23) | static inline void RegisterAllCoreRPCCommands(CRPCTable &t)

FILE: src/rpc/safemode.cpp
  function ObserveSafeMode (line 7) | void ObserveSafeMode()

FILE: src/rpc/server.cpp
  type CRPCSignals (line 35) | struct CRPCSignals
  function RPCTypeCheck (line 52) | void RPCTypeCheck(const UniValue& params,
  function RPCTypeCheckArgument (line 70) | void RPCTypeCheckArgument(const UniValue& value, UniValue::VType typeExp...
  function RPCTypeCheckObj (line 77) | void RPCTypeCheckObj(const UniValue& o,
  function CAmount (line 107) | CAmount AmountFromValue(const UniValue& value)
  function uint256 (line 119) | uint256 ParseHashV(const UniValue& v, std::string strName)
  function uint256 (line 132) | uint256 ParseHashO(const UniValue& o, std::string strKey)
  function ParseHexV (line 136) | std::vector<unsigned char> ParseHexV(const UniValue& v, std::string strN...
  function ParseHexO (line 145) | std::vector<unsigned char> ParseHexO(const UniValue& o, std::string strKey)
  function UniValue (line 210) | UniValue help(const JSONRPCRequest& jsonRequest)
  function UniValue (line 230) | UniValue stop(const JSONRPCRequest& jsonRequest)
  function UniValue (line 243) | UniValue uptime(const JSONRPCRequest& jsonRequest)
  function CRPCCommand (line 283) | const CRPCCommand *CRPCTable::operator[](const std::string &name) const
  function StartRPC (line 305) | bool StartRPC()
  function InterruptRPC (line 313) | void InterruptRPC()
  function StopRPC (line 320) | void StopRPC()
  function IsRPCRunning (line 328) | bool IsRPCRunning()
  function SetRPCWarmupStatus (line 333) | void SetRPCWarmupStatus(const std::string& newStatus)
  function SetRPCWarmupFinished (line 339) | void SetRPCWarmupFinished()
  function RPCIsInWarmup (line 346) | bool RPCIsInWarmup(std::string *outStatus)
  function IsDeprecatedRPCEnabled (line 383) | bool IsDeprecatedRPCEnabled(const std::string& method)
  function UniValue (line 390) | static UniValue JSONRPCExecOne(JSONRPCRequest jreq, const UniValue& req)
  function JSONRPCExecBatch (line 413) | std::string JSONRPCExecBatch(const JSONRPCRequest& jreq, const UniValue&...
  function JSONRPCRequest (line 426) | static inline JSONRPCRequest transformNamedArguments(const JSONRPCReques...
  function UniValue (line 472) | UniValue CRPCTable::execute(const JSONRPCRequest &request) const
  function HelpExampleCli (line 514) | std::string HelpExampleCli(const std::string& methodname, const std::str...
  function HelpExampleRpc (line 519) | std::string HelpExampleRpc(const std::string& methodname, const std::str...
  function RPCSetTimerInterfaceIfUnset (line 525) | void RPCSetTimerInterfaceIfUnset(RPCTimerInterface *iface)
  function RPCSetTimerInterface (line 531) | void RPCSetTimerInterface(RPCTimerInterface *iface)
  function RPCUnsetTimerInterface (line 536) | void RPCUnsetTimerInterface(RPCTimerInterface *iface)
  function RPCRunLater (line 542) | void RPCRunLater(const std::string& name, std::function<void(void)> func...
  function RPCSerializationFlags (line 551) | int RPCSerializationFlags()

FILE: src/rpc/server.h
  function namespace (line 24) | namespace RPCServer
  type UniValueType (line 32) | struct UniValueType {
  function class (line 39) | class JSONRPCRequest
  function class (line 91) | class RPCTimerBase
  function class (line 100) | class RPCTimerInterface
  type UniValue (line 128) | typedef UniValue(*rpcfn_type)(const JSONRPCRequest& jsonRequest);
  function class (line 130) | class CRPCCommand
  function class (line 142) | class CRPCTable

FILE: src/rpc/util.cpp
  function CPubKey (line 14) | CPubKey HexToPubKey(const std::string& hex_in)
  function CPubKey (line 27) | CPubKey AddrToPubKey(CKeyStore* const keystore, const std::string& addr_in)
  function CScript (line 48) | CScript CreateMultisigRedeemscript(const int required, const std::vector...

FILE: src/scheduler.cpp
  function toPosixTime (line 25) | static boost::system_time toPosixTime(const boost::chrono::system_clock:...
  function Repeat (line 120) | static void Repeat(CScheduler* s, CScheduler::Function f, int64_t deltaM...
  type RAIICallbacksRunning (line 175) | struct RAIICallbacksRunning {
    method RAIICallbacksRunning (line 177) | explicit RAIICallbacksRunning(SingleThreadedSchedulerClient* _instance...

FILE: src/scheduler.h
  function class (line 37) | class CScheduler
  function class (line 93) | class SingleThreadedSchedulerClient {

FILE: src/script/bitcoinconsensus.cpp
  class TxInputStream (line 16) | class TxInputStream
    method TxInputStream (line 19) | TxInputStream(int nTypeIn, int nVersionIn, const unsigned char *txTo, ...
    method read (line 26) | void read(char* pch, size_t nSize)
    method TxInputStream (line 43) | TxInputStream& operator>>(T& obj)
    method GetVersion (line 49) | int GetVersion() const { return m_version; }
    method GetType (line 50) | int GetType() const { return m_type; }
  function set_error (line 58) | inline int set_error(bitcoinconsensus_error* ret, bitcoinconsensus_error...
  type ECCryptoClosure (line 65) | struct ECCryptoClosure
  function verify_flags (line 74) | static bool verify_flags(unsigned int flags)
  function verify_script (line 79) | static int verify_script(const unsigned char *scriptPubKey, unsigned int...
  function bitcoinconsensus_verify_script_with_amount (line 104) | int bitcoinconsensus_verify_script_with_amount(const unsigned char *scri...
  function bitcoinconsensus_verify_script (line 113) | int bitcoinconsensus_verify_script(const unsigned char *scriptPubKey, un...
  function bitcoinconsensus_version (line 125) | unsigned int bitcoinconsensus_version()

FILE: src/script/bitcoinconsensus.h
  type bitcoinconsensus_error (line 38) | typedef enum bitcoinconsensus_error_t

FILE: src/script/interpreter.cpp
  function set_success (line 19) | inline bool set_success(ScriptError* ret)
  function set_error (line 26) | inline bool set_error(ScriptError* ret, const ScriptError serror)
  function CastToBool (line 35) | bool CastToBool(const valtype& vch)
  function popstack (line 56) | static inline void popstack(std::vector<valtype>& stack)
  function IsCompressedOrUncompressedPubKey (line 63) | bool static IsCompressedOrUncompressedPubKey(const valtype &vchPubKey) {
  function IsCompressedPubKey (line 85) | bool static IsCompressedPubKey(const valtype &vchPubKey) {
  function IsValidSignatureEncoding (line 107) | bool static IsValidSignatureEncoding(const std::vector<unsigned char> &s...
  function IsLowDERSignature (line 172) | bool static IsLowDERSignature(const valtype &vchSig, ScriptError* serror) {
  function IsDefinedHashtypeSignature (line 189) | bool static IsDefinedHashtypeSignature(const valtype &vchSig) {
  function CheckSignatureEncoding (line 200) | bool CheckSignatureEncoding(const std::vector<unsigned char> &vchSig, un...
  function CheckPubKeyEncoding (line 217) | bool static CheckPubKeyEncoding(const valtype &vchPubKey, unsigned int f...
  function CheckMinimalPush (line 228) | bool static CheckMinimalPush(const valtype& data, opcodetype opcode) {
  function EvalScript (line 251) | bool EvalScript(std::vector<std::vector<unsigned char> >& stack, const C...
  class CTransactionSignatureSerializer (line 1062) | class CTransactionSignatureSerializer {
    method CTransactionSignatureSerializer (line 1072) | CTransactionSignatureSerializer(const CTransaction &txToIn, const CScr...
    method SerializeScriptCode (line 1080) | void SerializeScriptCode(S &s) const {
    method SerializeInput (line 1103) | void SerializeInput(S &s, unsigned int nInput) const {
    method SerializeOutput (line 1125) | void SerializeOutput(S &s, unsigned int nOutput) const {
    method Serialize (line 1135) | void Serialize(S &s) const {
  function uint256 (line 1153) | uint256 GetPrevoutHash(const CTransaction& txTo) {
  function uint256 (line 1161) | uint256 GetSequenceHash(const CTransaction& txTo) {
  function uint256 (line 1169) | uint256 GetOutputsHash(const CTransaction& txTo) {
  function uint256 (line 1190) | uint256 SignatureHash(const CScript& scriptCode, const CTransaction& txT...
  function VerifyWitnessProgram (line 1367) | static bool VerifyWitnessProgram(const CScriptWitness& witness, int witv...
  function VerifyScript (line 1420) | bool VerifyScript(const CScript& scriptSig, const CScript& scriptPubKey,...
  function WitnessSigOps (line 1539) | size_t static WitnessSigOps(int witversion, const std::vector<unsigned c...
  function CountWitnessSigOps (line 1555) | size_t CountWitnessSigOps(const CScript& scriptSig, const CScript& scrip...

FILE: src/script/interpreter.h
  type PrecomputedTransactionData (line 122) | struct PrecomputedTransactionData
  type SigVersion (line 130) | enum SigVersion
  function class (line 138) | class BaseSignatureChecker

FILE: src/script/ismine.cpp
  function HaveKeys (line 16) | unsigned int HaveKeys(const std::vector<valtype>& pubkeys, const CKeySto...
  function isminetype (line 28) | isminetype IsMine(const CKeyStore& keystore, const CScript& scriptPubKey...
  function isminetype (line 34) | isminetype IsMine(const CKeyStore& keystore, const CTxDestination& dest,...
  function isminetype (line 40) | isminetype IsMine(const CKeyStore &keystore, const CTxDestination& dest,...
  function isminetype (line 46) | isminetype IsMine(const CKeyStore &keystore, const CScript& scriptPubKey...

FILE: src/script/ismine.h
  type isminetype (line 17) | enum isminetype
  type isminefilter (line 29) | typedef uint8_t isminefilter;

FILE: src/script/script.h
  type opcodetype (line 48) | enum opcodetype
  function class (line 199) | class scriptnum_error : public std::runtime_error
  function class (line 205) | class CScriptNum
  type CScriptBase (line 386) | typedef prevector<28, unsigned char> CScriptBase;
  function class (line 389) | class CScript : public CScriptBase
  function explicit (line 437) | explicit CScript(opcodetype b)     { operator<<(b); }
  function explicit (line 438) | explicit CScript(const CScriptNum& b) { operator<<(b); }
  function explicit (line 439) | explicit CScript(const std::vector<unsigned char>& b) { operator<<(b); }
  function GetOp (line 496) | bool GetOp(iterator& pc, opcodetype& opcodeRet, std::vector<unsigned cha...
  function GetOp (line 505) | bool GetOp(iterator& pc, opcodetype& opcodeRet)
  function GetOp (line 513) | bool GetOp(const_iterator& pc, opcodetype& opcodeRet, std::vector<unsign...
  function GetOp (line 518) | bool GetOp(const_iterator& pc, opcodetype& opcodeRet) const
  function GetOp2 (line 523) | bool GetOp2(const_iterator& pc, opcodetype& opcodeRet, std::vector<unsig...
  function DecodeOP_N (line 576) | static int DecodeOP_N(opcodetype opcode)
  function opcodetype (line 583) | static opcodetype EncodeOP_N(int n)
  function FindAndDelete (line 591) | int FindAndDelete(const CScript& b)
  function Find (line 618) | int Find(opcodetype op) const
  function IsPayToScriptHash (line 643) | bool IsPayToScriptHash() const;
  function SetNull (line 672) | struct CScriptWitness
  function class (line 688) | class CReserveScript

FILE: src/script/script_error.h
  type ScriptError (line 9) | typedef enum ScriptError_t

FILE: src/script/sigcache.cpp
  class CSignatureCache (line 23) | class CSignatureCache
    method CSignatureCache (line 33) | CSignatureCache()
    method ComputeEntry (line 38) | void
    method Get (line 44) | bool
    method Set (line 51) | void Set(uint256& entry)
    method setup_bytes (line 56) | uint32_t setup_bytes(size_t n)
  function InitSignatureCache (line 73) | void InitSignatureCache()

FILE: src/script/sigcache.h
  function class (line 30) | class SignatureCacheHasher
  function class (line 43) | class CachingTransactionSignatureChecker : public TransactionSignatureCh...

FILE: src/script/sign.cpp
  function Sign1 (line 37) | static bool Sign1(const CKeyID& address, const BaseSignatureCreator& cre...
  function SignN (line 46) | static bool SignN(const std::vector<valtype>& multisigdata, const BaseSi...
  function SignStep (line 66) | static bool SignStep(const BaseSignatureCreator& creator, const CScript&...
  function CScript (line 126) | static CScript PushAll(const std::vector<valtype>& values)
  function ProduceSignature (line 141) | bool ProduceSignature(const BaseSignatureCreator& creator, const CScript...
  function SignatureData (line 189) | SignatureData DataFromTransaction(const CMutableTransaction& tx, unsigne...
  function UpdateTransaction (line 198) | void UpdateTransaction(CMutableTransaction& tx, unsigned int nIn, const ...
  function SignSignature (line 205) | bool SignSignature(const CKeyStore &keystore, const CScript& fromPubKey,...
  function SignSignature (line 218) | bool SignSignature(const CKeyStore &keystore, const CTransaction& txFrom...
  function CombineMultisig (line 228) | static std::vector<valtype> CombineMultisig(const CScript& scriptPubKey,...
  type Stacks (line 285) | struct Stacks
    method Stacks (line 290) | Stacks() {}
    method Stacks (line 291) | explicit Stacks(const std::vector<valtype>& scriptSigStack_) : script(...
    method Stacks (line 292) | explicit Stacks(const SignatureData& data) : witness(data.scriptWitnes...
    method SignatureData (line 296) | SignatureData Output() const {
  function Stacks (line 305) | static Stacks CombineSignatures(const CScript& scriptPubKey, const BaseS...
    method Stacks (line 290) | Stacks() {}
    method Stacks (line 291) | explicit Stacks(const std::vector<valtype>& scriptSigStack_) : script(...
    method Stacks (line 292) | explicit Stacks(const SignatureData& data) : witness(data.scriptWitnes...
    method SignatureData (line 296) | SignatureData Output() const {
  function SignatureData (line 380) | SignatureData CombineSignatures(const CScript& scriptPubKey, const BaseS...
  class DummySignatureChecker (line 392) | class DummySignatureChecker : public BaseSignatureChecker
    method DummySignatureChecker (line 395) | DummySignatureChecker() {}
    method CheckSig (line 397) | bool CheckSig(const std::vector<unsigned char>& scriptSig, const std::...
  function BaseSignatureChecker (line 405) | const BaseSignatureChecker& DummySignatureCreator::Checker() const
  function IsSolvable (line 426) | bool IsSolvable(const CKeyStore& store, const CScript& script)

FILE: src/script/sign.h
  type CMutableTransaction (line 16) | struct CMutableTransaction
  function class (line 19) | class BaseSignatureCreator {
  function virtual (line 26) | virtual ~BaseSignatureCreator() {}

FILE: src/script/standard.cpp
  function Solver (line 38) | bool Solver(const CScript& scriptPubKey, txnouttype& typeRet, std::vecto...
  function ExtractDestination (line 183) | bool ExtractDestination(const CScript& scriptPubKey, CTxDestination& add...
  function ExtractDestinations (line 230) | bool ExtractDestinations(const CScript& scriptPubKey, txnouttype& typeRe...
  class CScriptVisitor (line 272) | class CScriptVisitor : public boost::static_visitor<bool>
    method CScriptVisitor (line 277) | explicit CScriptVisitor(CScript *scriptin) { script = scriptin; }
  function CScript (line 319) | CScript GetScriptForDestination(const CTxDestination& dest)
  function CScript (line 327) | CScript GetScriptForRawPubKey(const CPubKey& pubKey)
  function CScript (line 332) | CScript GetScriptForMultisig(int nRequired, const std::vector<CPubKey>& ...
  function CScript (line 343) | CScript GetScriptForWitness(const CScript& redeemscript)
  function IsValidDestination (line 361) | bool IsValidDestination(const CTxDestination& dest) {

FILE: src/script/standard.h
  function class (line 22) | class CScriptID : public uint160
  type txnouttype (line 56) | enum txnouttype
  function class (line 70) | class CNoDestination {
  function uint256 (line 76) | struct WitnessV0ScriptHash : public uint256
  function uint160 (line 83) | struct WitnessV0KeyHash : public uint160
  type WitnessUnknown (line 91) | struct WitnessUnknown
  type boost (line 122) | typedef boost::variant<CNoDestination, CKeyID, CScriptID, WitnessV0Scrip...

FILE: src/secp256k1/contrib/lax_der_parsing.c
  function ecdsa_signature_parse_der_lax (line 12) | int ecdsa_signature_parse_der_lax(const secp256k1_context* ctx, secp256k...

FILE: src/secp256k1/contrib/lax_der_privatekey_parsing.c
  function ec_privkey_import_der (line 12) | int ec_privkey_import_der(const secp256k1_context* ctx, unsigned char *o...
  function ec_privkey_export_der (line 56) | int ec_privkey_export_der(const secp256k1_context *ctx, unsigned char *p...

FILE: src/secp256k1/include/secp256k1.h
  type secp256k1_context (line 43) | typedef struct secp256k1_context_struct secp256k1_context;
  type secp256k1_pubkey (line 53) | typedef struct {
  type secp256k1_ecdsa_signature (line 66) | typedef struct {

FILE: src/secp256k1/include/secp256k1_recovery.h
  type secp256k1_ecdsa_recoverable_signature (line 24) | typedef struct {

FILE: src/secp256k1/src/bench.h
  function gettimedouble (line 14) | static double gettimedouble(void) {
  function print_number (line 20) | void print_number(double x) {
  function run_benchmark (line 33) | void run_benchmark(char *name, void (*benchmark)(void*), void (*setup)(v...

FILE: src/secp256k1/src/bench_ecdh.c
  type bench_ecdh_t (line 14) | typedef struct {
  function bench_ecdh_setup (line 20) | static void bench_ecdh_setup(void* arg) {
  function bench_ecdh (line 39) | static void bench_ecdh(void* arg) {
  function main (line 49) | int main(void) {

FILE: src/secp256k1/src/bench_internal.c
  type bench_inv_t (line 21) | typedef struct {
  function bench_setup (line 30) | void bench_setup(void* arg) {
  function bench_scalar_add (line 59) | void bench_scalar_add(void* arg) {
  function bench_scalar_negate (line 68) | void bench_scalar_negate(void* arg) {
  function bench_scalar_sqr (line 77) | void bench_scalar_sqr(void* arg) {
  function bench_scalar_mul (line 86) | void bench_scalar_mul(void* arg) {
  function bench_scalar_split (line 96) | void bench_scalar_split(void* arg) {
  function bench_scalar_inverse (line 108) | void bench_scalar_inverse(void* arg) {
  function bench_scalar_inverse_var (line 118) | void bench_scalar_inverse_var(void* arg) {
  function bench_field_normalize (line 128) | void bench_field_normalize(void* arg) {
  function bench_field_normalize_weak (line 137) | void bench_field_normalize_weak(void* arg) {
  function bench_field_mul (line 146) | void bench_field_mul(void* arg) {
  function bench_field_sqr (line 155) | void bench_field_sqr(void* arg) {
  function bench_field_inverse (line 164) | void bench_field_inverse(void* arg) {
  function bench_field_inverse_var (line 174) | void bench_field_inverse_var(void* arg) {
  function bench_field_sqrt (line 184) | void bench_field_sqrt(void* arg) {
  function bench_group_double_var (line 194) | void bench_group_double_var(void* arg) {
  function bench_group_add_var (line 203) | void bench_group_add_var(void* arg) {
  function bench_group_add_affine (line 212) | void bench_group_add_affine(void* arg) {
  function bench_group_add_affine_var (line 221) | void bench_group_add_affine_var(void* arg) {
  function bench_group_jacobi_var (line 230) | void bench_group_jacobi_var(void* arg) {
  function bench_ecmult_wnaf (line 239) | void bench_ecmult_wnaf(void* arg) {
  function bench_wnaf_const (line 249) | void bench_wnaf_const(void* arg) {
  function bench_sha256 (line 260) | void bench_sha256(void* arg) {
  function bench_hmac_sha256 (line 272) | void bench_hmac_sha256(void* arg) {
  function bench_rfc6979_hmac_sha256 (line 284) | void bench_rfc6979_hmac_sha256(void* arg) {
  function bench_context_verify (line 295) | void bench_context_verify(void* arg) {
  function bench_context_sign (line 303) | void bench_context_sign(void* arg) {
  function bench_num_jacobi (line 312) | void bench_num_jacobi(void* arg) {
  function have_flag (line 327) | int have_flag(int argc, char** argv, char *flag) {
  function main (line 342) | int main(int argc, char **argv) {

FILE: src/secp256k1/src/bench_recover.c
  type bench_recover_t (line 12) | typedef struct {
  function bench_recover (line 18) | void bench_recover(void* arg) {
  function bench_recover_setup (line 39) | void bench_recover_setup(void* arg) {
  function main (line 51) | int main(void) {

FILE: src/secp256k1/src/bench_sign.c
  type bench_sign_t (line 11) | typedef struct {
  function bench_sign_setup (line 17) | static void bench_sign_setup(void* arg) {
  function bench_sign (line 29) | static void bench_sign(void* arg) {
  function main (line 47) | int main(void) {

FILE: src/secp256k1/src/bench_verify.c
  type benchmark_verify_t (line 20) | typedef struct {
  function benchmark_verify (line 33) | static void benchmark_verify(void* arg) {
  function benchmark_verify_openssl (line 53) | static void benchmark_verify_openssl(void* arg) {
  function main (line 82) | int main(void) {

FILE: src/secp256k1/src/ecdsa_impl.h
  function secp256k1_der_read_len (line 49) | static int secp256k1_der_read_len(const unsigned char **sigp, const unsi...
  function secp256k1_der_parse_integer (line 99) | static int secp256k1_der_parse_integer(secp256k1_scalar *r, const unsign...
  function secp256k1_ecdsa_sig_parse (line 145) | static int secp256k1_ecdsa_sig_parse(secp256k1_scalar *rr, secp256k1_sca...
  function secp256k1_ecdsa_sig_serialize (line 177) | static int secp256k1_ecdsa_sig_serialize(unsigned char *sig, size_t *siz...
  function secp256k1_ecdsa_sig_verify (line 201) | static int secp256k1_ecdsa_sig_verify(const secp256k1_ecmult_context *ct...
  function secp256k1_ecdsa_sig_sign (line 271) | static int secp256k1_ecdsa_sig_sign(const secp256k1_ecmult_gen_context *...

FILE: src/secp256k1/src/eckey_impl.h
  function secp256k1_eckey_pubkey_parse (line 17) | static int secp256k1_eckey_pubkey_parse(secp256k1_ge *elem, const unsign...
  function secp256k1_eckey_pubkey_serialize (line 37) | static int secp256k1_eckey_pubkey_serialize(secp256k1_ge *elem, unsigned...
  function secp256k1_eckey_privkey_tweak_add (line 55) | static int secp256k1_eckey_privkey_tweak_add(secp256k1_scalar *key, cons...
  function secp256k1_eckey_pubkey_tweak_add (line 63) | static int secp256k1_eckey_pubkey_tweak_add(const secp256k1_ecmult_conte...
  function secp256k1_eckey_privkey_tweak_mul (line 77) | static int secp256k1_eckey_privkey_tweak_mul(secp256k1_scalar *key, cons...
  function secp256k1_eckey_pubkey_tweak_mul (line 86) | static int secp256k1_eckey_pubkey_tweak_mul(const secp256k1_ecmult_conte...

FILE: src/secp256k1/src/ecmult.h
  type secp256k1_ecmult_context (line 13) | typedef struct {

FILE: src/secp256k1/src/ecmult_const_impl.h
  function secp256k1_wnaf_const (line 58) | int secp256k1_wnaf_const(int *wnaf, secp256k1_scalar s, int w) {
  function secp256k1_ecmult_const (line 123) | static void secp256k1_ecmult_const(secp256k1_gej *r, const secp256k1_ge ...

FILE: src/secp256k1/src/ecmult_gen.h
  type secp256k1_ecmult_gen_context (line 13) | typedef struct {

FILE: src/secp256k1/src/ecmult_gen_impl.h
  function secp256k1_ecmult_gen_context_init (line 17) | static void secp256k1_ecmult_gen_context_init(secp256k1_ecmult_gen_conte...
  function secp256k1_ecmult_gen_context_build (line 21) | static void secp256k1_ecmult_gen_context_build(secp256k1_ecmult_gen_cont...
  function secp256k1_ecmult_gen_context_is_built (line 94) | static int secp256k1_ecmult_gen_context_is_built(const secp256k1_ecmult_...
  function secp256k1_ecmult_gen_context_clone (line 98) | static void secp256k1_ecmult_gen_context_clone(secp256k1_ecmult_gen_cont...
  function secp256k1_ecmult_gen_context_clear (line 115) | static void secp256k1_ecmult_gen_context_clear(secp256k1_ecmult_gen_cont...
  function secp256k1_ecmult_gen (line 124) | static void secp256k1_ecmult_gen(const secp256k1_ecmult_gen_context *ctx...
  function secp256k1_ecmult_gen_blind (line 159) | static void secp256k1_ecmult_gen_blind(secp256k1_ecmult_gen_context *ctx...

FILE: src/secp256k1/src/ecmult_impl.h
  function secp256k1_ecmult_odd_multiples_table (line 52) | static void secp256k1_ecmult_odd_multiples_table(int n, secp256k1_gej *p...
  function secp256k1_ecmult_odd_multiples_table_globalz_windowa (line 102) | static void secp256k1_ecmult_odd_multiples_table_globalz_windowa(secp256...
  function secp256k1_ecmult_odd_multiples_table_storage_var (line 112) | static void secp256k1_ecmult_odd_multiples_table_storage_var(int n, secp...
  function secp256k1_ecmult_context_init (line 157) | static void secp256k1_ecmult_context_init(secp256k1_ecmult_context *ctx) {
  function secp256k1_ecmult_context_build (line 164) | static void secp256k1_ecmult_context_build(secp256k1_ecmult_context *ctx...
  function secp256k1_ecmult_context_clone (line 196) | static void secp256k1_ecmult_context_clone(secp256k1_ecmult_context *dst,
  function secp256k1_ecmult_context_is_built (line 216) | static int secp256k1_ecmult_context_is_built(const secp256k1_ecmult_cont...
  function secp256k1_ecmult_context_clear (line 220) | static void secp256k1_ecmult_context_clear(secp256k1_ecmult_context *ctx) {
  function secp256k1_ecmult_wnaf (line 235) | static int secp256k1_ecmult_wnaf(int *wnaf, int len, const secp256k1_sca...
  function secp256k1_ecmult (line 286) | static void secp256k1_ecmult(const secp256k1_ecmult_context *ctx, secp25...

FILE: src/secp256k1/src/field_10x26.h
  type secp256k1_fe (line 12) | typedef struct {
  type secp256k1_fe_storage (line 41) | typedef struct {

FILE: src/secp256k1/src/field_10x26_impl.h
  function secp256k1_fe_verify (line 15) | static void secp256k1_fe_verify(const secp256k1_fe *a) {
  function secp256k1_fe_normalize (line 43) | static void secp256k1_fe_normalize(secp256k1_fe *r) {
  function secp256k1_fe_normalize_weak (line 98) | static void secp256k1_fe_normalize_weak(secp256k1_fe *r) {
  function secp256k1_fe_normalize_var (line 129) | static void secp256k1_fe_normalize_var(secp256k1_fe *r) {
  function secp256k1_fe_normalizes_to_zero (line 185) | static int secp256k1_fe_normalizes_to_zero(secp256k1_fe *r) {
  function secp256k1_fe_normalizes_to_zero_var (line 214) | static int secp256k1_fe_normalizes_to_zero_var(secp256k1_fe *r) {
  function SECP256K1_INLINE (line 266) | SECP256K1_INLINE static void secp256k1_fe_set_int(secp256k1_fe *r, int a) {
  function SECP256K1_INLINE (line 276) | SECP256K1_INLINE static int secp256k1_fe_is_zero(const secp256k1_fe *a) {
  function SECP256K1_INLINE (line 285) | SECP256K1_INLINE static int secp256k1_fe_is_odd(const secp256k1_fe *a) {
  function SECP256K1_INLINE (line 293) | SECP256K1_INLINE static void secp256k1_fe_clear(secp256k1_fe *a) {
  function secp256k1_fe_cmp_var (line 304) | static int secp256k1_fe_cmp_var(const secp256k1_fe *a, const secp256k1_f...
  function secp256k1_fe_set_b32 (line 323) | static int secp256k1_fe_set_b32(secp256k1_fe *r, const unsigned char *a) {
  function secp256k1_fe_get_b32 (line 347) | static void secp256k1_fe_get_b32(unsigned char *r, const secp256k1_fe *a) {
  function SECP256K1_INLINE (line 386) | SECP256K1_INLINE static void secp256k1_fe_negate(secp256k1_fe *r, const ...
  function SECP256K1_INLINE (line 408) | SECP256K1_INLINE static void secp256k1_fe_mul_int(secp256k1_fe *r, int a) {
  function SECP256K1_INLINE (line 426) | SECP256K1_INLINE static void secp256k1_fe_add(secp256k1_fe *r, const sec...
  function SECP256K1_INLINE (line 461) | SECP256K1_INLINE static void secp256k1_fe_mul_inner(uint32_t *r, const u...
  function SECP256K1_INLINE (line 790) | SECP256K1_INLINE static void secp256k1_fe_sqr_inner(uint32_t *r, const u...
  function secp256k1_fe_mul (line 1065) | static void secp256k1_fe_mul(secp256k1_fe *r, const secp256k1_fe *a, con...
  function secp256k1_fe_sqr (line 1081) | static void secp256k1_fe_sqr(secp256k1_fe *r, const secp256k1_fe *a) {
  function SECP256K1_INLINE (line 1094) | static SECP256K1_INLINE void secp256k1_fe_cmov(secp256k1_fe *r, const se...
  function SECP256K1_INLINE (line 1116) | static SECP256K1_INLINE void secp256k1_fe_storage_cmov(secp256k1_fe_stor...
  function secp256k1_fe_to_storage (line 1130) | static void secp256k1_fe_to_storage(secp256k1_fe_storage *r, const secp2...
  function SECP256K1_INLINE (line 1144) | static SECP256K1_INLINE void secp256k1_fe_from_storage(secp256k1_fe *r, ...

FILE: src/secp256k1/src/field_5x52.h
  type secp256k1_fe (line 12) | typedef struct {
  type secp256k1_fe_storage (line 36) | typedef struct {

FILE: src/secp256k1/src/field_5x52_asm_impl.h
  function SECP256K1_INLINE (line 17) | SECP256K1_INLINE static void secp256k1_fe_mul_inner(uint64_t *r, const u...
  function SECP256K1_INLINE (line 287) | SECP256K1_INLINE static void secp256k1_fe_sqr_inner(uint64_t *r, const u...

FILE: src/secp256k1/src/field_5x52_impl.h
  function secp256k1_fe_verify (line 33) | static void secp256k1_fe_verify(const secp256k1_fe *a) {
  function secp256k1_fe_normalize (line 54) | static void secp256k1_fe_normalize(secp256k1_fe *r) {
  function secp256k1_fe_normalize_weak (line 97) | static void secp256k1_fe_normalize_weak(secp256k1_fe *r) {
  function secp256k1_fe_normalize_var (line 121) | static void secp256k1_fe_normalize_var(secp256k1_fe *r) {
  function secp256k1_fe_normalizes_to_zero (line 165) | static int secp256k1_fe_normalizes_to_zero(secp256k1_fe *r) {
  function secp256k1_fe_normalizes_to_zero_var (line 188) | static int secp256k1_fe_normalizes_to_zero_var(secp256k1_fe *r) {
  function SECP256K1_INLINE (line 229) | SECP256K1_INLINE static void secp256k1_fe_set_int(secp256k1_fe *r, int a) {
  function SECP256K1_INLINE (line 239) | SECP256K1_INLINE static int secp256k1_fe_is_zero(const secp256k1_fe *a) {
  function SECP256K1_INLINE (line 248) | SECP256K1_INLINE static int secp256k1_fe_is_odd(const secp256k1_fe *a) {
  function SECP256K1_INLINE (line 256) | SECP256K1_INLINE static void secp256k1_fe_clear(secp256k1_fe *a) {
  function secp256k1_fe_cmp_var (line 267) | static int secp256k1_fe_cmp_var(const secp256k1_fe *a, const secp256k1_f...
  function secp256k1_fe_set_b32 (line 286) | static int secp256k1_fe_set_b32(secp256k1_fe *r, const unsigned char *a) {
  function secp256k1_fe_get_b32 (line 333) | static void secp256k1_fe_get_b32(unsigned char *r, const secp256k1_fe *a) {
  function SECP256K1_INLINE (line 372) | SECP256K1_INLINE static void secp256k1_fe_negate(secp256k1_fe *r, const ...
  function SECP256K1_INLINE (line 389) | SECP256K1_INLINE static void secp256k1_fe_mul_int(secp256k1_fe *r, int a) {
  function SECP256K1_INLINE (line 402) | SECP256K1_INLINE static void secp256k1_fe_add(secp256k1_fe *r, const sec...
  function secp256k1_fe_mul (line 418) | static void secp256k1_fe_mul(secp256k1_fe *r, const secp256k1_fe *a, con...
  function secp256k1_fe_sqr (line 434) | static void secp256k1_fe_sqr(secp256k1_fe *r, const secp256k1_fe *a) {
  function SECP256K1_INLINE (line 447) | static SECP256K1_INLINE void secp256k1_fe_cmov(secp256k1_fe *r, const se...
  function SECP256K1_INLINE (line 464) | static SECP256K1_INLINE void secp256k1_fe_storage_cmov(secp256k1_fe_stor...
  function secp256k1_fe_to_storage (line 474) | static void secp256k1_fe_to_storage(secp256k1_fe_storage *r, const secp2...
  function SECP256K1_INLINE (line 484) | static SECP256K1_INLINE void secp256k1_fe_from_storage(secp256k1_fe *r, ...

FILE: src/secp256k1/src/field_5x52_int128_impl.h
  function SECP256K1_INLINE (line 18) | SECP256K1_INLINE static void secp256k1_fe_mul_inner(uint64_t *r, const u...
  function SECP256K1_INLINE (line 155) | SECP256K1_INLINE static void secp256k1_fe_sqr_inner(uint64_t *r, const u...

FILE: src/secp256k1/src/field_impl.h
  function SECP256K1_INLINE (line 24) | SECP256K1_INLINE static int secp256k1_fe_equal(const secp256k1_fe *a, co...
  function SECP256K1_INLINE (line 31) | SECP256K1_INLINE static int secp256k1_fe_equal_var(const secp256k1_fe *a...
  function secp256k1_fe_sqrt (line 38) | static int secp256k1_fe_sqrt(secp256k1_fe *r, const secp256k1_fe *a) {
  function secp256k1_fe_inv (line 136) | static void secp256k1_fe_inv(secp256k1_fe *r, const secp256k1_fe *a) {
  function secp256k1_fe_inv_var (line 226) | static void secp256k1_fe_inv_var(secp256k1_fe *r, const secp256k1_fe *a) {
  function secp256k1_fe_inv_all_var (line 263) | static void secp256k1_fe_inv_all_var(secp256k1_fe *r, const secp256k1_fe...
  function secp256k1_fe_is_quad_var (line 290) | static int secp256k1_fe_is_quad_var(const secp256k1_fe *a) {

FILE: src/secp256k1/src/gen_context.c
  function default_error_callback_fn (line 16) | static void default_error_callback_fn(const char* str, void* data) {
  function main (line 27) | int main(int argc, char **argv) {

FILE: src/secp256k1/src/group.h
  type secp256k1_ge (line 14) | typedef struct {
  type secp256k1_gej (line 24) | typedef struct {
  type secp256k1_ge_storage (line 34) | typedef struct {

FILE: src/secp256k1/src/group_impl.h
  function secp256k1_ge_set_gej_zinv (line 74) | static void secp256k1_ge_set_gej_zinv(secp256k1_ge *r, const secp256k1_g...
  function secp256k1_ge_set_xy (line 84) | static void secp256k1_ge_set_xy(secp256k1_ge *r, const secp256k1_fe *x, ...
  function secp256k1_ge_is_infinity (line 90) | static int secp256k1_ge_is_infinity(const secp256k1_ge *a) {
  function secp256k1_ge_neg (line 94) | static void secp256k1_ge_neg(secp256k1_ge *r, const secp256k1_ge *a) {
  function secp256k1_ge_set_gej (line 100) | static void secp256k1_ge_set_gej(secp256k1_ge *r, secp256k1_gej *a) {
  function secp256k1_ge_set_gej_var (line 113) | static void secp256k1_ge_set_gej_var(secp256k1_ge *r, secp256k1_gej *a) {
  function secp256k1_ge_set_all_gej_var (line 129) | static void secp256k1_ge_set_all_gej_var(secp256k1_ge *r, const secp256k...
  function secp256k1_ge_set_table_gej_var (line 155) | static void secp256k1_ge_set_table_gej_var(secp256k1_ge *r, const secp25...
  function secp256k1_ge_globalz_set_table_gej (line 173) | static void secp256k1_ge_globalz_set_table_gej(size_t len, secp256k1_ge ...
  function secp256k1_gej_set_infinity (line 196) | static void secp256k1_gej_set_infinity(secp256k1_gej *r) {
  function secp256k1_gej_clear (line 203) | static void secp256k1_gej_clear(secp256k1_gej *r) {
  function secp256k1_ge_clear (line 210) | static void secp256k1_ge_clear(secp256k1_ge *r) {
  function secp256k1_ge_set_xquad (line 216) | static int secp256k1_ge_set_xquad(secp256k1_ge *r, const secp256k1_fe *x) {
  function secp256k1_ge_set_xo_var (line 227) | static int secp256k1_ge_set_xo_var(secp256k1_ge *r, const secp256k1_fe *...
  function secp256k1_gej_set_ge (line 239) | static void secp256k1_gej_set_ge(secp256k1_gej *r, const secp256k1_ge *a) {
  function secp256k1_gej_eq_x_var (line 246) | static int secp256k1_gej_eq_x_var(const secp256k1_fe *x, const secp256k1...
  function secp256k1_gej_neg (line 254) | static void secp256k1_gej_neg(secp256k1_gej *r, const secp256k1_gej *a) {
  function secp256k1_gej_is_infinity (line 263) | static int secp256k1_gej_is_infinity(const secp256k1_gej *a) {
  function secp256k1_gej_is_valid_var (line 267) | static int secp256k1_gej_is_valid_var(const secp256k1_gej *a) {
  function secp256k1_ge_is_valid_var (line 287) | static int secp256k1_ge_is_valid_var(const secp256k1_ge *a) {
  function secp256k1_gej_double_var (line 301) | static void secp256k1_gej_double_var(secp256k1_gej *r, const secp256k1_g...
  function SECP256K1_INLINE (line 356) | static SECP256K1_INLINE void secp256k1_gej_double_nonzero(secp256k1_gej ...
  function secp256k1_gej_add_var (line 361) | static void secp256k1_gej_add_var(secp256k1_gej *r, const secp256k1_gej ...
  function secp256k1_gej_add_ge_var (line 414) | static void secp256k1_gej_add_ge_var(secp256k1_gej *r, const secp256k1_g...
  function secp256k1_gej_add_zinv_var (line 463) | static void secp256k1_gej_add_zinv_var(secp256k1_gej *r, const secp256k1...
  function secp256k1_gej_add_ge (line 520) | static void secp256k1_gej_add_ge(secp256k1_gej *r, const secp256k1_gej *...
  function secp256k1_gej_rescale (line 642) | static void secp256k1_gej_rescale(secp256k1_gej *r, const secp256k1_fe *...
  function secp256k1_ge_to_storage (line 653) | static void secp256k1_ge_to_storage(secp256k1_ge_storage *r, const secp2...
  function secp256k1_ge_from_storage (line 664) | static void secp256k1_ge_from_storage(secp256k1_ge *r, const secp256k1_g...
  function SECP256K1_INLINE (line 670) | static SECP256K1_INLINE void secp256k1_ge_storage_cmov(secp256k1_ge_stor...
  function secp256k1_ge_mul_lambda (line 676) | static void secp256k1_ge_mul_lambda(secp256k1_ge *r, const secp256k1_ge ...
  function secp256k1_gej_has_quad_y_var (line 686) | static int secp256k1_gej_has_quad_y_var(const secp256k1_gej *a) {

FILE: src/secp256k1/src/hash.h
  type secp256k1_sha256_t (line 13) | typedef struct {
  type secp256k1_hmac_sha256_t (line 23) | typedef struct {
  type secp256k1_rfc6979_hmac_sha256_t (line 31) | typedef struct {

FILE: src/secp256k1/src/hash_impl.h
  function secp256k1_sha256_initialize (line 36) | static void secp256k1_sha256_initialize(secp256k1_sha256_t *hash) {
  function secp256k1_sha256_transform (line 49) | static void secp256k1_sha256_transform(uint32_t* s, const uint32_t* chun...
  function secp256k1_sha256_write (line 131) | static void secp256k1_sha256_write(secp256k1_sha256_t *hash, const unsig...
  function secp256k1_sha256_finalize (line 148) | static void secp256k1_sha256_finalize(secp256k1_sha256_t *hash, unsigned...
  function secp256k1_hmac_sha256_initialize (line 164) | static void secp256k1_hmac_sha256_initialize(secp256k1_hmac_sha256_t *ha...
  function secp256k1_hmac_sha256_write (line 192) | static void secp256k1_hmac_sha256_write(secp256k1_hmac_sha256_t *hash, c...
  function secp256k1_hmac_sha256_finalize (line 196) | static void secp256k1_hmac_sha256_finalize(secp256k1_hmac_sha256_t *hash...
  function secp256k1_rfc6979_hmac_sha256_initialize (line 205) | static void secp256k1_rfc6979_hmac_sha256_initialize(secp256k1_rfc6979_h...
  function secp256k1_rfc6979_hmac_sha256_generate (line 235) | static void secp256k1_rfc6979_hmac_sha256_generate(secp256k1_rfc6979_hma...
  function secp256k1_rfc6979_hmac_sha256_finalize (line 266) | static void secp256k1_rfc6979_hmac_sha256_finalize(secp256k1_rfc6979_hma...

FILE: src/secp256k1/src/java/org/bitcoin/NativeSecp256k1.java
  class NativeSecp256k1 (line 40) | public class NativeSecp256k1 {
    method verify (line 54) | public static boolean verify(byte[] data, byte[] signature, byte[] pub...
    method sign (line 87) | public static byte[] sign(byte[] data, byte[] sec) throws AssertFailEx...
    method secKeyVerify (line 123) | public static boolean secKeyVerify(byte[] seckey) {
    method computePubkey (line 153) | public static byte[] computePubkey(byte[] seckey) throws AssertFailExc...
    method cleanup (line 187) | public static synchronized void cleanup() {
    method cloneContext (line 196) | public static long cloneContext() {
    method privKeyTweakMul (line 209) | public static byte[] privKeyTweakMul(byte[] privkey, byte[] tweak) thr...
    method privKeyTweakAdd (line 248) | public static byte[] privKeyTweakAdd(byte[] privkey, byte[] tweak) thr...
    method pubKeyTweakAdd (line 287) | public static byte[] pubKeyTweakAdd(byte[] pubkey, byte[] tweak) throw...
    method pubKeyTweakMul (line 326) | public static byte[] pubKeyTweakMul(byte[] pubkey, byte[] tweak) throw...
    method createECDHSecret (line 365) | public static byte[] createECDHSecret(byte[] seckey, byte[] pubkey) th...
    method randomize (line 400) | public static synchronized boolean randomize(byte[] seed) throws Asser...
    method secp256k1_ctx_clone (line 420) | private static native long secp256k1_ctx_clone(long context);
    method secp256k1_context_randomize (line 422) | private static native int secp256k1_context_randomize(ByteBuffer byteB...
    method secp256k1_privkey_tweak_add (line 424) | private static native byte[][] secp256k1_privkey_tweak_add(ByteBuffer ...
    method secp256k1_privkey_tweak_mul (line 426) | private static native byte[][] secp256k1_privkey_tweak_mul(ByteBuffer ...
    method secp256k1_pubkey_tweak_add (line 428) | private static native byte[][] secp256k1_pubkey_tweak_add(ByteBuffer b...
    method secp256k1_pubkey_tweak_mul (line 430) | private static native byte[][] secp256k1_pubkey_tweak_mul(ByteBuffer b...
    method secp256k1_destroy_context (line 432) | private static native void secp256k1_destroy_context(long context);
    method secp256k1_ecdsa_verify (line 434) | private static native int secp256k1_ecdsa_verify(ByteBuffer byteBuff, ...
    method secp256k1_ecdsa_sign (line 436) | private static native byte[][] secp256k1_ecdsa_sign(ByteBuffer byteBuf...
    method secp256k1_ec_seckey_verify (line 438) | private static native int secp256k1_ec_seckey_verify(ByteBuffer byteBu...
    method secp256k1_ec_pubkey_create (line 440) | private static native byte[][] secp256k1_ec_pubkey_create(ByteBuffer b...
    method secp256k1_ec_pubkey_parse (line 442) | private static native byte[][] secp256k1_ec_pubkey_parse(ByteBuffer by...
    method secp256k1_ecdh (line 444) | private static native byte[][] secp256k1_ecdh(ByteBuffer byteBuff, lon...

FILE: src/secp256k1/src/java/org/bitcoin/NativeSecp256k1Test.java
  class NativeSecp256k1Test (line 12) | public class NativeSecp256k1Test {
    method testVerifyPos (line 18) | public static void testVerifyPos() throws AssertFailException{
    method testVerifyNeg (line 31) | public static void testVerifyNeg() throws AssertFailException{
    method testSecKeyVerifyPos (line 45) | public static void testSecKeyVerifyPos() throws AssertFailException{
    method testSecKeyVerifyNeg (line 57) | public static void testSecKeyVerifyNeg() throws AssertFailException{
    method testPubKeyCreatePos (line 69) | public static void testPubKeyCreatePos() throws AssertFailException{
    method testPubKeyCreateNeg (line 80) | public static void testPubKeyCreateNeg() throws AssertFailException{
    method testSignPos (line 91) | public static void testSignPos() throws AssertFailException{
    method testSignNeg (line 104) | public static void testSignNeg() throws AssertFailException{
    method testPrivKeyTweakAdd_1 (line 116) | public static void testPrivKeyTweakAdd_1() throws AssertFailException {
    method testPrivKeyTweakMul_1 (line 128) | public static void testPrivKeyTweakMul_1() throws AssertFailException {
    method testPrivKeyTweakAdd_2 (line 140) | public static void testPrivKeyTweakAdd_2() throws AssertFailException {
    method testPrivKeyTweakMul_2 (line 152) | public static void testPrivKeyTweakMul_2() throws AssertFailException {
    method testRandomize (line 164) | public static void testRandomize() throws AssertFailException {
    method testCreateECDHSecret (line 170) | public static void testCreateECDHSecret() throws AssertFailException{
    method main (line 180) | public static void main(String[] args) throws AssertFailException{

FILE: src/secp256k1/src/java/org/bitcoin/NativeSecp256k1Util.java
  class NativeSecp256k1Util (line 19) | public class NativeSecp256k1Util{
    method assertEquals (line 21) | public static void assertEquals( int val, int val2, String message ) t...
    method assertEquals (line 26) | public static void assertEquals( boolean val, boolean val2, String mes...
    method assertEquals (line 33) | public static void assertEquals( String val, String val2, String messa...
    class AssertFailException (line 40) | public static class AssertFailException extends Exception {
      method AssertFailException (line 41) | public AssertFailException(String message) {

FILE: src/secp256k1/src/java/org/bitcoin/Secp256k1Context.java
  class Secp256k1Context (line 23) | public class Secp256k1Context {
    method isEnabled (line 41) | public static boolean isEnabled() {
    method getContext (line 45) | public static long getContext() {
    method secp256k1_init_context (line 50) | private static native long secp256k1_init_context();

FILE: src/secp256k1/src/java/org_bitcoin_NativeSecp256k1.c
  function JNICALL (line 10) | JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ctx_1clone
  function JNICALL (line 23) | JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1context_1randomize
  function JNICALL (line 36) | JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1destroy_1context
  function JNICALL (line 46) | JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ecdsa_1verify
  function JNICALL (line 73) | JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ecdsa_1sign
  function JNICALL (line 115) | JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ec_1seckey_1verify
  function JNICALL (line 126) | JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ec_1pubkey_1create
  function JNICALL (line 168) | JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1privkey_1tweak_1add
  function JNICALL (line 203) | JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1privkey_1tweak_1mul
  function JNICALL (line 238) | JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1pubkey_1tweak_1add
  function JNICALL (line 283) | JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1pubkey_1tweak_1mul
  function JNICALL (line 327) | JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ecdsa_1pubkey_1combine
  function JNICALL (line 335) | JNICALL Java_org_bitcoin_NativeSecp256k1_secp256k1_1ecdh

FILE: src/secp256k1/src/java/org_bitcoin_Secp256k1Context.c
  function JNICALL (line 6) | JNICALL Java_org_bitcoin_Secp256k1Context_secp256k1_1init_1context

FILE: src/secp256k1/src/modules/ecdh/main_impl.h
  function secp256k1_ecdh (line 13) | int secp256k1_ecdh(const secp256k1_context* ctx, unsigned char *result, ...

FILE: src/secp256k1/src/modules/ecdh/tests_impl.h
  function test_ecdh_api (line 10) | void test_ecdh_api(void) {
  function test_ecdh_generator_basepoint (line 39) | void test_ecdh_generator_basepoint(void) {
  function test_bad_scalar (line 73) | void test_bad_scalar(void) {
  function run_ecdh_tests (line 99) | void run_ecdh_tests(void) {

FILE: src/secp256k1/src/modules/recovery/main_impl.h
  function secp256k1_ecdsa_recoverable_signature_load (line 12) | static void secp256k1_ecdsa_recoverable_signature_load(const secp256k1_c...
  function secp256k1_ecdsa_recoverable_signature_save (line 27) | static void secp256k1_ecdsa_recoverable_signature_save(secp256k1_ecdsa_r...
  function secp256k1_ecdsa_recoverable_signature_parse_compact (line 38) | int secp256k1_ecdsa_recoverable_signature_parse_compact(const secp256k1_...
  function secp256k1_ecdsa_recoverable_signature_serialize_compact (line 60) | int secp256k1_ecdsa_recoverable_signature_serialize_compact(const secp25...
  function secp256k1_ecdsa_recoverable_signature_convert (line 74) | int secp256k1_ecdsa_recoverable_signature_convert(const secp256k1_contex...
  function secp256k1_ecdsa_sig_recover (line 87) | static int secp256k1_ecdsa_sig_recover(const secp256k1_ecmult_context *c...
  function secp256k1_ecdsa_sign_recoverable (line 123) | int secp256k1_ecdsa_sign_recoverable(const secp256k1_context* ctx, secp2...
  function secp256k1_ecdsa_recover (line 170) | int secp256k1_ecdsa_recover(const secp256k1_context* ctx, secp256k1_pubk...

FILE: src/secp256k1/src/modules/recovery/tests_impl.h
  function recovery_test_nonce_function (line 10) | static int recovery_test_nonce_function(unsigned char *nonce32, const un...
  function test_ecdsa_recovery_api (line 31) | void test_ecdsa_recovery_api(void) {
  function test_ecdsa_recovery_end_to_end (line 150) | void test_ecdsa_recovery_end_to_end(void) {
  function test_ecdsa_recovery_edge_cases (line 209) | void test_ecdsa_recovery_edge_cases(void) {
  function run_recovery_tests (line 382) | void run_recovery_tests(void) {

FILE: src/secp256k1/src/num_gmp.h
  type secp256k1_num (line 14) | typedef struct {

FILE: src/secp256k1/src/num_gmp_impl.h
  function secp256k1_num_sanity (line 18) | static void secp256k1_num_sanity(const secp256k1_num *a) {
  function secp256k1_num_copy (line 25) | static void secp256k1_num_copy(secp256k1_num *r, const secp256k1_num *a) {
  function secp256k1_num_get_bin (line 29) | static void secp256k1_num_get_bin(unsigned char *r, unsigned int rlen, c...
  function secp256k1_num_set_bin (line 45) | static void secp256k1_num_set_bin(secp256k1_num *r, const unsigned char ...
  function secp256k1_num_add_abs (line 62) | static void secp256k1_num_add_abs(secp256k1_num *r, const secp256k1_num ...
  function secp256k1_num_sub_abs (line 71) | static void secp256k1_num_sub_abs(secp256k1_num *r, const secp256k1_num ...
  function secp256k1_num_mod (line 81) | static void secp256k1_num_mod(secp256k1_num *r, const secp256k1_num *m) {
  function secp256k1_num_mod_inverse (line 101) | static void secp256k1_num_mod_inverse(secp256k1_num *r, const secp256k1_...
  function secp256k1_num_jacobi (line 147) | static int secp256k1_num_jacobi(const secp256k1_num *a, const secp256k1_...
  function secp256k1_num_is_one (line 169) | static int secp256k1_num_is_one(const secp256k1_num *a) {
  function secp256k1_num_is_zero (line 173) | static int secp256k1_num_is_zero(const secp256k1_num *a) {
  function secp256k1_num_is_neg (line 177) | static int secp256k1_num_is_neg(const secp256k1_num *a) {
  function secp256k1_num_cmp (line 181) | static int secp256k1_num_cmp(const secp256k1_num *a, const secp256k1_num...
  function secp256k1_num_eq (line 191) | static int secp256k1_num_eq(const secp256k1_num *a, const secp256k1_num ...
  function secp256k1_num_subadd (line 204) | static void secp256k1_num_subadd(secp256k1_num *r, const secp256k1_num *...
  function secp256k1_num_add (line 223) | static void secp256k1_num_add(secp256k1_num *r, const secp256k1_num *a, ...
  function secp256k1_num_sub (line 229) | static void secp256k1_num_sub(secp256k1_num *r, const secp256k1_num *a, ...
  function secp256k1_num_mul (line 235) | static void secp256k1_num_mul(secp256k1_num *r, const secp256k1_num *a, ...
  function secp256k1_num_shift (line 262) | static void secp256k1_num_shift(secp256k1_num *r, int bits) {
  function secp256k1_num_negate (line 284) | static void secp256k1_num_negate(secp256k1_num *r) {

FILE: src/secp256k1/src/scalar_4x64.h
  type secp256k1_scalar (line 13) | typedef struct {

FILE: src/secp256k1/src/scalar_4x64_impl.h
  function SECP256K1_INLINE (line 27) | SECP256K1_INLINE static void secp256k1_scalar_clear(secp256k1_scalar *r) {
  function SECP256K1_INLINE (line 34) | SECP256K1_INLINE static void secp256k1_scalar_set_int(secp256k1_scalar *...
  function secp256k1_scalar_get_bits (line 41) | int secp256k1_scalar_get_bits(const secp256k1_scalar *a, unsigned int of...
  function secp256k1_scalar_get_bits_var (line 46) | int secp256k1_scalar_get_bits_var(const secp256k1_scalar *a, unsigned in...
  function SECP256K1_INLINE (line 57) | SECP256K1_INLINE static int secp256k1_scalar_check_overflow(const secp25...
  function SECP256K1_INLINE (line 69) | SECP256K1_INLINE static int secp256k1_scalar_reduce(secp256k1_scalar *r,...
  function secp256k1_scalar_add (line 83) | static int secp256k1_scalar_add(secp256k1_scalar *r, const secp256k1_sca...
  function secp256k1_scalar_cadd_bit (line 99) | static void secp256k1_scalar_cadd_bit(secp256k1_scalar *r, unsigned int ...
  function secp256k1_scalar_set_b32 (line 117) | static void secp256k1_scalar_set_b32(secp256k1_scalar *r, const unsigned...
  function secp256k1_scalar_get_b32 (line 129) | static void secp256k1_scalar_get_b32(unsigned char *bin, const secp256k1...
  function SECP256K1_INLINE (line 136) | SECP256K1_INLINE static int secp256k1_scalar_is_zero(const secp256k1_sca...
  function secp256k1_scalar_negate (line 140) | static void secp256k1_scalar_negate(secp256k1_scalar *r, const secp256k1...
  function SECP256K1_INLINE (line 152) | SECP256K1_INLINE static int secp256k1_scalar_is_one(const secp256k1_scal...
  function secp256k1_scalar_is_high (line 156) | static int secp256k1_scalar_is_high(const secp256k1_scalar *a) {
  function secp256k1_scalar_cond_negate (line 168) | static int secp256k1_scalar_cond_negate(secp256k1_scalar *r, int flag) {
  function secp256k1_scalar_reduce_512 (line 270) | static void secp256k1_scalar_reduce_512(secp256k1_scalar *r, const uint6...
  function secp256k1_scalar_mul_512 (line 579) | static void secp256k1_scalar_mul_512(uint64_t l[8], const secp256k1_scal...
  function secp256k1_scalar_sqr_512 (line 746) | static void secp256k1_scalar_sqr_512(uint64_t l[8], const secp256k1_scal...
  function secp256k1_scalar_mul (line 891) | static void secp256k1_scalar_mul(secp256k1_scalar *r, const secp256k1_sc...
  function secp256k1_scalar_shr_int (line 897) | static int secp256k1_scalar_shr_int(secp256k1_scalar *r, int n) {
  function secp256k1_scalar_sqr (line 909) | static void secp256k1_scalar_sqr(secp256k1_scalar *r, const secp256k1_sc...
  function secp256k1_scalar_split_128 (line 916) | static void secp256k1_scalar_split_128(secp256k1_scalar *r1, secp256k1_s...
  function SECP256K1_INLINE (line 928) | SECP256K1_INLINE static int secp256k1_scalar_eq(const secp256k1_scalar *...
  function SECP256K1_INLINE (line 932) | SECP256K1_INLINE static void secp256k1_scalar_mul_shift_var(secp256k1_sc...

FILE: src/secp256k1/src/scalar_8x32.h
  type secp256k1_scalar (line 13) | typedef struct {

FILE: src/secp256k1/src/scalar_8x32_impl.h
  function SECP256K1_INLINE (line 37) | SECP256K1_INLINE static void secp256k1_scalar_clear(secp256k1_scalar *r) {
  function SECP256K1_INLINE (line 48) | SECP256K1_INLINE static void secp256k1_scalar_set_int(secp256k1_scalar *...
  function secp256k1_scalar_get_bits (line 59) | int secp256k1_scalar_get_bits(const secp256k1_scalar *a, unsigned int of...
  function secp256k1_scalar_get_bits_var (line 64) | int secp256k1_scalar_get_bits_var(const secp256k1_scalar *a, unsigned in...
  function SECP256K1_INLINE (line 75) | SECP256K1_INLINE static int secp256k1_scalar_check_overflow(const secp25...
  function SECP256K1_INLINE (line 93) | SECP256K1_INLINE static int secp256k1_scalar_reduce(secp256k1_scalar *r,...
  function secp256k1_scalar_add (line 115) | static int secp256k1_scalar_add(secp256k1_scalar *r, const secp256k1_sca...
  function secp256k1_scalar_cadd_bit (line 139) | static void secp256k1_scalar_cadd_bit(secp256k1_scalar *r, unsigned int ...
  function secp256k1_scalar_set_b32 (line 165) | static void secp256k1_scalar_set_b32(secp256k1_scalar *r, const unsigned...
  function secp256k1_scalar_get_b32 (line 181) | static void secp256k1_scalar_get_b32(unsigned char *bin, const secp256k1...
  function SECP256K1_INLINE (line 192) | SECP256K1_INLINE static int secp256k1_scalar_is_zero(const secp256k1_sca...
  function secp256k1_scalar_negate (line 196) | static void secp256k1_scalar_negate(secp256k1_scalar *r, const secp256k1...
  function SECP256K1_INLINE (line 216) | SECP256K1_INLINE static int secp256k1_scalar_is_one(const secp256k1_scal...
  function secp256k1_scalar_is_high (line 220) | static int secp256k1_scalar_is_high(const secp256k1_scalar *a) {
  function secp256k1_scalar_cond_negate (line 238) | static int secp256k1_scalar_cond_negate(secp256k1_scalar *r, int flag) {
  function secp256k1_scalar_reduce_512 (line 349) | static void secp256k1_scalar_reduce_512(secp256k1_scalar *r, const uint3...
  function secp256k1_scalar_mul_512 (line 491) | static void secp256k1_scalar_mul_512(uint32_t *l, const secp256k1_scalar...
  function secp256k1_scalar_sqr_512 (line 579) | static void secp256k1_scalar_sqr_512(uint32_t *l, const secp256k1_scalar...
  function secp256k1_scalar_mul (line 647) | static void secp256k1_scalar_mul(secp256k1_scalar *r, const secp256k1_sc...
  function secp256k1_scalar_shr_int (line 653) | static int secp256k1_scalar_shr_int(secp256k1_scalar *r, int n) {
  function secp256k1_scalar_sqr (line 669) | static void secp256k1_scalar_sqr(secp256k1_scalar *r, const secp256k1_sc...
  function secp256k1_scalar_split_128 (line 676) | static void secp256k1_scalar_split_128(secp256k1_scalar *r1, secp256k1_s...
  function SECP256K1_INLINE (line 696) | SECP256K1_INLINE static int secp256k1_scalar_eq(const secp256k1_scalar *...
  function SECP256K1_INLINE (line 700) | SECP256K1_INLINE static void secp256k1_scalar_mul_shift_var(secp256k1_sc...

FILE: src/secp256k1/src/scalar_impl.h
  function secp256k1_scalar_get_num (line 28) | static void secp256k1_scalar_get_num(secp256k1_num *r, const secp256k1_s...
  function secp256k1_scalar_order_get_num (line 35) | static void secp256k1_scalar_order_get_num(secp256k1_num *r) {
  function SECP256K1_INLINE (line 220) | SECP256K1_INLINE static int secp256k1_scalar_is_even(const secp256k1_sca...
  function secp256k1_scalar_inverse_var (line 225) | static void secp256k1_scalar_inverse_var(secp256k1_scalar *r, const secp...
  function secp256k1_scalar_split_lambda (line 254) | static void secp256k1_scalar_split_lambda(secp256k1_scalar *r1, secp256k...
  function secp256k1_scalar_split_lambda (line 297) | static void secp256k1_scalar_split_lambda(secp256k1_scalar *r1, secp256k...

FILE: src/secp256k1/src/scalar_low.h
  type secp256k1_scalar (line 13) | typedef uint32_t secp256k1_scalar;

FILE: src/secp256k1/src/scalar_low_impl.h
  function SECP256K1_INLINE (line 14) | SECP256K1_INLINE static int secp256k1_scalar_is_even(const secp256k1_sca...
  function SECP256K1_INLINE (line 18) | SECP256K1_INLINE static void secp256k1_scalar_clear(secp256k1_scalar *r)...
  function SECP256K1_INLINE (line 19) | SECP256K1_INLINE static void secp256k1_scalar_set_int(secp256k1_scalar *...
  function secp256k1_scalar_get_bits (line 21) | int secp256k1_scalar_get_bits(const secp256k1_scalar *a, unsigned int of...
  function secp256k1_scalar_get_bits_var (line 28) | int secp256k1_scalar_get_bits_var(const secp256k1_scalar *a, unsigned in...
  function SECP256K1_INLINE (line 32) | SECP256K1_INLINE static int secp256k1_scalar_check_overflow(const secp25...
  function secp256k1_scalar_add (line 34) | static int secp256k1_scalar_add(secp256k1_scalar *r, const secp256k1_sca...
  function secp256k1_scalar_cadd_bit (line 39) | static void secp256k1_scalar_cadd_bit(secp256k1_scalar *r, unsigned int ...
  function secp256k1_scalar_set_b32 (line 47) | static void secp256k1_scalar_set_b32(secp256k1_scalar *r, const unsigned...
  function secp256k1_scalar_get_b32 (line 58) | static void secp256k1_scalar_get_b32(unsigned char *bin, const secp256k1...
  function SECP256K1_INLINE (line 63) | SECP256K1_INLINE static int secp256k1_scalar_is_zero(const secp256k1_sca...
  function secp256k1_scalar_negate (line 67) | static void secp256k1_scalar_negate(secp256k1_scalar *r, const secp256k1...
  function SECP256K1_INLINE (line 75) | SECP256K1_INLINE static int secp256k1_scalar_is_one(const secp256k1_scal...
  function secp256k1_scalar_is_high (line 79) | static int secp256k1_scalar_is_high(const secp256k1_scalar *a) {
  function secp256k1_scalar_cond_negate (line 83) | static int secp256k1_scalar_cond_negate(secp256k1_scalar *r, int flag) {
  function secp256k1_scalar_mul (line 88) | static void secp256k1_scalar_mul(secp256k1_scalar *r, const secp256k1_sc...
  function secp256k1_scalar_shr_int (line 92) | static int secp256k1_scalar_shr_int(secp256k1_scalar *r, int n) {
  function secp256k1_scalar_sqr (line 101) | static void secp256k1_scalar_sqr(secp256k1_scalar *r, const secp256k1_sc...
  function secp256k1_scalar_split_128 (line 105) | static void secp256k1_scalar_split_128(secp256k1_scalar *r1, secp256k1_s...
  function SECP256K1_INLINE (line 110) | SECP256K1_INLINE static int secp256k1_scalar_eq(const secp256k1_scalar *...

FILE: src/secp256k1/src/secp256k1.c
  function default_illegal_callback_fn (line 28) | static void default_illegal_callback_fn(const char* str, void* data) {
  function default_error_callback_fn (line 39) | static void default_error_callback_fn(const char* str, void* data) {
  type secp256k1_context_struct (line 51) | struct secp256k1_context_struct {
  function secp256k1_context (line 58) | secp256k1_context* secp256k1_context_create(unsigned int flags) {
  function secp256k1_context (line 83) | secp256k1_context* secp256k1_context_clone(const secp256k1_context* ctx) {
  function secp256k1_context_destroy (line 92) | void secp256k1_context_destroy(secp256k1_context* ctx) {
  function secp256k1_context_set_illegal_callback (line 101) | void secp256k1_context_set_illegal_callback(secp256k1_context* ctx, void...
  function secp256k1_context_set_error_callback (line 109) | void secp256k1_context_set_error_callback(secp256k1_context* ctx, void (...
  function secp256k1_pubkey_load (line 117) | static int secp256k1_pubkey_load(const secp256k1_context* ctx, secp256k1...
  function secp256k1_pubkey_save (line 136) | static void secp256k1_pubkey_save(secp256k1_pubkey* pubkey, secp256k1_ge...
  function secp256k1_ec_pubkey_parse (line 150) | int secp256k1_ec_pubkey_parse(const secp256k1_context* ctx, secp256k1_pu...
  function secp256k1_ec_pubkey_serialize (line 165) | int secp256k1_ec_pubkey_serialize(const secp256k1_context* ctx, unsigned...
  function secp256k1_ecdsa_signature_load (line 188) | static void secp256k1_ecdsa_signature_load(const secp256k1_context* ctx,...
  function secp256k1_ecdsa_signature_save (line 202) | static void secp256k1_ecdsa_signature_save(secp256k1_ecdsa_signature* si...
  function secp256k1_ecdsa_signature_parse_der (line 212) | int secp256k1_ecdsa_signature_parse_der(const secp256k1_context* ctx, se...
  function secp256k1_ecdsa_signature_parse_compact (line 228) | int secp256k1_ecdsa_signature_parse_compact(const secp256k1_context* ctx...
  function secp256k1_ecdsa_signature_serialize_der (line 249) | int secp256k1_ecdsa_signature_serialize_der(const secp256k1_context* ctx...
  function secp256k1_ecdsa_signature_serialize_compact (line 261) | int secp256k1_ecdsa_signature_serialize_compact(const secp256k1_context*...
  function secp256k1_ecdsa_signature_normalize (line 274) | int secp256k1_ecdsa_signature_normalize(const secp256k1_context* ctx, se...
  function secp256k1_ecdsa_verify (line 293) | int secp256k1_ecdsa_verify(const secp256k1_context* ctx, const secp256k1...
  function nonce_function_rfc6979 (line 310) | static int nonce_function_rfc6979(unsigned char *nonce32, const unsigned...
  function secp256k1_ecdsa_sign (line 345) | int secp256k1_ecdsa_sign(const secp256k1_context* ctx, secp256k1_ecdsa_s...
  function secp256k1_ec_seckey_verify (line 391) | int secp256k1_ec_seckey_verify(const secp256k1_context* ctx, const unsig...
  function secp256k1_ec_pubkey_create (line 404) | int secp256k1_ec_pubkey_create(const secp256k1_context* ctx, secp256k1_p...
  function secp256k1_ec_privkey_negate (line 427) | int secp256k1_ec_privkey_negate(const secp256k1_context* ctx, unsigned c...
  function secp256k1_ec_pubkey_negate (line 439) | int secp256k1_ec_pubkey_negate(const secp256k1_context* ctx, secp256k1_p...
  function secp256k1_ec_privkey_tweak_add (line 454) | int secp256k1_ec_privkey_tweak_add(const secp256k1_context* ctx, unsigne...
  function secp256k1_ec_pubkey_tweak_add (line 477) | int secp256k1_ec_pubkey_tweak_add(const secp256k1_context* ctx, secp256k...
  function secp256k1_ec_privkey_tweak_mul (line 501) | int secp256k1_ec_privkey_tweak_mul(const secp256k1_context* ctx, unsigne...
  function secp256k1_ec_pubkey_tweak_mul (line 523) | int secp256k1_ec_pubkey_tweak_mul(const secp256k1_context* ctx, secp256k...
  function secp256k1_context_randomize (line 547) | int secp256k1_context_randomize(secp256k1_context* ctx, const unsigned c...
  function secp256k1_ec_pubkey_combine (line 554) | int secp256k1_ec_pubkey_combine(const secp256k1_context* ctx, secp256k1_...

FILE: src/secp256k1/src/testrand_impl.h
  function SECP256K1_INLINE (line 22) | SECP256K1_INLINE static void secp256k1_rand_seed(const unsigned char *se...
  function SECP256K1_INLINE (line 26) | SECP256K1_INLINE static uint32_t secp256k1_rand32(void) {
  function secp256k1_rand_bits (line 34) | static uint32_t secp256k1_rand_bits(int bits) {
  function secp256k1_rand_int (line 47) | static uint32_t secp256k1_rand_int(uint32_t range) {
  function secp256k1_rand256 (line 86) | static void secp256k1_rand256(unsigned char *b32) {
  function secp256k1_rand_bytes_test (line 90) | static void secp256k1_rand_bytes_test(unsigned char *bytes, size_t len) {
  function secp256k1_rand256_test (line 106) | static void secp256k1_rand256_test(unsigned char *b32) {

FILE: src/secp256k1/src/tests.c
  function counting_illegal_callback_fn (line 45) | static void counting_illegal_callback_fn(const char* str, void* data) {
  function uncounting_illegal_callback_fn (line 53) | static void uncounting_illegal_callback_fn(const char* str, void* data) {
  function random_field_element_test (line 61) | void random_field_element_test(secp256k1_fe *fe) {
  function random_field_element_magnitude (line 71) | void random_field_element_magnitude(secp256k1_fe *fe) {
  function random_group_element_test (line 85) | void random_group_element_test(secp256k1_ge *ge) {
  function random_group_element_jacobian_test (line 96) | void random_group_element_jacobian_test(secp256k1_gej *gej, const secp25...
  function random_scalar_order_test (line 111) | void random_scalar_order_test(secp256k1_scalar *num) {
  function random_scalar_order (line 124) | void random_scalar_order(secp256k1_scalar *num) {
  function run_context_tests (line 137) | void run_context_tests(void) {
  function run_sha256_tests (line 253) | void run_sha256_tests(void) {
  function run_hmac_sha256_tests (line 289) | void run_hmac_sha256_tests(void) {
  function run_rfc6979_hmac_sha256_tests (line 333) | void run_rfc6979_hmac_sha256_tests(void) {
  function test_rand_bits (line 376) | void test_rand_bits(int rand32, int bits) {
  function test_rand_int (line 411) | void test_rand_int(uint32_t range, uint32_t subrange) {
  function run_rand_bits (line 427) | void run_rand_bits(void) {
  function run_rand_int (line 435) | void run_rand_int(void) {
  function random_num_negate (line 449) | void random_num_negate(secp256k1_num *num) {
  function random_num_order_test (line 455) | void random_num_order_test(secp256k1_num *num) {
  function random_num_order (line 461) | void random_num_order(secp256k1_num *num) {
  function test_num_negate (line 467) | void test_num_negate(void) {
  function test_num_add_sub (line 487) | void test_num_add_sub(void) {
  function test_num_mod (line 529) | void test_num_mod(void) {
  function test_num_jacobi (line 560) | void test_num_jacobi(void) {
  function run_num_smalltests (line 621) | void run_num_smalltests(void) {
  function scalar_test (line 634) | void scalar_test(void) {
  function run_scalar_tests (line 923) | void run_scalar_tests(void) {
  function random_fe (line 1553) | void random_fe(secp256k1_fe *x) {
  function random_fe_test (line 1563) | void random_fe_test(secp256k1_fe *x) {
  function random_fe_non_zero (line 1573) | void random_fe_non_zero(secp256k1_fe *nz) {
  function random_fe_non_square (line 1586) | void random_fe_non_square(secp256k1_fe *ns) {
  function check_fe_equal (line 1594) | int check_fe_equal(const secp256k1_fe *a, const secp256k1_fe *b) {
  function check_fe_inverse (line 1602) | int check_fe_inverse(const secp256k1_fe *a, const secp256k1_fe *ai) {
  function run_field_convert (line 1609) | void run_field_convert(void) {
  function fe_memcmp (line 1639) | int fe_memcmp(const secp256k1_fe *a, const secp256k1_fe *b) {
  function run_field_misc (line 1648) | void run_field_misc(void) {
  function run_field_inv (line 1720) | void run_field_inv(void) {
  function run_field_inv_var (line 1732) | void run_field_inv_var(void) {
  function run_field_inv_all_var (line 1744) | void run_field_inv_all_var(void) {
  function run_sqr (line 1766) | void run_sqr(void) {
  function test_sqrt (line 1782) | void test_sqrt(const secp256k1_fe *a, const secp256k1_fe *k) {
  function run_sqrt (line 1796) | void run_sqrt(void) {
  function ge_equals_ge (line 1832) | void ge_equals_ge(const secp256k1_ge *a, const secp256k1_ge *b) {
  function gej_xyz_equals_gej (line 1842) | int gej_xyz_equals_gej(const secp256k1_gej *a, const secp256k1_gej *b) {
  function ge_equals_gej (line 1863) | void ge_equals_gej(const secp256k1_ge *a, const secp256k1_gej *b) {
  function test_ge (line 1880) | void test_ge(void) {
  function test_add_neg_y_diff_x (line 2084) | void test_add_neg_y_diff_x(void) {
  function run_ge (line 2151) | void run_ge(void) {
  function test_ec_combine (line 2159) | void test_ec_combine(void) {
  function run_ec_combine (line 2184) | void run_ec_combine(void) {
  function test_group_decompress (line 2191) | void test_group_decompress(const secp256k1_fe* x) {
  function run_group_decompress (line 2255) | void run_group_decompress(void) {
  function run_ecmult_chain (line 2266) | void run_ecmult_chain(void) {
  function test_point_times_order (line 2330) | void test_point_times_order(const secp256k1_gej *point) {
  function run_point_times_order (line 2365) | void run_point_times_order(void) {
  function ecmult_const_random_mult (line 2387) | void ecmult_const_random_mult(void) {
  function ecmult_const_commutativity (line 2414) | void ecmult_const_commutativity(void) {
  function ecmult_const_mult_zero_one (line 2435) | void ecmult_const_mult_zero_one(void) {
  function ecmult_const_chain_multiply (line 2457) | void ecmult_const_chain_multiply(void) {
  function run_ecmult_const_tests (line 2483) | void run_ecmult_const_tests(void) {
  function test_wnaf (line 2490) | void test_wnaf(const secp256k1_scalar *number, int w) {
  function test_constant_wnaf_negate (line 2524) | void test_constant_wnaf_negate(const secp256k1_scalar *number) {
  function test_constant_wnaf (line 2539) | void test_constant_wnaf(const secp256k1_scalar *number, int w) {
  function run_wnaf (line 2578) | void run_wnaf(void) {
  function test_ecmult_constants (line 2602) | void test_ecmult_constants(void) {
  function run_ecmult_constants (line 2635) | void run_ecmult_constants(void) {
  function test_ecmult_gen_blind (line 2639) | void test_ecmult_gen_blind(void) {
  function test_ecmult_gen_blind_reset (line 2662) | void test_ecmult_gen_blind_reset(void) {
  function run_ecmult_gen_blind (line 2674) | void run_ecmult_gen_blind(void) {
  function test_scalar_split (line 2684) | void test_scalar_split(void) {
  function run_endomorphism_tests (line 2707) | void run_endomorphism_tests(void) {
  function ec_pubkey_parse_pointtest (line 2712) | void ec_pubkey_parse_pointtest(const unsigned char *input, int xvalid, i...
  function run_ec_pubkey_parse_test (line 2787) | void run_ec_pubkey_parse_test(void) {
  function run_eckey_edge_case_test (line 3114) | void run_eckey_edge_case_test(void) {
  function random_sign (line 3350) | void random_sign(secp256k1_scalar *sigr, secp256k1_scalar *sigs, const s...
  function test_ecdsa_sign_verify (line 3357) | void test_ecdsa_sign_verify(void) {
  function run_ecdsa_sign_verify (line 3380) | void run_ecdsa_sign_verify(void) {
  function precomputed_nonce_function (line 3388) | static int precomputed_nonce_function(unsigned char *nonce32, const unsi...
  function nonce_function_test_fail (line 3396) | static int nonce_function_test_fail(unsigned char *nonce32, const unsign...
  function nonce_function_test_retry (line 3404) | static int nonce_function_test_retry(unsigned char *nonce32, const unsig...
  function is_empty_signature (line 3434) | int is_empty_signature(const secp256k1_ecdsa_signature *sig) {
  function test_ecdsa_end_to_end (line 3439) | void test_ecdsa_end_to_end(void) {
  function test_random_pubkeys (line 3570) | void test_random_pubkeys(void) {
  function run_random_pubkeys (line 3630) | void run_random_pubkeys(void) {
  function run_ecdsa_end_to_end (line 3637) | void run_ecdsa_end_to_end(void) {
  function test_ecdsa_der_parse (line 3644) | int test_ecdsa_der_parse(const unsigned char *sig, size_t siglen, int ce...
  function assign_big_endian (line 3756) | static void assign_big_endian(unsigned char *ptr, size_t ptrlen, uint32_...
  function damage_array (line 3768) | static void damage_array(unsigned char *sig, size_t *len) {
  function random_ber_signature (line 3795) | static void random_ber_signature(unsigned char *sig, size_t *len, int* c...
  function run_ecdsa_der_parse (line 3941) | void run_ecdsa_der_parse(void) {
  function test_ecdsa_edge_cases (line 3973) | void test_ecdsa_edge_cases(void) {
  function run_ecdsa_edge_cases (line 4342) | void run_ecdsa_edge_cases(void) {
  function EC_KEY (line 4347) | EC_KEY *get_openssl_key(const unsigned char *key32) {
  function test_ecdsa_openssl (line 4359) | void test_ecdsa_openssl(void) {
  function run_ecdsa_openssl (line 4394) | void run_ecdsa_openssl(void) {
  function main (line 4410) | int main(int argc, char **argv) {

FILE: src/secp256k1/src/tests_exhaustive.c
  function ge_equals_ge (line 35) | void ge_equals_ge(const secp256k1_ge *a, const secp256k1_ge *b) {
  function ge_equals_gej (line 44) | void ge_equals_gej(const secp256k1_ge *a, const secp256k1_gej *b) {
  function random_fe (line 61) | void random_fe(secp256k1_fe *x) {
  function secp256k1_nonce_function_smallint (line 72) | int secp256k1_nonce_function_smallint(unsigned char *nonce32, const unsi...
  function test_exhaustive_endomorphism (line 93) | void test_exhaustive_endomorphism(const secp256k1_ge *group, int order) {
  function test_exhaustive_addition (line 103) | void test_exhaustive_addition(const secp256k1_ge *group, const secp256k1...
  function test_exhaustive_ecmult (line 163) | void test_exhaustive_ecmult(const secp256k1_context *ctx, const secp256k...
  function r_from_k (line 185) | void r_from_k(secp256k1_scalar *r, const secp256k1_ge *group, int k) {
  function test_exhaustive_verify (line 195) | void test_exhaustive_verify(const secp256k1_context *ctx, const secp256k...
  function test_exhaustive_sign (line 245) | void test_exhaustive_sign(const secp256k1_context *ctx, const secp256k1_...
  function test_exhaustive_recovery_sign (line 291) | void test_exhaustive_recovery_sign(const secp256k1_context *ctx, const s...
  function test_exhaustive_recovery_verify (line 354) | void test_exhaustive_recovery_verify(const secp256k1_context *ctx, const...
  function main (line 414) | int main(void) {

FILE: src/secp256k1/src/util.h
  type secp256k1_callback (line 18) | typedef struct {
  function SECP256K1_INLINE (line 23) | static SECP256K1_INLINE void secp256k1_callback_call(const secp256k1_cal...
  function SECP256K1_INLINE (line 71) | static SECP256K1_INLINE void *checked_malloc(const secp256k1_callback* c...

FILE: src/serialize.h
  type deserialize_type (line 39) | struct deserialize_type {}
  function deserialize_type (line 40) | constexpr deserialize_type deserialize {}
  function T (line 57) | T* NCONST_PTR(const T* val)
  function ser_double_to_uint64 (line 109) | inline uint64_t ser_double_to_uint64(double x)
  function ser_float_to_uint32 (line 115) | inline uint32_t ser_float_to_uint32(float x)
  function ser_uint64_to_double (line 121) | inline double ser_uint64_to_double(uint64_t y)
  function ser_uint32_to_float (line 127) | inline float ser_uint32_to_float(uint32_t y)
  function GetSizeOfCompactSize (line 209) | inline unsigned int GetSizeOfCompactSize(uint64_t nSize)
  function GetSizeOfVarInt (line 301) | unsigned int GetSizeOfVarInt(I n)
  function class (line 362) | class CFlatData
  function class (line 418) | class CCompactSize
  function WriteCompactSize (line 949) | inline void WriteCompactSize(CSizeComputer &s, uint64_t nSize)

FILE: src/streams.h
  function write (line 52) | void write(const char* pch, size_t nSize)
  function read (line 57) | void read(char* pch, size_t nSize)
  function class (line 76) | class CVectorWriter
  function write (line 101) | void write(const char* pch, size_t nSize)
  function seek (line 128) | void seek(size_t nSize)
  function class (line 146) | class CDataStream
  function Init (line 204) | void Init(int nTypeIn, int nVersionIn)
  function iterator (line 234) | iterator begin()                                 { return vch.begin() + ...
  function iterator (line 236) | iterator end()                                   { return vch.end(); }
  function reserve (line 240) | void reserve(size_type n)                        { vch.reserve(n + nRead...
  function const_reference (line 241) | const_reference operator[](size_type pos) const  { return vch[pos + nRea...
  function reference (line 242) | reference operator[](size_type pos)              { return vch[pos + nRea...
  function clear (line 243) | void clear()                                     { vch.clear(); nReadPos...
  function insert (line 245) | void insert(iterator it, size_type n, const char x) { vch.insert(it, n, ...
  function value_type (line 246) | value_type* data()                               { return vch.data() + n...
  function value_type (line 247) | const value_type* data() const                   { return vch.data() + n...
  function insert (line 249) | void insert(iterator it, std::vector<char>::const_iterator first, std::v...
  function insert (line 263) | void insert(iterator it, const char* first, const char* last)
  function iterator (line 277) | iterator erase(iterator it)
  function iterator (line 294) | iterator erase(iterator first, iterator last)
  function Compact (line 314) | inline void Compact()
  function Rewind (line 320) | bool Rewind(size_type n)
  function CDataStream (line 334) | CDataStream* rdbuf()         { return this; }
  function SetType (line 337) | void SetType(int n)          { nType = n; }
  function SetVersion (line 339) | void SetVersion(int n)       { nVersion = n; }
  function read (line 342) | void read(char* pch, size_t nSize)
  function ignore (line 361) | void ignore(int nSize)
  function write (line 379) | void write(const char* pch, size_t nSize)
  function GetAndClear (line 409) | void GetAndClear(CSerializeData &d) {
  function Xor (line 419) | void Xor(const std::vector<unsigned char>& key)
  function class (line 453) | class CAutoFile
  function class (line 562) | class CBufferedFile
  function FindByte (line 696) | void FindByte(char ch) {

FILE: src/support/allocators/secure.h
  type typename (line 22) | typedef typename base::size_type size_type;
  type typename (line 23) | typedef typename base::difference_type difference_type;
  type typename (line 24) | typedef typename base::pointer pointer;
  type typename (line 25) | typedef typename base::const_pointer const_pointer;
  type typename (line 26) | typedef typename base::reference reference;
  type typename (line 27) | typedef typename base::const_reference const_reference;
  type typename (line 28) | typedef typename base::value_type value_type;
  function base (line 30) | secure_allocator(const secure_allocator& a) noexcept : base(a) {}
  type secure_allocator (line 38) | typedef secure_allocator<_Other> other;
  function deallocate (line 46) | void deallocate(T* p, std::size_t n)
  type std (line 56) | typedef std::basic_string<char, std::char_traits<char>, secure_allocator...

FILE: src/support/allocators/zeroafterfree.h
  type typename (line 18) | typedef typename base::size_type size_type;
  type typename (line 19) | typedef typename base::difference_type difference_type;
  type typename (line 20) | typedef typename base::pointer pointer;
  type typename (line 21) | typedef typename base::const_pointer const_pointer;
  type typename (line 22) | typedef typename base::reference reference;
  type typename (line 23) | typedef typename base::const_reference const_reference;
  type typename (line 24) | typedef typename base::value_type value_type;
  function base (line 26) | zero_after_free_allocator(const zero_after_free_allocator& a) noexcept :...
  type zero_after_free_allocator (line 34) | typedef zero_after_free_allocator<_Other> other;
  function deallocate (line 37) | void deallocate(T* p, std::size_t n)
  type std (line 46) | typedef std::vector<char, zero_after_free_allocator<char> > CSerializeData;

FILE: src/support/cleanse.cpp
  function memory_cleanse (line 31) | void memory_cleanse(void *ptr, size_t len)

FILE: src/support/events.h
  type std (line 22) | typedef std::unique_ptr<struct type, type##_deleter> raii_##type
  function raii_event_base (line 30) | inline raii_event_base obtain_event_base() {
  function raii_event (line 37) | inline raii_event obtain_event(struct event_base* base, evutil_socket_t ...
  function raii_evhttp (line 41) | inline raii_evhttp obtain_evhttp(struct event_base* base) {
  function raii_evhttp_request (line 45) | inline raii_evhttp_request obtain_evhttp_request(void(*cb)(struct evhttp...
  function raii_evhttp_connection (line 49) | inline raii_evhttp_connection obtain_evhttp_connection_base(struct event...

FILE: src/support/lockedpool.cpp
  function align_up (line 39) | static inline size_t align_up(size_t x, size_t align)
  function extend (line 81) | bool extend(Iterator it, const Pair& other) {
  function printchunk (line 125) | void printchunk(char* base, size_t sz, bool used) {
  class Win32LockedPageAllocator (line 148) | class Win32LockedPageAllocator: public LockedPageAllocator
  class PosixLockedPageAllocator (line 200) | class PosixLockedPageAllocator: public LockedPageAllocator
  type rlimit (line 247) | struct rlimit

FILE: src/support/lockedpool.h
  function class (line 18) | class LockedPageAllocator
  function class (line 47) | class Arena
  function class (line 117) | class LockedPool
  function class (line 209) | class LockedPoolManager : public LockedPool

FILE: src/sync.cpp
  function PrintLockContention (line 18) | void PrintLockContention(const char* pszName, const char* pszFile, int n...
  type CLockLocation (line 37) | struct CLockLocation {
    method CLockLocation (line 38) | CLockLocation(const char* pszName, const char* pszFile, int nLine, boo...
    method ToString (line 46) | std::string ToString() const
  type LockData (line 62) | struct LockData {
    method LockData (line 68) | LockData() : available(true) {}
  function potential_deadlock_detected (line 78) | static void potential_deadlock_detected(const std::pair<void*, void*>& m...
  function push_lock (line 104) | static void push_lock(void* c, const CLockLocation& locklocation)
  function pop_lock (line 126) | static void pop_lock()
  function EnterCritical (line 131) | void EnterCritical(const char* pszName, const char* pszFile, int nLine, ...
  function LeaveCritical (line 136) | void LeaveCritical()
  function LocksHeld (line 141) | std::string LocksHeld()
  function AssertLockHeldInternal (line 149) | void AssertLockHeldInternal(const char* pszName, const char* pszFile, in...
  function AssertLockNotHeldInternal (line 158) | void AssertLockNotHeldInternal(const char* pszName, const char* pszFile,...
  function DeleteLock (line 168) | void DeleteLock(void* cs)

FILE: src/sync.h
  function LOCKABLE (line 54) | LOCKABLE AnnotatedMixin : public PARENT
  function LeaveCritical (line 82) | void static inline LeaveCritical() {}
  function AssertLockHeldInternal (line 83) | void static inline AssertLockHeldInternal(const char* pszName, const cha...
  function AssertLockNotHeldInternal (line 84) | void static inline AssertLockNotHeldInternal(const char* pszName, const ...
  function DeleteLock (line 85) | void static inline DeleteLock(void* cs) {}
  function class (line 94) | class CCriticalSection : public AnnotatedMixin<std::recursive_mutex>
  type AnnotatedMixin (line 103) | typedef AnnotatedMixin<std::mutex> CWaitableCriticalSection;
  type std (line 106) | typedef std::condition_variable CConditionVariable;
  type std (line 109) | typedef std::unique_lock<std::mutex> WaitableLock;
  function Enter (line 121) | void Enter(const char* pszName, const char* pszFile, int nLine)

FILE: src/test/DoS_tests.cpp
  type COrphanTx (line 27) | struct COrphanTx {
  function CService (line 34) | CService ip(uint32_t i)
  function BOOST_AUTO_TEST_CASE (line 55) | BOOST_AUTO_TEST_CASE(outbound_slow_chain_eviction)
  function AddRandomOutboundPeer (line 95) | void AddRandomOutboundPeer(std::vector<CNode *> &vNodes, PeerLogicValida...
  function BOOST_AUTO_TEST_CASE (line 109) | BOOST_AUTO_TEST_CASE(stale_tip_peer_management)
  function BOOST_AUTO_TEST_CASE (line 178) | BOOST_AUTO_TEST_CASE(DoS_banning)
  function BOOST_AUTO_TEST_CASE (line 224) | BOOST_AUTO_TEST_CASE(DoS_banscore)
  function BOOST_AUTO_TEST_CASE (line 261) | BOOST_AUTO_TEST_CASE(DoS_bantime)
  function CTransactionRef (line 294) | CTransactionRef RandomOrphan()
  function BOOST_AUTO_TEST_CASE (line 304) | BOOST_AUTO_TEST_CASE(DoS_mapOrphans)

FILE: src/test/addrman_tests.cpp
  class CAddrManTest (line 13) | class CAddrManTest : public CAddrMan
    method CAddrManTest (line 18) | explicit CAddrManTest(bool makeDeterministic = true)
    method MakeDeterministic (line 29) | void MakeDeterministic()
    method RandomInt (line 35) | int RandomInt(int nMax) override
    method CAddrInfo (line 41) | CAddrInfo* Find(const CNetAddr& addr, int* pnId = nullptr)
    method CAddrInfo (line 46) | CAddrInfo* Create(const CAddress& addr, const CNetAddr& addrSource, in...
    method Delete (line 51) | void Delete(int nId)
  function CNetAddr (line 57) | static CNetAddr ResolveIP(const char* ip)
  function CNetAddr (line 64) | static CNetAddr ResolveIP(std::string ip)
  function CService (line 69) | static CService ResolveService(const char* ip, int port = 0)
  function CService (line 76) | static CService ResolveService(std::string ip, int port = 0)
  function BOOST_AUTO_TEST_CASE (line 83) | BOOST_AUTO_TEST_CASE(addrman_simple)
  function BOOST_AUTO_TEST_CASE (line 132) | BOOST_AUTO_TEST_CASE(addrman_ports)
  function BOOST_AUTO_TEST_CASE (line 161) | BOOST_AUTO_TEST_CASE(addrman_select)
  function BOOST_AUTO_TEST_CASE (line 220) | BOOST_AUTO_TEST_CASE(addrman_new_collisions)
  function BOOST_AUTO_TEST_CASE (line 246) | BOOST_AUTO_TEST_CASE(addrman_tried_collisions)
  function BOOST_AUTO_TEST_CASE (line 273) | BOOST_AUTO_TEST_CASE(addrman_find)
  function BOOST_AUTO_TEST_CASE (line 306) | BOOST_AUTO_TEST_CASE(addrman_create)
  function BOOST_AUTO_TEST_CASE (line 326) | BOOST_AUTO_TEST_CASE(addrman_delete)
  function BOOST_AUTO_TEST_CASE (line 346) | BOOST_AUTO_TEST_CASE(addrman_getaddr)
  function BOOST_AUTO_TEST_CASE (line 407) | BOOST_AUTO_TEST_CASE(caddrinfo_get_tried_bucket)
  function BOOST_AUTO_TEST_CASE (line 489) | BOOST_AUTO_TEST_CASE(caddrinfo_get_new_bucket)

FILE: src/test/allocator_tests.cpp
  function BOOST_AUTO_TEST_CASE (line 16) | BOOST_AUTO_TEST_CASE(arena_tests)
  class TestLockedPageAllocator (line 132) | class TestLockedPageAllocator: public LockedPageAllocator
    method TestLockedPageAllocator (line 135) | TestLockedPageAllocator(int count_in, int lockedcount_in): count(count...
    method FreeLocked (line 151) | void FreeLocked(void* addr, size_t len) override
    method GetLimit (line 154) | size_t GetLimit() override
  function BOOST_AUTO_TEST_CASE (line 163) | BOOST_AUTO_TEST_CASE(lockedpool_tests_mock)
  function BOOST_AUTO_TEST_CASE (line 212) | BOOST_AUTO_TEST_CASE(lockedpool_tests_live)

FILE: src/test/amount_tests.cpp
  function BOOST_AUTO_TEST_CASE (line 13) | BOOST_AUTO_TEST_CASE(MoneyRangeTest)
  function BOOST_AUTO_TEST_CASE (line 20) | BOOST_AUTO_TEST_CASE(GetFeeTest)
  function BOOST_AUTO_TEST_CASE (line 84) | BOOST_AUTO_TEST_CASE(BinaryOperatorTest)
  function BOOST_AUTO_TEST_CASE (line 101) | BOOST_AUTO_TEST_CASE(ToStringTest)

FILE: src/test/arith_uint256_tests.cpp
  function arith_uint256 (line 20) | inline arith_uint256 arith_uint256V(const std::vector<unsigned char>& vch)
  function ArrayToString (line 56) | std::string ArrayToString(const unsigned char A[], unsigned int width)
  function BOOST_AUTO_TEST_CASE (line 67) | BOOST_AUTO_TEST_CASE( basics ) // constructors, equality, inequality
  function shiftArrayRight (line 125) | void shiftArrayRight(unsigned char* to, const unsigned char* from, unsig...
  function shiftArrayLeft (line 139) | void shiftArrayLeft(unsigned char* to, const unsigned char* from, unsign...
  function BOOST_AUTO_TEST_CASE (line 156) | BOOST_AUTO_TEST_CASE( shifts ) { // "<<"  ">>"  "<<="  ">>="
  function BOOST_AUTO_TEST_CASE (line 199) | BOOST_AUTO_TEST_CASE( unaryOperators ) // !    ~    -
  function BOOST_AUTO_TEST_CASE (line 230) | BOOST_AUTO_TEST_CASE( bitwiseOperators )
  function BOOST_AUTO_TEST_CASE (line 332) | BOOST_AUTO_TEST_CASE( multiply )
  function BOOST_AUTO_TEST_CASE (line 353) | BOOST_AUTO_TEST_CASE( divide )
  function almostEqual (line 372) | bool almostEqual(double d1, double d2)
  function BOOST_AUTO_TEST_CASE (line 377) | BOOST_AUTO_TEST_CASE( methods ) // GetHex SetHex size() GetLow64 GetSeri...
  function BOOST_AUTO_TEST_CASE (line 412) | BOOST_AUTO_TEST_CASE(bignum_SetCompact)

FILE: src/test/base32_tests.cpp
  function BOOST_AUTO_TEST_CASE (line 12) | BOOST_AUTO_TEST_CASE(base32_testvectors)

FILE: src/test/base58_tests.cpp
  function BOOST_AUTO_TEST_CASE (line 28) | BOOST_AUTO_TEST_CASE(base58_EncodeBase58)
  function BOOST_AUTO_TEST_CASE (line 48) | BOOST_AUTO_TEST_CASE(base58_DecodeBase58)
  function BOOST_AUTO_TEST_CASE (line 77) | BOOST_AUTO_TEST_CASE(base58_keys_valid_parse)
  function BOOST_AUTO_TEST_CASE (line 139) | BOOST_AUTO_TEST_CASE(base58_keys_valid_gen)
  function BOOST_AUTO_TEST_CASE (line 179) | BOOST_AUTO_TEST_CASE(base58_keys_invalid)

FILE: src/test/base64_tests.cpp
  function BOOST_AUTO_TEST_CASE (line 12) | BOOST_AUTO_TEST_CASE(base64_testvectors)

FILE: src/test/bech32_tests.cpp
  function CaseInsensitiveEqual (line 12) | bool CaseInsensitiveEqual(const std::string &s1, const std::string &s2)
  function BOOST_AUTO_TEST_CASE (line 25) | BOOST_AUTO_TEST_CASE(bip173_testvectors_valid)
  function BOOST_AUTO_TEST_CASE (line 45) | BOOST_AUTO_TEST_CASE(bip173_testvectors_invalid)

FILE: src/test/bip32_tests.cpp
  type TestDerivation (line 17) | struct TestDerivation {
  type TestVector (line 23) | struct TestVector {
    method TestVector (line 27) | explicit TestVector(std::string strHexMasterIn) : strHexMaster(strHexM...
    method TestVector (line 29) | TestVector& operator()(std::string pub, std::string prv, unsigned int ...
  function RunTest (line 90) | void RunTest(const TestVector &test) {
  function BOOST_AUTO_TEST_CASE (line 150) | BOOST_AUTO_TEST_CASE(bip32_test1) {
  function BOOST_AUTO_TEST_CASE (line 154) | BOOST_AUTO_TEST_CASE(bip32_test2) {
  function BOOST_AUTO_TEST_CASE (line 158) | BOOST_AUTO_TEST_CASE(bip32_test3) {

FILE: src/test/blockchain_tests.cpp
  function DoubleEquals (line 11) | bool DoubleEquals(double a, double b, double epsilon)
  function CBlockIndex (line 16) | CBlockIndex* CreateBlockIndexWithNbits(uint32_t nbits)
  function CChain (line 25) | CChain CreateChainWithNbits(uint32_t nbits)
  function RejectDifficultyMismatch (line 33) | void RejectDifficultyMismatch(double difficulty, double expected_difficu...
  function TestDifficulty (line 43) | void TestDifficulty(uint32_t nbits, double expected_difficulty)
  function BOOST_AUTO_TEST_CASE (line 59) | BOOST_AUTO_TEST_CASE(get_difficulty_for_very_low_target)
  function BOOST_AUTO_TEST_CASE (line 64) | BOOST_AUTO_TEST_CASE(get_difficulty_for_low_target)
  function BOOST_AUTO_TEST_CASE (line 69) | BOOST_AUTO_TEST_CASE(get_difficulty_for_mid_target)
  function BOOST_AUTO_TEST_CASE (line 74) | BOOST_AUTO_TEST_CASE(get_difficulty_for_high_target)
  function BOOST_AUTO_TEST_CASE (line 79) | BOOST_AUTO_TEST_CASE(get_difficulty_for_very_high_target)
  function BOOST_AUTO_TEST_CASE (line 85) | BOOST_AUTO_TEST_CASE(get_difficulty_for_null_tip)
  function BOOST_AUTO_TEST_CASE (line 95) | BOOST_AUTO_TEST_CASE(get_difficulty_for_null_block_index)
  function BOOST_AUTO_TEST_CASE (line 111) | BOOST_AUTO_TEST_CASE(get_difficulty_for_block_index_overrides_tip)

FILE: src/test/blockencodings_tests.cpp
  type RegtestingSetup (line 16) | struct RegtestingSetup : public TestingSetup {
    method RegtestingSetup (line 17) | RegtestingSetup() : TestingSetup(CBaseChainParams::REGTEST) {}
  function CBlock (line 22) | static CBlock BuildBlockTestCase() {
  function BOOST_AUTO_TEST_CASE (line 58) | BOOST_AUTO_TEST_CASE(SimpleRoundTripTest)
  class TestHeaderAndShortIDs (line 114) | class TestHeaderAndShortIDs {
    method TestHeaderAndShortIDs (line 122) | explicit TestHeaderAndShortIDs(const CBlockHeaderAndShortTxIDs& orig) {
    method TestHeaderAndShortIDs (line 127) | explicit TestHeaderAndShortIDs(const CBlock& block) :
    method GetShortID (line 130) | uint64_t GetShortID(const uint256& txhash) const {
    method SerializationOp (line 141) | inline void SerializationOp(Stream& s, Operation ser_action) {
  function BOOST_AUTO_TEST_CASE (line 158) | BOOST_AUTO_TEST_CASE(NonCoinbasePreforwardRTTest)
  function BOOST_AUTO_TEST_CASE (line 225) | BOOST_AUTO_TEST_CASE(SufficientPreforwardRTTest)
  function BOOST_AUTO_TEST_CASE (line 276) | BOOST_AUTO_TEST_CASE(EmptyBlockRoundTripTest)
  function BOOST_AUTO_TEST_CASE (line 320) | BOOST_AUTO_TEST_CASE(TransactionsRequestSerializationTest) {

FILE: src/test/bloom_tests.cpp
  function BOOST_AUTO_TEST_CASE (line 26) | BOOST_AUTO_TEST_CASE(bloom_create_insert_serialize)
  function BOOST_AUTO_TEST_CASE (line 57) | BOOST_AUTO_TEST_CASE(bloom_create_insert_serialize_with_tweak)
  function BOOST_AUTO_TEST_CASE (line 85) | BOOST_AUTO_TEST_CASE(bloom_create_insert_key)
  function BOOST_AUTO_TEST_CASE (line 112) | BOOST_AUTO_TEST_CASE(bloom_match)
  function BOOST_AUTO_TEST_CASE (line 181) | BOOST_AUTO_TEST_CASE(merkle_block_1)
  function BOOST_AUTO_TEST_CASE (line 222) | BOOST_AUTO_TEST_CASE(merkle_block_2)
  function BOOST_AUTO_TEST_CASE (line 277) | BOOST_AUTO_TEST_CASE(merkle_block_2_with_update_none)
  function BOOST_AUTO_TEST_CASE (line 329) | BOOST_AUTO_TEST_CASE(merkle_block_3_and_serialize)
  function BOOST_AUTO_TEST_CASE (line 368) | BOOST_AUTO_TEST_CASE(merkle_block_4)
  function BOOST_AUTO_TEST_CASE (line 414) | BOOST_AUTO_TEST_CASE(merkle_block_4_test_p2pubkey_only)
  function BOOST_AUTO_TEST_CASE (line 437) | BOOST_AUTO_TEST_CASE(merkle_block_4_test_update_none)
  function RandomData (line 459) | static std::vector<unsigned char> RandomData()
  function BOOST_AUTO_TEST_CASE (line 465) | BOOST_AUTO_TEST_CASE(rolling_bloom)

FILE: src/test/bswap_tests.cpp
  function BOOST_AUTO_TEST_CASE (line 12) | BOOST_AUTO_TEST_CASE(bswap_tests)

FILE: src/test/checkqueue_tests.cpp
  type FakeCheck (line 29) | struct FakeCheck {
  type FakeCheckCheckCompletion (line 37) | struct FakeCheckCheckCompletion {
  type FailingCheck (line 47) | struct FailingCheck {
    method FailingCheck (line 49) | FailingCheck(bool _fails) : fails(_fails){}
    method FailingCheck (line 50) | FailingCheck() : fails(true){}
    method swap (line 55) | void swap(FailingCheck& x)
  type UniqueCheck (line 61) | struct UniqueCheck {
    method UniqueCheck (line 65) | UniqueCheck(size_t check_id_in) : check_id(check_id_in){}
    method UniqueCheck (line 66) | UniqueCheck() : check_id(0){}
    method swap (line 73) | void swap(UniqueCheck& x) { std::swap(x.check_id, check_id); }
  type MemoryCheck (line 77) | struct MemoryCheck {
    method MemoryCheck (line 84) | MemoryCheck(){}
    method MemoryCheck (line 85) | MemoryCheck(const MemoryCheck& x)
    method MemoryCheck (line 93) | MemoryCheck(bool b_) : b(b_)
    method swap (line 101) | void swap(MemoryCheck& x) { std::swap(b, x.b); }
  type FrozenCleanupCheck (line 104) | struct FrozenCleanupCheck {
    method FrozenCleanupCheck (line 115) | FrozenCleanupCheck() {}
    method swap (line 125) | void swap(FrozenCleanupCheck& x){std::swap(should_freeze, x.should_fre...
  function Correct_Queue_range (line 149) | void Correct_Queue_range(std::vector<size_t> range)
  function BOOST_AUTO_TEST_CASE (line 179) | BOOST_AUTO_TEST_CASE(test_CheckQueue_Correct_Zero)
  function BOOST_AUTO_TEST_CASE (line 187) | BOOST_AUTO_TEST_CASE(test_CheckQueue_Correct_One)
  function BOOST_AUTO_TEST_CASE (line 195) | BOOST_AUTO_TEST_CASE(test_CheckQueue_Correct_Max)
  function BOOST_AUTO_TEST_CASE (line 203) | BOOST_AUTO_TEST_CASE(test_CheckQueue_Correct_Random)
  function BOOST_AUTO_TEST_CASE (line 214) | BOOST_AUTO_TEST_CASE(test_CheckQueue_Catches_Failure)
  function BOOST_AUTO_TEST_CASE (line 247) | BOOST_AUTO_TEST_CASE(test_CheckQueue_Recovers_From_Failure)
  function BOOST_AUTO_TEST_CASE (line 275) | BOOST_AUTO_TEST_CASE(test_CheckQueue_UniqueCheck)
  function BOOST_AUTO_TEST_CASE (line 311) | BOOST_AUTO_TEST_CASE(test_CheckQueue_Memory)
  function BOOST_AUTO_TEST_CASE (line 342) | BOOST_AUTO_TEST_CASE(test_CheckQueue_FrozenCleanup)
  function BOOST_AUTO_TEST_CASE (line 385) | BOOST_AUTO_TEST_CASE(test_CheckQueueControl_Locks)

FILE: src/test/coins_tests.cpp
  class CCoinsViewTest (line 33) | class CCoinsViewTest : public CCoinsView
    method GetCoin (line 39) | bool GetCoin(const COutPoint& outpoint, Coin& coin) const override
    method uint256 (line 53) | uint256 GetBestBlock() const override { return hashBestBlock_; }
    method BatchWrite (line 55) | bool BatchWrite(CCoinsMap& mapCoins, const uint256& hashBlock) override
  class CCoinsViewCacheTest (line 74) | class CCoinsViewCacheTest : public CCoinsViewCache
    method CCoinsViewCacheTest (line 77) | explicit CCoinsViewCacheTest(CCoinsView* _base) : CCoinsViewCache(_bas...
    method SelfTest (line 79) | void SelfTest() const
    method CCoinsMap (line 92) | CCoinsMap& map() const { return cacheCoins; }
  function BOOST_AUTO_TEST_CASE (line 111) | BOOST_AUTO_TEST_CASE(coins_cache_simulation_test)
  function FindRandomFrom (line 262) | UtxoData::iterator FindRandomFrom(const std::set<COutPoint> &utxoSet) {
  function BOOST_AUTO_TEST_CASE (line 279) | BOOST_AUTO_TEST_CASE(updatecoins_simulation_test)
  function BOOST_AUTO_TEST_CASE (line 476) | BOOST_AUTO_TEST_CASE(ccoins_serialization)
  function SetCoinsValue (line 543) | void SetCoinsValue(CAmount value, Coin& coin)
  function InsertCoinsMapEntry (line 555) | size_t InsertCoinsMapEntry(CCoinsMap& map, CAmount value, char flags)
  function GetCoinsMapEntry (line 570) | void GetCoinsMapEntry(const CCoinsMap& map, CAmount& value, char& flags)
  function WriteCoinsViewEntry (line 587) | void WriteCoinsViewEntry(CCoinsView& view, CAmount value, char flags)
  class SingleEntryCacheTest (line 594) | class SingleEntryCacheTest
    method SingleEntryCacheTest (line 597) | SingleEntryCacheTest(CAmount base_value, CAmount cache_value, char cac...
  function CheckAccessCoin (line 608) | void CheckAccessCoin(CAmount base_value, CAmount cache_value, CAmount ex...
  function BOOST_AUTO_TEST_CASE (line 621) | BOOST_AUTO_TEST_CASE(ccoins_access)
  function CheckSpendCoins (line 659) | void CheckSpendCoins(CAmount base_value, CAmount cache_value, CAmount ex...
  function BOOST_AUTO_TEST_CASE (line 672) | BOOST_AUTO_TEST_CASE(ccoins_spend)
  function CheckAddCoinBase (line 710) | void CheckAddCoinBase(CAmount base_value, CAmount cache_value, CAmount m...
  function CheckAddCoin (line 737) | void CheckAddCoin(Args&&... args)
  function BOOST_AUTO_TEST_CASE (line 743) | BOOST_AUTO_TEST_CASE(ccoins_add)
  function CheckWriteCoins (line 773) | void CheckWriteCoins(CAmount parent_value, CAmount child_value, CAmount ...
  function BOOST_AUTO_TEST_CASE (line 792) | BOOST_AUTO_TEST_CASE(ccoins_write)

FILE: src/test/compress_tests.cpp
  function TestEncode (line 27) | bool static TestEncode(uint64_t in) {
  function TestDecode (line 31) | bool static TestDecode(uint64_t in) {
  function TestPair (line 35) | bool static TestPair(uint64_t dec, uint64_t enc) {
  function BOOST_AUTO_TEST_CASE (line 40) | BOOST_AUTO_TEST_CASE(compress_amounts)

FILE: src/test/crypto_tests.cpp
  function TestVector (line 26) | void TestVector(const Hasher &h, const In &in, const Out &out) {
  function TestSHA1 (line 54) | void TestSHA1(const std::string &in, const std::string &hexout) { TestVe...
  function TestSHA256 (line 55) | void TestSHA256(const std::string &in, const std::string &hexout) { Test...
  function TestSHA512 (line 56) | void TestSHA512(const std::string &in, const std::string &hexout) { Test...
  function TestRIPEMD160 (line 57) | void TestRIPEMD160(const std::string &in, const std::string &hexout) { T...
  function TestHMACSHA256 (line 59) | void TestHMACSHA256(const std::string &hexkey, const std::string &hexin,...
  function TestHMACSHA512 (line 64) | void TestHMACSHA512(const std::string &hexkey, const std::string &hexin,...
  function TestAES128 (line 69) | void TestAES128(const std::string &hexkey, const std::string &hexin, con...
  function TestAES256 (line 89) | void TestAES256(const std::string &hexkey, const std::string &hexin, con...
  function TestAES128CBC (line 108) | void TestAES128CBC(const std::string &hexkey, const std::string &hexiv, ...
  function TestAES256CBC (line 149) | void TestAES256CBC(const std::string &hexkey, const std::string &hexiv, ...
  function TestChaCha20 (line 190) | void TestChaCha20(const std::string &hexkey, uint64_t nonce, uint64_t se...
  function LongTestString (line 203) | std::string LongTestString(void) {
  function BOOST_AUTO_TEST_CASE (line 217) | BOOST_AUTO_TEST_CASE(ripemd160_testvectors) {
  function BOOST_AUTO_TEST_CASE (line 233) | BOOST_AUTO_TEST_CASE(sha1_testvectors) {
  function BOOST_AUTO_TEST_CASE (line 249) | BOOST_AUTO_TEST_CASE(sha256_testvectors) {
  function BOOST_AUTO_TEST_CASE (line 271) | BOOST_AUTO_TEST_CASE(sha512_testvectors) {
  function BOOST_AUTO_TEST_CASE (line 308) | BOOST_AUTO_TEST_CASE(hmac_sha256_testvectors) {
  function BOOST_AUTO_TEST_CASE (line 361) | BOOST_AUTO_TEST_CASE(hmac_sha512_testvectors) {
  function BOOST_AUTO_TEST_CASE (line 429) | BOOST_AUTO_TEST_CASE(aes_testvectors) {
  function BOOST_AUTO_TEST_CASE (line 445) | BOOST_AUTO_TEST_CASE(aes_cbc_testvectors) {
  function BOOST_AUTO_TEST_CASE (line 497) | BOOST_AUTO_TEST_CASE(chacha20_testvector)
  function BOOST_AUTO_TEST_CASE (line 527) | BOOST_AUTO_TEST_CASE(countbits_tests)

FILE: src/test/cuckoocache_tests.cpp
  function insecure_GetRandHash (line 31) | void insecure_GetRandHash(uint256& t)
  function BOOST_AUTO_TEST_CASE (line 44) | BOOST_AUTO_TEST_CASE(test_cuckoocache_no_fakes)
  function test_cache (line 65) | double test_cache(size_t megabytes, double load)
  function normalize_hit_rate (line 112) | double normalize_hit_rate(double hits, double load)
  function BOOST_AUTO_TEST_CASE (line 118) | BOOST_AUTO_TEST_CASE(cuckoocache_hit_rate_ok)
  function test_cache_erase (line 135) | void test_cache_erase(size_t megabytes)
  function BOOST_AUTO_TEST_CASE (line 191) | BOOST_AUTO_TEST_CASE(cuckoocache_erase_ok)
  function test_cache_erase_parallel (line 198) | void test_cache_erase_parallel(size_t megabytes)
  function BOOST_AUTO_TEST_CASE (line 278) | BOOST_AUTO_TEST_CASE(cuckoocache_erase_parallel_ok)
  function test_cache_generations (line 286) | void test_cache_generations()
  function BOOST_AUTO_TEST_CASE (line 375) | BOOST_AUTO_TEST_CASE(cuckoocache_generations)

FILE: src/test/dbwrapper_tests.cpp
  function is_null_key (line 15) | bool is_null_key(const std::vector<unsigned char>& key) {
  function BOOST_AUTO_TEST_CASE (line 26) | BOOST_AUTO_TEST_CASE(dbwrapper)
  function BOOST_AUTO_TEST_CASE (line 46) | BOOST_AUTO_TEST_CASE(dbwrapper_batch)
  function BOOST_AUTO_TEST_CASE (line 82) | BOOST_AUTO_TEST_CASE(dbwrapper_iterator)
  function BOOST_AUTO_TEST_CASE (line 123) | BOOST_AUTO_TEST_CASE(existing_data_no_obfuscate)
  function BOOST_AUTO_TEST_CASE (line 164) | BOOST_AUTO_TEST_CASE(existing_data_reindex)
  function BOOST_AUTO_TEST_CASE (line 200) | BOOST_AUTO_TEST_CASE(iterator_ordering)
  type StringContentsSerializer (line 241) | struct StringContentsSerializer {
    method StringContentsSerializer (line 245) | StringContentsSerializer() {}
    method StringContentsSerializer (line 246) | explicit StringContentsSerializer(const std::string& inp) : str(inp) {}
    method StringContentsSerializer (line 248) | StringContentsSerializer& operator+=(const std::string& s) {
    method StringContentsSerializer (line 252) | StringContentsSerializer& operator+=(const StringContentsSerializer& s...
    method SerializationOp (line 257) | inline void SerializationOp(Stream& s, Operation ser_action) {
  function BOOST_AUTO_TEST_CASE (line 276) | BOOST_AUTO_TEST_CASE(iterator_string_ordering)

FILE: src/test/getarg_tests.cpp
  function ResetArgs (line 16) | static void ResetArgs(const std::string& strArg)
  function BOOST_AUTO_TEST_CASE (line 33) | BOOST_AUTO_TEST_CASE(boolarg)
  function BOOST_AUTO_TEST_CASE (line 85) | BOOST_AUTO_TEST_CASE(stringarg)
  function BOOST_AUTO_TEST_CASE (line 109) | BOOST_AUTO_TEST_CASE(intarg)
  function BOOST_AUTO_TEST_CASE (line 128) | BOOST_AUTO_TEST_CASE(doubledash)
  function BOOST_AUTO_TEST_CASE (line 138) | BOOST_AUTO_TEST_CASE(boolargno)

FILE: src/test/hash_tests.cpp
  function BOOST_AUTO_TEST_CASE (line 15) | BOOST_AUTO_TEST_CASE(murmurhash3)
  function BOOST_AUTO_TEST_CASE (line 80) | BOOST_AUTO_TEST_CASE(siphash)

FILE: src/test/key_tests.cpp
  function BOOST_AUTO_TEST_CASE (line 33) | BOOST_AUTO_TEST_CASE(key_test1)

FILE: src/test/limitedmap_tests.cpp
  function BOOST_AUTO_TEST_CASE (line 13) | BOOST_AUTO_TEST_CASE(limitedmap_test)

FILE: src/test/main_tests.cpp
  function TestBlockSubsidyHalvings (line 16) | static void TestBlockSubsidyHalvings(const Consensus::Params& consensusP...
  function TestBlockSubsidyHalvings (line 33) | static void TestBlockSubsidyHalvings(int nSubsidyHalvingInterval)
  function BOOST_AUTO_TEST_CASE (line 40) | BOOST_AUTO_TEST_CASE(block_subsidy_test)
  function BOOST_AUTO_TEST_CASE (line 48) | BOOST_AUTO_TEST_CASE(subsidy_limit_test)
  function ReturnFalse (line 69) | bool ReturnFalse() { return false; }
  function ReturnTrue (line 70) | bool ReturnTrue() { return true; }
  function BOOST_AUTO_TEST_CASE (line 72) | BOOST_AUTO_TEST_CASE(test_combiner_all)

FILE: src/test/mempool_tests.cpp
  function BOOST_AUTO_TEST_CASE (line 17) | BOOST_AUTO_TEST_CASE(MempoolRemoveTest)
  function CheckSort (line 109) | void CheckSort(CTxMemPool &pool, std::vector<std::string> &sortedOrder)
  function BOOST_AUTO_TEST_CASE (line 119) | BOOST_AUTO_TEST_CASE(MempoolIndexingTest)
  function BOOST_AUTO_TEST_CASE (line 292) | BOOST_AUTO_TEST_CASE(MempoolAncestorIndexingTest)
  function BOOST_AUTO_TEST_CASE (line 421) | BOOST_AUTO_TEST_CASE(MempoolSizeLimitTest)

FILE: src/test/merkle_tests.cpp
  function uint256 (line 13) | static uint256 BlockBuildMerkleTree(const CBlock& block, bool* fMutated,...
  function BlockGetMerkleBranch (line 42) | static std::vector<uint256> BlockGetMerkleBranch(const CBlock& block, co...
  function ctz (line 56) | static inline int ctz(uint32_t i) {
  function BOOST_AUTO_TEST_CASE (line 66) | BOOST_AUTO_TEST_CASE(merkle_test)

FILE: src/test/merkleblock_tests.cpp
  function BOOST_AUTO_TEST_CASE (line 18) | BOOST_AUTO_TEST_CASE(merkleblock_construct_from_txids_found)
  function BOOST_AUTO_TEST_CASE (line 59) | BOOST_AUTO_TEST_CASE(merkleblock_construct_from_txids_not_found)

FILE: src/test/miner_tests.cpp
  class HasReason (line 30) | class HasReason {
    method HasReason (line 32) | HasReason(const std::string& reason) : m_reason(reason) {}
  function BlockAssembler (line 42) | static BlockAssembler AssemblerForTest(const CChainParams& params) {
  function CBlockIndex (line 85) | CBlockIndex CreateBlockIndex(int nHeight)
  function TestSequenceLocks (line 93) | bool TestSequenceLocks(const CTransaction &tx, int flags)
  function TestPackageSelection (line 102) | void TestPackageSelection(const CChainParams& chainparams, CScript scrip...
  function BOOST_AUTO_TEST_CASE (line 205) | BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)

FILE: src/test/multisig_tests.cpp
  function CScript (line 21) | CScript
  function BOOST_AUTO_TEST_CASE (line 38) | BOOST_AUTO_TEST_CASE(multisig_verify)
  function BOOST_AUTO_TEST_CASE (line 138) | BOOST_AUTO_TEST_CASE(multisig_IsStandard)
  function BOOST_AUTO_TEST_CASE (line 174) | BOOST_AUTO_TEST_CASE(multisig_Sign)

FILE: src/test/net_tests.cpp
  class CAddrManSerializationMock (line 18) | class CAddrManSerializationMock : public CAddrMan
    method MakeDeterministic (line 24) | void MakeDeterministic()
  class CAddrManUncorrupted (line 31) | class CAddrManUncorrupted : public CAddrManSerializationMock
    method Serialize (line 34) | void Serialize(CDataStream& s) const override
  class CAddrManCorrupted (line 40) | class CAddrManCorrupted : public CAddrManSerializationMock
    method Serialize (line 43) | void Serialize(CDataStream& s) const override
  function CDataStream (line 66) | CDataStream AddrmanToStream(CAddrManSerializationMock& _addrman)
  function BOOST_AUTO_TEST_CASE (line 78) | BOOST_AUTO_TEST_CASE(cnode_listen_port)
  function BOOST_AUTO_TEST_CASE (line 90) | BOOST_AUTO_TEST_CASE(caddrdb_read)
  function BOOST_AUTO_TEST_CASE (line 135) | BOOST_AUTO_TEST_CASE(caddrdb_read_corrupted)
  function BOOST_AUTO_TEST_CASE (line 166) | BOOST_AUTO_TEST_CASE(cnode_simple_test)

FILE: src/test/netbase_tests.cpp
  function CNetAddr (line 15) | static CNetAddr ResolveIP(const char* ip)
  function CSubNet (line 22) | static CSubNet ResolveSubNet(const char* subnet)
  function CNetAddr (line 29) | static CNetAddr CreateInternal(const char* host)
  function BOOST_AUTO_TEST_CASE (line 36) | BOOST_AUTO_TEST_CASE(netbase_networks)
  function BOOST_AUTO_TEST_CASE (line 47) | BOOST_AUTO_TEST_CASE(netbase_properties)
  function TestSplitHost (line 75) | bool static TestSplitHost(std::string test, std::string host, int port)
  function BOOST_AUTO_TEST_CASE (line 83) | BOOST_AUTO_TEST_CASE(netbase_splithost)
  function TestParse (line 102) | bool static TestParse(std::string src, std::string canon)
  function BOOST_AUTO_TEST_CASE (line 108) | BOOST_AUTO_TEST_CASE(netbase_lookupnumeric)
  function BOOST_AUTO_TEST_CASE (line 124) | BOOST_AUTO_TEST_CASE(onioncat_test)
  function BOOST_AUTO_TEST_CASE (line 137) | BOOST_AUTO_TEST_CASE(subnet_test)
  function BOOST_AUTO_TEST_CASE (line 284) | BOOST_AUTO_TEST_CASE(netbase_getgroup)

FILE: src/test/pmt_tests.cpp
  class CPartialMerkleTreeTester (line 18) | class CPartialMerkleTreeTester : public CPartialMerkleTree
    method Damage (line 22) | void Damage() {
  function BOOST_AUTO_TEST_CASE (line 31) | BOOST_AUTO_TEST_CASE(pmt_test1)
  function BOOST_AUTO_TEST_CASE (line 109) | BOOST_AUTO_TEST_CASE(pmt_malleability)

FILE: src/test/policyestimator_tests.cpp
  function BOOST_AUTO_TEST_CASE (line 17) | BOOST_AUTO_TEST_CASE(BlockPolicyEstimates)

FILE: src/test/pow_tests.cpp
  function BOOST_AUTO_TEST_CASE (line 17) | BOOST_AUTO_TEST_CASE(get_next_work)
  function BOOST_AUTO_TEST_CASE (line 44) | BOOST_AUTO_TEST_CASE(get_next_work_pow_limit)
  function BOOST_AUTO_TEST_CASE (line 72) | BOOST_AUTO_TEST_CASE(get_next_work_lower_limit_actual)
  function BOOST_AUTO_TEST_CASE (line 100) | BOOST_AUTO_TEST_CASE(get_next_work_upper_limit_actual)
  function BOOST_AUTO_TEST_CASE (line 126) | BOOST_AUTO_TEST_CASE(GetBlockProofEquivalentTime_test)

FILE: src/test/prevector_tests.cpp
  class prevector_tester (line 19) | class prevector_tester {
    method local_check_equal (line 35) | void local_check_equal(A a, B b)
    method local_check (line 39) | void local_check(bool b)
    method test (line 43) | void test() {
    method resize (line 80) | void resize(Size s) {
    method reserve (line 88) | void reserve(Size s) {
    method insert (line 96) | void insert(Size position, const T& value) {
    method insert (line 102) | void insert(Size position, Size count, const T& value) {
    method insert_range (line 109) | void insert_range(Size position, I first, I last) {
    method erase (line 115) | void erase(Size position) {
    method erase (line 121) | void erase(Size first, Size last) {
    method update (line 127) | void update(Size pos, const T& value) {
    method push_back (line 133) | void push_back(const T& value) {
    method pop_back (line 139) | void pop_back() {
    method clear (line 145) | void clear() {
    method assign (line 150) | void assign(Size n, const T& value) {
    method Size (line 155) | Size size() const {
    method Size (line 159) | Size capacity() const {
    method shrink_to_fit (line 163) | void shrink_to_fit() {
    method swap (line 168) | void swap() {
    method move (line 174) | void move() {
    method copy (line 181) | void copy() {
    method prevector_tester (line 190) | prevector_tester() {
  function BOOST_AUTO_TEST_CASE (line 197) | BOOST_AUTO_TEST_CASE(PrevectorTestInt)

FILE: src/test/raii_event_tests.cpp
  function tag_free (line 33) | static void tag_free(void* mem) {
  function BOOST_AUTO_TEST_CASE (line 41) | BOOST_AUTO_TEST_CASE(raii_event_creation)
  function BOOST_AUTO_TEST_CASE (line 70) | BOOST_AUTO_TEST_CASE(raii_event_order)

FILE: src/test/random_tests.cpp
  function BOOST_AUTO_TEST_CASE (line 13) | BOOST_AUTO_TEST_CASE(osrandom_tests)
  function BOOST_AUTO_TEST_CASE (line 18) | BOOST_AUTO_TEST_CASE(fastrandom_tests)
  function BOOST_AUTO_TEST_CASE (line 45) | BOOST_AUTO_TEST_CASE(fastrandom_randbits)

FILE: src/test/reverselock_tests.cpp
  function BOOST_AUTO_TEST_CASE (line 12) | BOOST_AUTO_TEST_CASE(reverselock_basics)
  function BOOST_AUTO_TEST_CASE (line 25) | BOOST_AUTO_TEST_CASE(reverselock_errors)

FILE: src/test/rpc_tests.cpp
  function UniValue (line 19) | UniValue CallRPC(std::string args)
  function BOOST_AUTO_TEST_CASE (line 43) | BOOST_AUTO_TEST_CASE(rpc_rawparams)
  function BOOST_AUTO_TEST_CASE (line 87) | BOOST_AUTO_TEST_CASE(rpc_togglenetwork)
  function BOOST_AUTO_TEST_CASE (line 109) | BOOST_AUTO_TEST_CASE(rpc_rawsign)
  function BOOST_AUTO_TEST_CASE (line 128) | BOOST_AUTO_TEST_CASE(rpc_createraw_op_return)
  function BOOST_AUTO_TEST_CASE (line 146) | BOOST_AUTO_TEST_CASE(rpc_format_monetary_values)
  function UniValue (line 181) | static UniValue ValueFromString(const std::string &str)
  function BOOST_AUTO_TEST_CASE (line 188) | BOOST_AUTO_TEST_CASE(rpc_parse_monetary_values)
  function BOOST_AUTO_TEST_CASE (line 221) | BOOST_AUTO_TEST_CASE(json_parse_errors)
  function BOOST_AUTO_TEST_CASE (line 242) | BOOST_AUTO_TEST_CASE(rpc_ban)
  function BOOST_AUTO_TEST_CASE (line 325) | BOOST_AUTO_TEST_CASE(rpc_convert_values_generatetoaddress)

FILE: src/test/sanity_tests.cpp
  function BOOST_AUTO_TEST_CASE (line 13) | BOOST_AUTO_TEST_CASE(basic_sanity)

FILE: src/test/scheduler_tests.cpp
  function microTask (line 16) | static void microTask(CScheduler& s, boost::mutex& mutex, int& counter, ...
  function MicroSleep (line 29) | static void MicroSleep(uint64_t n)
  function BOOST_AUTO_TEST_CASE (line 41) | BOOST_AUTO_TEST_CASE(manythreads)

FILE: src/test/script_P2SH_tests.cpp
  function Serialize (line 22) | static std::vector<unsigned char>
  function Verify (line 29) | static bool
  function BOOST_AUTO_TEST_CASE (line 51) | BOOST_AUTO_TEST_CASE(sign)
  function BOOST_AUTO_TEST_CASE (line 125) | BOOST_AUTO_TEST_CASE(norecurse)
  function BOOST_AUTO_TEST_CASE (line 152) | BOOST_AUTO_TEST_CASE(set)
  function BOOST_AUTO_TEST_CASE (line 207) | BOOST_AUTO_TEST_CASE(is)
  function BOOST_AUTO_TEST_CASE (line 238) | BOOST_AUTO_TEST_CASE(switchover)
  function BOOST_AUTO_TEST_CASE (line 258) | BOOST_AUTO_TEST_CASE(AreInputsStandard)

FILE: src/test/script_standard_tests.cpp
  function BOOST_AUTO_TEST_CASE (line 18) | BOOST_AUTO_TEST_CASE(script_standard_Solver_success)
  function BOOST_AUTO_TEST_CASE (line 122) | BOOST_AUTO_TEST_CASE(script_standard_Solver_failure)
  function BOOST_AUTO_TEST_CASE (line 179) | BOOST_AUTO_TEST_CASE(script_standard_ExtractDestination)
  function BOOST_AUTO_TEST_CASE (line 248) | BOOST_AUTO_TEST_CASE(script_standard_ExtractDestinations)
  function BOOST_AUTO_TEST_CASE (line 314) | BOOST_AUTO_TEST_CASE(script_standard_GetScriptFor_)
  function BOOST_AUTO_TEST_CASE (line 386) | BOOST_AUTO_TEST_CASE(script_standard_IsMine)

FILE: src/test/script_tests.cpp
  function UniValue (line 39) | UniValue
  type ScriptErrorDesc (line 52) | struct ScriptErrorDesc
  function ScriptError_t (line 113) | ScriptError_t ParseScriptError(const std::string &name)
  function CMutableTransaction (line 124) | CMutableTransaction BuildCreditingTransaction(const CScript& scriptPubKe...
  function CMutableTransaction (line 140) | CMutableTransaction BuildSpendingTransaction(const CScript& scriptSig, c...
  function DoTest (line 158) | void DoTest(const CScript& scriptPubKey, const CScript& scriptSig, const...
  function NegateSignatureS (line 197) | void static NegateSignatureS(std::vector<unsigned char>& vchSig) {
  type KeyData (line 243) | struct KeyData
    method KeyData (line 250) | KeyData()
  type WitnessMode (line 272) | enum WitnessMode {
  class TestBuilder (line 278) | class TestBuilder
    method DoPush (line 297) | void DoPush()
    method DoPush (line 305) | void DoPush(const std::vector<unsigned char>& data)
    method TestBuilder (line 313) | TestBuilder(const CScript& script_, const std::string& comment_, int f...
    method TestBuilder (line 335) | TestBuilder& ScriptError(ScriptError_t err)
    method TestBuilder (line 341) | TestBuilder& Add(const CScript& _script)
    method TestBuilder (line 348) | TestBuilder& Num(int num)
    method TestBuilder (line 355) | TestBuilder& Push(const std::string& hex)
    method TestBuilder (line 361) | TestBuilder& Push(const CScript& _script) {
    method TestBuilder (line 366) | TestBuilder& PushSig(const CKey& key, int nHashType = SIGHASH_ALL, uns...
    method TestBuilder (line 384) | TestBuilder& PushWitSig(const CKey& key, CAmount amount = -1, int nHas...
    method TestBuilder (line 391) | TestBuilder& Push(const CPubKey& pubkey)
    method TestBuilder (line 397) | TestBuilder& PushRedeem()
    method TestBuilder (line 403) | TestBuilder& PushWitRedeem()
    method TestBuilder (line 409) | TestBuilder& EditPush(unsigned int pos, const std::string& hexin, cons...
    method TestBuilder (line 421) | TestBuilder& DamagePush(unsigned int pos)
    method TestBuilder (line 429) | TestBuilder& Test()
    method TestBuilder (line 438) | TestBuilder& AsWit()
    method UniValue (line 446) | UniValue GetJSON()
    method GetComment (line 466) | std::string GetComment() const
  function JSONPrettyPrint (line 472) | std::string JSONPrettyPrint(const UniValue& univalue)
  function BOOST_AUTO_TEST_CASE (line 485) | BOOST_AUTO_TEST_CASE(script_build)
  function BOOST_AUTO_TEST_CASE (line 960) | BOOST_AUTO_TEST_CASE(script_json_test)
  function BOOST_AUTO_TEST_CASE (line 1003) | BOOST_AUTO_TEST_CASE(script_PushData)
  function CScript (line 1033) | CScript
  function CScript (line 1057) | CScript
  function BOOST_AUTO_TEST_CASE (line 1065) | BOOST_AUTO_TEST_CASE(script_CHECKMULTISIG12)
  function BOOST_AUTO_TEST_CASE (line 1095) | BOOST_AUTO_TEST_CASE(script_CHECKMULTISIG23)
  function BOOST_AUTO_TEST_CASE (line 1164) | BOOST_AUTO_TEST_CASE(script_combineSigs)
  function BOOST_AUTO_TEST_CASE (line 1274) | BOOST_AUTO_TEST_CASE(script_standard_push)
  function BOOST_AUTO_TEST_CASE (line 1295) | BOOST_AUTO_TEST_CASE(script_IsPushOnly_on_invalid_scripts)
  function BOOST_AUTO_TEST_CASE (line 1306) | BOOST_AUTO_TEST_CASE(script_GetScriptAsm)
  function CScript (line 1336) | static CScript
  function BOOST_AUTO_TEST_CASE (line 1344) | BOOST_AUTO_TEST_CASE(script_FindAndDelete)
  function BOOST_AUTO_TEST_CASE (line 1453) | BOOST_AUTO_TEST_CASE(script_HasValidOps)
  function BOOST_AUTO_TEST_CASE (line 1467) | BOOST_AUTO_TEST_CASE(script_can_append_self)
  function BOOST_AUTO_TEST_CASE (line 1488) | BOOST_AUTO_TEST_CASE(bitcoinconsensus_verify_script_returns_true)
  function BOOST_AUTO_TEST_CASE (line 1511) | BOOST_AUTO_TEST_CASE(bitcoinconsensus_verify_script_tx_index_err)
  function BOOST_AUTO_TEST_CASE (line 1534) | BOOST_AUTO_TEST_CASE(bitcoinconsensus_verify_script_tx_size)
  function BOOST_AUTO_TEST_CASE (line 1557) | BOOST_AUTO_TEST_CASE(bitcoinconsensus_verify_script_tx_serialization)
  function BOOST_AUTO_TEST_CASE (line 1580) | BOOST_AUTO_TEST_CASE(bitcoinconsensus_verify_script_amount_required_err)
  function BOOST_AUTO_TEST_CASE (line 1603) | BOOST_AUTO_TEST_CASE(bitcoinconsensus_verify_script_invalid_flags)

FILE: src/test/scriptnum10.h
  function class (line 17) | class scriptnum10_error : public std::runtime_error
  function class (line 23) | class CScriptNum10

FILE: src/test/scriptnum_tests.cpp
  function verify (line 21) | static bool verify(const CScriptNum10& bignum, const CScriptNum& scriptnum)
  function CheckCreateVch (line 26) | static void CheckCreateVch(const int64_t& num)
  function CheckCreateInt (line 41) | static void CheckCreateInt(const int64_t& num)
  function CheckAdd (line 52) | static void CheckAdd(const int64_t& num1, const int64_t& num2)
  function CheckNegate (line 74) | static void CheckNegate(const int64_t& num)
  function CheckSubtract (line 84) | static void CheckSubtract(const int64_t& num1, const int64_t& num2)
  function CheckCompare (line 109) | static void CheckCompare(const int64_t& num1, const int64_t& num2)
  function RunCreate (line 145) | static void RunCreate(const int64_t& num)
  function RunOperators (line 157) | static void RunOperators(const int64_t& num1, const int64_t& num2)
  function BOOST_AUTO_TEST_CASE (line 165) | BOOST_AUTO_TEST_CASE(creation)
  function BOOST_AUTO_TEST_CASE (line 178) | BOOST_AUTO_TEST_CASE(operators)

FILE: src/test/serialize_tests.cpp
  class CSerializeMethodsTestSingle (line 16) | class CSerializeMethodsTestSingle
    method CSerializeMethodsTestSingle (line 25) | CSerializeMethodsTestSingle() = default;
    method CSerializeMethodsTestSingle (line 26) | CSerializeMethodsTestSingle(int intvalin, bool boolvalin, std::string ...
    method SerializationOp (line 30) | inline void SerializationOp(Stream& s, Operation ser_action) {
  class CSerializeMethodsTestMany (line 48) | class CSerializeMethodsTestMany : public CSerializeMethodsTestSingle
    method SerializationOp (line 55) | inline void SerializationOp(Stream& s, Operation ser_action) {
  function BOOST_AUTO_TEST_CASE (line 60) | BOOST_AUTO_TEST_CASE(sizes)
  function BOOST_AUTO_TEST_CASE (line 91) | BOOST_AUTO_TEST_CASE(floats_conversion)
  function BOOST_AUTO_TEST_CASE (line 110) | BOOST_AUTO_TEST_CASE(doubles_conversion)
  function BOOST_AUTO_TEST_CASE (line 139) | BOOST_AUTO_TEST_CASE(floats)
  function BOOST_AUTO_TEST_CASE (line 156) | BOOST_AUTO_TEST_CASE(doubles)
  function BOOST_AUTO_TEST_CASE (line 173) | BOOST_AUTO_TEST_CASE(varints)
  function BOOST_AUTO_TEST_CASE (line 205) | BOOST_AUTO_TEST_CASE(varints_bitpatterns)
  function BOOST_AUTO_TEST_CASE (line 226) | BOOST_AUTO_TEST_CASE(compactsize)
  function isCanonicalException (line 245) | static bool isCanonicalException(const std::ios_base::failure& ex)
  function BOOST_AUTO_TEST_CASE (line 257) | BOOST_AUTO_TEST_CASE(noncanonical)
  function BOOST_AUTO_TEST_CASE (line 294) | BOOST_AUTO_TEST_CASE(insert_delete)
  function BOOST_AUTO_TEST_CASE (line 342) | BOOST_AUTO_TEST_CASE(class_methods)

FILE: src/test/sighash_tests.cpp
  function uint256 (line 27) | uint256 static SignatureHashOld(CScript scriptCode, const CTransaction& ...
  function RandomScript (line 87) | void static RandomScript(CScript &script) {
  function RandomTransaction (line 95) | void static RandomTransaction(CMutableTransaction &tx, bool fSingle) {
  function BOOST_AUTO_TEST_CASE (line 120) | BOOST_AUTO_TEST_CASE(sighash_test)
  function BOOST_AUTO_TEST_CASE (line 165) | BOOST_AUTO_TEST_CASE(sighash_from_data)

FILE: src/test/sigopcount_tests.cpp
  function Serialize (line 19) | static std::vector<unsigned char>
  function BOOST_AUTO_TEST_CASE (line 28) | BOOST_AUTO_TEST_CASE(GetSigOpCount)
  function ScriptError (line 70) | ScriptError VerifyWithFlag(const CTransaction& output, const CMutableTra...
  function BuildTxs (line 85) | void BuildTxs(CMutableTransaction& spendingTx, CCoinsViewCache& coins, C...
  function BOOST_AUTO_TEST_CASE (line 108) | BOOST_AUTO_TEST_CASE(GetTxSigOpCost)

FILE: src/test/skiplist_tests.cpp
  function BOOST_AUTO_TEST_CASE (line 17) | BOOST_AUTO_TEST_CASE(skiplist_test)
  function BOOST_AUTO_TEST_CASE (line 46) | BOOST_AUTO_TEST_CASE(getlocator_test)
  function BOOST_AUTO_TEST_CASE (line 102) | BOOST_AUTO_TEST_CASE(findearliestatleast_test)
  function BOOST_AUTO_TEST_CASE (line 146) | BOOST_AUTO_TEST_CASE(findearliestatleast_edge_test)

FILE: src/test/streams_tests.cpp
  function BOOST_AUTO_TEST_CASE (line 13) | BOOST_AUTO_TEST_CASE(streams_vector_writer)
  function BOOST_AUTO_TEST_CASE (line 71) | BOOST_AUTO_TEST_CASE(streams_serializedata_xor)

FILE: src/test/test_bitcoin.cpp
  function CBlock (line 139) | CBlock
  function CTxMemPoolEntry (line 171) | CTxMemPoolEntry TestMemPoolEntryHelper::FromTx(const CMutableTransaction...
  function CTxMemPoolEntry (line 176) | CTxMemPoolEntry TestMemPoolEntryHelper::FromTx(const CTransaction &txn) {
  function CBlock (line 185) | CBlock getBlock13b8a()

FILE: src/test/test_bitcoin.h
  function InsecureRand32 (line 34) | static inline uint32_t InsecureRand32() { return insecure_rand_ctx.rand3...
  function uint256 (line 35) | static inline uint256 InsecureRand256() { return insecure_rand_ctx.rand2...
  function InsecureRandBits (line 36) | static inline uint64_t InsecureRandBits(int bits) { return insecure_rand...
  function InsecureRandRange (line 37) | static inline uint64_t InsecureRandRange(uint64_t range) { return insecu...
  function InsecureRandBool (line 38) | static inline bool InsecureRandBool() { return insecure_rand_ctx.randboo...
  type BasicTestingSetup (line 43) | struct BasicTestingSetup {
  type CConnmanTest (line 55) | struct CConnmanTest {
  function BasicTestingSetup (line 61) | struct TestingSetup: public BasicTestingSetup {
  type CMutableTransaction (line 73) | struct CMutableTransaction
  function TestingSetup (line 80) | struct TestChain100Setup : public TestingSetup {

FILE: src/test/test_bitcoin_fuzzy.cpp
  type TEST_ID (line 31) | enum TEST_ID {
  function read_stdin (line 55) | bool read_stdin(std::vector<uint8_t> &data) {
  function test_one_input (line 66) | int test_one_input(std::vector<uint8_t> buffer) {
  function initialize (line 279) | void initialize() {
  function LLVMFuzzerTestOneInput (line 284) | int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
  function LLVMFuzzerInitialize (line 290) | int LLVMFuzzerInitialize(int *argc, char ***argv) {
  function main (line 299) | __attribute__((weak))

FILE: src/test/test_bitcoin_main.cpp
  function Shutdown (line 15) | [[noreturn]] void Shutdown(void* parg)
  function StartShutdown (line 20) | [[noreturn]] void StartShutdown()
  function ShutdownRequested (line 25) | bool ShutdownRequested()

FILE: src/test/timedata_tests.cpp
  function BOOST_AUTO_TEST_CASE (line 12) | BOOST_AUTO_TEST_CASE(util_MedianFilter)

FILE: src/test/torcontrol_tests.cpp
  function CheckSplitTorReplyLine (line 13) | void CheckSplitTorReplyLine(std::string input, std::string command, std:...
  function BOOST_AUTO_TEST_CASE (line 21) | BOOST_AUTO_TEST_CASE(util_SplitTorReplyLine)
  function CheckParseTorReplyMapping (line 54) | void CheckParseTorReplyMapping(std::string input, std::map<std::string,s...
  function BOOST_AUTO_TEST_CASE (line 69) | BOOST_AUTO_TEST_CASE(util_ParseTorReplyMapping)

FILE: src/test/transaction_tests.cpp
  function ParseScriptFlags (line 59) | unsigned int ParseScriptFlags(std::string strFlags)
  function FormatScriptFlags (line 78) | std::string FormatScriptFlags(unsigned int flags)
  function BOOST_AUTO_TEST_CASE (line 96) | BOOST_AUTO_TEST_CASE(tx_valid)
  function BOOST_AUTO_TEST_CASE (line 181) | BOOST_AUTO_TEST_CASE(tx_invalid)
  function BOOST_AUTO_TEST_CASE (line 267) | BOOST_AUTO_TEST_CASE(basic_transaction_tests)
  function SetupDummyInputs (line 289) | static std::vector<CMutableTransaction>
  function BOOST_AUTO_TEST_CASE (line 321) | BOOST_AUTO_TEST_CASE(test_Get)
  function CreateCreditAndSpend (line 347) | void CreateCreditAndSpend(const CKeyStore& keystore, const CScript& outs...
  function CheckWithFlag (line 385) | void CheckWithFlag(const CTransactionRef& output, const CMutableTransact...
  function CScript (line 393) | static CScript PushAll(const std::vector<valtype>& values)
  function ReplaceRedeemScript (line 408) | void ReplaceRedeemScript(CScript& script, const CScript& redeemScript)
  function BOOST_AUTO_TEST_CASE (line 417) | BOOST_AUTO_TEST_CASE(test_big_witness_transaction) {
  function BOOST_AUTO_TEST_CASE (line 497) | BOOST_AUTO_TEST_CASE(test_witness)
  function BOOST_AUTO_TEST_CASE (line 672) | BOOST_AUTO_TEST_CASE(test_IsStandard)

FILE: src/test/txvalidation_tests.cpp
  function BOOST_FIXTURE_TEST_CASE (line 21) | BOOST_FIXTURE_TEST_CASE(tx_mempool_reject_coinbase, TestChain100Setup)

FILE: src/test/txvalidationcache_tests.cpp
  function ToMemPool (line 26) | static bool
  function BOOST_FIXTURE_TEST_CASE (line 36) | BOOST_FIXTURE_TEST_CASE(tx_mempool_block_doublespend, TestChain100Setup)
  function ValidateCheckInputsForAllFlags (line 105) | void ValidateCheckInputsForAllFlags(CMutableTransaction &tx, uint32_t fa...
  function BOOST_FIXTURE_TEST_CASE (line 144) | BOOST_FIXTURE_TEST_CASE(checkinputs_test, TestChain100Setup)

FILE: src/test/uint256_tests.cpp
  function ArrayToString (line 51) | std::string ArrayToString(const unsigned char A[], unsigned int width)
  function uint160 (line 62) | inline uint160 uint160S(const char *str)
  function uint160 (line 68) | inline uint160 uint160S(const std::string& str)
  function BOOST_AUTO_TEST_CASE (line 75) | BOOST_AUTO_TEST_CASE( basics ) // constructors, equality, inequality
  function BOOST_AUTO_TEST_CASE (line 127) | BOOST_AUTO_TEST_CASE( comparison ) // <= >= < >
  function BOOST_AUTO_TEST_CASE (line 159) | BOOST_AUTO_TEST_CASE( methods ) // GetHex SetHex begin() end() size() Ge...
  function BOOST_AUTO_TEST_CASE (line 253) | BOOST_AUTO_TEST_CASE( conversion )

FILE: src/test/util_tests.cpp
  function BOOST_AUTO_TEST_CASE (line 26) | BOOST_AUTO_TEST_CASE(util_criticalsection)
  function BOOST_AUTO_TEST_CASE (line 53) | BOOST_AUTO_TEST_CASE(util_ParseHex)
  function BOOST_AUTO_TEST_CASE (line 74) | BOOST_AUTO_TEST_CASE(util_HexStr)
  function BOOST_AUTO_TEST_CASE (line 96) | BOOST_AUTO_TEST_CASE(util_DateTimeStrFormat)
  class TestArgsManager (line 105) | class TestArgsManager : public ArgsManager
  function BOOST_AUTO_TEST_CASE (line 118) | BOOST_AUTO_TEST_CASE(util_ParseParameters)
  function BOOST_AUTO_TEST_CASE (line 143) | BOOST_AUTO_TEST_CASE(util_GetArg)
  function BOOST_AUTO_TEST_CASE (line 168) | BOOST_AUTO_TEST_CASE(util_FormatMoney)
  function BOOST_AUTO_TEST_CASE (line 193) | BOOST_AUTO_TEST_CASE(util_ParseMoney)
  function BOOST_AUTO_TEST_CASE (line 246) | BOOST_AUTO_TEST_CASE(util_IsHex)
  function BOOST_AUTO_TEST_CASE (line 261) | BOOST_AUTO_TEST_CASE(util_IsHexNumber)
  function BOOST_AUTO_TEST_CASE (line 286) | BOOST_AUTO_TEST_CASE(util_seed_insecure_rand)
  function BOOST_AUTO_TEST_CASE (line 311) | BOOST_AUTO_TEST_CASE(util_TimingResistantEqual)
  function BOOST_AUTO_TEST_CASE (line 326) | BOOST_AUTO_TEST_CASE(strprintf_numbers)
  function BOOST_AUTO_TEST_CASE (line 352) | BOOST_AUTO_TEST_CASE(gettime)
  function BOOST_AUTO_TEST_CASE (line 357) | BOOST_AUTO_TEST_CASE(test_ParseInt32)
  function BOOST_AUTO_TEST_CASE (line 386) | BOOST_AUTO_TEST_CASE(test_ParseInt64)
  function BOOST_AUTO_TEST_CASE (line 416) | BOOST_AUTO_TEST_CASE(test_ParseUInt32)
  function BOOST_AUTO_TEST_CASE (line 447) | BOOST_AUTO_TEST_CASE(test_ParseUInt64)
  function BOOST_AUTO_TEST_CASE (line 479) | BOOST_AUTO_TEST_CASE(test_ParseDouble)
  function BOOST_AUTO_TEST_CASE (line 507) | BOOST_AUTO_TEST_CASE(test_FormatParagraph)
  function BOOST_AUTO_TEST_CASE (line 534) | BOOST_AUTO_TEST_CASE(test_FormatSubVersion)
  function BOOST_AUTO_TEST_CASE (line 546) | BOOST_AUTO_TEST_CASE(test_ParseFixedPoint)
  function TestOtherThread (line 611) | static void TestOtherThread(fs::path dirname, std::string lockname, bool...
  function TestOtherProcess (line 621) | static void TestOtherProcess(fs::path dirname, std::string lockname, int...
  function BOOST_AUTO_TEST_CASE (line 649) | BOOST_AUTO_TEST_CASE(test_LockDirectory)

FILE: src/test/validation_block_tests.cpp
  type RegtestingSetup (line 17) | struct RegtestingSetup : public TestingSetup {
    method RegtestingSetup (line 18) | RegtestingSetup() : TestingSetup(CBaseChainParams::REGTEST) {}
  type TestSubscriber (line 23) | struct TestSubscriber : public CValidationInterface {
    method TestSubscriber (line 26) | TestSubscriber(uint256 tip) : m_expected_tip(tip) {}
    method UpdatedBlockTip (line 28) | void UpdatedBlockTip(const CBlockIndex* pindexNew, const CBlockIndex* ...
    method BlockConnected (line 33) | void BlockConnected(const std::shared_ptr<const CBlock>& block, const ...
    method BlockDisconnected (line 41) | void BlockDisconnected(const std::shared_ptr<const CBlock>& block)
  function Block (line 49) | std::shared_ptr<CBlock> Block(const uint256& prev_hash)
  function FinalizeBlock (line 70) | std::shared_ptr<CBlock> FinalizeBlock(std::shared_ptr<CBlock> pblock)
  function GoodBlock (line 82) | const std::shared_ptr<const CBlock> GoodBlock(const uint256& prev_hash)
  function BadBlock (line 88) | const std::shared_ptr<const CBlock> BadBlock(const uint256& prev_hash)
  function BuildChain (line 103) | void BuildChain(const uint256& root, int height, const unsigned int inva...
  function BOOST_AUTO_TEST_CASE (line 122) | BOOST_AUTO_TEST_CASE(processnewblock_signals_ordering)

FILE: src/test/versionbits_tests.cpp
  function TestTime (line 15) | int32_t TestTime(int nHeight) { return 1415926536 + 600 * nHeight; }
  class TestConditionChecker (line 19) | class TestConditionChecker : public AbstractThresholdConditionChecker
    method BeginTime (line 25) | int64_t BeginTime(const Consensus::Params& params) const override { re...
    method EndTime (line 26) | int64_t EndTime(const Consensus::Params& params) const override { retu...
    method Period (line 27) | int Period(const Consensus::Params& params) const override { return 10...
    method Threshold (line 28) | int Threshold(const Consensus::Params& params) const override { return...
    method Condition (line 29) | bool Condition(const CBlockIndex* pindex, const Consensus::Params& par...
    method ThresholdState (line 31) | ThresholdState GetStateFor(const CBlockIndex* pindexPrev) const { retu...
    method GetStateSinceHeightFor (line 32) | int GetStateSinceHeightFor(const CBlockIndex* pindexPrev) const { retu...
  class TestAlwaysActiveConditionChecker (line 35) | class TestAlwaysActiveConditionChecker : public TestConditionChecker
    method BeginTime (line 38) | int64_t BeginTime(const Consensus::Params& params) const override { re...
  class VersionBitsTester (line 43) | class VersionBitsTester
    method VersionBitsTester (line 59) | VersionBitsTester() : num(0) {}
    method VersionBitsTester (line 61) | VersionBitsTester& Reset() {
    method VersionBitsTester (line 77) | VersionBitsTester& Mine(unsigned int height, int32_t nTime, int32_t nV...
    method VersionBitsTester (line 90) | VersionBitsTester& TestStateSinceHeight(int height) {
    method VersionBitsTester (line 101) | VersionBitsTester& TestDefined() {
    method VersionBitsTester (line 112) | VersionBitsTester& TestStarted() {
    method VersionBitsTester (line 123) | VersionBitsTester& TestLockedIn() {
    method VersionBitsTester (line 134) | VersionBitsTester& TestActive() {
    method VersionBitsTester (line 145) | VersionBitsTester& TestFailed() {
    method CBlockIndex (line 156) | CBlockIndex * Tip() { return vpblock.size() ? vpblock.back() : nullptr; }
  function BOOST_AUTO_TEST_CASE (line 161) | BOOST_AUTO_TEST_CASE(versionbits_test)
  function BOOST_AUTO_TEST_CASE (line 249) | BOOST_AUTO_TEST_CASE(versionbits_computeblockversion)

FILE: src/threadinterrupt.h
  function class (line 18) | class CThreadInterrupt

FILE: src/timedata.cpp
  function GetTimeOffset (line 29) | int64_t GetTimeOffset()
  function GetAdjustedTime (line 35) | int64_t GetAdjustedTime()
  function abs64 (line 40) | static int64_t abs64(int64_t n)
  function AddTimeData (line 47) | void AddTimeData(const CNetAddr& ip, int64_t nOffsetSample)

FILE: src/timedata.h
  function input (line 47) | void input(T value)
  function T (line 59) | T median() const

FILE: src/tinyformat.h
  function namespace (line 118) | namespace tinyformat {}
  function namespace (line 165) | namespace tinyformat {
  function invoke (line 236) | static bool invoke(std::ostream& /**/, const T& /**/) { return false; }
  function invoke (line 258) | static int invoke(const T& /*value*/)
  function invoke (line 269) | static int invoke(const T& value) { return static_cast<int>(value); }
  function formatTruncated (line 274) | void formatTruncated(std::ostream& out, const T& value, int ntrunc)
  function formatValue (line 315) | void formatValue(std::ostream& out, const char* /*fmtBegin*/,
  function namespace (line 489) | namespace detail {
  function parseIntAndAdvance (line 549) | inline int parseIntAndAdvance(const char*& c)
  function formatImpl (line 788) | inline void formatImpl(std::ostream& out, const char* fmt,
  function class (line 855) | class FormatList
  type FormatList (line 870) | typedef const FormatList& FormatListRef;
  function namespace (line 873) | namespace detail {
  function detail (line 938) | inline detail::FormatListN<0> makeFormatList()
  function vformat (line 957) | inline void vformat(std::ostream& out, const char* fmt, FormatListRef list)
  function string (line 975) | string format(const char* fmt, const Args&... args)
  function format (line 998) | inline void format(std::ostream& out, const char* fmt)
  function std (line 1003) | inline std::string format(const char* fmt)
  function printf (line 1010) | inline void printf(const char* fmt)
  function printfln (line 1015) | inline void printfln(const char* fmt)
  function string (line 1057) | string format(const std::string &fmt, const Args&... args)

FILE: src/torcontrol.cpp
  class TorControlReply (line 53) | class TorControlReply
    method TorControlReply (line 56) | TorControlReply() { Clear(); }
    method Clear (line 61) | void Clear()
  class TorControlConnection (line 71) | class TorControlConnection
    type event_base (line 79) | struct event_base
    type event_base (line 110) | struct event_base
    type bufferevent (line 112) | struct bufferevent
    type bufferevent (line 119) | struct bufferevent
    type bufferevent (line 120) | struct bufferevent
  type event_base (line 123) | struct event_base
  type bufferevent (line 134) | struct bufferevent
  type evbuffer (line 137) | struct evbuffer
  type bufferevent (line 179) | struct bufferevent
  type sockaddr_storage (line 201) | struct sockaddr_storage
  type sockaddr (line 204) | struct sockaddr
  type sockaddr (line 219) | struct sockaddr
  type evbuffer (line 238) | struct evbuffer
  function SplitTorReplyLine (line 254) | static std::pair<std::string,std::string> SplitTorReplyLine(const std::s...
  function ParseTorReplyMapping (line 273) | static std::map<std::string,std::string> ParseTorReplyMapping(const std:...
  function ReadBinaryFile (line 367) | static std::pair<bool,std::string> ReadBinaryFile(const fs::path &filena...
  function WriteBinaryFile (line 393) | static bool WriteBinaryFile(const fs::path &filename, const std::string ...
  class TorController (line 411) | class TorController
    type event_base (line 414) | struct event_base
    type event_base (line 423) | struct event_base
    type event (line 429) | struct event
  type event_base (line 454) | struct event_base
  function ComputeResponse (line 564) | static std::vector<uint8_t> ComputeResponse(const std::string &key, cons...
  type timeval (line 704) | struct timeval
  type event_base (line 733) | struct event_base
  function TorControlThread (line 736) | static void TorControlThread()
  function StartTorControl (line 743) | void StartTorControl(boost::thread_group& threadGroup, CScheduler& sched...
  function InterruptTorControl (line 760) | void InterruptTorControl()
  function StopTorControl (line 768) | void StopTorControl()

FILE: src/txdb.cpp
  type CoinEntry (line 35) | struct CoinEntry {
    method CoinEntry (line 38) | explicit CoinEntry(const COutPoint* ptr) : outpoint(const_cast<COutPoi...
    method Serialize (line 41) | void Serialize(Stream &s) const {
    method Unserialize (line 48) | void Unserialize(Stream& s) {
  function uint256 (line 69) | uint256 CCoinsViewDB::GetBestBlock() const {
  function CCoinsViewCursor (line 173) | CCoinsViewCursor *CCoinsViewDB::Cursor() const
  class CCoins (line 316) | class CCoins
    method CCoins (line 329) | CCoins() : fCoinBase(false), vout(0), nHeight(0) { }
    method Unserialize (line 332) | void Unserialize(Stream &s) {

FILE: src/txdb.h
  function CDiskBlockPos (line 42) | struct CDiskTxPos : public CDiskBlockPos
  function SetNull (line 61) | void SetNull() {
  function class (line 88) | class CCoinsViewDBCursor: public CCoinsViewCursor

FILE: src/txmempool.cpp
  function CheckInputsAndUpdateCoins (line 610) | static void CheckInputsAndUpdateCoins(const CTransaction& tx, CCoinsView...
  class DepthAndScoreComparator (line 757) | class DepthAndScoreComparator
  function TxMempoolInfo (line 799) | static TxMempoolInfo GetInfo(CTxMemPool::indexed_transaction_set::const_...
  function CTransactionRef (line 817) | CTransactionRef CTxMemPool::get(const uint256& hash) const
  function TxMempoolInfo (line 826) | TxMempoolInfo CTxMemPool::info(const uint256& hash) const
  function CFeeRate (line 983) | CFeeRate CTxMemPool::GetMinFee(size_t sizelimit) const {

FILE: src/txmempool.h
  function GetTxSize (line 35) | struct LockPoints
  type update_descendant_state (line 134) | struct update_descendant_state
  type update_ancestor_state (line 149) | struct update_ancestor_state
  type update_fee_delta (line 165) | struct update_fee_delta
  type update_lock_points (line 175) | struct update_lock_points
  function const (line 186) | struct mempoolentry_txid
  function class (line 204) | class CompareTxMemPoolEntryByDescendantScore
  function class (line 246) | class CompareTxMemPoolEntryByScore
  function class (line 260) | class CompareTxMemPoolEntryByEntryTime
  function class (line 273) | class CompareTxMemPoolEntryByAncestorFee
  type descendant_score (line 314) | struct descendant_score {}
  type entry_time (line 315) | struct entry_time {}
  type ancestor_score (line 316) | struct ancestor_score {}
  type TxMempoolInfo (line 323) | struct TxMempoolInfo
  function MemPoolRemovalReason (line 341) | enum class MemPoolRemovalReason {
  function class (line 698) | class CCoinsViewMemPool : public CCoinsViewBacked
  type txid_index (line 724) | struct txid_index {}
  type insertion_order (line 725) | struct insertion_order {}
  type DisconnectedBlockTransactions (line 727) | struct DisconnectedBlockTransactions {
  function DynamicMemoryUsage (line 759) | size_t DynamicMemoryUsage() const {
  function removeForBlock (line 770) | void removeForBlock(const std::vector<CTransactionRef>& vtx)

FILE: src/ui_interface.cpp
  function InitError (line 10) | bool InitError(const std::string& str)
  function InitWarning (line 16) | void InitWarning(const std::string& str)
  function AmountHighWarn (line 21) | std::string AmountHighWarn(const std::string& optname)
  function AmountErrMsg (line 26) | std::string AmountErrMsg(const char* const optname, const std::string& s...

FILE: src/ui_interface.h
  type ChangeType (line 19) | enum ChangeType
  function class (line 27) | class CClientUIInterface

FILE: src/uint256.h
  function SetNull (line 40) | void SetNull()
  function Compare (line 45) | inline int Compare(const base_blob& other) const { return memcmp(data, o...
  function GetUint64 (line 81) | uint64_t GetUint64(int pos) const
  function class (line 122) | class uint256 : public base_blob<256> {
  function uint256 (line 142) | inline uint256 uint256S(const char *str)
  function uint256 (line 152) | inline uint256 uint256S(const std::string& str)

FILE: src/undo.h
  function class (line 21) | class TxInUndoSerializer
  function explicit (line 36) | explicit TxInUndoSerializer(const Coin* coin) : txout(coin) {}
  function class (line 39) | class TxInUndoDeserializer
  function class (line 67) | class CTxUndo

FILE: src/univalue/include/univalue.h
  function class (line 20) | class UniValue {
  function setInt (line 60) | bool setInt(int val_) { return setInt((int64_t)val_); }
  type VType (line 66) | enum VType
  function UniValue (line 75) | const UniValue& operator[](const std::string& key) const;
  function push_back (line 89) | bool push_back(const std::string& val_) {
  function push_back (line 93) | bool push_back(const char *val_) {
  function push_back (line 97) | bool push_back(uint64_t val_) {
  function push_back (line 101) | bool push_back(int64_t val_) {
  function push_back (line 105) | bool push_back(int val_) {
  function push_back (line 109) | bool push_back(double val_) {
  function pushKV (line 117) | bool pushKV(const std::string& key, const std::string& val_) {
  function pushKV (line 121) | bool pushKV(const std::string& key, const char *val_) {
  function pushKV (line 125) | bool pushKV(const std::string& key, int64_t val_) {
  function pushKV (line 129) | bool pushKV(const std::string& key, uint64_t val_) {
  function pushKV (line 133) | bool pushKV(const std::string& key, int val_) {
  function pushKV (line 137) | bool pushKV(const std::string& key, double val_) {
  function read (line 147) | bool read(const char *raw) { return read(raw, strlen(raw)); }
  function read (line 148) | bool read(const std::string& rawStr) {
  function push_back (line 176) | bool push_back(std::pair<std::string,UniValue> pear) {
  type jtokentype (line 246) | enum jtokentype {
  type jtokentype (line 262) | enum jtokentype
  function jsonTokenIsValue (line 266) | static inline bool jsonTokenIsValue(enum jtokentype jtt)
  function json_isspace (line 283) | static inline bool json_isspace(int ch)

FILE: src/univalue/lib/univalue.cpp
  function validNumStr (line 40) | static bool validNumStr(const string& s)
  function UniValue (line 199) | const UniValue& UniValue::operator[](const std::string& key) const
  function UniValue (line 211) | const UniValue& UniValue::operator[](size_t index) const
  function UniValue (line 236) | const UniValue& find_value(const UniValue& obj, const std::string& name)

FILE: src/univalue/lib/univalue_get.cpp
  function ParsePrechecks (line 19) | static bool ParsePrechecks(const std::string& str)
  function ParseInt32 (line 30) | bool ParseInt32(const std::string& str, int32_t *out)
  function ParseInt64 (line 46) | bool ParseInt64(const std::string& str, int64_t *out)
  function ParseDouble (line 61) | bool ParseDouble(const std::string& str, double *out)
  function UniValue (line 134) | const UniValue& UniValue::get_obj() const
  function UniValue (line 141) | const UniValue& UniValue::get_array() const

FILE: src/univalue/lib/univalue_read.cpp
  function json_isdigit (line 13) | static bool json_isdigit(int ch)
  function getJsonToken (line 45) | enum jtokentype getJsonToken(string& tokenVal, unsigned int& consumed,
  type expect_bits (line 241) | enum expect_bits {
  type jtokentype (line 262) | enum jtokentype
  type jtokentype (line 263) | enum jtokentype

FILE: src/univalue/lib/univalue_utffilter.h
  function class (line 13) | class JSONUTF8StringFilter

FILE: src/univalue/lib/univalue_write.cpp
  function string (line 13) | static string json_escape(const string& inS)
  function string (line 31) | string UniValue::write(unsigned int prettyIndent,
  function indentStr (line 65) | static void indentStr(unsigned int prettyIndent, unsigned int indentLeve...

FILE: src/univalue/test/no_nul.cpp
  function main (line 3) | int main (int argc, char *argv[])

FILE: src/univalue/test/object.cpp
  function BOOST_AUTO_TEST_CASE (line 38) | BOOST_AUTO_TEST_CASE(univalue_constructor)
  function BOOST_AUTO_TEST_CASE (line 86) | BOOST_AUTO_TEST_CASE(univalue_typecheck)
  function BOOST_AUTO_TEST_CASE (line 128) | BOOST_AUTO_TEST_CASE(univalue_set)
  function BOOST_AUTO_TEST_CASE (line 187) | BOOST_AUTO_TEST_CASE(univalue_array)
  function BOOST_AUTO_TEST_CASE (line 234) | BOOST_AUTO_TEST_CASE(univalue_object)
  function BOOST_AUTO_TEST_CASE (line 341) | BOOST_AUTO_TEST_CASE(univalue_readwrite)
  function main (line 386) | int main (int argc, char *argv[])

FILE: src/univalue/test/test_json.cpp
  function main (line 13) | int main (int argc, char *argv[])

FILE: src/univalue/test/unitester.cpp
  function rtrim (line 27) | static std::string rtrim(std::string s)
  function runtest (line 33) | static void runtest(string filename, const string& jdata)
  function runtest_file (line 57) | static void runtest_file(const char *filename_)
  function unescape_unicode_test (line 138) | void unescape_unicode_test()
  function main (line 160) | int main (int argc, char *argv[])

FILE: src/util.cpp
  function locking_callback (line 105) | void locking_callback(int mode, int i, const char* file, int line) NO_TH...
  class CInit (line 115) | class CInit
    method CInit (line 118) | CInit()
  function FileWriteStr (line 177) | static int FileWriteStr(const std::string &str, FILE *fp)
  function DebugPrintInit (line 182) | static void DebugPrintInit()
  function GetDebugLogPath (line 189) | fs::path GetDebugLogPath()
  function OpenDebugLog (line 199) | bool OpenDebugLog()
  type CLogCategoryDesc (line 225) | struct CLogCategoryDesc
  function GetLogCategory (line 260) | bool GetLogCategory(uint32_t *f, const std::string *str)
  function ListLogCategories (line 277) | std::string ListLogCategories()
  function ListActiveLogCategories (line 292) | std::vector<CLogCategoryActive> ListActiveLogCategories()
  function LogTimestampStr (line 312) | static std::string LogTimestampStr(const std::string &str, std::atomic_b...
  function LogPrintStr (line 340) | int LogPrintStr(const std::string &str)
  function LockDirectory (line 428) | bool LockDirectory(const fs::path& directory, const std::string lockfile...
  function ReleaseDirectoryLocks (line 457) | void ReleaseDirectoryLocks()
  function InterpretBool (line 464) | static bool InterpretBool(const std::string& strValue)
  function InterpretNegativeSetting (line 472) | static void InterpretNegativeSetting(std::string& strKey, std::string& s...
  function HelpMessageGroup (line 584) | std::string HelpMessageGroup(const std::string &message) {
  function HelpMessageOpt (line 588) | std::string HelpMessageOpt(const std::string &option, const std::string ...
  function FormatException (line 595) | static std::string FormatException(const std::exception* pex, const char...
  function PrintExceptionContinue (line 611) | void PrintExceptionContinue(const std::exception* pex, const char* pszTh...
  function GetDefaultDataDir (line 618) | fs::path GetDefaultDataDir()
  function ClearDatadirCache (line 680) | void ClearDatadirCache()
  function GetConfigFile (line 688) | fs::path GetConfigFile(const std::string& confPath)
  function GetPidFile (line 727) | fs::path GetPidFile()
  function CreatePidFile (line 734) | void CreatePidFile(const fs::path &path, pid_t pid)
  function RenameOver (line 745) | bool RenameOver(fs::path src, fs::path dest)
  function TryCreateDirectories (line 761) | bool TryCreateDirectories(const fs::path& p)
  function FileCommit (line 775) | void FileCommit(FILE *file)
  function TruncateFile (line 792) | bool TruncateFile(FILE *file, unsigned int length) {
  function RaiseFileDescriptorLimit (line 804) | int RaiseFileDescriptorLimit(int nMinFD) {
  function AllocateFileRange (line 827) | void AllocateFileRange(FILE *file, unsigned int offset, unsigned int len...
  function ShrinkDebugFile (line 869) | void ShrinkDebugFile()
  function GetSpecialFolderPath (line 898) | fs::path GetSpecialFolderPath(int nFolder, bool fCreate)
  function runCommand (line 912) | void runCommand(const std::string& strCommand)
  function RenameThread (line 920) | void RenameThread(const char* name)
  function SetupEnvironment (line 936) | void SetupEnvironment()
  function SetupNetworking (line 965) | bool SetupNetworking()
  function GetNumCores (line 977) | int GetNumCores()
  function CopyrightHolders (line 986) | std::string CopyrightHolders(const std::string& strPrefix)
  function GetStartupTime (line 1002) | int64_t GetStartupTime()

FILE: src/util.h
  function class (line 43) | class CTranslationInterface
  function std (line 69) | inline std::string _(const char* psz)
  type CLogCategoryActive (line 78) | struct CLogCategoryActive
  function namespace (line 84) | namespace BCLog {
  function LogAcceptCategory (line 112) | static inline bool LogAcceptCategory(uint32_t category)
  function string (line 130) | string FormatStringFromLogArgs(const char *fmt, const Args&... args) { r...
  function MarkUsed (line 132) | static inline void MarkUsed() {}
  function MarkUsed (line 133) | inline void MarkUsed(const T& t, const Args&... args)
  function IsSwitchChar (line 202) | inline bool IsSwitchChar(char c)
  function class (line 211) | class ArgsManager

FILE: src/utilmoneystr.cpp
  function FormatMoney (line 12) | std::string FormatMoney(const CAmount& n)
  function ParseMoney (line 34) | bool ParseMoney(const std::string& str, CAmount& nRet)
  function ParseMoney (line 39) | bool ParseMoney(const char* pszIn, CAmount& nRet)

FILE: src/utilstrencodings.cpp
  function SanitizeString (line 24) | std::string SanitizeString(const std::string& str, int rule)
  function HexDigit (line 53) | signed char HexDigit(char c)
  function IsHex (line 58) | bool IsHex(const std::string& str)
  function IsHexNumber (line 68) | bool IsHexNumber(const std::string& str)
  function ParseHex (line 81) | std::vector<unsigned char> ParseHex(const char* psz)
  function ParseHex (line 102) | std::vector<unsigned char> ParseHex(const std::string& str)
  function SplitHostPort (line 107) | void SplitHostPort(std::string in, int &portOut, std::string &hostOut) {
  function EncodeBase64 (line 126) | std::string EncodeBase64(const unsigned char* pch, size_t len)
  function EncodeBase64 (line 172) | std::string EncodeBase64(const std::string& str)
  function DecodeBase64 (line 177) | std::vector<unsigned char> DecodeBase64(const char* p, bool* pfInvalid)
  function DecodeBase64 (line 260) | std::string DecodeBase64(const std::string& str)
  function EncodeBase32 (line 266) | std::string EncodeBase32(const unsigned char* pch, size_t len)
  function EncodeBase32 (line 325) | std::string EncodeBase32(const std::string& str)
  function DecodeBase32 (line 330) | std::vector<unsigned char> DecodeBase32(const char* p, bool* pfInvalid)
  function DecodeBase32 (line 447) | std::string DecodeBase32(const std::string& str)
  function ParsePrechecks (line 453) | static bool ParsePrechecks(const std::string& str)
  function ParseInt32 (line 464) | bool ParseInt32(const std::string& str, int32_t *out)
  function ParseInt64 (line 480) | bool ParseInt64(const std::string& str, int64_t *out)
  function ParseUInt32 (line 495) | bool ParseUInt32(const std::string& str, uint32_t *out)
  function ParseUInt64 (line 512) | bool ParseUInt64(const std::string& str, uint64_t *out)
  function ParseDouble (line 529) | bool ParseDouble(const std::string& str, double *out)
  function FormatParagraph (line 543) | std::string FormatParagraph(const std::string& in, size_t width, size_t ...
  function i64tostr (line 584) | std::string i64tostr(int64_t n)
  function itostr (line 589) | std::string itostr(int n)
  function atoi64 (line 594) | int64_t atoi64(const char* psz)
  function atoi64 (line 603) | int64_t atoi64(const std::string& str)
  function atoi (line 612) | int atoi(const std::string& str)
  function ProcessMantissaDigit (line 628) | static inline bool ProcessMantissaDigit(char ch, int64_t &mantissa, int ...
  function ParseFixedPoint (line 644) | bool ParseFixedPoint(const std::string &val, int decimals, int64_t *amou...

FILE: src/utilstrencodings.h
  type SafeChars (line 23) | enum SafeChars

FILE: src/utiltime.cpp
  function GetTime (line 19) | int64_t GetTime()
  function SetMockTime (line 29) | void SetMockTime(int64_t nMockTimeIn)
  function GetMockTime (line 34) | int64_t GetMockTime()
  function GetTimeMillis (line 39) | int64_t GetTimeMillis()
  function GetTimeMicros (line 47) | int64_t GetTimeMicros()
  function GetSystemTimeInSeconds (line 55) | int64_t GetSystemTimeInSeconds()
  function MilliSleep (line 60) | void MilliSleep(int64_t n)
  function DateTimeStrFormat (line 78) | std::string DateTimeStrFormat(const char* pszFormat, int64_t nTime)

FILE: src/validation.cpp
  type CBlockIndexWorkComparator (line 63) | struct CBlockIndexWorkComparator
  type DisconnectResult (line 85) | enum DisconnectResult
  class ConnectTrace (line 92) | class ConnectTrace
    method ConnectTrace (line 2359) | explicit ConnectTrace(CTxMemPool &_pool) : blocksConnected(1), pool(_p...
    method BlockConnected (line 2367) | void BlockConnected(CBlockIndex* pindex, std::shared_ptr<const CBlock>...
    method NotifyEntryRemoved (line 2388) | void NotifyEntryRemoved(CTransactionRef txRemoved, MemPoolRemovalReaso...
  class CChainState (line 108) | class CChainState {
  function CBlockIndex (line 270) | CBlockIndex* FindForkInGlobalIndex(const CChain& chain, const CBlockLoca...
  type FlushStateMode (line 292) | enum FlushStateMode {
  function CheckFinalTx (line 306) | bool CheckFinalTx(const CTransaction &tx, int flags)
  function TestLockPointValidity (line 338) | bool TestLockPointValidity(const LockPoints* lp)
  function CheckSequenceLocks (line 356) | bool CheckSequenceLocks(const CTransaction &tx, int flags, LockPoints* l...
  function LimitMempoolSize (line 431) | static void LimitMempoolSize(CTxMemPool& pool, size_t limit, unsigned lo...
  function FormatStateMessage (line 444) | std::string FormatStateMessage(const CValidationState &state)
  function IsCurrentForFeeEstimation (line 452) | static bool IsCurrentForFeeEstimation()
  function UpdateMempoolForReorg (line 477) | void UpdateMempoolForReorg(DisconnectedBlockTransactions &disconnectpool...
  function CheckInputsFromMempoolAndCache (line 518) | static bool CheckInputsFromMempoolAndCache(const CTransaction& tx, CVali...
  function AcceptToMemoryPoolWorker (line 552) | static bool AcceptToMemoryPoolWorker(const CChainParams& chainparams, CT...
  function AcceptToMemoryPoolWithTime (line 989) | static bool AcceptToMemoryPoolWithTime(const CChainParams& chainparams, ...
  function AcceptToMemoryPool (line 1005) | bool AcceptToMemoryPool(CTxMemPool& pool, CValidationState &state, const...
  function GetTransaction (line 1017) | bool GetTransaction(const uint256& hash, CTransactionRef& txOut, const C...
  function WriteBlockToDisk (line 1086) | static bool WriteBlockToDisk(const CBlock& block, CDiskBlockPos& pos, co...
  function ReadBlockFromDisk (line 1107) | bool ReadBlockFromDisk(CBlock& block, const CDiskBlockPos& pos, const Co...
  function ReadBlockFromDisk (line 1131) | bool ReadBlockFromDisk(CBlock& block, const CBlockIndex* pindex, const C...
  function CAmount (line 1147) | CAmount GetBlockSubsidy(int nHeight, const Consensus::Params& consensusP...
  function IsInitialBlockDownload (line 1218) | bool IsInitialBlockDownload()
  function AlertNotify (line 1244) | static void AlertNotify(const std::string& strMessage)
  function CheckForkWarningConditions (line 1261) | static void CheckForkWarningConditions()
  function CheckForkWarningConditionsOnNewFork (line 1302) | static void CheckForkWarningConditionsOnNewFork(CBlockIndex* pindexNewFo...
  function InvalidChainFound (line 1335) | void static InvalidChainFound(CBlockIndex* pindexNew)
  function UpdateCoins (line 1362) | void UpdateCoins(const CTransaction& tx, CCoinsViewCache& inputs, CTxUnd...
  function UpdateCoins (line 1377) | void UpdateCoins(const CTransaction& tx, CCoinsViewCache& inputs, int nH...
  function GetSpendHeight (line 1389) | int GetSpendHeight(const CCoinsViewCache& inputs)
  function InitScriptExecutionCache (line 1400) | void InitScriptExecutionCache() {
  function CheckInputs (line 1423) | bool CheckInputs(const CTransaction& tx, CValidationState &state, const ...
  function UndoWriteToDisk (line 1508) | bool UndoWriteToDisk(const CBlockUndo& blockundo, CDiskBlockPos& pos, co...
  function UndoReadFromDisk (line 1535) | static bool UndoReadFromDisk(CBlockUndo& blockundo, const CBlockIndex *p...
  function AbortNode (line 1567) | bool AbortNode(const std::string& strMessage, const std::string& userMes...
  function AbortNode (line 1578) | bool AbortNode(CValidationState& state, const std::string& strMessage, c...
  function ApplyTxInUndo (line 1593) | int ApplyTxInUndo(Coin&& undo, CCoinsViewCache& view, const COutPoint& out)
  function DisconnectResult (line 1622) | DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const...
  function FlushBlockFile (line 1679) | void static FlushBlockFile(bool fFinalize = false)
  function WriteUndoDataForBlock (line 1704) | static bool WriteUndoDataForBlock(const CBlockUndo& blockundo, CValidati...
  function WriteTxIndexDataForBlock (line 1723) | static bool WriteTxIndexDataForBlock(const CBlock& block, CValidationSta...
  function ThreadScriptCheck (line 1745) | void ThreadScriptCheck() {
  function ComputeBlockVersion (line 1753) | int32_t ComputeBlockVersion(const CBlockIndex* pindexPrev, const Consens...
  class WarningBitsConditionChecker (line 1771) | class WarningBitsConditionChecker : public AbstractThresholdConditionChe...
    method WarningBitsConditionChecker (line 1777) | explicit WarningBitsConditionChecker(int bitIn) : bit(bitIn) {}
    method BeginTime (line 1779) | int64_t BeginTime(const Consensus::Params& params) const override { re...
    method EndTime (line 1780) | int64_t EndTime(const Consensus::Params& params) const override { retu...
    method Period (line 1781) | int Period(const Consensus::Params& params) const override { return pa...
    method Threshold (line 1782) | int Threshold(const Consensus::Params& params) const override { return...
    method Condition (line 1784) | bool Condition(const CBlockIndex* pindex, const Consensus::Params& par...
  function GetBlockScriptFlags (line 1795) | static unsigned int GetBlockScriptFlags(const CBlockIndex* pindex, const...
  function FlushStateToDisk (line 2082) | bool static FlushStateToDisk(const CChainParams& chainparams, CValidatio...
  function FlushStateToDisk (line 2190) | void FlushStateToDisk() {
  function PruneAndFlush (line 2196) | void PruneAndFlush() {
  function DoWarning (line 2203) | static void DoWarning(const std::string& strWarning)
  function UpdateTip (line 2214) | void static UpdateTip(const CBlockIndex *pindexNew, const CChainParams& ...
  type PerBlockConnectTrace (line 2331) | struct PerBlockConnectTrace {
    method PerBlockConnectTrace (line 2335) | PerBlockConnectTrace() : conflictedTxs(std::make_shared<std::vector<CT...
  class ConnectTrace (line 2353) | class ConnectTrace {
    method ConnectTrace (line 2359) | explicit ConnectTrace(CTxMemPool &_pool) : blocksConnected(1), pool(_p...
    method BlockConnected (line 2367) | void BlockConnected(CBlockIndex* pindex, std::shared_ptr<const CBlock>...
    method NotifyEntryRemoved (line 2388) | void NotifyEntryRemoved(CTransactionRef txRemoved, MemPoolRemovalReaso...
  function CBlockIndex (line 2461) | CBlockIndex* CChainState::FindMostWorkChain() {
  function NotifyHeaderTip (line 2613) | static bool NotifyHeaderTip() {
  function ActivateBestChain (line 2737) | bool ActivateBestChain(CValidationState &state, const CChainParams& chai...
  function PreciousBlock (line 2769) | bool PreciousBlock(CValidationState& state, const CChainParams& params, ...
  function InvalidateBlock (line 2832) | bool InvalidateBlock(CValidationState& state, const CChainParams& chainp...
  function ResetBlockFailureFlags (line 2870) | bool ResetBlockFailureFlags(CBlockIndex *pindex) {
  function CBlockIndex (line 2874) | CBlockIndex* CChainState::AddToBlockIndex(const CBlockHeader& block)
  function FindBlockPos (line 2957) | static bool FindBlockPos(CDiskBlockPos &pos, unsigned int nAddSize, unsi...
  function FindUndoPos (line 3014) | static bool FindUndoPos(CValidationState &state, int nFile, CDiskBlockPo...
  function CheckBlockHeader (line 3045) | static bool CheckBlockHeader(const CBlockHeader& block, CValidationState...
  function CheckBlock (line 3061) | bool CheckBlock(const CBlock& block, CValidationState& state, const Cons...
  function IsWitnessEnabled (line 3125) | bool IsWitnessEnabled(const CBlockIndex* pindexPrev, const Consensus::Pa...
  function GetWitnessCommitmentIndex (line 3133) | static int GetWitnessCommitmentIndex(const CBlock& block)
  function UpdateUncommittedBlockStructures (line 3146) | void UpdateUncommittedBlockStructures(CBlock& block, const CBlockIndex* ...
  function GenerateCoinbaseCommitment (line 3158) | std::vector<unsigned char> GenerateCoinbaseCommitment(CBlock& block, con...
  function ContextualCheckBlockHeader (line 3196) | static bool ContextualCheckBlockHeader(const CBlockHeader& block, CValid...
  function ContextualCheckBlock (line 3246) | static bool ContextualCheckBlock(const CBlock& block, CValidationState& ...
  function ProcessNewBlockHeaders (line 3389) | bool ProcessNewBlockHeaders(const std::vector<CBlockHeader>& headers, CV...
  function CDiskBlockPos (line 3415) | static CDiskBlockPos SaveBlockToDisk(const CBlock& block, int nHeight, c...
  function ProcessNewBlock (line 3515) | bool ProcessNewBlock(const CChainParams& chainparams, const std::shared_...
  function TestBlockValidity (line 3568) | bool TestBlockValidity(CValidationState& state, const CChainParams& chai...
  function CalculateCurrentUsage (line 3596) | uint64_t CalculateCurrentUsage()
  function PruneOneBlockFile (line 3608) | void PruneOneBlockFile(const int fileNumber)
  function UnlinkPrunedFiles (line 3642) | void UnlinkPrunedFiles(const std::set<int>& setFilesToPrune)
  function FindFilesToPruneManual (line 3653) | static void FindFilesToPruneManual(std::set<int>& setFilesToPrune, int n...
  function PruneBlockFilesManual (line 3675) | void PruneBlockFilesManual(int nManualPruneHeight)
  function FindFilesToPrune (line 3697) | static void FindFilesToPrune(std::set<int>& setFilesToPrune, uint64_t nP...
  function CheckDiskSpace (line 3744) | bool CheckDiskSpace(uint64_t nAdditionalBytes)
  function FILE (line 3755) | static FILE* OpenDiskFile(const CDiskBlockPos &pos, const char *prefix, ...
  function FILE (line 3778) | FILE* OpenBlockFile(const CDiskBlockPos &pos, bool fReadOnly) {
  function FILE (line 3783) | static FILE* OpenUndoFile(const CDiskBlockPos &pos, bool fReadOnly) {
  function GetBlockPosFilename (line 3787) | fs::path GetBlockPosFilename(const CDiskBlockPos &pos, const char *prefix)
  function CBlockIndex (line 3792) | CBlockIndex * CChainState::InsertBlockIndex(const uint256& hash)
  function LoadBlockIndexDB (line 3862) | bool static LoadBlockIndexDB(const CChainParams& chainparams)
  function LoadChainTip (line 3919) | bool LoadChainTip(const CChainParams& chainparams)
  function ReplayBlocks (line 4138) | bool ReplayBlocks(const CChainParams& params, CCoinsView* view) {
  function RewindBlockIndex (line 4228) | bool RewindBlockIndex(const CChainParams& params) {
  function UnloadBlockIndex (line 4255) | void UnloadBlockIndex()
  function LoadBlockIndex (line 4281) | bool LoadBlockIndex(const CChainParams& chainparams)
  function LoadGenesisBlock (line 4333) | bool LoadGenesisBlock(const CChainParams& chainparams)
  function LoadExternalBlockFile (line 4338) | bool LoadExternalBlockFile(const CChainParams& chainparams, FILE* fileIn...
  function CBlockFileInfo (line 4644) | CBlockFileInfo* GetBlockFileInfo(size_t n)
  function ThresholdState (line 4651) | ThresholdState VersionBitsTipState(const Consensus::Params& params, Cons...
  function BIP9Stats (line 4657) | BIP9Stats VersionBitsTipStatistics(const Consensus::Params& params, Cons...
  function VersionBitsTipStateSinceHeight (line 4663) | int VersionBitsTipStateSinceHeight(const Consensus::Params& params, Cons...
  function LoadMempool (line 4671) | bool LoadMempool(void)
  function DumpMempool (line 4747) | bool DumpMempool(void)
  function GuessVerificationProgress (line 4797) | double GuessVerificationProgress(const ChainTxData& data, const CBlockIn...
  class CMainCleanup (line 4814) | class CMainCleanup
    method CMainCleanup (line 4817) | CMainCleanup() {}

FILE: src/validation.h
  type ChainTxData (line 44) | struct ChainTxData
  type PrecomputedTransactionData (line 46) | struct PrecomputedTransactionData
  type LockPoints (line 47) | struct LockPoints
  type BlockHasher (line 162) | struct BlockHasher
  type std (line 171) | typedef std::unordered_map<uint256, CBlockIndex*, BlockHasher> BlockMap;
  function class (line 372) | class CScriptCheck
  function class (line 432) | class CVerifyDB {

FILE: src/validationinterface.cpp
  type MainSignalsInstance (line 22) | struct MainSignalsInstance {
    method MainSignalsInstance (line 38) | explicit MainSignalsInstance(CScheduler *pscheduler) : m_schedulerClie...
  function CMainSignals (line 71) | CMainSignals& GetMainSignals()
  function RegisterValidationInterface (line 76) | void RegisterValidationInterface(CValidationInterface* pwalletIn) {
  function UnregisterValidationInterface (line 88) | void UnregisterValidationInterface(CValidationInterface* pwalletIn) {
  function UnregisterAllValidationInterfaces (line 100) | void UnregisterAllValidationInterfaces() {
  function CallFunctionInValidationInterfaceQueue (line 115) | void CallFunctionInValidationInterfaceQueue(std::function<void ()> func) {
  function SyncWithValidationInterfaceQueue (line 119) | void SyncWithValidationInterfaceQueue() {

FILE: src/validationinterface.h
  type CBlockLocator (line 16) | struct CBlockLocator
  type class (line 25) | enum class
  function class (line 56) | class CValidationInterface {
  type MainSignalsInstance (line 122) | struct MainSignalsInstance
  function class (line 123) | class CMainSignals {

FILE: src/versionbits.cpp
  type VBDeploymentInfo (line 8) | struct VBDeploymentInfo
  function ThresholdState (line 23) | ThresholdState AbstractThresholdConditionChecker::GetStateFor(const CBlo...
  function BIP9Stats (line 113) | BIP9Stats AbstractThresholdConditionChecker::GetStateStatisticsFor(const...
  class VersionBitsConditionChecker (line 182) | class VersionBitsConditionChecker : public AbstractThresholdConditionChe...
    method BeginTime (line 187) | int64_t BeginTime(const Consensus::Params& params) const override { re...
    method EndTime (line 188) | int64_t EndTime(const Consensus::Params& params) const override { retu...
    method Period (line 189) | int Period(const Consensus::Params& params) const override { return pa...
    method Threshold (line 190) | int Threshold(const Consensus::Params& params) const override { return...
    method Condition (line 192) | bool Condition(const CBlockIndex* pindex, const Consensus::Params& par...
    method VersionBitsConditionChecker (line 198) | explicit VersionBitsConditionChecker(Consensus::DeploymentPos id_) : i...
    method Mask (line 199) | uint32_t Mask(const Consensus::Params& params) const { return ((uint32...
  function ThresholdState (line 204) | ThresholdState VersionBitsState(const CBlockIndex* pindexPrev, const Con...
  function BIP9Stats (line 209) | BIP9Stats VersionBitsStatistics(const CBlockIndex* pindexPrev, const Con...
  function VersionBitsStateSinceHeight (line 214) | int VersionBitsStateSinceHeight(const CBlockIndex* pindexPrev, const Con...
  function VersionBitsMask (line 219) | uint32_t VersionBitsMask(const Consensus::Params& params, Consensus::Dep...

FILE: src/versionbits.h
  type ThresholdState (line 20) | enum ThresholdState {
  type std (line 31) | typedef std::map<const CBlockIndex*, ThresholdState> ThresholdConditionC...
  type VBDeploymentInfo (line 33) | struct VBDeploymentInfo {
  type BIP9Stats (line 40) | struct BIP9Stats {
  type VBDeploymentInfo (line 48) | struct VBDeploymentInfo
  function class (line 53) | class AbstractThresholdConditionChecker {
  type VersionBitsCache (line 68) | struct VersionBitsCache

FILE: src/wallet/coincontrol.h
  function class (line 16) | class CCoinControl

FILE: src/wallet/crypter.cpp
  function EncryptSecret (line 111) | static bool EncryptSecret(const CKeyingMaterial& vMasterKey, const CKeyi...
  function DecryptSecret (line 121) | static bool DecryptSecret(const CKeyingMaterial& vMasterKey, const std::...
  function DecryptKey (line 131) | static bool DecryptKey(const CKeyingMaterial& vMasterKey, const std::vec...

FILE: src/wallet/crypter.h
  function class (line 34) | class CMasterKey
  type std (line 68) | typedef std::vector<unsigned char, secure_allocator<unsigned char> > CKe...
  function namespace (line 70) | namespace wallet_crypto
  function class (line 76) | class CCrypter
  function class (line 115) | class CCryptoKeyStore : public CBasicKeyStore

FILE: src/wallet/db.cpp
  function CheckUniqueFileid (line 33) | void CheckUniqueFileid(const CDBEnv& env, const std::string& filename, D...

FILE: src/wallet/db.h
  function class (line 27) | class CDBEnv
  function class (line 94) | class CWalletDBWrapper
  function class (line 146) | class CDB
  function TxnCommit (line 340) | bool TxnCommit()
  function TxnAbort (line 349) | bool TxnAbort()
  function ReadVersion (line 358) | bool ReadVersion(int& nVersion)
  function WriteVersion (line 364) | bool WriteVersion(int nVersion)

FILE: src/wallet/feebumper.cpp
  function CalculateMaximumSignedTxSize (line 26) | static int64_t CalculateMaximumSignedTxSize(const CTransaction &tx, cons...
  function PreconditionChecks (line 48) | static feebumper::Result PreconditionChecks(const CWallet* wallet, const...
  type feebumper (line 71) | namespace feebumper {
    function TransactionCanBeBumped (line 73) | bool TransactionCanBeBumped(CWallet* wallet, const uint256& txid)
    function Result (line 80) | Result CreateTransaction(const CWallet* wallet, const uint256& txid, c...
    function SignTransaction (line 234) | bool SignTransaction(CWallet* wallet, CMutableTransaction& mtx) {
    function Result (line 239) | Result CommitTransaction(CWallet* wallet, const uint256& txid, CMutabl...

FILE: src/wallet/feebumper.h
  type class (line 14) | enum class
  function Result (line 18) | enum class Result

FILE: src/wallet/fees.cpp
  function CAmount (line 16) | CAmount GetRequiredFee(unsigned int nTxBytes)
  function CAmount (line 22) | CAmount GetMinimumFee(unsigned int nTxBytes, const CCoinControl& coin_co...
  function CFeeRate (line 80) | CFeeRate GetDiscardRate(const CBlockPolicyEstimator& estimator)

FILE: src/wallet/fees.h
  type FeeCalculation (line 15) | struct FeeCalculation

FILE: src/wallet/init.cpp
  function GetWalletHelpString (line 16) | std::string GetWalletHelpString(bool showDebug)
  function WalletParameterInteraction (line 58) | bool WalletParameterInteraction()
  function RegisterWalletRPC (line 195) | void RegisterWalletRPC(CRPCTable &t)
  function VerifyWallets (line 204) | bool VerifyWallets()
  function OpenWallets (line 275) | bool OpenWallets()
  function StartWallets (line 293) | void StartWallets(CScheduler& scheduler) {
  function FlushWallets (line 299) | void FlushWallets() {
  function StopWallets (line 305) | void StopWallets() {
  function CloseWallets (line 311) | void CloseWallets() {

FILE: src/wallet/rpcdump.cpp
  function EncodeDumpTime (line 31) | std::string static EncodeDumpTime(int64_t nTime) {
  function DecodeDumpTime (line 35) | int64_t static DecodeDumpTime(const std::string &str) {
  function EncodeDumpString (line 48) | std::string static EncodeDumpString(const std::string &str) {
  function DecodeDumpString (line 60) | std::string DecodeDumpString(const std::string &str) {
  function GetWalletAddressesForKey (line 74) | bool GetWalletAddressesForKey(CWallet * const pwallet, const CKeyID &key...
  function UniValue (line 96) | UniValue importprivkey(const JSONRPCRequest& request)
  function UniValue (line 190) | UniValue abortrescan(const JSONRPCRequest& request)
  function ImportScript (line 217) | void ImportScript(CWallet* const pwallet, const CScript& script, const s...
  function ImportAddress (line 242) | void ImportAddress(CWallet* const pwallet, const CTxDestination& dest, c...
  function UniValue (line 251) | UniValue importaddress(const JSONRPCRequest& request)
  function UniValue (line 329) | UniValue importprunedfunds(const JSONRPCRequest& request)
  function UniValue (line 390) | UniValue removeprunedfunds(const JSONRPCRequest& request)
  function UniValue (line 428) | UniValue importpubkey(const JSONRPCRequest& request)
  function UniValue (line 498) | UniValue importwallet(const JSONRPCRequest& request)
  function UniValue (line 623) | UniValue dumpprivkey(const JSONRPCRequest& request)
  function UniValue (line 666) | UniValue dumpwallet(const JSONRPCRequest& request)
  function UniValue (line 799) | UniValue ProcessImport(CWallet * const pwallet, const UniValue& data, co...
  function GetImportTimestamp (line 1112) | int64_t GetImportTimestamp(const UniValue& data, int64_t now)
  function UniValue (line 1126) | UniValue importmulti(const JSONRPCRequest& mainRequest)

FILE: src/wallet/rpcwallet.cpp
  function CWallet (line 40) | CWallet *GetWalletForJSONRPCRequest(const JSONRPCRequest& request)
  function HelpRequiringPassphrase (line 55) | std::string HelpRequiringPassphrase(CWallet * const pwallet)
  function EnsureWalletIsAvailable (line 62) | bool EnsureWalletIsAvailable(CWallet * const pwallet, bool avoidException)
  function EnsureWalletIsUnlocked (line 79) | void EnsureWalletIsUnlocked(CWallet * const pwallet)
  function WalletTxToJSON (line 86) | void WalletTxToJSON(const CWalletTx& wtx, UniValue& entry)
  function AccountFromValue (line 125) | std::string AccountFromValue(const UniValue& value)
  function UniValue (line 133) | UniValue getnewaddress(const JSONRPCRequest& request)
  function CTxDestination (line 189) | CTxDestination GetAccountDestination(CWallet* const pwallet, std::string...
  function UniValue (line 199) | UniValue getaccountaddress(const JSONRPCRequest& request)
  function UniValue (line 233) | UniValue getrawchangeaddress(const JSONRPCRequest& request)
  function UniValue (line 282) | UniValue setaccount(const JSONRPCRequest& request)
  function UniValue (line 330) | UniValue getaccount(const JSONRPCRequest& request)
  function UniValue (line 366) | UniValue getaddressesbyaccount(const JSONRPCRequest& request)
  function SendMoney (line 405) | static void SendMoney(CWallet * const pwallet, const CTxDestination &add...
  function UniValue (line 443) | UniValue sendtoaddress(const JSONRPCRequest& request)
  function UniValue (line 533) | UniValue listaddressgroupings(const JSONRPCRequest& request)
  function UniValue (line 592) | UniValue signmessage(const JSONRPCRequest& request)
  function UniValue (line 653) | UniValue getreceivedbyaddress(const JSONRPCRequest& request)
  function UniValue (line 720) | UniValue getreceivedbyaccount(const JSONRPCRequest& request)
  function UniValue (line 785) | UniValue getbalance(const JSONRPCRequest& request)
  function UniValue (line 865) | UniValue getunconfirmedbalance(const JSONRPCRequest &request)
  function UniValue (line 889) | UniValue movecmd(const JSONRPCRequest& request)
  function UniValue (line 940) | UniValue sendfrom(const JSONRPCRequest& request)
  function UniValue (line 1017) | UniValue sendmany(const JSONRPCRequest& request)
  function UniValue (line 1165) | UniValue addmultisigaddress(const JSONRPCRequest& request)
  class Witnessifier (line 1252) | class Witnessifier : public boost::static_visitor<bool>
    method Witnessifier (line 1259) | explicit Witnessifier(CWallet *_pwallet) : pwallet(_pwallet), already_...
  function UniValue (line 1310) | UniValue addwitnessaddress(const JSONRPCRequest& request)
  type tallyitem (line 1382) | struct tallyitem
    method tallyitem (line 1388) | tallyitem()
  function UniValue (line 1396) | UniValue ListReceived(CWallet * const pwallet, const UniValue& params, b...
  function UniValue (line 1514) | UniValue listreceivedbyaddress(const JSONRPCRequest& request)
  function UniValue (line 1564) | UniValue listreceivedbyaccount(const JSONRPCRequest& request)
  function MaybePushAddress (line 1609) | static void MaybePushAddress(UniValue & entry, const CTxDestination &dest)
  function ListTransactions (line 1627) | void ListTransactions(CWallet* const pwallet, const CWalletTx& wtx, cons...
  function AcentryToJSON (line 1707) | void AcentryToJSON(const CAccountingEntry& acentry, const std::string& s...
  function UniValue (line 1724) | UniValue listtransactions(const JSONRPCRequest& request)
  function UniValue (line 1860) | UniValue listaccounts(const JSONRPCRequest& request)
  function UniValue (line 1948) | UniValue listsinceblock(const JSONRPCRequest& request)
  function UniValue (line 2090) | UniValue gettransaction(const JSONRPCRequest& request)
  function UniValue (line 2186) | UniValue abandontransaction(const JSONRPCRequest& request)
  function UniValue (line 2231) | UniValue backupwallet(const JSONRPCRequest& request)
  function UniValue (line 2264) | UniValue keypoolrefill(const JSONRPCRequest& request)
  function LockWallet (line 2304) | static void LockWallet(CWallet* pWallet)
  function UniValue (line 2311) | UniValue walletpassphrase(const JSONRPCRequest& request)
  function UniValue (line 2386) | UniValue walletpassphrasechange(const JSONRPCRequest& request)
  function UniValue (line 2437) | UniValue walletlock(const JSONRPCRequest& request)
  function UniValue (line 2477) | UniValue encryptwallet(const JSONRPCRequest& request)
  function UniValue (line 2539) | UniValue lockunspent(const JSONRPCRequest& request)
  function UniValue (line 2666) | UniValue listlockunspent(const JSONRPCRequest& request)
  function UniValue (line 2718) | UniValue settxfee(const JSONRPCRequest& request)
  function UniValue (line 2747) | UniValue getwalletinfo(const JSONRPCRequest& request)
  function UniValue (line 2810) | UniValue listwallets(const JSONRPCRequest& request)
  function UniValue (line 2843) | UniValue resendwallettransactions(const JSONRPCRequest& request)
  function UniValue (line 2878) | UniValue listunspent(const JSONRPCRequest& request)
  function UniValue (line 3042) | UniValue fundrawtransaction(const JSONRPCRequest& request)
  function UniValue (line 3244) | UniValue bumpfee(const JSONRPCRequest& request)
  function UniValue (line 3393) | UniValue generate(const JSONRPCRequest& request)
  function UniValue (line 3438) | UniValue rescanblockchain(const JSONRPCRequest& request)
  function RegisterWalletRPCCommands (line 3593) | void RegisterWalletRPCCommands(CRPCTable &t)

FILE: src/wallet/test/accounting_tests.cpp
  function GetResults (line 15) | static void
  function BOOST_AUTO_TEST_CASE (line 29) | BOOST_AUTO_TEST_CASE(acc_orderupgrade)

FILE: src/wallet/test/crypto_tests.cpp
  class TestCrypter (line 15) | class TestCrypter
    method TestPassphraseSingle (line 18) | static void TestPassphraseSingle(const std::vector<unsigned char>& vch...
    method TestPassphrase (line 33) | static void TestPassphrase(const std::vector<unsigned char>& vchSalt, ...
    method TestDecrypt (line 42) | static void TestDecrypt(const CCrypter& crypt, const std::vector<unsig...
    method TestEncryptSingle (line 51) | static void TestEncryptSingle(const CCrypter& crypt, const CKeyingMate...
    method TestEncrypt (line 64) | static void TestEncrypt(const CCrypter& crypt, const std::vector<unsig...
  function BOOST_AUTO_TEST_CASE (line 74) | BOOST_AUTO_TEST_CASE(passphrase) {
  function BOOST_AUTO_TEST_CASE (line 90) | BOOST_AUTO_TEST_CASE(encrypt) {
  function BOOST_AUTO_TEST_CASE (line 105) | BOOST_AUTO_TEST_CASE(decrypt) {

FILE: src/wallet/test/wallet_test_fixture.h
  function TestingSetup (line 16) | struct WalletTestingSetup: public TestingSetup {

FILE: src/wallet/test/wallet_tests.cpp
  function add_coin (line 43) | static void add_coin(const CAmount& nValue, int nAge = 6*24, bool fIsFro...
  function empty_wallet (line 66) | static void empty_wallet(void)
  function equal_sets (line 72) | static bool equal_sets(CoinSet a, CoinSet b)
  function BOOST_AUTO_TEST_CASE (line 78) | BOOST_AUTO_TEST_CASE(coin_selection_tests)
  function BOOST_AUTO_TEST_CASE (line 345) | BOOST_AUTO_TEST_CASE(ApproximateBestSubset)
  function AddKey (line 366) | static void AddKey(CWallet& wallet, const CKey& key)
  function BOOST_FIXTURE_TEST_CASE (line 372) | BOOST_FIXTURE_TEST_CASE(rescan, TestChain100Setup)
  function BOOST_FIXTURE_TEST_CASE (line 453) | BOOST_FIXTURE_TEST_CASE(importwallet_rescan, TestChain100Setup)
  function BOOST_FIXTURE_TEST_CASE (line 518) | BOOST_FIXTURE_TEST_CASE(coin_mark_dirty_immature_credit, TestChain100Setup)
  function AddTx (line 537) | static int64_t AddTx(CWallet& wallet, uint32_t lockTime, int64_t mockTim...
  function BOOST_AUTO_TEST_CASE (line 564) | BOOST_AUTO_TEST_CASE(ComputeTimeSmart)
  function BOOST_AUTO_TEST_CASE (line 592) | BOOST_AUTO_TEST_CASE(LoadReceiveRequests)
  class ListCoinsTestingSetup (line 606) | class ListCoinsTestingSetup : public TestChain100Setup
    method ListCoinsTestingSetup (line 609) | ListCoinsTestingSetup()
    method CWalletTx (line 631) | CWalletTx& AddTx(CRecipient recipient)
  function BOOST_FIXTURE_TEST_CASE (line 658) | BOOST_FIXTURE_TEST_CASE(ListCoins, ListCoinsTestingSetup)

FILE: src/wallet/wallet.cpp
  type CompareValueOnly (line 72) | struct CompareValueOnly
  class CAffectedKeysVisitor (line 86) | class CAffectedKeysVisitor : public boost::static_visitor<void> {
    method CAffectedKeysVisitor (line 92) | CAffectedKeysVisitor(const CKeyStore &keystoreIn, std::vector<CKeyID> ...
    method Process (line 94) | void Process(const CScript &script) {
  function CWalletTx (line 137) | const CWalletTx* CWallet::GetWalletTx(const uint256& hash) const
  function CPubKey (line 146) | CPubKey CWallet::GenerateNewKey(CWalletDB &walletdb, bool internal)
  type WalletFeature (line 453) | enum WalletFeature
  function DBErrors (line 702) | DBErrors CWallet::ReorderTransactions()
  function isminetype (line 1302) | isminetype CWallet::IsMine(const CTxIn &txin) const
  function CAmount (line 1319) | CAmount CWallet::GetDebit(const CTxIn &txin, const isminefilter& filter)...
  function isminetype (line 1335) | isminetype CWallet::IsMine(const CTxOut& txout) const
  function CAmount (line 1340) | CAmount CWallet::GetCredit(const CTxOut& txout, const isminefilter& filt...
  function CAmount (line 1369) | CAmount CWallet::GetChange(const CTxOut& txout) const
  function CAmount (line 1389) | CAmount CWallet::GetDebit(const CTransaction& tx, const isminefilter& fi...
  function CAmount (line 1422) | CAmount CWallet::GetCredit(const CTransaction& tx, const isminefilter& f...
  function CAmount (line 1434) | CAmount CWallet::GetChange(const CTransaction& tx) const
  function CPubKey (line 1446) | CPubKey CWallet::GenerateNewHDMasterKey()
  function CBlockIndex (line 1612) | CBlockIndex* CWallet::ScanForWalletTransactions(CBlockIndex* pindexStart...
  function CAmount (line 1752) | CAmount CWalletTx::GetDebit(const isminefilter& filter) const
  function CAmount (line 1783) | CAmount CWalletTx::GetCredit(const isminefilter& filter) const
  function CAmount (line 1816) | CAmount CWalletTx::GetImmatureCredit(bool fUseCache) const
  function CAmount (line 1830) | CAmount CWalletTx::GetAvailableCredit(bool fUseCache) const
  function CAmount (line 1860) | CAmount CWalletTx::GetImmatureWatchOnlyCredit(const bool fUseCache) const
  function CAmount (line 1874) | CAmount CWalletTx::GetAvailableWatchOnlyCredit(const bool fUseCache) const
  function CAmount (line 1903) | CAmount CWalletTx::GetChange() const
  function CAmount (line 2016) | CAmount CWallet::GetBalance() const
  function CAmount (line 2032) | CAmount CWallet::GetUnconfirmedBalance() const
  function CAmount (line 2047) | CAmount CWallet::GetImmatureBalance() const
  function CAmount (line 2061) | CAmount CWallet::GetWatchOnlyBalance() const
  function CAmount (line 2077) | CAmount CWallet::GetUnconfirmedWatchOnlyBalance() const
  function CAmount (line 2092) | CAmount CWallet::GetImmatureWatchOnlyBalance() const
  function CAmount (line 2112) | CAmount CWallet::GetLegacyBalance(const isminefilter& filter, int minDep...
  function CAmount (line 2149) | CAmount CWallet::GetAvailableBalance(const CCoinControl* coinControl) const
  function CTxOut (line 2321) | const CTxOut& CWallet::FindNonChangeParentOutput(const CTransaction& tx,...
  function ApproximateBestSubset (line 2338) | static void ApproximateBestSubset(const std::vector<CInputCoin>& vValue,...
  function OutputType (line 2637) | OutputType CWallet::TransactionChangeType(OutputType change_type, const ...
  function DBErrors (line 3094) | DBErrors CWallet::LoadWallet(bool& fFirstRunRet)
  function DBErrors (line 3124) | DBErrors CWallet::ZapSelectTx(std::vector<uint256>& vHashIn, std::vector...
  function DBErrors (line 3156) | DBErrors CWallet::ZapWalletTx(std::vector<CWalletTx>& vWtx)
  function GetOldestKeyTimeInPool (line 3424) | static int64_t GetOldestKeyTimeInPool(const std::set<int64_t>& setKeyPoo...
  function CWallet (line 3876) | CWallet* CWallet::CreateWalletFromFile(const std::string walletFile)
  function OutputType (line 4169) | OutputType ParseOutputType(const std::string& type, OutputType default_t...
  function CTxDestination (line 4211) | CTxDestination GetDestinationForKey(const CPubKey& key, OutputType type)
  function GetAllDestinationsForKey (line 4230) | std::vector<CTxDestination> GetAllDestinationsForKey(const CPubKey& key)
  function CTxDestination (line 4242) | CTxDestination CWallet::AddAndGetDestinationForScript(const CScript& scr...

FILE: src/wallet/wallet.h
  type CWallet (line 33) | typedef CWallet* CWalletRef;
  type FeeCalculation (line 83) | struct FeeCalculation
  type class (line 84) | enum class
  type WalletFeature (line 87) | enum WalletFeature
  type OutputType (line 103) | enum OutputType : int
  function class (line 119) | class CKeyPool
  function class (line 155) | class CAddressBookData
  type CRecipient (line 167) | struct CRecipient
  type std (line 174) | typedef std::map<std::string, std::string> mapValue_t;
  function ReadOrderPos (line 177) | static inline void ReadOrderPos(int64_t& nOrderPos, mapValue_t& mapValue)
  function WriteOrderPos (line 188) | static inline void WriteOrderPos(const int64_t& nOrderPos, mapValue_t& m...
  type COutputEntry (line 195) | struct COutputEntry
  function class (line 203) | class CMerkleTx
  function class (line 278) | class CWalletTx : public CMerkleTx
  function Init (line 364) | void Init(const CWallet* pwalletIn)
  function MarkDirty (line 440) | void MarkDirty()
  function BindWallet (line 453) | void BindWallet(CWallet *pwalletIn)
  function CAmount (line 466) | CAmount GetChange() const;
  function class (line 523) | class COutput
  function class (line 555) | class CWalletKey
  function class (line 585) | class CAccountingEntry
  type std (line 703) | typedef std::multimap<COutPoint, uint256> TxSpends;
  type std (line 789) | typedef std::map<unsigned int, CMasterKey> MasterKeyMap;
  function explicit (line 800) | explicit CWallet(std::unique_ptr<CWalletDBWrapper> dbw_in) : dbw(std::mo...
  function SetNull (line 811) | void SetNull()
  type std (line 832) | typedef std::pair<CWalletTx*, CAccountingEntry*> TxPair;
  type std (line 833) | typedef std::multimap<int64_t, TxPair > TxItems;
  function CanSupportFeature (line 846) | bool CanSupportFeature(enum WalletFeature wf) const { AssertLockHeld(cs_...
  function AbortRescan (line 882) | void AbortRescan() { fAbortRescan = true; }
  function IsAbortingRescan (line 883) | bool IsAbortingRescan() { return fAbortRescan; }
  function IsScanning (line 884) | bool IsScanning() { return fScanningWallet; }
  function LoadKey (line 895) | bool LoadKey(const CKey& key, const CPubKey &pubkey) { return CCryptoKey...
  function LoadMinVersion (line 900) | bool LoadMinVersion(int nVersion) { AssertLockHeld(cs_wallet); nWalletVe...
  function CAmount (line 960) | CAmount GetBalance() const;
  type WalletFeature (line 1055) | enum WalletFeature
  function GetVersion (line 1061) | int GetVersion() { LOCK(cs_wallet); return nWalletVersion; }
  function SetBroadcastTransactions (line 1097) | void SetBroadcastTransactions(bool broadcast) { fBroadcastTransactions =...
  function IsHDEnabled (line 1124) | bool IsHDEnabled() const;
  function class (line 1200) | class CAccount

FILE: src/wallet/walletdb.cpp
  function CAmount (line 169) | CAmount CWalletDB::GetAccountCreditDebit(const std::string& strAccount)
  class CWalletScanState (line 224) | class CWalletScanState {
    method CWalletScanState (line 235) | CWalletScanState() {
  function ReadKeyValue (line 243) | bool
  function DBErrors (line 521) | DBErrors CWalletDB::LoadWallet(CWallet* pwallet)
  function DBErrors (line 627) | DBErrors CWalletDB::FindWalletTx(std::vector<uint256>& vTxHash, std::vec...
  function DBErrors (line 686) | DBErrors CWalletDB::ZapSelectTx(std::vector<uint256>& vTxHashIn, std::ve...
  function DBErrors (line 724) | DBErrors CWalletDB::ZapWalletTx(std::vector<CWalletTx>& vWtx)
  function MaybeCompactWalletDB (line 741) | void MaybeCompactWalletDB()

FILE: src/wallet/walletdb.h
  type CBlockLocator (line 39) | struct CBlockLocator
  type DBErrors (line 49) | enum DBErrors
  function class (line 60) | class CHDChain
  function SetNull (line 84) | void SetNull()
  function class (line 93) | class CKeyMetadata
  function SetNull (line 127) | void SetNull()
  function class (line 141) | class CWalletDB

FILE: src/wallet/walletutil.cpp
  function GetWalletDir (line 7) | fs::path GetWalletDir()

FILE: src/warnings.cpp
  function SetMiscWarning (line 16) | void SetMiscWarning(const std::string& strWarning)
  function SetfLargeWorkForkFound (line 22) | void SetfLargeWorkForkFound(bool flag)
  function GetfLargeWorkForkFound (line 28) | bool GetfLargeWorkForkFound()
  function SetfLargeWorkInvalidChainFound (line 34) | void SetfLargeWorkInvalidChainFound(bool flag)
  function GetWarnings (line 40) | std::string GetWarnings(const std::string& strFor)

FILE: src/zmq/zmqabstractnotifier.h
  type CZMQAbstractNotifier (line 13) | typedef CZMQAbstractNotifier* (*CZMQNotifierFactory)();
  function class (line 15) | class CZMQAbstractNotifier

FILE: src/zmq/zmqnotificationinterface.cpp
  function zmqError (line 13) | void zmqError(const char *str)
  function CZMQNotificationInterface (line 32) | CZMQNotificationInterface* CZMQNotificationInterface::Create()

FILE: src/zmq/zmqpublishnotifier.cpp
  function zmq_send_multipart (line 21) | static int zmq_send_multipart(void *sock, const void* data, size_t size,...

FILE: src/zmq/zmqpublishnotifier.h
  function class (line 12) | class CZMQAbstractPublishNotifier : public CZMQAbstractNotifier
  function class (line 31) | class CZMQPublishHashBlockNotifier : public CZMQAbstractPublishNotifier
  function class (line 37) | class CZMQPublishHashTransactionNotifier : public CZMQAbstractPublishNot...
  function class (line 43) | class CZMQPublishRawBlockNotifier : public CZMQAbstractPublishNotifier
  function class (line 49) | class CZMQPublishRawTransactionNotifier : public CZMQAbstractPublishNoti...

FILE: test/functional/combine_logs.py
  function main (line 20) | def main():
  function read_logs (line 45) | def read_logs(tmp_dir):
  function get_log_events (line 60) | def get_log_events(source, logfile):
  function print_logs (line 88) | def print_logs(log_events, color=False, html=False):

FILE: test/functional/create_cache.py
  class CreateCache (line 14) | class CreateCache(BitcoinTestFramework):
    method set_test_params (line 17) | def set_test_params(self):
    method setup_network (line 21) | def setup_network(self):
    method run_test (line 24) | def run_test(self):

FILE: test/functional/example_test.py
  class BaseNode (line 37) | class BaseNode(P2PInterface):
    method __init__ (line 38) | def __init__(self):
    method on_block (line 53) | def on_block(self, message):
    method on_inv (line 60) | def on_inv(self, message):
  function custom_function (line 64) | def custom_function():
  class ExampleTest (line 72) | class ExampleTest(BitcoinTestFramework):
    method set_test_params (line 78) | def set_test_params(self):
    method setup_network (line 101) | def setup_network(self):
    method custom_method (line 123) | def custom_method(self):
    method run_test (line 132) | def run_test(self):

FILE: test/functional/feature_assumevalid.py
  class BaseNode (line 50) | class BaseNode(P2PInterface):
    method send_header_for_blocks (line 51) | def send_header_for_blocks(self, new_blocks):
  class AssumeValidTest (line 56) | class AssumeValidTest(BitcoinTestFramework):
    method set_test_params (line 57) | def set_test_params(self):
    method setup_network (line 61) | def setup_network(self):
    method send_blocks_until_disconnected (line 68) | def send_blocks_until_disconnected(self, p2p_conn):
    method assert_blockchain_height (line 79) | def assert_blockchain_height(self, node, height):
    method run_test (line 97) | def run_test(self):

FILE: test/functional/feature_bip68_sequence.py
  class BIP68Test (line 19) | class BIP68Test(BitcoinTestFramework):
    method set_test_params (line 20) | def set_test_params(self):
    method run_test (line 24) | def run_test(self):
    method test_disable_flag (line 53) | def test_disable_flag(self):
    method get_median_time_past (line 96) | def get_median_time_past(self, confirmations):
    method test_sequence_lock_confirmed_inputs (line 101) | def test_sequence_lock_confirmed_inputs(self):
    method test_sequence_lock_unconfirmed_inputs (line 193) | def test_sequence_lock_unconfirmed_inputs(self):
    method test_bip68_not_consensus (line 327) | def test_bip68_not_consensus(self):
    method activateCSV (line 371) | def activateCSV(self):
    method test_version2_relay (line 384) | def test_version2_relay(self):

FILE: test/functional/feature_bip9_softforks.py
  class BIP9SoftForksTest (line 30) | class BIP9SoftForksTest(ComparisonTestFramework):
    method set_test_params (line 31) | def set_test_params(self):
    method run_test (line 36) | def run_test(self):
    method create_transaction (line 42) | def create_transaction(self, node, coinbase, to_address, amount):
    method sign_transaction (line 53) | def sign_transaction(self, node, tx):
    method generate_blocks (line 60) | def generate_blocks(self, number, version, test_blocks = []):
    method get_bip9_status (line 72) | def get_bip9_status(self, key):
    method test_BIP (line 76) | def test_BIP(self, bipName, activated_version, invalidate, invalidateP...
    method get_tests (line 251) | def get_tests(self):
    method donothing (line 259) | def donothing(self, tx):
    method csv_invalidate (line 262) | def csv_invalidate(self, tx):
    method sequence_lock_invalidate (line 269) | def sequence_lock_invalidate(self, tx):
    method mtp_invalidate (line 276) | def mtp_invalidate(self, tx):

FILE: test/functional/feature_block.py
  class PreviousSpendableOutput (line 24) | class PreviousSpendableOutput():
    method __init__ (line 25) | def __init__(self, tx = CTransaction(), n = -1):
  class CBrokenBlock (line 31) | class CBrokenBlock(CBlock):
    method __init__ (line 32) | def __init__(self, header=None):
    method initialize (line 35) | def initialize(self, base_block):
    method serialize (line 39) | def serialize(self, with_witness=False):
    method normal_serialize (line 50) | def normal_serialize(self):
  class FullBlockTest (line 55) | class FullBlockTest(ComparisonTestFramework):
    method set_test_params (line 58) | def set_test_params(self):
    method add_options (line 68) | def add_options(self, parser):
    method run_test (line 72) | def run_test(self):
    method add_transactions_to_block (line 78) | def add_transactions_to_block(self, block, tx_list):
    method create_tx (line 83) | def create_tx(self, spend_tx, n, value, script=CScript([OP_TRUE, OP_DR...
    method sign_tx (line 89) | def sign_tx(self, tx, spend_tx, n):
    method create_and_sign_transaction (line 97) | def create_and_sign_transaction(self, spend_tx, n, value, script=CScri...
    method next_block (line 103) | def next_block(self, number, spend=None, additional_coinbase_value=0, ...
    method get_tests (line 133) | def get_tests(self):

FILE: test/functional/feature_cltv.py
  function cltv_invalidate (line 25) | def cltv_invalidate(tx):
  function cltv_validate (line 36) | def cltv_validate(node, tx, height):
  function create_transaction (line 52) | def create_transaction(node, coinbase, to_address, amount):
  class BIP65Test (line 62) | class BIP65Test(BitcoinTestFramework):
    method set_test_params (line 63) | def set_test_params(self):
    method run_test (line 68) | def run_test(self):

FILE: test/functional/feature_config_args.py
  class ConfArgsTest (line 12) | class ConfArgsTest(BitcoinTestFramework):
    method set_test_params (line 13) | def set_test_params(self):
    method run_test (line 17) | def run_test(self):

FILE: test/functional/feature_csv_activation.py
  function all_rlt_txs (line 85) | def all_rlt_txs(txarray):
  class BIP68_112_113Test (line 94) | class BIP68_112_113Test(ComparisonTestFramework):
    method set_test_params (line 95) | def set_test_params(self):
    method run_test (line 100) | def run_test(self):
    method send_generic_input_tx (line 106) | def send_generic_input_tx(self, node, coinbases):
    method create_transaction (line 110) | def create_transaction(self, node, txid, to_address, amount):
    method sign_transaction (line 119) | def sign_transaction(self, node, unsignedtx):
    method generate_blocks (line 127) | def generate_blocks(self, number, version, test_blocks = []):
    method create_test_block (line 136) | def create_test_block(self, txs, version = 536870912):
    method create_bip68txs (line 145) | def create_bip68txs(self, bip68inputs, txversion, locktime_delta = 0):
    method create_bip112special (line 166) | def create_bip112special(self, input, txversion):
    method create_bip112txs (line 173) | def create_bip112txs(self, bip112inputs, varyOP_CSV, txversion, lockti...
    method get_tests (line 202) | def get_tests(self):

FILE: test/functional/feature_dbcrash.py
  class ChainstateWriteCrashTest (line 45) | class ChainstateWriteCrashTest(BitcoinTestFramework):
    method set_test_params (line 46) | def set_test_params(self):
    method setup_network (line 65) | def setup_network(self):
    method restart_node (line 71) | def restart_node(self, node_index, expected_tip):
    method submit_block_catch_error (line 100) | def submit_block_catch_error(self, node_index, block):
    method sync_node3blocks (line 128) | def sync_node3blocks(self, block_hashes):
    method verify_utxo_hash (line 173) | def verify_utxo_hash(self):
    method generate_small_transactions (line 188) | def generate_small_transactions(self, node, count, utxo_list):
    method run_test (line 213) | def run_test(self):

FILE: test/functional/feature_dersig.py
  function unDERify (line 26) | def unDERify(tx):
  function create_transaction (line 40) | def create_transaction(node, coinbase, to_address, amount):
  class BIP66Test (line 50) | class BIP66Test(BitcoinTestFramework):
    method set_test_params (line 51) | def set_test_params(self):
    method run_test (line 56) | def run_test(self):

FILE: test/functional/feature_fee_estimation.py
  function small_txpuzzle_randfee (line 25) | def small_txpuzzle_randfee(from_node, conflist, unconflist, amount, min_...
  function split_inputs (line 66) | def split_inputs(from_node, txins, txouts, initial_split = False):
  function check_estimates (line 94) | def check_estimates(node, fees_seen, max_invalid, print_estimates = True):
  class EstimateFeeTest (line 143) | class EstimateFeeTest(BitcoinTestFramework):
    method set_test_params (line 144) | def set_test_params(self):
    method setup_network (line 147) | def setup_network(self):
    method transact_and_mine (line 164) | def transact_and_mine(self, numblocks, mining_node):
    method run_test (line 190) | def run_test(self):

FILE: test/functional/feature_help.py
  class HelpTest (line 11) | class HelpTest(BitcoinTestFramework):
    method set_test_params (line 12) | def set_test_params(self):
    method setup_network (line 16) | def setup_network(self):
    method run_test (line 20) | def run_test(self):

FILE: test/functional/feature_logging.py
  class LoggingTest (line 11) | class LoggingTest(BitcoinTestFramework):
    method set_test_params (line 12) | def set_test_params(self):
    method run_test (line 16) | def run_test(self):

FILE: test/functional/feature_maxuploadtarget.py
  class TestNode (line 20) | class TestNode(P2PInterface):
    method __init__ (line 21) | def __init__(self):
    method on_inv (line 25) | def on_inv(self, message):
    method on_block (line 28) | def on_block(self, message):
  class MaxUploadTest (line 32) | class MaxUploadTest(BitcoinTestFramework):
    method set_test_params (line 34) | def set_test_params(self):
    method run_test (line 42) | def run_test(self):

FILE: test/functional/feature_minchainwork.py
  class MinimumChainWorkTest (line 26) | class MinimumChainWorkTest(BitcoinTestFramework):
    method set_test_params (line 27) | def set_test_params(self):
    method setup_network (line 34) | def setup_network(self):
    method run_test (line 44) | def run_test(self):

FILE: test/functional/feature_notifications.py
  class NotificationsTest (line 11) | class NotificationsTest(BitcoinTestFramework):
    method set_test_params (line 12) | def set_test_params(self):
    method setup_network (line 16) | def setup_network(self):
    method run_test (line 30) | def run_test(self):

FILE: test/functional/feature_nulldummy.py
  function trueDummy (line 26) | def trueDummy(tx):
  class NULLDUMMYTest (line 38) | class NULLDUMMYTest(BitcoinTestFramework):
    method set_test_params (line 40) | def set_test_params(self):
    method run_test (line 47) | def run_test(self):
    method create_transaction (line 101) | def create_transaction(self, node, txid, to_address, amount):
    method block_submit (line 112) | def block_submit(self, node, txs, witness = False, accept = False):

FILE: test/functional/feature_proxy.py
  class ProxyTest (line 44) | class ProxyTest(BitcoinTestFramework):
    method set_test_params (line 45) | def set_test_params(self):
    method setup_nodes (line 48) | def setup_nodes(self):
    method node_test (line 92) | def node_test(self, node, proxies, auth, test_onion=True):
    method run_test (line 148) | def run_test(self):

FILE: test/functional/feature_pruning.py
  function calc_usage (line 24) | def calc_usage(blockdir):
  class PruneTest (line 27) | class PruneTest(BitcoinTestFramework):
    method set_test_params (line 28) | def set_test_params(self):
    method setup_network (line 44) | def setup_network(self):
    method setup_nodes (line 56) | def setup_nodes(self):
    method create_big_chain (line 60) | def create_big_chain(self):
    method test_height_min (line 71) | def test_height_min(self):
    method create_chain_with_staleblocks (line 90) | def create_chain_with_staleblocks(self):
    method reorg_test (line 121) | def reorg_test(self):
    method reorg_back (line 182) | def reorg_back(self):
    method manual_test (line 223) | def manual_test(self, node_number, use_timestamp):
    method wallet_test (line 318) | def wallet_test(self):
    method run_test (line 335) | def run_test(self):

FILE: test/functional/feature_rbf.py
  function txToHex (line 14) | def txToHex(tx):
  function make_utxo (line 17) | def make_utxo(node, amount, confirmed=True, scriptPubKey=CScript([1])):
  class ReplaceByFeeTest (line 62) | class ReplaceByFeeTest(BitcoinTestFramework):
    method set_test_params (line 64) | def set_test_params(self):
    method run_test (line 74) | def run_test(self):
    method test_simple_doublespend (line 115) | def test_simple_doublespend(self):
    method test_doublespend_chain (line 165) | def test_doublespend_chain(self):
    method test_doublespend_tree (line 205) | def test_doublespend_tree(self):
    method test_replacement_feeperkb (line 287) | def test_replacement_feeperkb(self):
    method test_spends_of_conflicting_outputs (line 307) | def test_spends_of_conflicting_outputs(self):
    method test_new_unconfirmed_inputs (line 347) | def test_new_unconfirmed_inputs(self):
    method test_too_many_replacements (line 366) | def test_too_many_replacements(self):
    method test_opt_in (line 419) | def test_opt_in(self):
    method test_prioritised_transactions (line 487) | def test_prioritised_transactions(self):
    method test_rpc (line 544) | def test_rpc(self):

FILE: test/functional/feature_reindex.py
  class ReindexTest (line 15) | class ReindexTest(BitcoinTestFramework):
    method set_test_params (line 17) | def set_test_params(self):
    method reindex (line 21) | def reindex(self, justchainstate=False):
    method run_test (line 30) | def run_test(self):

FILE: test/functional/feature_segwit.py
  function getutxo (line 27) | def getutxo(txid):
  function find_unspent (line 33) | def find_unspent(node, min_value):
  class SegWitTest (line 38) | class SegWitTest(BitcoinTestFramework):
    method set_test_params (line 39) | def set_test_params(self):
    method setup_network (line 47) | def setup_network(self):
    method success_mine (line 52) | def success_mine(self, node, txid, sign, redeem_script=""):
    method skip_mine (line 58) | def skip_mine(self, node, txid, sign, redeem_script=""):
    method fail_accept (line 64) | def fail_accept(self, node, error_msg, txid, sign, redeem_script=""):
    method fail_mine (line 67) | def fail_mine(self, node, txid, sign, redeem_script=""):
    method run_test (line 72) | def run_test(self):
    method mine_and_test_listunspent (line 572) | def mine_and_test_listunspent(self, script_list, ismine):
    method p2sh_address_to_script (line 599) | def p2sh_address_to_script(self,v):
    method p2pkh_address_to_script (line 606) | def p2pkh_address_to_script(self,v):
    method create_and_mine_tx_from_txids (line 620) | def create_and_mine_tx_from_txids(self, txids, success = True):

FILE: test/functional/feature_uacomment.py
  class UacommentTest (line 10) | class UacommentTest(BitcoinTestFramework):
    method set_test_params (line 11) | def set_test_params(self):
    method run_test (line 15) | def run_test(self):

FILE: test/functional/feature_versionbits_warning.py
  class VersionBitsWarningTest (line 29) | class VersionBitsWarningTest(BitcoinTestFramework):
    method set_test_params (line 30) | def set_test_params(self):
    method setup_network (line 34) | def setup_network(self):
    method send_blocks_with_version (line 42) | def send_blocks_with_version(self, peer, numblocks, version):
    method versionbits_in_alert_file (line 59) | def versionbits_in_alert_file(self):
    method run_test (line 64) | def run_test(self):

FILE: test/functional/interface_bitcoin_cli.py
  class TestBitcoinCli (line 9) | class TestBitcoinCli(BitcoinTestFramework):
    method set_test_params (line 11) | def set_test_params(self):
    method run_test (line 15) | def run_test(self):

FILE: test/functional/interface_http.py
  class HTTPBasicsTest (line 13) | class HTTPBasicsTest (BitcoinTestFramework):
    method set_test_params (line 14) | def set_test_params(self):
    method setup_network (line 17) | def setup_network(self):
    method run_test (line 20) | def run_test(self):

FILE: test/functional/interface_rest.py
  function deser_uint256 (line 16) | def deser_uint256(f):
  function http_get_call (line 24) | def http_get_call(host, port, path, response_object = 0):
  function http_post_call (line 34) | def http_post_call(host, port, path, requestdata = '', response_object =...
  class RESTTest (line 43) | class RESTTest (BitcoinTestFramework):
    method set_test_params (line 46) | def set_test_params(self):
    method setup_network (line 50) | def setup_network(self, split=False):
    method run_test (line 54) | def run_test(self):

FILE: test/functional/interface_zmq.py
  class ZMQSubscriber (line 18) | class ZMQSubscriber:
    method __init__ (line 19) | def __init__(self, socket, topic):
    method receive (line 27) | def receive(self):
  class ZMQTest (line 37) | class ZMQTest (BitcoinTestFramework):
    method set_test_params (line 38) | def set_test_params(self):
    method setup_nodes (line 41) | def setup_nodes(self):
    method run_test (line 78) | def run_test(self):
    method _zmq_test (line 86) | def _zmq_test(self):

FILE: test/functional/mempool_limit.py
  class MempoolLimitTest (line 10) | class MempoolLimitTest(BitcoinTestFramework):
    method set_test_params (line 11) | def set_test_params(self):
    method run_test (line 16) | def run_test(self):

FILE: test/functional/mempool_packages.py
  class MempoolPackagesTest (line 14) | class MempoolPackagesTest(BitcoinTestFramework):
    method set_test_params (line 15) | def set_test_params(self):
    method chain_transaction (line 21) | def chain_transaction(self, node, parent_txid, vout, value, fee, num_o...
    method run_test (line 34) | def run_test(self):

FILE: test/functional/mempool_persist.py
  class MempoolPersistTest (line 44) | class MempoolPersistTest(BitcoinTestFramework):
    method set_test_params (line 45) | def set_test_params(self):
    method run_test (line 49) | def run_test(self):

FILE: test/functional/mempool_reorg.py
  class MempoolCoinbaseTest (line 15) | class MempoolCoinbaseTest(BitcoinTestFramework):
    method set_test_params (line 16) | def set_test_params(self):
    method run_test (line 22) | def run_test(self):

FILE: test/functional/mempool_resurrect.py
  class MempoolCoinbaseTest (line 11) | class MempoolCoinbaseTest(BitcoinTestFramework):
    method set_test_params (line 12) | def set_test_params(self):
    method run_test (line 16) | def run_test(self):

FILE: test/functional/mempool_spend_coinbase.py
  class MempoolSpendCoinbaseTest (line 19) | class MempoolSpendCoinbaseTest(BitcoinTestFramework):
    method set_test_params (line 20) | def set_test_params(self):
    method run_test (line 24) | def run_test(self):

FILE: test/functional/mining_basic.py
  function b2x (line 20) | def b2x(b):
  function assert_template (line 23) | def assert_template(node, block, expect, rehash=True):
  class MiningTest (line 29) | class MiningTest(BitcoinTestFramework):
    method set_test_params (line 30) | def set_test_params(self):
    method run_test (line 34) | def run_test(self):

FILE: test/functional/mining_getblocktemplate_longpoll.py
  class LongpollThread (line 12) | class LongpollThread(threading.Thread):
    method __init__ (line 13) | def __init__(self, node):
    method run (line 22) | def run(self):
  class GetBlockTemplateLPTest (line 25) | class GetBlockTemplateLPTest(BitcoinTestFramework):
    method set_test_params (line 26) | def set_test_params(self):
    method run_test (line 29) | def run_test(self):

FILE: test/functional/mining_prioritisetransaction.py
  class PrioritiseTransactionTest (line 11) | class PrioritiseTransactionTest(BitcoinTestFramework):
    method set_test_params (line 12) | def set_test_params(self):
    method run_test (line 17) | def run_test(self):

FILE: test/functional/p2p_compactblocks.py
  class TestNode (line 19) | class TestNode(P2PInterface):
    method __init__ (line 20) | def __init__(self):
    method on_sendcmpct (line 29) | def on_sendcmpct(self, message):
    method on_cmpctblock (line 32) | def on_cmpctblock(self, message):
    method on_headers (line 37) | def on_headers(self, message):
    method on_inv (line 43) | def on_inv(self, message):
    method received_block_announcement (line 50) | def received_block_announcement(self):
    method clear_block_announcement (line 53) | def clear_block_announcement(self):
    method get_headers (line 60) | def get_headers(self, locator, hashstop):
    method send_header_for_blocks (line 66) | def send_header_for_blocks(self, new_blocks):
    method request_headers_and_sync (line 71) | def request_headers_and_sync(self, locator, hashstop=0):
    method wait_for_block_announcement (line 79) | def wait_for_block_announcement(self, block_hash, timeout=30):
    method send_await_disconnect (line 84) | def send_await_disconnect(self, message, timeout=30):
  class CompactBlocksTest (line 92) | class CompactBlocksTest(BitcoinTestFramework):
    method set_test_params (line 93) | def set_test_params(self):
    method build_block_on_tip (line 102) | def build_block_on_tip(self, node, segwit=False):
    method make_utxos (line 114) | def make_utxos(self):
    method test_sendcmpct (line 147) | def test_sendcmpct(self, node, test_node, preferred_version, old_node=...
    method test_invalid_cmpctblock_message (line 239) | def test_invalid_cmpctblock_message(self):
    method test_compactblock_construction (line 254) | def test_compactblock_construction(self, node, test_node, version, use...
    method check_compactblock_construction_from_block (line 322) | def check_compactblock_construction_from_block(self, version, header_a...
    method test_compactblock_requests (line 373) | def test_compactblock_requests(self, node, test_node, version, segwit):
    method build_block_with_transactions (line 421) | def build_block_with_transactions(self, node, utxo, num_transactions):
    method test_getblocktxn_requests (line 439) | def test_getblocktxn_requests(self, node, test_node, version):
    method test_incorrect_blocktxn_response (line 522) | def test_incorrect_blocktxn_response(self, node, test_node, version):
    method test_getblocktxn_handler (line 578) | def test_getblocktxn_handler(self, node, test_node, version):
    method test_compactblocks_not_at_tip (line 625) | def test_compactblocks_not_at_tip(self, node, test_node):
    method activate_segwit (line 680) | def activate_segwit(self, node):
    method test_end_to_end_block_relay (line 684) | def test_end_to_end_block_relay(self, node, listeners):
    method test_invalid_tx_in_compactblock (line 705) | def test_invalid_tx_in_compactblock(self, node, test_node, use_segwit):
    method request_cb_announcements (line 732) | def request_cb_announcements(self, peer, node, version):
    method test_compactblock_reconstruction_multiple_peers (line 741) | def test_compactblock_reconstruction_multiple_peers(self, node, stalli...
    method run_test (line 790) | def run_test(self):

FILE: test/functional/p2p_disconnect_ban.py
  class DisconnectBanTest (line 16) | class DisconnectBanTest(BitcoinTestFramework):
    method set_test_params (line 17) | def set_test_params(self):
    method run_test (line 20) | def run_test(self):

FILE: test/functional/p2p_feefilter.py
  function hashToHex (line 13) | def hashToHex(hash):
  function allInvsMatch (line 17) | def allInvsMatch(invsExpected, testnode):
  class TestNode (line 25) | class TestNode(P2PInterface):
    method __init__ (line 26) | def __init__(self):
    method on_inv (line 30) | def on_inv(self, message):
    method clear_invs (line 35) | def clear_invs(self):
  class FeeFilterTest (line 39) | class FeeFilterTest(BitcoinTestFramework):
    method set_test_params (line 40) | def set_test_params(self):
    method run_test (line 43) | def run_test(self):

FILE: test/functional/p2p_fingerprint.py
  class P2PFingerprintTest (line 29) | class P2PFingerprintTest(BitcoinTestFramework):
    method set_test_params (line 30) | def set_test_params(self):
    method build_chain (line 35) | def build_chain(self, nblocks, prev_hash, prev_height, prev_median_time):
    method send_block_request (line 50) | def send_block_request(self, block_hash, node):
    method send_header_request (line 56) | def send_header_request(self, block_hash, node):
    method last_block_equals (line 62) | def last_block_equals(self, expected_hash, node):
    method last_header_equals (line 67) | def last_header_equals(self, expected_hash, node):
    method run_test (line 77) | def run_test(self):

FILE: test/functional/p2p_invalid_block.py
  class InvalidBlockRequestTest (line 23) | class InvalidBlockRequestTest(ComparisonTestFramework):
    method set_test_params (line 27) | def set_test_params(self):
    method run_test (line 31) | def run_test(self):
    method get_tests (line 39) | def get_tests(self):

FILE: test/functional/p2p_invalid_tx.py
  class InvalidTxRequestTest (line 18) | class InvalidTxRequestTest(ComparisonTestFramework):
    method set_test_params (line 22) | def set_test_params(self):
    method run_test (line 26) | def run_test(self):
    method get_tests (line 34) | def get_tests(self):

FILE: test/functional/p2p_leak.py
  class CLazyNode (line 23) | class CLazyNode(P2PInterface):
    method __init__ (line 24) | def __init__(self):
    method bad_message (line 29) | def bad_message(self, message):
    method on_open (line 33) | def on_open(self):
    method on_version (line 36) | def on_version(self, message): self.bad_message(message)
    method on_verack (line 37) | def on_verack(self, message): self.bad_message(message)
    method on_reject (line 38) | def on_reject(self, message): self.bad_message(message)
    method on_inv (line 39) | def on_inv(self, message): self.bad_message(message)
    method on_addr (line 40) | def on_addr(self, message): self.bad_message(message)
    method on_getdata (line 41) | def on_getdata(self, message): self.bad_message(message)
    method on_getblocks (line 42) | def on_getblocks(self, message): self.bad_message(message)
    method on_tx (line 43) | def on_tx(self, message): self.bad_message(message)
    method on_block (line 44) | def on_block(self, message): self.bad_message(message)
    method on_getaddr (line 45) | def on_getaddr(self, message): self.bad_message(message)
    method on_headers (line 46) | def on_headers(self, message): self.bad_message(message)
    method on_getheaders (line 47) | def on_getheaders(self, message): self.bad_message(message)
    method on_ping (line 48) | def on_ping(self, message): self.bad_message(message)
    method on_mempool (line 49) | def on_mempool(self, message): self.bad_message(message)
    method on_pong (line 50) | def on_pong(self, message): self.bad_message(message)
    method on_feefilter (line 51) | def on_feefilter(self, message): self.bad_message(message)
    method on_sendheaders (line 52) | def on_sendheaders(self, message): self.bad_message(message)
    method on_sendcmpct (line 53) | def on_sendcmpct(self, message): self.bad_message(message)
    method on_cmpctblock (line 54) | def on_cmpctblock(self, message): self.bad_message(message)
    method on_getblocktxn (line 55) | def on_getblocktxn(self, message): self.bad_message(message)
    method on_blocktxn (line 56) | def on_blocktxn(self, message): self.bad_message(message)
  class CNodeNoVersionBan (line 60) | class CNodeNoVersionBan(CLazyNode):
    method on_open (line 63) | def on_open(self):
    method on_reject (line 68) | def on_reject(self, message): pass
  class CNodeNoVersionIdle (line 72) | class CNodeNoVersionIdle(CLazyNode):
    method __init__ (line 73) | def __init__(self):
  class CNodeNoVerackIdle (line 77) | class CNodeNoVerackIdle(CLazyNode):
    method __init__ (line 78) | def __init__(self):
    method on_reject (line 82) | def on_reject(self, message): pass
    method on_verack (line 83) | def on_verack(self, message): pass
    method on_version (line 87) | def on_version(self, message):
  class P2PLeakTest (line 92) | class P2PLeakTest(BitcoinTestFramework):
    method set_test_params (line 93) | def set_test_params(self):
    method run_test (line 97) | def run_test(self):

FILE: test/functional/p2p_mempool.py
  class P2PMempoolTests (line 15) | class P2PMempoolTests(BitcoinTestFramework):
    method set_test_params (line 16) | def set_test_params(self):
    method run_test (line 21) | def run_test(self):

FILE: test/functional/p2p_node_network_limited.py
  class P2PIgnoreInv (line 16) | class P2PIgnoreInv(P2PInterface):
    method on_inv (line 17) | def on_inv(self, message):
    method send_getdata_for_block (line 21) | def send_getdata_for_block(self, blockhash):
  class NodeNetworkLimitedTest (line 26) | class NodeNetworkLimitedTest(BitcoinTestFramework):
    method set_test_params (line 27) | def set_test_params(self):
    method run_test (line 32) | def run_test(self):

FILE: test/functional/p2p_segwit.py
  function get_virtual_size (line 27) | def get_virtual_size(witness_block):
  function test_transaction_acceptance (line 34) | def test_transaction_acceptance(rpc, p2p, tx, with_witness, accepted, re...
  function test_witness_block (line 50) | def test_witness_block(rpc, p2p, block, accepted, with_witness=True):
  class TestNode (line 62) | class TestNode(P2PInterface):
    method __init__ (line 63) | def __init__(self):
    method on_getdata (line 67) | def on_getdata(self, message):
    method announce_tx_and_wait_for_getdata (line 71) | def announce_tx_and_wait_for_getdata(self, tx, timeout=60):
    method announce_block_and_wait_for_getdata (line 77) | def announce_block_and_wait_for_getdata(self, block, use_header, timeo...
    method request_block (line 91) | def request_block(self, blockhash, inv_type, timeout=60):
  class UTXO (line 99) | class UTXO():
    method __init__ (line 100) | def __init__(self, sha256, n, nValue):
  function GetP2PKHScript (line 106) | def GetP2PKHScript(pubkeyhash):
  function sign_P2PK_witness_input (line 110) | def sign_P2PK_witness_input(script, txTo, inIdx, hashtype, value, key):
  class SegWitTest (line 117) | class SegWitTest(BitcoinTestFramework):
    method set_test_params (line 118) | def set_test_params(self):
    method setup_network (line 124) | def setup_network(self):
    method build_next_block (line 132) | def build_next_block(self, nVersion=4):
    method update_witness_block_with_transactions (line 142) | def update_witness_block_with_transactions(self, block, tx_list, nonce...
    method test_witness_services (line 149) | def test_witness_services(self):
    method test_non_witness_transaction (line 156) | def test_non_witness_transaction(self):
    method test_unnecessary_witness_before_segwit_activation (line 187) | def test_unnecessary_witness_before_segwit_activation(self):
    method advance_to_segwit_started (line 276) | def advance_to_segwit_started(self):
    method advance_to_segwit_lockin (line 289) | def advance_to_segwit_lockin(self):
    method advance_to_segwit_active (line 304) | def advance_to_segwit_active(self):
    method test_witness_commitments (line 314) | def test_witness_commitments(self):
    method test_block_malleability (line 403) | def test_block_malleability(self):
    method test_witness_block_size (line 444) | def test_witness_block_size(self):
    method test_submit_block (line 525) | def test_submit_block(self):
    method test_extra_witness_data (line 561) | def test_extra_witness_data(self):
    method test_max_witness_push_length (line 636) | def test_max_witness_push_length(self):
    method test_max_witness_program_length (line 675) | def test_max_witness_program_length(self):
    method test_witness_input_length (line 725) | def test_witness_input_length(self):
    method test_witness_tx_relay_before_segwit_activation (line 809) | def test_witness_tx_relay_before_segwit_activation(self):
    method test_tx_relay_after_segwit_activation (line 861) | def test_tx_relay_after_segwit_activation(self):
    method test_block_relay (line 950) | def test_block_relay(self, segwit_activated):
    method test_standardness_v0 (line 1043) | def test_standardness_v0(self, segwit_activated):
    method test_segwit_versions (line 1120) | def test_segwit_versions(self):
    method test_premature_coinbase_witness_spend (line 1204) | def test_premature_coinbase_witness_spend(self):
    method test_signature_version_1 (line 1239) | def test_signature_version_1(self):
    method test_p2sh_witness (line 1423) | def test_p2sh_witness(self, segwit_activated):
    method test_upgrade_after_activation (line 1496) | def test_upgrade_after_activation(self, node_id):
    method test_witness_sigops (line 1523) | def test_witness_sigops(self):
    method test_getblocktemplate_before_lockin (line 1626) | def test_getblocktemplate_before_lockin(self):
    method test_uncompressed_pubkey (line 1675) | def test_uncompressed_pubkey(self):
    method test_non_standard_witness (line 1777) | def test_non_standard_witness(self):
    method run_test (line 1878) | def run_test(self):

FILE: test/functional/p2p_sendheaders.py
  class BaseNode (line 113) | class BaseNode(P2PInterface):
    method __init__ (line 114) | def __init__(self):
    method send_get_data (line 121) | def send_get_data(self, block_hashes):
    method send_get_headers (line 128) | def send_get_headers(self, locator, hashstop):
    method send_block_inv (line 134) | def send_block_inv(self, blockhash):
    method send_header_for_blocks (line 139) | def send_header_for_blocks(self, new_blocks):
    method send_getblocks (line 144) | def send_getblocks(self, locator):
    method wait_for_getdata (line 149) | def wait_for_getdata(self, hash_list, timeout=60):
    method wait_for_block_announcement (line 156) | def wait_for_block_announcement(self, block_hash, timeout=60):
    method on_inv (line 160) | def on_inv(self, message):
    method on_headers (line 164) | def on_headers(self, message):
    method clear_block_announcements (line 173) | def clear_block_announcements(self):
    method check_last_headers_announcement (line 181) | def check_last_headers_announcement(self, headers):
    method check_last_inv_announcement (line 192) | def check_last_inv_announcement(self, inv):
  class SendHeadersTest (line 207) | class SendHeadersTest(BitcoinTestFramework):
    method set_test_params (line 208) | def set_test_params(self):
    method mine_blocks (line 212) | def mine_blocks(self, count):
    method mine_reorg (line 220) | def mine_reorg(self, length):
    method run_test (line 240) | def run_test(self):
    method test_null_locators (line 260) | def test_null_locators(self, test_node, inv_node):
    method test_nonnull_locators (line 284) | def test_nonnull_locators(self, test_node, inv_node):

FILE: test/functional/p2p_timeouts.py
  class TestNode (line 30) | class TestNode(P2PInterface):
    method on_version (line 31) | def on_version(self, message):
  class TimeoutsTest (line 35) | class TimeoutsTest(BitcoinTestFramework):
    method set_test_params (line 36) | def set_test_params(self):
    method run_test (line 40) | def run_test(self):

FILE: test/functional/p2p_unrequested_blocks.py
  class AcceptBlockTest (line 60) | class AcceptBlockTest(BitcoinTestFramework):
    method add_options (line 61) | def add_options(self, parser):
    method set_test_params (line 66) | def set_test_params(self):
    method setup_network (line 71) | def setup_network(self):
    method run_test (line 79) | def run_test(self):

FILE: test/functional/rpc_bind.py
  class RPCBindTest (line 14) | class RPCBindTest(BitcoinTestFramework):
    method set_test_params (line 15) | def set_test_params(self):
    method setup_network (line 19) | def setup_network(self):
    method run_bind_test (line 22) | def run_bind_test(self, allow_ips, connect_to, addresses, expected):
    method run_allowip_test (line 40) | def run_allowip_test(self, allow_ips, rpchost, rpcport):
    method run_test (line 54) | def run_test(self):

FILE: test/functional/rpc_blockchain.py
  class BlockchainTest (line 36) | class BlockchainTest(BitcoinTestFramework):
    method set_test_params (line 37) | def set_test_params(self):
    method run_test (line 41) | def run_test(self):
    method _test_getblockchaininfo (line 51) | def _test_getblockchaininfo(self):
    method _test_getchaintxstats (line 102) | def _test_getchaintxstats(self):
    method _test_gettxoutsetinfo (line 132) | def _test_gettxoutsetinfo(self):
    method _test_getblockheader (line 173) | def _test_getblockheader(self):
    method _test_getdifficulty (line 200) | def _test_getdifficulty(self):
    method _test_getnetworkhashps (line 206) | def _test_getnetworkhashps(self):
    method _test_stopatheight (line 211) | def _test_stopatheight(self):

FILE: test/functional/rpc_decodescript.py
  class DecodeScriptTest (line 12) | class DecodeScriptTest(BitcoinTestFramework):
    method set_test_params (line 13) | def set_test_params(self):
    method decodescript_script_sig (line 17) | def decodescript_script_sig(self):
    method decodescript_script_pub_key (line 50) | def decodescript_script_pub_key(self):
    method decoderawtransaction_asm_sighashtype (line 107) | def decoderawtransaction_asm_sighashtype(self):
    method run_test (line 173) | def run_test(self):

FILE: test/functional/rpc_deprecated.py
  class DeprecatedRpcTest (line 9) | class DeprecatedRpcTest(BitcoinTestFramework):
    method set_test_params (line 10) | def set_test_params(self):
    method run_test (line 15) | def run_test(self):

FILE: test/functional/rpc_fundrawtransaction.py
  function get_unspent (line 11) | def get_unspent(listunspent, amount):
  class RawTransactionsTest (line 17) | class RawTransactionsTest(BitcoinTestFramework):
    method set_test_params (line 18) | def set_test_params(self):
    method setup_network (line 22) | def setup_network(self, split=False):
    method run_test (line 30) | def run_test(self):

FILE: test/functional/rpc_getchaintips.py
  class GetChainTipsTest (line 16) | class GetChainTipsTest (BitcoinTestFramework):
    method set_test_params (line 17) | def set_test_params(self):
    method run_test (line 20) | def run_test (self):

FILE: test/functional/rpc_invalidateblock.py
  class InvalidateTest (line 10) | class InvalidateTest(BitcoinTestFramework):
    method set_test_params (line 11) | def set_test_params(self):
    method setup_network (line 15) | def setup_network(self):
    method run_test (line 18) | def run_test(self):

FILE: test/functional/rpc_listtransactions.py
  function txFromHex (line 12) | def txFromHex(hexstring):
  class ListTransactionsTest (line 18) | class ListTransactionsTest(BitcoinTestFramework):
    method set_test_params (line 19) | def set_test_params(self):
    method run_test (line 23) | def run_test(self):
    method run_rbf_opt_in_test (line 99) | def run_rbf_opt_in_test(self):

FILE: test/functional/rpc_named_arguments.py
  class NamedArgumentTest (line 13) | class NamedArgumentTest(BitcoinTestFramework):
    method set_test_params (line 14) | def set_test_params(self):
    method run_test (line 17) | def run_test(self):

FILE: test/functional/rpc_net.py
  class NetTest (line 20) | class NetTest(BitcoinTestFramework):
    method set_test_params (line 21) | def set_test_params(self):
    method run_test (line 25) | def run_test(self):
    method _test_connection_count (line 32) | def _test_connection_count(self):
    method _test_getnettotals (line 36) | def _test_getnettotals(self):
    method _test_getnetworkinginfo (line 66) | def _test_getnetworkinginfo(self):
    method _test_getaddednodeinfo (line 80) | def _test_getaddednodeinfo(self):
    method _test_getpeerinfo (line 92) | def _test_getpeerinfo(self):

FILE: test/functional/rpc_preciousblock.py
  function unidirectional_node_sync_via_rpc (line 15) | def unidirectional_node_sync_via_rpc(node_src, node_dest):
  function node_sync_via_rpc (line 30) | def node_sync_via_rpc(nodes):
  class PreciousTest (line 37) | class PreciousTest(BitcoinTestFramework):
    method set_test_params (line 38) | def set_test_params(self):
    method setup_network (line 42) | def setup_network(self):
    method run_test (line 45) | def run_test(self):

FILE: test/functional/rpc_rawtransaction.py
  class multidict (line 19) | class multidict(dict):
    method __init__ (line 29) | def __init__(self, x):
    method items (line 33) | def items(self):
  class RawTransactionsTest (line 38) | class RawTransactionsTest(BitcoinTestFramework):
    method set_test_params (line 39) | def set_test_params(self):
    method setup_network (line 44) | def setup_network(self, split=False):
    method run_test (line 48) | def run_test(self):

FILE: test/functional/rpc_signmessage.py
  class SignMessagesTest (line 10) | class SignMessagesTest(BitcoinTestFramework):
    method set_test_params (line 11) | def set_test_params(self):
    method run_test (line 16) | def run_test(self):

FILE: test/functional/rpc_signrawtransaction.py
  class SignRawTransactionsTest (line 11) | class SignRawTransactionsTest(BitcoinTestFramework):
    method set_test_params (line 12) | def set_test_params(self):
    method successful_signing_test (line 16) | def successful_signing_test(self):
    method script_verification_error_test (line 45) | def script_verification_error_test(self):
    method run_test (line 137) | def run_test(self):

FILE: test/functional/rpc_txoutproof.py
  class MerkleBlockTest (line 12) | class MerkleBlockTest(BitcoinTestFramework):
    method set_test_params (line 13) | def set_test_params(self):
    method setup_network (line 19) | def setup_network(self):
    method run_test (line 27) | def run_test(self):

FILE: test/functional/rpc_uptime.py
  class UptimeTest (line 15) | class UptimeTest(BitcoinTestFramework):
    method set_test_params (line 16) | def set_test_params(self):
    method run_test (line 20) | def run_test(self):
    method _test_uptime (line 23) | def _test_uptime(self):

FILE: test/functional/rpc_users.py
  class HTTPBasicsTest (line 14) | class HTTPBasicsTest (BitcoinTestFramework):
    method set_test_params (line 15) | def set_test_params(self):
    method setup_chain (line 18) | def setup_chain(self):
    method run_test (line 32) | def run_test(self):

FILE: test/functional/test_framework/address.py
  function byte_to_base58 (line 14) | def byte_to_base58(b, version):
  function keyhash_to_p2pkh (line 31) | def keyhash_to_p2pkh(hash, main = False):
  function scripthash_to_p2sh (line 36) | def scripthash_to_p2sh(hash, main = False):
  function key_to_p2pkh (line 41) | def key_to_p2pkh(key, main = False):
  function script_to_p2sh (line 45) | def script_to_p2sh(script, main = False):
  function key_to_p2sh_p2wpkh (line 49) | def key_to_p2sh_p2wpkh(key, main = False):
  function program_to_witness (line 54) | def program_to_witness(version, program, main = False):
  function script_to_p2wsh (line 62) | def script_to_p2wsh(script, main = False):
  function key_to_p2wpkh (line 66) | def key_to_p2wpkh(key, main = False):
  function script_to_p2sh_p2wsh (line 70) | def script_to_p2sh_p2wsh(script, main = False):
  function check_key (line 75) | def check_key(key):
  function check_script (line 82) | def check_script(script):

FILE: test/functional/test_framework/authproxy.py
  class JSONRPCException (line 50) | class JSONRPCException(Exception):
    method __init__ (line 51) | def __init__(self, rpc_error):
  function EncodeDecimal (line 60) | def EncodeDecimal(o):
  class AuthServiceProxy (line 65) | class AuthServiceProxy():
    method __init__ (line 69) | def __init__(self, service_url, service_name=None, timeout=HTTP_TIMEOU...
    method __getattr__ (line 88) | def __getattr__(self, name):
    method _request (line 96) | def _request(self, method, path, postdata):
    method get_request (line 122) | def get_request(self, *args, **argsn):
    method __call__ (line 134) | def __call__(self, *args, **argsn):
    method batch (line 145) | def batch(self, rpc_call_list):
    method _get_response (line 150) | def _get_response(self):
    method __truediv__ (line 179) | def __truediv__(self, relative_uri):

FILE: test/functional/test_framework/bignum.py
  function bn_bytes (line 15) | def bn_bytes(v, have_ext=False):
  function bn2bin (line 21) | def bn2bin(v):
  function bn2mpi (line 29) | def bn2mpi(v):
  function mpi2vch (line 52) | def mpi2vch(s):
  function bn2vch (line 57) | def bn2vch(v):

FILE: test/functional/test_framework/blockstore.py
  class BlockStore (line 13) | class BlockStore():
    method __init__ (line 21) | def __init__(self, datadir):
    method close (line 26) | def close(self):
    method erase (line 29) | def erase(self, blockhash):
    method get (line 33) | def get(self, blockhash):
    method get_block (line 42) | def get_block(self, blockhash):
    method get_header (line 52) | def get_header(self, blockhash):
    method headers_for (line 61) | def headers_for(self, locator, hash_stop, current_tip=None):
    method add_block (line 86) | def add_block(self, block):
    method add_header (line 95) | def add_header(self, header):
    method get_blocks (line 100) | def get_blocks(self, inv):
    method get_locator (line 110) | def get_locator(self, current_tip=None):
  class TxStore (line 130) | class TxStore():
    method __init__ (line 131) | def __init__(self, datadir):
    method close (line 134) | def close(self):
    method get (line 138) | def get(self, txhash):
    method add_transaction (line 146) | def add_transaction(self, tx):
    method get_transactions (line 153) | def get_transactions(self, inv):

FILE: test/functional/test_framework/blocktools.py
  function create_block (line 27) | def create_block(hashprev, coinbase, nTime=None):
  function get_witness_script (line 45) | def get_witness_script(witness_root, witness_nonce):
  function add_witness_commitment (line 53) | def add_witness_commitment(block, nonce=0):
  function serialize_script_num (line 69) | def serialize_script_num(value):
  function create_coinbase (line 87) | def create_coinbase(height, pubkey = None):
  function create_transaction (line 105) | def create_transaction(prevtx, n, sig, value, scriptPubKey=CScript()):
  function get_legacy_sigopcount_block (line 113) | def get_legacy_sigopcount_block(block, fAccurate=True):
  function get_legacy_sigopcount_tx (line 119) | def get_legacy_sigopcount_tx(tx, fAccurate=True):
  function witness_script (line 131) | def witness_script(use_p2wsh, pubkey):
  function create_witness_tx (line 145) | def create_witness_tx(node, use_p2wsh, utxo, pubkey, encode_p2sh, amount):
  function send_to_witness (line 160) | def send_to_witness(use_p2wsh, node, utxo, pubkey, encode_p2sh, amount, ...

FILE: test/functional/test_framework/comptool.py
  class RejectResult (line 30) | class RejectResult():
    method __init__ (line 32) | def __init__(self, code, reason=b''):
    method match (line 35) | def match(self, other):
    method __repr__ (line 39) | def __repr__(self):
  class TestNode (line 42) | class TestNode(P2PInterface):
    method __init__ (line 44) | def __init__(self, block_store, tx_store):
    method on_close (line 60) | def on_close(self):
    method on_headers (line 63) | def on_headers(self, message):
    method on_getheaders (line 69) | def on_getheaders(self, message):
    method on_getdata (line 74) | def on_getdata(self, message):
    method on_inv (line 84) | def on_inv(self, message):
    method on_pong (line 87) | def on_pong(self, message):
    method on_reject (line 93) | def on_reject(self, message):
    method send_inv (line 99) | def send_inv(self, obj):
    method send_getheaders (line 103) | def send_getheaders(self):
    method send_header (line 109) | def send_header(self, header):
    method send_ping (line 115) | def send_ping(self, nonce):
    method received_ping_response (line 119) | def received_ping_response(self, nonce):
    method send_mempool (line 122) | def send_mempool(self):
  class TestInstance (line 155) | class TestInstance():
    method __init__ (line 156) | def __init__(self, objects=None, sync_every_block=True, sync_every_tx=...
  class TestManager (line 161) | class TestManager():
    method __init__ (line 163) | def __init__(self, testgen, datadir):
    method add_all_connections (line 170) | def add_all_connections(self, nodes):
    method clear_all_connections (line 177) | def clear_all_connections(self):
    method wait_for_disconnections (line 180) | def wait_for_disconnections(self):
    method wait_for_verack (line 185) | def wait_for_verack(self):
    method wait_for_pings (line 188) | def wait_for_pings(self, counter):
    method sync_blocks (line 196) | def sync_blocks(self, blockhash, num_blocks):
    method sync_transaction (line 215) | def sync_transaction(self, txhash, num_events):
    method check_results (line 240) | def check_results(self, blockhash, outcome):
    method check_mempool (line 265) | def check_mempool(self, txhash, outcome):
    method run (line 285) | def run(self):

FILE: test/functional/test_framework/coverage.py
  class AuthServiceProxyWrapper (line 17) | class AuthServiceProxyWrapper():
    method __init__ (line 22) | def __init__(self, auth_service_proxy_instance, coverage_logfile=None):
    method __getattr__ (line 34) | def __getattr__(self, name):
    method __call__ (line 41) | def __call__(self, *args, **kwargs):
    method _log_call (line 51) | def _log_call(self):
    method __truediv__ (line 58) | def __truediv__(self, relative_uri):
    method get_request (line 62) | def get_request(self, *args, **kwargs):
  function get_filename (line 66) | def get_filename(dirname, n_node):
  function write_all_rpc_commands (line 77) | def write_all_rpc_commands(dirname, node):

FILE: test/functional/test_framework/key.py
  function _check_result (line 78) | def _check_result(val, func, args):
  class CECKey (line 87) | class CECKey():
    method __init__ (line 93) | def __init__(self):
    method __del__ (line 96) | def __del__(self):
    method set_secretbytes (line 101) | def set_secretbytes(self, secret):
    method set_privkey (line 115) | def set_privkey(self, key):
    method set_pubkey (line 119) | def set_pubkey(self, key):
    method get_privkey (line 123) | def get_privkey(self):
    method get_pubkey (line 129) | def get_pubkey(self):
    method get_raw_ecdh_key (line 135) | def get_raw_ecdh_key(self, other_pubkey):
    method get_ecdh_key (line 144) | def get_ecdh_key(self, other_pubkey, kdf=lambda k: hashlib.sha256(k).d...
    method sign (line 149) | def sign(self, hash, low_s = True):
    method verify (line 181) | def verify(self, hash, sig):
    method set_compressed (line 185) | def set_compressed(self, compressed):
  class CPubKey (line 193) | class CPubKey(bytes):
    method __new__ (line 203) | def __new__(cls, buf, _cec_key=None):
    method is_valid (line 212) | def is_valid(self):
    method is_compressed (line 216) | def is_compressed(self):
    method verify (line 219) | def verify(self, hash, sig):
    method __str__ (line 222) | def __str__(self):
    method __repr__ (line 225) | def __repr__(self):

FILE: test/functional/test_framework/messages.py
  function sha256 (line 48) | def sha256(s):
  function ripemd160 (line 51) | def ripemd160(s):
  function hash256 (line 54) | def hash256(s):
  function ser_compact_size (line 57) | def ser_compact_size(l):
  function deser_compact_size (line 69) | def deser_compact_size(f):
  function deser_string (line 79) | def deser_string(f):
  function ser_string (line 83) | def ser_string(s):
  function deser_uint256 (line 86) | def deser_uint256(f):
  function ser_uint256 (line 94) | def ser_uint256(u):
  function uint256_from_str (line 102) | def uint256_from_str(s):
  function uint256_from_compact (line 110) | def uint256_from_compact(c):
  function deser_vector (line 116) | def deser_vector(f, c):
  function ser_vector (line 129) | def ser_vector(l, ser_function_name=None):
  function deser_uint256_vector (line 139) | def deser_uint256_vector(f):
  function ser_uint256_vector (line 148) | def ser_uint256_vector(l):
  function deser_string_vector (line 155) | def deser_string_vector(f):
  function ser_string_vector (line 164) | def ser_string_vector(l):
  function FromHex (line 172) | def FromHex(obj, hex_string):
  function ToHex (line 177) | def ToHex(obj):
  class CAddress (line 182) | class CAddress():
    method __init__ (line 183) | def __init__(self):
    method deserialize (line 189) | def deserialize(self, f):
    method serialize (line 195) | def serialize(self):
    method __repr__ (line 203) | def __repr__(self):
  class CInv (line 209) | class CInv():
    method __init__ (line 219) | def __init__(self, t=0, h=0):
    method deserialize (line 223) | def deserialize(self, f):
    method serialize (line 227) | def serialize(self):
    method __repr__ (line 233) | def __repr__(self):
  class CBlockLocator (line 238) | class CBlockLocator():
    method __init__ (line 239) | def __init__(self):
    method deserialize (line 243) | def deserialize(self, f):
    method serialize (line 247) | def serialize(self):
    method __repr__ (line 253) | def __repr__(self):
  class COutPoint (line 258) | class COutPoint():
    method __init__ (line 259) | def __init__(self, hash=0, n=0):
    method deserialize (line 263) | def deserialize(self, f):
    method serialize (line 267) | def serialize(self):
    method __repr__ (line 273) | def __repr__(self):
  class CTxIn (line 277) | class CTxIn():
    method __init__ (line 278) | def __init__(self, outpoint=None, scriptSig=b"", nSequence=0):
    method deserialize (line 286) | def deserialize(self, f):
    method serialize (line 292) | def serialize(self):
    method __repr__ (line 299) | def __repr__(self):
  class CTxOut (line 305) | class CTxOut():
    method __init__ (line 306) | def __init__(self, nValue=0, scriptPubKey=b""):
    method deserialize (line 310) | def deserialize(self, f):
    method serialize (line 314) | def serialize(self):
    method __repr__ (line 320) | def __repr__(self):
  class CScriptWitness (line 326) | class CScriptWitness():
    method __init__ (line 327) | def __init__(self):
    method __repr__ (line 331) | def __repr__(self):
    method is_null (line 335) | def is_null(self):
  class CTxInWitness (line 341) | class CTxInWitness():
    method __init__ (line 342) | def __init__(self):
    method deserialize (line 345) | def deserialize(self, f):
    method serialize (line 348) | def serialize(self):
    method __repr__ (line 351) | def __repr__(self):
    method is_null (line 354) | def is_null(self):
  class CTxWitness (line 358) | class CTxWitness():
    method __init__ (line 359) | def __init__(self):
    method deserialize (line 362) | def deserialize(self, f):
    method serialize (line 366) | def serialize(self):
    method __repr__ (line 375) | def __repr__(self):
    method is_null (line 379) | def is_null(self):
  class CTransaction (line 386) | class CTransaction():
    method __init__ (line 387) | def __init__(self, tx=None):
    method deserialize (line 405) | def deserialize(self, f):
    method serialize_without_witness (line 425) | def serialize_without_witness(self):
    method serialize_with_witness (line 434) | def serialize_with_witness(self):
    method serialize (line 458) | def serialize(self):
    method rehash (line 462) | def rehash(self):
    method calc_sha256 (line 468) | def calc_sha256(self, with_witness=False):
    method is_valid (line 477) | def is_valid(self):
    method __repr__ (line 484) | def __repr__(self):
  class CBlockHeader (line 489) | class CBlockHeader():
    method __init__ (line 490) | def __init__(self, header=None):
    method set_null (line 504) | def set_null(self):
    method deserialize (line 514) | def deserialize(self, f):
    method serialize (line 524) | def serialize(self):
    method calc_sha256 (line 534) | def calc_sha256(self):
    method rehash (line 546) | def rehash(self):
    method __repr__ (line 551) | def __repr__(self):
  class CBlock (line 557) | class CBlock(CBlockHeader):
    method __init__ (line 558) | def __init__(self, header=None):
    method deserialize (line 562) | def deserialize(self, f):
    method serialize (line 566) | def serialize(self, with_witness=False):
    method get_merkle_root (line 577) | def get_merkle_root(cls, hashes):
    method calc_merkle_root (line 586) | def calc_merkle_root(self):
    method calc_witness_merkle_root (line 593) | def calc_witness_merkle_root(self):
    method is_valid (line 604) | def is_valid(self):
    method solve (line 616) | def solve(self):
    method __repr__ (line 623) | def __repr__(self):
  class PrefilledTransaction (line 629) | class PrefilledTransaction():
    method __init__ (line 630) | def __init__(self, index=0, tx = None):
    method deserialize (line 634) | def deserialize(self, f):
    method serialize (line 639) | def serialize(self, with_witness=True):
    method serialize_without_witness (line 648) | def serialize_without_witness(self):
    method serialize_with_witness (line 651) | def serialize_with_witness(self):
    method __repr__ (line 654) | def __repr__(self):
  class P2PHeaderAndShortIDs (line 658) | class P2PHeaderAndShortIDs():
    method __init__ (line 659) | def __init__(self):
    method deserialize (line 667) | def deserialize(self, f):
    method serialize (line 679) | def serialize(self, with_witness=False):
    method __repr__ (line 693) | def __repr__(self):
  class P2PHeaderAndShortWitnessIDs (line 698) | class P2PHeaderAndShortWitnessIDs(P2PHeaderAndShortIDs):
    method serialize (line 699) | def serialize(self):
  function calculate_shortid (line 703) | def calculate_shortid(k0, k1, tx_hash):
  class HeaderAndShortIDs (line 710) | class HeaderAndShortIDs():
    method __init__ (line 711) | def __init__(self, p2pheaders_and_shortids = None):
    method to_p2p (line 727) | def to_p2p(self):
    method get_siphash_keys (line 744) | def get_siphash_keys(self):
    method initialize_from_block (line 753) | def initialize_from_block(self, block, nonce=0, prefill_list = [0], us...
    method __repr__ (line 767) | def __repr__(self):
  class BlockTransactionsRequest (line 771) | class BlockTransactionsRequest():
    method __init__ (line 773) | def __init__(self, blockhash=0, indexes = None):
    method deserialize (line 777) | def deserialize(self, f):
    method serialize (line 783) | def serialize(self):
    method from_absolute (line 792) | def from_absolute(self, absolute_indexes):
    method to_absolute (line 799) | def to_absolute(self):
    method __repr__ (line 807) | def __repr__(self):
  class BlockTransactions (line 811) | class BlockTransactions():
    method __init__ (line 813) | def __init__(self, blockhash=0, transactions = None):
    method deserialize (line 817) | def deserialize(self, f):
    method serialize (line 821) | def serialize(self, with_witness=True):
    method __repr__ (line 830) | def __repr__(self):
  class CPartialMerkleTree (line 833) | class CPartialMerkleTree():
    method __init__ (line 834) | def __init__(self):
    method deserialize (line 840) | def deserialize(self, f):
    method serialize (line 848) | def serialize(self):
    method __repr__ (line 858) | def __repr__(self):
  class CMerkleBlock (line 861) | class CMerkleBlock():
    method __init__ (line 862) | def __init__(self):
    method deserialize (line 866) | def deserialize(self, f):
    method serialize (line 870) | def serialize(self):
    method __repr__ (line 876) | def __repr__(self):
  class msg_version (line 881) | class msg_version():
    method __init__ (line 884) | def __init__(self):
    method deserialize (line 895) | def deserialize(self, f):
    method serialize (line 929) | def serialize(self):
    method __repr__ (line 942) | def __repr__(self):
  class msg_verack (line 949) | class msg_verack():
    method __init__ (line 952) | def __init__(self):
    method deserialize (line 955) | def deserialize(self, f):
    method serialize (line 958) | def serialize(self):
    method __repr__ (line 961) | def __repr__(self):
  class msg_addr (line 965) | class msg_addr():
    method __init__ (line 968) | def __init__(self):
    method deserialize (line 971) | def deserialize(self, f):
    method serialize (line 974) | def serialize(self):
    method __repr__ (line 977) | def __repr__(self):
  class msg_inv (line 981) | class msg_inv():
    method __init__ (line 984) | def __init__(self, inv=None):
    method deserialize (line 990) | def deserialize(self, f):
    method serialize (line 993) | def serialize(self):
    method __repr__ (line 996) | def __repr__(self):
  class msg_getdata (line 1000) | class msg_getdata():
    method __init__ (line 1003) | def __init__(self, inv=None):
    method deserialize (line 1006) | def deserialize(self, f):
    method serialize (line 1009) | def serialize(self):
    method __repr__ (line 1012) | def __repr__(self):
  class msg_getblocks (line 1016) | class msg_getblocks():
    method __init__ (line 1019) | def __init__(self):
    method deserialize (line 1023) | def deserialize(self, f):
    method serialize (line 1028) | def serialize(self):
    method __repr__ (line 1034) | def __repr__(self):
  class msg_tx (line 1039) | class msg_tx():
    method __init__ (line 1042) | def __init__(self, tx=CTransaction()):
    method deserialize (line 1045) | def deserialize(self, f):
    method serialize (line 1048) | def serialize(self):
    method __repr__ (line 1051) | def __repr__(self):
  class msg_witness_tx (line 1054) | class msg_witness_tx(msg_tx):
    method serialize (line 1056) | def serialize(self):
  class msg_block (line 1060) | class msg_block():
    method __init__ (line 1063) | def __init__(self, block=None):
    method deserialize (line 1069) | def deserialize(self, f):
    method serialize (line 1072) | def serialize(self):
    method __repr__ (line 1075) | def __repr__(self):
  class msg_generic (line 1080) | class msg_generic():
    method __init__ (line 1081) | def __init__(self, command, data=None):
    method serialize (line 1085) | def serialize(self):
    method __repr__ (line 1088) | def __repr__(self):
  class msg_witness_block (line 1091) | class msg_witness_block(msg_block):
    method serialize (line 1093) | def serialize(self):
  class msg_getaddr (line 1097) | class msg_getaddr():
    method __init__ (line 1100) | def __init__(self):
    method deserialize (line 1103) | def deserialize(self, f):
    method serialize (line 1106) | def serialize(self):
    method __repr__ (line 1109) | def __repr__(self):
  class msg_ping (line 1113) | class msg_ping():
    method __init__ (line 1116) | def __init__(self, nonce=0):
    method deserialize (line 1119) | def deserialize(self, f):
    method serialize (line 1122) | def serialize(self):
    method __repr__ (line 1127) | def __repr__(self):
  class msg_pong (line 1131) | class msg_pong():
    method __init__ (line 1134) | def __init__(self, nonce=0):
    method deserialize (line 1137) | def deserialize(self, f):
    method serialize (line 1140) | def serialize(self):
    method __repr__ (line 1145) | def __repr__(self):
  class msg_mempool (line 1149) | class msg_mempool():
    method __init__ (line 1152) | def __init__(self):
    method deserialize (line 1155) | def deserialize(self, f):
    method serialize (line 1158) | def serialize(self):
    method __repr__ (line 1161) | def __repr__(self):
  class msg_sendheaders (line 1164) | class msg_sendheaders():
    method __init__ (line 1167) | def __init__(self):
    method deserialize (line 1170) | def deserialize(self, f):
    method serialize (line 1173) | def serialize(self):
    method __repr__ (line 1176) | def __repr__(self):
  class msg_getheaders (line 1184) | class msg_getheaders():
    method __init__ (line 1187) | def __init__(self):
    method deserialize (line 1191) | def deserialize(self, f):
    method serialize (line 1196) | def serialize(self):
    method __repr__ (line 1202) | def __repr__(self):
  class msg_headers (line 1209) | class msg_headers():
    method __init__ (line 1212) | def __init__(self, headers=None):
    method deserialize (line 1215) | def deserialize(self, f):
    method serialize (line 1221) | def serialize(self):
    method __repr__ (line 1225) | def __repr__(self):
  class msg_reject (line 1229) | class msg_reject():
    method __init__ (line 1233) | def __init__(self):
    method deserialize (line 1239) | def deserialize(self, f):
    method serialize (line 1247) | def serialize(self):
    method __repr__ (line 1256) | def __repr__(self):
  class msg_feefilter (line 1260) | class msg_feefilter():
    method __init__ (line 1263) | def __init__(self, feerate=0):
    method deserialize (line 1266) | def deserialize(self, f):
    method serialize (line 1269) | def serialize(self):
    method __repr__ (line 1274) | def __repr__(self):
  class msg_sendcmpct (line 1277) | class msg_sendcmpct():
    method __init__ (line 1280) | def __init__(self):
    method deserialize (line 1284) | def deserialize(self, f):
    method serialize (line 1288) | def serialize(self):
    method __repr__ (line 1294) | def __repr__(self):
  class msg_cmpctblock (line 1297) | class msg_cmpctblock():
    method __init__ (line 1300) | def __init__(self, header_and_shortids = None):
    method deserialize (line 1303) | def deserialize(self, f):
    method serialize (line 1307) | def serialize(self):
    method __repr__ (line 1312) | def __repr__(self):
  class msg_getblocktxn (line 1315) | class msg_getblocktxn():
    method __init__ (line 1318) | def __init__(self):
    method deserialize (line 1321) | def deserialize(self, f):
    method serialize (line 1325) | def serialize(self):
    method __repr__ (line 1330) | def __repr__(self):
  class msg_blocktxn (line 1333) | class msg_blocktxn():
    method __init__ (line 1336) | def __init__(self):
    method deserialize (line 1339) | def deserialize(self, f):
    method serialize (line 1342) | def serialize(self):
    method __repr__ (line 1347) | def __repr__(self):
  class msg_witness_blocktxn (line 1350) | class msg_witness_blocktxn(msg_blocktxn):
    method serialize (line 1351) | def serialize(self):

FILE: test/functional/test_framework/mininode.py
  class P2PConnection (line 58) | class P2PConnection(asyncore.dispatcher):
    method __init__ (line 71) | def __init__(self):
    method peer_connect (line 78) | def peer_connect(self, dstaddr, dstport, net="regtest"):
    method peer_disconnect (line 96) | def peer_disconnect(self):
    method handle_connect (line 103) | def handle_connect(self):
    method handle_close (line 110) | def handle_close(self):
    method disconnect_node (line 122) | def disconnect_node(self):
    method handle_read (line 131) | def handle_read(self):
    method _on_data (line 138) | def _on_data(self):
    method on_message (line 174) | def on_message(self, message):
    method writable (line 180) | def writable(self):
    method handle_write (line 187) | def handle_write(self):
    method send_message (line 205) | def send_message(self, message, pushbuf=False):
    method _log_message (line 235) | def _log_message(self, direction, msg):
  class P2PInterface (line 247) | class P2PInterface(P2PConnection):
    method __init__ (line 256) | def __init__(self):
    method peer_connect (line 270) | def peer_connect(self, *args, services=NODE_NETWORK|NODE_WITNESS, send...
    method on_message (line 285) | def on_message(self, message):
    method on_open (line 303) | def on_open(self):
    method on_close (line 306) | def on_close(self):
    method on_addr (line 309) | def on_addr(self, message): pass
    method on_block (line 310) | def on_block(self, message): pass
    method on_blocktxn (line 311) | def on_blocktxn(self, message): pass
    method on_cmpctblock (line 312) | def on_cmpctblock(self, message): pass
    method on_feefilter (line 313) | def on_feefilter(self, message): pass
    method on_getaddr (line 314) | def on_getaddr(self, message): pass
    method on_getblocks (line 315) | def on_getblocks(self, message): pass
    method on_getblocktxn (line 316) | def on_getblocktxn(self, message): pass
    method on_getdata (line 317) | def on_getdata(self, message): pass
    method on_getheaders (line 318) | def on_getheaders(self, message): pass
    method on_headers (line 319) | def on_headers(self, message): pass
    method on_mempool (line 320) | def on_mempool(self, message): pass
    method on_pong (line 321) | def on_pong(self, message): pass
    method on_reject (line 322) | def on_reject(self, message): pass
    method on_sendcmpct (line 323) | def on_sendcmpct(self, message): pass
    method on_sendheaders (line 324) | def on_sendheaders(self, message): pass
    method on_tx (line 325) | def on_tx(self, message): pass
    method on_inv (line 327) | def on_inv(self, message):
    method on_ping (line 335) | def on_ping(self, message):
    method on_verack (line 338) | def on_verack(self, message):
    method on_version (line 341) | def on_version(self, message):
    method wait_for_disconnect (line 348) | def wait_for_disconnect(self, timeout=60):
    method wait_for_block (line 354) | def wait_for_block(self, blockhash, timeout=60):
    method wait_for_getdata (line 358) | def wait_for_getdata(self, timeout=60):
    method wait_for_getheaders (line 362) | def wait_for_getheaders(self, timeout=60):
    method wait_for_inv (line 366) | def wait_for_inv(self, expected_inv, timeout=60):
    method wait_for_verack (line 375) | def wait_for_verack(self, timeout=60):
    method send_and_ping (line 381) | def send_and_ping(self, message):
    method sync_with_ping (line 386) | def sync_with_ping(self, timeout=60):
  class NetworkThread (line 406) | class NetworkThread(threading.Thread):
    method __init__ (line 407) | def __init__(self):
    method run (line 410) | def run(self):
  function network_thread_start (line 423) | def network_thread_start():
  function network_thread_running (line 430) | def network_thread_running():
  function network_thread_join (line 434) | def network_thread_join(timeout=10):

FILE: test/functional/test_framework/netutil.py
  function get_socket_inodes (line 30) | def get_socket_inodes(pid):
  function _remove_empty (line 42) | def _remove_empty(array):
  function _convert_ip_port (line 45) | def _convert_ip_port(array):
  function netstat (line 56) | def netstat(typ='tcp'):
  function get_bind_addrs (line 77) | def get_bind_addrs(pid):
  function all_interfaces (line 89) | def all_interfaces():
  function addr_to_hex (line 114) | def addr_to_hex(addr):
  function test_ipv6_local (line 143) | def test_ipv6_local():

FILE: test/functional/test_framework/script.py
  function hash160 (line 30) | def hash160(s):
  class CScriptOp (line 35) | class CScriptOp(int):
    method encode_op_pushdata (line 40) | def encode_op_pushdata(d):
    method encode_op_n (line 54) | def encode_op_n(n):
    method decode_op_n (line 64) | def decode_op_n(self):
    method is_small_int (line 74) | def is_small_int(self):
    method __str__ (line 81) | def __str__(self):
    method __repr__ (line 84) | def __repr__(self):
    method __new__ (line 90) | def __new__(cls, n):
  class CScriptInvalidError (line 362) | class CScriptInvalidError(Exception):
  class CScriptTruncatedPushDataError (line 366) | class CScriptTruncatedPushDataError(CScriptInvalidError):
    method __init__ (line 368) | def __init__(self, msg, data):
  class CScriptNum (line 373) | class CScriptNum():
    method __init__ (line 374) | def __init__(self, d=0):
    method encode (line 378) | def encode(obj):
  class CScript (line 394) | class CScript(bytes):
    method __coerce_instance (line 405) | def __coerce_instance(cls, other):
    method __add__ (line 425) | def __add__(self, other):
    method join (line 436) | def join(self, iterable):
    method __new__ (line 440) | def __new__(cls, value=b''):
    method raw_iter (line 451) | def raw_iter(self):
    method __iter__ (line 508) | def __iter__(self):
    method __repr__ (line 528) | def __repr__(self):
    method GetSigOpCount (line 555) | def GetSigOpCount(self, fAccurate):
  function FindAndDelete (line 581) | def FindAndDelete(script, sig):
  function SignatureHash (line 599) | def SignatureHash(script, txTo, inIdx, hashtype):
  function SegwitVersion1SignatureHash (line 653) | def SegwitVersion1SignatureHash(script, txTo, inIdx, hashtype, amount):

FILE: test/functional/test_framework/segwit_addr.py
  function bech32_polymod (line 11) | def bech32_polymod(values):
  function bech32_hrp_expand (line 23) | def bech32_hrp_expand(hrp):
  function bech32_verify_checksum (line 28) | def bech32_verify_checksum(hrp, data):
  function bech32_create_checksum (line 33) | def bech32_create_checksum(hrp, data):
  function bech32_encode (line 40) | def bech32_encode(hrp, data):
  function bech32_decode (line 46) | def bech32_decode(bech):
  function convertbits (line 64) | def convertbits(data, frombits, tobits, pad=True):
  function decode (line 87) | def decode(hrp, addr):
  function encode (line 102) | def encode(hrp, witver, witprog):

FILE: test/functional/test_framework/siphash.py
  function rotl64 (line 10) | def rotl64(n, b):
  function siphash_round (line 13) | def siphash_round(v0, v1, v2, v3):
  function siphash256 (line 30) | def siphash256(k0, k1, h):

FILE: test/functional/test_framework/socks5.py
  class Command (line 13) | class Command:
  class AddressType (line 16) | class AddressType:
  function recvall (line 22) | def recvall(s, n):
  class Socks5Configuration (line 34) | class Socks5Configuration():
    method __init__ (line 36) | def __init__(self):
  class Socks5Command (line 42) | class Socks5Command():
    method __init__ (line 44) | def __init__(self, cmd, atyp, addr, port, username, password):
    method __repr__ (line 51) | def __repr__(self):
  class Socks5Connection (line 54) | class Socks5Connection():
    method __init__ (line 55) | def __init__(self, serv, conn, peer):
    method handle (line 60) | def handle(self):
  class Socks5Server (line 125) | class Socks5Server():
    method __init__ (line 126) | def __init__(self, conf):
    method run (line 136) | def run(self):
    method start (line 145) | def start(self):
    method stop (line 152) | def stop(self):

FILE: test/functional/test_framework/test_framework.py
  class TestStatus (line 35) | class TestStatus(Enum):
  class BitcoinTestFramework (line 44) | class BitcoinTestFramework():
    method __init__ (line 60) | def __init__(self):
    method main (line 70) | def main(self):
    method set_test_params (line 172) | def set_test_params(self):
    method add_options (line 176) | def add_options(self, parser):
    method setup_chain (line 180) | def setup_chain(self):
    method setup_network (line 188) | def setup_network(self):
    method setup_nodes (line 199) | def setup_nodes(self):
    method run_test (line 207) | def run_test(self):
    method add_nodes (line 213) | def add_nodes(self, num_nodes, extra_args=None, rpchost=None, timewait...
    method start_node (line 225) | def start_node(self, i, *args, **kwargs):
    method start_nodes (line 236) | def start_nodes(self, extra_args=None, *args, **kwargs):
    method stop_node (line 256) | def stop_node(self, i):
    method stop_nodes (line 261) | def stop_nodes(self):
    method restart_node (line 271) | def restart_node(self, i, extra_args=None):
    method assert_start_raises_init_error (line 276) | def assert_start_raises_init_error(self, i, extra_args=None, expected_...
    method wait_for_node_exit (line 297) | def wait_for_node_exit(self, i, timeout):
    method split_network (line 300) | def split_network(self):
    method join_network (line 308) | def join_network(self):
    method sync_all (line 315) | def sync_all(self, node_groups=None):
    method enable_mocktime (line 323) | def enable_mocktime(self):
    method disable_mocktime (line 335) | def disable_mocktime(self):
    method _start_logging (line 340) | def _start_logging(self):
    method _initialize_chain (line 368) | def _initialize_chain(self):
    method _initialize_chain_clean (line 440) | def _initialize_chain_clean(self):
  class ComparisonTestFramework (line 448) | class ComparisonTestFramework(BitcoinTestFramework):
    method set_test_params (line 456) | def set_test_params(self):
    method add_options (line 460) | def add_options(self, parser):
    method setup_network (line 468) | def setup_network(self):
  class SkipTest (line 477) | class SkipTest(Exception):
    method __init__ (line 479) | def __init__(self, message):

FILE: test/functional/test_framework/test_node.py
  class TestNode (line 32) | class TestNode():
    method __init__ (line 46) | def __init__(self, i, dirname, extra_args, rpchost, timewait, binary, ...
    method __del__ (line 78) | def __del__(self):
    method __getattr__ (line 88) | def __getattr__(self, name):
    method start (line 96) | def start(self, extra_args=None, stderr=None, *args, **kwargs):
    method wait_for_rpc_connection (line 110) | def wait_for_rpc_connection(self):
    method get_wallet_rpc (line 136) | def get_wallet_rpc(self, wallet_name):
    method stop_node (line 145) | def stop_node(self):
    method is_node_stopped (line 156) | def is_node_stopped(self):
    method wait_until_stopped (line 176) | def wait_until_stopped(self, timeout=BITCOIND_PROC_WAIT_TIMEOUT):
    method node_encrypt_wallet (line 179) | def node_encrypt_wallet(self, passphrase):
    method add_p2p_connection (line 187) | def add_p2p_connection(self, p2p_conn, *args, **kwargs):
    method p2p (line 203) | def p2p(self):
    method disconnect_p2ps (line 211) | def disconnect_p2ps(self):
  class TestNodeCLIAttr (line 217) | class TestNodeCLIAttr:
    method __init__ (line 218) | def __init__(self, cli, command):
    method __call__ (line 222) | def __call__(self, *args, **kwargs):
    method get_request (line 225) | def get_request(self, *args, **kwargs):
  class TestNodeCLI (line 228) | class TestNodeCLI():
    method __init__ (line 231) | def __init__(self, binary, datadir):
    method __call__ (line 238) | def __call__(self, *options, input=None):
    method __getattr__ (line 245) | def __getattr__(self, command):
    method batch (line 248) | def batch(self, requests):
    method send_cli (line 257) | def send_cli(self, command=None, *args, **kwargs):

FILE: test/functional/test_framework/util.py
  function assert_fee_amount (line 27) | def assert_fee_amount(fee, tx_size, fee_per_kB):
  function assert_equal (line 36) | def assert_equal(thing1, thing2, *args):
  function assert_greater_than (line 40) | def assert_greater_than(thing1, thing2):
  function assert_greater_than_or_equal (line 44) | def assert_greater_than_or_equal(thing1, thing2):
  function assert_raises (line 48) | def assert_raises(exc, fun, *args, **kwds):
  function assert_raises_message (line 51) | def assert_raises_message(exc, message, fun, *args, **kwds):
  function assert_raises_process_error (line 64) | def assert_raises_process_error(returncode, output, fun, *args, **kwds):
  function assert_raises_rpc_error (line 88) | def assert_raises_rpc_error(code, message, fun, *args, **kwds):
  function try_rpc (line 106) | def try_rpc(code, message, fun, *args, **kwds):
  function assert_is_hex_string (line 125) | def assert_is_hex_string(string):
  function assert_is_hash_string (line 132) | def assert_is_hash_string(string, length=64):
  function assert_array_result (line 142) | def assert_array_result(object_array, to_match, expected, should_not_fin...
  function check_json_precision (line 174) | def check_json_precision():
  function count_bytes (line 181) | def count_bytes(hex_string):
  function bytes_to_hex_str (line 184) | def bytes_to_hex_str(byte_str):
  function hash256 (line 187) | def hash256(byte_str):
  function hex_str_to_bytes (line 194) | def hex_str_to_bytes(hex_str):
  function str_to_b64str (line 197) | def str_to_b64str(string):
  function satoshi_round (line 200) | def satoshi_round(amount):
  function wait_until (line 203) | def wait_until(predicate, *, attempts=float('inf'), timeout=float('inf')...
  class PortSeed (line 235) | class PortSeed:
  function get_rpc_proxy (line 239) | def get_rpc_proxy(url, node_number, timeout=None, coveragedir=None):
  function p2p_port (line 264) | def p2p_port(n):
  function rpc_port (line 268) | def rpc_port(n):
  function rpc_url (line 271) | def rpc_url(datadir, i, rpchost=None):
  function initialize_datadir (line 286) | def initialize_datadir(dirname, n):
  function get_datadir_path (line 297) | def get_datadir_path(dirname, n):
  function get_auth_cookie (line 300) | def get_auth_cookie(datadir):
  function delete_cookie_file (line 323) | def delete_cookie_file(datadir):
  function get_bip9_status (line 328) | def get_bip9_status(node, key):
  function set_node_times (line 332) | def set_node_times(nodes, t):
  function disconnect_nodes (line 336) | def disconnect_nodes(from_connection, node_num):
  function connect_nodes (line 350) | def connect_nodes(from_connection, node_num):
  function connect_nodes_bi (line 357) | def connect_nodes_bi(nodes, a, b):
  function sync_blocks (line 361) | def sync_blocks(rpc_connections, *, wait=1, timeout=60):
  function sync_chain (line 386) | def sync_chain(rpc_connections, *, wait=1, timeout=60):
  function sync_mempools (line 398) | def sync_mempools(rpc_connections, *, wait=1, timeout=60, flush_schedule...
  function find_output (line 421) | def find_output(node, txid, amount):
  function gather_inputs (line 432) | def gather_inputs(from_node, amount_needed, confirmations_required=1):
  function make_change (line 449) | def make_change(from_node, amount_in, amount_out, fee):
  function random_transaction (line 466) | def random_transaction(nodes, amount, min_fee, fee_increment, fee_varian...
  function create_confirmed_utxos (line 487) | def create_confirmed_utxos(fee, node, count):
  function gen_return_txouts (line 519) | def gen_return_txouts():
  function create_tx (line 537) | def create_tx(node, coinbase, to_address, amount):
  function create_lots_of_big_transactions (line 547) | def create_lots_of_big_transactions(node, txouts, utxos, num, fee):
  function mine_large_block (line 565) | def mine_large_block(node, utxos=None):

FILE: test/functional/test_runner.py
  function main (line 179) | def main():
  function run_tests (line 283) | def run_tests(test_list, src_dir, build_dir, exeext, tmpdir, jobs=1, ena...
  function print_results (line 365) | def print_results(test_results, max_len_name, runtime):
  class TestHandler (line 383) | class TestHandler:
    method __init__ (line 388) | def __init__(self, num_tests_parallel, tests_dir, tmpdir, test_list=No...
    method get_next (line 402) | def get_next(self):
  class TestResult (line 450) | class TestResult():
    method __init__ (line 451) | def __init__(self, name, status, time):
    method __repr__ (line 457) | def __repr__(self):
    method was_successful (line 471) | def was_successful(self):
  function check_script_prefixes (line 475) | def check_script_prefixes():
  function check_script_list (line 493) | def check_script_list(src_dir):
  class RPCCoverage (line 507) | class RPCCoverage():
    method __init__ (line 522) | def __init__(self):
    method report_rpc_coverage (line 526) | def report_rpc_coverage(self):
    method cleanup (line 539) | def cleanup(self):
    method _get_uncovered_rpc_commands (line 542) | def _get_uncovered_rpc_commands(self):

FILE: test/functional/wallet_abandonconflict.py
  class AbandonConflictTest (line 16) | class AbandonConflictTest(BitcoinTestFramework):
    method set_test_params (line 17) | def set_test_params(self):
    method run_test (line 21) | def run_test(self):

FILE: test/functional/wallet_accounts.py
  class WalletAccountsTest (line 19) | class WalletAccountsTest(BitcoinTestFramework):
    method set_test_params (line 20) | def set_test_params(self):
    method run_test (line 25) | def run_test(self):
  class Account (line 155) | class Account:
    method __init__ (line 156) | def __init__(self, name):
    method add_address (line 164) | def add_address(self, address):
    method add_receive_address (line 168) | def add_receive_address(self, address):
    method verify (line 172) | def verify(self, node):
  function change_account (line 184) | def change_account(node, address, old_account, new_account):

FILE: test/functional/wallet_address_types.py
  class AddressTypeTest (line 66) | class AddressTypeTest(BitcoinTestFramework):
    method set_test_params (line 67) | def set_test_params(self):
    method setup_network (line 78) | def setup_network(self):
    method get_balances (line 87) | def get_balances(self, confirmed=True):
    method test_address (line 94) | def test_address(self, node, address, multisig, typ):
    method test_change_output_type (line 145) | def test_change_output_type(self, node_sender, destinations, expected_...
    method run_test (line 161) | def run_test(self):

FILE: test/functional/wallet_backup.py
  class WalletBackupTest (line 39) | class WalletBackupTest(BitcoinTestFramework):
    method set_test_params (line 40) | def set_test_params(self):
    method setup_network (line 46) | def setup_network(self, split=False):
    method one_send (line 54) | def one_send(self, from_node, to_address):
    method do_one_round (line 59) | def do_one_round(self):
    method start_three (line 78) | def start_three(self):
    method stop_three (line 87) | def stop_three(self):
    method erase_three (line 92) | def erase_three(self):
    method run_test (line 97) | def run_test(self):

FILE: test/functional/wallet_basic.py
  class WalletTest (line 9) | class WalletTest(BitcoinTestFramework):
    method set_test_params (line 10) | def set_test_params(self):
    method setup_network (line 14) | def setup_network(self):
    method check_fee_amount (line 24) | def check_fee_amount(self, curr_balance, balance_with_fee, fee_per_byt...
    method get_vsize (line 30) | def get_vsize(self, txn):
    method run_test (line 33) | def run_test(self):

FILE: test/functional/wallet_bumpfee.py
  class BumpFeeTest (line 32) | class BumpFeeTest(BitcoinTestFramework):
    method set_test_params (line 33) | def set_test_params(self):
    method run_test (line 39) | def run_test(self):
  function test_simple_bumpfee_succeeds (line 80) | def test_simple_bumpfee_succeeds(rbf_node, peer_node, dest_address):
  function test_segwit_bumpfee_succeeds (line 102) | def test_segwit_bumpfee_succeeds(rbf_node, dest_address):
  function test_nonrbf_bumpfee_fails (line 133) | def test_nonrbf_bumpfee_fails(peer_node, dest_address):
  function test_notmine_bumpfee_fails (line 139) | def test_notmine_bumpfee_fails(rbf_node, peer_node, dest_address):
  function test_bumpfee_with_descendant_fails (line 160) | def test_bumpfee_with_descendant_fails(rbf_node, rbf_node_address, dest_...
  function test_small_output_fails (line 170) | def test_small_output_fails(rbf_node, dest_address):
  function test_dust_to_fee (line 179) | def test_dust_to_fee(rbf_node, dest_address):
  function test_settxfee (line 191) | def test_settxfee(rbf_node, dest_address):
  function test_rebumping (line 204) | def test_rebumping(rbf_node, dest_address):
  function test_rebumping_not_replaceable (line 212) | def test_rebumping_not_replaceable(rbf_node, dest_address):
  function test_unconfirmed_not_spendable (line 220) | def test_unconfirmed_not_spendable(rbf_node, rbf_node_address):
  function test_bumpfee_metadata (line 256) | def test_bumpfee_metadata(rbf_node, dest_address):
  function test_locked_wallet_fails (line 264) | def test_locked_wallet_fails(rbf_node, dest_address):
  function spend_one_input (line 271) | def spend_one_input(node, dest_address):
  function submit_block_with_tx (line 282) | def submit_block_with_tx(node, tx):

FILE: test/functional/wallet_disable.py
  class DisableWalletTest (line 14) | class DisableWalletTest (BitcoinTestFramework):
    method set_test_params (line 15) | def set_test_params(self):
    method run_test (line 20) | def run_test (self):

FILE: test/functional/wallet_dump.py
  function read_dump (line 13) | def read_dump(file_name, addrs, script_addrs, hd_master_addr_old):
  class WalletDumpTest (line 77) | class WalletDumpTest(BitcoinTestFramework):
    method set_test_params (line 78) | def set_test_params(self):
    method setup_network (line 82) | def setup_network(self, split=False):
    method run_test (line 90) | def run_test (self):

FILE: test/functional/wallet_encryption.py
  class WalletEncryptionTest (line 17) | class WalletEncryptionTest(BitcoinTestFramework):
    method set_test_params (line 18) | def set_test_params(self):
    method run_test (line 22) | def run_test(self):

FILE: test/functional/wallet_hd.py
  class WalletHDTest (line 15) | class WalletHDTest(BitcoinTestFramework):
    method set_test_params (line 16) | def set_test_params(self):
    method run_test (line 21) | def run_test (self):

FILE: test/functional/wallet_import_rescan.py
  class Variant (line 34) | class Variant(collections.namedtuple("Variant", "call data rescan prune")):
    method try_rpc (line 37) | def try_rpc(self, func, *args, **kwargs):
    method do_import (line 43) | def do_import(self, timestamp):
    method check (line 70) | def check(self, txid=None, amount=None, confirmations=None):
  class ImportRescanTest (line 117) | class ImportRescanTest(BitcoinTestFramework):
    method set_test_params (line 118) | def set_test_params(self):
    method setup_network (line 121) | def setup_network(self):
    method run_test (line 132) | def run_test(self):

FILE: test/functional/wallet_importmulti.py
  class ImportMultiTest (line 9) | class ImportMultiTest (BitcoinTestFramework):
    method set_test_params (line 10) | def set_test_params(self):
    method setup_network (line 15) | def setup_network(self):
    method run_test (line 18) | def run_test (self):

FILE: test/functional/wallet_importprunedfunds.py
  class ImportPrunedFundsTest (line 9) | class ImportPrunedFundsTest(BitcoinTestFramework):
    method set_test_params (line 10) | def set_test_params(self):
    method run_test (line 14) | def run_test(self):

FILE: test/functional/wallet_keypool.py
  class KeyPoolTest (line 10) | class KeyPoolTest(BitcoinTestFramework):
    method set_test_params (line 11) | def set_test_params(self):
    method run_test (line 14) | def run_test(self):

FILE: test/functional/wallet_keypool_topup.py
  class KeypoolRestoreTest (line 22) | class KeypoolRestoreTest(BitcoinTestFramework):
    method set_test_params (line 23) | def set_test_params(self):
    method run_test (line 28) | def run_test(self):

FILE: test/functional/wallet_listreceivedby.py
  class ReceivedByTest (line 17) | class ReceivedByTest(BitcoinTestFramework):
    method set_test_params (line 18) | def set_test_params(self):
    method run_test (line 21) | def run_test(self):

FILE: test/functional/wallet_listsinceblock.py
  class ListSinceBlockTest (line 10) | class ListSinceBlockTest (BitcoinTestFramework):
    method set_test_params (line 11) | def set_test_params(self):
    method run_test (line 15) | def run_test(self):
    method test_no_blockhash (line 25) | def test_no_blockhash(self):
    method test_invalid_blockhash (line 48) | def test_invalid_blockhash(self):
    method test_reorg (line 56) | def test_reorg(self):
    method test_double_spend (line 109) | def test_double_spend(self):
    method test_double_send (line 192) | def test_double_send(self):

FILE: test/functional/wallet_multiwallet.py
  class MultiWalletTest (line 15) | class MultiWalletTest(BitcoinTestFramework):
    method set_test_params (line 16) | def set_test_params(self):
    method run_test (line 22) | def run_test(self):

FILE: test/functional/wallet_resendwallettransactions.py
  class ResendWalletTransactionsTest (line 10) | class ResendWalletTransactionsTest(BitcoinTestFramework):
    method set_test_params (line 11) | def set_test_params(self):
    method run_test (line 15) | def run_test(self):

FILE: test/functional/wallet_txn_clone.py
  class TxnMallTest (line 10) | class TxnMallTest(BitcoinTestFramework):
    method set_test_params (line 11) | def set_test_params(self):
    method add_options (line 14) | def add_options(self, parser):
    method setup_network (line 20) | def setup_network(self):
    method run_test (line 26) | def run_test(self):

FILE: test/functional/wallet_txn_doublespend.py
  class TxnMallTest (line 10) | class TxnMallTest(BitcoinTestFramework):
    method set_test_params (line 11) | def set_test_params(self):
    method add_options (line 14) | def add_options(self, parser):
    method setup_network (line 18) | def setup_network(self):
    method run_test (line 24) | def run_test(self):

FILE: test/functional/wallet_zapwallettxes.py
  class ZapWalletTXesTest (line 24) | class ZapWalletTXesTest (BitcoinTestFramework):
    method set_test_params (line 25) | def set_test_params(self):
    method run_test (line 29) | def run_test(self):

FILE: test/util/bitcoin-util-test.py
  function main (line 28) | def main():
  function bctester (line 49) | def bctester(testDir, input_basename, buildenv):
  function bctest (line 73) | def bctest(testDir, testObj, buildenv):
  function parse_output (line 168) | def parse_output(a, fmt):