bdecode_node()

bdecode_node () = default;

creates a default constructed node, it will have the type none_t.

operator=() bdecode_node()

bdecode_node& operator= (bdecode_node const&) &;
bdecode_node& operator= (bdecode_node&&) & = default;
bdecode_node (bdecode_node const&);
bdecode_node (bdecode_node&&) noexcept;

For owning nodes, the copy will create a copy of the tree, but the underlying buffer remains the same.

type()

type_t type () const noexcept;

the type of this node. See type_t.

bool()

explicit operator bool () const noexcept;

returns true if type() != none_t.

non_owning()

bdecode_node non_owning () const;

return a non-owning reference to this node. This is useful to refer to the root node without copying it in assignments.

data_section() data_offset()

span<char const> data_section () const noexcept;
std::ptrdiff_t data_offset () const noexcept;

returns the buffer and length of the section in the original bencoded buffer where this node is defined. For a dictionary for instance, this starts with d and ends with e, and has all the content of the dictionary in between. the data_offset() function returns the byte-offset to this node in, starting from the beginning of the buffer that was parsed.

list_at() list_size() list_string_value_at() list_int_value_at()

std::int64_t list_int_value_at (int i
      , std::int64_t default_val = 0) const;
string_view list_string_value_at (int i
      , string_view default_val = string_view()) const;
int list_size () const;
bdecode_node list_at (int i) const;

functions with the list_ prefix operate on lists. These functions are only valid if type() == list_t. list_at() returns the item in the list at index i. i may not be greater than or equal to the size of the list. size() returns the size of the list.

dict_find_int_value() dict_find_int() dict_find() dict_at() dict_find_string_value() dict_find_dict() dict_find_list() dict_size() dict_at_node() dict_find_string()

string_view dict_find_string_value (string_view key
      , string_view default_value = string_view()) const;
std::int64_t dict_find_int_value (string_view key
      , std::int64_t default_val = 0) const;
int dict_size () const;
bdecode_node dict_find_dict (string_view key) const;
bdecode_node dict_find_int (string_view key) const;
bdecode_node dict_find (string_view key) const;
bdecode_node dict_find_string (string_view key) const;
std::pair<string_view, bdecode_node> dict_at (int i) const;
std::pair<bdecode_node, bdecode_node> dict_at_node (int i) const;
bdecode_node dict_find_list (string_view key) const;

Functions with the dict_ prefix operates on dictionaries. They are only valid if type() == dict_t. In case a key you're looking up contains a 0 byte, you cannot use the 0-terminated string overloads, but have to use string_view instead. dict_find_list will return a valid bdecode_node if the key is found _and_ it is a list. Otherwise it will return a default-constructed bdecode_node.

Functions with the _value suffix return the value of the node directly, rather than the nodes. In case the node is not found, or it has a different type, a default value is returned (which can be specified).

dict_at() returns the (key, value)-pair at the specified index in a dictionary. Keys are only allowed to be strings. dict_at_node() also returns the (key, value)-pair, but the key is returned as a bdecode_node (and it will always be a string).

int_value()

std::int64_t int_value () const;

this function is only valid if type() == int_t. It returns the value of the integer.

string_length() string_offset() string_ptr() string_value()

char const* string_ptr () const;
int string_length () const;
string_view string_value () const;
std::ptrdiff_t string_offset () const;

these functions are only valid if type() == string_t. They return the string values. Note that string_ptr() is not 0-terminated. string_length() returns the number of bytes in the string. string_offset() returns the byte offset from the start of the parsed bencoded buffer this string can be found.

clear()

void clear ();

resets the bdecoded_node to a default constructed state. If this is an owning node, the tree is freed and all child nodes are invalidated.

swap()

void swap (bdecode_node& n);

Swap contents.

reserve()

void reserve (int tokens);

preallocate memory for the specified numbers of tokens. This is useful if you know approximately how many tokens are in the file you are about to parse. Doing so will save realloc operations while parsing. You should only call this on the root node, before passing it in to bdecode().

switch_underlying_buffer()

void switch_underlying_buffer (char const* buf) noexcept;

this buffer MUST be identical to the one originally parsed. This operation is only defined on owning root nodes, i.e. the one passed in to decode().

has_soft_error()

bool has_soft_error (span<char> error) const;

returns true if there is a non-fatal error in the bencoding of this node or its children

enum type_t

Declared in "libtorrent/bdecode.hpp"